'''simple docstring'''




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 							snake_case__				(     _A:   str					)       ->      Dict:

		'''simple docstring'''


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






def 							snake_case__				(     _A:   List[str]					)       ->      Dict:

		'''simple docstring'''


		with open(_A ,  """r""" ,  encoding="""utf-8""" ,  newline="""\n"""					) as f:
				lowerCAmelCase     =    f.readlines()

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

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

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

		lowerCAmelCase     =    {"""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.
				lowerCAmelCase     =    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:
						lowerCAmelCase     =    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

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

						lowerCAmelCase     =    objects
				else:
						line_index += 1

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

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

						lowerCAmelCase     =    []
						# Until we unindent, add backend objects to the list
						while len(lines[line_index]					) <= 1 or lines[line_index].startswith(""" """ * 8					):
								lowerCAmelCase     =    lines[line_index]
								lowerCAmelCase     =    _re_import.search(_A					)
								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

						lowerCAmelCase     =    objects
				else:
						line_index += 1

		return import_dict_objects, type_hint_objects






def 							snake_case__				(     _A:   int ,  _A:   List[str]					)       ->      int:

		'''simple docstring'''


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

		lowerCAmelCase     =    []
		for key in import_dict_objects.keys():
				lowerCAmelCase     =    find_duplicates(import_dict_objects[key]					)
				if duplicate_imports:
						errors.append(f"Duplicate _import_structure definitions for: {duplicate_imports}"					)
				lowerCAmelCase     =    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]					)					):
						lowerCAmelCase     =    """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 							snake_case__				(     )       ->      List[Any]:

		'''simple docstring'''


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






def 							snake_case__				(     )       ->      Tuple:

		'''simple docstring'''


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


__lowercase        =    [
    '''convert_pytorch_checkpoint_to_tf2''',
    '''modeling_flax_pytorch_utils''',
    '''models.esm.openfold_utils''',
]






def 							snake_case__				(     )       ->      List[Any]:

		'''simple docstring'''


		from transformers.utils import direct_transformers_import

		lowerCAmelCase     =    direct_transformers_import(_A					)

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

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

		if len(_A					) > 0:
				lowerCAmelCase     =    """\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'''




import unittest

from transformers import is_torch_available
from transformers.testing_utils import require_torch


if is_torch_available():
						import torch

						from transformers.generation import DisjunctiveConstraint






@require_torch
class 							a__(   unittest.TestCase      ):


			'''simple docstring'''






			def 				a_			(  self):




					"""simple docstring"""


					lowerCAmelCase     =    [[1, 2, 4], [1, 2, 3, 4]]
					lowerCAmelCase     =    DisjunctiveConstraint(__lowerCAmelCase)
					self.assertTrue(isinstance(dc.token_ids			,       __lowerCAmelCase))

					with self.assertRaises(__lowerCAmelCase):
							DisjunctiveConstraint(torch.LongTensor([[1, 2, 4], [1, 2, 3]]))

					with self.assertRaises(__lowerCAmelCase):
							DisjunctiveConstraint([torch.LongTensor([1, 2, 4]), torch.LongTensor([1, 2, 3, 4, 5])])



			def 				a_			(  self):




					"""simple docstring"""


					lowerCAmelCase     =    [[1, 2], [1, 2, 3, 4]]

					with self.assertRaises(__lowerCAmelCase):
							DisjunctiveConstraint(__lowerCAmelCase)  # fails here



			def 				a_			(  self):




					"""simple docstring"""


					lowerCAmelCase     =    [[1, 2, 3], [1, 2, 4]]

					lowerCAmelCase     =    DisjunctiveConstraint(__lowerCAmelCase)

					lowerCAmelCase   ,	lowerCAmelCase   ,	lowerCAmelCase     =    dc.update(1)
					lowerCAmelCase     =    stepped is True and completed is False and reset is False
					self.assertTrue(__lowerCAmelCase)
					self.assertTrue(not dc.completed)
					self.assertTrue(dc.current_seq == [1])

					lowerCAmelCase   ,	lowerCAmelCase   ,	lowerCAmelCase     =    dc.update(2)
					lowerCAmelCase     =    stepped is True and completed is False and reset is False
					self.assertTrue(__lowerCAmelCase)
					self.assertTrue(not dc.completed)
					self.assertTrue(dc.current_seq == [1, 2])

					lowerCAmelCase   ,	lowerCAmelCase   ,	lowerCAmelCase     =    dc.update(3)
					lowerCAmelCase     =    stepped is True and completed is True and reset is False
					self.assertTrue(__lowerCAmelCase)
					self.assertTrue(dc.completed)  # Completed!
					self.assertTrue(dc.current_seq == [1, 2, 3])







			def 				a_			(  self):




					"""simple docstring"""


					lowerCAmelCase     =    [[1, 2, 3], [1, 2, 4, 5], [1, 2, 5]]

					lowerCAmelCase     =    DisjunctiveConstraint(__lowerCAmelCase)

					lowerCAmelCase   ,	lowerCAmelCase   ,	lowerCAmelCase     =    dc.update(1)
					self.assertTrue(not dc.completed)
					self.assertTrue(dc.current_seq == [1])

					lowerCAmelCase   ,	lowerCAmelCase   ,	lowerCAmelCase     =    dc.update(2)
					self.assertTrue(not dc.completed)
					self.assertTrue(dc.current_seq == [1, 2])

					lowerCAmelCase   ,	lowerCAmelCase   ,	lowerCAmelCase     =    dc.update(4)
					self.assertTrue(not dc.completed)
					self.assertTrue(dc.current_seq == [1, 2, 4])

					lowerCAmelCase   ,	lowerCAmelCase   ,	lowerCAmelCase     =    dc.update(5)
					self.assertTrue(dc.completed)  # Completed!
					self.assertTrue(dc.current_seq == [1, 2, 4, 5])

					dc.reset()

					lowerCAmelCase   ,	lowerCAmelCase   ,	lowerCAmelCase     =    dc.update(1)
					self.assertTrue(not dc.completed)
					self.assertTrue(dc.remaining() == 3)
					self.assertTrue(dc.current_seq == [1])

					lowerCAmelCase   ,	lowerCAmelCase   ,	lowerCAmelCase     =    dc.update(2)
					self.assertTrue(not dc.completed)
					self.assertTrue(dc.remaining() == 2)
					self.assertTrue(dc.current_seq == [1, 2])

					lowerCAmelCase   ,	lowerCAmelCase   ,	lowerCAmelCase     =    dc.update(5)
					self.assertTrue(dc.completed)  # Completed!
					self.assertTrue(dc.remaining() == 0)
					self.assertTrue(dc.current_seq == [1, 2, 5])




