

import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin


if is_torch_available():
    import torch

if is_vision_available():
    from PIL import Image

    from transformers import BlipImageProcessor





class       __UpperCAmelCase  ( unittest.TestCase		):



   def __init__(							self							:  Any,	__A							:  Dict,	__A							:  Dict=7,	__A							:  str=3,	__A							:  Union[str, Any]=1_8,	__A							:  Optional[Any]=3_0,	__A							:  Union[str, Any]=4_0_0,	__A							:  Optional[Any]=True,	__A							:  Optional[int]=None,	__A							:  Any=True,	__A							:  Any=False,	__A							:  Dict=[0.4_8_1_4_5_4_6_6, 0.4_5_7_8_2_7_5, 0.4_0_8_2_1_0_7_3],	__A							:  Optional[int]=[0.2_6_8_6_2_9_5_4, 0.2_6_1_3_0_2_5_8, 0.2_7_5_7_7_7_1_1],	__A							:  Tuple=True,	):
     UpperCAmelCase :							str								=				size if size is not None else {'''height''': 2_0, '''width''': 2_0}
     UpperCAmelCase :							Optional[int]								=				parent
     UpperCAmelCase :							Optional[int]								=				batch_size
     UpperCAmelCase :							Tuple								=				num_channels
     UpperCAmelCase :							Union[str, Any]								=				image_size
     UpperCAmelCase :							Dict								=				min_resolution
     UpperCAmelCase :							Tuple								=				max_resolution
     UpperCAmelCase :							Union[str, Any]								=				do_resize
     UpperCAmelCase :							Union[str, Any]								=				size
     UpperCAmelCase :							Union[str, Any]								=				do_normalize
     UpperCAmelCase :							Optional[Any]								=				image_mean
     UpperCAmelCase :							str								=				image_std
     UpperCAmelCase :							int								=				do_pad
     UpperCAmelCase :							Optional[Any]								=				do_convert_rgb



   def  __magic_name__					(							self							:  List[Any]		):
     return {
         "do_resize": self.do_resize,
         "size": self.size,
         "do_normalize": self.do_normalize,
         "image_mean": self.image_mean,
         "image_std": self.image_std,
         "do_convert_rgb": self.do_convert_rgb,
         "do_pad": self.do_pad,
     }





   def  __magic_name__					(							self							:  str,	__A							:  int=False,	__A							:  Tuple=False,	__A							:  Optional[Any]=False		):
     assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

     if equal_resolution:
       UpperCAmelCase :							Optional[Any]								=				[]
       for i in range(self.batch_size		):
         image_inputs.append(
             np.random.randint(
                 2_5_5,	size=(self.num_channels, self.max_resolution, self.max_resolution),	dtype=np.uinta		)		)
     else:
       UpperCAmelCase :							Union[str, Any]								=				[]
       for i in range(self.batch_size		):
         UpperCAmelCase :							int								=				np.random.choice(np.arange(self.min_resolution,	self.max_resolution		),	2		)
         image_inputs.append(np.random.randint(2_5_5,	size=(self.num_channels, width, height),	dtype=np.uinta		)		)

     if not numpify and not torchify:
       # PIL expects the channel dimension as last dimension
       UpperCAmelCase :							List[Any]								=				[Image.fromarray(np.moveaxis(__A,	0,	-1		)		) for x in image_inputs]

     if torchify:
       UpperCAmelCase :							List[str]								=				[torch.from_numpy(__A		) for x in image_inputs]

     return image_inputs






