


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


lowerCamelCase__							:						str							     =   """src/transformers"""


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







def SCREAMING_SNAKE_CASE	(			__lowerCAmelCase				)    ->				str:
  if _re_test_backend.search(__lowerCAmelCase				) is None:
    return None
  snake_case__						= [b[0] for b in _re_backend.findall(__lowerCAmelCase				)]
  backends.sort()
  return "_and_".join(__lowerCAmelCase				)







def SCREAMING_SNAKE_CASE	(			__lowerCAmelCase				)    ->				List[str]:
  with open(__lowerCAmelCase							,   '''r'''							,   encoding='''utf-8'''							,   newline='''\n'''				) as f:
    snake_case__						= f.readlines()

  snake_case__						= 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
  snake_case__						= []
  while not lines[line_index].startswith('''if TYPE_CHECKING'''				) and find_backend(lines[line_index]				) is None:
    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(__lowerCAmelCase				):
      snake_case__						= _re_one_line_import_struct.search(__lowerCAmelCase				).groups()[0]
      snake_case__						= re.findall('''\[([^\]]+)\]'''							,   __lowerCAmelCase				)
      for imp in imports:
        objects.extend([obj[1:-1] for obj in imp.split(''', '''				)]				)
      line_index += 1
      continue
    snake_case__						= _re_import_struct_key_value.search(__lowerCAmelCase				)
    if single_line_import_search is not None:
      snake_case__						= [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

  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.
    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:
      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

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

      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
  snake_case__						= []
  while (
      line_index < len(__lowerCAmelCase				)
      and find_backend(lines[line_index]				) is None
      and not lines[line_index].startswith('''else'''				)
  ):
    snake_case__						= lines[line_index]
    snake_case__						= _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

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

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

      snake_case__						= objects
    else:
      line_index += 1

  return import_dict_objects, type_hint_objects







def SCREAMING_SNAKE_CASE	(			__lowerCAmelCase							,   __lowerCAmelCase				)    ->				List[str]:

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

  snake_case__						= []
  for key in import_dict_objects.keys():
    snake_case__						= find_duplicates(import_dict_objects[key]				)
    if duplicate_imports:
      errors.append(F"""Duplicate _import_structure definitions for: {duplicate_imports}"""				)
    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]				)				):
      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 SCREAMING_SNAKE_CASE	(			)    ->				str:
  snake_case__						= []
  for root, _, files in os.walk(__lowerCAmelCase				):
    if "__init__.py" in files:
      snake_case__						= os.path.join(__lowerCAmelCase							,   '''__init__.py'''				)
      snake_case__						= parse_init(__lowerCAmelCase				)
      if objects is not None:
        snake_case__						= analyze_results(*__lowerCAmelCase				)
        if len(__lowerCAmelCase				) > 0:
          snake_case__						= 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 SCREAMING_SNAKE_CASE	(			)    ->				Tuple:
  snake_case__						= []
  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
      snake_case__						= str((Path(__lowerCAmelCase				) / folder).relative_to(__lowerCAmelCase				)				)
      snake_case__						= short_path.replace(os.path.sep							,   '''.'''				)
      submodules.append(__lowerCAmelCase				)
    for fname in files:
      if fname == "__init__.py":
        continue
      snake_case__						= str((Path(__lowerCAmelCase				) / fname).relative_to(__lowerCAmelCase				)				)
      snake_case__						= short_path.replace('''.py'''							,   ''''''				).replace(os.path.sep							,   '''.'''				)
      if len(submodule.split('''.'''				)				) == 1:
        submodules.append(__lowerCAmelCase				)
  return submodules


lowerCamelCase__							:						Optional[int]							     =   [
    """convert_pytorch_checkpoint_to_tf2""",
    """modeling_flax_pytorch_utils""",
]







