



import numpy as np

from transformers import BatchFeature
from transformers.testing_utils import require_tf, require_torch

from .test_feature_extraction_common import FeatureExtractionSavingTestMixin



class    UpperCAmelCase__(				A__						):

   '''simple docstring'''




   A     :	int												=     None
   A     :	Any												=     None


   @property
   def       UpperCAmelCase		(    self	:      List[str])						->					Any:




         """simple docstring"""

         return self.feat_extract_tester.prepare_feat_extract_dict()


   def       UpperCAmelCase		(    self	:      Any)						->					List[Any]:




         """simple docstring"""

         lowercase__  =	self.feature_extraction_class(**self.feat_extract_dict)
         self.assertTrue(hasattr(_lowerCamelCase      ,					'feature_size'))
         self.assertTrue(hasattr(_lowerCamelCase      ,					'sampling_rate'))
         self.assertTrue(hasattr(_lowerCamelCase      ,					'padding_value'))


   def       UpperCAmelCase		(    self	:      str)						->					Union[str, Any]:




         """simple docstring"""

         lowercase__  =	self.feat_extract_tester.prepare_inputs_for_common()
         lowercase__  =	self.feature_extraction_class(**self.feat_extract_dict)
         lowercase__  =	feat_extract.model_input_names[0]

         lowercase__  =	BatchFeature({input_name: speech_inputs})

         self.assertTrue(all(len(_lowerCamelCase) == len(_lowerCamelCase) for x, y in zip(_lowerCamelCase      ,					processed_features[input_name])))

         lowercase__  =	self.feat_extract_tester.prepare_inputs_for_common(equal_length=_lowerCamelCase)
         lowercase__  =	BatchFeature({input_name: speech_inputs}      ,					tensor_type='np')

         lowercase__  =	processed_features[input_name]

         if len(batch_features_input.shape) < 3:
               lowercase__  =	batch_features_input[:, :, None]

         self.assertTrue(
             batch_features_input.shape
             == (self.feat_extract_tester.batch_size, len(speech_inputs[0]), self.feat_extract_tester.feature_size))


   @require_torch
   def       UpperCAmelCase		(    self	:      List[str])						->					List[str]:




         """simple docstring"""

         lowercase__  =	self.feat_extract_tester.prepare_inputs_for_common(equal_length=_lowerCamelCase)
         lowercase__  =	self.feature_extraction_class(**self.feat_extract_dict)
         lowercase__  =	feat_extract.model_input_names[0]

         lowercase__  =	BatchFeature({input_name: speech_inputs}      ,					tensor_type='pt')

         lowercase__  =	processed_features[input_name]

         if len(batch_features_input.shape) < 3:
               lowercase__  =	batch_features_input[:, :, None]

         self.assertTrue(
             batch_features_input.shape
             == (self.feat_extract_tester.batch_size, len(speech_inputs[0]), self.feat_extract_tester.feature_size))


   @require_tf
   def       UpperCAmelCase		(    self	:      Tuple)						->					List[Any]:




         """simple docstring"""

         lowercase__  =	self.feat_extract_tester.prepare_inputs_for_common(equal_length=_lowerCamelCase)
         lowercase__  =	self.feature_extraction_class(**self.feat_extract_dict)
         lowercase__  =	feat_extract.model_input_names[0]

         lowercase__  =	BatchFeature({input_name: speech_inputs}      ,					tensor_type='tf')

         lowercase__  =	processed_features[input_name]

         if len(batch_features_input.shape) < 3:
               lowercase__  =	batch_features_input[:, :, None]

         self.assertTrue(
             batch_features_input.shape
             == (self.feat_extract_tester.batch_size, len(speech_inputs[0]), self.feat_extract_tester.feature_size))


   def       UpperCAmelCase		(    self	:      Union[str, Any]      ,					lowerCAmelCase	:      List[Any]=False)						->					Optional[Any]:




         """simple docstring"""

         def _inputs_have_equal_length(lowerCAmelCase	:      List[Any]):
               lowercase__  =	len(input[0])
               for input_slice in input[1:]:
                     if len(_lowerCamelCase) != length:
                           return False
               return True

         def _inputs_are_equal(lowerCAmelCase	:      str      ,					lowerCAmelCase	:      str):
               if len(_lowerCamelCase) != len(_lowerCamelCase):
                     return False

               for input_slice_a, input_slice_a in zip(_lowerCamelCase      ,					_lowerCamelCase):
                     if not np.allclose(np.asarray(_lowerCamelCase)      ,					np.asarray(_lowerCamelCase)      ,					atol=1E-3):
                           return False
               return True

         lowercase__  =	self.feature_extraction_class(**self.feat_extract_dict)
         lowercase__  =	self.feat_extract_tester.prepare_inputs_for_common(numpify=_lowerCamelCase)
         lowercase__  =	feat_extract.model_input_names[0]

         lowercase__  =	BatchFeature({input_name: speech_inputs})

         lowercase__  =	self.feat_extract_tester.seq_length_diff
         lowercase__  =	self.feat_extract_tester.max_seq_length + pad_diff
         lowercase__  =	self.feat_extract_tester.min_seq_length
         lowercase__  =	self.feat_extract_tester.batch_size
         lowercase__  =	self.feat_extract_tester.feature_size

         # test padding for List[int] + numpy
         lowercase__  =	feat_extract.pad(_lowerCamelCase      ,					padding=_lowerCamelCase)
         lowercase__  =	input_a[input_name]

         lowercase__  =	feat_extract.pad(_lowerCamelCase      ,					padding='longest')
         lowercase__  =	input_a[input_name]

         lowercase__  =	feat_extract.pad(_lowerCamelCase      ,					padding='max_length'      ,					max_length=len(speech_inputs[-1]))
         lowercase__  =	input_a[input_name]

         lowercase__  =	feat_extract.pad(_lowerCamelCase      ,					padding='longest'      ,					return_tensors='np')
         lowercase__  =	input_a[input_name]

         # max_length parameter has to be provided when setting `padding="max_length"`
         with self.assertRaises(_lowerCamelCase):
               feat_extract.pad(_lowerCamelCase      ,					padding='max_length')[input_name]

         lowercase__  =	feat_extract.pad(
             _lowerCamelCase      ,					padding='max_length'      ,					max_length=_lowerCamelCase      ,					return_tensors='np')
         lowercase__  =	input_a[input_name]

         self.assertFalse(_inputs_have_equal_length(_lowerCamelCase))
         self.assertTrue(_inputs_have_equal_length(_lowerCamelCase))
         self.assertTrue(_inputs_have_equal_length(_lowerCamelCase))
         self.assertTrue(_inputs_are_equal(_lowerCamelCase      ,					_lowerCamelCase))
         self.assertTrue(len(input_a[0]) == pad_min_length)
         self.assertTrue(len(input_a[1]) == pad_min_length + pad_diff)
         self.assertTrue(input_a.shape[:2] == (batch_size, len(input_a[0])))
         self.assertTrue(input_a.shape[:2] == (batch_size, pad_max_length))

         if feature_size > 1:
               self.assertTrue(input_a.shape[2] == input_a.shape[2] == feature_size)

         # test padding for `pad_to_multiple_of` for List[int] + numpy
         lowercase__  =	feat_extract.pad(_lowerCamelCase      ,					pad_to_multiple_of=10)
         lowercase__  =	input_a[input_name]

         lowercase__  =	feat_extract.pad(_lowerCamelCase      ,					padding='longest'      ,					pad_to_multiple_of=10)
         lowercase__  =	input_a[input_name]

         lowercase__  =	feat_extract.pad(
             _lowerCamelCase      ,					padding='max_length'      ,					pad_to_multiple_of=10      ,					max_length=_lowerCamelCase)
         lowercase__  =	input_a[input_name]

         lowercase__  =	feat_extract.pad(
             _lowerCamelCase      ,					padding='max_length'      ,					pad_to_multiple_of=10      ,					max_length=_lowerCamelCase      ,					return_tensors='np'      ,					)
         lowercase__  =	input_a[input_name]

         self.assertTrue(all(len(_lowerCamelCase) % 10 == 0 for x in input_a))
         self.assertTrue(_inputs_are_equal(_lowerCamelCase      ,					_lowerCamelCase))

         lowercase__  =	pad_max_length if pad_max_length % 10 == 0 else (pad_max_length // 10 + 1) * 10
         self.assertTrue(all(len(_lowerCamelCase) == expected_mult_pad_length for x in input_a))
         self.assertEqual(input_a.shape[:2]      ,					(batch_size, expected_mult_pad_length))

         if feature_size > 1:
               self.assertTrue(input_a.shape[2] == feature_size)

         # Check padding value is correct
         lowercase__  =	(np.ones(self.feat_extract_tester.feature_size) * feat_extract.padding_value).sum()
         self.assertTrue(
             abs(np.asarray(input_a[0])[pad_min_length:].sum() - padding_vector_sum * (pad_max_length - pad_min_length))
             < 1E-3)
         self.assertTrue(
             abs(
                 np.asarray(input_a[1])[pad_min_length + pad_diff :].sum()
                 - padding_vector_sum * (pad_max_length - pad_min_length - pad_diff))
             < 1E-3)
         self.assertTrue(
             abs(
                 np.asarray(input_a[2])[pad_min_length + 2 * pad_diff :].sum()
                 - padding_vector_sum * (pad_max_length - pad_min_length - 2 * pad_diff))
             < 1E-3)
         self.assertTrue(
             abs(input_a[0, pad_min_length:].sum() - padding_vector_sum * (pad_max_length - pad_min_length)) < 1E-3)
         self.assertTrue(
             abs(input_a[0, pad_min_length:].sum() - padding_vector_sum * (expected_mult_pad_length - pad_min_length))
             < 1E-3)


   def       UpperCAmelCase		(    self	:      str      ,					lowerCAmelCase	:      Optional[Any]=False)						->					Union[str, Any]:




         """simple docstring"""

         def _inputs_have_equal_length(lowerCAmelCase	:      Optional[int]):
               lowercase__  =	len(input[0])
               for input_slice in input[1:]:
                     if len(_lowerCamelCase) != length:
                           return False
               return True

         def _inputs_are_equal(lowerCAmelCase	:      Tuple      ,					lowerCAmelCase	:      int):
               if len(_lowerCamelCase) != len(_lowerCamelCase):
                     return False

               for input_slice_a, input_slice_a in zip(_lowerCamelCase      ,					_lowerCamelCase):
                     if not np.allclose(np.asarray(_lowerCamelCase)      ,					np.asarray(_lowerCamelCase)      ,					atol=1E-3):
                           return False
               return True

         lowercase__  =	self.feature_extraction_class(**self.feat_extract_dict)
         lowercase__  =	self.feat_extract_tester.prepare_inputs_for_common(numpify=_lowerCamelCase)
         lowercase__  =	feat_extract.model_input_names[0]

         lowercase__  =	BatchFeature({input_name: speech_inputs})

         # truncate to smallest
         lowercase__  =	feat_extract.pad(
             _lowerCamelCase      ,					padding='max_length'      ,					max_length=len(speech_inputs[0])      ,					truncation=_lowerCamelCase)
         lowercase__  =	input_a[input_name]

         lowercase__  =	feat_extract.pad(_lowerCamelCase      ,					padding='max_length'      ,					max_length=len(speech_inputs[0]))
         lowercase__  =	input_a[input_name]

         self.assertTrue(_inputs_have_equal_length(_lowerCamelCase))
         self.assertFalse(_inputs_have_equal_length(_lowerCamelCase))

         # truncate to smallest with np
         lowercase__  =	feat_extract.pad(
             _lowerCamelCase      ,					padding='max_length'      ,					max_length=len(speech_inputs[0])      ,					return_tensors='np'      ,					truncation=_lowerCamelCase      ,					)
         lowercase__  =	input_a[input_name]

         lowercase__  =	feat_extract.pad(
             _lowerCamelCase      ,					padding='max_length'      ,					max_length=len(speech_inputs[0])      ,					return_tensors='np')
         lowercase__  =	input_a[input_name]

         self.assertTrue(_inputs_have_equal_length(_lowerCamelCase))
         self.assertTrue(input_a.shape[1] == len(speech_inputs[0]))

         # since truncation forces padding to be smaller than longest input
         # function can't return `np.ndarray`, but has to return list
         self.assertFalse(_inputs_have_equal_length(_lowerCamelCase))

         # truncate to middle
         lowercase__  =	feat_extract.pad(
             _lowerCamelCase      ,					padding='max_length'      ,					max_length=len(speech_inputs[1])      ,					truncation=_lowerCamelCase      ,					return_tensors='np'      ,					)
         lowercase__  =	input_a[input_name]

         lowercase__  =	feat_extract.pad(
             _lowerCamelCase      ,					padding='max_length'      ,					max_length=len(speech_inputs[1])      ,					truncation=_lowerCamelCase)
         lowercase__  =	input_a[input_name]

         lowercase__  =	feat_extract.pad(
             _lowerCamelCase      ,					padding='max_length'      ,					max_length=len(speech_inputs[1])      ,					return_tensors='np')
         lowercase__  =	input_a[input_name]

         self.assertTrue(input_a.shape[1] == len(speech_inputs[1]))
         self.assertTrue(_inputs_have_equal_length(_lowerCamelCase))
         self.assertTrue(_inputs_have_equal_length(_lowerCamelCase))
         self.assertTrue(_inputs_are_equal(_lowerCamelCase      ,					_lowerCamelCase))

         # since truncation forces padding to be smaller than longest input
         # function can't return `np.ndarray`, but has to return list
         self.assertFalse(_inputs_have_equal_length(_lowerCamelCase))
         self.assertTrue(len(input_a[-1]) == len(speech_inputs[-1]))

         # padding has to be max_length when setting `truncation=True`
         with self.assertRaises(_lowerCamelCase):
               feat_extract.pad(_lowerCamelCase      ,					truncation=_lowerCamelCase)[input_name]

         # padding has to be max_length when setting `truncation=True`
         with self.assertRaises(_lowerCamelCase):
               feat_extract.pad(_lowerCamelCase      ,					padding='longest'      ,					truncation=_lowerCamelCase)[input_name]

         # padding has to be max_length when setting `truncation=True`
         with self.assertRaises(_lowerCamelCase):
               feat_extract.pad(_lowerCamelCase      ,					padding='longest'      ,					truncation=_lowerCamelCase)[input_name]

         # max_length parameter has to be provided when setting `truncation=True` and padding="max_length"
         with self.assertRaises(_lowerCamelCase):
               feat_extract.pad(_lowerCamelCase      ,					padding='max_length'      ,					truncation=_lowerCamelCase)[input_name]

         # test truncation for `pad_to_multiple_of` for List[int] + numpy
         lowercase__  =	12
         lowercase__  =	feat_extract.pad(
             _lowerCamelCase      ,					padding='max_length'      ,					max_length=len(speech_inputs[0])      ,					pad_to_multiple_of=_lowerCamelCase      ,					truncation=_lowerCamelCase      ,					)
         lowercase__  =	input_a[input_name]

         lowercase__  =	feat_extract.pad(
             _lowerCamelCase      ,					padding='max_length'      ,					max_length=len(speech_inputs[0])      ,					pad_to_multiple_of=_lowerCamelCase      ,					)
         lowercase__  =	input_a[input_name]

         # retrieve expected_length as multiple of pad_to_multiple_of
         lowercase__  =	len(speech_inputs[0])
         if expected_length % pad_to_multiple_of != 0:
               lowercase__  =	((len(speech_inputs[0]) // pad_to_multiple_of) + 1) * pad_to_multiple_of

         self.assertTrue(len(input_a[0]) == expected_length)
         self.assertTrue(_inputs_have_equal_length(_lowerCamelCase))
         self.assertFalse(_inputs_have_equal_length(_lowerCamelCase))


   def       UpperCAmelCase		(    self	:      Optional[Any])						->					Union[str, Any]:




         """simple docstring"""

         self._check_padding(numpify=_lowerCamelCase)


   def       UpperCAmelCase		(    self	:      List[Any])						->					Optional[int]:




         """simple docstring"""

         self._check_padding(numpify=_lowerCamelCase)


   def       UpperCAmelCase		(    self	:      Optional[int])						->					Any:




         """simple docstring"""

         self._check_truncation(numpify=_lowerCamelCase)


   def       UpperCAmelCase		(    self	:      int)						->					int:




         """simple docstring"""

         self._check_truncation(numpify=_lowerCamelCase)


   @require_torch
   def       UpperCAmelCase		(    self	:      List[Any])						->					Tuple:




         """simple docstring"""

         lowercase__  =	self.feature_extraction_class(**self.feat_extract_dict)
         lowercase__  =	self.feat_extract_tester.prepare_inputs_for_common()
         lowercase__  =	feat_extract.model_input_names[0]

         lowercase__  =	BatchFeature({input_name: speech_inputs})

         lowercase__  =	feat_extract.pad(_lowerCamelCase      ,					padding='longest'      ,					return_tensors='np')[input_name]
         lowercase__  =	feat_extract.pad(_lowerCamelCase      ,					padding='longest'      ,					return_tensors='pt')[input_name]

         self.assertTrue(abs(input_np.astype(np.floataa).sum() - input_pt.numpy().astype(np.floataa).sum()) < 1E-2)


   @require_tf
   def       UpperCAmelCase		(    self	:      List[Any])						->					List[Any]:




         """simple docstring"""

         lowercase__  =	self.feature_extraction_class(**self.feat_extract_dict)
         lowercase__  =	self.feat_extract_tester.prepare_inputs_for_common()
         lowercase__  =	feat_extract.model_input_names[0]

         lowercase__  =	BatchFeature({input_name: speech_inputs})

         lowercase__  =	feat_extract.pad(_lowerCamelCase      ,					padding='longest'      ,					return_tensors='np')[input_name]
         lowercase__  =	feat_extract.pad(_lowerCamelCase      ,					padding='longest'      ,					return_tensors='tf')[input_name]

         self.assertTrue(abs(input_np.astype(np.floataa).sum() - input_tf.numpy().astype(np.floataa).sum()) < 1E-2)


   def       UpperCAmelCase		(    self	:      Any)						->					List[str]:




         """simple docstring"""

         lowercase__  =	self.feat_extract_dict
         lowercase__  =	True
         lowercase__  =	self.feature_extraction_class(**_lowerCamelCase)
         lowercase__  =	self.feat_extract_tester.prepare_inputs_for_common()
         lowercase__  =	[len(_lowerCamelCase) for x in speech_inputs]
         lowercase__  =	feat_extract.model_input_names[0]

         lowercase__  =	BatchFeature({input_name: speech_inputs})

         lowercase__  =	feat_extract.pad(_lowerCamelCase      ,					padding='longest'      ,					return_tensors='np')
         self.assertIn('attention_mask'      ,					_lowerCamelCase)
         self.assertListEqual(list(processed.attention_mask.shape)      ,					list(processed[input_name].shape[:2]))
         self.assertListEqual(processed.attention_mask.sum(-1).tolist()      ,					_lowerCamelCase)



   def       UpperCAmelCase		(    self	:      Tuple)						->					int:




         """simple docstring"""

         lowercase__  =	self.feat_extract_dict
         lowercase__  =	True
         lowercase__  =	self.feature_extraction_class(**_lowerCamelCase)
         lowercase__  =	self.feat_extract_tester.prepare_inputs_for_common()
         lowercase__  =	[len(_lowerCamelCase) for x in speech_inputs]
         lowercase__  =	feat_extract.model_input_names[0]

         lowercase__  =	BatchFeature({input_name: speech_inputs})
         lowercase__  =	min(_lowerCamelCase)

         lowercase__  =	feat_extract.pad(
             _lowerCamelCase      ,					padding='max_length'      ,					max_length=_lowerCamelCase      ,					truncation=_lowerCamelCase      ,					return_tensors='np')
         self.assertIn('attention_mask'      ,					_lowerCamelCase)
         self.assertListEqual(
             list(processed_pad.attention_mask.shape)      ,					[processed_pad[input_name].shape[0], max_length])
         self.assertListEqual(
             processed_pad.attention_mask[:, :max_length].sum(-1).tolist()      ,					[max_length for x in speech_inputs])


"""simple docstring"""






from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


__SCREAMING_SNAKE_CASE							=     {
    'configuration_whisper': ['WHISPER_PRETRAINED_CONFIG_ARCHIVE_MAP', 'WhisperConfig', 'WhisperOnnxConfig'],
    'feature_extraction_whisper': ['WhisperFeatureExtractor'],
    'processing_whisper': ['WhisperProcessor'],
    'tokenization_whisper': ['WhisperTokenizer'],
}

try:
 if not is_tokenizers_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __SCREAMING_SNAKE_CASE							=     ['WhisperTokenizerFast']

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __SCREAMING_SNAKE_CASE							=     [
     'WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST',
     'WhisperForConditionalGeneration',
     'WhisperModel',
     'WhisperPreTrainedModel',
     'WhisperForAudioClassification',
 ]

try:
 if not is_tf_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __SCREAMING_SNAKE_CASE							=     [
     'TF_WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST',
     'TFWhisperForConditionalGeneration',
     'TFWhisperModel',
     'TFWhisperPreTrainedModel',
 ]

try:
 if not is_flax_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __SCREAMING_SNAKE_CASE							=     [
     'FlaxWhisperForConditionalGeneration',
     'FlaxWhisperModel',
     'FlaxWhisperPreTrainedModel',
     'FlaxWhisperForAudioClassification',
 ]


if TYPE_CHECKING:
 from .configuration_whisper import WHISPER_PRETRAINED_CONFIG_ARCHIVE_MAP, WhisperConfig, WhisperOnnxConfig
 from .feature_extraction_whisper import WhisperFeatureExtractor
 from .processing_whisper import WhisperProcessor
 from .tokenization_whisper import WhisperTokenizer

 try:
  if not is_tokenizers_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .tokenization_whisper_fast import WhisperTokenizerFast

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_whisper import (
      WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST,
      WhisperForAudioClassification,
      WhisperForConditionalGeneration,
      WhisperModel,
      WhisperPreTrainedModel,
  )

 try:
  if not is_tf_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_tf_whisper import (
      TF_WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST,
      TFWhisperForConditionalGeneration,
      TFWhisperModel,
      TFWhisperPreTrainedModel,
  )

 try:
  if not is_flax_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_flax_whisper import (
      FlaxWhisperForAudioClassification,
      FlaxWhisperForConditionalGeneration,
      FlaxWhisperModel,
      FlaxWhisperPreTrainedModel,
  )

else:
 import sys

 __SCREAMING_SNAKE_CASE							=     _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
