
"""simple docstring"""

def 			lowercase__  (    lowerCAmelCase :    int = 998_001       )       ->					int:






    """simple docstring"""




    for number in range(n - 1       , 9_999       , -1       ):
        UpperCAmelCase  	=    str(lowerCAmelCase       )

        # checks whether 'str_number' is a palindrome.
        if str_number == str_number[::-1]:
            UpperCAmelCase  	=    999

            # if 'number' is a product of two 3-digit numbers
            # then number is the answer otherwise fetch next number.
            while divisor != 99:
                if (number % divisor == 0) and (len(str(number // divisor       )       ) == 3.0):
                    return number
                divisor -= 1
    raise ValueError('That number is larger than our acceptable range.'       )


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





"""simple docstring"""

import json
import os
import shutil
import tempfile
import unittest

from transformers.models.wavaveca import WavaVecaCTCTokenizer, WavaVecaFeatureExtractor, WavaVecaProcessor
from transformers.models.wavaveca.tokenization_wavaveca import VOCAB_FILES_NAMES
from transformers.utils import FEATURE_EXTRACTOR_NAME

from .test_feature_extraction_wavaveca import floats_list
class    _UpperCAmelCase							(						unittest.TestCase							):




      def 			a_					(							self							)  ->    Any:
          UpperCAmelCase  	=    '<pad> <s> </s> <unk> | E T A O N I H S R D L U M W C F G Y P B V K \' X J Q Z'.split(' '							)
          UpperCAmelCase  	=    dict(zip(lowercase_      ,				range(len(lowercase_							)							)							)							)

          UpperCAmelCase  	=    {
              'pad_token': '<pad>',
              'unk_token': '<unk>',
              'bos_token': '<s>',
              'eos_token': '</s>',
          }
          UpperCAmelCase  	=    {
              'feature_size': 1,
              'padding_value': 0.0,
              'sampling_rate': 1_6_0_0_0,
              'return_attention_mask': False,
              'do_normalize': True,
          }

          UpperCAmelCase  	=    tempfile.mkdtemp()
          UpperCAmelCase  	=    os.path.join(self.tmpdirname      ,				VOCAB_FILES_NAMES['vocab_file']							)
          UpperCAmelCase  	=    os.path.join(self.tmpdirname      ,				lowercase_							)
          with open(self.vocab_file      ,				'w'      ,				encoding='utf-8'							) as fp:
              fp.write(json.dumps(lowercase_							) + '\n'							)

          with open(self.feature_extraction_file      ,				'w'      ,				encoding='utf-8'							) as fp:
              fp.write(json.dumps(lowercase_							) + '\n'							)




      def 			a_					(							self      ,				**lowercase_							)  ->    Any:
          UpperCAmelCase  	=    self.add_kwargs_tokens_map.copy()
          kwargs.update(lowercase_							)
          return WavaVecaCTCTokenizer.from_pretrained(self.tmpdirname      ,				**lowercase_							)




      def 			a_					(							self      ,				**lowercase_							)  ->    Dict:
          return WavaVecaFeatureExtractor.from_pretrained(self.tmpdirname      ,				**lowercase_							)




      def 			a_					(							self							)  ->    Any:
          shutil.rmtree(self.tmpdirname							)




      def 			a_					(							self							)  ->    Tuple:
          UpperCAmelCase  	=    self.get_tokenizer()
          UpperCAmelCase  	=    self.get_feature_extractor()

          UpperCAmelCase  	=    WavaVecaProcessor(tokenizer=lowercase_      ,				feature_extractor=lowercase_							)

          processor.save_pretrained(self.tmpdirname							)
          UpperCAmelCase  	=    WavaVecaProcessor.from_pretrained(self.tmpdirname							)

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

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




      def 			a_					(							self							)  ->    Dict:
          UpperCAmelCase  	=    WavaVecaProcessor(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=lowercase_      ,				padding_value=1.0							)

          UpperCAmelCase  	=    WavaVecaProcessor.from_pretrained(
              self.tmpdirname      ,				bos_token='(BOS)'      ,				eos_token='(EOS)'      ,				do_normalize=lowercase_      ,				padding_value=1.0							)

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

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




      def 			a_					(							self							)  ->    Tuple:
          UpperCAmelCase  	=    self.get_feature_extractor()
          UpperCAmelCase  	=    self.get_tokenizer()

          UpperCAmelCase  	=    WavaVecaProcessor(tokenizer=lowercase_      ,				feature_extractor=lowercase_							)

          UpperCAmelCase  	=    floats_list((3, 1_0_0_0)							)

          UpperCAmelCase  	=    feature_extractor(lowercase_      ,				return_tensors='np'							)
          UpperCAmelCase  	=    processor(lowercase_      ,				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							)  ->    List[str]:
          UpperCAmelCase  	=    self.get_feature_extractor()
          UpperCAmelCase  	=    self.get_tokenizer()

          UpperCAmelCase  	=    WavaVecaProcessor(tokenizer=lowercase_      ,				feature_extractor=lowercase_							)

          UpperCAmelCase  	=    'This is a test string'

          UpperCAmelCase  	=    processor(text=lowercase_							)

          UpperCAmelCase  	=    tokenizer(lowercase_							)

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




      def 			a_					(							self							)  ->    List[str]:
          UpperCAmelCase  	=    self.get_feature_extractor()
          UpperCAmelCase  	=    self.get_tokenizer()

          UpperCAmelCase  	=    WavaVecaProcessor(tokenizer=lowercase_      ,				feature_extractor=lowercase_							)

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

          UpperCAmelCase  	=    processor.batch_decode(lowercase_							)
          UpperCAmelCase  	=    tokenizer.batch_decode(lowercase_							)

          self.assertListEqual(lowercase_      ,				lowercase_							)




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

          UpperCAmelCase  	=    WavaVecaProcessor(tokenizer=lowercase_      ,				feature_extractor=lowercase_							)

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



