


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





							'''simple docstring'''


							def UpperCAmelCase_     (   self  ):
											_SCREAMING_SNAKE_CASE			:	List[str]							=				"""<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(""" """  )
											_SCREAMING_SNAKE_CASE			:	Union[str, Any]							=				dict(zip(__snake_case   , range(len(__snake_case  )  )  )  )

											_SCREAMING_SNAKE_CASE			:	int							=				{
											    """pad_token""": """<pad>""",
											    """unk_token""": """<unk>""",
											    """bos_token""": """<s>""",
											    """eos_token""": """</s>""",
											}
											_SCREAMING_SNAKE_CASE			:	Optional[Any]							=				{
											    """feature_size""": 1,
											    """padding_value""": 0.0,
											    """sampling_rate""": 1_6000,
											    """return_attention_mask""": False,
											    """do_normalize""": True,
											}

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

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






							def UpperCAmelCase_     (   self   , **__snake_case  ):
											_SCREAMING_SNAKE_CASE			:	Union[str, Any]							=				self.add_kwargs_tokens_map.copy()
											kwargs.update(__snake_case  )
											return WavaVecaCTCTokenizer.from_pretrained(self.tmpdirname   , **__snake_case  )






							def UpperCAmelCase_     (   self   , **__snake_case  ):
											return WavaVecaFeatureExtractor.from_pretrained(self.tmpdirname   , **__snake_case  )






							def UpperCAmelCase_     (   self  ):
											shutil.rmtree(self.tmpdirname  )






							def UpperCAmelCase_     (   self  ):
											_SCREAMING_SNAKE_CASE			:	Optional[Any]							=				self.get_tokenizer()
											_SCREAMING_SNAKE_CASE			:	Optional[int]							=				self.get_feature_extractor()

											_SCREAMING_SNAKE_CASE			:	List[str]							=				WavaVecaProcessor(tokenizer=__snake_case   , feature_extractor=__snake_case  )

											processor.save_pretrained(self.tmpdirname  )
											_SCREAMING_SNAKE_CASE			:	Optional[int]							=				WavaVecaProcessor.from_pretrained(self.tmpdirname  )

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

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






							def UpperCAmelCase_     (   self  ):
											_SCREAMING_SNAKE_CASE			:	List[str]							=				WavaVecaProcessor(tokenizer=self.get_tokenizer()   , feature_extractor=self.get_feature_extractor()  )
											processor.save_pretrained(self.tmpdirname  )

											_SCREAMING_SNAKE_CASE			:	Dict							=				self.get_tokenizer(bos_token="""(BOS)"""   , eos_token="""(EOS)"""  )
											_SCREAMING_SNAKE_CASE			:	Any							=				self.get_feature_extractor(do_normalize=__snake_case   , padding_value=1.0  )

											_SCREAMING_SNAKE_CASE			:	Any							=				WavaVecaProcessor.from_pretrained(
											    self.tmpdirname   , bos_token="""(BOS)"""   , eos_token="""(EOS)"""   , do_normalize=__snake_case   , padding_value=1.0  )

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

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






							def UpperCAmelCase_     (   self  ):
											_SCREAMING_SNAKE_CASE			:	List[Any]							=				self.get_feature_extractor()
											_SCREAMING_SNAKE_CASE			:	Any							=				self.get_tokenizer()

											_SCREAMING_SNAKE_CASE			:	Union[str, Any]							=				WavaVecaProcessor(tokenizer=__snake_case   , feature_extractor=__snake_case  )

											_SCREAMING_SNAKE_CASE			:	Union[str, Any]							=				floats_list((3, 1000)  )

											_SCREAMING_SNAKE_CASE			:	Tuple							=				feature_extractor(__snake_case   , return_tensors="""np"""  )
											_SCREAMING_SNAKE_CASE			:	Optional[int]							=				processor(__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  ):
											_SCREAMING_SNAKE_CASE			:	Union[str, Any]							=				self.get_feature_extractor()
											_SCREAMING_SNAKE_CASE			:	Optional[Any]							=				self.get_tokenizer()

											_SCREAMING_SNAKE_CASE			:	Dict							=				WavaVecaProcessor(tokenizer=__snake_case   , feature_extractor=__snake_case  )

											_SCREAMING_SNAKE_CASE			:	List[str]							=				"""This is a test string"""

											_SCREAMING_SNAKE_CASE			:	Any							=				processor(text=__snake_case  )

											_SCREAMING_SNAKE_CASE			:	Optional[int]							=				tokenizer(__snake_case  )

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






							def UpperCAmelCase_     (   self  ):
											_SCREAMING_SNAKE_CASE			:	List[str]							=				self.get_feature_extractor()
											_SCREAMING_SNAKE_CASE			:	List[Any]							=				self.get_tokenizer()

											_SCREAMING_SNAKE_CASE			:	List[str]							=				WavaVecaProcessor(tokenizer=__snake_case   , feature_extractor=__snake_case  )

											_SCREAMING_SNAKE_CASE			:	Optional[int]							=				[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

											_SCREAMING_SNAKE_CASE			:	Tuple							=				processor.batch_decode(__snake_case  )
											_SCREAMING_SNAKE_CASE			:	str							=				tokenizer.batch_decode(__snake_case  )

											self.assertListEqual(__snake_case   , __snake_case  )






							def UpperCAmelCase_     (   self  ):
											_SCREAMING_SNAKE_CASE			:	int							=				self.get_feature_extractor()
											_SCREAMING_SNAKE_CASE			:	str							=				self.get_tokenizer()

											_SCREAMING_SNAKE_CASE			:	Dict							=				WavaVecaProcessor(tokenizer=__snake_case   , feature_extractor=__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'''


def       snake_case_       (  SCREAMING_SNAKE_CASE__							,				SCREAMING_SNAKE_CASE__					):







				"""simple docstring"""





				_SCREAMING_SNAKE_CASE			:	Tuple							=				1
				while b > 0:
								if b & 1:
												res *= a

								a *= a
								b >>= 1

				return res







def       snake_case_       (  SCREAMING_SNAKE_CASE__							,				SCREAMING_SNAKE_CASE__							,				SCREAMING_SNAKE_CASE__					):







				"""simple docstring"""





				_SCREAMING_SNAKE_CASE			:	Union[str, Any]							=				1
				while b > 0:
								if b & 1:
												_SCREAMING_SNAKE_CASE			:	Tuple							=				((res % c) * (a % c)) % c

								a *= a
								b >>= 1

				return res




