




import argparse
import os
import re

import packaging.version


UpperCamelCase__    			=			"""examples/"""
UpperCamelCase__    			=			{
    """examples""": (re.compile(R"""^check_min_version\(\"[^\"]+\"\)\s*$""", re.MULTILINE), """check_min_version(\"VERSION\")\n"""),
    """init""": (re.compile(R"""^__version__\s+=\s+\"([^\"]+)\"\s*$""", re.MULTILINE), """__version__ = \"VERSION\"\n"""),
    """setup""": (re.compile(R"""^(\s*)version\s*=\s*\"[^\"]+\",""", re.MULTILINE), R"""\1version=\"VERSION\","""),
    """doc""": (re.compile(R"""^(\s*)release\s*=\s*\"[^\"]+\"$""", re.MULTILINE), """release = \"VERSION\"\n"""),
}
UpperCamelCase__    			=			{
    """init""": """src/transformers/__init__.py""",
    """setup""": """setup.py""",
}
UpperCamelCase__    			=			"""README.md"""







def 	_a      (						SCREAMING_SNAKE_CASE_							:				Optional[int]      ,      SCREAMING_SNAKE_CASE_							:				Any      ,      SCREAMING_SNAKE_CASE_							:				List[str]     ):
					with open(SCREAMING_SNAKE_CASE_      ,      "r"      ,      encoding="utf-8"      ,      newline="\n"     ) as f:
										__lowerCAmelCase				   =       f.read()
					__lowerCAmelCase   ,							__lowerCAmelCase				   =       REPLACE_PATTERNS[pattern]
					__lowerCAmelCase				   =       replace.replace("VERSION"      ,      SCREAMING_SNAKE_CASE_     )
					__lowerCAmelCase				   =       re_pattern.sub(SCREAMING_SNAKE_CASE_      ,      SCREAMING_SNAKE_CASE_     )
					with open(SCREAMING_SNAKE_CASE_      ,      "w"      ,      encoding="utf-8"      ,      newline="\n"     ) as f:
										f.write(SCREAMING_SNAKE_CASE_     )







def 	_a      (						SCREAMING_SNAKE_CASE_							:				List[Any]     ):
					for folder, directories, fnames in os.walk(SCREAMING_SNAKE_CASE_     ):
										# Removing some of the folders with non-actively maintained examples from the walk
										if "research_projects" in directories:
															directories.remove("research_projects"     )
										if "legacy" in directories:
															directories.remove("legacy"     )
										for fname in fnames:
															if fname.endswith(".py"     ):
																				update_version_in_file(os.path.join(SCREAMING_SNAKE_CASE_      ,      SCREAMING_SNAKE_CASE_     )      ,      SCREAMING_SNAKE_CASE_      ,      pattern="examples"     )







def 	_a      (						SCREAMING_SNAKE_CASE_							:				Tuple      ,      SCREAMING_SNAKE_CASE_							:				Optional[int]=False     ):
					for pattern, fname in REPLACE_FILES.items():
										update_version_in_file(SCREAMING_SNAKE_CASE_      ,      SCREAMING_SNAKE_CASE_      ,      SCREAMING_SNAKE_CASE_     )
					if not patch:
										update_version_in_examples(SCREAMING_SNAKE_CASE_     )







def 	_a      (						):
					__lowerCAmelCase				   =       "🤗 Transformers currently provides the following architectures"
					__lowerCAmelCase				   =       "1. Want to contribute a new model?"
					with open(SCREAMING_SNAKE_CASE_      ,      "r"      ,      encoding="utf-8"      ,      newline="\n"     ) as f:
										__lowerCAmelCase				   =       f.readlines()

					# Find the start of the list.
					__lowerCAmelCase				   =       0
					while not lines[start_index].startswith(_start_prompt     ):
										start_index += 1
					start_index += 1

					__lowerCAmelCase				   =       start_index
					# Update the lines in the model list.
					while not lines[index].startswith(_end_prompt     ):
										if lines[index].startswith("1."     ):
															__lowerCAmelCase				   =       lines[index].replace(
															    "https://huggingface.co/docs/transformers/main/model_doc"      ,      "https://huggingface.co/docs/transformers/model_doc"      ,      )
										index += 1

					with open(SCREAMING_SNAKE_CASE_      ,      "w"      ,      encoding="utf-8"      ,      newline="\n"     ) as f:
										f.writelines(SCREAMING_SNAKE_CASE_     )







def 	_a      (						):
					with open(REPLACE_FILES["init"]      ,      "r"     ) as f:
										__lowerCAmelCase				   =       f.read()
					__lowerCAmelCase				   =       REPLACE_PATTERNS["init"][0].search(SCREAMING_SNAKE_CASE_     ).groups()[0]
					return packaging.version.parse(SCREAMING_SNAKE_CASE_     )







