




import shutil
import tempfile
import unittest
from pathlib import Path
from shutil import copyfile

from transformers import SpeechaTextTokenizer, is_speech_available
from transformers.models.speech_to_text.tokenization_speech_to_text import VOCAB_FILES_NAMES, save_json
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_torch, require_torchaudio
from transformers.utils import FEATURE_EXTRACTOR_NAME

from .test_feature_extraction_speech_to_text import floats_list


if is_speech_available():
 from transformers import SpeechaTextFeatureExtractor, SpeechaTextProcessor


_lowerCamelCase    				=		get_tests_dir('fixtures/test_sentencepiece.model')



@require_torch
@require_torchaudio
@require_sentencepiece
class     a  (     unittest.TestCase    ):

     '''simple docstring'''





     def 						lowerCamelCase_     (			self     :    int       ):
         UpperCAmelCase_											=  tempfile.mkdtemp()

         UpperCAmelCase_											=  ['''<s>''', '''<pad>''', '''</s>''', '''<unk>''', '''▁This''', '''▁is''', '''▁a''', '''▁t''', '''est''']
         UpperCAmelCase_											=  dict(zip(__snake_case      ,					range(len(__snake_case       )       )       )       )
         UpperCAmelCase_											=  Path(self.tmpdirname       )
         save_json(__snake_case      ,					save_dir / VOCAB_FILES_NAMES['''vocab_file''']       )
         if not (save_dir / VOCAB_FILES_NAMES["spm_file"]).exists():
             copyfile(__snake_case      ,					save_dir / VOCAB_FILES_NAMES['''spm_file''']       )

         UpperCAmelCase_											=  SpeechaTextTokenizer.from_pretrained(self.tmpdirname       )
         tokenizer.save_pretrained(self.tmpdirname       )

         UpperCAmelCase_											=  {
             '''feature_size''': 24,
             '''num_mel_bins''': 24,
             '''padding_value''': 0.0,
             '''sampling_rate''': 1_60_00,
             '''return_attention_mask''': False,
             '''do_normalize''': True,
         }
         save_json(__snake_case      ,					save_dir / FEATURE_EXTRACTOR_NAME       )
     def 						lowerCamelCase_     (			self     :    List[str]      ,					**__snake_case     :    str       ):
         return SpeechaTextTokenizer.from_pretrained(self.tmpdirname      ,					**__snake_case       )
     def 						lowerCamelCase_     (			self     :    Optional[int]      ,					**__snake_case     :    str       ):
         return SpeechaTextFeatureExtractor.from_pretrained(self.tmpdirname      ,					**__snake_case       )
     def 						lowerCamelCase_     (			self     :    Dict       ):
         shutil.rmtree(self.tmpdirname       )
     def 						lowerCamelCase_     (			self     :    List[str]       ):
         UpperCAmelCase_											=  self.get_tokenizer()
         UpperCAmelCase_											=  self.get_feature_extractor()

         UpperCAmelCase_											=  SpeechaTextProcessor(tokenizer=__snake_case      ,					feature_extractor=__snake_case       )

         processor.save_pretrained(self.tmpdirname       )
         UpperCAmelCase_											=  SpeechaTextProcessor.from_pretrained(self.tmpdirname       )

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

         self.assertEqual(processor.feature_extractor.to_json_string()      ,					feature_extractor.to_json_string()       )
         self.assertIsInstance(processor.feature_extractor      ,					__snake_case       )
     def 						lowerCamelCase_     (			self     :    Optional[Any]       ):
         UpperCAmelCase_											=  SpeechaTextProcessor(
             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=__snake_case      ,					padding_value=1.0       )

         UpperCAmelCase_											=  SpeechaTextProcessor.from_pretrained(
             self.tmpdirname      ,					bos_token='''(BOS)'''      ,					eos_token='''(EOS)'''      ,					do_normalize=__snake_case      ,					padding_value=1.0       )

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

         self.assertEqual(processor.feature_extractor.to_json_string()      ,					feature_extractor_add_kwargs.to_json_string()       )
         self.assertIsInstance(processor.feature_extractor      ,					__snake_case       )
     def 						lowerCamelCase_     (			self     :    Any       ):
         UpperCAmelCase_											=  self.get_feature_extractor()
         UpperCAmelCase_											=  self.get_tokenizer()

         UpperCAmelCase_											=  SpeechaTextProcessor(tokenizer=__snake_case      ,					feature_extractor=__snake_case       )

         UpperCAmelCase_											=  floats_list((3, 10_00)       )

         UpperCAmelCase_											=  feature_extractor(__snake_case      ,					return_tensors='''np'''       )
         UpperCAmelCase_											=  processor(__snake_case      ,					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 						lowerCamelCase_     (			self     :    Optional[int]       ):
         UpperCAmelCase_											=  self.get_feature_extractor()
         UpperCAmelCase_											=  self.get_tokenizer()

         UpperCAmelCase_											=  SpeechaTextProcessor(tokenizer=__snake_case      ,					feature_extractor=__snake_case       )

         UpperCAmelCase_											=  '''This is a test string'''

         UpperCAmelCase_											=  processor(text=__snake_case       )

         UpperCAmelCase_											=  tokenizer(__snake_case       )

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

         UpperCAmelCase_											=  SpeechaTextProcessor(tokenizer=__snake_case      ,					feature_extractor=__snake_case       )

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

         UpperCAmelCase_											=  processor.batch_decode(__snake_case       )
         UpperCAmelCase_											=  tokenizer.batch_decode(__snake_case       )

         self.assertListEqual(__snake_case      ,					__snake_case       )




     def 						lowerCamelCase_     (			self     :    Tuple       ):
         UpperCAmelCase_											=  self.get_feature_extractor()
         UpperCAmelCase_											=  self.get_tokenizer()

         UpperCAmelCase_											=  SpeechaTextProcessor(tokenizer=__snake_case      ,					feature_extractor=__snake_case       )

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











import decimal




def       SCREAMING_SNAKE_CASE			( )						->							int:
    UpperCAmelCase_											=  0
    UpperCAmelCase_											=  decimal.Context(prec=105   )
    for i in range(2 ,  100   ):
        UpperCAmelCase_											=  decimal.Decimal(__UpperCamelCase   )
        UpperCAmelCase_											=  number.sqrt(__UpperCamelCase   )
        if len(str(__UpperCamelCase   )   ) > 1:
            answer += int(str(__UpperCamelCase   )[0]   )
            UpperCAmelCase_											=  str(__UpperCamelCase   )[2:101]
            answer += sum(int(__UpperCamelCase   ) for x in sqrt_number_str   )
    return answer


if __name__ == "__main__":
 import doctest

 doctest.testmod()
 print(F"{solution() = }")





