





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


lowercase						:      Optional[int]									= 'src/transformers'


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




def 			_SCREAMING_SNAKE_CASE      (	_lowerCamelCase				:    List[Any])      ->					Optional[int]:






							'''simple docstring'''





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




def 			_SCREAMING_SNAKE_CASE      (	_lowerCamelCase				:    int)      ->					List[str]:






							'''simple docstring'''





							with open(_lowerCamelCase		,						"r"		,						encoding="utf-8"		,						newline="\n") as f:
														__UpperCamelCase			:     List[Any]         =      f.readlines()

							__UpperCamelCase			:     Any         =      0
							while line_index < len(_lowerCamelCase) and not lines[line_index].startswith("_import_structure = {"):
														line_index += 1

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

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

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

																					__UpperCamelCase			:     List[str]         =      objects
														else:
																					line_index += 1

    # At this stage we are in the TYPE_CHECKING part, first grab the objects without a specific backend
							__UpperCamelCase			:     str         =      []
							while (
							    line_index < len(_lowerCamelCase)
							    and find_backend(lines[line_index]) is None
							    and not lines[line_index].startswith("else")
							):
														__UpperCamelCase			:     Union[str, Any]         =      lines[line_index]
														__UpperCamelCase			:     List[str]         =      _re_import.search(_lowerCamelCase)
														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			:     List[Any]         =      {"none": objects}
							# Let's continue with backend-specific objects
							while line_index < len(_lowerCamelCase):
														# If the line is an if is_backend_available, we grab all objects associated.
														__UpperCamelCase			:     List[str]         =      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			:     Union[str, Any]         =      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			:     Tuple         =      []
																					# Until we unindent, add backend objects to the list
																					while len(lines[line_index]) <= 1 or lines[line_index].startswith(" " * 8):
																												__UpperCamelCase			:     Optional[Any]         =      lines[line_index]
																												__UpperCamelCase			:     Dict         =      _re_import.search(_lowerCamelCase)
																												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			:     Any         =      objects
														else:
																					line_index += 1

							return import_dict_objects, type_hint_objects




def 			_SCREAMING_SNAKE_CASE      (	_lowerCamelCase				:    List[str]		,						_lowerCamelCase				:    Optional[Any])      ->					Tuple:






							'''simple docstring'''





							def find_duplicates(_lowerCamelCase				:    Optional[Any]):
														return [k for k, v in collections.Counter(_lowerCamelCase).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			:     Union[str, Any]         =      []
							for key in import_dict_objects.keys():
														__UpperCamelCase			:     int         =      find_duplicates(import_dict_objects[key])
														if duplicate_imports:
																					errors.append(F'Duplicate _import_structure definitions for: {duplicate_imports}')
														__UpperCamelCase			:     int         =      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			:     Optional[int]         =      "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      (	)      ->					Optional[int]:






							'''simple docstring'''





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




def 			_SCREAMING_SNAKE_CASE      (	)      ->					Union[str, Any]:






							'''simple docstring'''





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


lowercase						:      Any									= [
    'convert_pytorch_checkpoint_to_tf2',
    'modeling_flax_pytorch_utils',
]




def 			_SCREAMING_SNAKE_CASE      (	)      ->					List[Any]:






							'''simple docstring'''





							__UpperCamelCase			:     List[Any]         =      importlib.util.spec_from_file_location(
							    "transformers"		,						os.path.join(_lowerCamelCase		,						"__init__.py")		,						submodule_search_locations=[PATH_TO_TRANSFORMERS]		,						)
							__UpperCamelCase			:     Optional[int]         =      spec.loader.load_module()

							__UpperCamelCase			:     Tuple         =      [
							    module
							    for module in get_transformers_submodules()
							    if module not in IGNORE_SUBMODULES and module not in transformers._import_structure.keys()
							]
							if len(_lowerCamelCase) > 0:
														__UpperCamelCase			:     str         =      "\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 typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


lowercase						:      Tuple									= {
    'configuration_swinv2': ['SWINV2_PRETRAINED_CONFIG_ARCHIVE_MAP', 'Swinv2Config'],
}


try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		lowercase						:      Union[str, Any]									= [
		    'SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST',
		    'Swinv2ForImageClassification',
		    'Swinv2ForMaskedImageModeling',
		    'Swinv2Model',
		    'Swinv2PreTrainedModel',
		]


if TYPE_CHECKING:
		from .configuration_swinva import SWINV2_PRETRAINED_CONFIG_ARCHIVE_MAP, SwinvaConfig

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_swinva import (
				    SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST,
				    SwinvaForImageClassification,
				    SwinvaForMaskedImageModeling,
				    SwinvaModel,
				    SwinvaPreTrainedModel,
				)


else:
		import sys

		lowercase						:      Optional[Any]									= _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)