


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


SCREAMING_SNAKE_CASE							    =							random.Random()




def  a   (lowerCAmelCase__		,				lowerCAmelCase__=1.0		,				lowerCAmelCase__=None		,				lowerCAmelCase__=None   ):







   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


@require_torch
class     __UpperCAmelCase							(       unittest.TestCase							):


     """simple docstring"""


     def __init__(	self  ,       __A  ,       __A=7  ,       __A=400  ,       __A=2000  ,       __A=1  ,       __A=0.0  ,       __A=16000  ,       __A=True  ,       __A=80  ,       __A=16  ,       __A=64  ,       __A="hann_window"  ,       __A=80  ,       __A=7600  ,       __A=1E-10  ,       __A=True  ,       ):
        __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					=  do_normalize
        __a					=  num_mel_bins
        __a					=  hop_length
        __a					=  win_length
        __a					=  win_function
        __a					=  fmin
        __a					=  fmax
        __a					=  mel_floor
        __a					=  return_attention_mask


     def 	snake_case_  (	self    ):
        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 	snake_case_  (	self  ,       __A=False  ,       __A=False    ):


        def _flatten(__A    ):
           return list(itertools.chain(*A_    )    )

        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(A_    ) for x in speech_inputs]

        return speech_inputs


     def 	snake_case_  (	self  ,       __A=False  ,       __A=False    ):


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

        return speech_inputs







