






import collections
import os
import re
from pathlib import Path


__lowercase										= "src/transformers"


# Matches is_xxx_available()
__lowercase										= re.compile(r'''is\_([a-z_]*)_available()''')
# Catches a one-line _import_struct = {xxx}
__lowercase										= re.compile(r'''^_import_structure\s+=\s+\{([^\}]+)\}''')
# Catches a line with a key-values pattern: "bla": ["foo", "bar"]
__lowercase										= re.compile(r'''\s+\"\S*\":\s+\[([^\]]*)\]''')
# Catches a line if not is_foo_available
__lowercase										= re.compile(r'''^\s*if\s+not\s+is\_[a-z_]*\_available\(\)''')
# Catches a line _import_struct["bla"].append("foo")
__lowercase										= re.compile(r'''^\s*_import_structure\[\"\S*\"\]\.append\(\"(\S*)\"\)''')
# Catches a line _import_struct["bla"].extend(["foo", "bar"]) or _import_struct["bla"] = ["foo", "bar"]
__lowercase										= re.compile(r'''^\s*_import_structure\[\S*\](?:\.extend\(|\s*=\s+)\[([^\]]*)\]''')
# Catches a line with an object between quotes and a comma:     "MyModel",
__lowercase										= re.compile(r'''^\s+\"([^\"]+)\",''')
# Catches a line with objects between brackets only:    ["foo", "bar"],
__lowercase										= re.compile(r'''^\s+\[([^\]]+)\]''')
# Catches a line with from foo import bar, bla, boo
__lowercase										= re.compile(r'''\s+from\s+\S*\s+import\s+([^\(\s].*)\n''')
# Catches a line with try:
__lowercase										= re.compile(r'''^\s*try:''')
# Catches a line with else:
__lowercase										= re.compile(r'''^\s*else:''')



def lowerCamelCase  (       SCREAMING_SNAKE_CASE     ):
    '''simple docstring'''







    if _re_test_backend.search(SCREAMING_SNAKE_CASE     ) is None:
        return None
    __UpperCamelCase					:Union[str, Any]        =		[b[0] for b in _re_backend.findall(SCREAMING_SNAKE_CASE     )]
    backends.sort()
    return "_and_".join(SCREAMING_SNAKE_CASE     )



