





'''simple docstring'''





from ..models.auto import AutoModelForSeqaSeqLM, AutoTokenizer
from .base import PipelineTool


__lowerCamelCase :  Optional[Any]										=  {
    """Acehnese Arabic""": """ace_Arab""",
    """Acehnese Latin""": """ace_Latn""",
    """Mesopotamian Arabic""": """acm_Arab""",
    """Ta'izzi-Adeni Arabic""": """acq_Arab""",
    """Tunisian Arabic""": """aeb_Arab""",
    """Afrikaans""": """afr_Latn""",
    """South Levantine Arabic""": """ajp_Arab""",
    """Akan""": """aka_Latn""",
    """Amharic""": """amh_Ethi""",
    """North Levantine Arabic""": """apc_Arab""",
    """Modern Standard Arabic""": """arb_Arab""",
    """Modern Standard Arabic Romanized""": """arb_Latn""",
    """Najdi Arabic""": """ars_Arab""",
    """Moroccan Arabic""": """ary_Arab""",
    """Egyptian Arabic""": """arz_Arab""",
    """Assamese""": """asm_Beng""",
    """Asturian""": """ast_Latn""",
    """Awadhi""": """awa_Deva""",
    """Central Aymara""": """ayr_Latn""",
    """South Azerbaijani""": """azb_Arab""",
    """North Azerbaijani""": """azj_Latn""",
    """Bashkir""": """bak_Cyrl""",
    """Bambara""": """bam_Latn""",
    """Balinese""": """ban_Latn""",
    """Belarusian""": """bel_Cyrl""",
    """Bemba""": """bem_Latn""",
    """Bengali""": """ben_Beng""",
    """Bhojpuri""": """bho_Deva""",
    """Banjar Arabic""": """bjn_Arab""",
    """Banjar Latin""": """bjn_Latn""",
    """Standard Tibetan""": """bod_Tibt""",
    """Bosnian""": """bos_Latn""",
    """Buginese""": """bug_Latn""",
    """Bulgarian""": """bul_Cyrl""",
    """Catalan""": """cat_Latn""",
    """Cebuano""": """ceb_Latn""",
    """Czech""": """ces_Latn""",
    """Chokwe""": """cjk_Latn""",
    """Central Kurdish""": """ckb_Arab""",
    """Crimean Tatar""": """crh_Latn""",
    """Welsh""": """cym_Latn""",
    """Danish""": """dan_Latn""",
    """German""": """deu_Latn""",
    """Southwestern Dinka""": """dik_Latn""",
    """Dyula""": """dyu_Latn""",
    """Dzongkha""": """dzo_Tibt""",
    """Greek""": """ell_Grek""",
    """English""": """eng_Latn""",
    """Esperanto""": """epo_Latn""",
    """Estonian""": """est_Latn""",
    """Basque""": """eus_Latn""",
    """Ewe""": """ewe_Latn""",
    """Faroese""": """fao_Latn""",
    """Fijian""": """fij_Latn""",
    """Finnish""": """fin_Latn""",
    """Fon""": """fon_Latn""",
    """French""": """fra_Latn""",
    """Friulian""": """fur_Latn""",
    """Nigerian Fulfulde""": """fuv_Latn""",
    """Scottish Gaelic""": """gla_Latn""",
    """Irish""": """gle_Latn""",
    """Galician""": """glg_Latn""",
    """Guarani""": """grn_Latn""",
    """Gujarati""": """guj_Gujr""",
    """Haitian Creole""": """hat_Latn""",
    """Hausa""": """hau_Latn""",
    """Hebrew""": """heb_Hebr""",
    """Hindi""": """hin_Deva""",
    """Chhattisgarhi""": """hne_Deva""",
    """Croatian""": """hrv_Latn""",
    """Hungarian""": """hun_Latn""",
    """Armenian""": """hye_Armn""",
    """Igbo""": """ibo_Latn""",
    """Ilocano""": """ilo_Latn""",
    """Indonesian""": """ind_Latn""",
    """Icelandic""": """isl_Latn""",
    """Italian""": """ita_Latn""",
    """Javanese""": """jav_Latn""",
    """Japanese""": """jpn_Jpan""",
    """Kabyle""": """kab_Latn""",
    """Jingpho""": """kac_Latn""",
    """Kamba""": """kam_Latn""",
    """Kannada""": """kan_Knda""",
    """Kashmiri Arabic""": """kas_Arab""",
    """Kashmiri Devanagari""": """kas_Deva""",
    """Georgian""": """kat_Geor""",
    """Central Kanuri Arabic""": """knc_Arab""",
    """Central Kanuri Latin""": """knc_Latn""",
    """Kazakh""": """kaz_Cyrl""",
    """Kabiyè""": """kbp_Latn""",
    """Kabuverdianu""": """kea_Latn""",
    """Khmer""": """khm_Khmr""",
    """Kikuyu""": """kik_Latn""",
    """Kinyarwanda""": """kin_Latn""",
    """Kyrgyz""": """kir_Cyrl""",
    """Kimbundu""": """kmb_Latn""",
    """Northern Kurdish""": """kmr_Latn""",
    """Kikongo""": """kon_Latn""",
    """Korean""": """kor_Hang""",
    """Lao""": """lao_Laoo""",
    """Ligurian""": """lij_Latn""",
    """Limburgish""": """lim_Latn""",
    """Lingala""": """lin_Latn""",
    """Lithuanian""": """lit_Latn""",
    """Lombard""": """lmo_Latn""",
    """Latgalian""": """ltg_Latn""",
    """Luxembourgish""": """ltz_Latn""",
    """Luba-Kasai""": """lua_Latn""",
    """Ganda""": """lug_Latn""",
    """Luo""": """luo_Latn""",
    """Mizo""": """lus_Latn""",
    """Standard Latvian""": """lvs_Latn""",
    """Magahi""": """mag_Deva""",
    """Maithili""": """mai_Deva""",
    """Malayalam""": """mal_Mlym""",
    """Marathi""": """mar_Deva""",
    """Minangkabau Arabic """: """min_Arab""",
    """Minangkabau Latin""": """min_Latn""",
    """Macedonian""": """mkd_Cyrl""",
    """Plateau Malagasy""": """plt_Latn""",
    """Maltese""": """mlt_Latn""",
    """Meitei Bengali""": """mni_Beng""",
    """Halh Mongolian""": """khk_Cyrl""",
    """Mossi""": """mos_Latn""",
    """Maori""": """mri_Latn""",
    """Burmese""": """mya_Mymr""",
    """Dutch""": """nld_Latn""",
    """Norwegian Nynorsk""": """nno_Latn""",
    """Norwegian Bokmål""": """nob_Latn""",
    """Nepali""": """npi_Deva""",
    """Northern Sotho""": """nso_Latn""",
    """Nuer""": """nus_Latn""",
    """Nyanja""": """nya_Latn""",
    """Occitan""": """oci_Latn""",
    """West Central Oromo""": """gaz_Latn""",
    """Odia""": """ory_Orya""",
    """Pangasinan""": """pag_Latn""",
    """Eastern Panjabi""": """pan_Guru""",
    """Papiamento""": """pap_Latn""",
    """Western Persian""": """pes_Arab""",
    """Polish""": """pol_Latn""",
    """Portuguese""": """por_Latn""",
    """Dari""": """prs_Arab""",
    """Southern Pashto""": """pbt_Arab""",
    """Ayacucho Quechua""": """quy_Latn""",
    """Romanian""": """ron_Latn""",
    """Rundi""": """run_Latn""",
    """Russian""": """rus_Cyrl""",
    """Sango""": """sag_Latn""",
    """Sanskrit""": """san_Deva""",
    """Santali""": """sat_Olck""",
    """Sicilian""": """scn_Latn""",
    """Shan""": """shn_Mymr""",
    """Sinhala""": """sin_Sinh""",
    """Slovak""": """slk_Latn""",
    """Slovenian""": """slv_Latn""",
    """Samoan""": """smo_Latn""",
    """Shona""": """sna_Latn""",
    """Sindhi""": """snd_Arab""",
    """Somali""": """som_Latn""",
    """Southern Sotho""": """sot_Latn""",
    """Spanish""": """spa_Latn""",
    """Tosk Albanian""": """als_Latn""",
    """Sardinian""": """srd_Latn""",
    """Serbian""": """srp_Cyrl""",
    """Swati""": """ssw_Latn""",
    """Sundanese""": """sun_Latn""",
    """Swedish""": """swe_Latn""",
    """Swahili""": """swh_Latn""",
    """Silesian""": """szl_Latn""",
    """Tamil""": """tam_Taml""",
    """Tatar""": """tat_Cyrl""",
    """Telugu""": """tel_Telu""",
    """Tajik""": """tgk_Cyrl""",
    """Tagalog""": """tgl_Latn""",
    """Thai""": """tha_Thai""",
    """Tigrinya""": """tir_Ethi""",
    """Tamasheq Latin""": """taq_Latn""",
    """Tamasheq Tifinagh""": """taq_Tfng""",
    """Tok Pisin""": """tpi_Latn""",
    """Tswana""": """tsn_Latn""",
    """Tsonga""": """tso_Latn""",
    """Turkmen""": """tuk_Latn""",
    """Tumbuka""": """tum_Latn""",
    """Turkish""": """tur_Latn""",
    """Twi""": """twi_Latn""",
    """Central Atlas Tamazight""": """tzm_Tfng""",
    """Uyghur""": """uig_Arab""",
    """Ukrainian""": """ukr_Cyrl""",
    """Umbundu""": """umb_Latn""",
    """Urdu""": """urd_Arab""",
    """Northern Uzbek""": """uzn_Latn""",
    """Venetian""": """vec_Latn""",
    """Vietnamese""": """vie_Latn""",
    """Waray""": """war_Latn""",
    """Wolof""": """wol_Latn""",
    """Xhosa""": """xho_Latn""",
    """Eastern Yiddish""": """ydd_Hebr""",
    """Yoruba""": """yor_Latn""",
    """Yue Chinese""": """yue_Hant""",
    """Chinese Simplified""": """zho_Hans""",
    """Chinese Traditional""": """zho_Hant""",
    """Standard Malay""": """zsm_Latn""",
    """Zulu""": """zul_Latn""",
}



