
'''simple docstring'''







import json
import os
import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers import BertTokenizer, BertTokenizerFast
from transformers.models.bert.tokenization_bert import VOCAB_FILES_NAMES
from transformers.testing_utils import require_vision
from transformers.utils import IMAGE_PROCESSOR_NAME, is_vision_available


if is_vision_available():
					from PIL import Image

					from transformers import AlignProcessor, EfficientNetImageProcessor


@require_vision
class 		__UpperCAmelCase   (      unittest.TestCase		):


							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	tempfile.mkdtemp()

								_snake_case     		=	[
								    '[UNK]',
								    '[CLS]',
								    '[SEP]',
								    '[PAD]',
								    '[MASK]',
								    'want',
								    '##want',
								    '##ed',
								    'wa',
								    'un',
								    'runn',
								    '##ing',
								    ',',
								    'low',
								    'lowest',
								]
								_snake_case     		=	os.path.join(self.tmpdirname					,     VOCAB_FILES_NAMES['vocab_file']						)
								with open(self.vocab_file					,     'w'					,     encoding='utf-8'						) as vocab_writer:
									vocab_writer.write(''.join([x + '\n' for x in vocab_tokens]						)						)

								_snake_case     		=	{
								    'do_resize': True,
								    'size': 20,
								    'do_center_crop': True,
								    'crop_size': 18,
								    'do_normalize': True,
								    'image_mean': [0.48145466, 0.4578275, 0.40821073],
								    'image_std': [0.26862954, 0.26130258, 0.27577711],
								}
								_snake_case     		=	os.path.join(self.tmpdirname					,     lowerCAmelCase_						)
								with open(self.image_processor_file					,     'w'					,     encoding='utf-8'						) as fp:
									json.dump(lowerCAmelCase_					,     lowerCAmelCase_						)


							def 				lowerCamelCase       ( self					,     **lowerCAmelCase_						):





								"""simple docstring"""






								return BertTokenizer.from_pretrained(self.tmpdirname					,     **lowerCAmelCase_						)


							def 				lowerCamelCase       ( self					,     **lowerCAmelCase_						):





								"""simple docstring"""






								return BertTokenizerFast.from_pretrained(self.tmpdirname					,     **lowerCAmelCase_						)


							def 				lowerCamelCase       ( self					,     **lowerCAmelCase_						):





								"""simple docstring"""






								return EfficientNetImageProcessor.from_pretrained(self.tmpdirname					,     **lowerCAmelCase_						)


							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								shutil.rmtree(self.tmpdirname						)


							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	[np.random.randint(2_55					,     size=(3, 30, 4_00)					,     dtype=np.uinta						)]
								_snake_case     		=	[Image.fromarray(np.moveaxis(lowerCAmelCase_					,     0					,     -1						)						) for x in image_inputs]
								return image_inputs


							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	self.get_tokenizer()
								_snake_case     		=	self.get_rust_tokenizer()
								_snake_case     		=	self.get_image_processor()

								_snake_case     		=	AlignProcessor(tokenizer=lowerCAmelCase_					,     image_processor=lowerCAmelCase_						)
								processor_slow.save_pretrained(self.tmpdirname						)
								_snake_case     		=	AlignProcessor.from_pretrained(self.tmpdirname					,     use_fast=lowerCAmelCase_						)

								_snake_case     		=	AlignProcessor(tokenizer=lowerCAmelCase_					,     image_processor=lowerCAmelCase_						)
								processor_fast.save_pretrained(self.tmpdirname						)
								_snake_case     		=	AlignProcessor.from_pretrained(self.tmpdirname						)

								self.assertEqual(processor_slow.tokenizer.get_vocab()					,     tokenizer_slow.get_vocab()						)
								self.assertEqual(processor_fast.tokenizer.get_vocab()					,     tokenizer_fast.get_vocab()						)
								self.assertEqual(tokenizer_slow.get_vocab()					,     tokenizer_fast.get_vocab()						)
								self.assertIsInstance(processor_slow.tokenizer					,     lowerCAmelCase_						)
								self.assertIsInstance(processor_fast.tokenizer					,     lowerCAmelCase_						)

								self.assertEqual(processor_slow.image_processor.to_json_string()					,     image_processor.to_json_string()						)
								self.assertEqual(processor_fast.image_processor.to_json_string()					,     image_processor.to_json_string()						)
								self.assertIsInstance(processor_slow.image_processor					,     lowerCAmelCase_						)
								self.assertIsInstance(processor_fast.image_processor					,     lowerCAmelCase_						)


							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	AlignProcessor(tokenizer=self.get_tokenizer()					,     image_processor=self.get_image_processor()						)
								processor.save_pretrained(self.tmpdirname						)

								_snake_case     		=	self.get_tokenizer(bos_token='(BOS)'					,     eos_token='(EOS)'						)
								_snake_case     		=	self.get_image_processor(do_normalize=lowerCAmelCase_					,     padding_value=1.0						)

								_snake_case     		=	AlignProcessor.from_pretrained(
								    self.tmpdirname					,     bos_token='(BOS)'					,     eos_token='(EOS)'					,     do_normalize=lowerCAmelCase_					,     padding_value=1.0						)

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

								self.assertEqual(processor.image_processor.to_json_string()					,     image_processor_add_kwargs.to_json_string()						)
								self.assertIsInstance(processor.image_processor					,     lowerCAmelCase_						)


							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	self.get_image_processor()
								_snake_case     		=	self.get_tokenizer()

								_snake_case     		=	AlignProcessor(tokenizer=lowerCAmelCase_					,     image_processor=lowerCAmelCase_						)

								_snake_case     		=	self.prepare_image_inputs()

								_snake_case     		=	image_processor(lowerCAmelCase_					,     return_tensors='np'						)
								_snake_case     		=	processor(images=lowerCAmelCase_					,     return_tensors='np'						)

								for key in input_image_proc.keys():
									self.assertAlmostEqual(input_image_proc[key].sum()					,     input_processor[key].sum()					,     delta=1E-2						)


							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	self.get_image_processor()
								_snake_case     		=	self.get_tokenizer()

								_snake_case     		=	AlignProcessor(tokenizer=lowerCAmelCase_					,     image_processor=lowerCAmelCase_						)

								_snake_case     		=	'lower newer'

								_snake_case     		=	processor(text=lowerCAmelCase_						)

								_snake_case     		=	tokenizer(lowerCAmelCase_					,     padding='max_length'					,     max_length=64						)

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


							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	self.get_image_processor()
								_snake_case     		=	self.get_tokenizer()

								_snake_case     		=	AlignProcessor(tokenizer=lowerCAmelCase_					,     image_processor=lowerCAmelCase_						)

								_snake_case     		=	'lower newer'
								_snake_case     		=	self.prepare_image_inputs()

								_snake_case     		=	processor(text=lowerCAmelCase_					,     images=lowerCAmelCase_						)

								self.assertListEqual(list(inputs.keys()						)					,     ['input_ids', 'token_type_ids', 'attention_mask', 'pixel_values']						)

								# test if it raises when no input is passed
								with pytest.raises(lowerCAmelCase_						):
									processor()


							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	self.get_image_processor()
								_snake_case     		=	self.get_tokenizer()

								_snake_case     		=	AlignProcessor(tokenizer=lowerCAmelCase_					,     image_processor=lowerCAmelCase_						)

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

								_snake_case     		=	processor.batch_decode(lowerCAmelCase_						)
								_snake_case     		=	tokenizer.batch_decode(lowerCAmelCase_						)

								self.assertListEqual(lowerCAmelCase_					,     lowerCAmelCase_						)




							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	self.get_image_processor()
								_snake_case     		=	self.get_tokenizer()

								_snake_case     		=	AlignProcessor(tokenizer=lowerCAmelCase_					,     image_processor=lowerCAmelCase_						)

								_snake_case     		=	'lower newer'
								_snake_case     		=	self.prepare_image_inputs()

								_snake_case     		=	processor(text=lowerCAmelCase_					,     images=lowerCAmelCase_						)

								self.assertListEqual(list(inputs.keys()						)					,     processor.model_input_names						)



'''simple docstring'''







from ..utils import DummyObject, requires_backends


class 		__UpperCAmelCase   (      metaclass=_lowerCamelCase		):
							__lowercase   	= ["""torch""", """torchsde"""]


							def __init__( self					,     *lowerCAmelCase_					,     **lowerCAmelCase_						):





								"""simple docstring"""






								requires_backends(self					,     ['torch', 'torchsde']						)


							@classmethod
							def 				lowerCamelCase       ( cls					,     *lowerCAmelCase_					,     **lowerCAmelCase_						):





								"""simple docstring"""






								requires_backends(cls					,     ['torch', 'torchsde']						)




							@classmethod
							def 				lowerCamelCase       ( cls					,     *lowerCAmelCase_					,     **lowerCAmelCase_						):





								"""simple docstring"""






								requires_backends(cls					,     ['torch', 'torchsde']						)