def lowerCamelCase  (       SCREAMING_SNAKE_CASE     ):
    '''simple docstring'''







    with open(SCREAMING_SNAKE_CASE  ,      '''r'''  ,      encoding='''utf-8'''  ,      newline='''\n'''     ) as f:
        __UpperCamelCase					:int        =		f.readlines()

    __UpperCamelCase					:Dict        =		0
    while line_index < len(SCREAMING_SNAKE_CASE     ) and not lines[line_index].startswith('''_import_structure = {'''     ):
        line_index += 1

    # If this is a traditional init, just return.
    if line_index >= len(SCREAMING_SNAKE_CASE     ):
        return None

    # First grab the objects without a specific backend in _import_structure
    __UpperCamelCase					:Optional[int]        =		[]
    while not lines[line_index].startswith('''if TYPE_CHECKING'''     ) and find_backend(lines[line_index]     ) is None:
        __UpperCamelCase					:int        =		lines[line_index]
        # If we have everything on a single line, let's deal with it.
        if _re_one_line_import_struct.search(SCREAMING_SNAKE_CASE     ):
            __UpperCamelCase					:List[Any]        =		_re_one_line_import_struct.search(SCREAMING_SNAKE_CASE     ).groups()[0]
            __UpperCamelCase					:Dict        =		re.findall(R'''\[([^\]]+)\]'''  ,      SCREAMING_SNAKE_CASE     )
            for imp in imports:
                objects.extend([obj[1:-1] for obj in imp.split(''', '''     )]     )
            line_index += 1
            continue
        __UpperCamelCase					:Any        =		_re_import_struct_key_value.search(SCREAMING_SNAKE_CASE     )
        if single_line_import_search is not None:
            __UpperCamelCase					:Any        =		[obj[1:-1] for obj in single_line_import_search.groups()[0].split(''', '''     ) if len(SCREAMING_SNAKE_CASE     ) > 0]
            objects.extend(SCREAMING_SNAKE_CASE     )
        elif line.startswith(''' ''' * 8 + '''\"'''     ):
            objects.append(line[9:-3]     )
        line_index += 1

    __UpperCamelCase					:Optional[int]        =		{"""none""": objects}
    # Let's continue with backend-specific objects in _import_structure
    while not lines[line_index].startswith('''if TYPE_CHECKING'''     ):
        # If the line is an if not is_backend_available, we grab all objects associated.
        __UpperCamelCase					:int        =		find_backend(lines[line_index]     )
        # Check if the backend declaration is inside a try block:
        if _re_try.search(lines[line_index - 1]     ) is None:
            __UpperCamelCase					:Tuple        =		None

        if backend is not None:
            line_index += 1

            # Scroll until we hit the else block of try-except-else
            while _re_else.search(lines[line_index]     ) is None:
                line_index += 1

            line_index += 1

            __UpperCamelCase					:Any        =		[]
            # Until we unindent, add backend objects to the list
            while len(lines[line_index]     ) <= 1 or lines[line_index].startswith(''' ''' * 4     ):
                __UpperCamelCase					:str        =		lines[line_index]
                if _re_import_struct_add_one.search(SCREAMING_SNAKE_CASE     ) is not None:
                    objects.append(_re_import_struct_add_one.search(SCREAMING_SNAKE_CASE     ).groups()[0]     )
                elif _re_import_struct_add_many.search(SCREAMING_SNAKE_CASE     ) is not None:
                    __UpperCamelCase					:Optional[int]        =		_re_import_struct_add_many.search(SCREAMING_SNAKE_CASE     ).groups()[0].split(''', '''     )
                    __UpperCamelCase					:Optional[Any]        =		[obj[1:-1] for obj in imports if len(SCREAMING_SNAKE_CASE     ) > 0]
                    objects.extend(SCREAMING_SNAKE_CASE     )
                elif _re_between_brackets.search(SCREAMING_SNAKE_CASE     ) is not None:
                    __UpperCamelCase					:Optional[int]        =		_re_between_brackets.search(SCREAMING_SNAKE_CASE     ).groups()[0].split(''', '''     )
                    __UpperCamelCase					:str        =		[obj[1:-1] for obj in imports if len(SCREAMING_SNAKE_CASE     ) > 0]
                    objects.extend(SCREAMING_SNAKE_CASE     )
                elif _re_quote_object.search(SCREAMING_SNAKE_CASE     ) is not None:
                    objects.append(_re_quote_object.search(SCREAMING_SNAKE_CASE     ).groups()[0]     )
                elif line.startswith(''' ''' * 8 + '''\"'''     ):
                    objects.append(line[9:-3]     )
                elif line.startswith(''' ''' * 12 + '''\"'''     ):
                    objects.append(line[13:-3]     )
                line_index += 1

            __UpperCamelCase					:Dict        =		objects
        else:
            line_index += 1

             # At this stage we are in the TYPE_CHECKING part, first grab the objects without a specific backend
    __UpperCamelCase					:List[Any]        =		[]
    while (
        line_index < len(SCREAMING_SNAKE_CASE     )
        and find_backend(lines[line_index]     ) is None
        and not lines[line_index].startswith('''else'''     )
    ):
        __UpperCamelCase					:List[Any]        =		lines[line_index]
        __UpperCamelCase					:str        =		_re_import.search(SCREAMING_SNAKE_CASE     )
        if single_line_import_search is not None:
            objects.extend(single_line_import_search.groups()[0].split(''', '''     )     )
        elif line.startswith(''' ''' * 8     ):
            objects.append(line[8:-2]     )
        line_index += 1

    __UpperCamelCase					:Optional[int]        =		{"""none""": objects}
    # Let's continue with backend-specific objects
    while line_index < len(SCREAMING_SNAKE_CASE     ):
        # If the line is an if is_backend_available, we grab all objects associated.
        __UpperCamelCase					:List[Any]        =		find_backend(lines[line_index]     )
        # Check if the backend declaration is inside a try block:
        if _re_try.search(lines[line_index - 1]     ) is None:
            __UpperCamelCase					:List[str]        =		None

        if backend is not None:
            line_index += 1

            # Scroll until we hit the else block of try-except-else
            while _re_else.search(lines[line_index]     ) is None:
                line_index += 1

            line_index += 1

            __UpperCamelCase					:Optional[int]        =		[]
            # Until we unindent, add backend objects to the list
            while len(lines[line_index]     ) <= 1 or lines[line_index].startswith(''' ''' * 8     ):
                __UpperCamelCase					:Tuple        =		lines[line_index]
                __UpperCamelCase					:Union[str, Any]        =		_re_import.search(SCREAMING_SNAKE_CASE     )
                if single_line_import_search is not None:
                    objects.extend(single_line_import_search.groups()[0].split(''', '''     )     )
                elif line.startswith(''' ''' * 12     ):
                    objects.append(line[12:-2]     )
                line_index += 1

            __UpperCamelCase					:Optional[Any]        =		objects
        else:
            line_index += 1

    return import_dict_objects, type_hint_objects



