




import json
import os
import shutil
import tempfile
import unittest

from transformers import is_speech_available, is_torch_available
from transformers.models.speechta import SpeechTaTokenizer
from transformers.testing_utils import get_tests_dir, require_torch
from transformers.utils import FEATURE_EXTRACTOR_NAME


if is_speech_available() and is_torch_available():
  from transformers import SpeechTaFeatureExtractor, SpeechTaProcessor

  from .test_feature_extraction_speechta import floats_list


_lowerCAmelCase  :				Optional[int]						=				get_tests_dir("fixtures/test_sentencepiece_bpe_char.model")
@require_torch
class      _UpperCamelCase (			unittest.TestCase						):
      def 		UpperCAmelCase_  (     self				:Tuple )       ->     Dict:
       UpperCAmelCase__								=  tempfile.mkdtemp()

       UpperCAmelCase__								=  SpeechTaTokenizer(lowerCamelCase )
       tokenizer.save_pretrained(self.tmpdirname )

       UpperCAmelCase__								=  {
           "feature_size": 1,
           "padding_value": 0.0,
           "sampling_rate": 1_6000,
           "do_normalize": False,
           "num_mel_bins": 80,
           "hop_length": 16,
           "win_length": 64,
           "win_function": "hann_window",
           "fmin": 80,
           "fmax": 7600,
           "mel_floor": 1e-10,
           "reduction_factor": 2,
           "return_attention_mask": True,
       }

       UpperCAmelCase__								=  os.path.join(self.tmpdirname	, lowerCamelCase )
       with open(self.feature_extraction_file	, "w"	, encoding="utf-8" ) as fp:
        fp.write(json.dumps(lowerCamelCase ) + "\n" )
      def 		UpperCAmelCase_  (     self				:int	, **lowerCamelCase				:List[str] )       ->     List[str]:
       return SpeechTaTokenizer.from_pretrained(self.tmpdirname	, **lowerCamelCase )
      def 		UpperCAmelCase_  (     self				:Optional[int]	, **lowerCamelCase				:Tuple )       ->     List[str]:
       return SpeechTaFeatureExtractor.from_pretrained(self.tmpdirname	, **lowerCamelCase )
      def 		UpperCAmelCase_  (     self				:List[Any] )       ->     int:
       shutil.rmtree(self.tmpdirname )
      def 		UpperCAmelCase_  (     self				:Tuple )       ->     Any:
       UpperCAmelCase__								=  self.get_tokenizer()
       UpperCAmelCase__								=  self.get_feature_extractor()

       UpperCAmelCase__								=  SpeechTaProcessor(tokenizer=lowerCamelCase	, feature_extractor=lowerCamelCase )

       processor.save_pretrained(self.tmpdirname )
       UpperCAmelCase__								=  SpeechTaProcessor.from_pretrained(self.tmpdirname )

       self.assertEqual(processor.tokenizer.get_vocab()	, tokenizer.get_vocab() )
       self.assertIsInstance(processor.tokenizer	, lowerCamelCase )

       self.assertEqual(processor.feature_extractor.to_json_string()	, feature_extractor.to_json_string() )
       self.assertIsInstance(processor.feature_extractor	, lowerCamelCase )
      def 		UpperCAmelCase_  (     self				:int )       ->     Any:
       UpperCAmelCase__								=  SpeechTaProcessor(tokenizer=self.get_tokenizer()	, feature_extractor=self.get_feature_extractor() )
       processor.save_pretrained(self.tmpdirname )

       UpperCAmelCase__								=  self.get_tokenizer(bos_token="(BOS)"	, eos_token="(EOS)" )
       UpperCAmelCase__								=  self.get_feature_extractor(do_normalize=lowerCamelCase	, padding_value=1.0 )

       UpperCAmelCase__								=  SpeechTaProcessor.from_pretrained(
           self.tmpdirname	, bos_token="(BOS)"	, eos_token="(EOS)"	, do_normalize=lowerCamelCase	, padding_value=1.0 )

       self.assertEqual(processor.tokenizer.get_vocab()	, tokenizer_add_kwargs.get_vocab() )
       self.assertIsInstance(processor.tokenizer	, lowerCamelCase )

       self.assertEqual(processor.feature_extractor.to_json_string()	, feature_extractor_add_kwargs.to_json_string() )
       self.assertIsInstance(processor.feature_extractor	, lowerCamelCase )
      def 		UpperCAmelCase_  (     self				:Optional[Any] )       ->     List[str]:
       UpperCAmelCase__								=  self.get_feature_extractor()
       UpperCAmelCase__								=  self.get_tokenizer()

       UpperCAmelCase__								=  SpeechTaProcessor(tokenizer=lowerCamelCase	, feature_extractor=lowerCamelCase )

       UpperCAmelCase__								=  floats_list((3, 1000) )

       UpperCAmelCase__								=  feature_extractor(audio=lowerCamelCase	, return_tensors="np" )
       UpperCAmelCase__								=  processor(audio=lowerCamelCase	, return_tensors="np" )

       for key in input_feat_extract.keys():
        self.assertAlmostEqual(input_feat_extract[key].sum()	, input_processor[key].sum()	, delta=1e-2 )
      def 		UpperCAmelCase_  (     self				:List[Any] )       ->     Optional[Any]:
       UpperCAmelCase__								=  self.get_feature_extractor()
       UpperCAmelCase__								=  self.get_tokenizer()

       UpperCAmelCase__								=  SpeechTaProcessor(tokenizer=lowerCamelCase	, feature_extractor=lowerCamelCase )

       UpperCAmelCase__								=  floats_list((3, 1000) )

       UpperCAmelCase__								=  feature_extractor(audio_target=lowerCamelCase	, return_tensors="np" )
       UpperCAmelCase__								=  processor(audio_target=lowerCamelCase	, return_tensors="np" )

       for key in input_feat_extract.keys():
        self.assertAlmostEqual(input_feat_extract[key].sum()	, input_processor[key].sum()	, delta=1e-2 )
      def 		UpperCAmelCase_  (     self				:Tuple )       ->     Any:
       UpperCAmelCase__								=  self.get_feature_extractor()
       UpperCAmelCase__								=  self.get_tokenizer()

       UpperCAmelCase__								=  SpeechTaProcessor(tokenizer=lowerCamelCase	, feature_extractor=lowerCamelCase )

       UpperCAmelCase__								=  "This is a test string"

       UpperCAmelCase__								=  processor(text=lowerCamelCase )
       UpperCAmelCase__								=  tokenizer(lowerCamelCase )

       for key in encoded_tok.keys():
        self.assertListEqual(encoded_tok[key]	, encoded_processor[key] )
      def 		UpperCAmelCase_  (     self				:Any )       ->     int:
       UpperCAmelCase__								=  self.get_feature_extractor()
       UpperCAmelCase__								=  self.get_tokenizer()

       UpperCAmelCase__								=  SpeechTaProcessor(tokenizer=lowerCamelCase	, feature_extractor=lowerCamelCase )

       UpperCAmelCase__								=  "This is a test string"

       UpperCAmelCase__								=  processor(text_target=lowerCamelCase )
       UpperCAmelCase__								=  tokenizer(lowerCamelCase )

       for key in encoded_tok.keys():
        self.assertListEqual(encoded_tok[key]	, encoded_processor[key] )
      def 		UpperCAmelCase_  (     self				:Tuple )       ->     List[str]:
       UpperCAmelCase__								=  self.get_feature_extractor()
       UpperCAmelCase__								=  self.get_tokenizer()

       UpperCAmelCase__								=  SpeechTaProcessor(tokenizer=lowerCamelCase	, feature_extractor=lowerCamelCase )

       UpperCAmelCase__								=  [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

       UpperCAmelCase__								=  processor.batch_decode(lowerCamelCase )
       UpperCAmelCase__								=  tokenizer.batch_decode(lowerCamelCase )

       self.assertListEqual(lowerCamelCase	, lowerCamelCase )







      def 		UpperCAmelCase_  (     self				:Union[str, Any] )       ->     Any:
       UpperCAmelCase__								=  self.get_feature_extractor()
       UpperCAmelCase__								=  self.get_tokenizer()

       UpperCAmelCase__								=  SpeechTaProcessor(tokenizer=lowerCamelCase	, feature_extractor=lowerCamelCase )

       self.assertListEqual(
           processor.model_input_names	, feature_extractor.model_input_names	, msg="`processor` and `feature_extractor` model input names do not match"	, )











from collections import defaultdict



def   lowerCAmelCase						(						_lowerCAmelCase							:				int = 5		):




 """simple docstring"""







 UpperCAmelCase__								=  defaultdict(_lowerCAmelCase		)
 UpperCAmelCase__								=  0

 while True:
  UpperCAmelCase__								=  get_digits(_lowerCAmelCase		)
  freqs[digits].append(_lowerCAmelCase		)

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

  num += 1



def   lowerCAmelCase						(						_lowerCAmelCase							:				int		):




 """simple docstring"""







 return "".join(sorted(str(num**3		)		)		)


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





