





import itertools
import os
import random
import tempfile
import unittest

import numpy as np
from datasets import load_dataset

from transformers import is_speech_available
from transformers.testing_utils import check_json_file_has_correct_format, require_torch, require_torchaudio
from transformers.utils.import_utils import is_torch_available

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_speech_available():
       from transformers import WhisperFeatureExtractor

if is_torch_available():
       import torch

_lowerCamelCase      							=   random.Random()




def  __UpperCAmelCase(   lowercase_			,     lowercase_=1.0			,     lowercase_=None			,     lowercase_=None   ):
       if rng is None:
              _lowerCamelCase				:  str						=		global_rng

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

       return values







@require_torch
@require_torchaudio
class       __A							(   unittest.TestCase	):




      """simple docstring"""







      def __init__(		self   ,				a__   ,				a__=7   ,				a__=400   ,				a__=2000   ,				a__=10   ,				a__=160   ,				a__=8   ,				a__=0.0   ,				a__=4000   ,				a__=False   ,				a__=True   ,				):



             """simple docstring"""





             _lowerCamelCase				:  List[Any]						=		parent
             _lowerCamelCase				:  int						=		batch_size
             _lowerCamelCase				:  int						=		min_seq_length
             _lowerCamelCase				:  List[str]						=		max_seq_length
             _lowerCamelCase				:  Union[str, Any]						=		(self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
             _lowerCamelCase				:  Tuple						=		padding_value
             _lowerCamelCase				:  Optional[int]						=		sampling_rate
             _lowerCamelCase				:  Any						=		return_attention_mask
             _lowerCamelCase				:  Union[str, Any]						=		do_normalize
             _lowerCamelCase				:  str						=		feature_size
             _lowerCamelCase				:  str						=		chunk_length
             _lowerCamelCase				:  Optional[int]						=		hop_length


      def 					__snake_case      (		self):



             """simple docstring"""





             return {
                 "feature_size": self.feature_size,
                 "hop_length": self.hop_length,
                 "chunk_length": self.chunk_length,
                 "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   ,				a__=False   ,				a__=False):



             """simple docstring"""





             def _flatten(a__):
                    return list(itertools.chain(*a__))

             if equal_length:
                    _lowerCamelCase				:  Optional[Any]						=		[floats_list((self.max_seq_length, self.feature_size)) for _ in range(self.batch_size)]
             else:
                    # make sure that inputs increase in size
                    _lowerCamelCase				:  List[str]						=		[
                        floats_list((x, self.feature_size))
                        for x in range(self.min_seq_length   ,				self.max_seq_length   ,				self.seq_length_diff)
                    ]
             if numpify:
                    _lowerCamelCase				:  Union[str, Any]						=		[np.asarray(a__) for x in speech_inputs]
             return speech_inputs







@require_torch
@require_torchaudio
class       __A							(   lowerCamelCase__			,unittest.TestCase	):




      """simple docstring"""







      UpperCAmelCase__							=   WhisperFeatureExtractor if is_speech_available() else None


      def 					__snake_case      (		self):



             """simple docstring"""





             _lowerCamelCase				:  str						=		WhisperFeatureExtractionTester(self)


      def 					__snake_case      (		self):



             """simple docstring"""





             _lowerCamelCase				:  Optional[int]						=		self.feature_extraction_class(**self.feat_extract_dict)

             with tempfile.TemporaryDirectory() as tmpdirname:
                    _lowerCamelCase				:  Optional[Any]						=		feat_extract_first.save_pretrained(a__)[0]
                    check_json_file_has_correct_format(a__)
                    _lowerCamelCase				:  Any						=		self.feature_extraction_class.from_pretrained(a__)

             _lowerCamelCase				:  List[str]						=		feat_extract_first.to_dict()
             _lowerCamelCase				:  str						=		feat_extract_second.to_dict()
             _lowerCamelCase				:  Any						=		feat_extract_first.mel_filters
             _lowerCamelCase				:  Union[str, Any]						=		feat_extract_second.mel_filters
             self.assertTrue(np.allclose(a__   ,				a__))
             self.assertEqual(a__   ,				a__)


      def 					__snake_case      (		self):



             """simple docstring"""





             _lowerCamelCase				:  str						=		self.feature_extraction_class(**self.feat_extract_dict)

             with tempfile.TemporaryDirectory() as tmpdirname:
                    _lowerCamelCase				:  List[str]						=		os.path.join(a__   ,				'''feat_extract.json''')
                    feat_extract_first.to_json_file(a__)
                    _lowerCamelCase				:  List[Any]						=		self.feature_extraction_class.from_json_file(a__)

             _lowerCamelCase				:  Any						=		feat_extract_first.to_dict()
             _lowerCamelCase				:  List[Any]						=		feat_extract_second.to_dict()
             _lowerCamelCase				:  Optional[Any]						=		feat_extract_first.mel_filters
             _lowerCamelCase				:  str						=		feat_extract_second.mel_filters
             self.assertTrue(np.allclose(a__   ,				a__))
             self.assertEqual(a__   ,				a__)


      def 					__snake_case      (		self):



             """simple docstring"""





             _lowerCamelCase				:  Dict						=		self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict())
             # create three inputs of length 800, 1000, and 1200
             _lowerCamelCase				:  Any						=		[floats_list((1, x))[0] for x in range(800   ,				1400   ,				200)]
             _lowerCamelCase				:  Any						=		[np.asarray(a__) for speech_input in speech_inputs]

             # Test feature size
             _lowerCamelCase				:  str						=		feature_extractor(a__   ,				padding='''max_length'''   ,				return_tensors='''np''').input_features
             self.assertTrue(input_features.ndim == 3)
             self.assertTrue(input_features.shape[-1] == feature_extractor.nb_max_frames)
             self.assertTrue(input_features.shape[-2] == feature_extractor.feature_size)

             # Test not batched input
             _lowerCamelCase				:  List[str]						=		feature_extractor(speech_inputs[0]   ,				return_tensors='''np''').input_features
             _lowerCamelCase				:  str						=		feature_extractor(np_speech_inputs[0]   ,				return_tensors='''np''').input_features
             self.assertTrue(np.allclose(a__   ,				a__   ,				atol=1e-3))

             # Test batched
             _lowerCamelCase				:  Dict						=		feature_extractor(a__   ,				return_tensors='''np''').input_features
             _lowerCamelCase				:  Any						=		feature_extractor(a__   ,				return_tensors='''np''').input_features
             for enc_seq_a, enc_seq_a in zip(a__   ,				a__):
                    self.assertTrue(np.allclose(a__   ,				a__   ,				atol=1e-3))

             # Test 2-D numpy arrays are batched.
             _lowerCamelCase				:  int						=		[floats_list((1, x))[0] for x in (800, 800, 800)]
             _lowerCamelCase				:  Optional[int]						=		np.asarray(a__)
             _lowerCamelCase				:  str						=		feature_extractor(a__   ,				return_tensors='''np''').input_features
             _lowerCamelCase				:  Union[str, Any]						=		feature_extractor(a__   ,				return_tensors='''np''').input_features
             for enc_seq_a, enc_seq_a in zip(a__   ,				a__):
                    self.assertTrue(np.allclose(a__   ,				a__   ,				atol=1e-3))

             # Test truncation required
             _lowerCamelCase				:  Any						=		[floats_list((1, x))[0] for x in range(200   ,				(feature_extractor.n_samples + 500)   ,				200)]
             _lowerCamelCase				:  List[str]						=		[np.asarray(a__) for speech_input in speech_inputs]

             _lowerCamelCase				:  Any						=		[x[: feature_extractor.n_samples] for x in speech_inputs]
             _lowerCamelCase				:  Dict						=		[np.asarray(a__) for speech_input in speech_inputs_truncated]

             _lowerCamelCase				:  int						=		feature_extractor(a__   ,				return_tensors='''np''').input_features
             _lowerCamelCase				:  Tuple						=		feature_extractor(a__   ,				return_tensors='''np''').input_features
             for enc_seq_a, enc_seq_a in zip(a__   ,				a__):
                    self.assertTrue(np.allclose(a__   ,				a__   ,				atol=1e-3))


      def 					__snake_case      (		self):



             """simple docstring"""





             import torch

             _lowerCamelCase				:  str						=		self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict())
             _lowerCamelCase				:  Any						=		np.random.rand(100   ,				32).astype(np.floataa)
             _lowerCamelCase				:  Tuple						=		np_speech_inputs.tolist()

             for inputs in [py_speech_inputs, np_speech_inputs]:
                    _lowerCamelCase				:  Optional[Any]						=		feature_extractor.pad([{'''input_features''': inputs}]   ,				return_tensors='''np''')
                    self.assertTrue(np_processed.input_features.dtype == np.floataa)
                    _lowerCamelCase				:  List[Any]						=		feature_extractor.pad([{'''input_features''': inputs}]   ,				return_tensors='''pt''')
                    self.assertTrue(pt_processed.input_features.dtype == torch.floataa)


      def 					__snake_case      (		self   ,				a__):



             """simple docstring"""





             _lowerCamelCase				:  str						=		load_dataset('''hf-internal-testing/librispeech_asr_dummy'''   ,				'''clean'''   ,				split='''validation''')
             # automatic decoding with librispeech
             _lowerCamelCase				:  Optional[Any]						=		ds.sort('''id''').select(range(a__))[:num_samples]['''audio''']

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


      def 					__snake_case      (		self):



             """simple docstring"""





             _lowerCamelCase				:  Any						=		torch.tensor(
                 [
                     0.1193, -0.0946, -0.1098, -0.0196, 0.0225, -0.0690, -0.1736, 0.0951,
                     0.0971, -0.0817, -0.0702, 0.0162, 0.0260, 0.0017, -0.0192, -0.1678,
                     0.0709, -0.1867, -0.0655, -0.0274, -0.0234, -0.1884, -0.0516, -0.0554,
                     -0.0274, -0.1425, -0.1423, 0.0837, 0.0377, -0.0854
                 ])
             # fmt: on

             _lowerCamelCase				:  int						=		self._load_datasamples(1)
             _lowerCamelCase				:  Optional[int]						=		WhisperFeatureExtractor()
             _lowerCamelCase				:  Union[str, Any]						=		feature_extractor(a__   ,				return_tensors='''pt''').input_features
             self.assertEqual(input_features.shape   ,				(1, 80, 3000))
             self.assertTrue(torch.allclose(input_features[0, 0, :30]   ,				a__   ,				atol=1e-4))



      def 					__snake_case      (		self):



             """simple docstring"""





             _lowerCamelCase				:  Optional[int]						=		self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict())
             _lowerCamelCase				:  Union[str, Any]						=		self._load_datasamples(1)[0]
             _lowerCamelCase				:  Union[str, Any]						=		((audio - audio.min()) / (audio.max() - audio.min())) * 6_5535  # Rescale to [0, 65535] to show issue
             _lowerCamelCase				:  List[str]						=		feat_extract.zero_mean_unit_var_norm([audio]   ,				attention_mask=a__)[0]

             self.assertTrue(np.all(np.mean(a__) < 1e-3))
             self.assertTrue(np.all(np.abs(np.var(a__) - 1) < 1e-3))








import warnings

from ...utils import logging
from .image_processing_deit import DeiTImageProcessor


_lowerCamelCase      							=   logging.get_logger(__name__)







class       __A							(   lowerCamelCase__	):




      """simple docstring"""







      def __init__(		self   ,				*a__   ,				**a__):



             """simple docstring"""





             warnings.warn(
                 '''The class DeiTFeatureExtractor is deprecated and will be removed in version 5 of Transformers. Please'''
                 ''' use DeiTImageProcessor instead.'''   ,				a__   ,				)
             super().__init__(*a__   ,				**a__)

