'''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      lowerCamelCase_     (unittest.TestCase   ):
						'''simple docstring'''

						def 					_A     (	self						:    Optional[Any]	):
													_UpperCAmelCase					:  Optional[int]											=   "<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					:  int											=   dict(zip(__A						, range(len(__A	)	)	)	)

													_UpperCAmelCase					:  str											=   {
													    "pad_token": "<pad>",
													    "unk_token": "<unk>",
													    "bos_token": "<s>",
													    "eos_token": "</s>",
													}
													_UpperCAmelCase					:  Union[str, Any]											=   {
													    "feature_size": 1,
													    "padding_value": 0.0,
													    "sampling_rate": 16000,
													    "return_attention_mask": False,
													    "do_normalize": True,
													}

													_UpperCAmelCase					:  Any											=   tempfile.mkdtemp()
													_UpperCAmelCase					:  int											=   os.path.join(self.tmpdirname						, VOCAB_FILES_NAMES["vocab_file"]	)
													_UpperCAmelCase					:  str											=   os.path.join(self.tmpdirname						, __A	)
													with open(self.vocab_file						, "w"						, encoding="utf-8"	) as fp:
																				fp.write(json.dumps(__A	) + "\n"	)

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




						def 					_A     (	self						:    int						, **A						:    Optional[Any]	):
													_UpperCAmelCase					:  str											=   self.add_kwargs_tokens_map.copy()
													kwargs.update(__A	)
													return WavaVecaCTCTokenizer.from_pretrained(self.tmpdirname						, **__A	)




						def 					_A     (	self						:    str						, **A						:    str	):
													return WavaVecaFeatureExtractor.from_pretrained(self.tmpdirname						, **__A	)




						def 					_A     (	self						:    Tuple	):
													shutil.rmtree(self.tmpdirname	)




						def 					_A     (	self						:    Tuple	):
													_UpperCAmelCase					:  List[Any]											=   self.get_tokenizer()
													_UpperCAmelCase					:  Dict											=   self.get_feature_extractor()

													_UpperCAmelCase					:  List[Any]											=   WavaVecaProcessor(tokenizer=__A						, feature_extractor=__A	)

													processor.save_pretrained(self.tmpdirname	)
													_UpperCAmelCase					:  Optional[Any]											=   WavaVecaProcessor.from_pretrained(self.tmpdirname	)

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

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




						def 					_A     (	self						:    Optional[Any]	):
													_UpperCAmelCase					:  Tuple											=   WavaVecaProcessor(tokenizer=self.get_tokenizer()						, feature_extractor=self.get_feature_extractor()	)
													processor.save_pretrained(self.tmpdirname	)

													_UpperCAmelCase					:  Optional[Any]											=   self.get_tokenizer(bos_token="(BOS)"						, eos_token="(EOS)"	)
													_UpperCAmelCase					:  Tuple											=   self.get_feature_extractor(do_normalize=__A						, padding_value=1.0	)

													_UpperCAmelCase					:  Optional[int]											=   WavaVecaProcessor.from_pretrained(
													    self.tmpdirname						, bos_token="(BOS)"						, eos_token="(EOS)"						, do_normalize=__A						, padding_value=1.0	)

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

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




						def 					_A     (	self						:    Optional[Any]	):
													_UpperCAmelCase					:  Dict											=   self.get_feature_extractor()
													_UpperCAmelCase					:  Optional[int]											=   self.get_tokenizer()

													_UpperCAmelCase					:  int											=   WavaVecaProcessor(tokenizer=__A						, feature_extractor=__A	)

													_UpperCAmelCase					:  List[Any]											=   floats_list((3, 1000)	)

													_UpperCAmelCase					:  str											=   feature_extractor(__A						, return_tensors="np"	)
													_UpperCAmelCase					:  List[str]											=   processor(__A						, 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						:    Tuple	):
													_UpperCAmelCase					:  str											=   self.get_feature_extractor()
													_UpperCAmelCase					:  Dict											=   self.get_tokenizer()

													_UpperCAmelCase					:  List[Any]											=   WavaVecaProcessor(tokenizer=__A						, feature_extractor=__A	)

													_UpperCAmelCase					:  Optional[Any]											=   "This is a test string"

													_UpperCAmelCase					:  int											=   processor(text=__A	)

													_UpperCAmelCase					:  List[str]											=   tokenizer(__A	)

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




						def 					_A     (	self						:    Tuple	):
													_UpperCAmelCase					:  List[str]											=   self.get_feature_extractor()
													_UpperCAmelCase					:  Union[str, Any]											=   self.get_tokenizer()

													_UpperCAmelCase					:  List[Any]											=   WavaVecaProcessor(tokenizer=__A						, feature_extractor=__A	)

													_UpperCAmelCase					:  str											=   [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

													_UpperCAmelCase					:  Union[str, Any]											=   processor.batch_decode(__A	)
													_UpperCAmelCase					:  str											=   tokenizer.batch_decode(__A	)

													self.assertListEqual(__A						, __A	)





						def 					_A     (	self						:    List[Any]	):
													_UpperCAmelCase					:  Optional[Any]											=   self.get_feature_extractor()
													_UpperCAmelCase					:  Any											=   self.get_tokenizer()

													_UpperCAmelCase					:  str											=   WavaVecaProcessor(tokenizer=__A						, feature_extractor=__A	)

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


'''simple docstring'''




def      UpperCamelCase_							( _UpperCAmelCase  :				Optional[int]      ,     _UpperCAmelCase  :				List[Any]   )   ->   List[str]:


       """simple docstring"""







       if len(str(_UpperCAmelCase   )   ) == 1 or len(str(_UpperCAmelCase   )   ) == 1:
              return a * b

       _UpperCAmelCase					:  Any											=   max(len(str(_UpperCAmelCase   )   )      ,     len(str(_UpperCAmelCase   )   )   )
       _UpperCAmelCase					:  Any											=   ma // 2

       _UpperCAmelCase				,  _UpperCAmelCase					:  Union[str, Any]											=   divmod(_UpperCAmelCase      ,     10**ma   )
       _UpperCAmelCase				,  _UpperCAmelCase					:  int											=   divmod(_UpperCAmelCase      ,     10**ma   )

       _UpperCAmelCase					:  List[str]											=   karatsuba(_UpperCAmelCase      ,     _UpperCAmelCase   )
       _UpperCAmelCase					:  int											=   karatsuba((aa + aa)      ,     (ba + ba)   )
       _UpperCAmelCase					:  Any											=   karatsuba(_UpperCAmelCase      ,     _UpperCAmelCase   )

       return (z * 10 ** (2 * ma)) + ((y - z - x) * 10 ** (ma)) + (x)

def      UpperCamelCase_							( )   ->   List[str]:


       """simple docstring"""







       print(karatsuba(15_463      ,     23_489   )   )


if __name__ == "__main__":
  main()

