

import json
import os
from functools import lru_cache
from typing import List, Optional, Tuple

import regex as re

from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...utils import logging


_SCREAMING_SNAKE_CASE					:  Any             =      logging.get_logger(__name__)


_SCREAMING_SNAKE_CASE					:  Union[str, Any]             =      {'''vocab_file''': '''vocab.json''', '''merges_file''': '''merges.txt'''}

# See all BART models at https://huggingface.co/models?filter=bart
_SCREAMING_SNAKE_CASE					:  Optional[Any]             =      {
    '''vocab_file''': {
        '''facebook/bart-base''': '''https://huggingface.co/facebook/bart-base/resolve/main/vocab.json''',
        '''facebook/bart-large''': '''https://huggingface.co/facebook/bart-large/resolve/main/vocab.json''',
        '''facebook/bart-large-mnli''': '''https://huggingface.co/facebook/bart-large-mnli/resolve/main/vocab.json''',
        '''facebook/bart-large-cnn''': '''https://huggingface.co/facebook/bart-large-cnn/resolve/main/vocab.json''',
        '''facebook/bart-large-xsum''': '''https://huggingface.co/facebook/bart-large-xsum/resolve/main/vocab.json''',
        '''yjernite/bart_eli5''': '''https://huggingface.co/yjernite/bart_eli5/resolve/main/vocab.json''',
    },
    '''merges_file''': {
        '''facebook/bart-base''': '''https://huggingface.co/facebook/bart-base/resolve/main/merges.txt''',
        '''facebook/bart-large''': '''https://huggingface.co/facebook/bart-large/resolve/main/merges.txt''',
        '''facebook/bart-large-mnli''': '''https://huggingface.co/facebook/bart-large-mnli/resolve/main/merges.txt''',
        '''facebook/bart-large-cnn''': '''https://huggingface.co/facebook/bart-large-cnn/resolve/main/merges.txt''',
        '''facebook/bart-large-xsum''': '''https://huggingface.co/facebook/bart-large-xsum/resolve/main/merges.txt''',
        '''yjernite/bart_eli5''': '''https://huggingface.co/yjernite/bart_eli5/resolve/main/merges.txt''',
    },
}

_SCREAMING_SNAKE_CASE					:  List[Any]             =      {
    '''facebook/bart-base''': 1024,
    '''facebook/bart-large''': 1024,
    '''facebook/bart-large-mnli''': 1024,
    '''facebook/bart-large-cnn''': 1024,
    '''facebook/bart-large-xsum''': 1024,
    '''yjernite/bart_eli5''': 1024,
}
@lru_cache()
def     UpperCAmelCase_       (						):





       '''simple docstring'''




       SCREAMING_SNAKE_CASE__   =   (
           list(range(ord('''!'''    )				,		ord('''~'''    ) + 1    )    ) + list(range(ord('''¡'''    )				,		ord('''¬'''    ) + 1    )    ) + list(range(ord('''®'''    )				,		ord('''ÿ'''    ) + 1    )    )
       )
       SCREAMING_SNAKE_CASE__   =   bs[:]
       SCREAMING_SNAKE_CASE__   =   0
       for b in range(2**8    ):
              if b not in bs:
                     bs.append(_A    )
                     cs.append(2**8 + n    )
                     n += 1
       SCREAMING_SNAKE_CASE__   =   [chr(_A    ) for n in cs]
       return dict(zip(_A				,		_A    )    )
def     UpperCAmelCase_       (						_A    ):





       '''simple docstring'''




       SCREAMING_SNAKE_CASE__   =   set()
       SCREAMING_SNAKE_CASE__   =   word[0]
       for char in word[1:]:
              pairs.add((prev_char, char)    )
              SCREAMING_SNAKE_CASE__   =   char
       return pairs







