

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

   '''simple docstring'''




   def 					_UpperCAmelCase					(							self			)				->       str:






     """simple docstring"""






     a__    =tempfile.mkdtemp()

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

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

     a__    ={
         '''feature_size''': 24,
         '''num_mel_bins''': 24,
         '''padding_value''': 0.0,
         '''sampling_rate''': 16000,
         '''return_attention_mask''': False,
         '''do_normalize''': True,
     }
     save_json(_SCREAMING_SNAKE_CASE,       save_dir / FEATURE_EXTRACTOR_NAME			)



   def 					_UpperCAmelCase					(							self,       **lowercase_			)				->       List[Any]:






     """simple docstring"""






     return SpeechaTextTokenizer.from_pretrained(self.tmpdirname,       **_SCREAMING_SNAKE_CASE			)



   def 					_UpperCAmelCase					(							self,       **lowercase_			)				->       Any:






     """simple docstring"""






     return SpeechaTextFeatureExtractor.from_pretrained(self.tmpdirname,       **_SCREAMING_SNAKE_CASE			)



   def 					_UpperCAmelCase					(							self			)				->       List[Any]:






     """simple docstring"""






     shutil.rmtree(self.tmpdirname			)



   def 					_UpperCAmelCase					(							self			)				->       Union[str, Any]:






     """simple docstring"""






     a__    =self.get_tokenizer()
     a__    =self.get_feature_extractor()

     a__    =SpeechaTextProcessor(tokenizer=_SCREAMING_SNAKE_CASE,       feature_extractor=_SCREAMING_SNAKE_CASE			)

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

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

     self.assertEqual(processor.feature_extractor.to_json_string(),       feature_extractor.to_json_string()			)
     self.assertIsInstance(processor.feature_extractor,       _SCREAMING_SNAKE_CASE			)



   def 					_UpperCAmelCase					(							self			)				->       Optional[Any]:






     """simple docstring"""






     a__    =SpeechaTextProcessor(
         tokenizer=self.get_tokenizer(),       feature_extractor=self.get_feature_extractor()			)
     processor.save_pretrained(self.tmpdirname			)

     a__    =self.get_tokenizer(bos_token='''(BOS)''',       eos_token='''(EOS)'''			)
     a__    =self.get_feature_extractor(do_normalize=_SCREAMING_SNAKE_CASE,       padding_value=1.0			)

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

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

     self.assertEqual(processor.feature_extractor.to_json_string(),       feature_extractor_add_kwargs.to_json_string()			)
     self.assertIsInstance(processor.feature_extractor,       _SCREAMING_SNAKE_CASE			)



   def 					_UpperCAmelCase					(							self			)				->       Union[str, Any]:






     """simple docstring"""






     a__    =self.get_feature_extractor()
     a__    =self.get_tokenizer()

     a__    =SpeechaTextProcessor(tokenizer=_SCREAMING_SNAKE_CASE,       feature_extractor=_SCREAMING_SNAKE_CASE			)

     a__    =floats_list((3, 1000)			)

     a__    =feature_extractor(_SCREAMING_SNAKE_CASE,       return_tensors='''np'''			)
     a__    =processor(_SCREAMING_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 					_UpperCAmelCase					(							self			)				->       Union[str, Any]:






     """simple docstring"""






     a__    =self.get_feature_extractor()
     a__    =self.get_tokenizer()

     a__    =SpeechaTextProcessor(tokenizer=_SCREAMING_SNAKE_CASE,       feature_extractor=_SCREAMING_SNAKE_CASE			)

     a__    ='''This is a test string'''

     a__    =processor(text=_SCREAMING_SNAKE_CASE			)

     a__    =tokenizer(_SCREAMING_SNAKE_CASE			)

     for key in encoded_tok.keys():
       self.assertListEqual(encoded_tok[key],       encoded_processor[key]			)



   def 					_UpperCAmelCase					(							self			)				->       Tuple:






     """simple docstring"""






     a__    =self.get_feature_extractor()
     a__    =self.get_tokenizer()

     a__    =SpeechaTextProcessor(tokenizer=_SCREAMING_SNAKE_CASE,       feature_extractor=_SCREAMING_SNAKE_CASE			)

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

     a__    =processor.batch_decode(_SCREAMING_SNAKE_CASE			)
     a__    =tokenizer.batch_decode(_SCREAMING_SNAKE_CASE			)

     self.assertListEqual(_SCREAMING_SNAKE_CASE,       _SCREAMING_SNAKE_CASE			)



   def 					_UpperCAmelCase					(							self			)				->       Any:






     """simple docstring"""






     a__    =self.get_feature_extractor()
     a__    =self.get_tokenizer()

     a__    =SpeechaTextProcessor(tokenizer=_SCREAMING_SNAKE_CASE,       feature_extractor=_SCREAMING_SNAKE_CASE			)

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

'''simple docstring'''




__snake_case  : str		       =    10**8





def 	_UpperCAmelCase       (				_UpperCamelCase       :      int  )      -> bool:
    if n % 10 == 0:
        return False
    A_      =  str(_UpperCamelCase  )
    return s == s[::-1]





def 	_UpperCAmelCase       (				)      -> int:
    A_      =  set()
    A_      =  1
    A_      =  5
    while sum_squares < LIMIT:
        A_      =  first_square + 1
        while sum_squares < LIMIT:
            if is_palindrome(_UpperCamelCase  ):
                answer.add(_UpperCamelCase  )
            last_square += 1
            sum_squares += last_square**2
        first_square += 1
        A_      =  first_square**2 + (first_square + 1) ** 2

    return sum(_UpperCamelCase  )


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






