

'''simple docstring'''
import collections
import os
import re
from pathlib import Path


lowerCamelCase			:				Dict 			=					"src/transformers"


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


def 	_lowerCAmelCase (						_UpperCamelCase						:					Optional[Any]    )				->      Tuple:
     """simple docstring"""




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


def 	_lowerCAmelCase (						_UpperCamelCase						:					Dict    )				->      Any:
     """simple docstring"""




     with open(a__							,			'r'							,			encoding='utf-8'							,			newline='\n'    ) as f:
          _SCREAMING_SNAKE_CASE							   =f.readlines()

     _SCREAMING_SNAKE_CASE							   =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
     _SCREAMING_SNAKE_CASE							   =[]
     while not lines[line_index].startswith('if TYPE_CHECKING'    ) and find_backend(lines[line_index]    ) is None:
          _SCREAMING_SNAKE_CASE							   =lines[line_index]
          # If we have everything on a single line, let's deal with it.
          if _re_one_line_import_struct.search(a__    ):
               _SCREAMING_SNAKE_CASE							   =_re_one_line_import_struct.search(a__    ).groups()[0]
               _SCREAMING_SNAKE_CASE							   =re.findall(r'\[([^\]]+)\]'							,			a__    )
               for imp in imports:
                    objects.extend([obj[1:-1] for obj in imp.split(', '    )]    )
               line_index += 1
               continue
          _SCREAMING_SNAKE_CASE							   =_re_import_struct_key_value.search(a__    )
          if single_line_import_search is not None:
               _SCREAMING_SNAKE_CASE							   =[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

     _SCREAMING_SNAKE_CASE							   ={'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.
          _SCREAMING_SNAKE_CASE							   =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:
               _SCREAMING_SNAKE_CASE							   =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

               _SCREAMING_SNAKE_CASE							   =[]
               # Until we unindent, add backend objects to the list
               while len(lines[line_index]    ) <= 1 or lines[line_index].startswith(' ' * 4    ):
                    _SCREAMING_SNAKE_CASE							   =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:
                         _SCREAMING_SNAKE_CASE							   =_re_import_struct_add_many.search(a__    ).groups()[0].split(', '    )
                         _SCREAMING_SNAKE_CASE							   =[obj[1:-1] for obj in imports if len(a__    ) > 0]
                         objects.extend(a__    )
                    elif _re_between_brackets.search(a__    ) is not None:
                         _SCREAMING_SNAKE_CASE							   =_re_between_brackets.search(a__    ).groups()[0].split(', '    )
                         _SCREAMING_SNAKE_CASE							   =[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

               _SCREAMING_SNAKE_CASE							   =objects
          else:
               line_index += 1

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

     _SCREAMING_SNAKE_CASE							   ={'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.
          _SCREAMING_SNAKE_CASE							   =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:
               _SCREAMING_SNAKE_CASE							   =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

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

               _SCREAMING_SNAKE_CASE							   =objects
          else:
               line_index += 1

     return import_dict_objects, type_hint_objects


def 	_lowerCAmelCase (						_UpperCamelCase						:					Optional[Any]							,			_UpperCamelCase						:					List[Any]    )				->      str:
     """simple docstring"""




     def find_duplicates(_UpperCamelCase						:					Optional[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!"]

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




     _SCREAMING_SNAKE_CASE							   =[]
     for root, _, files in os.walk(a__    ):
          if "__init__.py" in files:
               _SCREAMING_SNAKE_CASE							   =os.path.join(a__							,			'__init__.py'    )
               _SCREAMING_SNAKE_CASE							   =parse_init(a__    )
               if objects is not None:
                    _SCREAMING_SNAKE_CASE							   =analyze_results(*a__    )
                    if len(a__    ) > 0:
                         _SCREAMING_SNAKE_CASE							   =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 	_lowerCAmelCase (						)				->      List[Any]:
     """simple docstring"""




     _SCREAMING_SNAKE_CASE							   =[]
     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
               _SCREAMING_SNAKE_CASE							   =str((Path(a__    ) / folder).relative_to(a__    )    )
               _SCREAMING_SNAKE_CASE							   =short_path.replace(os.path.sep							,			'.'    )
               submodules.append(a__    )
          for fname in files:
               if fname == "__init__.py":
                    continue
               _SCREAMING_SNAKE_CASE							   =str((Path(a__    ) / fname).relative_to(a__    )    )
               _SCREAMING_SNAKE_CASE							   =short_path.replace('.py'							,			''    ).replace(os.path.sep							,			'.'    )
               if len(submodule.split('.'    )    ) == 1:
                    submodules.append(a__    )
     return submodules


lowerCamelCase			:				List[str] 			=					[
    "convert_pytorch_checkpoint_to_tf2",
    "modeling_flax_pytorch_utils",
    "models.esm.openfold_utils",
]


def 	_lowerCAmelCase (						)				->      Optional[Any]:
     """simple docstring"""




     from transformers.utils import direct_transformers_import

     _SCREAMING_SNAKE_CASE							   =direct_transformers_import(a__    )

     _SCREAMING_SNAKE_CASE							   =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:
          _SCREAMING_SNAKE_CASE							   =f.read()
     import_structure_keys.update(set(re.findall(r'import_structure\[\"([^\"]*)\"\]'							,			a__    )    )    )

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

     if len(a__    ) > 0:
          _SCREAMING_SNAKE_CASE							   ='\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 warnings
from contextlib import contextmanager

from ....processing_utils import ProcessorMixin







class 							A__   (	A__  ):
  A__					=    'MCTCTFeatureExtractor'
  A__					=    'AutoTokenizer'





  def __init__(		self				:     Optional[Any]							, _a				:     Optional[int]							, _a				:     Union[str, Any]			)     ->   Union[str, Any]:





       '''simple docstring'''






       super().__init__(_a							, _a			)
       _SCREAMING_SNAKE_CASE							   =self.feature_extractor
       _SCREAMING_SNAKE_CASE							   =False





  def __call__(		self				:     Dict							, *_a				:     str							, **_a				:     Dict			)     ->   Dict:





       '''simple docstring'''






       if self._in_target_context_manager:
            return self.current_processor(*_a							, **_a			)

       if "raw_speech" in kwargs:
            warnings.warn('Using `raw_speech` as a keyword argument is deprecated. Use `audio` instead.'			)
            _SCREAMING_SNAKE_CASE							   =kwargs.pop('raw_speech'			)
       else:
            _SCREAMING_SNAKE_CASE							   =kwargs.pop('audio'							, _a			)
       _SCREAMING_SNAKE_CASE							   =kwargs.pop('sampling_rate'							, _a			)
       _SCREAMING_SNAKE_CASE							   =kwargs.pop('text'							, _a			)
       if len(_a			) > 0:
            _SCREAMING_SNAKE_CASE							   =args[0]
            _SCREAMING_SNAKE_CASE							   =args[1:]

       if audio is None and text is None:
            raise ValueError('You need to specify either an `audio` or `text` input to process.'			)

       if audio is not None:
            _SCREAMING_SNAKE_CASE							   =self.feature_extractor(_a							, *_a							, sampling_rate=_a							, **_a			)
       if text is not None:
            _SCREAMING_SNAKE_CASE							   =self.tokenizer(_a							, **_a			)

       if text is None:
            return inputs
       elif audio is None:
            return encodings
       else:
            _SCREAMING_SNAKE_CASE							   =encodings['input_ids']
            return inputs





  def 						A  (		self				:     Any							, *_a				:     List[str]							, **_a				:     Optional[int]			)     ->   Optional[int]:





       '''simple docstring'''






       return self.tokenizer.batch_decode(*_a							, **_a			)





  def 						A  (		self				:     Dict							, *_a				:     Tuple							, **_a				:     Dict			)     ->   List[str]:





       '''simple docstring'''






       if self._in_target_context_manager:
            return self.current_processor.pad(*_a							, **_a			)

       _SCREAMING_SNAKE_CASE							   =kwargs.pop('input_features'							, _a			)
       _SCREAMING_SNAKE_CASE							   =kwargs.pop('labels'							, _a			)
       if len(_a			) > 0:
            _SCREAMING_SNAKE_CASE							   =args[0]
            _SCREAMING_SNAKE_CASE							   =args[1:]

       if input_features is not None:
            _SCREAMING_SNAKE_CASE							   =self.feature_extractor.pad(_a							, *_a							, **_a			)
       if labels is not None:
            _SCREAMING_SNAKE_CASE							   =self.tokenizer.pad(_a							, **_a			)

       if labels is None:
            return input_features
       elif input_features is None:
            return labels
       else:
            _SCREAMING_SNAKE_CASE							   =labels['input_ids']
            return input_features





  def 						A  (		self				:     Tuple							, *_a				:     Dict							, **_a				:     List[Any]			)     ->   Optional[int]:





       '''simple docstring'''






       return self.tokenizer.decode(*_a							, **_a			)





  @contextmanager
  def 						A  (		self				:     Optional[Any]			)     ->   Dict:





       '''simple docstring'''






       warnings.warn(
           '`as_target_processor` is deprecated and will be removed in v5 of Transformers. You can process your '
           'labels by using the argument `text` of the regular `__call__` method (either in the same call as '
           'your audio inputs, or in a separate call.'			)
       _SCREAMING_SNAKE_CASE							   =True
       _SCREAMING_SNAKE_CASE							   =self.tokenizer
       yield
       _SCREAMING_SNAKE_CASE							   =self.feature_extractor
       _SCREAMING_SNAKE_CASE							   =False