def lowerCamelCase  (       SCREAMING_SNAKE_CASE  ,      SCREAMING_SNAKE_CASE     ):
    '''simple docstring'''







    def find_duplicates(SCREAMING_SNAKE_CASE     ):
        return [k for k, v in collections.Counter(SCREAMING_SNAKE_CASE     ).items() if v > 1]

    if list(import_dict_objects.keys()     ) != list(type_hint_objects.keys()     ):
        return ["Both sides of the init do not have the same backends!"]

    __UpperCamelCase					:Tuple        =		[]
    for key in import_dict_objects.keys():
        __UpperCamelCase					:Union[str, Any]        =		find_duplicates(import_dict_objects[key]     )
        if duplicate_imports:
            errors.append(f"""Duplicate _import_structure definitions for: {duplicate_imports}"""     )
        __UpperCamelCase					:Union[str, Any]        =		find_duplicates(type_hint_objects[key]     )
        if duplicate_type_hints:
            errors.append(f"""Duplicate TYPE_CHECKING objects for: {duplicate_type_hints}"""     )

        if sorted(set(import_dict_objects[key]     )     ) != sorted(set(type_hint_objects[key]     )     ):
            __UpperCamelCase					:Dict        =		"""base imports""" if key == """none""" else f"""{key} backend"""
            errors.append(f"""Differences for {name}:"""     )
            for a in type_hint_objects[key]:
                if a not in import_dict_objects[key]:
                    errors.append(f"""  {a} in TYPE_HINT but not in _import_structure."""     )
            for a in import_dict_objects[key]:
                if a not in type_hint_objects[key]:
                    errors.append(f"""  {a} in _import_structure but not in TYPE_HINT."""     )
    return errors



def lowerCamelCase  (       ):
    '''simple docstring'''







    __UpperCamelCase					:Dict        =		[]
    for root, _, files in os.walk(SCREAMING_SNAKE_CASE     ):
        if "__init__.py" in files:
            __UpperCamelCase					:List[str]        =		os.path.join(SCREAMING_SNAKE_CASE  ,      '''__init__.py'''     )
            __UpperCamelCase					:Optional[Any]        =		parse_init(SCREAMING_SNAKE_CASE     )
            if objects is not None:
                __UpperCamelCase					:str        =		analyze_results(*SCREAMING_SNAKE_CASE     )
                if len(SCREAMING_SNAKE_CASE     ) > 0:
                    __UpperCamelCase					:str        =		f"""Problem in {fname}, both halves do not define the same objects.\n{errors[0]}"""
                    failures.append('''\n'''.join(SCREAMING_SNAKE_CASE     )     )
    if len(SCREAMING_SNAKE_CASE     ) > 0:
        raise ValueError('''\n\n'''.join(SCREAMING_SNAKE_CASE     )     )



