

import itertools
import random
import unittest

import numpy as np

from transformers import EncodecFeatureExtractor
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						:str      =			random.Random()




def        lowerCAmelCase(	SCREAMING_SNAKE_CASE_       ,		SCREAMING_SNAKE_CASE_=1.0       ,		SCREAMING_SNAKE_CASE_=None       ,		SCREAMING_SNAKE_CASE_=None       )->		List[str]:



    """simple docstring"""






    if rng is None:
        UpperCamelCase_          =		global_rng

    UpperCamelCase_          =		[]
    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 		__magic_name__ (				unittest.TestCase							):






     def __init__(							self						,		_lowercase						,		_lowercase=7						,		_lowercase=400						,		_lowercase=2_000						,		_lowercase=1						,		_lowercase=0.0						,		_lowercase=24_000						,		_lowercase=True						,		)->			Tuple:
         UpperCamelCase_          =		parent
         UpperCamelCase_          =		batch_size
         UpperCamelCase_          =		min_seq_length
         UpperCamelCase_          =		max_seq_length
         UpperCamelCase_          =		(self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
         UpperCamelCase_          =		feature_size
         UpperCamelCase_          =		padding_value
         UpperCamelCase_          =		sampling_rate
         UpperCamelCase_          =		return_attention_mask






     def      UpperCAmelCase_							(							self     )->			str:
         return {
             "feature_size": self.feature_size,
             "padding_value": self.padding_value,
             "sampling_rate": self.sampling_rate,
             "return_attention_mask": self.return_attention_mask,
         }






     def      UpperCAmelCase_							(							self						,		_lowercase=False						,		_lowercase=False     )->			Tuple:
         def _flatten(_lowercase     ):
             return list(itertools.chain(*__A     )     )

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

         return audio_inputs






@require_torch
class 		__magic_name__ (				snake_case       ,	unittest.TestCase							):
     UpperCamelCase_     :Tuple									=	EncodecFeatureExtractor






     def      UpperCAmelCase_							(							self     )->			Tuple:
         UpperCamelCase_          =		EnCodecFeatureExtractionTester(self     )






     def      UpperCAmelCase_							(							self     )->			List[Any]:
         # Tests that all call wrap to encode_plus and batch_encode_plus
         UpperCamelCase_          =		self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()     )
         # create three inputs of length 800, 1000, and 1200
         UpperCamelCase_          =		[floats_list((1, x)     )[0] for x in range(800						,		1_400						,		200     )]
         UpperCamelCase_          =		[np.asarray(__A     ) for audio_input in audio_inputs]

         # Test not batched input
         UpperCamelCase_          =		feat_extract(audio_inputs[0]						,		return_tensors="np"     ).input_values
         UpperCamelCase_          =		feat_extract(np_audio_inputs[0]						,		return_tensors="np"     ).input_values
         self.assertTrue(np.allclose(__A						,		__A						,		atol=1e-3     )     )

         # Test batched
         UpperCamelCase_          =		feat_extract(__A						,		padding=__A						,		return_tensors="np"     ).input_values
         UpperCamelCase_          =		feat_extract(__A						,		padding=__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      UpperCAmelCase_							(							self     )->			Optional[Any]:
         UpperCamelCase_          =		self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()     )
         UpperCamelCase_          =		np.random.rand(100     ).astype(np.floataa     )
         UpperCamelCase_          =		np_audio_inputs.tolist()

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






     def      UpperCAmelCase_							(							self						,		_lowercase     )->			Any:
         from datasets import load_dataset

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

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






     def      UpperCAmelCase_							(							self     )->			List[str]:
         # fmt: off
         UpperCamelCase_          =		torch.tensor(
             [2.3_8_0_4e-0_3, 2.0_7_5_2e-0_3, 1.9_8_3_6e-0_3, 2.1_0_5_7e-0_3, 1.6_1_7_4e-0_3,
              3.0_5_1_8e-0_4, 9.1_5_5_3e-0_5, 3.3_5_6_9e-0_4, 9.7_6_5_6e-0_4, 1.8_3_1_1e-0_3,
              2.0_1_4_2e-0_3, 2.1_0_5_7e-0_3, 1.7_3_9_5e-0_3, 4.5_7_7_6e-0_4, -3.9_6_7_3e-0_4,
              4.5_7_7_6e-0_4, 1.0_0_7_1e-0_3, 9.1_5_5_3e-0_5, 4.8_8_2_8e-0_4, 1.1_5_9_7e-0_3,
              7.3_2_4_2e-0_4, 9.4_6_0_4e-0_4, 1.8_0_0_5e-0_3, 1.8_3_1_1e-0_3, 8.8_5_0_1e-0_4,
              4.2_7_2_5e-0_4, 4.8_8_2_8e-0_4, 7.3_2_4_2e-0_4, 1.0_9_8_6e-0_3, 2.1_0_5_7e-0_3]     )
         # fmt: on
         UpperCamelCase_          =		self._load_datasamples(1     )
         UpperCamelCase_          =		EncodecFeatureExtractor()
         UpperCamelCase_          =		feature_extractor(__A						,		return_tensors="pt"     ).input_values
         self.assertEquals(input_values.shape						,		(1, 1, 93_680)     )
         self.assertTrue(torch.allclose(input_values[0, 0, :30]						,		__A						,		atol=1e-6     )     )






     def      UpperCAmelCase_							(							self     )->			Optional[int]:
         # fmt: off
         UpperCamelCase_          =		torch.tensor(
             [2.3_8_0_4e-0_3, 2.0_7_5_2e-0_3, 1.9_8_3_6e-0_3, 2.1_0_5_7e-0_3, 1.6_1_7_4e-0_3,
              3.0_5_1_8e-0_4, 9.1_5_5_3e-0_5, 3.3_5_6_9e-0_4, 9.7_6_5_6e-0_4, 1.8_3_1_1e-0_3,
              2.0_1_4_2e-0_3, 2.1_0_5_7e-0_3, 1.7_3_9_5e-0_3, 4.5_7_7_6e-0_4, -3.9_6_7_3e-0_4,
              4.5_7_7_6e-0_4, 1.0_0_7_1e-0_3, 9.1_5_5_3e-0_5, 4.8_8_2_8e-0_4, 1.1_5_9_7e-0_3,
              7.3_2_4_2e-0_4, 9.4_6_0_4e-0_4, 1.8_0_0_5e-0_3, 1.8_3_1_1e-0_3, 8.8_5_0_1e-0_4,
              4.2_7_2_5e-0_4, 4.8_8_2_8e-0_4, 7.3_2_4_2e-0_4, 1.0_9_8_6e-0_3, 2.1_0_5_7e-0_3]     )
         # fmt: on
         UpperCamelCase_          =		self._load_datasamples(1     )
         UpperCamelCase_          =		[np.tile(input_audio[0][None]						,		reps=(2, 1)     )]
         input_audio[0][1] *= 0.5
         UpperCamelCase_          =		EncodecFeatureExtractor(feature_size=2     )
         UpperCamelCase_          =		feature_extractor(__A						,		return_tensors="pt"     ).input_values
         self.assertEquals(input_values.shape						,		(1, 2, 93_680)     )
         self.assertTrue(torch.allclose(input_values[0, 0, :30]						,		__A						,		atol=1e-6     )     )
         self.assertTrue(torch.allclose(input_values[0, 1, :30]						,		EXPECTED_INPUT_VALUES * 0.5						,		atol=1e-6     )     )






     def      UpperCAmelCase_							(							self     )->			int:
         UpperCamelCase_          =		self._load_datasamples(2     )
         # would be easier if the stride was like
         UpperCamelCase_          =		EncodecFeatureExtractor(feature_size=1						,		chunk_length_s=1						,		overlap=0.01     )

         # pad and trunc raise an error ?
         with self.assertRaisesRegex(
             __A						,		"^Both padding and truncation were set. Make sure you only set one.$"						,		):
             UpperCamelCase_          =		feature_extractor(
                 __A						,		padding="max_length"						,		truncation=__A						,		return_tensors="pt"     ).input_values

         # truncate to chunk
         UpperCamelCase_          =		feature_extractor(__A						,		truncation=__A						,		return_tensors="pt"     ).input_values
         self.assertEquals(truncated_outputs.shape						,		(2, 1, 71_520)     )  # 2 chunks

         # force truncate to max_length
         UpperCamelCase_          =		feature_extractor(
             __A						,		truncation=__A						,		max_length=48_000						,		return_tensors="pt"     ).input_values
         self.assertEquals(truncated_outputs.shape						,		(2, 1, 48_000)     )

         # pad to chunk
         UpperCamelCase_          =		feature_extractor(__A						,		padding=__A						,		return_tensors="pt"     ).input_values
         self.assertEquals(padded_outputs.shape						,		(2, 1, 95_280)     )

         # pad to chunk
         UpperCamelCase_          =		feature_extractor(__A						,		return_tensors="pt"     ).input_values
         self.assertEquals(truncated_outputs.shape						,		(2, 1, 95_280)     )

         # force pad to max length
         UpperCamelCase_          =		feature_extractor(
             __A						,		padding="max_length"						,		max_length=100_000						,		return_tensors="pt"     ).input_values
         self.assertEquals(truncated_outputs.shape						,		(2, 1, 100_000)     )

         # force no pad
         with self.assertRaisesRegex(
             __A						,		"^Unable to create tensor, you should probably activate padding with \'padding=True\' to have batched tensors with the same length.$"						,		):
             UpperCamelCase_          =		feature_extractor(__A						,		padding=__A						,		return_tensors="pt"     ).input_values

         UpperCamelCase_          =		feature_extractor(input_audio[0]						,		padding=__A						,		return_tensors="pt"     ).input_values
         self.assertEquals(truncated_outputs.shape						,		(1, 1, 93_680)     )

         # no pad if no chunk_length_s
         UpperCamelCase_          =		None
         with self.assertRaisesRegex(
             __A						,		"^Unable to create tensor, you should probably activate padding with \'padding=True\' to have batched tensors with the same length.$"						,		):
             UpperCamelCase_          =		feature_extractor(__A						,		padding=__A						,		return_tensors="pt"     ).input_values

         UpperCamelCase_          =		feature_extractor(input_audio[0]						,		padding=__A						,		return_tensors="pt"     ).input_values
         self.assertEquals(truncated_outputs.shape						,		(1, 1, 93_680)     )

         # no pad if no overlap
         UpperCamelCase_          =		2
         UpperCamelCase_          =		None
         with self.assertRaisesRegex(
             __A						,		"^Unable to create tensor, you should probably activate padding with \'padding=True\' to have batched tensors with the same length.$"						,		):
             UpperCamelCase_          =		feature_extractor(__A						,		padding=__A						,		return_tensors="pt"     ).input_values

         UpperCamelCase_          =		feature_extractor(input_audio[0]						,		padding=__A						,		return_tensors="pt"     ).input_values
         self.assertEquals(truncated_outputs.shape						,		(1, 1, 93_680)     )








from math import factorial




def    __A    (   _lowercase    ,	_lowercase       ):

					'''simple docstring'''







					return factorial(_lowercase       ) / (factorial(_lowercase       ) * factorial(n - r       ))




def    __A    (   ):

					'''simple docstring'''







					_A									=       0

					for i in range(1    ,	1_01       ):
										for j in range(1    ,	i + 1       ):
															if combinations(_lowercase    ,	_lowercase       ) > 1e6:
																				total += 1
					return total


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



