





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


_UpperCAmelCase										=					get_tests_dir('fixtures/test_sentencepiece.model')



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

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




              """simple docstring"""


              UpperCamelCase_ 							=	tempfile.mkdtemp()

              UpperCamelCase_ 							=	["<s>", "<pad>", "</s>", "<unk>", "▁This", "▁is", "▁a", "▁t", "est"]
              UpperCamelCase_ 							=	dict(zip(_SCREAMING_SNAKE_CASE       , range(len(_SCREAMING_SNAKE_CASE		)		)		)		)
              UpperCamelCase_ 							=	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"]		)

              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(_SCREAMING_SNAKE_CASE       , save_dir / FEATURE_EXTRACTOR_NAME		)

       def lowercase			(		self:			Optional[Any]       , **_SCREAMING_SNAKE_CASE:			List[str]		)							->			Any:




              """simple docstring"""


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

       def lowercase			(		self:			int       , **_SCREAMING_SNAKE_CASE:			Optional[int]		)							->			Optional[Any]:




              """simple docstring"""


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

       def lowercase			(		self:			Optional[int]		)							->			List[str]:




              """simple docstring"""


              shutil.rmtree(self.tmpdirname		)

       def lowercase			(		self:			int		)							->			Dict:




              """simple docstring"""


              UpperCamelCase_ 							=	self.get_tokenizer()
              UpperCamelCase_ 							=	self.get_feature_extractor()

              UpperCamelCase_ 							=	SpeechaTextProcessor(tokenizer=_SCREAMING_SNAKE_CASE       , feature_extractor=_SCREAMING_SNAKE_CASE		)

              processor.save_pretrained(self.tmpdirname		)
              UpperCamelCase_ 							=	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 lowercase			(		self:			Optional[int]		)							->			int:




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

              UpperCamelCase_ 							=	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 lowercase			(		self:			Tuple		)							->			Union[str, Any]:




              """simple docstring"""


              UpperCamelCase_ 							=	self.get_feature_extractor()
              UpperCamelCase_ 							=	self.get_tokenizer()

              UpperCamelCase_ 							=	SpeechaTextProcessor(tokenizer=_SCREAMING_SNAKE_CASE       , feature_extractor=_SCREAMING_SNAKE_CASE		)

              UpperCamelCase_ 							=	floats_list((3, 1000)		)

              UpperCamelCase_ 							=	feature_extractor(_SCREAMING_SNAKE_CASE       , return_tensors="np"		)
              UpperCamelCase_ 							=	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 lowercase			(		self:			Tuple		)							->			Optional[Any]:




              """simple docstring"""


              UpperCamelCase_ 							=	self.get_feature_extractor()
              UpperCamelCase_ 							=	self.get_tokenizer()

              UpperCamelCase_ 							=	SpeechaTextProcessor(tokenizer=_SCREAMING_SNAKE_CASE       , feature_extractor=_SCREAMING_SNAKE_CASE		)

              UpperCamelCase_ 							=	"This is a test string"

              UpperCamelCase_ 							=	processor(text=_SCREAMING_SNAKE_CASE		)

              UpperCamelCase_ 							=	tokenizer(_SCREAMING_SNAKE_CASE		)

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

       def lowercase			(		self:			Dict		)							->			Dict:




              """simple docstring"""


              UpperCamelCase_ 							=	self.get_feature_extractor()
              UpperCamelCase_ 							=	self.get_tokenizer()

              UpperCamelCase_ 							=	SpeechaTextProcessor(tokenizer=_SCREAMING_SNAKE_CASE       , feature_extractor=_SCREAMING_SNAKE_CASE		)

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

              UpperCamelCase_ 							=	processor.batch_decode(_SCREAMING_SNAKE_CASE		)
              UpperCamelCase_ 							=	tokenizer.batch_decode(_SCREAMING_SNAKE_CASE		)

              self.assertListEqual(_SCREAMING_SNAKE_CASE       , _SCREAMING_SNAKE_CASE		)



       def lowercase			(		self:			Any		)							->			Optional[int]:




              """simple docstring"""


              UpperCamelCase_ 							=	self.get_feature_extractor()
              UpperCamelCase_ 							=	self.get_tokenizer()

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


__SCREAMING_SNAKE_CASE						=      {hex(i)[2:]: i for i in range(16)}  # Use [:2] to strip off the leading '0x'
def 					__magic_name__(       UpperCAmelCase__ :       str	):
						UpperCamelCase_     :	str					     =     hex_string.strip().lower()
						if not hex_string:
												raise ValueError("""Empty string was passed to the function"""	)
						UpperCamelCase_     :	Dict					     =     hex_string[0] == """-"""
						if is_negative:
												UpperCamelCase_     :	List[str]					     =     hex_string[1:]
						if not all(char in hex_table for char in hex_string	):
												raise ValueError("""Non-hexadecimal value was passed to the function"""	)
						UpperCamelCase_     :	int					     =     0
						for char in hex_string:
												UpperCamelCase_     :	Any					     =     16 * decimal_number + hex_table[char]
						return -decimal_number if is_negative else decimal_number


if __name__ == "__main__":
	from doctest import testmod

	testmod()




