





'''simple docstring'''


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


lowerCAmelCase_   :   Optional[int]       =					"src/transformers"


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







def    _lowerCamelCase  (__lowerCamelCase  :     Optional[Any]     )   ->    Optional[int]:
			if _re_test_backend.search(__lowerCamelCase     ) is None:
						return None
			a__     = [b[0] for b in _re_backend.findall(__lowerCamelCase     )]
			backends.sort()
			return "_and_".join(__lowerCamelCase     )







def    _lowerCamelCase  (__lowerCamelCase  :     int     )   ->    List[str]:
			with open(__lowerCamelCase					,  "r"					,  encoding="utf-8"					,  newline="\n"     ) as f:
						a__     = f.readlines()

			a__     = 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
			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(__lowerCamelCase     ):
									a__     = _re_one_line_import_struct.search(__lowerCamelCase     ).groups()[0]
									a__     = re.findall("\[([^\]]+)\]"					,  __lowerCamelCase     )
									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(__lowerCamelCase     )
						if single_line_import_search is not None:
									a__     = [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

			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(__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:
															a__     = _re_import_struct_add_many.search(__lowerCamelCase     ).groups()[0].split(", "     )
															a__     = [obj[1:-1] for obj in imports if len(__lowerCamelCase     ) > 0]
															objects.extend(__lowerCamelCase     )
												elif _re_between_brackets.search(__lowerCamelCase     ) is not None:
															a__     = _re_between_brackets.search(__lowerCamelCase     ).groups()[0].split(", "     )
															a__     = [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

									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(__lowerCamelCase     )
			    and find_backend(lines[line_index]     ) is None
			    and not lines[line_index].startswith("else"     )
			):
						a__     = lines[line_index]
						a__     = _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

			a__     = {"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.
						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(__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

									a__     = objects
						else:
									line_index += 1

			return import_dict_objects, type_hint_objects







def    _lowerCamelCase  (__lowerCamelCase  :     int					,  __lowerCamelCase  :     List[str]     )   ->    Union[str, Any]:

			def find_duplicates(__lowerCamelCase  :     str     ):
						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!"]

			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  ()   ->    Dict:
			a__     = []
			for root, _, files in os.walk(__lowerCamelCase     ):
						if "__init__.py" in files:
									a__     = os.path.join(__lowerCamelCase					,  "__init__.py"     )
									a__     = parse_init(__lowerCamelCase     )
									if objects is not None:
												a__     = analyze_results(*__lowerCamelCase     )
												if len(__lowerCamelCase     ) > 0:
															a__     = 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    _lowerCamelCase  ()   ->    List[str]:
			a__     = []
			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
									a__     = str((Path(__lowerCamelCase     ) / folder).relative_to(__lowerCamelCase     )     )
									a__     = short_path.replace(os.path.sep					,  "."     )
									submodules.append(__lowerCamelCase     )
						for fname in files:
									if fname == "__init__.py":
												continue
									a__     = str((Path(__lowerCamelCase     ) / fname).relative_to(__lowerCamelCase     )     )
									a__     = short_path.replace(".py"					,  ""     ).replace(os.path.sep					,  "."     )
									if len(submodule.split("."     )     ) == 1:
												submodules.append(__lowerCamelCase     )
			return submodules


lowerCAmelCase_   :   Dict       =					[
    "convert_pytorch_checkpoint_to_tf2",
    "modeling_flax_pytorch_utils",
]







def    _lowerCamelCase  ()   ->    Tuple:
			# 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(__lowerCamelCase					,  "__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(__lowerCamelCase     ) > 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()










'''simple docstring'''


from manim import *






class       UpperCamelCase__  (		__lowerCAmelCase     ):







	def 						__a   (				self			:   List[Any]		):




				'''simple docstring'''
				a__     = Rectangle(height=0.5 , width=0.5		)
				a__     = Rectangle(height=0.25 , width=0.25		)
				a__     = Rectangle(height=0.46 , width=0.46		).set_stroke(width=0		)

				a__     = [mem.copy() for i in range(6		)]
				a__     = [mem.copy() for i in range(6		)]
				a__     = VGroup(*lowerCamelCase		).arrange(lowerCamelCase , buff=0		)
				a__     = VGroup(*lowerCamelCase		).arrange(lowerCamelCase , buff=0		)
				a__     = VGroup(lowerCamelCase , lowerCamelCase		).arrange(lowerCamelCase , buff=0		)
				a__     = Text("CPU" , font_size=2_4		)
				a__     = Group(lowerCamelCase , lowerCamelCase		).arrange(lowerCamelCase , buff=0.5 , aligned_edge=lowerCamelCase		)
				cpu.move_to([-2.5, -0.5, 0]		)
				self.add(lowerCamelCase		)

				a__     = [mem.copy() for i in range(4		)]
				a__     = VGroup(*lowerCamelCase		).arrange(lowerCamelCase , buff=0		)
				a__     = Text("GPU" , font_size=2_4		)
				a__     = Group(lowerCamelCase , lowerCamelCase		).arrange(lowerCamelCase , buff=0.5 , aligned_edge=lowerCamelCase		)
				gpu.move_to([-1, -1, 0]		)
				self.add(lowerCamelCase		)

				a__     = [mem.copy() for i in range(6		)]
				a__     = VGroup(*lowerCamelCase		).arrange(lowerCamelCase , buff=0		)

				a__     = Text("Model" , font_size=2_4		)
				a__     = Group(lowerCamelCase , lowerCamelCase		).arrange(lowerCamelCase , buff=0.5 , aligned_edge=lowerCamelCase		)
				model.move_to([3, -1.0, 0]		)
				self.add(lowerCamelCase		)

				a__     = []
				a__     = []
				a__     = []

				for i, rect in enumerate(lowerCamelCase		):
							rect.set_stroke(lowerCamelCase		)

							a__     = Rectangle(height=0.46 / 4 , width=0.46 / 3		).set_stroke(width=0.0		).set_fill(lowerCamelCase , opacity=0.7		)

							if i == 0:
										cpu_target.next_to(cpu_left_col_base[0].get_corner(DOWN + LEFT		) , buff=0.02 , direction=lowerCamelCase		)
										cpu_target.set_x(cpu_target.get_x() + 0.1		)
							elif i == 3:
										cpu_target.next_to(model_cpu_arr[0] , direction=lowerCamelCase , buff=0.0		)
							else:
										cpu_target.next_to(model_cpu_arr[i - 1] , direction=lowerCamelCase , buff=0.0		)
							self.add(lowerCamelCase		)
							model_cpu_arr.append(lowerCamelCase		)

				self.add(*lowerCamelCase , *lowerCamelCase , *lowerCamelCase		)

				a__     = [mem.copy() for i in range(6		)]
				a__     = VGroup(*lowerCamelCase		).arrange(lowerCamelCase , buff=0		)

				a__     = Text("Loaded Checkpoint" , font_size=2_4		)
				a__     = Group(lowerCamelCase , lowerCamelCase		).arrange(lowerCamelCase , buff=0.5 , aligned_edge=lowerCamelCase		)
				checkpoint.move_to([3, 0.5, 0]		)

				self.add(lowerCamelCase		)

				a__     = []
				a__     = []

				for i, rect in enumerate(lowerCamelCase		):
							a__     = fill.copy().set_fill(lowerCamelCase , opacity=0.7		)
							target.move_to(lowerCamelCase		)
							ckpt_arr.append(lowerCamelCase		)

							a__     = target.copy()
							if i < 5:
										cpu_target.move_to(cpu_left_col_base[i + 1]		)
							else:
										cpu_target.move_to(cpu_right_col_base[i - 5]		)
							ckpt_cpu_arr.append(lowerCamelCase		)
				self.add(*lowerCamelCase , *lowerCamelCase		)

				a__     = Square(side_length=2.2		)
				key.move_to([-5, 2, 0]		)

				a__     = MarkupText(
				    F'''<b>Key:</b>\n\n<span fgcolor=\'{YELLOW}\'>●</span> Empty Model''' , font_size=1_8 , )

				key_text.move_to([-5, 2.4, 0]		)

				self.add(lowerCamelCase , lowerCamelCase		)

				a__     = MarkupText(
				    F'''<span fgcolor=\'{BLUE}\'>●</span> Checkpoint''' , font_size=1_8 , )

				blue_text.next_to(lowerCamelCase , DOWN * 2.4 , aligned_edge=key_text.get_left()		)
				self.add(lowerCamelCase		)

				a__     = MarkupText(
				    F'''Based on the passed in configuration, weights are stored in\na variety of np.memmaps on disk or to a particular device.''' , font_size=2_4 , )
				step_a.move_to([2, 2, 0]		)

				a__     = [meta_mem.copy() for i in range(6		)]
				a__     = [meta_mem.copy() for i in range(6		)]
				a__     = VGroup(*lowerCamelCase		).arrange(lowerCamelCase , buff=0		)
				a__     = VGroup(*lowerCamelCase		).arrange(lowerCamelCase , buff=0		)
				a__     = VGroup(lowerCamelCase , lowerCamelCase		).arrange(lowerCamelCase , buff=0		)
				a__     = Text("Disk" , font_size=2_4		)
				a__     = Group(lowerCamelCase , lowerCamelCase		).arrange(lowerCamelCase , buff=0.5 , aligned_edge=lowerCamelCase		)
				disk.move_to([-4.0, -1.25, 0]		)
				self.play(Write(lowerCamelCase , run_time=3		) , Write(lowerCamelCase , run_time=1		) , Create(lowerCamelCase , run_time=1		)		)

				a__     = []
				for i, rect in enumerate(lowerCamelCase		):
							a__     = rect.copy()
							target.generate_target()
							target.target.move_to(disk_left_col_base[i]		).scale(0.5		)
							animations.append(MoveToTarget(lowerCamelCase , run_time=1.5		)		)
				self.play(*lowerCamelCase		)

				self.play(FadeOut(lowerCamelCase		)		)

				a__     = MarkupText(F'''Then, the checkpoint is removed from memory\nthrough garbage collection.''' , font_size=2_4		)
				step_a.move_to([2, 2, 0]		)

				self.play(Write(lowerCamelCase , run_time=3		)		)

				self.play(
				    FadeOut(lowerCamelCase , lowerCamelCase , *lowerCamelCase , *lowerCamelCase		) , )

				self.wait()



