


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 	__a   (       unittest.TestCase    ):
		def 			UpperCAmelCase__       (    self		)				-> str:




									"""simple docstring"""





									_UpperCAmelCase					=    '<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(' '		)
									_UpperCAmelCase					=    dict(zip(_SCREAMING_SNAKE_CASE    ,					range(len(_SCREAMING_SNAKE_CASE		)		)		)		)

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

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

									with open(self.feature_extraction_file    ,					'w'    ,					encoding='utf-8'		) as fp:
																fp.write(json.dumps(_SCREAMING_SNAKE_CASE		) + '\n'		)
		def 			UpperCAmelCase__       (    self    ,					**_SCREAMING_SNAKE_CASE		)				-> Dict:




									"""simple docstring"""





									_UpperCAmelCase					=    self.add_kwargs_tokens_map.copy()
									kwargs.update(_SCREAMING_SNAKE_CASE		)
									return WavaVecaCTCTokenizer.from_pretrained(self.tmpdirname    ,					**_SCREAMING_SNAKE_CASE		)
		def 			UpperCAmelCase__       (    self    ,					**_SCREAMING_SNAKE_CASE		)				-> Optional[int]:




									"""simple docstring"""





									return WavaVecaFeatureExtractor.from_pretrained(self.tmpdirname    ,					**_SCREAMING_SNAKE_CASE		)
		def 			UpperCAmelCase__       (    self		)				-> List[str]:




									"""simple docstring"""





									shutil.rmtree(self.tmpdirname		)
		def 			UpperCAmelCase__       (    self		)				-> Any:




									"""simple docstring"""





									_UpperCAmelCase					=    self.get_tokenizer()
									_UpperCAmelCase					=    self.get_feature_extractor()

									_UpperCAmelCase					=    WavaVecaProcessor(tokenizer=_SCREAMING_SNAKE_CASE    ,					feature_extractor=_SCREAMING_SNAKE_CASE		)

									processor.save_pretrained(self.tmpdirname		)
									_UpperCAmelCase					=    WavaVecaProcessor.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 			UpperCAmelCase__       (    self		)				-> List[Any]:




									"""simple docstring"""





									_UpperCAmelCase					=    WavaVecaProcessor(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					=    WavaVecaProcessor.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 			UpperCAmelCase__       (    self		)				-> List[str]:




									"""simple docstring"""





									_UpperCAmelCase					=    self.get_feature_extractor()
									_UpperCAmelCase					=    self.get_tokenizer()

									_UpperCAmelCase					=    WavaVecaProcessor(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 			UpperCAmelCase__       (    self		)				-> Any:




									"""simple docstring"""





									_UpperCAmelCase					=    self.get_feature_extractor()
									_UpperCAmelCase					=    self.get_tokenizer()

									_UpperCAmelCase					=    WavaVecaProcessor(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 			UpperCAmelCase__       (    self		)				-> Dict:




									"""simple docstring"""





									_UpperCAmelCase					=    self.get_feature_extractor()
									_UpperCAmelCase					=    self.get_tokenizer()

									_UpperCAmelCase					=    WavaVecaProcessor(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 			UpperCAmelCase__       (    self		)				-> Any:




									"""simple docstring"""





									_UpperCAmelCase					=    self.get_feature_extractor()
									_UpperCAmelCase					=    self.get_tokenizer()

									_UpperCAmelCase					=    WavaVecaProcessor(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'    ,					)




import warnings

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding

class 	__a   (       UpperCAmelCase    ):
		_a			:						int    			=			['image_processor', 'tokenizer']
		_a			:						Union[str, Any]    			=			'AutoImageProcessor'
		_a			:						Optional[int]    			=			'AutoTokenizer'
		def __init__(    self    ,					_SCREAMING_SNAKE_CASE=None    ,					_SCREAMING_SNAKE_CASE=None    ,					**_SCREAMING_SNAKE_CASE		)				-> Tuple:




									"""simple docstring"""





									_UpperCAmelCase					=    None
									if "feature_extractor" in kwargs:
																warnings.warn(
																    'The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`'
																    ' instead.'    ,					_SCREAMING_SNAKE_CASE    ,					)
																_UpperCAmelCase					=    kwargs.pop('feature_extractor'		)

									_UpperCAmelCase					=    image_processor if image_processor is not None else feature_extractor
									if image_processor is None:
																raise ValueError('You have to specify an image_processor.'		)
									if tokenizer is None:
																raise ValueError('You have to specify a tokenizer.'		)

									super().__init__(_SCREAMING_SNAKE_CASE    ,					_SCREAMING_SNAKE_CASE		)
									_UpperCAmelCase					=    self.image_processor
		def __call__(    self    ,					_SCREAMING_SNAKE_CASE=None    ,					_SCREAMING_SNAKE_CASE=None    ,					_SCREAMING_SNAKE_CASE=None    ,					**_SCREAMING_SNAKE_CASE		)				-> Dict:




									"""simple docstring"""





									if text is None and images is None:
																raise ValueError('You have to specify either text or images. Both cannot be none.'		)

									if text is not None:
																_UpperCAmelCase					=    self.tokenizer(_SCREAMING_SNAKE_CASE    ,					return_tensors=_SCREAMING_SNAKE_CASE    ,					**_SCREAMING_SNAKE_CASE		)

									if images is not None:
																_UpperCAmelCase					=    self.image_processor(_SCREAMING_SNAKE_CASE    ,					return_tensors=_SCREAMING_SNAKE_CASE    ,					**_SCREAMING_SNAKE_CASE		)

									if text is not None and images is not None:
																_UpperCAmelCase					=    image_features.pixel_values
																return encoding
									elif text is not None:
																return encoding
									else:
																return BatchEncoding(data=dict(**_SCREAMING_SNAKE_CASE		)    ,					tensor_type=_SCREAMING_SNAKE_CASE		)
		def 			UpperCAmelCase__       (    self    ,					*_SCREAMING_SNAKE_CASE    ,					**_SCREAMING_SNAKE_CASE		)				-> int:




									"""simple docstring"""





									return self.tokenizer.batch_decode(*_SCREAMING_SNAKE_CASE    ,					**_SCREAMING_SNAKE_CASE		)
		def 			UpperCAmelCase__       (    self    ,					*_SCREAMING_SNAKE_CASE    ,					**_SCREAMING_SNAKE_CASE		)				-> Tuple:




									"""simple docstring"""





									return self.tokenizer.decode(*_SCREAMING_SNAKE_CASE    ,					**_SCREAMING_SNAKE_CASE		)
		@property
		def 			UpperCAmelCase__       (    self		)				-> Optional[int]:




									"""simple docstring"""





									_UpperCAmelCase					=    self.tokenizer.model_input_names
									_UpperCAmelCase					=    self.image_processor.model_input_names
									return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names		)		)
		@property
		def 			UpperCAmelCase__       (    self		)				-> Any:




									"""simple docstring"""





									warnings.warn(
									    '`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead.'    ,					_SCREAMING_SNAKE_CASE    ,					)
									return self.image_processor_class






		@property
		def 			UpperCAmelCase__       (    self		)				-> Any:




									"""simple docstring"""





									warnings.warn(
									    '`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead.'    ,					_SCREAMING_SNAKE_CASE    ,					)
									return self.image_processor