def lowerCamelCase  (       ):
    '''simple docstring'''







    __UpperCamelCase					:Tuple        =		[]
    for path, directories, files in os.walk(SCREAMING_SNAKE_CASE     ):
        for folder in directories:
            # Ignore private modules
            if folder.startswith('''_'''     ):
                directories.remove(SCREAMING_SNAKE_CASE     )
                continue
            # Ignore leftovers from branches (empty folders apart from pycache)
            if len(list((Path(SCREAMING_SNAKE_CASE     ) / folder).glob('''*.py'''     )     )     ) == 0:
                continue
            __UpperCamelCase					:Tuple        =		str((Path(SCREAMING_SNAKE_CASE     ) / folder).relative_to(SCREAMING_SNAKE_CASE     )     )
            __UpperCamelCase					:List[Any]        =		short_path.replace(os.path.sep  ,      '''.'''     )
            submodules.append(SCREAMING_SNAKE_CASE     )
        for fname in files:
            if fname == "__init__.py":
                continue
            __UpperCamelCase					:Optional[Any]        =		str((Path(SCREAMING_SNAKE_CASE     ) / fname).relative_to(SCREAMING_SNAKE_CASE     )     )
            __UpperCamelCase					:List[Any]        =		short_path.replace('''.py'''  ,      ''''''     ).replace(os.path.sep  ,      '''.'''     )
            if len(submodule.split('''.'''     )     ) == 1:
                submodules.append(SCREAMING_SNAKE_CASE     )
    return submodules


__lowercase										= [
    "convert_pytorch_checkpoint_to_tf2",
    "modeling_flax_pytorch_utils",
    "models.esm.openfold_utils",
]



def lowerCamelCase  (       ):
    '''simple docstring'''







    from transformers.utils import direct_transformers_import

    __UpperCamelCase					:List[str]        =		direct_transformers_import(SCREAMING_SNAKE_CASE     )

    __UpperCamelCase					:Any        =		set(transformers._import_structure.keys()     )
    # This contains all the base keys of the _import_structure object defined in the init, but if the user is missing
    # some optional dependencies, they may not have all of them. Thus we read the init to read all additions and
    # (potentiall re-) add them.
    with open(os.path.join(SCREAMING_SNAKE_CASE  ,      '''__init__.py'''     )  ,      '''r'''     ) as f:
        __UpperCamelCase					:List[Any]        =		f.read()
    import_structure_keys.update(set(re.findall(R'''import_structure\[\"([^\"]*)\"\]'''  ,      SCREAMING_SNAKE_CASE     )     )     )

    __UpperCamelCase					:List[str]        =		[
        module
        for module in get_transformers_submodules()
        if module not in IGNORE_SUBMODULES and module not in import_structure_keys
    ]

    if len(SCREAMING_SNAKE_CASE     ) > 0:
        __UpperCamelCase					:Union[str, Any]        =		"""\n""".join(f"""- {module}""" for module in module_not_registered     )
        raise ValueError(
            '''The following submodules are not properly registed in the main init of Transformers:\n'''
            f"""{list_of_modules}\n"""
            '''Make sure they appear somewhere in the keys of `_import_structure` with an empty list as value.'''     )


if __name__ == "__main__":
    check_all_inits()
    check_submodules()






from collections import OrderedDict
from typing import Any, List, Mapping, Optional

from ... import PreTrainedTokenizer, TensorType, is_torch_available
from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfigWithPast, PatchingSpec
from ...utils import logging


__lowercase										= logging.get_logger(__name__)

__lowercase										= {
    '''EleutherAI/gpt-j-6B''': '''https://huggingface.co/EleutherAI/gpt-j-6B/resolve/main/config.json''',
    # See all GPT-J models at https://huggingface.co/models?filter=gpt_j
}


class      lowerCamelCase_					(       UpperCAmelCase_			):






    '''simple docstring'''






    a__     :						Optional[Any]      =				"""gptj"""
    a__     :						Tuple      =				{
        """max_position_embeddings""": """n_positions""",
        """hidden_size""": """n_embd""",
        """num_attention_heads""": """n_head""",
        """num_hidden_layers""": """n_layer""",
    }







    def __init__(     self			,			__lowercase=50_400			,			__lowercase=2_048			,			__lowercase=4_096			,			__lowercase=28			,			__lowercase=16			,			__lowercase=64			,			__lowercase=None			,			__lowercase="gelu_new"			,			__lowercase=0.0			,			__lowercase=0.0			,			__lowercase=0.0			,			__lowercase=1E-5			,			__lowercase=0.02			,			__lowercase=True			,			__lowercase=50_256			,			__lowercase=50_256			,			__lowercase=False			,			**__lowercase			,			)	->     Tuple:
        __UpperCamelCase					:Any        =		vocab_size
        __UpperCamelCase					:Optional[int]        =		n_positions
        __UpperCamelCase					:Tuple        =		n_embd
        __UpperCamelCase					:int        =		n_layer
        __UpperCamelCase					:Any        =		n_head
        __UpperCamelCase					:Any        =		n_inner
        __UpperCamelCase					:Dict        =		rotary_dim
        __UpperCamelCase					:Tuple        =		activation_function
        __UpperCamelCase					:Optional[Any]        =		resid_pdrop
        __UpperCamelCase					:Any        =		embd_pdrop
        __UpperCamelCase					:List[str]        =		attn_pdrop
        __UpperCamelCase					:str        =		layer_norm_epsilon
        __UpperCamelCase					:List[Any]        =		initializer_range
        __UpperCamelCase					:Dict        =		use_cache

        __UpperCamelCase					:List[Any]        =		bos_token_id
        __UpperCamelCase					:Tuple        =		eos_token_id

        super().__init__(
            bos_token_id=__lowercase			,			eos_token_id=__lowercase			,			tie_word_embeddings=__lowercase			,			**__lowercase)