class 	UpperCAmelCase__		(	A__	):






  """simple docstring"""


  a									= VOCAB_FILES_NAMES
  a									= PRETRAINED_VOCAB_FILES_MAP
  a									= PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
  a									= ["input_ids", "attention_mask"]






  def __init__(							self						:		Union[str, Any]     ,       __lowerCamelCase						:		Any     ,       __lowerCamelCase						:		Optional[int]     ,       __lowerCamelCase						:		Optional[int]="replace"     ,       __lowerCamelCase						:		List[str]="<s>"     ,       __lowerCamelCase						:		Tuple="</s>"     ,       __lowerCamelCase						:		Union[str, Any]="</s>"     ,       __lowerCamelCase						:		str="<s>"     ,       __lowerCamelCase						:		Optional[int]="<unk>"     ,       __lowerCamelCase						:		Union[str, Any]="<pad>"     ,       __lowerCamelCase						:		List[Any]="<mask>"     ,       __lowerCamelCase						:		List[str]=False     ,       **__lowerCamelCase						:		Optional[int]     ,       )		->							List[str]:
         SCREAMING_SNAKE_CASE__   =   AddedToken(__lowerCamelCase     ,       lstrip=__lowerCamelCase     ,       rstrip=__lowerCamelCase ) if isinstance(__lowerCamelCase     ,       __lowerCamelCase ) else bos_token
         SCREAMING_SNAKE_CASE__   =   AddedToken(__lowerCamelCase     ,       lstrip=__lowerCamelCase     ,       rstrip=__lowerCamelCase ) if isinstance(__lowerCamelCase     ,       __lowerCamelCase ) else eos_token
         SCREAMING_SNAKE_CASE__   =   AddedToken(__lowerCamelCase     ,       lstrip=__lowerCamelCase     ,       rstrip=__lowerCamelCase ) if isinstance(__lowerCamelCase     ,       __lowerCamelCase ) else sep_token
         SCREAMING_SNAKE_CASE__   =   AddedToken(__lowerCamelCase     ,       lstrip=__lowerCamelCase     ,       rstrip=__lowerCamelCase ) if isinstance(__lowerCamelCase     ,       __lowerCamelCase ) else cls_token
         SCREAMING_SNAKE_CASE__   =   AddedToken(__lowerCamelCase     ,       lstrip=__lowerCamelCase     ,       rstrip=__lowerCamelCase ) if isinstance(__lowerCamelCase     ,       __lowerCamelCase ) else unk_token
         SCREAMING_SNAKE_CASE__   =   AddedToken(__lowerCamelCase     ,       lstrip=__lowerCamelCase     ,       rstrip=__lowerCamelCase ) if isinstance(__lowerCamelCase     ,       __lowerCamelCase ) else pad_token

         # Mask token behave like a normal word, i.e. include the space before it
         SCREAMING_SNAKE_CASE__   =   AddedToken(__lowerCamelCase     ,       lstrip=__lowerCamelCase     ,       rstrip=__lowerCamelCase ) if isinstance(__lowerCamelCase     ,       __lowerCamelCase ) else mask_token

         super().__init__(
             errors=__lowerCamelCase     ,       bos_token=__lowerCamelCase     ,       eos_token=__lowerCamelCase     ,       unk_token=__lowerCamelCase     ,       sep_token=__lowerCamelCase     ,       cls_token=__lowerCamelCase     ,       pad_token=__lowerCamelCase     ,       mask_token=__lowerCamelCase     ,       add_prefix_space=__lowerCamelCase     ,       **__lowerCamelCase     ,       )

         with open(__lowerCamelCase     ,       encoding='''utf-8''' ) as vocab_handle:
                SCREAMING_SNAKE_CASE__   =   json.load(__lowerCamelCase )
         SCREAMING_SNAKE_CASE__   =   {v: k for k, v in self.encoder.items()}
         SCREAMING_SNAKE_CASE__   =   errors  # how to handle errors in decoding
         SCREAMING_SNAKE_CASE__   =   bytes_to_unicode()
         SCREAMING_SNAKE_CASE__   =   {v: k for k, v in self.byte_encoder.items()}
         with open(__lowerCamelCase     ,       encoding='''utf-8''' ) as merges_handle:
                SCREAMING_SNAKE_CASE__   =   merges_handle.read().split('''\n''' )[1:-1]
         SCREAMING_SNAKE_CASE__   =   [tuple(merge.split() ) for merge in bpe_merges]
         SCREAMING_SNAKE_CASE__   =   dict(zip(__lowerCamelCase     ,       range(len(__lowerCamelCase ) ) ) )
         SCREAMING_SNAKE_CASE__   =   {}
         SCREAMING_SNAKE_CASE__   =   add_prefix_space

         # Should have added re.IGNORECASE so BPE merges can happen for capitalized versions of contractions
         SCREAMING_SNAKE_CASE__   =   re.compile(r'''\'s|\'t|\'re|\'ve|\'m|\'ll|\'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+''' )






  @property
  def 				lowercase_		(							self						:		Any )		->							int:
         return len(self.encoder )






  def 				lowercase_		(							self						:		List[str] )		->							str:
         return dict(self.encoder     ,       **self.added_tokens_encoder )






  def 				lowercase_		(							self						:		Any     ,       __lowerCamelCase						:		int )		->							Dict:
         if token in self.cache:
                return self.cache[token]
         SCREAMING_SNAKE_CASE__   =   tuple(__lowerCamelCase )
         SCREAMING_SNAKE_CASE__   =   get_pairs(__lowerCamelCase )

         if not pairs:
                return token

         while True:
                SCREAMING_SNAKE_CASE__   =   min(__lowerCamelCase     ,       key=lambda __lowerCamelCase : self.bpe_ranks.get(__lowerCamelCase     ,       float('''inf''' ) ) )
                if bigram not in self.bpe_ranks:
                       break
                SCREAMING_SNAKE_CASE__,SCREAMING_SNAKE_CASE__   =   bigram
                SCREAMING_SNAKE_CASE__   =   []
                SCREAMING_SNAKE_CASE__   =   0
                while i < len(__lowerCamelCase ):
                       try:
                              SCREAMING_SNAKE_CASE__   =   word.index(__lowerCamelCase     ,       __lowerCamelCase )
                       except ValueError:
                              new_word.extend(word[i:] )
                              break
                       else:
                              new_word.extend(word[i:j] )
                              SCREAMING_SNAKE_CASE__   =   j

                       if word[i] == first and i < len(__lowerCamelCase ) - 1 and word[i + 1] == second:
                              new_word.append(first + second )
                              i += 2
                       else:
                              new_word.append(word[i] )
                              i += 1
                SCREAMING_SNAKE_CASE__   =   tuple(__lowerCamelCase )
                SCREAMING_SNAKE_CASE__   =   new_word
                if len(__lowerCamelCase ) == 1:
                       break
                else:
                       SCREAMING_SNAKE_CASE__   =   get_pairs(__lowerCamelCase )
         SCREAMING_SNAKE_CASE__   =   ''' '''.join(__lowerCamelCase )
         SCREAMING_SNAKE_CASE__   =   word
         return word






  def 				lowercase_		(							self						:		Union[str, Any]     ,       __lowerCamelCase						:		Optional[int] )		->							Tuple:
         SCREAMING_SNAKE_CASE__   =   []
         for token in re.findall(self.pat     ,       __lowerCamelCase ):
                SCREAMING_SNAKE_CASE__   =   ''''''.join(
                    self.byte_encoder[b] for b in token.encode('''utf-8''' ) )  # Maps all our bytes to unicode strings, avoiding control tokens of the BPE (spaces in our case)
                bpe_tokens.extend(bpe_token for bpe_token in self.bpe(__lowerCamelCase ).split(''' ''' ) )
         return bpe_tokens






  def 				lowercase_		(							self						:		int     ,       __lowerCamelCase						:		Any )		->							List[str]:
         return self.encoder.get(__lowerCamelCase     ,       self.encoder.get(self.unk_token ) )






  def 				lowercase_		(							self						:		List[str]     ,       __lowerCamelCase						:		str )		->							Optional[int]:
         return self.decoder.get(__lowerCamelCase )






  def 				lowercase_		(							self						:		Any     ,       __lowerCamelCase						:		Tuple )		->							List[Any]:
         SCREAMING_SNAKE_CASE__   =   ''''''.join(__lowerCamelCase )
         SCREAMING_SNAKE_CASE__   =   bytearray([self.byte_decoder[c] for c in text] ).decode('''utf-8'''     ,       errors=self.errors )
         return text






  def 				lowercase_		(							self						:		List[str]     ,       __lowerCamelCase						:		str     ,       __lowerCamelCase						:		Optional[str] = None )		->							Tuple[str]:
         if not os.path.isdir(__lowerCamelCase ):
                logger.error(f'''Vocabulary path ({save_directory}) should be a directory''' )
                return
         SCREAMING_SNAKE_CASE__   =   os.path.join(
             __lowerCamelCase     ,       (filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''vocab_file'''] )
         SCREAMING_SNAKE_CASE__   =   os.path.join(
             __lowerCamelCase     ,       (filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''merges_file'''] )

         with open(__lowerCamelCase     ,       '''w'''     ,       encoding='''utf-8''' ) as f:
                f.write(json.dumps(self.encoder     ,       indent=2     ,       sort_keys=__lowerCamelCase     ,       ensure_ascii=__lowerCamelCase ) + '''\n''' )

         SCREAMING_SNAKE_CASE__   =   0
         with open(__lowerCamelCase     ,       '''w'''     ,       encoding='''utf-8''' ) as writer:
                writer.write('''#version: 0.2\n''' )
                for bpe_tokens, token_index in sorted(self.bpe_ranks.items()     ,       key=lambda __lowerCamelCase : kv[1] ):
                       if index != token_index:
                              logger.warning(
                                  f'''Saving vocabulary to {merge_file}: BPE merge indices are not consecutive.'''
                                  ''' Please check that the tokenizer is not corrupted!''' )
                              SCREAMING_SNAKE_CASE__   =   token_index
                       writer.write(''' '''.join(__lowerCamelCase ) + '''\n''' )
                       index += 1

         return vocab_file, merge_file






  def 				lowercase_		(							self						:		int     ,       __lowerCamelCase						:		List[int]     ,       __lowerCamelCase						:		Optional[List[int]] = None )		->							List[int]:
         if token_ids_a is None:
                return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
         SCREAMING_SNAKE_CASE__   =   [self.cls_token_id]
         SCREAMING_SNAKE_CASE__   =   [self.sep_token_id]
         return cls + token_ids_a + sep + sep + token_ids_a + sep






  def 				lowercase_		(							self						:		List[str]     ,       __lowerCamelCase						:		List[int]     ,       __lowerCamelCase						:		Optional[List[int]] = None     ,       __lowerCamelCase						:		bool = False )		->							List[int]:
         if already_has_special_tokens:
                return super().get_special_tokens_mask(
                    token_ids_a=__lowerCamelCase     ,       token_ids_a=__lowerCamelCase     ,       already_has_special_tokens=__lowerCamelCase )

         if token_ids_a is None:
                return [1] + ([0] * len(__lowerCamelCase )) + [1]
         return [1] + ([0] * len(__lowerCamelCase )) + [1, 1] + ([0] * len(__lowerCamelCase )) + [1]






  def 				lowercase_		(							self						:		List[Any]     ,       __lowerCamelCase						:		List[int]     ,       __lowerCamelCase						:		Optional[List[int]] = None )		->							List[int]:
         SCREAMING_SNAKE_CASE__   =   [self.sep_token_id]
         SCREAMING_SNAKE_CASE__   =   [self.cls_token_id]

         if token_ids_a is None:
                return len(cls + token_ids_a + sep ) * [0]
         return len(cls + token_ids_a + sep + sep + token_ids_a + sep ) * [0]







  def 				lowercase_		(							self						:		Union[str, Any]     ,       __lowerCamelCase						:		Any     ,       __lowerCamelCase						:		Union[str, Any]=False     ,       **__lowerCamelCase						:		List[str] )		->							List[str]:
         SCREAMING_SNAKE_CASE__   =   kwargs.pop('''add_prefix_space'''     ,       self.add_prefix_space )
         if (is_split_into_words or add_prefix_space) and (len(__lowerCamelCase ) > 0 and not text[0].isspace()):
                SCREAMING_SNAKE_CASE__   =   ''' ''' + text
         return (text, kwargs)





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


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






