code: 
  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 			_a(self							:   Dict						)   -> List[str]:
  							_lowercase					:  Tuple    			=      "<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(" "						)
  							_lowercase					:  Optional[int]    			=      dict(zip(snake_case			,  range(len(snake_case						)						)						)						)
  
  							_lowercase					:  Optional[Any]    			=      {
  							    "pad_token": "<pad>",
  							    "unk_token": "<unk>",
  							    "bos_token": "<s>",
  							    "eos_token": "</s>",
  							}
  							_lowercase					:  str    			=      {
  							    "feature_size": 1,
  							    "padding_value": 0.0,
  							    "sampling_rate": 1_6000,
  							    "return_attention_mask": False,
  							    "do_normalize": True,
  							}
  
  							_lowercase					:  Tuple    			=      tempfile.mkdtemp()
  							_lowercase					:  Dict    			=      os.path.join(self.tmpdirname			,  VOCAB_FILES_NAMES["vocab_file"]						)
  							_lowercase					:  List[str]    			=      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 			_a(self							:   int			,  **snake_case							:   List[str]						)   -> Optional[Any]:
  							_lowercase					:  Any    			=      self.add_kwargs_tokens_map.copy()
  							kwargs.update(snake_case						)
  							return WavaVecaCTCTokenizer.from_pretrained(self.tmpdirname			,  **snake_case						)
  
  
  
  
  
  
  	def 			_a(self							:   Any			,  **snake_case							:   Dict						)   -> Any:
  							return WavaVecaFeatureExtractor.from_pretrained(self.tmpdirname			,  **snake_case						)
  
  
  
  
  
  
  	def 			_a(self							:   str						)   -> str:
  							shutil.rmtree(self.tmpdirname						)
  
  
  
  
  
  
  	def 			_a(self							:   List[str]						)   -> Optional[int]:
  							_lowercase					:  Dict    			=      self.get_tokenizer()
  							_lowercase					:  Optional[Any]    			=      self.get_feature_extractor()
  
  							_lowercase					:  List[Any]    			=      WavaVecaProcessor(tokenizer=snake_case			,  feature_extractor=snake_case						)
  
  							processor.save_pretrained(self.tmpdirname						)
  							_lowercase					:  Optional[Any]    			=      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 			_a(self							:   List[Any]						)   -> Union[str, Any]:
  							_lowercase					:  Any    			=      WavaVecaProcessor(tokenizer=self.get_tokenizer()			,  feature_extractor=self.get_feature_extractor()						)
  							processor.save_pretrained(self.tmpdirname						)
  
  							_lowercase					:  List[Any]    			=      self.get_tokenizer(bos_token="(BOS)"			,  eos_token="(EOS)"						)
  							_lowercase					:  Optional[Any]    			=      self.get_feature_extractor(do_normalize=snake_case			,  padding_value=1.0						)
  
  							_lowercase					:  str    			=      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 			_a(self							:   Tuple						)   -> str:
  							_lowercase					:  Dict    			=      self.get_feature_extractor()
  							_lowercase					:  List[Any]    			=      self.get_tokenizer()
  
  							_lowercase					:  Optional[int]    			=      WavaVecaProcessor(tokenizer=snake_case			,  feature_extractor=snake_case						)
  
  							_lowercase					:  Union[str, Any]    			=      floats_list((3, 1000)						)
  
  							_lowercase					:  Any    			=      feature_extractor(snake_case			,  return_tensors="np"						)
  							_lowercase					:  Tuple    			=      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 			_a(self							:   Optional[Any]						)   -> str:
  							_lowercase					:  Optional[Any]    			=      self.get_feature_extractor()
  							_lowercase					:  Any    			=      self.get_tokenizer()
  
  							_lowercase					:  Any    			=      WavaVecaProcessor(tokenizer=snake_case			,  feature_extractor=snake_case						)
  
  							_lowercase					:  Tuple    			=      "This is a test string"
  
  							_lowercase					:  List[str]    			=      processor(text=snake_case						)
  
  							_lowercase					:  Any    			=      tokenizer(snake_case						)
  
  							for key in encoded_tok.keys():
  													self.assertListEqual(encoded_tok[key]			,  encoded_processor[key]						)
  
  
  
  
  
  
  	def 			_a(self							:   Optional[Any]						)   -> int:
  							_lowercase					:  Any    			=      self.get_feature_extractor()
  							_lowercase					:  Union[str, Any]    			=      self.get_tokenizer()
  
  							_lowercase					:  Any    			=      WavaVecaProcessor(tokenizer=snake_case			,  feature_extractor=snake_case						)
  
  							_lowercase					:  Optional[Any]    			=      [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]
  
  							_lowercase					:  int    			=      processor.batch_decode(snake_case						)
  							_lowercase					:  List[str]    			=      tokenizer.batch_decode(snake_case						)
  
  							self.assertListEqual(snake_case			,  snake_case						)
  
  
  
  
  
  
  	def 			_a(self							:   Union[str, Any]						)   -> Tuple:
  							_lowercase					:  List[str]    			=      self.get_feature_extractor()
  							_lowercase					:  List[Any]    			=      self.get_tokenizer()
  
  							_lowercase					:  List[Any]    			=      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"			,  )
  
  
  
  
  
