





import itertools
import random
import unittest

import numpy as np

from transformers import BatchFeature, SpeechTaFeatureExtractor
from transformers.testing_utils import require_torch
from transformers.utils.import_utils import is_torch_available

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_torch_available():
  import torch


_snake_case           =			random.Random()


def _A       (   __magic_name__  , __magic_name__=1.0  , __magic_name__=None  , __magic_name__=None	):
   if rng is None:
      lowercase__			       =  global_rng

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

   return values





@require_torch
class  lowerCAmelCase							(       unittest.TestCase ):







  def __init__(      self  :Union[str, Any]   ,							_lowercase  :Optional[Any]   ,							_lowercase  :List[Any]=7   ,							_lowercase  :Optional[Any]=4_00   ,							_lowercase  :Optional[Any]=20_00   ,							_lowercase  :Dict=1   ,							_lowercase  :Optional[int]=0.0   ,							_lowercase  :Tuple=1_60_00   ,							_lowercase  :str=True   ,							_lowercase  :Optional[Any]=80   ,							_lowercase  :List[str]=16   ,							_lowercase  :Optional[int]=64   ,							_lowercase  :Optional[int]="hann_window"   ,							_lowercase  :Any=80   ,							_lowercase  :int=76_00   ,							_lowercase  :Dict=1e-10   ,							_lowercase  :Union[str, Any]=True   ,							):






     '''simple docstring'''





     lowercase__			       =  parent
     lowercase__			       =  batch_size
     lowercase__			       =  min_seq_length
     lowercase__			       =  max_seq_length
     lowercase__			       =  (self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
     lowercase__			       =  feature_size
     lowercase__			       =  padding_value
     lowercase__			       =  sampling_rate
     lowercase__			       =  do_normalize
     lowercase__			       =  num_mel_bins
     lowercase__			       =  hop_length
     lowercase__			       =  win_length
     lowercase__			       =  win_function
     lowercase__			       =  fmin
     lowercase__			       =  fmax
     lowercase__			       =  mel_floor
     lowercase__			       =  return_attention_mask







  def   UpperCAmelCase					(      self  :Optional[Any] ):






     '''simple docstring'''





     return {
         "feature_size": self.feature_size,
         "padding_value": self.padding_value,
         "sampling_rate": self.sampling_rate,
         "do_normalize": self.do_normalize,
         "num_mel_bins": self.num_mel_bins,
         "hop_length": self.hop_length,
         "win_length": self.win_length,
         "win_function": self.win_function,
         "fmin": self.fmin,
         "fmax": self.fmax,
         "mel_floor": self.mel_floor,
         "return_attention_mask": self.return_attention_mask,
     }







  def   UpperCAmelCase					(      self  :Tuple   ,							_lowercase  :int=False   ,							_lowercase  :Optional[Any]=False ):






     '''simple docstring'''





     def _flatten(_lowercase  :Union[str, Any] ):
        return list(itertools.chain(*_lowercase ) )

     if equal_length:
        lowercase__			       =  floats_list((self.batch_size, self.max_seq_length) )
     else:
        # make sure that inputs increase in size
        lowercase__			       =  [
            _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:
        lowercase__			       =  [np.asarray(_lowercase ) for x in speech_inputs]

     return speech_inputs







  def   UpperCAmelCase					(      self  :List[Any]   ,							_lowercase  :Dict=False   ,							_lowercase  :Tuple=False ):






     '''simple docstring'''





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

     if numpify:
        lowercase__			       =  [np.asarray(_lowercase ) for x in speech_inputs]

     return speech_inputs





@require_torch
class  lowerCAmelCase							(       lowercase_							,							unittest.TestCase ):
  __lowerCamelCase		=      SpeechTaFeatureExtractor







  def   UpperCAmelCase					(      self  :Tuple ):






     '''simple docstring'''





     lowercase__			       =  SpeechTaFeatureExtractionTester(self )







  def   UpperCAmelCase					(      self  :List[str]   ,							_lowercase  :Union[str, Any] ):






     '''simple docstring'''





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







  def   UpperCAmelCase					(      self  :Optional[Any] ):






     '''simple docstring'''





     lowercase__			       =  self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() )
     # create three inputs of length 800, 1000, and 1200
     lowercase__			       =  [floats_list((1, x) )[0] for x in range(8_00   ,							14_00   ,							2_00 )]
     lowercase__			       =  [np.asarray(_lowercase ) for speech_input in speech_inputs]

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

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







  def   UpperCAmelCase					(      self  :int ):






     '''simple docstring'''





     lowercase__			       =  self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() )
     lowercase__			       =  [floats_list((1, x) )[0] for x in range(8_00   ,							14_00   ,							2_00 )]

     lowercase__			       =  ["longest", "max_length", "do_not_pad"]
     lowercase__			       =  [None, 16_00, None]
     for max_length, padding in zip(_lowercase   ,							_lowercase ):
        lowercase__			       =  feat_extract(_lowercase   ,							padding=_lowercase   ,							max_length=_lowercase   ,							return_tensors="np" )
        lowercase__			       =  processed.input_values

        self._check_zero_mean_unit_variance(input_values[0][:8_00] )
        self.assertTrue(input_values[0][8_00:].sum() < 1e-6 )
        self._check_zero_mean_unit_variance(input_values[1][:10_00] )
        self.assertTrue(input_values[0][10_00:].sum() < 1e-6 )
        self._check_zero_mean_unit_variance(input_values[2][:12_00] )







  def   UpperCAmelCase					(      self  :int ):






     '''simple docstring'''





     lowercase__			       =  self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() )
     lowercase__			       =  range(8_00   ,							14_00   ,							2_00 )
     lowercase__			       =  [floats_list((1, x) )[0] for x in lengths]

     lowercase__			       =  ["longest", "max_length", "do_not_pad"]
     lowercase__			       =  [None, 16_00, None]

     for max_length, padding in zip(_lowercase   ,							_lowercase ):
        lowercase__			       =  feat_extract(_lowercase   ,							max_length=_lowercase   ,							padding=_lowercase )
        lowercase__			       =  processed.input_values

        self._check_zero_mean_unit_variance(input_values[0][:8_00] )
        self._check_zero_mean_unit_variance(input_values[1][:10_00] )
        self._check_zero_mean_unit_variance(input_values[2][:12_00] )







  def   UpperCAmelCase					(      self  :Optional[int] ):






     '''simple docstring'''





     lowercase__			       =  self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() )
     lowercase__			       =  [floats_list((1, x) )[0] for x in range(8_00   ,							14_00   ,							2_00 )]
     lowercase__			       =  feat_extract(
         _lowercase   ,							truncation=_lowercase   ,							max_length=10_00   ,							padding="max_length"   ,							return_tensors="np" )
     lowercase__			       =  processed.input_values

     self._check_zero_mean_unit_variance(input_values[0, :8_00] )
     self._check_zero_mean_unit_variance(input_values[1] )
     self._check_zero_mean_unit_variance(input_values[2] )







  def   UpperCAmelCase					(      self  :Optional[Any] ):






     '''simple docstring'''





     lowercase__			       =  self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() )
     lowercase__			       =  [floats_list((1, x) )[0] for x in range(8_00   ,							14_00   ,							2_00 )]
     lowercase__			       =  feat_extract(
         _lowercase   ,							truncation=_lowercase   ,							max_length=10_00   ,							padding="longest"   ,							return_tensors="np" )
     lowercase__			       =  processed.input_values

     self._check_zero_mean_unit_variance(input_values[0, :8_00] )
     self._check_zero_mean_unit_variance(input_values[1, :10_00] )
     self._check_zero_mean_unit_variance(input_values[2] )

     # make sure that if max_length < longest -> then pad to max_length
     self.assertTrue(input_values.shape == (3, 10_00) )

     lowercase__			       =  [floats_list((1, x) )[0] for x in range(8_00   ,							14_00   ,							2_00 )]
     lowercase__			       =  feat_extract(
         _lowercase   ,							truncation=_lowercase   ,							max_length=20_00   ,							padding="longest"   ,							return_tensors="np" )
     lowercase__			       =  processed.input_values

     self._check_zero_mean_unit_variance(input_values[0, :8_00] )
     self._check_zero_mean_unit_variance(input_values[1, :10_00] )
     self._check_zero_mean_unit_variance(input_values[2] )

     # make sure that if max_length > longest -> then pad to longest
     self.assertTrue(input_values.shape == (3, 12_00) )







  def   UpperCAmelCase					(      self  :str ):






     '''simple docstring'''





     lowercase__			       =  self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() )
     lowercase__			       =  np.random.rand(1_00 ).astype(np.floataa )
     lowercase__			       =  np_speech_inputs.tolist()

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







  def   UpperCAmelCase					(      self  :Tuple ):






     '''simple docstring'''





     lowercase__			       =  self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() )
     # create three inputs of length 800, 1000, and 1200
     lowercase__			       =  [floats_list((1, x) )[0] for x in range(8_00   ,							14_00   ,							2_00 )]
     lowercase__			       =  [np.asarray(_lowercase ) for speech_input in speech_inputs]

     # Test feature size
     lowercase__			       =  feature_extractor(audio_target=_lowercase   ,							padding=_lowercase   ,							return_tensors="np" ).input_values
     self.assertTrue(input_values.ndim == 3 )
     self.assertTrue(input_values.shape[-1] == feature_extractor.num_mel_bins )

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

     # Test batched
     lowercase__			       =  feature_extractor(_lowercase   ,							return_tensors="np" ).input_values
     lowercase__			       =  feature_extractor(_lowercase   ,							return_tensors="np" ).input_values
     for enc_seq_a, enc_seq_a in zip(_lowercase   ,							_lowercase ):
        self.assertTrue(np.allclose(_lowercase   ,							_lowercase   ,							atol=1e-3 ) )

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







  def   UpperCAmelCase					(      self  :Tuple ):






     '''simple docstring'''





     lowercase__			       =  self.feat_extract_tester.prepare_inputs_for_target()
     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(_lowercase ) == len(_lowercase ) for x, y in zip(_lowercase   ,							processed_features[input_name] ) ) )

     lowercase__			       =  self.feat_extract_tester.prepare_inputs_for_target(equal_length=_lowercase )
     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.num_mel_bins) )







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






     '''simple docstring'''





     lowercase__			       =  self.feat_extract_tester.prepare_inputs_for_target(equal_length=_lowercase )
     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.num_mel_bins) )







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






     '''simple docstring'''





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

     lowercase__			       =  BatchFeature({input_name: speech_inputs} )

     lowercase__			       =  feat_extract.num_mel_bins  # hack!

     lowercase__			       =  feat_extract.pad(_lowercase   ,							padding="longest"   ,							return_tensors="np" )[input_name]
     lowercase__			       =  feat_extract.pad(_lowercase   ,							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 )







  def   UpperCAmelCase					(      self  :Optional[Any] ):






     '''simple docstring'''





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

     lowercase__			       =  BatchFeature({input_name: speech_inputs} )

     lowercase__			       =  feat_extract.num_mel_bins  # hack!

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







  def   UpperCAmelCase					(      self  :int ):






     '''simple docstring'''





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

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

     lowercase__			       =  feat_extract.num_mel_bins  # hack!

     lowercase__			       =  feat_extract.pad(
         _lowercase   ,							padding="max_length"   ,							max_length=_lowercase   ,							truncation=_lowercase   ,							return_tensors="np" )
     self.assertIn("attention_mask"   ,							_lowercase )
     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] )







  def   UpperCAmelCase					(      self  :Optional[Any]   ,							_lowercase  :str ):






     '''simple docstring'''





     from datasets import load_dataset

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

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







  def   UpperCAmelCase					(      self  :Optional[int] ):






     '''simple docstring'''





     lowercase__			       =  torch.tensor(
         [2.38_04e-03, 2.07_52e-03, 1.98_36e-03, 2.10_57e-03, 1.61_74e-03,
          3.05_18e-04, 9.15_53e-05, 3.35_69e-04, 9.76_56e-04, 1.83_11e-03,
          2.01_42e-03, 2.10_57e-03, 1.73_95e-03, 4.57_76e-04, -3.96_73e-04,
          4.57_76e-04, 1.00_71e-03, 9.15_53e-05, 4.88_28e-04, 1.15_97e-03,
          7.32_42e-04, 9.46_04e-04, 1.80_05e-03, 1.83_11e-03, 8.85_01e-04,
          4.27_25e-04, 4.88_28e-04, 7.32_42e-04, 1.09_86e-03, 2.10_57e-03] )
     # fmt: on

     lowercase__			       =  self._load_datasamples(1 )
     lowercase__			       =  SpeechTaFeatureExtractor()
     lowercase__			       =  feature_extractor(_lowercase   ,							return_tensors="pt" ).input_values
     self.assertEquals(input_values.shape   ,							(1, 9_36_80) )
     self.assertTrue(torch.allclose(input_values[0, :30]   ,							_lowercase   ,							atol=1e-6 ) )







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






     '''simple docstring'''





     lowercase__			       =  torch.tensor(
         [-2.6870, -3.0104, -3.1356, -3.5352, -3.0044, -3.0353, -3.4719, -3.6777,
          -3.1520, -2.9435, -2.6553, -2.8795, -2.9944, -2.5921, -3.0279, -3.0386,
          -3.0864, -3.1291, -3.2353, -2.7444, -2.6831, -2.7287, -3.1761, -3.1571,
          -3.2726, -3.0582, -3.1007, -3.4533, -3.4695, -3.0998] )
     # fmt: on

     lowercase__			       =  self._load_datasamples(1 )
     lowercase__			       =  SpeechTaFeatureExtractor()
     lowercase__			       =  feature_extractor(audio_target=_lowercase   ,							return_tensors="pt" ).input_values
     self.assertEquals(input_values.shape   ,							(1, 3_66, 80) )
     self.assertTrue(torch.allclose(input_values[0, 0, :30]   ,							_lowercase   ,							atol=1e-4 ) )













from itertools import count


def _A       (   __magic_name__ = 50	):
   lowercase__			       =  [1] * min_block_length

   for n in count(__magic_name__	):
      fill_count_functions.append(1	)

      for block_length in range(__magic_name__  , n + 1	):
         for block_start in range(n - block_length	):
            fill_count_functions[n] += fill_count_functions[
                n - block_start - block_length - 1
            ]

         fill_count_functions[n] += 1

      if fill_count_functions[n] > 100_0000:
         break

   return n


if __name__ == "__main__":
  print(F"""{solution() = }""")