def 	_a      (						SCREAMING_SNAKE_CASE_							:				List[Any]=False     ):
					__lowerCAmelCase				   =       get_version()
					if patch and default_version.is_devrelease:
										raise ValueError("Can't create a patch version from the dev branch, checkout a released version!"     )
					if default_version.is_devrelease:
										__lowerCAmelCase				   =       default_version.base_version
					elif patch:
										__lowerCAmelCase				   =       F"""{default_version.major}.{default_version.minor}.{default_version.micro + 1}"""
					else:
										__lowerCAmelCase				   =       F"""{default_version.major}.{default_version.minor + 1}.0"""

					# Now let's ask nicely if that's the right one.
					__lowerCAmelCase				   =       input(F"""Which version are you releasing? [{default_version}]"""     )
					if len(SCREAMING_SNAKE_CASE_     ) == 0:
										__lowerCAmelCase				   =       default_version

					print(F"""Updating version to {version}."""     )
					global_version_update(SCREAMING_SNAKE_CASE_      ,      patch=SCREAMING_SNAKE_CASE_     )
					if not patch:
										print("Cleaning main README, don't forget to run `make fix-copies`."     )
										clean_main_ref_in_model_list()







def 	_a      (						):
					__lowerCAmelCase				   =       get_version()
					__lowerCAmelCase				   =       F"""{current_version.major}.{current_version.minor + 1}.0.dev0"""
					__lowerCAmelCase				   =       current_version.base_version

					# Check with the user we got that right.
					__lowerCAmelCase				   =       input(F"""Which version are we developing now? [{dev_version}]"""     )
					if len(SCREAMING_SNAKE_CASE_     ) == 0:
										__lowerCAmelCase				   =       dev_version

					print(F"""Updating version to {version}."""     )
					global_version_update(SCREAMING_SNAKE_CASE_     )
					print("Cleaning main README, don't forget to run `make fix-copies`."     )
					clean_main_ref_in_model_list()


if __name__ == "__main__":
					UpperCamelCase__    			=			argparse.ArgumentParser()
					parser.add_argument("""--post_release""", action="""store_true""", help="""Whether this is pre or post release.""")
					parser.add_argument("""--patch""", action="""store_true""", help="""Whether or not this is a patch release.""")
					UpperCamelCase__    			=			parser.parse_args()
					if not args.post_release:
										pre_release_work(patch=args.patch)
					elif args.patch:
										print("""Nothing to do after a patch :-)""")
					else:
										post_release_work()







import copy
from typing import Any, Dict, List, Optional, Union

import numpy as np

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


lowercase_									=   logging.get_logger(__name__)