@require_torch
@require_vision
class       __UpperCAmelCase  ( lowerCamelCase__    ,						unittest.TestCase		):
   UpperCamelCase       =  BlipImageProcessor if is_vision_available() else None



   def  __magic_name__					(							self							:  Optional[Any]		):
     UpperCAmelCase :							Optional[int]								=				BlipImageProcessingTester(self		)



   @property
   def  __magic_name__					(							self							:  Union[str, Any]		):
     return self.image_processor_tester.prepare_image_processor_dict()



   def  __magic_name__					(							self							:  str		):
     UpperCAmelCase :							Dict								=				self.image_processing_class(**self.image_processor_dict		)
     self.assertTrue(hasattr(__A,	'''do_resize'''		)		)
     self.assertTrue(hasattr(__A,	'''size'''		)		)
     self.assertTrue(hasattr(__A,	'''do_normalize'''		)		)
     self.assertTrue(hasattr(__A,	'''image_mean'''		)		)
     self.assertTrue(hasattr(__A,	'''image_std'''		)		)
     self.assertTrue(hasattr(__A,	'''do_convert_rgb'''		)		)



   def  __magic_name__					(							self							:  Tuple		):
     pass



   def  __magic_name__					(							self							:  Any		):
     # Initialize image_processor
     UpperCAmelCase :							List[str]								=				self.image_processing_class(**self.image_processor_dict		)
     # create random PIL images
     UpperCAmelCase :							List[Any]								=				self.image_processor_tester.prepare_inputs(equal_resolution=__A		)
     for image in image_inputs:
       self.assertIsInstance(__A,	Image.Image		)

     # Test not batched input
     UpperCAmelCase :							Any								=				image_processor(image_inputs[0],	return_tensors='''pt'''		).pixel_values
     self.assertEqual(
         encoded_images.shape,	(
             1,
             self.image_processor_tester.num_channels,
             self.image_processor_tester.size['''height'''],
             self.image_processor_tester.size['''width'''],
         ),	)

     # Test batched
     UpperCAmelCase :							Any								=				image_processor(__A,	return_tensors='''pt'''		).pixel_values
     self.assertEqual(
         encoded_images.shape,	(
             self.image_processor_tester.batch_size,
             self.image_processor_tester.num_channels,
             self.image_processor_tester.size['''height'''],
             self.image_processor_tester.size['''width'''],
         ),	)



   def  __magic_name__					(							self							:  int		):
     # Initialize image_processor
     UpperCAmelCase :							int								=				self.image_processing_class(**self.image_processor_dict		)
     # create random numpy tensors
     UpperCAmelCase :							Optional[int]								=				self.image_processor_tester.prepare_inputs(equal_resolution=__A,	numpify=__A		)
     for image in image_inputs:
       self.assertIsInstance(__A,	np.ndarray		)

     # Test not batched input
     UpperCAmelCase :							List[Any]								=				image_processor(image_inputs[0],	return_tensors='''pt'''		).pixel_values
     self.assertEqual(
         encoded_images.shape,	(
             1,
             self.image_processor_tester.num_channels,
             self.image_processor_tester.size['''height'''],
             self.image_processor_tester.size['''width'''],
         ),	)

     # Test batched
     UpperCAmelCase :							Optional[int]								=				image_processor(__A,	return_tensors='''pt'''		).pixel_values
     self.assertEqual(
         encoded_images.shape,	(
             self.image_processor_tester.batch_size,
             self.image_processor_tester.num_channels,
             self.image_processor_tester.size['''height'''],
             self.image_processor_tester.size['''width'''],
         ),	)





   def  __magic_name__					(							self							:  List[Any]		):
     # Initialize image_processor
     UpperCAmelCase :							str								=				self.image_processing_class(**self.image_processor_dict		)
     # create random PyTorch tensors
     UpperCAmelCase :							int								=				self.image_processor_tester.prepare_inputs(equal_resolution=__A,	torchify=__A		)
     for image in image_inputs:
       self.assertIsInstance(__A,	torch.Tensor		)

     # Test not batched input
     UpperCAmelCase :							Optional[int]								=				image_processor(image_inputs[0],	return_tensors='''pt'''		).pixel_values
     self.assertEqual(
         encoded_images.shape,	(
             1,
             self.image_processor_tester.num_channels,
             self.image_processor_tester.size['''height'''],
             self.image_processor_tester.size['''width'''],
         ),	)

     # Test batched
     UpperCAmelCase :							int								=				image_processor(__A,	return_tensors='''pt'''		).pixel_values
     self.assertEqual(
         encoded_images.shape,	(
             self.image_processor_tester.batch_size,
             self.image_processor_tester.num_channels,
             self.image_processor_tester.size['''height'''],
             self.image_processor_tester.size['''width'''],
         ),	)






