





'''simple docstring'''

import itertools
import random
import unittest

import numpy as np

from transformers import is_speech_available
from transformers.testing_utils import require_torch, require_torchaudio

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_speech_available():
    from transformers import SpeechaTextFeatureExtractor

a   	=    random.Random()

def     __magic_name__							(				__UpperCAmelCase				,						__UpperCAmelCase=1.0				,						__UpperCAmelCase=None				,						__UpperCAmelCase=None   )    ->       List[Any]:

   '''simple docstring'''







   if rng is None:
      __SCREAMING_SNAKE_CASE   				=							global_rng

   __SCREAMING_SNAKE_CASE   				=							[]
   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      ):





   def __init__(       self					:      Dict					,lowerCamelCase					:      Any					,lowerCamelCase					:      List[str]=7					,lowerCamelCase					:      Dict=400					,lowerCamelCase					:      Optional[Any]=2000					,lowerCamelCase					:      Tuple=24					,lowerCamelCase					:      Optional[Any]=24					,lowerCamelCase					:      Any=0.0					,lowerCamelCase					:      List[Any]=1_6000					,lowerCamelCase					:      List[str]=True					,lowerCamelCase					:      str=True					,):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							parent
      __SCREAMING_SNAKE_CASE   				=							batch_size
      __SCREAMING_SNAKE_CASE   				=							min_seq_length
      __SCREAMING_SNAKE_CASE   				=							max_seq_length
      __SCREAMING_SNAKE_CASE   				=							(self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
      __SCREAMING_SNAKE_CASE   				=							feature_size
      __SCREAMING_SNAKE_CASE   				=							num_mel_bins
      __SCREAMING_SNAKE_CASE   				=							padding_value
      __SCREAMING_SNAKE_CASE   				=							sampling_rate
      __SCREAMING_SNAKE_CASE   				=							return_attention_mask
      __SCREAMING_SNAKE_CASE   				=							do_normalize





   def   UpperCAmelCase__  (       self					:      List[Any]     ):

      '''simple docstring'''

      return {
          "feature_size": self.feature_size,
          "num_mel_bins": self.num_mel_bins,
          "padding_value": self.padding_value,
          "sampling_rate": self.sampling_rate,
          "return_attention_mask": self.return_attention_mask,
          "do_normalize": self.do_normalize,
      }





   def   UpperCAmelCase__  (       self					:      Optional[Any]					,lowerCamelCase					:      Dict=False					,lowerCamelCase					:      Optional[int]=False     ):

      '''simple docstring'''

      def _flatten(lowerCamelCase					:      Optional[Any]     ):
         return list(itertools.chain(*lowerCamelCase     )     )

      if equal_length:
         __SCREAMING_SNAKE_CASE   				=							[floats_list((self.max_seq_length, self.feature_size)     ) for _ in range(self.batch_size     )]
      else:
         # make sure that inputs increase in size
         __SCREAMING_SNAKE_CASE   				=							[
             floats_list((x, self.feature_size)     )
             for x in range(self.min_seq_length					,self.max_seq_length					,self.seq_length_diff     )
         ]
      if numpify:
         __SCREAMING_SNAKE_CASE   				=							[np.asarray(lowerCamelCase     ) for x in speech_inputs]
      return speech_inputs







@require_torch
@require_torchaudio
class __a			( _snake_case, unittest.TestCase      ):
   __UpperCamelCase :			Tuple						   =						SpeechaTextFeatureExtractor if is_speech_available() else None





   def   UpperCAmelCase__  (       self					:      Any     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							SpeechaTextFeatureExtractionTester(self     )





   def   UpperCAmelCase__  (       self					:      int					,lowerCamelCase					:      Tuple     ):

      '''simple docstring'''

      self.assertTrue(np.all(np.mean(lowerCamelCase					,axis=0     ) < 1E-3     )     )
      self.assertTrue(np.all(np.abs(np.var(lowerCamelCase					,axis=0     ) - 1     ) < 1E-3     )     )





   def   UpperCAmelCase__  (       self					:      List[Any]     ):

      '''simple docstring'''

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

      # Test feature size
      __SCREAMING_SNAKE_CASE   				=							feature_extractor(lowerCamelCase					,padding=lowerCamelCase					,return_tensors="""np"""     ).input_features
      self.assertTrue(input_features.ndim == 3     )
      self.assertTrue(input_features.shape[-1] == feature_extractor.feature_size     )

      # Test not batched input
      __SCREAMING_SNAKE_CASE   				=							feature_extractor(speech_inputs[0]					,return_tensors="""np"""     ).input_features
      __SCREAMING_SNAKE_CASE   				=							feature_extractor(np_speech_inputs[0]					,return_tensors="""np"""     ).input_features
      self.assertTrue(np.allclose(lowerCamelCase					,lowerCamelCase					,atol=1E-3     )     )

      # Test batched
      __SCREAMING_SNAKE_CASE   				=							feature_extractor(lowerCamelCase					,return_tensors="""np"""     ).input_features
      __SCREAMING_SNAKE_CASE   				=							feature_extractor(lowerCamelCase					,return_tensors="""np"""     ).input_features
      for enc_seq_a, enc_seq_a in zip(lowerCamelCase					,lowerCamelCase     ):
         self.assertTrue(np.allclose(lowerCamelCase					,lowerCamelCase					,atol=1E-3     )     )

      # Test 2-D numpy arrays are batched.
      __SCREAMING_SNAKE_CASE   				=							[floats_list((1, x)     )[0] for x in (800, 800, 800)]
      __SCREAMING_SNAKE_CASE   				=							np.asarray(lowerCamelCase     )
      __SCREAMING_SNAKE_CASE   				=							feature_extractor(lowerCamelCase					,return_tensors="""np"""     ).input_features
      __SCREAMING_SNAKE_CASE   				=							feature_extractor(lowerCamelCase					,return_tensors="""np"""     ).input_features
      for enc_seq_a, enc_seq_a in zip(lowerCamelCase					,lowerCamelCase     ):
         self.assertTrue(np.allclose(lowerCamelCase					,lowerCamelCase					,atol=1E-3     )     )





   def   UpperCAmelCase__  (       self					:      Optional[Any]     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()     )
      __SCREAMING_SNAKE_CASE   				=							[floats_list((1, x)     )[0] for x in range(800					,1400					,200     )]

      __SCREAMING_SNAKE_CASE   				=							["""longest""", """max_length""", """do_not_pad"""]
      __SCREAMING_SNAKE_CASE   				=							[None, 16, None]
      for max_length, padding in zip(lowerCamelCase					,lowerCamelCase     ):
         __SCREAMING_SNAKE_CASE   				=							feature_extractor(
             lowerCamelCase					,padding=lowerCamelCase					,max_length=lowerCamelCase					,return_attention_mask=lowerCamelCase     )
         __SCREAMING_SNAKE_CASE   				=							inputs.input_features
         __SCREAMING_SNAKE_CASE   				=							inputs.attention_mask
         __SCREAMING_SNAKE_CASE   				=							[np.sum(lowerCamelCase     ) for x in attention_mask]

         self._check_zero_mean_unit_variance(input_features[0][: fbank_feat_lengths[0]]     )
         self._check_zero_mean_unit_variance(input_features[1][: fbank_feat_lengths[1]]     )
         self._check_zero_mean_unit_variance(input_features[2][: fbank_feat_lengths[2]]     )





   def   UpperCAmelCase__  (       self					:      Tuple     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()     )
      __SCREAMING_SNAKE_CASE   				=							[floats_list((1, x)     )[0] for x in range(800					,1400					,200     )]

      __SCREAMING_SNAKE_CASE   				=							["""longest""", """max_length""", """do_not_pad"""]
      __SCREAMING_SNAKE_CASE   				=							[None, 16, None]
      for max_length, padding in zip(lowerCamelCase					,lowerCamelCase     ):
         __SCREAMING_SNAKE_CASE   				=							feature_extractor(
             lowerCamelCase					,max_length=lowerCamelCase					,padding=lowerCamelCase					,return_tensors="""np"""					,return_attention_mask=lowerCamelCase     )
         __SCREAMING_SNAKE_CASE   				=							inputs.input_features
         __SCREAMING_SNAKE_CASE   				=							inputs.attention_mask
         __SCREAMING_SNAKE_CASE   				=							[np.sum(lowerCamelCase     ) for x in attention_mask]

         self._check_zero_mean_unit_variance(input_features[0][: fbank_feat_lengths[0]]     )
         self.assertTrue(input_features[0][fbank_feat_lengths[0] :].sum() < 1E-6     )
         self._check_zero_mean_unit_variance(input_features[1][: fbank_feat_lengths[1]]     )
         self.assertTrue(input_features[0][fbank_feat_lengths[1] :].sum() < 1E-6     )
         self._check_zero_mean_unit_variance(input_features[2][: fbank_feat_lengths[2]]     )





   def   UpperCAmelCase__  (       self					:      Dict     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()     )
      __SCREAMING_SNAKE_CASE   				=							[floats_list((1, x)     )[0] for x in range(800					,1400					,200     )]
      __SCREAMING_SNAKE_CASE   				=							feature_extractor(
          lowerCamelCase					,padding="""max_length"""					,max_length=4					,truncation=lowerCamelCase					,return_tensors="""np"""					,return_attention_mask=lowerCamelCase					,)
      __SCREAMING_SNAKE_CASE   				=							inputs.input_features
      __SCREAMING_SNAKE_CASE   				=							inputs.attention_mask
      __SCREAMING_SNAKE_CASE   				=							np.sum(attention_mask == 1					,axis=1     )

      self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]]     )
      self._check_zero_mean_unit_variance(input_features[1]     )
      self._check_zero_mean_unit_variance(input_features[2]     )





   def   UpperCAmelCase__  (       self					:      List[str]     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()     )
      __SCREAMING_SNAKE_CASE   				=							[floats_list((1, x)     )[0] for x in range(800					,1400					,200     )]
      __SCREAMING_SNAKE_CASE   				=							feature_extractor(
          lowerCamelCase					,padding="""longest"""					,max_length=4					,truncation=lowerCamelCase					,return_tensors="""np"""					,return_attention_mask=lowerCamelCase					,)
      __SCREAMING_SNAKE_CASE   				=							inputs.input_features
      __SCREAMING_SNAKE_CASE   				=							inputs.attention_mask
      __SCREAMING_SNAKE_CASE   				=							np.sum(attention_mask == 1					,axis=1     )

      self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]]     )
      self._check_zero_mean_unit_variance(input_features[1, : fbank_feat_lengths[1]]     )
      self._check_zero_mean_unit_variance(input_features[2]     )

      # make sure that if max_length < longest -> then pad to max_length
      self.assertEqual(input_features.shape					,(3, 4, 24)     )

      __SCREAMING_SNAKE_CASE   				=							[floats_list((1, x)     )[0] for x in range(800					,1400					,200     )]
      __SCREAMING_SNAKE_CASE   				=							feature_extractor(
          lowerCamelCase					,padding="""longest"""					,max_length=16					,truncation=lowerCamelCase					,return_tensors="""np"""					,return_attention_mask=lowerCamelCase					,)
      __SCREAMING_SNAKE_CASE   				=							inputs.input_features
      __SCREAMING_SNAKE_CASE   				=							inputs.attention_mask
      __SCREAMING_SNAKE_CASE   				=							np.sum(attention_mask == 1					,axis=1     )

      self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]]     )
      self._check_zero_mean_unit_variance(input_features[1, : fbank_feat_lengths[1]]     )
      self._check_zero_mean_unit_variance(input_features[2]     )

      # make sure that if max_length < longest -> then pad to max_length
      self.assertEqual(input_features.shape					,(3, 6, 24)     )





   def   UpperCAmelCase__  (       self					:      str     ):

      '''simple docstring'''

      import torch

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

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





   def   UpperCAmelCase__  (       self					:      Optional[int]					,lowerCamelCase					:      Union[str, Any]     ):

      '''simple docstring'''

      from datasets import load_dataset

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

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





   def   UpperCAmelCase__  (       self					:      List[Any]     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							np.array([
          -1.5_745, -1.7_713, -1.7_020, -1.6_069, -1.2_250, -1.1_105, -0.9_072, -0.8_241,
          -1.2_310, -0.8_098, -0.3_320, -0.4_101, -0.7_985, -0.4_996, -0.8_213, -0.9_128,
          -1.0_420, -1.1_286, -1.0_440, -0.7_999, -0.8_405, -1.2_275, -1.5_443, -1.4_625,
      ]     )
      # fmt: on

      __SCREAMING_SNAKE_CASE   				=							self._load_datasamples(1     )
      __SCREAMING_SNAKE_CASE   				=							self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()     )
      __SCREAMING_SNAKE_CASE   				=							feature_extractor(lowerCamelCase					,return_tensors="""pt"""     ).input_features
      self.assertEquals(input_features.shape					,(1, 584, 24)     )
      self.assertTrue(np.allclose(input_features[0, 0, :30]					,lowerCamelCase					,atol=1E-4     )     )












'''simple docstring'''

from typing import TYPE_CHECKING

# rely on isort to merge the imports
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


a   	=    {
    "configuration_informer": [
        "INFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "InformerConfig",
    ],
}

try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    a   	=    [
        "INFORMER_PRETRAINED_MODEL_ARCHIVE_LIST",
        "InformerForPrediction",
        "InformerModel",
        "InformerPreTrainedModel",
    ]


if TYPE_CHECKING:
    from .configuration_informer import INFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, InformerConfig

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_informer import (
            INFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
            InformerForPrediction,
            InformerModel,
            InformerPreTrainedModel,
        )

else:
    import sys

    a   	=    _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)





