

'''simple docstring'''







import itertools
import random
import unittest

import numpy as np

from transformers import ASTFeatureExtractor
from transformers.testing_utils import require_torch, require_torchaudio
from transformers.utils.import_utils import is_torch_available

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


__lowerCamelCase									=     random.Random()

if is_torch_available():
      import torch
def    UpperCAmelCase__     (   UpperCAmelCase__,							UpperCAmelCase__=1.0,							UpperCAmelCase__=None,							UpperCAmelCase__=None					)      ->      str:
       if rng is None:
              A_						       =   global_rng

       A_						       =   []
       for batch_idx in range(shape[0]					):
              values.append([]					)
              for _ in range(shape[1]					):
                     values[-1].append(rng.random() * scale					)

       return values


class        A__   (   unittest.TestCase      ):



    def __init__(       self		,					UpperCamelCase__		,					UpperCamelCase__=7		,					UpperCamelCase__=400		,					UpperCamelCase__=2000		,					UpperCamelCase__=1		,					UpperCamelCase__=0.0		,					UpperCamelCase__=16000		,					UpperCamelCase__=True		,					UpperCamelCase__=True		,					)    ->   List[str]:





           '''simple docstring'''
           A_						       =   parent
           A_						       =   batch_size
           A_						       =   min_seq_length
           A_						       =   max_seq_length
           A_						       =   (self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
           A_						       =   feature_size
           A_						       =   padding_value
           A_						       =   sampling_rate
           A_						       =   return_attention_mask
           A_						       =   do_normalize



    def        snake_case_      (       self							)    ->   str:





           '''simple docstring'''
           return {
               "feature_size": self.feature_size,
               "padding_value": self.padding_value,
               "sampling_rate": self.sampling_rate,
               "return_attention_mask": self.return_attention_mask,
               "do_normalize": self.do_normalize,
           }







    def        snake_case_      (       self		,					UpperCamelCase__=False		,					UpperCamelCase__=False							)    ->   Optional[int]:





           '''simple docstring'''
           def _flatten(UpperCamelCase__							):
                  return list(itertools.chain(*UpperCamelCase__							)							)

           if equal_length:
                  A_						       =   floats_list((self.batch_size, self.max_seq_length)							)
           else:
                  # make sure that inputs increase in size
                  A_						       =   [
                      _flatten(floats_list((x, self.feature_size)							)							)
                      for x in range(self.min_seq_length		,					self.max_seq_length		,					self.seq_length_diff							)
                  ]

           if numpify:
                  A_						       =   [np.asarray(UpperCamelCase__							) for x in speech_inputs]

           return speech_inputs


@require_torch
@require_torchaudio
class        A__   (   _snake_case    ,    unittest.TestCase      ):
    lowercase						       =		ASTFeatureExtractor



    def        snake_case_      (       self							)    ->   Optional[Any]:





           '''simple docstring'''
           A_						       =   ASTFeatureExtractionTester(self							)



    def        snake_case_      (       self							)    ->   List[str]:





           '''simple docstring'''
           # Tests that all call wrap to encode_plus and batch_encode_plus
           A_						       =   self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()							)
           # create three inputs of length 800, 1000, and 1200
           A_						       =   [floats_list((1, x)							)[0] for x in range(800		,					1400		,					200							)]
           A_						       =   [np.asarray(UpperCamelCase__							) for speech_input in speech_inputs]

           # Test not batched input
           A_						       =   feat_extract(speech_inputs[0]		,					return_tensors="""np"""							).input_values
           A_						       =   feat_extract(np_speech_inputs[0]		,					return_tensors="""np"""							).input_values
           self.assertTrue(np.allclose(UpperCamelCase__		,					UpperCamelCase__		,					atol=1e-3							)							)

           # Test batched
           A_						       =   feat_extract(UpperCamelCase__		,					padding=UpperCamelCase__		,					return_tensors="""np"""							).input_values
           A_						       =   feat_extract(UpperCamelCase__		,					padding=UpperCamelCase__		,					return_tensors="""np"""							).input_values
           for enc_seq_a, enc_seq_a in zip(UpperCamelCase__		,					UpperCamelCase__							):
                  self.assertTrue(np.allclose(UpperCamelCase__		,					UpperCamelCase__		,					atol=1e-3							)							)

           # Test 2-D numpy arrays are batched.
           A_						       =   [floats_list((1, x)							)[0] for x in (800, 800, 800)]
           A_						       =   np.asarray(UpperCamelCase__							)
           A_						       =   feat_extract(UpperCamelCase__		,					return_tensors="""np"""							).input_values
           A_						       =   feat_extract(UpperCamelCase__		,					return_tensors="""np"""							).input_values
           for enc_seq_a, enc_seq_a in zip(UpperCamelCase__		,					UpperCamelCase__							):
                  self.assertTrue(np.allclose(UpperCamelCase__		,					UpperCamelCase__		,					atol=1e-3							)							)



    @require_torch
    def        snake_case_      (       self							)    ->   Optional[int]:





           '''simple docstring'''
           import torch

           A_						       =   self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()							)
           A_						       =   np.random.rand(100							).astype(np.floataa							)
           A_						       =   np_speech_inputs.tolist()

           for inputs in [py_speech_inputs, np_speech_inputs]:
                  A_						       =   feature_extractor.pad([{"""input_values""": inputs}]		,					return_tensors="""np"""							)
                  self.assertTrue(np_processed.input_values.dtype == np.floataa							)
                  A_						       =   feature_extractor.pad([{"""input_values""": inputs}]		,					return_tensors="""pt"""							)
                  self.assertTrue(pt_processed.input_values.dtype == torch.floataa							)



    def        snake_case_      (       self		,					UpperCamelCase__							)    ->   List[str]:





           '''simple docstring'''
           from datasets import load_dataset

           A_						       =   load_dataset("""hf-internal-testing/librispeech_asr_dummy"""		,					"""clean"""		,					split="""validation"""							)
           # automatic decoding with librispeech
           A_						       =   ds.sort("""id"""							).select(range(UpperCamelCase__							)							)[:num_samples]["""audio"""]

           return [x["array"] for x in speech_samples]







    @require_torch
    def        snake_case_      (       self							)    ->   Dict:





           '''simple docstring'''
           # fmt: off
           A_						       =   torch.tensor(
               [-0.9894, -1.2776, -0.9066, -1.2776, -0.9349, -1.2609, -1.0386, -1.2776,
                -1.1561, -1.2776, -1.2052, -1.2723, -1.2190, -1.2132, -1.2776, -1.1133,
                -1.1953, -1.1343, -1.1584, -1.2203, -1.1770, -1.2474, -1.2381, -1.1936,
                -0.9270, -0.8317, -0.8049, -0.7706, -0.7565, -0.7869]							)
           # fmt: on

           A_						       =   self._load_datasamples(1							)
           A_						       =   ASTFeatureExtractor()
           A_						       =   feature_extractor(UpperCamelCase__		,					return_tensors="""pt"""							).input_values
           self.assertEquals(input_values.shape		,					(1, 1024, 128)							)
           self.assertTrue(torch.allclose(input_values[0, 0, :30]		,					UpperCamelCase__		,					atol=1e-4							)							)



'''simple docstring'''







from typing import TYPE_CHECKING

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


__lowerCamelCase									=     {
    '''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:
      __lowerCamelCase									=     ['''WhisperTokenizerFast''']

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

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

try:
      if not is_flax_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      __lowerCamelCase									=     [
          '''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

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