


"""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

__snake_case		=       random.Random()
def       A_   (   _lowerCAmelCase     :					Optional[int],     _lowerCAmelCase     :					str=1.0,     _lowerCAmelCase     :					str=None,     _lowerCAmelCase     :					Optional[Any]=None       ):






     """simple docstring"""

     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
@require_torchaudio
class     __lowerCamelCase  (					unittest.TestCase				):

     '''simple docstring'''


     def __init__(      self    ,				__UpperCAmelCase    ,				__UpperCAmelCase=7    ,				__UpperCAmelCase=400    ,				__UpperCAmelCase=2000    ,				__UpperCAmelCase=24    ,				__UpperCAmelCase=24    ,				__UpperCAmelCase=0.0    ,				__UpperCAmelCase=16000    ,				__UpperCAmelCase=True    ,				__UpperCAmelCase=True    ,				)       ->							List[str]:
          _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    	=				num_mel_bins
          _a    	=				padding_value
          _a    	=				sampling_rate
          _a    	=				return_attention_mask
          _a    	=				do_normalize


     def 							_UpperCAmelCase      (      self							)       ->							Optional[Any]:
          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    ,				__UpperCAmelCase=False    ,				__UpperCAmelCase=False							)       ->							Optional[int]:
          def _flatten(__UpperCAmelCase							):
               return list(itertools.chain(*__UpperCAmelCase							)							)

          if equal_length:
               _a    	=				[floats_list((self.max_seq_length, self.feature_size)							) for _ in range(self.batch_size							)]
          else:
               # make sure that inputs increase in size
               _a    	=				[
                   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     __lowerCamelCase  (					a__  ,					unittest.TestCase				):

     '''simple docstring'''
     A_       :	Union[str, Any]    =		SpeechaTextFeatureExtractor if is_speech_available() else None


     def 							_UpperCAmelCase      (      self							)       ->							Optional[int]:
          _a    	=				SpeechaTextFeatureExtractionTester(self							)


     def 							_UpperCAmelCase      (      self    ,				__UpperCAmelCase							)       ->							Any:
          self.assertTrue(np.all(np.mean(__UpperCAmelCase    ,				axis=0							) < 1e-3							)							)
          self.assertTrue(np.all(np.abs(np.var(__UpperCAmelCase    ,				axis=0							) - 1							) < 1e-3							)							)


     def 							_UpperCAmelCase      (      self							)       ->							List[str]:
          # 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 feature size
          _a    	=				feature_extractor(__UpperCAmelCase    ,				padding=__UpperCAmelCase    ,				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
          _a    	=				feature_extractor(speech_inputs[0]    ,				return_tensors='''np'''							).input_features
          _a    	=				feature_extractor(np_speech_inputs[0]    ,				return_tensors='''np'''							).input_features
          self.assertTrue(np.allclose(__UpperCAmelCase    ,				__UpperCAmelCase    ,				atol=1e-3							)							)

          # Test batched
          _a    	=				feature_extractor(__UpperCAmelCase    ,				return_tensors='''np'''							).input_features
          _a    	=				feature_extractor(__UpperCAmelCase    ,				return_tensors='''np'''							).input_features
          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    	=				feature_extractor(__UpperCAmelCase    ,				return_tensors='''np'''							).input_features
          _a    	=				feature_extractor(__UpperCAmelCase    ,				return_tensors='''np'''							).input_features
          for enc_seq_a, enc_seq_a in zip(__UpperCAmelCase    ,				__UpperCAmelCase							):
               self.assertTrue(np.allclose(__UpperCAmelCase    ,				__UpperCAmelCase    ,				atol=1e-3							)							)


     def 							_UpperCAmelCase      (      self							)       ->							Dict:
          _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, 16, None]
          for max_length, padding in zip(__UpperCAmelCase    ,				__UpperCAmelCase							):
               _a    	=				feature_extractor(
                   __UpperCAmelCase    ,				padding=__UpperCAmelCase    ,				max_length=__UpperCAmelCase    ,				return_attention_mask=__UpperCAmelCase							)
               _a    	=				inputs.input_features
               _a    	=				inputs.attention_mask
               _a    	=				[np.sum(__UpperCAmelCase							) 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							)       ->							int:
          _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, 16, None]
          for max_length, padding in zip(__UpperCAmelCase    ,				__UpperCAmelCase							):
               _a    	=				feature_extractor(
                   __UpperCAmelCase    ,				max_length=__UpperCAmelCase    ,				padding=__UpperCAmelCase    ,				return_tensors='''np'''    ,				return_attention_mask=__UpperCAmelCase							)
               _a    	=				inputs.input_features
               _a    	=				inputs.attention_mask
               _a    	=				[np.sum(__UpperCAmelCase							) 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							)       ->							Union[str, Any]:
          _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    	=				feature_extractor(
              __UpperCAmelCase    ,				padding='''max_length'''    ,				max_length=4    ,				truncation=__UpperCAmelCase    ,				return_tensors='''np'''    ,				return_attention_mask=__UpperCAmelCase    ,				)
          _a    	=				inputs.input_features
          _a    	=				inputs.attention_mask
          _a    	=				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							)       ->							Dict:
          _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    	=				feature_extractor(
              __UpperCAmelCase    ,				padding='''longest'''    ,				max_length=4    ,				truncation=__UpperCAmelCase    ,				return_tensors='''np'''    ,				return_attention_mask=__UpperCAmelCase    ,				)
          _a    	=				inputs.input_features
          _a    	=				inputs.attention_mask
          _a    	=				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)							)

          _a    	=				[floats_list((1, x)							)[0] for x in range(800    ,				1400    ,				200							)]
          _a    	=				feature_extractor(
              __UpperCAmelCase    ,				padding='''longest'''    ,				max_length=16    ,				truncation=__UpperCAmelCase    ,				return_tensors='''np'''    ,				return_attention_mask=__UpperCAmelCase    ,				)
          _a    	=				inputs.input_features
          _a    	=				inputs.attention_mask
          _a    	=				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							)       ->							Optional[int]:
          import torch

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

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


     def 							_UpperCAmelCase      (      self    ,				__UpperCAmelCase							)       ->							Union[str, Any]:
          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]





     def 							_UpperCAmelCase      (      self							)       ->							Any:
          # fmt: off
          _a    	=				np.array([
              -1.5745, -1.7713, -1.7020, -1.6069, -1.2250, -1.1105, -0.9072, -0.8241,
              -1.2310, -0.8098, -0.3320, -0.4101, -0.7985, -0.4996, -0.8213, -0.9128,
              -1.0420, -1.1286, -1.0440, -0.7999, -0.8405, -1.2275, -1.5443, -1.4625,
          ]							)
          # fmt: on

          _a    	=				self._load_datasamples(1							)
          _a    	=				self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()							)
          _a    	=				feature_extractor(__UpperCAmelCase    ,				return_tensors='''pt'''							).input_features
          self.assertEquals(input_features.shape    ,				(1, 584, 24)							)
          self.assertTrue(np.allclose(input_features[0, 0, :30]    ,				__UpperCAmelCase    ,				atol=1e-4							)							)



"""simple docstring"""






def       A_   (   _lowerCAmelCase     :					Dict=2_81_23       ):






     """simple docstring"""

     _a    	=				[1] * (limit + 1)

     for i in range(2,     int(limit**0.5       ) + 1       ):
          sum_divs[i * i] += i
          for k in range(i + 1,     limit // i + 1       ):
               sum_divs[k * i] += k + i

     _a    	=				set()
     _a    	=				0

     for n in range(1,     limit + 1       ):
          if sum_divs[n] > n:
               abundants.add(_lowerCAmelCase       )

          if not any((n - a in abundants) for a in abundants       ):
               res += n

     return res


if __name__ == "__main__":
   print(solution())