

'''simple docstring'''







import collections
import os
import re
from pathlib import Path


__lowerCamelCase									=     '''src/transformers'''


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

                     A_						       =   objects
              else:
                     line_index += 1

       return import_dict_objects, type_hint_objects
def    UpperCAmelCase__     (   UpperCAmelCase__,							UpperCAmelCase__					)      ->      Tuple:

       def find_duplicates(UpperCAmelCase__					):
              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    UpperCAmelCase__     (   )      ->      Dict:
       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    UpperCAmelCase__     (   )      ->      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


__lowerCamelCase									=     [
    '''convert_pytorch_checkpoint_to_tf2''',
    '''modeling_flax_pytorch_utils''',
    '''models.esm.openfold_utils''',
]
def    UpperCAmelCase__     (   )      ->      int:
       # 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()



'''simple docstring'''







from collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging
from ...utils.backbone_utils import BackboneConfigMixin, get_aligned_output_features_output_indices


__lowerCamelCase									=     logging.get_logger(__name__)

__lowerCamelCase									=     {
    '''microsoft/resnet-50''': '''https://huggingface.co/microsoft/resnet-50/blob/main/config.json''',
}


class        A__   (   _snake_case    ,    _snake_case      ):
    lowercase						       =		"resnet"
    lowercase						       =		["basic", "bottleneck"]



    def __init__(       self		,					UpperCamelCase__=3		,					UpperCamelCase__=64		,					UpperCamelCase__=[256, 512, 1024, 2048]		,					UpperCamelCase__=[3, 4, 6, 3]		,					UpperCamelCase__="bottleneck"		,					UpperCamelCase__="relu"		,					UpperCamelCase__=False		,					UpperCamelCase__=None		,					UpperCamelCase__=None		,					**UpperCamelCase__		,					)    ->   List[str]:





           '''simple docstring'''
           super().__init__(**UpperCamelCase__							)
           if layer_type not in self.layer_types:
                  raise ValueError(f'''layer_type={layer_type} is not one of {",".join(self.layer_types							)}'''							)
           A_						       =   num_channels
           A_						       =   embedding_size
           A_						       =   hidden_sizes
           A_						       =   depths
           A_						       =   layer_type
           A_						       =   hidden_act
           A_						       =   downsample_in_first_stage
           A_						       =   ["""stem"""] + [f'''stage{idx}''' for idx in range(1		,					len(UpperCamelCase__							) + 1							)]
           A_       ,      A_						       =   get_aligned_output_features_output_indices(
               out_features=UpperCamelCase__		,					out_indices=UpperCamelCase__		,					stage_names=self.stage_names							)


class        A__   (   _snake_case      ):
    lowercase						       =		version.parse("1.11"      )



    @property
    def        snake_case_      (       self							)    ->   Mapping[str, Mapping[int, str]]:





           '''simple docstring'''
           return OrderedDict(
               [
                   ("""pixel_values""", {0: """batch""", 1: """num_channels""", 2: """height""", 3: """width"""}),
               ]							)







    @property
    def        snake_case_      (       self							)    ->   float:





           '''simple docstring'''
           return 1e-3