class 	UpperCAmelCase__		(	A__	):






  """simple docstring"""


  a									= ["input_features"]






  def __init__(							self						:		Dict     ,       __lowerCamelCase						:		Tuple=80     ,       __lowerCamelCase						:		List[Any]=1_6000     ,       __lowerCamelCase						:		Optional[int]=160     ,       __lowerCamelCase						:		List[str]=30     ,       __lowerCamelCase						:		List[Any]=400     ,       __lowerCamelCase						:		Union[str, Any]=0.0     ,       __lowerCamelCase						:		str=False     ,       **__lowerCamelCase						:		List[str]     ,       )		->							Any:
       super().__init__(
           feature_size=__lowerCamelCase     ,       sampling_rate=__lowerCamelCase     ,       padding_value=__lowerCamelCase     ,       return_attention_mask=__lowerCamelCase     ,       **__lowerCamelCase     ,       )
       SCREAMING_SNAKE_CASE__   =   n_fft
       SCREAMING_SNAKE_CASE__   =   hop_length
       SCREAMING_SNAKE_CASE__   =   chunk_length
       SCREAMING_SNAKE_CASE__   =   chunk_length * sampling_rate
       SCREAMING_SNAKE_CASE__   =   self.n_samples // hop_length
       SCREAMING_SNAKE_CASE__   =   sampling_rate
       SCREAMING_SNAKE_CASE__   =   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 				lowercase_		(							self						:		int     ,       __lowerCamelCase						:		np.array )		->							np.ndarray:
       SCREAMING_SNAKE_CASE__   =   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'''     ,       )
       SCREAMING_SNAKE_CASE__   =   log_spec[:, :-1]
       SCREAMING_SNAKE_CASE__   =   np.maximum(__lowerCamelCase     ,       log_spec.max() - 8.0 )
       SCREAMING_SNAKE_CASE__   =   (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 				lowercase_		(							__lowerCamelCase						:		List[np.ndarray]     ,       __lowerCamelCase						:		List[np.ndarray]     ,       __lowerCamelCase						:		float = 0.0 )		->							List[np.ndarray]:
       if attention_mask is not None:
            SCREAMING_SNAKE_CASE__   =   np.array(__lowerCamelCase     ,       np.intaa )
            SCREAMING_SNAKE_CASE__   =   []

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

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

       return normed_input_values






  def __call__(							self						:		List[str]     ,       __lowerCamelCase						:		Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]     ,       __lowerCamelCase						:		bool = True     ,       __lowerCamelCase						:		Optional[int] = None     ,       __lowerCamelCase						:		Optional[Union[str, TensorType]] = None     ,       __lowerCamelCase						:		Optional[bool] = None     ,       __lowerCamelCase						:		Optional[str] = "max_length"     ,       __lowerCamelCase						:		Optional[int] = None     ,       __lowerCamelCase						:		Optional[int] = None     ,       __lowerCamelCase						:		Optional[bool] = None     ,       **__lowerCamelCase						:		List[str]     ,       )		->							BatchFeature:

       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.''' )

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

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

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

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

       # convert into correct format for padding

       SCREAMING_SNAKE_CASE__   =   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:
            SCREAMING_SNAKE_CASE__   =   self.zero_mean_unit_var_norm(
                padded_inputs['''input_features''']     ,       attention_mask=padded_inputs['''attention_mask''']     ,       padding_value=self.padding_value     ,       )
            SCREAMING_SNAKE_CASE__   =   np.stack(padded_inputs['''input_features''']     ,       axis=0 )

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

       SCREAMING_SNAKE_CASE__   =   [self._np_extract_fbank_features(__lowerCamelCase ) for waveform in input_features[0]]

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

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

       if return_tensors is not None:
            SCREAMING_SNAKE_CASE__   =   padded_inputs.convert_to_tensors(__lowerCamelCase )

       return padded_inputs







  def 				lowercase_		(							self						:		str )		->							Dict[str, Any]:
       SCREAMING_SNAKE_CASE__   =   copy.deepcopy(self.__dict__ )
       SCREAMING_SNAKE_CASE__   =   self.__class__.__name__
       if "mel_filters" in output:
            del output["mel_filters"]
       return output