class  __lowerCAmelCase     (					SCREAMING_SNAKE_CASE							):
  _a									=  ["""input_features"""]




  def __init__(				self							,   lowerCAmelCase=80							,   lowerCAmelCase=16_000							,   lowerCAmelCase=160							,   lowerCAmelCase=30							,   lowerCAmelCase=400							,   lowerCAmelCase=0.0							,   lowerCAmelCase=False							,   **lowerCAmelCase							,   )  -> Any:
        '''simple docstring'''






        super().__init__(
            feature_size=lowerCAmelCase							,   sampling_rate=lowerCAmelCase							,   padding_value=lowerCAmelCase							,   return_attention_mask=lowerCAmelCase							,   **lowerCAmelCase							,   )
        _lowercase	       =n_fft
        _lowercase	       =hop_length
        _lowercase	       =chunk_length
        _lowercase	       =chunk_length * sampling_rate
        _lowercase	       =self.n_samples // hop_length
        _lowercase	       =sampling_rate
        _lowercase	       =mel_filter_bank(
            num_frequency_bins=1 + n_fft // 2							,   num_mel_filters=lowerCAmelCase							,   min_frequency=0.0							,   max_frequency=8000.0							,   sampling_rate=lowerCAmelCase							,   norm='slaney'							,   mel_scale='slaney'							,   )




  def   A__     (				self							,   lowerCAmelCase					)  -> np.ndarray:
        '''simple docstring'''






        _lowercase	       =spectrogram(
            lowerCAmelCase							,   window_function(self.n_fft							,   'hann'					)							,   frame_length=self.n_fft							,   hop_length=self.hop_length							,   power=2.0							,   mel_filters=self.mel_filters							,   log_mel='log10'							,   )
        _lowercase	       =log_spec[:, :-1]
        _lowercase	       =np.maximum(lowerCAmelCase							,   log_spec.max() - 8.0					)
        _lowercase	       =(log_spec + 4.0) / 4.0
        return log_spec




  @staticmethod
  # Copied from transformers.models.wav2vec2.feature_extraction_wav2vec2.Wav2Vec2FeatureExtractor.zero_mean_unit_var_norm
  def   A__     (				lowerCAmelCase							,   lowerCAmelCase							,   lowerCAmelCase = 0.0					)  -> List[np.ndarray]:
        '''simple docstring'''






        if attention_mask is not None:
              _lowercase	       =np.array(lowerCAmelCase							,   np.intaa					)
              _lowercase	       =[]

              for vector, length in zip(lowerCAmelCase							,   attention_mask.sum(-1					)					):
                    _lowercase	       =(vector - vector[:length].mean()) / np.sqrt(vector[:length].var() + 1e-7					)
                    if length < normed_slice.shape[0]:
                          _lowercase	       =padding_value

                    normed_input_values.append(lowerCAmelCase					)
        else:
              _lowercase	       =[(x - x.mean()) / np.sqrt(x.var() + 1e-7					) for x in input_values]

        return normed_input_values




  def __call__(				self							,   lowerCAmelCase							,   lowerCAmelCase = True							,   lowerCAmelCase = None							,   lowerCAmelCase = None							,   lowerCAmelCase = None							,   lowerCAmelCase = "max_length"							,   lowerCAmelCase = None							,   lowerCAmelCase = None							,   lowerCAmelCase = None							,   **lowerCAmelCase							,   )  -> BatchFeature:
        '''simple docstring'''






        if sampling_rate is not None:
              if sampling_rate != self.sampling_rate:
                    raise ValueError(
                        F'''The model corresponding to this feature extractor: {self.__class__.__name__} was trained using a'''
                        F''' sampling rate of {self.sampling_rate}. Please make sure that the provided `raw_speech` input'''
                        F''' was sampled 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.'					)

        _lowercase	       =isinstance(lowerCAmelCase							,   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}'''					)
        _lowercase	       =is_batched_numpy or (
            isinstance(lowerCAmelCase							,   (list, tuple)					) and (isinstance(raw_speech[0]							,   (np.ndarray, tuple, list)					))
        )

        if is_batched:
              _lowercase	       =[np.asarray([speech]							,   dtype=np.floataa					).T for speech in raw_speech]
        elif not is_batched and not isinstance(lowerCAmelCase							,   np.ndarray					):
              _lowercase	       =np.asarray(lowerCAmelCase							,   dtype=np.floataa					)
        elif isinstance(lowerCAmelCase							,   np.ndarray					) and raw_speech.dtype is np.dtype(np.floataa					):
              _lowercase	       =raw_speech.astype(np.floataa					)

        # always return batch
        if not is_batched:
              _lowercase	       =[np.asarray([raw_speech]					).T]

        _lowercase	       =BatchFeature({'input_features': raw_speech}					)

        # convert into correct format for padding

        _lowercase	       =self.pad(
            lowerCAmelCase							,   padding=lowerCAmelCase							,   max_length=max_length if max_length else self.n_samples							,   truncation=lowerCAmelCase							,   pad_to_multiple_of=lowerCAmelCase							,   return_attention_mask=return_attention_mask or do_normalize							,   )

        # zero-mean and unit-variance normalization
        if do_normalize:
              _lowercase	       =self.zero_mean_unit_var_norm(
                  padded_inputs['input_features']							,   attention_mask=padded_inputs['attention_mask']							,   padding_value=self.padding_value							,   )
              _lowercase	       =np.stack(padded_inputs['input_features']							,   axis=0					)

        # make sure list is in array format
        _lowercase	       =padded_inputs.get('input_features'					).transpose(2							,   0							,   1					)

        _lowercase	       =[self._np_extract_fbank_features(lowerCAmelCase					) for waveform in input_features[0]]

        if isinstance(input_features[0]							,   lowerCAmelCase					):
              _lowercase	       =[np.asarray(lowerCAmelCase							,   dtype=np.floataa					) for feature in input_features]
        else:
              _lowercase	       =input_features

        if return_attention_mask:
              # rescale from sample (48000) to feature (3000)
              _lowercase	       =padded_inputs['attention_mask'][:, :: self.hop_length]

        if return_tensors is not None:
              _lowercase	       =padded_inputs.convert_to_tensors(lowerCAmelCase					)

        return padded_inputs




  def   A__     (				self					)  -> Dict[str, Any]:
        '''simple docstring'''






        _lowercase	       =copy.deepcopy(self.__dict__					)
        _lowercase	       =self.__class__.__name__
        if "mel_filters" in output:
              del output["mel_filters"]
        return output


