






"""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  ):






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







        '''simple docstring'''


        _a					      =						"<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(" "						)
        _a					      =						dict(zip(__UpperCamelCase  ,  range(len(__UpperCamelCase						)						)						)						)

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

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

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






      def       lowerCamelCase__     (     self  ,  **a_						)						->Optional[int]:







        '''simple docstring'''


        _a					      =						self.add_kwargs_tokens_map.copy()
        kwargs.update(__UpperCamelCase						)
        return WavaVecaCTCTokenizer.from_pretrained(self.tmpdirname  ,  **__UpperCamelCase						)






      def       lowerCamelCase__     (     self  ,  **a_						)						->Optional[int]:







        '''simple docstring'''


        return WavaVecaFeatureExtractor.from_pretrained(self.tmpdirname  ,  **__UpperCamelCase						)






      def       lowerCamelCase__     (     self						)						->Tuple:







        '''simple docstring'''


        shutil.rmtree(self.tmpdirname						)






      def       lowerCamelCase__     (     self						)						->Dict:







        '''simple docstring'''


        _a					      =						self.get_tokenizer()
        _a					      =						self.get_feature_extractor()

        _a					      =						WavaVecaProcessor(tokenizer=__UpperCamelCase  ,  feature_extractor=__UpperCamelCase						)

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

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

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






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







        '''simple docstring'''


        _a					      =						WavaVecaProcessor(tokenizer=self.get_tokenizer()  ,  feature_extractor=self.get_feature_extractor()						)
        processor.save_pretrained(self.tmpdirname						)

        _a					      =						self.get_tokenizer(bos_token="(BOS)"  ,  eos_token="(EOS)"						)
        _a					      =						self.get_feature_extractor(do_normalize=__UpperCamelCase  ,  padding_value=1.0						)

        _a					      =						WavaVecaProcessor.from_pretrained(
            self.tmpdirname  ,  bos_token="(BOS)"  ,  eos_token="(EOS)"  ,  do_normalize=__UpperCamelCase  ,  padding_value=1.0						)

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

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






      def       lowerCamelCase__     (     self						)						->Any:







        '''simple docstring'''


        _a					      =						self.get_feature_extractor()
        _a					      =						self.get_tokenizer()

        _a					      =						WavaVecaProcessor(tokenizer=__UpperCamelCase  ,  feature_extractor=__UpperCamelCase						)

        _a					      =						floats_list((3, 1_0_0_0)						)

        _a					      =						feature_extractor(__UpperCamelCase  ,  return_tensors="np"						)
        _a					      =						processor(__UpperCamelCase  ,  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       lowerCamelCase__     (     self						)						->List[Any]:







        '''simple docstring'''


        _a					      =						self.get_feature_extractor()
        _a					      =						self.get_tokenizer()

        _a					      =						WavaVecaProcessor(tokenizer=__UpperCamelCase  ,  feature_extractor=__UpperCamelCase						)

        _a					      =						"This is a test string"

        _a					      =						processor(text=__UpperCamelCase						)

        _a					      =						tokenizer(__UpperCamelCase						)

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






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







        '''simple docstring'''


        _a					      =						self.get_feature_extractor()
        _a					      =						self.get_tokenizer()

        _a					      =						WavaVecaProcessor(tokenizer=__UpperCamelCase  ,  feature_extractor=__UpperCamelCase						)

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

        _a					      =						processor.batch_decode(__UpperCamelCase						)
        _a					      =						tokenizer.batch_decode(__UpperCamelCase						)

        self.assertListEqual(__UpperCamelCase  ,  __UpperCamelCase						)






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







        '''simple docstring'''


        _a					      =						self.get_feature_extractor()
        _a					      =						self.get_tokenizer()

        _a					      =						WavaVecaProcessor(tokenizer=__UpperCamelCase  ,  feature_extractor=__UpperCamelCase						)

        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 				a__			(					lowerCAmelCase						:							str		):






     '''simple docstring'''
     UpperCAmelCase__				:			Optional[Any]							=    str(lowerCAmelCase		).strip()
     if not oct_string:
          raise ValueError("Empty string was passed to the function"		)
     UpperCAmelCase__				:			Tuple							=    oct_string[0] == "-"
     if is_negative:
          UpperCAmelCase__				:			List[Any]							=    oct_string[1:]
     if not oct_string.isdigit() or not all(0 <= int(lowerCAmelCase		) <= 7 for char in oct_string		):
          raise ValueError("Non-octal value was passed to the function"		)
     UpperCAmelCase__				:			Optional[int]							=    0
     for char in oct_string:
          UpperCAmelCase__				:			Tuple							=    8 * decimal_number + int(lowerCAmelCase		)
     if is_negative:
          UpperCAmelCase__				:			int							=    -decimal_number
     return decimal_number


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

    testmod()



