






"""simple docstring"""






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


A_			  =    random.Random()




def 						_UpperCamelCase			(  A    ,       A=1.0    ,       A=None    ,       A=None			):

   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 						__lowerCAmelCase   (			unittest.TestCase       ):







  '''simple docstring'''


  def __init__(      self:		int				,			UpperCamelCase_:		int				,			UpperCamelCase_:		List[str]=7				,			UpperCamelCase_:		int=400				,			UpperCamelCase_:		Dict=2000				,			UpperCamelCase_:		Dict=1				,			UpperCamelCase_:		List[Any]=0.0				,			UpperCamelCase_:		Any=2_4000				,			UpperCamelCase_:		Dict=True				,			):
     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:		List[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:		Optional[int]				,			UpperCamelCase_:		List[Any]=False				,			UpperCamelCase_:		Tuple=False					):







     def _flatten(UpperCamelCase_:		int					):
        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 						__lowerCAmelCase   (			a__       ,   unittest.TestCase       ):







  '''simple docstring'''


  __lowerCamelCase       :    List[Any]     	=			EncodecFeatureExtractor
  def 					UpperCamelCase__   (      self:		Optional[Any]					):
     UpperCamelCase_     =EnCodecFeatureExtractionTester(self					)
  def 					UpperCamelCase__   (      self:		Optional[int]					):
     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				,			1400				,			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:		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:		Union[str, Any]				,			UpperCamelCase_:		str					):
     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:		Optional[int]					):
     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, 9_3680)					)
     self.assertTrue(torch.allclose(input_values[0, 0, :30]				,			__A				,			atol=1e-6					)					)
  def 					UpperCamelCase__   (      self:		List[str]					):
     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, 9_3680)					)
     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:		Optional[Any]					):
     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, 7_1520)					)  # 2 chunks

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

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

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

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

     # 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, 9_3680)					)

     # 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, 9_3680)					)

     # 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, 9_3680)					)














"""simple docstring"""






from collections import defaultdict




def 						_UpperCamelCase			(  A = 5			):
   UpperCamelCase_     =defaultdict(A			)
   UpperCamelCase_     =0

   while True:
      UpperCamelCase_     =get_digits(A			)
      freqs[digits].append(A			)

      if len(freqs[digits]			) == max_base:
         UpperCamelCase_     =freqs[digits][0] ** 3
         return base

      num += 1




def 						_UpperCamelCase			(  A			):
   return "".join(sorted(str(num**3			)			)			)


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