style_context: 
  import os
  import unittest
  
  from transformers.models.bertweet.tokenization_bertweet import VOCAB_FILES_NAMES, BertweetTokenizer
  
  from ...test_tokenization_common import TokenizerTesterMixin
  
  
  
  
  class      __lowercase	(	__snake_case      ,   unittest.TestCase					):
  	_A   			=      BertweetTokenizer
  	_A   			=      False
  
  
  
  
  
  
  	def 			_a(self							:   Tuple						)   -> Any:
  							super().setUp()
  
  							# Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt
  							_lowercase					:  Tuple    			=      ["I", "m", "V@@", "R@@", "r", "e@@"]
  							_lowercase					:  Tuple    			=      dict(zip(snake_case			,  range(len(snake_case						)						)						)						)
  							_lowercase					:  Tuple    			=      ["#version: 0.2", "a m</w>"]
  							_lowercase					:  Optional[Any]    			=      {"unk_token": "<unk>"}
  
  							_lowercase					:  int    			=      os.path.join(self.tmpdirname			,  VOCAB_FILES_NAMES["vocab_file"]						)
  							_lowercase					:  Optional[int]    			=      os.path.join(self.tmpdirname			,  VOCAB_FILES_NAMES["merges_file"]						)
  							with open(self.vocab_file			,  "w"			,  encoding="utf-8"						) as fp:
  													for token in vocab_tokens:
  																			fp.write(F"""{token} {vocab_tokens[token]}\n"""						)
  							with open(self.merges_file			,  "w"			,  encoding="utf-8"						) as fp:
  													fp.write("\n".join(snake_case						)						)
  
  
  
  
  
  
  	def 			_a(self							:   List[Any]			,  **snake_case							:   Tuple						)   -> Union[str, Any]:
  							kwargs.update(self.special_tokens_map						)
  							return BertweetTokenizer.from_pretrained(self.tmpdirname			,  **snake_case						)
  
  
  
  
  
  
  	def 			_a(self							:   Any			,  snake_case							:   Any						)   -> List[Any]:
  							_lowercase					:  Tuple    			=      "I am VinAI Research"
  							_lowercase					:  Optional[int]    			=      "I <unk> m V<unk> <unk> <unk> I Re<unk> e<unk> <unk> <unk> <unk>"
  							return input_text, output_text
  
  
  
  
  
  
  	def 			_a(self							:   str						)   -> Optional[int]:
  							_lowercase					:  str    			=      BertweetTokenizer(self.vocab_file			,  self.merges_file			,  **self.special_tokens_map						)
  							_lowercase					:  Optional[Any]    			=      "I am VinAI Research"
  							_lowercase					:  str    			=      "I a@@ m V@@ i@@ n@@ A@@ I R@@ e@@ s@@ e@@ a@@ r@@ c@@ h".split()
  							_lowercase					:  Tuple    			=      tokenizer.tokenize(snake_case						)
  							self.assertListEqual(snake_case			,  snake_case						)
  
  							_lowercase					:  str    			=      tokens + [tokenizer.unk_token]
  
  							_lowercase					:  str    			=      [4, 3, 5, 6, 3, 3, 3, 4, 7, 9, 3, 9, 3, 3, 3, 3, 3]
  							self.assertListEqual(tokenizer.convert_tokens_to_ids(snake_case						)			,  snake_case						)
  
  
  
  
  