def SCREAMING_SNAKE_CASE	(			)    ->				Optional[Any]:
  # This is to make sure the transformers module imported is the one in the repo.
  snake_case__						= importlib.util.spec_from_file_location(
      '''transformers'''							,   os.path.join(__lowerCAmelCase							,   '''__init__.py'''				)							,   submodule_search_locations=[PATH_TO_TRANSFORMERS]							,   )
  snake_case__						= spec.loader.load_module()

  snake_case__						= [
      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:
    snake_case__						= '''\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 math import ceil
from typing import List, Optional, Union

import numpy as np

from ...audio_utils import mel_filter_bank, spectrogram, window_function
from ...feature_extraction_sequence_utils import BatchFeature, SequenceFeatureExtractor
from ...utils import TensorType, logging


UpperCamelCase_    	=				logging.get_logger(__name__)






class 							_a				(			SCREAMING_SNAKE_CASE ):





       '''simple docstring'''






       A						:				str        =						['''audio_values''', '''audio_mask''']







       def __init__(      self,							A=2_048,							A=1,							A=[16, 16],							A=128,							A=44_100,							A=86,							A=2_048,							A=0.0,							**A,							):







             '''simple docstring'''







             super().__init__(
                 feature_size=A,							sampling_rate=A,							padding_value=A,							**A,							)

             SCREAMING_SNAKE_CASE   :      str    					=						spectrogram_length
             SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						num_channels
             SCREAMING_SNAKE_CASE   :      List[str]    					=						patch_size
             SCREAMING_SNAKE_CASE   :      Optional[int]    					=						feature_size // self.patch_size[1]
             SCREAMING_SNAKE_CASE   :      Dict    					=						n_fft
             SCREAMING_SNAKE_CASE   :      Tuple    					=						sampling_rate // hop_length_to_sampling_rate
             SCREAMING_SNAKE_CASE   :      str    					=						sampling_rate
             SCREAMING_SNAKE_CASE   :      int    					=						padding_value
             SCREAMING_SNAKE_CASE   :      Any    					=						mel_filter_bank(
                 num_frequency_bins=1 + n_fft // 2,							num_mel_filters=A,							min_frequency=0.0,							max_frequency=2_20_50.0,							sampling_rate=A,							norm='slaney',							mel_scale='slaney',							).T







       def        UpperCamelCase_							(      self,							A  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      Optional[int]    					=						spectrogram(
                 A,							window_function(self.n_fft,							'hann'  ),							frame_length=self.n_fft,							hop_length=self.hop_length,							power=2.0,							mel_filters=self.mel_filters.T,							log_mel='dB',							db_range=80.0,							)
             SCREAMING_SNAKE_CASE   :      Union[str, Any]    					=						log_spec[:, :-1]
             SCREAMING_SNAKE_CASE   :      List[Any]    					=						log_spec - 20.0
             SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						np.clip(log_spec / 40.0,							-2.0,							0.0  ) + 1.0
             return log_spec







       def __call__(      self,							A,							A = None,							A = True,							A = None,							A = False,							A = False,							**A,							):







             '''simple docstring'''







             if sampling_rate is not None:
                   if sampling_rate != self.sampling_rate:
                         raise ValueError(
                             'This feature extractor is set to support sampling rate'
                             F" of {self.sampling_rate}. Please make sure that the provided `raw_speech` input was sampled"
                             F" with {self.sampling_rate} and not {sampling_rate}."  )
             else:
                   logger.warning(
                       'It is strongly recommended to pass the `sampling_rate` argument to this function. '
                       'Failing to do so can result in silent errors that might be hard to debug.'  )

             SCREAMING_SNAKE_CASE   :      List[Any]    					=						isinstance(A,							np.ndarray  ) and len(raw_speech.shape  ) > 1
             if is_batched_numpy and len(raw_speech.shape  ) > 2:
                   raise ValueError(F"Only mono-channel audio is supported for input to {self}"  )
             SCREAMING_SNAKE_CASE   :      int    					=						is_batched_numpy or (
                 isinstance(A,							(list, tuple)  ) and (isinstance(raw_speech[0],							(np.ndarray, tuple, list)  ))
             )
             if is_batched:
                   SCREAMING_SNAKE_CASE   :      Union[str, Any]    					=						[np.asarray([speech],							dtype=np.floataa  ).T for speech in raw_speech]
             elif not is_batched and not isinstance(A,							np.ndarray  ):
                   SCREAMING_SNAKE_CASE   :      Any    					=						np.asarray(A,							dtype=np.floataa  )
             elif isinstance(A,							np.ndarray  ) and raw_speech.dtype is np.dtype(np.floataa  ):
                   SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						raw_speech.astype(np.floataa  )
             # always return batch
             if not is_batched:
                   SCREAMING_SNAKE_CASE   :      Union[str, Any]    					=						[np.asarray([raw_speech]  ).T]

             # Convert audio signals to log mel spectrograms, truncate by time axis
             SCREAMING_SNAKE_CASE   :      int    					=						[
                 self._np_extract_fbank_features(waveform.squeeze()  ).T[: self.spectrogram_length] for waveform in raw_speech
             ]
             if isinstance(audio_features[0],							A  ):
                   SCREAMING_SNAKE_CASE   :      Union[str, Any]    					=						[np.asarray(A,							dtype=np.floataa  ) for feature in audio_features]

             # Create audio attention mask
             SCREAMING_SNAKE_CASE   :      Tuple    					=						max(
                 [ceil(feature.shape[0] / self.patch_size[0]  ) * self.freq_len for feature in audio_features]  )  # The maximum number of audio patches in a batch
             if return_attention_mask:
                   SCREAMING_SNAKE_CASE   :      List[Any]    					=						[
                       (ceil(feature.shape[0] / self.patch_size[0]  ) * self.freq_len) * [1]
                       + (max_patch_len - ceil(feature.shape[0] / self.patch_size[0]  ) * self.freq_len) * [0]
                       for feature in audio_features
                   ]
                   SCREAMING_SNAKE_CASE   :      Tuple    					=						np.array(A  ).astype(np.floataa  )

             # convert into correct format for padding
             SCREAMING_SNAKE_CASE   :      Tuple    					=						max_patch_len // self.freq_len * self.patch_size[0]  # The maximum audio size in a batch
             SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						np.ones([len(A  ), 1, max_time_len, self.feature_size]  ).astype(np.floataa  )
             SCREAMING_SNAKE_CASE   :      Optional[int]    					=						padded_audio_features * self.padding_value
             for i in range(len(A  )  ):
                   SCREAMING_SNAKE_CASE   :      Optional[int]    					=						audio_features[i]
                   SCREAMING_SNAKE_CASE   :      Union[str, Any]    					=						feature

             # return as BatchFeature
             if return_attention_mask:
                   SCREAMING_SNAKE_CASE   :      Any    					=						{'audio_values': padded_audio_features, 'audio_mask': audio_mask}
             else:
                   SCREAMING_SNAKE_CASE   :      Dict    					=						{'audio_values': padded_audio_features}

             SCREAMING_SNAKE_CASE   :      str    					=						BatchFeature(data=A,							tensor_type=A  )
             return encoded_inputs


