





'''simple docstring'''






from typing import List, Optional, Union

import numpy as np
import torch
import torchaudio.compliance.kaldi as ta_kaldi

from ...feature_extraction_sequence_utils import SequenceFeatureExtractor
from ...feature_extraction_utils import BatchFeature
from ...utils import PaddingStrategy, TensorType, logging


__UpperCamelCase					    =	logging.get_logger(__name__)




class  _A (					__lowercase		):
		lowercase__:   Optional[int]				     =   ['''input_features''', '''attention_mask''']

		def __init__(   self					:   Union[str, Any]  ,      __magic_name__					:   str=80  ,      __magic_name__					:   Any=1_60_00  ,      __magic_name__					:   Dict=80  ,      __magic_name__					:   Optional[int]=0.0  ,      __magic_name__					:   List[str]=True  ,      __magic_name__					:   List[Any]=True  ,      __magic_name__					:   Optional[int]=True  ,      **__magic_name__					:   int  ,      )					->    Optional[Any]:


					"""simple docstring"""

					super().__init__(feature_size=__magic_name__  ,      sampling_rate=__magic_name__  ,      padding_value=__magic_name__  ,      **__magic_name__			)
					__snake_case					:      Optional[int]							      =     num_mel_bins
					__snake_case					:      int							      =     do_ceptral_normalize
					__snake_case					:      Union[str, Any]							      =     normalize_means
					__snake_case					:      Dict							      =     normalize_vars
					__snake_case					:      Union[str, Any]							      =     True

		def 	lowercase__     (   self					:   Dict  ,      __magic_name__					:   np.ndarray  ,      )					->    np.ndarray:


					"""simple docstring"""

					__snake_case					:      Tuple							      =     waveform * (2**15)  # Kaldi compliance: 16-bit signed integers
					__snake_case					:      Union[str, Any]							      =     torch.from_numpy(__magic_name__			).unsqueeze(0			)
					__snake_case					:      Any							      =     ta_kaldi.fbank(__magic_name__  ,      num_mel_bins=self.num_mel_bins  ,      sample_frequency=self.sampling_rate			)
					return features.numpy()

		@staticmethod
		def 	lowercase__     (   __magic_name__					:   np.ndarray  ,      __magic_name__					:   int  ,      __magic_name__					:   Optional[bool] = True  ,      __magic_name__					:   Optional[bool] = True  ,      __magic_name__					:   float = 0.0  ,      )					->    np.ndarray:


					"""simple docstring"""

					if normalize_means:
								__snake_case					:      Optional[Any]							      =     x[:input_length].mean(axis=0			)
								__snake_case					:      Tuple							      =     np.subtract(__magic_name__  ,      __magic_name__			)
					if normalize_vars:
								__snake_case					:      Optional[Any]							      =     x[:input_length].std(axis=0			)
								__snake_case					:      Tuple							      =     np.divide(__magic_name__  ,      __magic_name__			)

					if input_length < x.shape[0]:
								__snake_case					:      Optional[Any]							      =     padding_value

					# make sure array is in float32
					__snake_case					:      Union[str, Any]							      =     x.astype(np.floataa			)

					return x

		def 	lowercase__     (   self					:   Dict  ,      __magic_name__					:   List[np.ndarray]  ,      __magic_name__					:   Optional[np.ndarray] = None			)					->    List[np.ndarray]:


					"""simple docstring"""

					__snake_case					:      Union[str, Any]							      =     attention_mask.sum(-1			) if attention_mask is not None else [x.shape[0] for x in input_features]
					return [
					    self.utterance_cmvn(__magic_name__  ,      __magic_name__  ,      self.normalize_means  ,      self.normalize_vars  ,      self.padding_value			)
					    for x, n in zip(__magic_name__  ,      __magic_name__			)
					]

		def __call__(   self					:   Optional[int]  ,      __magic_name__					:   Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]  ,      __magic_name__					:   Union[bool, str, PaddingStrategy] = False  ,      __magic_name__					:   Optional[int] = None  ,      __magic_name__					:   bool = False  ,      __magic_name__					:   Optional[int] = None  ,      __magic_name__					:   Optional[Union[str, TensorType]] = None  ,      __magic_name__					:   Optional[int] = None  ,      __magic_name__					:   Optional[bool] = None  ,      **__magic_name__					:   Dict  ,      )					->    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} was trained using a sampling rate of'''
											    f''' {self.sampling_rate}. Please make sure that the provided `raw_speech` input was sampled with'''
											    f''' {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."""			)

					__snake_case					:      Any							      =     isinstance(__magic_name__  ,      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}'''			)
					__snake_case					:      Dict							      =     is_batched_numpy or (
					    isinstance(__magic_name__  ,      (list, tuple)			) and (isinstance(raw_speech[0]  ,      (np.ndarray, tuple, list)			))
					)

					if is_batched:
								__snake_case					:      Optional[int]							      =     [np.asarray(__magic_name__  ,      dtype=np.floataa			) for speech in raw_speech]
					elif not is_batched and not isinstance(__magic_name__  ,      np.ndarray			):
								__snake_case					:      str							      =     np.asarray(__magic_name__  ,      dtype=np.floataa			)
					elif isinstance(__magic_name__  ,      np.ndarray			) and raw_speech.dtype is np.dtype(np.floataa			):
								__snake_case					:      Optional[Any]							      =     raw_speech.astype(np.floataa			)

					# always return batch
					if not is_batched:
								__snake_case					:      int							      =     [raw_speech]

					# extract fbank features
					__snake_case					:      Optional[int]							      =     [self._extract_fbank_features(__magic_name__			) for waveform in raw_speech]

					# convert into correct format for padding
					__snake_case					:      List[str]							      =     BatchFeature({"""input_features""": features}			)

					__snake_case					:      Optional[Any]							      =     self.pad(
					    __magic_name__  ,      padding=__magic_name__  ,      max_length=__magic_name__  ,      truncation=__magic_name__  ,      pad_to_multiple_of=__magic_name__  ,      return_attention_mask=__magic_name__  ,      **__magic_name__  ,      )

					# make sure list is in array format
					__snake_case					:      List[Any]							      =     padded_inputs.get("""input_features"""			)
					if isinstance(input_features[0]  ,      __magic_name__			):
								__snake_case					:      Dict							      =     [np.asarray(__magic_name__  ,      dtype=np.floataa			) for feature in input_features]

					__snake_case					:      Optional[Any]							      =     padded_inputs.get("""attention_mask"""			)
					if attention_mask is not None:
								__snake_case					:      Union[str, Any]							      =     [np.asarray(__magic_name__  ,      dtype=np.intaa			) for array in attention_mask]

					# Utterance-level cepstral mean and variance normalization
					if self.do_ceptral_normalize:
								__snake_case					:      List[Any]							      =     (
								    np.array(__magic_name__  ,      dtype=np.intaa			)
								    if self._get_padding_strategies(__magic_name__  ,      max_length=__magic_name__			) is not PaddingStrategy.DO_NOT_PAD
								    else None
								)
								__snake_case					:      int							      =     self.normalize(
								    padded_inputs["""input_features"""]  ,      attention_mask=__magic_name__			)

					if return_tensors is not None:
								__snake_case					:      Union[str, Any]							      =     padded_inputs.convert_to_tensors(__magic_name__			)

					return padded_inputs








from google.protobuf import descriptor as _descriptor
from google.protobuf import descriptor_pool as _descriptor_pool
from google.protobuf import symbol_database as _symbol_database
from google.protobuf.internal import builder as _builder


# @@protoc_insertion_point(imports)

SCREAMING_SNAKE_CASE:     str									= _symbol_database.Default()


SCREAMING_SNAKE_CASE:     Dict									= _descriptor_pool.Default().AddSerializedFile(
    b'''\n\x19sentencepiece_model.proto\x12\rsentencepiece"\x80\x0c\n\x0bTrainerSpec\x12\r\n\x05input\x18\x01 \x03(\t\x12\x14\n\x0cinput_format\x18\x07 \x01(\t\x12\x14\n\x0cmodel_prefix\x18\x02 \x01(\t\x12\x41\n\nmodel_type\x18\x03 \x01(\x0e\x32$.sentencepiece.TrainerSpec.ModelType:\x07UNIGRAM\x12\x18\n\nvocab_size\x18\x04 \x01(\x05:\x04\x38\x30\x30\x30\x12\x17\n\x0f\x61\x63\x63\x65pt_language\x18\x05 \x03(\t\x12 \n\x15self_test_sample_size\x18\x06 \x01(\x05:\x01\x30\x12*\n\x1b\x65nable_differential_privacy\x18\x32 \x01(\x08:\x05\x66\x61lse\x12+\n differential_privacy_noise_level\x18\x33 \x01(\x02:\x01\x30\x12\x32\n\'differential_privacy_clipping_threshold\x18\x34 \x01(\x04:\x01\x30\x12"\n\x12\x63haracter_coverage\x18\n \x01(\x02:\x06\x30.9995\x12\x1e\n\x13input_sentence_size\x18\x0b \x01(\x04:\x01\x30\x12$\n\x16shuffle_input_sentence\x18\x13 \x01(\x08:\x04true\x12 \n\x14mining_sentence_size\x18\x0c \x01(\x05\x42\x02\x18\x01\x12"\n\x16training_sentence_size\x18\r \x01(\x05\x42\x02\x18\x01\x12(\n\x17seed_sentencepiece_size\x18\x0e \x01(\x05:\x07\x31\x30\x30\x30\x30\x30\x30\x12\x1e\n\x10shrinking_factor\x18\x0f \x01(\x02:\x04\x30.75\x12!\n\x13max_sentence_length\x18\x12 \x01(\x05:\x04\x34\x31\x39\x32\x12\x17\n\x0bnum_threads\x18\x10 \x01(\x05:\x02\x31\x36\x12\x1d\n\x12num_sub_iterations\x18\x11 \x01(\x05:\x01\x32\x12$\n\x18max_sentencepiece_length\x18\x14 \x01(\x05:\x02\x31\x36\x12%\n\x17split_by_unicode_script\x18\x15 \x01(\x08:\x04true\x12\x1d\n\x0fsplit_by_number\x18\x17 \x01(\x08:\x04true\x12!\n\x13split_by_whitespace\x18\x16 \x01(\x08:\x04true\x12)\n\x1atreat_whitespace_as_suffix\x18\x18 \x01(\x08:\x05\x66\x61lse\x12+\n\x1c\x61llow_whitespace_only_pieces\x18\x1a \x01(\x08:\x05\x66\x61lse\x12\x1b\n\x0csplit_digits\x18\x19 \x01(\x08:\x05\x66\x61lse\x12#\n\x19pretokenization_delimiter\x18\x35 \x01(\t:\x00\x12\x17\n\x0f\x63ontrol_symbols\x18\x1e \x03(\t\x12\x1c\n\x14user_defined_symbols\x18\x1f \x03(\t\x12\x16\n\x0erequired_chars\x18$ \x01(\t\x12\x1c\n\rbyte_fallback\x18# \x01(\x08:\x05\x66\x61lse\x12+\n\x1dvocabulary_output_piece_score\x18  \x01(\x08:\x04true\x12\x1e\n\x10hard_vocab_limit\x18! \x01(\x08:\x04true\x12\x1c\n\ruse_all_vocab\x18" \x01(\x08:\x05\x66\x61lse\x12\x11\n\x06unk_id\x18( \x01(\x05:\x01\x30\x12\x11\n\x06\x62os_id\x18) \x01(\x05:\x01\x31\x12\x11\n\x06\x65os_id\x18* \x01(\x05:\x01\x32\x12\x12\n\x06pad_id\x18+ \x01(\x05:\x02-1\x12\x18\n\tunk_piece\x18- \x01(\t:\x05<unk>\x12\x16\n\tbos_piece\x18. \x01(\t:\x03<s>\x12\x17\n\teos_piece\x18/ \x01(\t:\x04</s>\x12\x18\n\tpad_piece\x18\x30 \x01(\t:\x05<pad>\x12\x1a\n\x0bunk_surface\x18, \x01(\t:\x05 \xe2\x81\x87 \x12+\n\x1ctrain_extremely_large_corpus\x18\x31 \x01(\x08:\x05\x66\x61lse"5\n\tModelType\x12\x0b\n\x07UNIGRAM\x10\x01\x12\x07\n\x03\x42PE\x10\x02\x12\x08\n\x04WORD\x10\x03\x12\x08\n\x04\x43HAR\x10\x04*\t\x08\xc8\x01\x10\x80\x80\x80\x80\x02"\xd1\x01\n\x0eNormalizerSpec\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x1c\n\x14precompiled_charsmap\x18\x02 \x01(\x0c\x12\x1e\n\x10\x61\x64\x64_dummy_prefix\x18\x03 \x01(\x08:\x04true\x12&\n\x18remove_extra_whitespaces\x18\x04 \x01(\x08:\x04true\x12 \n\x12\x65scape_whitespaces\x18\x05 \x01(\x08:\x04true\x12\x1e\n\x16normalization_rule_tsv\x18\x06 \x01(\t*\t\x08\xc8\x01\x10\x80\x80\x80\x80\x02"y\n\x0cSelfTestData\x12\x33\n\x07samples\x18\x01 \x03(\x0b\x32".sentencepiece.SelfTestData.Sample\x1a)\n\x06Sample\x12\r\n\x05input\x18\x01 \x01(\t\x12\x10\n\x08\x65xpected\x18\x02 \x01(\t*\t\x08\xc8\x01\x10\x80\x80\x80\x80\x02"\xfe\x03\n\nModelProto\x12\x37\n\x06pieces\x18\x01 \x03(\x0b\x32\'.sentencepiece.ModelProto.SentencePiece\x12\x30\n\x0ctrainer_spec\x18\x02 \x01(\x0b\x32\x1a.sentencepiece.TrainerSpec\x12\x36\n\x0fnormalizer_spec\x18\x03 \x01(\x0b\x32\x1d.sentencepiece.NormalizerSpec\x12\x33\n\x0eself_test_data\x18\x04 \x01(\x0b\x32\x1b.sentencepiece.SelfTestData\x12\x38\n\x11\x64\x65normalizer_spec\x18\x05 \x01(\x0b\x32\x1d.sentencepiece.NormalizerSpec\x1a\xd2\x01\n\rSentencePiece\x12\r\n\x05piece\x18\x01 \x01(\t\x12\r\n\x05score\x18\x02 \x01(\x02\x12\x42\n\x04type\x18\x03 \x01(\x0e\x32,.sentencepiece.ModelProto.SentencePiece.Type:\x06NORMAL"T\n\x04Type\x12\n\n\x06NORMAL\x10\x01\x12\x0b\n\x07UNKNOWN\x10\x02\x12\x0b\n\x07\x43ONTROL\x10\x03\x12\x10\n\x0cUSER_DEFINED\x10\x04\x12\x08\n\x04\x42YTE\x10\x06\x12\n\n\x06UNUSED\x10\x05*\t\x08\xc8\x01\x10\x80\x80\x80\x80\x02*\t\x08\xc8\x01\x10\x80\x80\x80\x80\x02\x42\x02H\x03'''
)

SCREAMING_SNAKE_CASE:     Optional[Any]									= globals()
_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, '''sentencepiece_model_pb2''', _globals)
if _descriptor._USE_C_DESCRIPTORS is False:
						SCREAMING_SNAKE_CASE:     List[Any]									= None
						SCREAMING_SNAKE_CASE:     str									= b'''H\003'''
						# (generated by protobuf compiler, but `_TRAINERSPEC` is not defined)
						# _TRAINERSPEC.fields_by_name["mining_sentence_size"]._options = None
						# _TRAINERSPEC.fields_by_name["mining_sentence_size"]._serialized_options = b"\030\001"
						# _TRAINERSPEC.fields_by_name["training_sentence_size"]._options = None
						# _TRAINERSPEC.fields_by_name["training_sentence_size"]._serialized_options = b"\030\001"
						SCREAMING_SNAKE_CASE:     List[Any]									= 4_5
						SCREAMING_SNAKE_CASE:     List[Any]									= 1_5_8_1
						SCREAMING_SNAKE_CASE:     Union[str, Any]									= 1_5_1_7
						SCREAMING_SNAKE_CASE:     Any									= 1_5_7_0
						SCREAMING_SNAKE_CASE:     Union[str, Any]									= 1_5_8_4
						SCREAMING_SNAKE_CASE:     str									= 1_7_9_3
						SCREAMING_SNAKE_CASE:     List[Any]									= 1_7_9_5
						SCREAMING_SNAKE_CASE:     Any									= 1_9_1_6
						SCREAMING_SNAKE_CASE:     Optional[Any]									= 1_8_6_4
						SCREAMING_SNAKE_CASE:     Union[str, Any]									= 1_9_0_5
						SCREAMING_SNAKE_CASE:     str									= 1_9_1_9
						SCREAMING_SNAKE_CASE:     Any									= 2_4_2_9
						SCREAMING_SNAKE_CASE:     Dict									= 2_2_0_8
						SCREAMING_SNAKE_CASE:     Optional[Any]									= 2_4_1_8
						SCREAMING_SNAKE_CASE:     Optional[Any]									= 2_3_2_3
						SCREAMING_SNAKE_CASE:     Tuple									= 2_4_0_7
# @@protoc_insertion_point(module_scope)