






import unittest

from transformers import AlbertTokenizer, AlbertTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin


__snake_case      :      Union[str, Any]             =       get_tests_dir("""fixtures/spiece.model""")


@require_sentencepiece
@require_tokenizers
class       __SCREAMING_SNAKE_CASE   (				UpperCamelCase_						,   unittest.TestCase):
      _SCREAMING_SNAKE_CASE		:    Optional[Any]						=   AlbertTokenizer
      _SCREAMING_SNAKE_CASE		:    Optional[int]						=   AlbertTokenizerFast
      _SCREAMING_SNAKE_CASE		:    Dict						=   True
      _SCREAMING_SNAKE_CASE		:    Union[str, Any]						=   True
      _SCREAMING_SNAKE_CASE		:    int						=   True






      def  UpperCamelCase__ (		self				):






            """simple docstring"""
            super().setUp()

            # We have a SentencePiece fixture for testing
            lowerCAmelCase__        =  AlbertTokenizer(_a				)
            tokenizer.save_pretrained(self.tmpdirname				)






      def  UpperCamelCase__ (		self       ,  _UpperCamelCase				):






            """simple docstring"""
            lowerCAmelCase__        =  """this is a test"""
            lowerCAmelCase__        =  """this is a test"""
            return input_text, output_text






      def  UpperCamelCase__ (		self				):






            """simple docstring"""
            lowerCAmelCase__        =  """<pad>"""
            lowerCAmelCase__        =  0

            self.assertEqual(self.get_tokenizer()._convert_token_to_id(_a				)       ,  _a				)
            self.assertEqual(self.get_tokenizer()._convert_id_to_token(_a				)       ,  _a				)






      def  UpperCamelCase__ (		self				):






            """simple docstring"""
            lowerCAmelCase__        =  list(self.get_tokenizer().get_vocab().keys()				)

            self.assertEqual(vocab_keys[0]       ,  '<pad>'				)
            self.assertEqual(vocab_keys[1]       ,  '<unk>'				)
            self.assertEqual(vocab_keys[-1]       ,  '▁eloquent'				)
            self.assertEqual(len(_a				)       ,  3_00_00				)






      def  UpperCamelCase__ (		self				):






            """simple docstring"""
            self.assertEqual(self.get_tokenizer().vocab_size       ,  3_00_00				)






      def  UpperCamelCase__ (		self				):






            """simple docstring"""


            if not self.test_rust_tokenizer:
                  return

            lowerCAmelCase__        =  self.get_tokenizer()
            lowerCAmelCase__        =  self.get_rust_tokenizer()

            lowerCAmelCase__        =  """I was born in 92000, and this is falsé."""

            lowerCAmelCase__        =  tokenizer.tokenize(_a				)
            lowerCAmelCase__        =  rust_tokenizer.tokenize(_a				)
            self.assertListEqual(_a       ,  _a				)

            lowerCAmelCase__        =  tokenizer.encode(_a       ,  add_special_tokens=_a				)
            lowerCAmelCase__        =  rust_tokenizer.encode(_a       ,  add_special_tokens=_a				)
            self.assertListEqual(_a       ,  _a				)

            lowerCAmelCase__        =  self.get_rust_tokenizer()
            lowerCAmelCase__        =  tokenizer.encode(_a				)
            lowerCAmelCase__        =  rust_tokenizer.encode(_a				)
            self.assertListEqual(_a       ,  _a				)






      def  UpperCamelCase__ (		self				):






            """simple docstring"""
            lowerCAmelCase__        =  AlbertTokenizer(_a       ,  keep_accents=_a				)

            lowerCAmelCase__        =  tokenizer.tokenize('This is a test'				)
            self.assertListEqual(_a       ,  ['▁this', '▁is', '▁a', '▁test']				)

            self.assertListEqual(tokenizer.convert_tokens_to_ids(_a				)       ,  [48, 25, 21, 12_89]				)

            lowerCAmelCase__        =  tokenizer.tokenize('I was born in 92000, and this is falsé.'				)
            self.assertListEqual(
                _a       ,  ['▁i', '▁was', '▁born', '▁in', '▁9', '2000', ',', '▁and', '▁this', '▁is', '▁fal', 's', 'é', '.']				)
            lowerCAmelCase__        =  tokenizer.convert_tokens_to_ids(_a				)
            self.assertListEqual(_a       ,  [31, 23, 3_86, 19, 5_61, 30_50, 15, 17, 48, 25, 82_56, 18, 1, 9]				)

            lowerCAmelCase__        =  tokenizer.convert_ids_to_tokens(_a				)
            self.assertListEqual(
                _a       ,  ['▁i', '▁was', '▁born', '▁in', '▁9', '2000', ',', '▁and', '▁this', '▁is', '▁fal', 's', '<unk>', '.']       ,  )






      def  UpperCamelCase__ (		self				):






            """simple docstring"""
            lowerCAmelCase__        =  AlbertTokenizer(_a				)

            lowerCAmelCase__        =  tokenizer.encode('sequence builders'				)
            lowerCAmelCase__        =  tokenizer.encode('multi-sequence build'				)

            lowerCAmelCase__        =  tokenizer.build_inputs_with_special_tokens(_a				)
            lowerCAmelCase__        =  tokenizer.build_inputs_with_special_tokens(_a       ,  _a				)

            assert encoded_sentence == [tokenizer.cls_token_id] + text + [tokenizer.sep_token_id]
            assert encoded_pair == [tokenizer.cls_token_id] + text + [tokenizer.sep_token_id] + text_a + [
                tokenizer.sep_token_id
            ]







      @slow
      def  UpperCamelCase__ (		self				):






            """simple docstring"""
            lowerCAmelCase__        =  {"""attention_mask""": [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], """input_ids""": [[2, 2_19_70, 13, 5, 60_92, 1_67, 28, 71_03, 21_53, 6_73, 8, 70_28, 1_20_51, 18, 17, 71_03, 21_53, 6_73, 8, 35_15, 1_86_84, 8, 44_61, 6, 19_27, 2_97, 8, 1_20_60, 26_07, 18, 13, 5, 44_61, 15, 1_05_38, 38, 8, 1_35, 15, 8_22, 58, 15, 9_93, 1_03_63, 15, 14_60, 80_05, 44_61, 15, 9_93, 2_55, 23_28, 9, 9, 9, 6, 26, 11_12, 8_16, 32_60, 13, 5, 1_03, 23_77, 6, 17, 11_12, 8_16, 27_82, 13, 5, 1_03, 1_06_41, 6, 29, 84, 25_12, 24_30, 7_82, 1_86_84, 27_61, 19, 8_08, 24_30, 25_56, 17, 8_55, 14_80, 94_77, 40_91, 1_28, 1_17_12, 15, 71_03, 21_53, 6_73, 17, 2_48_83, 99_90, 9, 3], [2, 1_15_02, 25, 10_06, 20, 7_82, 8, 1_18_09, 8_55, 17_32, 1_93_93, 1_86_67, 37, 3_67, 2_10_18, 69, 18_54, 34, 1_18_60, 1_91_24, 27, 1_56, 2_25, 17, 1_93, 41_41, 19, 65, 91_24, 9, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [2, 14, 22_31, 8_86, 23_85, 1_76_59, 84, 14, 1_67_92, 19_52, 9, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], """token_type_ids""": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}  # noqa: E501
            # fmt: on

            self.tokenizer_integration_test_util(
                expected_encoding=_a       ,  model_name='albert-base-v2'       ,  revision='6b6560eaf5ff2e250b00c50f380c5389a9c2d82e'       ,  )













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

import numpy as np
import torch

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


__snake_case      :      Any             =       logging.get_logger(__name__)


class       __SCREAMING_SNAKE_CASE   (				__lowercase):
						_SCREAMING_SNAKE_CASE		:    Tuple						=   ['''input_features''', '''is_longer''']






						def __init__(		self       ,  _UpperCamelCase=64       ,  _UpperCamelCase=4_80_00       ,  _UpperCamelCase=4_80       ,  _UpperCamelCase=10       ,  _UpperCamelCase=10_24       ,  _UpperCamelCase=0.0       ,  _UpperCamelCase=False       ,  _UpperCamelCase = 0       ,  _UpperCamelCase = 1_40_00       ,  _UpperCamelCase = None       ,  _UpperCamelCase = "fusion"       ,  _UpperCamelCase = "repeatpad"       ,  **_UpperCamelCase       ,  ):






												"""simple docstring"""
												super().__init__(
												    feature_size=_UpperCamelCase       ,  sampling_rate=_UpperCamelCase       ,  padding_value=_UpperCamelCase       ,  return_attention_mask=_UpperCamelCase       ,  **_UpperCamelCase       ,  )
												lowerCAmelCase__        =  top_db
												lowerCAmelCase__        =  truncation
												lowerCAmelCase__        =  padding
												lowerCAmelCase__        =  fft_window_size
												lowerCAmelCase__        =  (fft_window_size >> 1) + 1
												lowerCAmelCase__        =  hop_length
												lowerCAmelCase__        =  max_length_s
												lowerCAmelCase__        =  max_length_s * sampling_rate
												lowerCAmelCase__        =  sampling_rate
												lowerCAmelCase__        =  frequency_min
												lowerCAmelCase__        =  frequency_max
												lowerCAmelCase__        =  mel_filter_bank(
												    num_frequency_bins=self.nb_frequency_bins       ,  num_mel_filters=_UpperCamelCase       ,  min_frequency=_UpperCamelCase       ,  max_frequency=_UpperCamelCase       ,  sampling_rate=_UpperCamelCase       ,  norm=_UpperCamelCase       ,  mel_scale='htk'       ,  )
												lowerCAmelCase__        =  mel_filter_bank(
												    num_frequency_bins=self.nb_frequency_bins       ,  num_mel_filters=_UpperCamelCase       ,  min_frequency=_UpperCamelCase       ,  max_frequency=_UpperCamelCase       ,  sampling_rate=_UpperCamelCase       ,  norm='slaney'       ,  mel_scale='slaney'       ,  )






						def  UpperCamelCase__ (		self				):






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






						def  UpperCamelCase__ (		self       ,  _UpperCamelCase       ,  _UpperCamelCase = None				):






												"""simple docstring"""
												lowerCAmelCase__        =  spectrogram(
												    _UpperCamelCase       ,  window_function(self.fft_window_size       ,  'hann'				)       ,  frame_length=self.fft_window_size       ,  hop_length=self.hop_length       ,  power=2.0       ,  mel_filters=_UpperCamelCase       ,  log_mel='dB'       ,  )
												return log_mel_spectrogram.T






						def  UpperCamelCase__ (		self       ,  _UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase				):






												"""simple docstring"""
												lowerCAmelCase__        =  np.array_split(list(range(0       ,  total_frames - chunk_frames + 1				)				)       ,  3				)
												if len(ranges[1]				) == 0:
																		# if the audio is too short, we just use the first chunk
																		lowerCAmelCase__        =  [0]
												if len(ranges[2]				) == 0:
																		# if the audio is too short, we just use the first chunk
																		lowerCAmelCase__        =  [0]
												# randomly choose index for each part
												lowerCAmelCase__        =  np.random.choice(ranges[0]				)
												lowerCAmelCase__        =  np.random.choice(ranges[1]				)
												lowerCAmelCase__        =  np.random.choice(ranges[2]				)

												lowerCAmelCase__        =  mel[idx_front : idx_front + chunk_frames, :]
												lowerCAmelCase__        =  mel[idx_middle : idx_middle + chunk_frames, :]
												lowerCAmelCase__        =  mel[idx_back : idx_back + chunk_frames, :]

												lowerCAmelCase__        =  torch.tensor(mel[None, None, :]				)
												lowerCAmelCase__        =  torch.nn.functional.interpolate(
												    _UpperCamelCase       ,  size=[chunk_frames, 64]       ,  mode='bilinear'       ,  align_corners=_UpperCamelCase				)
												lowerCAmelCase__        =  mel_shrink[0][0].numpy()
												lowerCAmelCase__        =  np.stack([mel_shrink, mel_chunk_front, mel_chunk_middle, mel_chunk_back]       ,  axis=0				)
												return mel_fusion






						def  UpperCamelCase__ (		self       ,  _UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase				):






												"""simple docstring"""
												if waveform.shape[0] > max_length:
																		if truncation == "rand_trunc":
																								lowerCAmelCase__        =  True
																								# random crop to max_length (for compatibility) -> this should be handled by self.pad
																								lowerCAmelCase__        =  len(_UpperCamelCase				) - max_length
																								lowerCAmelCase__        =  np.random.randint(0       ,  overflow + 1				)
																								lowerCAmelCase__        =  waveform[idx : idx + max_length]
																								lowerCAmelCase__        =  self._np_extract_fbank_features(_UpperCamelCase       ,  self.mel_filters_slaney				)[None, :]
																		elif truncation == "fusion":
																								lowerCAmelCase__        =  self._np_extract_fbank_features(_UpperCamelCase       ,  self.mel_filters				)
																								lowerCAmelCase__        =  max_length // self.hop_length + 1  # the +1 related to how the spectrogram is computed
																								lowerCAmelCase__        =  mel.shape[0]
																								if chunk_frames == total_frames:
																														# there is a corner case where the audio length is larger than max_length but smaller than max_length+hop_length.
																														# In this case, we just use the whole audio.
																														lowerCAmelCase__        =  np.stack([mel, mel, mel, mel]       ,  axis=0				)
																														lowerCAmelCase__        =  False
																								else:
																														lowerCAmelCase__        =  self._random_mel_fusion(_UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase				)
																														lowerCAmelCase__        =  True
																		else:
																								raise NotImplementedError(F"data_truncating {truncation} not implemented"				)

												else:
																		lowerCAmelCase__        =  False
																		# only use repeat as a new possible value for padding. you repeat the audio before applying the usual max_length padding
																		if waveform.shape[0] < max_length:
																								if padding == "repeat":
																														lowerCAmelCase__        =  int(max_length / len(_UpperCamelCase				)				)
																														lowerCAmelCase__        =  np.stack(np.tile(_UpperCamelCase       ,  n_repeat + 1				)				)[:max_length]
																								if padding == "repeatpad":
																														lowerCAmelCase__        =  int(max_length / len(_UpperCamelCase				)				)
																														lowerCAmelCase__        =  np.stack(np.tile(_UpperCamelCase       ,  _UpperCamelCase				)				)
																								lowerCAmelCase__        =  np.pad(_UpperCamelCase       ,  (0, max_length - waveform.shape[0])       ,  mode='constant'       ,  constant_values=0				)

																		if truncation == "fusion":
																								lowerCAmelCase__        =  self._np_extract_fbank_features(_UpperCamelCase       ,  self.mel_filters				)
																								lowerCAmelCase__        =  np.stack([input_mel, input_mel, input_mel, input_mel]       ,  axis=0				)
																		else:
																								lowerCAmelCase__        =  self._np_extract_fbank_features(_UpperCamelCase       ,  self.mel_filters_slaney				)[None, :]

												return input_mel, longer







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






												"""simple docstring"""
												lowerCAmelCase__        =  truncation if truncation is not None else self.truncation
												lowerCAmelCase__        =  padding if padding else self.padding

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

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

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

												# always return batch
												if not is_batched:
																		lowerCAmelCase__        =  [np.asarray(_UpperCamelCase				)]

												# convert to mel spectrogram, truncate and pad if needed.
												lowerCAmelCase__        =  [
												    self._get_input_mel(_UpperCamelCase       ,  max_length if max_length else self.nb_max_samples       ,  _UpperCamelCase       ,  _UpperCamelCase				)
												    for waveform in raw_speech
												]

												lowerCAmelCase__        =  []
												lowerCAmelCase__        =  []
												for mel, longer in padded_inputs:
																		input_mel.append(_UpperCamelCase				)
																		is_longer.append(_UpperCamelCase				)

												if truncation == "fusion" and sum(_UpperCamelCase				) == 0:
																		# if no audio is longer than 10s, then randomly select one audio to be longer
																		lowerCAmelCase__        =  np.random.randint(0       ,  len(_UpperCamelCase				)				)
																		lowerCAmelCase__        =  True

												if isinstance(input_mel[0]       ,  _UpperCamelCase				):
																		lowerCAmelCase__        =  [np.asarray(_UpperCamelCase       ,  dtype=np.floataa				) for feature in input_mel]

												# is_longer is a list of bool
												lowerCAmelCase__        =  [[longer] for longer in is_longer]

												lowerCAmelCase__        =  {'input_features': input_mel, 'is_longer': is_longer}
												lowerCAmelCase__        =  BatchFeature(_UpperCamelCase				)

												if return_tensors is not None:
																		lowerCAmelCase__        =  input_features.convert_to_tensors(_UpperCamelCase				)

												return input_features





