


'''simple docstring'''

import collections
import os
import re
from pathlib import Path


a_						:       List[str]      			=				"""src/transformers"""


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





def __snake_case      (   UpperCAmelCase_		:		int	):
	if _re_test_backend.search(UpperCAmelCase_	) is None:
		return None
	lowerCamelCase_  				=						[b[0] for b in _re_backend.findall(UpperCAmelCase_	)]
	backends.sort()
	return "_and_".join(UpperCAmelCase_	)





def __snake_case      (   UpperCAmelCase_		:		Any	):
	with open(UpperCAmelCase_      ,       "r"      ,       encoding="utf-8"      ,       newline="\n"	) as f:
		lowerCamelCase_  				=						f.readlines()

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

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

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

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

			lowerCamelCase_  				=						objects
		else:
			line_index += 1

	return import_dict_objects, type_hint_objects





def __snake_case      (   UpperCAmelCase_		:		Union[str, Any]      ,       UpperCAmelCase_		:		Dict	):

	def find_duplicates(UpperCAmelCase_		:		Union[str, Any]	):
		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!"]

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


a_						:       Any      			=				[
    """convert_pytorch_checkpoint_to_tf2""",
    """modeling_flax_pytorch_utils""",
    """models.esm.openfold_utils""",
]





def __snake_case      (   ):
	# 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(UpperCAmelCase_	)

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

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

	if len(UpperCAmelCase_	) > 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 functools
import operator

from ...configuration_utils import PretrainedConfig
from ...utils import logging


a_						:       List[str]      			=				logging.get_logger(__name__)

a_						:       Dict      			=				{
    """microsoft/unispeech-large-1500h-cv""": (
        """https://huggingface.co/microsoft/unispeech-large-1500h-cv/resolve/main/config.json"""
    ),
    # See all UniSpeech models at https://huggingface.co/models?filter=unispeech
}





