




import collections
import os
import re
from pathlib import Path


_A     =			'''src/transformers'''


# Matches is_xxx_available()
_A     =			re.compile(R'''is\_([a-z_]*)_available()''')
# Catches a one-line _import_struct = {xxx}
_A     =			re.compile(R'''^_import_structure\s+=\s+\{([^\}]+)\}''')
# Catches a line with a key-values pattern: "bla": ["foo", "bar"]
_A     =			re.compile(R'''\s+\"\S*\":\s+\[([^\]]*)\]''')
# Catches a line if not is_foo_available
_A     =			re.compile(R'''^\s*if\s+not\s+is\_[a-z_]*\_available\(\)''')
# Catches a line _import_struct["bla"].append("foo")
_A     =			re.compile(R'''^\s*_import_structure\[\"\S*\"\]\.append\(\"(\S*)\"\)''')
# Catches a line _import_struct["bla"].extend(["foo", "bar"]) or _import_struct["bla"] = ["foo", "bar"]
_A     =			re.compile(R'''^\s*_import_structure\[\S*\](?:\.extend\(|\s*=\s+)\[([^\]]*)\]''')
# Catches a line with an object between quotes and a comma:     "MyModel",
_A     =			re.compile(R'''^\s+\"([^\"]+)\",''')
# Catches a line with objects between brackets only:    ["foo", "bar"],
_A     =			re.compile(R'''^\s+\[([^\]]+)\]''')
# Catches a line with from foo import bar, bla, boo
_A     =			re.compile(R'''\s+from\s+\S*\s+import\s+([^\(\s].*)\n''')
# Catches a line with try:
_A     =			re.compile(R'''^\s*try:''')
# Catches a line with else:
_A     =			re.compile(R'''^\s*else:''')





def __UpperCamelCase			(       _A  ):
						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 __UpperCamelCase			(       _A  ):
						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 __UpperCamelCase			(       _A ,  _A  ):

						def find_duplicates(_A  ):
												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 __UpperCamelCase			(       ):
						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 __UpperCamelCase			(       ):
						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


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





def __UpperCamelCase			(       ):
						# This is to make sure the transformers module imported is the one in the repo.
						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()












import logging
from dataclasses import dataclass, field
from typing import Optional

from seqaseq_trainer import arg_to_scheduler

from transformers import TrainingArguments


lowercase  							=					logging.getLogger(__name__)




@dataclass
class  UpperCamelCase_      (			snake_case_				):



	'''simple docstring'''




	lowerCAmelCase													= field(
	    default=0.0       ,					metadata={'''help''': '''The label smoothing epsilon to apply (if not zero).'''}				)
	lowerCAmelCase													= field(default=snake_case_       ,					metadata={'''help''': '''Whether to SortishSamler or not.'''}				)
	lowerCAmelCase													= field(
	    default=snake_case_       ,					metadata={'''help''': '''Whether to use generate to calculate generative metrics (ROUGE, BLEU).'''}				)
	lowerCAmelCase													= field(default=snake_case_       ,					metadata={'''help''': '''whether to use adafactor'''}				)
	lowerCAmelCase													= field(
	    default=snake_case_       ,					metadata={'''help''': '''Encoder layer dropout probability. Goes into model.config.'''}				)
	lowerCAmelCase													= field(
	    default=snake_case_       ,					metadata={'''help''': '''Decoder layer dropout probability. Goes into model.config.'''}				)
	lowerCAmelCase													= field(default=snake_case_       ,					metadata={'''help''': '''Dropout probability. Goes into model.config.'''}				)
	lowerCAmelCase													= field(
	    default=snake_case_       ,					metadata={'''help''': '''Attention dropout probability. Goes into model.config.'''}				)
	lowerCAmelCase													= field(
	    default='''linear'''       ,					metadata={'''help''': F'''Which lr scheduler to use. Selected in {sorted(arg_to_scheduler.keys()				)}'''}       ,					)





