
'''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


lowerCAmelCase :  List[Any]      =      get_tests_dir('fixtures/test_sentencepiece.model')


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







				def 		UpperCAmelCase_  (    self			)->						List[str]:







											'''simple docstring'''






											UpperCamelCase					       =			tempfile.mkdtemp()

											UpperCamelCase					       =			['<s>', '<pad>', '</s>', '<unk>', '▁This', '▁is', '▁a', '▁t', 'est']
											UpperCamelCase					       =			dict(zip(A_		,							range(len(A_			)			)			)			)
											UpperCamelCase					       =			Path(self.tmpdirname			)
											save_json(A_		,							save_dir / VOCAB_FILES_NAMES['vocab_file']			)
											if not (save_dir / VOCAB_FILES_NAMES["spm_file"]).exists():
																		copyfile(A_		,							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': 16000,
											    'return_attention_mask': False,
											    'do_normalize': True,
											}
											save_json(A_		,							save_dir / FEATURE_EXTRACTOR_NAME			)







				def 		UpperCAmelCase_  (    self		,							**A_			)->						Tuple:







											'''simple docstring'''






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







				def 		UpperCAmelCase_  (    self		,							**A_			)->						Optional[int]:







											'''simple docstring'''






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







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







											'''simple docstring'''






											shutil.rmtree(self.tmpdirname			)







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







											'''simple docstring'''






											UpperCamelCase					       =			self.get_tokenizer()
											UpperCamelCase					       =			self.get_feature_extractor()

											UpperCamelCase					       =			SpeechaTextProcessor(tokenizer=A_		,							feature_extractor=A_			)

											processor.save_pretrained(self.tmpdirname			)
											UpperCamelCase					       =			SpeechaTextProcessor.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 		UpperCAmelCase_  (    self			)->						List[Any]:







											'''simple docstring'''






											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=A_		,							padding_value=1.0			)

											UpperCamelCase					       =			SpeechaTextProcessor.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 		UpperCAmelCase_  (    self			)->						Dict:







											'''simple docstring'''






											UpperCamelCase					       =			self.get_feature_extractor()
											UpperCamelCase					       =			self.get_tokenizer()

											UpperCamelCase					       =			SpeechaTextProcessor(tokenizer=A_		,							feature_extractor=A_			)

											UpperCamelCase					       =			floats_list((3, 1000)			)

											UpperCamelCase					       =			feature_extractor(A_		,							return_tensors='np'			)
											UpperCamelCase					       =			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 		UpperCAmelCase_  (    self			)->						Dict:







											'''simple docstring'''






											UpperCamelCase					       =			self.get_feature_extractor()
											UpperCamelCase					       =			self.get_tokenizer()

											UpperCamelCase					       =			SpeechaTextProcessor(tokenizer=A_		,							feature_extractor=A_			)

											UpperCamelCase					       =			'This is a test string'

											UpperCamelCase					       =			processor(text=A_			)

											UpperCamelCase					       =			tokenizer(A_			)

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







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







											'''simple docstring'''






											UpperCamelCase					       =			self.get_feature_extractor()
											UpperCamelCase					       =			self.get_tokenizer()

											UpperCamelCase					       =			SpeechaTextProcessor(tokenizer=A_		,							feature_extractor=A_			)

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

											UpperCamelCase					       =			processor.batch_decode(A_			)
											UpperCamelCase					       =			tokenizer.batch_decode(A_			)

											self.assertListEqual(A_		,							A_			)







				def 		UpperCAmelCase_  (    self			)->						Dict:







											'''simple docstring'''






											UpperCamelCase					       =			self.get_feature_extractor()
											UpperCamelCase					       =			self.get_tokenizer()

											UpperCamelCase					       =			SpeechaTextProcessor(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'''







import unittest
from timeit import timeit






def 		_lowercase		(	lowercase_						,							lowercase_  ):



		'''simple docstring'''







		_snake_case	       =       first_num if first_num >= second_num else second_num
		_snake_case	       =       max_num
		while (common_mult % first_num > 0) or (common_mult % second_num > 0):
				common_mult += max_num
		return common_mult






def 		_lowercase		(	lowercase_						,							lowercase_  ):



		'''simple docstring'''







		return b if a == 0 else greatest_common_divisor(b % a						,							lowercase_  )






def 		_lowercase		(	lowercase_						,							lowercase_  ):



		'''simple docstring'''







		return first_num // greatest_common_divisor(lowercase_						,							lowercase_  ) * second_num






def 		_lowercase		(	):



		'''simple docstring'''







		_snake_case	       =       (
		    "from __main__ import least_common_multiple_slow, least_common_multiple_fast"
		)
		print(
		    "least_common_multiple_slow():"						,							timeit("least_common_multiple_slow(1000, 999)"						,							setup=lowercase_  )						,							)
		print(
		    "least_common_multiple_fast():"						,							timeit("least_common_multiple_fast(1000, 999)"						,							setup=lowercase_  )						,							)





class      lowerCamelCase_							(       unittest.TestCase							):




					'''simple docstring'''






					lowercase__    = (
					    (1_0, 2_0),
					    (1_3, 1_5),
					    (4, 3_1),
					    (1_0, 4_2),
					    (4_3, 3_4),
					    (5, 1_2),
					    (1_2, 2_5),
					    (1_0, 2_5),
					    (6, 9),
					)
					lowercase__    = (2_0, 1_9_5, 1_2_4, 2_1_0, 1_4_6_2, 6_0, 3_0_0, 5_0, 1_8)






					def 				__SCREAMING_SNAKE_CASE	(    self ):
							for i, (first_num, second_num) in enumerate(self.test_inputs ):
									_snake_case	       =       least_common_multiple_slow(__UpperCamelCase,  __UpperCamelCase )
									_snake_case	       =       least_common_multiple_fast(__UpperCamelCase,  __UpperCamelCase )
									with self.subTest(i=__UpperCamelCase ):
											self.assertEqual(__UpperCamelCase,  self.expected_results[i] )
											self.assertEqual(__UpperCamelCase,  self.expected_results[i] )


if __name__ == "__main__":
						benchmark()
						unittest.main()