class   snake_case					(					lowercase    ):





  """simple docstring"""




  _lowerCamelCase						=						"unispeech"






  def __init__(					self    ,						UpperCamelCase=32    ,						UpperCamelCase=768    ,						UpperCamelCase=12    ,						UpperCamelCase=12    ,						UpperCamelCase=3072    ,						UpperCamelCase="gelu"    ,						UpperCamelCase=0.1    ,						UpperCamelCase=0.1    ,						UpperCamelCase=0.1    ,						UpperCamelCase=0.0    ,						UpperCamelCase=0.0    ,						UpperCamelCase=0.1    ,						UpperCamelCase=0.1    ,						UpperCamelCase=0.02    ,						UpperCamelCase=1e-5    ,						UpperCamelCase="group"    ,						UpperCamelCase="gelu"    ,						UpperCamelCase=(512, 512, 512, 512, 512, 512, 512)    ,						UpperCamelCase=(5, 2, 2, 2, 2, 2, 2)    ,						UpperCamelCase=(10, 3, 3, 3, 3, 2, 2)    ,						UpperCamelCase=False    ,						UpperCamelCase=128    ,						UpperCamelCase=16    ,						UpperCamelCase=False    ,						UpperCamelCase=True    ,						UpperCamelCase=0.05    ,						UpperCamelCase=10    ,						UpperCamelCase=2    ,						UpperCamelCase=0.0    ,						UpperCamelCase=10    ,						UpperCamelCase=0    ,						UpperCamelCase=320    ,						UpperCamelCase=2    ,						UpperCamelCase=0.1    ,						UpperCamelCase=100    ,						UpperCamelCase=256    ,						UpperCamelCase=256    ,						UpperCamelCase=0.1    ,						UpperCamelCase="mean"    ,						UpperCamelCase=False    ,						UpperCamelCase=False    ,						UpperCamelCase=256    ,						UpperCamelCase=80    ,						UpperCamelCase=0    ,						UpperCamelCase=1    ,						UpperCamelCase=2    ,						UpperCamelCase=0.5    ,						**UpperCamelCase    ,						):







   """simple docstring"""
   super().__init__(**UpperCamelCase    ,						pad_token_id=UpperCamelCase    ,						bos_token_id=UpperCamelCase    ,						eos_token_id=UpperCamelCase  )
   lowerCamelCase_  				=						hidden_size
   lowerCamelCase_  				=						feat_extract_norm
   lowerCamelCase_  				=						feat_extract_activation
   lowerCamelCase_  				=						list(UpperCamelCase  )
   lowerCamelCase_  				=						list(UpperCamelCase  )
   lowerCamelCase_  				=						list(UpperCamelCase  )
   lowerCamelCase_  				=						conv_bias
   lowerCamelCase_  				=						num_conv_pos_embeddings
   lowerCamelCase_  				=						num_conv_pos_embedding_groups
   lowerCamelCase_  				=						len(self.conv_dim  )
   lowerCamelCase_  				=						num_hidden_layers
   lowerCamelCase_  				=						intermediate_size
   lowerCamelCase_  				=						hidden_act
   lowerCamelCase_  				=						num_attention_heads
   lowerCamelCase_  				=						hidden_dropout
   lowerCamelCase_  				=						attention_dropout
   lowerCamelCase_  				=						activation_dropout
   lowerCamelCase_  				=						feat_proj_dropout
   lowerCamelCase_  				=						final_dropout
   lowerCamelCase_  				=						layerdrop
   lowerCamelCase_  				=						layer_norm_eps
   lowerCamelCase_  				=						initializer_range
   lowerCamelCase_  				=						num_ctc_classes
   lowerCamelCase_  				=						vocab_size
   lowerCamelCase_  				=						do_stable_layer_norm
   lowerCamelCase_  				=						use_weighted_layer_sum
   lowerCamelCase_  				=						classifier_proj_size

   if (
       (len(self.conv_stride  ) != self.num_feat_extract_layers)
       or (len(self.conv_kernel  ) != self.num_feat_extract_layers)
       or (len(self.conv_dim  ) != self.num_feat_extract_layers)
   ):
    raise ValueError(
        "Configuration for convolutional layers is incorrect. It is required that `len(config.conv_dim)` =="
        " `len(config.conv_stride)` == `len(config.conv_kernel)`, but is `len(config.conv_dim) ="
        f''' {len(self.conv_dim  )}`, `len(config.conv_stride) = {len(self.conv_stride  )}`,'''
        f''' `len(config.conv_kernel) = {len(self.conv_kernel  )}`.'''  )

   # fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779
   lowerCamelCase_  				=						apply_spec_augment
   lowerCamelCase_  				=						mask_time_prob
   lowerCamelCase_  				=						mask_time_length
   lowerCamelCase_  				=						mask_time_min_masks
   lowerCamelCase_  				=						mask_feature_prob
   lowerCamelCase_  				=						mask_feature_length
   lowerCamelCase_  				=						mask_feature_min_masks

   # parameters for pretraining with codevector quantized representations
   lowerCamelCase_  				=						num_codevectors_per_group
   lowerCamelCase_  				=						num_codevector_groups
   lowerCamelCase_  				=						contrastive_logits_temperature
   lowerCamelCase_  				=						feat_quantizer_dropout
   lowerCamelCase_  				=						num_negatives
   lowerCamelCase_  				=						codevector_dim
   lowerCamelCase_  				=						proj_codevector_dim
   lowerCamelCase_  				=						diversity_loss_weight

   # ctc loss
   lowerCamelCase_  				=						ctc_loss_reduction
   lowerCamelCase_  				=						ctc_zero_infinity

   # pretraining loss
   lowerCamelCase_  				=						replace_prob







  @property
  def 						snake_case	(					self  ):







   """simple docstring"""
   return functools.reduce(operator.mul    ,						self.conv_stride    ,						1  )