class       A__     ( __snake_case    ):
      _UpperCAmelCase			:int							=     'facebook/nllb-200-distilled-600M'
      _UpperCAmelCase			:int							=     (
          'This is a tool that translates text from a language to another. It takes three inputs: `text`, which should '
          'be the text to translate, `src_lang`, which should be the language of the text to translate and `tgt_lang`, '
          'which should be the language for the desired ouput language. Both `src_lang` and `tgt_lang` are written in '
          'plain English, such as \'Romanian\', or \'Albanian\'. It returns the text translated in `tgt_lang`.'
      )
      _UpperCAmelCase			:List[Any]							=     'translator'
      _UpperCAmelCase			:str							=     AutoTokenizer
      _UpperCAmelCase			:List[Any]							=     AutoModelForSeqaSeqLM
      _UpperCAmelCase			:int							=     LANGUAGE_CODES

      _UpperCAmelCase			:int							=     ['text', 'text', 'text']
      _UpperCAmelCase			:Any							=     ['text']





      def  __UpperCamelCase(				self ,							A_ ,							A_ ,							A_     ):
       '''simple docstring'''




       if src_lang not in self.lang_to_code:
        raise ValueError(F"""{src_lang} is not a supported language."""     )
       if tgt_lang not in self.lang_to_code:
        raise ValueError(F"""{tgt_lang} is not a supported language."""     )
       UpperCamelCase			:      Any 			=     self.lang_to_code[src_lang]
       UpperCamelCase			:      List[str] 			=     self.lang_to_code[tgt_lang]
       return self.pre_processor._build_translation_inputs(
           __a ,							return_tensors="pt" ,							src_lang=__a ,							tgt_lang=__a     )





      def  __UpperCamelCase(				self ,							A_     ):
       '''simple docstring'''




       return self.model.generate(**__a     )





      def  __UpperCamelCase(				self ,							A_     ):
       '''simple docstring'''




       return self.post_processor.decode(outputs[0].tolist() ,							skip_special_tokens=__a     )







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