@require_torch
@require_vision
class       __UpperCAmelCase  ( lowerCamelCase__    ,						unittest.TestCase		):
   UpperCamelCase       =  BlipImageProcessor if is_vision_available() else None



   def  __magic_name__					(							self							:  List[str]		):
     UpperCAmelCase :							str								=				BlipImageProcessingTester(self,	num_channels=4		)
     UpperCAmelCase :							Dict								=				3



   @property
   def  __magic_name__					(							self							:  Union[str, Any]		):
     return self.image_processor_tester.prepare_image_processor_dict()



   def  __magic_name__					(							self							:  Any		):
     UpperCAmelCase :							int								=				self.image_processing_class(**self.image_processor_dict		)
     self.assertTrue(hasattr(__A,	'''do_resize'''		)		)
     self.assertTrue(hasattr(__A,	'''size'''		)		)
     self.assertTrue(hasattr(__A,	'''do_normalize'''		)		)
     self.assertTrue(hasattr(__A,	'''image_mean'''		)		)
     self.assertTrue(hasattr(__A,	'''image_std'''		)		)
     self.assertTrue(hasattr(__A,	'''do_convert_rgb'''		)		)



   def  __magic_name__					(							self							:  List[Any]		):
     pass





   def  __magic_name__					(							self							:  List[Any]		):
     # Initialize image_processor
     UpperCAmelCase :							Union[str, Any]								=				self.image_processing_class(**self.image_processor_dict		)
     # create random PIL images
     UpperCAmelCase :							Optional[Any]								=				self.image_processor_tester.prepare_inputs(equal_resolution=__A		)
     for image in image_inputs:
       self.assertIsInstance(__A,	Image.Image		)

     # Test not batched input
     UpperCAmelCase :							Tuple								=				image_processor(image_inputs[0],	return_tensors='''pt'''		).pixel_values
     self.assertEqual(
         encoded_images.shape,	(
             1,
             self.expected_encoded_image_num_channels,
             self.image_processor_tester.size['''height'''],
             self.image_processor_tester.size['''width'''],
         ),	)

     # Test batched
     UpperCAmelCase :							Tuple								=				image_processor(__A,	return_tensors='''pt'''		).pixel_values
     self.assertEqual(
         encoded_images.shape,	(
             self.image_processor_tester.batch_size,
             self.expected_encoded_image_num_channels,
             self.image_processor_tester.size['''height'''],
             self.image_processor_tester.size['''width'''],
         ),	)








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



   def  __magic_name__					(							self							:  Dict		):
     UpperCAmelCase :							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(''' '''		)
     UpperCAmelCase :							List[str]								=				dict(zip(__A,	range(len(__A		)		)		)		)

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

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

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



   def  __magic_name__					(							self							:  List[Any],	**__A							:  List[Any]		):
     UpperCAmelCase :							str								=				self.add_kwargs_tokens_map.copy()
     kwargs.update(__A		)
     return WavaVecaCTCTokenizer.from_pretrained(self.tmpdirname,	**__A		)



   def  __magic_name__					(							self							:  List[Any],	**__A							:  Union[str, Any]		):
     return WavaVecaFeatureExtractor.from_pretrained(self.tmpdirname,	**__A		)



   def  __magic_name__					(							self							:  Any		):
     shutil.rmtree(self.tmpdirname		)



   def  __magic_name__					(							self							:  str		):
     UpperCAmelCase :							Any								=				self.get_tokenizer()
     UpperCAmelCase :							Optional[int]								=				self.get_feature_extractor()

     UpperCAmelCase :							Tuple								=				WavaVecaProcessor(tokenizer=__A,	feature_extractor=__A		)

     processor.save_pretrained(self.tmpdirname		)
     UpperCAmelCase :							Union[str, Any]								=				WavaVecaProcessor.from_pretrained(self.tmpdirname		)

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

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



   def  __magic_name__					(							self							:  Optional[int]		):
     UpperCAmelCase :							int								=				WavaVecaProcessor(tokenizer=self.get_tokenizer(),	feature_extractor=self.get_feature_extractor()		)
     processor.save_pretrained(self.tmpdirname		)

     UpperCAmelCase :							Dict								=				self.get_tokenizer(bos_token='''(BOS)''',	eos_token='''(EOS)'''		)
     UpperCAmelCase :							int								=				self.get_feature_extractor(do_normalize=__A,	padding_value=1.0		)

     UpperCAmelCase :							int								=				WavaVecaProcessor.from_pretrained(
         self.tmpdirname,	bos_token='''(BOS)''',	eos_token='''(EOS)''',	do_normalize=__A,	padding_value=1.0		)

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

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



   def  __magic_name__					(							self							:  Union[str, Any]		):
     UpperCAmelCase :							Optional[Any]								=				self.get_feature_extractor()
     UpperCAmelCase :							Optional[int]								=				self.get_tokenizer()

     UpperCAmelCase :							Any								=				WavaVecaProcessor(tokenizer=__A,	feature_extractor=__A		)

     UpperCAmelCase :							Tuple								=				floats_list((3, 1_0_0_0)		)

     UpperCAmelCase :							Any								=				feature_extractor(__A,	return_tensors='''np'''		)
     UpperCAmelCase :							int								=				processor(__A,	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  __magic_name__					(							self							:  Union[str, Any]		):
     UpperCAmelCase :							Optional[Any]								=				self.get_feature_extractor()
     UpperCAmelCase :							Union[str, Any]								=				self.get_tokenizer()

     UpperCAmelCase :							List[Any]								=				WavaVecaProcessor(tokenizer=__A,	feature_extractor=__A		)

     UpperCAmelCase :							List[str]								=				'''This is a test string'''

     UpperCAmelCase :							Tuple								=				processor(text=__A		)

     UpperCAmelCase :							Tuple								=				tokenizer(__A		)

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



   def  __magic_name__					(							self							:  Optional[int]		):
     UpperCAmelCase :							Tuple								=				self.get_feature_extractor()
     UpperCAmelCase :							int								=				self.get_tokenizer()

     UpperCAmelCase :							List[str]								=				WavaVecaProcessor(tokenizer=__A,	feature_extractor=__A		)

     UpperCAmelCase :							Any								=				[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

     UpperCAmelCase :							str								=				processor.batch_decode(__A		)
     UpperCAmelCase :							List[str]								=				tokenizer.batch_decode(__A		)

     self.assertListEqual(__A,	__A		)





   def  __magic_name__					(							self							:  int		):
     UpperCAmelCase :							Optional[int]								=				self.get_feature_extractor()
     UpperCAmelCase :							List[str]								=				self.get_tokenizer()

     UpperCAmelCase :							Any								=				WavaVecaProcessor(tokenizer=__A,	feature_extractor=__A		)

     self.assertListEqual(
         processor.model_input_names,	feature_extractor.model_input_names,	msg='''`processor` and `feature_extractor` model input names do not match''',	)





