'''simple docstring'''




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


__snake_case  : List[str]		       =    get_tests_dir('fixtures/test_sentencepiece.model')




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





       '''simple docstring'''



       def    __A			( self					)						->	str:
           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''': 1_6000,
               '''return_attention_mask''': False,
               '''do_normalize''': True,
           }
           save_json(_SCREAMING_SNAKE_CASE       ,	save_dir / FEATURE_EXTRACTOR_NAME					)

       def    __A			( self       ,	**_SCREAMING_SNAKE_CASE					)						->	List[Any]:
           return SpeechaTextTokenizer.from_pretrained(self.tmpdirname       ,	**_SCREAMING_SNAKE_CASE					)

       def    __A			( self       ,	**_SCREAMING_SNAKE_CASE					)						->	Any:
           return SpeechaTextFeatureExtractor.from_pretrained(self.tmpdirname       ,	**_SCREAMING_SNAKE_CASE					)

       def    __A			( self					)						->	List[Any]:
           shutil.rmtree(self.tmpdirname					)

       def    __A			( self					)						->	Union[str, Any]:
           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    __A			( self					)						->	Optional[Any]:
           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    __A			( self					)						->	Union[str, Any]:
           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    __A			( self					)						->	Union[str, Any]:
           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    __A			( self					)						->	Tuple:
           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    __A			( self					)						->	Any:
           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'''




import itertools





def 	_UpperCAmelCase       (				_UpperCamelCase       :      int = 1_00_00_00  )      -> int:
    A_      =  [1]

    for i in itertools.count(len(_UpperCamelCase  )  ):
        A_      =  0
        for j in itertools.count(1  ):
            A_      =  -1 if j % 2 == 0 else +1
            A_      =  (j * j * 3 - j) // 2
            if index > i:
                break
            item += partitions[i - index] * sign
            item %= number
            index += j
            if index > i:
                break
            item += partitions[i - index] * sign
            item %= number

        if item == 0:
            return i
        partitions.append(_UpperCamelCase  )

    return 0


if __name__ == "__main__":
  import doctest

  doctest.testmod()

  print(F"""{solution() = }""")