__lowerCamelCase :  Dict										=  logging.get_logger(__name__)



class       A__     ( __snake_case    ):
      _UpperCAmelCase			:Tuple							=     ['audio_values', 'audio_mask']





      def __init__(				self ,							A_=2048 ,							A_=1 ,							A_=[16, 16] ,							A_=128 ,							A_=4_4100 ,							A_=86 ,							A_=2048 ,							A_=0.0 ,							**A_ ,							):
       '''simple docstring'''




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

       UpperCamelCase			:      Optional[int] 			=     spectrogram_length
       UpperCamelCase			:      Dict 			=     num_channels
       UpperCamelCase			:      Optional[Any] 			=     patch_size
       UpperCamelCase			:      str 			=     feature_size // self.patch_size[1]
       UpperCamelCase			:      List[str] 			=     n_fft
       UpperCamelCase			:      int 			=     sampling_rate // hop_length_to_sampling_rate
       UpperCamelCase			:      Optional[int] 			=     sampling_rate
       UpperCamelCase			:      int 			=     padding_value
       UpperCamelCase			:      str 			=     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'''




       UpperCamelCase			:      Union[str, Any] 			=     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 ,							)
       UpperCamelCase			:      List[Any] 			=     log_spec[:, :-1]
       UpperCamelCase			:      Optional[int] 			=     log_spec - 20.0
       UpperCamelCase			:      str 			=     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."     )

       UpperCamelCase			:      Optional[int] 			=     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}"""     )
       UpperCamelCase			:      Union[str, Any] 			=     is_batched_numpy or (
           isinstance(A_ ,							(list, tuple)     ) and (isinstance(raw_speech[0] ,							(np.ndarray, tuple, list)     ))
       )
       if is_batched:
        UpperCamelCase			:      int 			=     [np.asarray([speech] ,							dtype=np.floataa     ).T for speech in raw_speech]
       elif not is_batched and not isinstance(A_ ,							np.ndarray     ):
        UpperCamelCase			:      str 			=     np.asarray(A_ ,							dtype=np.floataa     )
       elif isinstance(A_ ,							np.ndarray     ) and raw_speech.dtype is np.dtype(np.floataa     ):
        UpperCamelCase			:      List[Any] 			=     raw_speech.astype(np.floataa     )
       # always return batch
       if not is_batched:
        UpperCamelCase			:      Tuple 			=     [np.asarray([raw_speech]     ).T]

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

       # Create audio attention mask
       UpperCamelCase			:      List[str] 			=     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:
        UpperCamelCase			:      str 			=     [
            (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
        ]
        UpperCamelCase			:      Tuple 			=     np.array(A_     ).astype(np.floataa     )

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

       # return as BatchFeature
       if return_attention_mask:
        UpperCamelCase			:      Optional[Any] 			=     {"audio_values": padded_audio_features, "audio_mask": audio_mask}
       else:
        UpperCamelCase			:      int 			=     {"audio_values": padded_audio_features}

       UpperCamelCase			:      Any 			=     BatchFeature(data=A_ ,							tensor_type=A_     )
       return encoded_inputs