class      lowerCamelCase_					(       UpperCAmelCase_			):






    '''simple docstring'''






    def __init__(     self			,			__lowercase			,			__lowercase = "default"			,			__lowercase = None			,			__lowercase = False			,			)	->     Any:
        super().__init__(__lowercase			,			task=__lowercase			,			patching_specs=__lowercase			,			use_past=__lowercase)
        if not getattr(self._config			,			'''pad_token_id'''			,			__lowercase):
            # TODO: how to do that better?
            __UpperCamelCase					:Tuple        =		0







    @property
    def       UpperCamelCase__       (     self)	->     Mapping[str, Mapping[int, str]]:
        __UpperCamelCase					:Tuple        =		OrderedDict({'''input_ids''': {0: '''batch''', 1: '''sequence'''}})
        if self.use_past:
            self.fill_with_past_key_values_(__lowercase			,			direction='''inputs''')
            __UpperCamelCase					:str        =		{0: '''batch''', 1: '''past_sequence + sequence'''}
        else:
            __UpperCamelCase					:Any        =		{0: '''batch''', 1: '''sequence'''}

        return common_inputs







    @property
    def       UpperCamelCase__       (     self)	->     int:
        return self._config.n_layer







    @property
    def       UpperCamelCase__       (     self)	->     int:
        return self._config.n_head







    def       UpperCamelCase__       (     self			,			__lowercase			,			__lowercase = -1			,			__lowercase = -1			,			__lowercase = False			,			__lowercase = None			,			)	->     Mapping[str, Any]:
        __UpperCamelCase					:Optional[int]        =		super(__lowercase			,			self).generate_dummy_inputs(
            __lowercase			,			batch_size=__lowercase			,			seq_length=__lowercase			,			is_pair=__lowercase			,			framework=__lowercase)

        # We need to order the input in the way they appears in the forward()
        __UpperCamelCase					:int        =		OrderedDict({'''input_ids''': common_inputs['''input_ids''']})

        # Need to add the past_keys
        if self.use_past:
            if not is_torch_available():
                raise ValueError('''Cannot generate dummy past_keys inputs without PyTorch installed.''')
            else:
                import torch

                __UpperCamelCase  ,	__UpperCamelCase					:str        =		common_inputs['''input_ids'''].shape
                # Not using the same length for past_key_values
                __UpperCamelCase					:List[str]        =		seqlen + 2
                __UpperCamelCase					:Union[str, Any]        =		(
                    batch,
                    self.num_attention_heads,
                    past_key_values_length,
                    self._config.hidden_size // self.num_attention_heads,
                )
                __UpperCamelCase					:Tuple        =		[
                    (torch.zeros(__lowercase), torch.zeros(__lowercase)) for _ in range(self.num_layers)
                ]

        __UpperCamelCase					:Tuple        =		common_inputs['''attention_mask''']
        if self.use_past:
            __UpperCamelCase					:Tuple        =		ordered_inputs['''attention_mask'''].dtype
            __UpperCamelCase					:Optional[Any]        =		torch.cat(
                [ordered_inputs['''attention_mask'''], torch.ones(__lowercase			,			__lowercase			,			dtype=__lowercase)]			,			dim=1)

        return ordered_inputs







    @property
    def       UpperCamelCase__       (     self)	->     int:
        return 13





