




'''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 TensorType, logging


a		:	Optional[Any]       =      logging.get_logger(__name__)




class      UpperCamelCase       (	snake_case__       ):
  a     :List[str]          =					['input_values', 'attention_mask']



  def __init__(			self		,     __lowerCAmelCase=1		,     __lowerCAmelCase=1_6000		,     __lowerCAmelCase=128		,     __lowerCAmelCase=1024		,     __lowerCAmelCase=0.0		,     __lowerCAmelCase=True		,     __lowerCAmelCase=-4.2677393		,     __lowerCAmelCase=4.5689974		,     __lowerCAmelCase=False		,     **__lowerCAmelCase		,     ):







      '''simple docstring'''


      super().__init__(feature_size=__lowerCAmelCase		,     sampling_rate=__lowerCAmelCase		,     padding_value=__lowerCAmelCase		,     **__lowerCAmelCase )
      _a				:							Union[str, Any]							       =      num_mel_bins
      _a				:							Dict							       =      max_length
      _a				:							Union[str, Any]							       =      do_normalize
      _a				:							Optional[int]							       =      mean
      _a				:							Dict							       =      std
      _a				:							int							       =      return_attention_mask



  def     a_							(			self		,     __lowerCAmelCase		,     __lowerCAmelCase		,     ):







      '''simple docstring'''


      _a				:							Optional[int]							       =      torch.from_numpy(__lowerCAmelCase ).unsqueeze(0 )
      _a				:							Union[str, Any]							       =      ta_kaldi.fbank(
          __lowerCAmelCase		,     htk_compat=__lowerCAmelCase		,     sample_frequency=self.sampling_rate		,     use_energy=__lowerCAmelCase		,     window_type="""hanning"""		,     num_mel_bins=self.num_mel_bins		,     dither=0.0		,     frame_shift=10		,     )

      _a				:							Tuple							       =      fbank.shape[0]
      _a				:							Optional[int]							       =      max_length - n_frames

      # pad or truncate, depending on difference
      if difference > 0:
          _a				:							Union[str, Any]							       =      torch.nn.ZeroPadad((0, 0, 0, difference) )
          _a				:							List[str]							       =      pad_module(__lowerCAmelCase )
      elif difference < 0:
          _a				:							List[Any]							       =      fbank[0:max_length, :]

      _a				:							List[Any]							       =      fbank.numpy()

      return fbank



  def     a_							(			self		,     __lowerCAmelCase ):







      '''simple docstring'''


      return (input_values - (self.mean)) / (self.std * 2)



  def __call__(			self		,     __lowerCAmelCase		,     __lowerCAmelCase = None		,     __lowerCAmelCase = None		,     **__lowerCAmelCase		,     ):







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

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

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

      # always return batch
      if not is_batched:
          _a				:							Any							       =      [raw_speech]

      # extract fbank features and pad/truncate to max_length
      _a				:							List[str]							       =      [self._extract_fbank_features(__lowerCAmelCase		,     max_length=self.max_length ) for waveform in raw_speech]

      # convert into BatchFeature
      _a				:							List[str]							       =      BatchFeature({"""input_values""": features} )

      # make sure list is in array format
      _a				:							Any							       =      padded_inputs.get("""input_values""" )
      if isinstance(input_values[0]		,     __lowerCAmelCase ):
          _a				:							Tuple							       =      [np.asarray(__lowerCAmelCase		,     dtype=np.floataa ) for feature in input_values]

      # normalization
      if self.do_normalize:
          _a				:							Union[str, Any]							       =      [self.normalize(__lowerCAmelCase ) for feature in input_values]

      if return_tensors is not None:
          _a				:							Optional[int]							       =      padded_inputs.convert_to_tensors(__lowerCAmelCase )

      return padded_inputs







from typing import Dict, List, Optional, Tuple

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


_lowercase:					int      =						logging.get_logger(__name__)



class       _lowercase				(  lowerCAmelCase      ):





	"""simple docstring"""
	__A		      =				["input_ids", "attention_mask"]




	def __init__(self						,			lowerCamelCase_="[PAD]"						,			lowerCamelCase_="[BOS]"						,			lowerCamelCase_="[EOS]"						,			lowerCamelCase_="[MASK]"						,			lowerCamelCase_="[CLS]"						,			lowerCamelCase_="[SEP]"						,			lowerCamelCase_=2048						,			**lowerCamelCase_						,			):
						"""simple docstring"""

						a   	=  AddedToken(lowerCamelCase_						,			lstrip=lowerCamelCase_						,			rstrip=lowerCamelCase_						) if isinstance(lowerCamelCase_						,			lowerCamelCase_						) else pad_token
						a   	=  AddedToken(lowerCamelCase_						,			lstrip=lowerCamelCase_						,			rstrip=lowerCamelCase_						) if isinstance(lowerCamelCase_						,			lowerCamelCase_						) else bos_token
						a   	=  AddedToken(lowerCamelCase_						,			lstrip=lowerCamelCase_						,			rstrip=lowerCamelCase_						) if isinstance(lowerCamelCase_						,			lowerCamelCase_						) else eos_token
						a   	=  AddedToken(lowerCamelCase_						,			lstrip=lowerCamelCase_						,			rstrip=lowerCamelCase_						) if isinstance(lowerCamelCase_						,			lowerCamelCase_						) else mask_token
						a   	=  AddedToken(lowerCamelCase_						,			lstrip=lowerCamelCase_						,			rstrip=lowerCamelCase_						) if isinstance(lowerCamelCase_						,			lowerCamelCase_						) else cls_token
						a   	=  AddedToken(lowerCamelCase_						,			lstrip=lowerCamelCase_						,			rstrip=lowerCamelCase_						) if isinstance(lowerCamelCase_						,			lowerCamelCase_						) else sep_token

						super().__init__(
						    pad_token=lowerCamelCase_						,			bos_token=lowerCamelCase_						,			eos_token=lowerCamelCase_						,			mask_token=lowerCamelCase_						,			cls_token=lowerCamelCase_						,			sep_token=lowerCamelCase_						,			model_max_length=lowerCamelCase_						,			**lowerCamelCase_						,			)

						a   	=  2**8  # utf is 8 bits

						# define special tokens dict
						a   	=  {
						    self.pad_token: 0,
						    self.bos_token: 1,
						    self.eos_token: 2,
						    self.mask_token: 3,
						    self.cls_token: 4,
						    self.sep_token: 5,
						}
						a   	=  len(self.special_tokens_encoder						)
						a   	=  {v: k for k, v in self.special_tokens_encoder.items()}




	def 	UpperCamelCase_			(self						):
						"""simple docstring"""

						a   	=  self.special_tokens_encoder.copy()
						vocab.update(self.added_tokens_encoder						)
						for i in range(self._utf_vocab_size						):
											a   	=  chr(lowerCamelCase_						)
											a   	=  i + len(self.special_tokens_encoder						)
						return vocab




	@property
	def 	UpperCamelCase_			(self						):
						"""simple docstring"""

						return self._utf_vocab_size + self._num_special_tokens




	def 	UpperCamelCase_			(self						,			lowerCamelCase_						,			lowerCamelCase_ = None						,			lowerCamelCase_ = False						):
						"""simple docstring"""

						if already_has_special_tokens:
											return super().get_special_tokens_mask(
											    token_ids_a=lowerCamelCase_						,			token_ids_a=lowerCamelCase_						,			already_has_special_tokens=lowerCamelCase_						)

						# normal case: some special tokens
						if token_ids_a is None:
											return [1] + [0] * len(lowerCamelCase_						) + [1]
						return [1] + ([0] * len(lowerCamelCase_						)) + [1] + ([0] * len(lowerCamelCase_						)) + [1]




	def 	UpperCamelCase_			(self						,			lowerCamelCase_						,			lowerCamelCase_ = None						):
						"""simple docstring"""

						if token_ids_a is None:
											return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
						else:
											return [self.cls_token_id] + token_ids_a + [self.sep_token_id] + token_ids_a + [self.sep_token_id]




	def 	UpperCamelCase_			(self						,			lowerCamelCase_						):
						"""simple docstring"""

						a   	=  [chr(lowerCamelCase_						) for i in text.encode("utf-8"						)]
						return tokens




	def 	UpperCamelCase_			(self						,			lowerCamelCase_						):
						"""simple docstring"""

						if token in self.special_tokens_encoder:
											a   	=  self.special_tokens_encoder[token]
						elif token in self.added_tokens_encoder:
											a   	=  self.added_tokens_encoder[token]
						elif len(lowerCamelCase_						) != 1:
											a   	=  self.unk_token_id
						else:
											a   	=  ord(lowerCamelCase_						) + self._num_special_tokens
						return token_id




	def 	UpperCamelCase_			(self						,			lowerCamelCase_						):
						"""simple docstring"""

						if index in self.special_tokens_decoder:
											a   	=  self.special_tokens_decoder[index]
						elif index in self.added_tokens_decoder:
											a   	=  self.added_tokens_decoder[index]
						else:
											a   	=  chr(index - self._num_special_tokens						)
						return token




	def 	UpperCamelCase_			(self						,			lowerCamelCase_						):
						"""simple docstring"""

						a   	=  B""
						for token in tokens:
											if token in self.special_tokens_decoder:
																a   	=  self.special_tokens_decoder[token].encode("utf-8"						)
											elif token in self.added_tokens_decoder:
																a   	=  self.special_tokens_decoder[token].encode("utf-8"						)
											elif token in self.special_tokens_encoder:
																a   	=  token.encode("utf-8"						)
											elif token in self.added_tokens_encoder:
																a   	=  token.encode("utf-8"						)
											else:
																a   	=  bytes([ord(lowerCamelCase_						)]						)
											bstring += tok_string
						a   	=  bstring.decode("utf-8"						,			errors="replace"						)
						return string




	def 	UpperCamelCase_			(self						,			lowerCamelCase_						,			lowerCamelCase_ = None						):
						"""simple docstring"""

						return ()
