



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__    (					UpperCamelCase_				:       Dict	)->  int:
    if _re_test_backend.search(UpperCamelCase_	) is None:
        return None
    A__		 =					[b[0] for b in _re_backend.findall(UpperCamelCase_	)]
    backends.sort()
    return "_and_".join(UpperCamelCase_	)



def 		lowerCAmelCase__    (					UpperCamelCase_				:       int	)->  Any:
    with open(UpperCamelCase_ ,       '''r''' ,       encoding='''utf-8''' ,       newline='''\n'''	) as f:
        A__		 =					f.readlines()

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

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

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

    A__		 =					{'''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.
        A__		 =					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:
            A__		 =					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

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

            A__		 =					objects
        else:
            line_index += 1

    # At this stage we are in the TYPE_CHECKING part, first grab the objects without a specific backend
    A__		 =					[]
    while (
        line_index < len(UpperCamelCase_	)
        and find_backend(lines[line_index]	) is None
        and not lines[line_index].startswith('''else'''	)
    ):
        A__		 =					lines[line_index]
        A__		 =					_re_import.search(UpperCamelCase_	)
        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

    A__		 =					{'''none''': objects}
    # Let's continue with backend-specific objects
    while line_index < len(UpperCamelCase_	):
        # If the line is an if is_backend_available, we grab all objects associated.
        A__		 =					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:
            A__		 =					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

            A__		 =					[]
            # Until we unindent, add backend objects to the list
            while len(lines[line_index]	) <= 1 or lines[line_index].startswith(''' ''' * 8	):
                A__		 =					lines[line_index]
                A__		 =					_re_import.search(UpperCamelCase_	)
                if single_line_import_search is not None:
                    objects.extend(single_line_import_search.groups()[0].split(''', '''	)	)
                elif line.startswith(''' ''' * 1_2	):
                    objects.append(line[1_2:-2]	)
                line_index += 1

            A__		 =					objects
        else:
            line_index += 1

    return import_dict_objects, type_hint_objects



def 		lowerCAmelCase__    (					UpperCamelCase_				:       str ,       UpperCamelCase_				:       Any	)->  str:

    def find_duplicates(UpperCamelCase_				:       Dict	):
        return [k for k, v in collections.Counter(UpperCamelCase_	).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!"]

    A__		 =					[]
    for key in import_dict_objects.keys():
        A__		 =					find_duplicates(import_dict_objects[key]	)
        if duplicate_imports:
            errors.append(f"Duplicate _import_structure definitions for: {duplicate_imports}"	)
        A__		 =					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]	)	):
            A__		 =					'''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__    (					)->  Optional[int]:
    A__		 =					[]
    for root, _, files in os.walk(UpperCamelCase_	):
        if "__init__.py" in files:
            A__		 =					os.path.join(UpperCamelCase_ ,       '''__init__.py'''	)
            A__		 =					parse_init(UpperCamelCase_	)
            if objects is not None:
                A__		 =					analyze_results(*UpperCamelCase_	)
                if len(UpperCamelCase_	) > 0:
                    A__		 =					f"Problem in {fname}, both halves do not define the same objects.\n{errors[0]}"
                    failures.append('''\n'''.join(UpperCamelCase_	)	)
    if len(UpperCamelCase_	) > 0:
        raise ValueError('''\n\n'''.join(UpperCamelCase_	)	)



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


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



def 		lowerCAmelCase__    (					)->  Dict:
    # This is to make sure the transformers module imported is the one in the repo.
    from transformers.utils import direct_transformers_import

    A__		 =					direct_transformers_import(UpperCamelCase_	)

    A__		 =					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(UpperCamelCase_ ,       '''__init__.py'''	) ,       '''r'''	) as f:
        A__		 =					f.read()
    import_structure_keys.update(set(re.findall(r'''import_structure\[\"([^\"]*)\"\]''' ,       UpperCamelCase_	)	)	)

    A__		 =					[
        module
        for module in get_transformers_submodules()
        if module not in IGNORE_SUBMODULES and module not in import_structure_keys
    ]

    if len(UpperCamelCase_	) > 0:
        A__		 =					'''\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 Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


_lowercase						  =		logging.get_logger(__name__)

_lowercase						  =		{
    "bert-base-uncased": "https://huggingface.co/bert-base-uncased/resolve/main/config.json",
    "bert-large-uncased": "https://huggingface.co/bert-large-uncased/resolve/main/config.json",
    "bert-base-cased": "https://huggingface.co/bert-base-cased/resolve/main/config.json",
    "bert-large-cased": "https://huggingface.co/bert-large-cased/resolve/main/config.json",
    "bert-base-multilingual-uncased": "https://huggingface.co/bert-base-multilingual-uncased/resolve/main/config.json",
    "bert-base-multilingual-cased": "https://huggingface.co/bert-base-multilingual-cased/resolve/main/config.json",
    "bert-base-chinese": "https://huggingface.co/bert-base-chinese/resolve/main/config.json",
    "bert-base-german-cased": "https://huggingface.co/bert-base-german-cased/resolve/main/config.json",
    "bert-large-uncased-whole-word-masking": (
        "https://huggingface.co/bert-large-uncased-whole-word-masking/resolve/main/config.json"
    ),
    "bert-large-cased-whole-word-masking": (
        "https://huggingface.co/bert-large-cased-whole-word-masking/resolve/main/config.json"
    ),
    "bert-large-uncased-whole-word-masking-finetuned-squad": (
        "https://huggingface.co/bert-large-uncased-whole-word-masking-finetuned-squad/resolve/main/config.json"
    ),
    "bert-large-cased-whole-word-masking-finetuned-squad": (
        "https://huggingface.co/bert-large-cased-whole-word-masking-finetuned-squad/resolve/main/config.json"
    ),
    "bert-base-cased-finetuned-mrpc": "https://huggingface.co/bert-base-cased-finetuned-mrpc/resolve/main/config.json",
    "bert-base-german-dbmdz-cased": "https://huggingface.co/bert-base-german-dbmdz-cased/resolve/main/config.json",
    "bert-base-german-dbmdz-uncased": "https://huggingface.co/bert-base-german-dbmdz-uncased/resolve/main/config.json",
    "cl-tohoku/bert-base-japanese": "https://huggingface.co/cl-tohoku/bert-base-japanese/resolve/main/config.json",
    "cl-tohoku/bert-base-japanese-whole-word-masking": (
        "https://huggingface.co/cl-tohoku/bert-base-japanese-whole-word-masking/resolve/main/config.json"
    ),
    "cl-tohoku/bert-base-japanese-char": (
        "https://huggingface.co/cl-tohoku/bert-base-japanese-char/resolve/main/config.json"
    ),
    "cl-tohoku/bert-base-japanese-char-whole-word-masking": (
        "https://huggingface.co/cl-tohoku/bert-base-japanese-char-whole-word-masking/resolve/main/config.json"
    ),
    "TurkuNLP/bert-base-finnish-cased-v1": (
        "https://huggingface.co/TurkuNLP/bert-base-finnish-cased-v1/resolve/main/config.json"
    ),
    "TurkuNLP/bert-base-finnish-uncased-v1": (
        "https://huggingface.co/TurkuNLP/bert-base-finnish-uncased-v1/resolve/main/config.json"
    ),
    "wietsedv/bert-base-dutch-cased": "https://huggingface.co/wietsedv/bert-base-dutch-cased/resolve/main/config.json",
    # See all BERT models at https://huggingface.co/models?filter=bert
}



class     _UpperCAmelCase			(       A__     ):
     UpperCamelCase__		    =				'''bert'''




     def __init__(				self ,						a__=3_0_5_2_2 ,						a__=7_6_8 ,						a__=1_2 ,						a__=1_2 ,						a__=3_0_7_2 ,						a__="gelu" ,						a__=0.1 ,						a__=0.1 ,						a__=5_1_2 ,						a__=2 ,						a__=0.0_2 ,						a__=1e-12 ,						a__=0 ,						a__="absolute" ,						a__=True ,						a__=None ,						**a__ ,						):
         super().__init__(pad_token_id=a__ ,						**a__)

         A__		 =					vocab_size
         A__		 =					hidden_size
         A__		 =					num_hidden_layers
         A__		 =					num_attention_heads
         A__		 =					hidden_act
         A__		 =					intermediate_size
         A__		 =					hidden_dropout_prob
         A__		 =					attention_probs_dropout_prob
         A__		 =					max_position_embeddings
         A__		 =					type_vocab_size
         A__		 =					initializer_range
         A__		 =					layer_norm_eps
         A__		 =					position_embedding_type
         A__		 =					use_cache
         A__		 =					classifier_dropout







class     _UpperCAmelCase			(       A__     ):




     @property
     def 		snake_case_		(				self):
         if self.task == "multiple-choice":
             A__		 =					{0: '''batch''', 1: '''choice''', 2: '''sequence'''}
         else:
             A__		 =					{0: '''batch''', 1: '''sequence'''}
         return OrderedDict(
             [
                 ('''input_ids''', dynamic_axis),
                 ('''attention_mask''', dynamic_axis),
                 ('''token_type_ids''', dynamic_axis),
             ])