@require_torch
class     __UpperCAmelCase							(       _a ,					unittest.TestCase							):


     """simple docstring"""
     _lowerCamelCase   =      SpeechTaFeatureExtractor


     def 	snake_case_  (	self    ):
        __a					=  SpeechTaFeatureExtractionTester(self    )


     def 	snake_case_  (	self  ,       __A    ):
        self.assertTrue(np.all(np.mean(A_  ,       axis=0    ) < 1E-3    )    )
        self.assertTrue(np.all(np.abs(np.var(A_  ,       axis=0    ) - 1    ) < 1E-3    )    )


     def 	snake_case_  (	self    ):
        __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(A_    ) 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(A_  ,       A_  ,       atol=1E-3    )    )

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


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

        __a					=  ["""longest""", """max_length""", """do_not_pad"""]
        __a					=  [None, 1600, None]
        for max_length, padding in zip(A_  ,       A_    ):
           __a					=  feat_extract(A_  ,       padding=A_  ,       max_length=A_  ,       return_tensors="""np"""    )
           __a					=  processed.input_values

           self._check_zero_mean_unit_variance(input_values[0][:800]    )
           self.assertTrue(input_values[0][800:].sum() < 1E-6    )
           self._check_zero_mean_unit_variance(input_values[1][:1000]    )
           self.assertTrue(input_values[0][1000:].sum() < 1E-6    )
           self._check_zero_mean_unit_variance(input_values[2][:1200]    )


     def 	snake_case_  (	self    ):
        __a					=  self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()    )
        __a					=  range(800  ,       1400  ,       200    )
        __a					=  [floats_list((1, x)    )[0] for x in lengths]

        __a					=  ["""longest""", """max_length""", """do_not_pad"""]
        __a					=  [None, 1600, None]

        for max_length, padding in zip(A_  ,       A_    ):
           __a					=  feat_extract(A_  ,       max_length=A_  ,       padding=A_    )
           __a					=  processed.input_values

           self._check_zero_mean_unit_variance(input_values[0][:800]    )
           self._check_zero_mean_unit_variance(input_values[1][:1000]    )
           self._check_zero_mean_unit_variance(input_values[2][:1200]    )


     def 	snake_case_  (	self    ):
        __a					=  self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()    )
        __a					=  [floats_list((1, x)    )[0] for x in range(800  ,       1400  ,       200    )]
        __a					=  feat_extract(
            A_  ,       truncation=A_  ,       max_length=1000  ,       padding="""max_length"""  ,       return_tensors="""np"""    )
        __a					=  processed.input_values

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


     def 	snake_case_  (	self    ):
        __a					=  self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()    )
        __a					=  [floats_list((1, x)    )[0] for x in range(800  ,       1400  ,       200    )]
        __a					=  feat_extract(
            A_  ,       truncation=A_  ,       max_length=1000  ,       padding="""longest"""  ,       return_tensors="""np"""    )
        __a					=  processed.input_values

        self._check_zero_mean_unit_variance(input_values[0, :800]    )
        self._check_zero_mean_unit_variance(input_values[1, :1000]    )
        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, 1000)    )

        __a					=  [floats_list((1, x)    )[0] for x in range(800  ,       1400  ,       200    )]
        __a					=  feat_extract(
            A_  ,       truncation=A_  ,       max_length=2000  ,       padding="""longest"""  ,       return_tensors="""np"""    )
        __a					=  processed.input_values

        self._check_zero_mean_unit_variance(input_values[0, :800]    )
        self._check_zero_mean_unit_variance(input_values[1, :1000]    )
        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, 1200)    )


     def 	snake_case_  (	self    ):
        __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    ):
        __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(A_    ) for speech_input in speech_inputs]

        # Test feature size
        __a					=  feature_extractor(audio_target=A_  ,       padding=A_  ,       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
        __a					=  feature_extractor(speech_inputs[0]  ,       return_tensors="""np"""    ).input_values
        __a					=  feature_extractor(np_speech_inputs[0]  ,       return_tensors="""np"""    ).input_values
        self.assertTrue(np.allclose(A_  ,       A_  ,       atol=1E-3    )    )

        # Test batched
        __a					=  feature_extractor(A_  ,       return_tensors="""np"""    ).input_values
        __a					=  feature_extractor(A_  ,       return_tensors="""np"""    ).input_values
        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.
        __a					=  [floats_list((1, x)    )[0] for x in (800, 800, 800)]
        __a					=  np.asarray(A_    )
        __a					=  feature_extractor(A_  ,       return_tensors="""np"""    ).input_values
        __a					=  feature_extractor(A_  ,       return_tensors="""np"""    ).input_values
        for enc_seq_a, enc_seq_a in zip(A_  ,       A_    ):
           self.assertTrue(np.allclose(A_  ,       A_  ,       atol=1E-3    )    )


     def 	snake_case_  (	self    ):
        __a					=  self.feat_extract_tester.prepare_inputs_for_target()
        __a					=  self.feature_extraction_class(**self.feat_extract_dict    )
        __a					=  feat_extract.model_input_names[0]

        __a					=  BatchFeature({input_name: speech_inputs}    )

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

        __a					=  self.feat_extract_tester.prepare_inputs_for_target(equal_length=A_    )
        __a					=  BatchFeature({input_name: speech_inputs}  ,       tensor_type="""np"""    )

        __a					=  processed_features[input_name]

        if len(batch_features_input.shape    ) < 3:
           __a					=  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 	snake_case_  (	self    ):
        __a					=  self.feat_extract_tester.prepare_inputs_for_target(equal_length=A_    )
        __a					=  self.feature_extraction_class(**self.feat_extract_dict    )
        __a					=  feat_extract.model_input_names[0]

        __a					=  BatchFeature({input_name: speech_inputs}  ,       tensor_type="""pt"""    )

        __a					=  processed_features[input_name]

        if len(batch_features_input.shape    ) < 3:
           __a					=  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 	snake_case_  (	self    ):
        __a					=  self.feature_extraction_class(**self.feat_extract_dict    )
        __a					=  self.feat_extract_tester.prepare_inputs_for_target()
        __a					=  feat_extract.model_input_names[0]

        __a					=  BatchFeature({input_name: speech_inputs}    )

        __a					=  feat_extract.num_mel_bins  # hack!

        __a					=  feat_extract.pad(A_  ,       padding="""longest"""  ,       return_tensors="""np"""    )[input_name]
        __a					=  feat_extract.pad(A_  ,       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 	snake_case_  (	self    ):
        __a					=  self.feat_extract_dict
        __a					=  True
        __a					=  self.feature_extraction_class(**A_    )
        __a					=  self.feat_extract_tester.prepare_inputs_for_target()
        __a					=  [len(A_    ) for x in speech_inputs]
        __a					=  feat_extract.model_input_names[0]

        __a					=  BatchFeature({input_name: speech_inputs}    )

        __a					=  feat_extract.num_mel_bins  # hack!

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


     def 	snake_case_  (	self    ):
        __a					=  self.feat_extract_dict
        __a					=  True
        __a					=  self.feature_extraction_class(**A_    )
        __a					=  self.feat_extract_tester.prepare_inputs_for_target()
        __a					=  [len(A_    ) for x in speech_inputs]
        __a					=  feat_extract.model_input_names[0]

        __a					=  BatchFeature({input_name: speech_inputs}    )
        __a					=  min(A_    )

        __a					=  feat_extract.num_mel_bins  # hack!

        __a					=  feat_extract.pad(
            A_  ,       padding="""max_length"""  ,       max_length=A_  ,       truncation=A_  ,       return_tensors="""np"""    )
        self.assertIn("""attention_mask"""  ,       A_    )
        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 	snake_case_  (	self  ,       __A    ):
        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(A_    )    )[:num_samples]["""audio"""]

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


     def 	snake_case_  (	self    ):
        __a					=  torch.tensor(
            [2.3804E-03, 2.0752E-03, 1.9836E-03, 2.1057E-03, 1.6174E-03,
             3.0518E-04, 9.1553E-05, 3.3569E-04, 9.7656E-04, 1.8311E-03,
             2.0142E-03, 2.1057E-03, 1.7395E-03, 4.5776E-04, -3.9673E-04,
             4.5776E-04, 1.0071E-03, 9.1553E-05, 4.8828E-04, 1.1597E-03,
             7.3242E-04, 9.4604E-04, 1.8005E-03, 1.8311E-03, 8.8501E-04,
             4.2725E-04, 4.8828E-04, 7.3242E-04, 1.0986E-03, 2.1057E-03]    )
        # fmt: on

        __a					=  self._load_datasamples(1    )
        __a					=  SpeechTaFeatureExtractor()
        __a					=  feature_extractor(A_  ,       return_tensors="""pt"""    ).input_values
        self.assertEquals(input_values.shape  ,       (1, 93680)    )
        self.assertTrue(torch.allclose(input_values[0, :30]  ,       A_  ,       atol=1E-6    )    )


     def 	snake_case_  (	self    ):
        __a					=  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

        __a					=  self._load_datasamples(1    )
        __a					=  SpeechTaFeatureExtractor()
        __a					=  feature_extractor(audio_target=A_  ,       return_tensors="""pt"""    ).input_values
        self.assertEquals(input_values.shape  ,       (1, 366, 80)    )
        self.assertTrue(torch.allclose(input_values[0, 0, :30]  ,       A_  ,       atol=1E-4    )    )







"""simple docstring"""

def lowerCAmelCase_   (					UpperCamelCase__						:			Union[str, Any]					, UpperCamelCase__						:			Union[str, Any]					, UpperCamelCase__						:			int			):






 """simple docstring"""







 if n == 0:
  return 1

 elif n % 2 == 1:
  return (binary_exponentiation(UpperCamelCase__					, n - 1					, UpperCamelCase__			) * a) % mod

 else:
  __lowercase						=						binary_exponentiation(UpperCamelCase__					, n / 2					, UpperCamelCase__			)
  return (b * b) % mod


# a prime number
UpperCAmelCase__					=701

UpperCAmelCase__					=10_0000_0000
UpperCAmelCase__					=10

# using binary exponentiation function, O(log(p)):
print((a / b) % p == (a * binary_exponentiation(b, p - 2, p)) % p)

print((a / b) % p == (a * b ** (p - 2)) % p)
