




import collections
import importlib.util
import os
import re
from pathlib import Path


lowercase__				:      int	   = "src/transformers"


# Matches is_xxx_available()
lowercase__				:      Dict	   = re.compile(R"is\_([a-z_]*)_available()")
# Catches a one-line _import_struct = {xxx}
lowercase__				:      Any	   = re.compile(R"^_import_structure\s+=\s+\{([^\}]+)\}")
# Catches a line with a key-values pattern: "bla": ["foo", "bar"]
lowercase__				:      Optional[int]	   = re.compile(R"\s+\"\S*\":\s+\[([^\]]*)\]")
# Catches a line if not is_foo_available
lowercase__				:      Any	   = re.compile(R"^\s*if\s+not\s+is\_[a-z_]*\_available\(\)")
# Catches a line _import_struct["bla"].append("foo")
lowercase__				:      Dict	   = 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__				:      Optional[int]	   = re.compile(R"^\s*_import_structure\[\S*\](?:\.extend\(|\s*=\s+)\[([^\]]*)\]")
# Catches a line with an object between quotes and a comma:     "MyModel",
lowercase__				:      List[Any]	   = re.compile("^\s+\"([^\"]+)\",")
# Catches a line with objects between brackets only:    ["foo", "bar"],
lowercase__				:      Union[str, Any]	   = re.compile("^\s+\[([^\]]+)\]")
# Catches a line with from foo import bar, bla, boo
lowercase__				:      int	   = re.compile(R"\s+from\s+\S*\s+import\s+([^\(\s].*)\n")
# Catches a line with try:
lowercase__				:      str	   = re.compile(R"^\s*try:")
# Catches a line with else:
lowercase__				:      Union[str, Any]	   = re.compile(R"^\s*else:")

def  SCREAMING_SNAKE_CASE							(       __UpperCamelCase)      ->					Union[str, Any]:
     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  SCREAMING_SNAKE_CASE							(       __UpperCamelCase)      ->					List[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("\[([^\]]+)\]"		, __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  SCREAMING_SNAKE_CASE							(       __UpperCamelCase		, __UpperCamelCase)      ->					Any:

     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  SCREAMING_SNAKE_CASE							(       )      ->					Union[str, Any]:
     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  SCREAMING_SNAKE_CASE							(       )      ->					Tuple:
     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__				:      Optional[Any]	   = [
    "convert_pytorch_checkpoint_to_tf2",
    "modeling_flax_pytorch_utils",
]

def  SCREAMING_SNAKE_CASE							(       )      ->					Any:
     # This is to make sure the transformers module imported is the one in the repo.
     a     =				importlib.util.spec_from_file_location(
         "transformers"		, os.path.join(__UpperCamelCase		, "__init__.py")		, submodule_search_locations=[PATH_TO_TRANSFORMERS]		, )
     a     =				spec.loader.load_module()

     a     =				[
         module
         for module in get_transformers_submodules()
         if module not in IGNORE_SUBMODULES and module not in transformers._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 registered 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 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


lowercase__				:      Tuple	   = logging.get_logger(__name__)

lowercase__				:      int	   = {
    "microsoft/resnet-50": "https://huggingface.co/microsoft/resnet-50/blob/main/config.json",
}




class       a__	( UpperCamelCase__       , UpperCamelCase__				):
     a		:      Any		 =     """resnet"""
     a		:      Tuple		 =     ["""basic""", """bottleneck"""]







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



          '''simple docstring'''



          super().__init__(**A			)
          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(A			) + 1			)]
          a  ,				a     =				get_aligned_output_features_output_indices(
              out_features=A  ,		out_indices=A  ,		stage_names=self.stage_names			)







class       a__	( UpperCamelCase__				):
     a		:      Optional[int]		 =     version.parse("""1.11"""				)







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



          '''simple docstring'''



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







     @property
     def       lowerCAmelCase_    (     self			)  ->   float:



          '''simple docstring'''



          return 1e-3

