



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




    '''simple docstring'''






    def 			_lowerCAmelCase					(       self		):
        A :       int          =   tempfile.mkdtemp()

        A :       Optional[Any]          =   [
            "[UNK]",
            "[CLS]",
            "[SEP]",
            "[PAD]",
            "[MASK]",
            "want",
            "##want",
            "##ed",
            "wa",
            "un",
            "runn",
            "##ing",
            ",",
            "low",
            "lowest",
        ]
        A :       Tuple          =   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]		)		)

        A :       str          =   {
            "do_resize": True,
            "size": 20,
            "do_center_crop": True,
            "crop_size": 18,
            "do_normalize": True,
            "image_mean": [0.4814_5466, 0.457_8275, 0.4082_1073],
            "image_std": [0.2686_2954, 0.2613_0258, 0.2757_7711],
        }
        A :       List[str]          =   os.path.join(self.tmpdirname,		_A		)
        with open(self.image_processor_file,		"""w""",		encoding="""utf-8"""		) as fp:
            json.dump(_A,		_A		)






    def 			_lowerCAmelCase					(       self,		**lowerCamelCase__		):
        return BertTokenizer.from_pretrained(self.tmpdirname,		**_A		)






    def 			_lowerCAmelCase					(       self,		**lowerCamelCase__		):
        return BertTokenizerFast.from_pretrained(self.tmpdirname,		**_A		)






    def 			_lowerCAmelCase					(       self,		**lowerCamelCase__		):
        return EfficientNetImageProcessor.from_pretrained(self.tmpdirname,		**_A		)






    def 			_lowerCAmelCase					(       self		):
        shutil.rmtree(self.tmpdirname		)






    def 			_lowerCAmelCase					(       self		):
        A :       Tuple          =   [np.random.randint(255,		size=(3, 30, 400),		dtype=np.uinta		)]
        A :       Optional[Any]          =   [Image.fromarray(np.moveaxis(_A,		0,		-1		)		) for x in image_inputs]
        return image_inputs






    def 			_lowerCAmelCase					(       self		):
        A :       str          =   self.get_tokenizer()
        A :       Union[str, Any]          =   self.get_rust_tokenizer()
        A :       List[str]          =   self.get_image_processor()

        A :       Any          =   AlignProcessor(tokenizer=_A,		image_processor=_A		)
        processor_slow.save_pretrained(self.tmpdirname		)
        A :       Tuple          =   AlignProcessor.from_pretrained(self.tmpdirname,		use_fast=_A		)

        A :       Optional[Any]          =   AlignProcessor(tokenizer=_A,		image_processor=_A		)
        processor_fast.save_pretrained(self.tmpdirname		)
        A :       Tuple          =   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,		_A		)
        self.assertIsInstance(processor_fast.tokenizer,		_A		)

        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,		_A		)
        self.assertIsInstance(processor_fast.image_processor,		_A		)






    def 			_lowerCAmelCase					(       self		):
        A :       Tuple          =   AlignProcessor(tokenizer=self.get_tokenizer(),		image_processor=self.get_image_processor()		)
        processor.save_pretrained(self.tmpdirname		)

        A :       Any          =   self.get_tokenizer(bos_token="""(BOS)""",		eos_token="""(EOS)"""		)
        A :       List[Any]          =   self.get_image_processor(do_normalize=_A,		padding_value=1.0		)

        A :       List[Any]          =   AlignProcessor.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.image_processor.to_json_string(),		image_processor_add_kwargs.to_json_string()		)
        self.assertIsInstance(processor.image_processor,		_A		)






    def 			_lowerCAmelCase					(       self		):
        A :       str          =   self.get_image_processor()
        A :       Any          =   self.get_tokenizer()

        A :       Dict          =   AlignProcessor(tokenizer=_A,		image_processor=_A		)

        A :       Union[str, Any]          =   self.prepare_image_inputs()

        A :       List[str]          =   image_processor(_A,		return_tensors="""np"""		)
        A :       str          =   processor(images=_A,		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		):
        A :       Optional[int]          =   self.get_image_processor()
        A :       int          =   self.get_tokenizer()

        A :       Optional[int]          =   AlignProcessor(tokenizer=_A,		image_processor=_A		)

        A :       Optional[int]          =   "lower newer"

        A :       List[str]          =   processor(text=_A		)

        A :       List[Any]          =   tokenizer(_A,		padding="""max_length""",		max_length=64		)

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






    def 			_lowerCAmelCase					(       self		):
        A :       List[str]          =   self.get_image_processor()
        A :       Optional[Any]          =   self.get_tokenizer()

        A :       Optional[Any]          =   AlignProcessor(tokenizer=_A,		image_processor=_A		)

        A :       List[Any]          =   "lower newer"
        A :       Union[str, Any]          =   self.prepare_image_inputs()

        A :       Union[str, Any]          =   processor(text=_A,		images=_A		)

        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(_A		):
            processor()






    def 			_lowerCAmelCase					(       self		):
        A :       str          =   self.get_image_processor()
        A :       Any          =   self.get_tokenizer()

        A :       Any          =   AlignProcessor(tokenizer=_A,		image_processor=_A		)

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

        A :       Any          =   processor.batch_decode(_A		)
        A :       List[Any]          =   tokenizer.batch_decode(_A		)

        self.assertListEqual(_A,		_A		)






    def 			_lowerCAmelCase					(       self		):
        A :       Dict          =   self.get_image_processor()
        A :       Tuple          =   self.get_tokenizer()

        A :       Any          =   AlignProcessor(tokenizer=_A,		image_processor=_A		)

        A :       str          =   "lower newer"
        A :       Optional[int]          =   self.prepare_image_inputs()

        A :       Optional[Any]          =   processor(text=_A,		images=_A		)

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



import unittest

import numpy as np

from transformers.testing_utils import require_flax, require_tf, require_torch
from transformers.utils import (
    expand_dims,
    flatten_dict,
    is_flax_available,
    is_tf_available,
    is_torch_available,
    reshape,
    squeeze,
    transpose,
)


if is_flax_available():
		import jax.numpy as jnp

if is_tf_available():
		import tensorflow as tf

if is_torch_available():
		import torch






class 		a__						(					unittest.TestCase					):

					def 				__UpperCamelCase   (    self      :       List[str]    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Dict				      =    {
							    "task_specific_params": {
							        "summarization": {"length_penalty": 1.0, "max_length": 128, "min_length": 12, "num_beams": 4},
							        "summarization_cnn": {"length_penalty": 2.0, "max_length": 142, "min_length": 56, "num_beams": 4},
							        "summarization_xsum": {"length_penalty": 1.0, "max_length": 62, "min_length": 11, "num_beams": 6},
							    }
							}
							SCREAMING_SNAKE_CASE_  :		Any				      =    {
							    "task_specific_params.summarization.length_penalty": 1.0,
							    "task_specific_params.summarization.max_length": 128,
							    "task_specific_params.summarization.min_length": 12,
							    "task_specific_params.summarization.num_beams": 4,
							    "task_specific_params.summarization_cnn.length_penalty": 2.0,
							    "task_specific_params.summarization_cnn.max_length": 142,
							    "task_specific_params.summarization_cnn.min_length": 56,
							    "task_specific_params.summarization_cnn.num_beams": 4,
							    "task_specific_params.summarization_xsum.length_penalty": 1.0,
							    "task_specific_params.summarization_xsum.max_length": 62,
							    "task_specific_params.summarization_xsum.min_length": 11,
							    "task_specific_params.summarization_xsum.num_beams": 6,
							}

							self.assertEqual(flatten_dict(_A    ),_A    )

					def 				__UpperCamelCase   (    self      :       str    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Dict				      =    np.random.randn(3,4    )
							self.assertTrue(np.allclose(transpose(_A    ),x.transpose()    )    )

							SCREAMING_SNAKE_CASE_  :		Tuple				      =    np.random.randn(3,4,5    )
							self.assertTrue(np.allclose(transpose(_A,axes=(1, 2, 0)    ),x.transpose((1, 2, 0)    )    )    )

					@require_torch
					def 				__UpperCamelCase   (    self      :       List[Any]    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		List[str]				      =    np.random.randn(3,4    )
							SCREAMING_SNAKE_CASE_  :		Any				      =    torch.tensor(_A    )
							self.assertTrue(np.allclose(transpose(_A    ),transpose(_A    ).numpy()    )    )

							SCREAMING_SNAKE_CASE_  :		Dict				      =    np.random.randn(3,4,5    )
							SCREAMING_SNAKE_CASE_  :		Tuple				      =    torch.tensor(_A    )
							self.assertTrue(np.allclose(transpose(_A,axes=(1, 2, 0)    ),transpose(_A,axes=(1, 2, 0)    ).numpy()    )    )

					@require_tf
					def 				__UpperCamelCase   (    self      :       List[str]    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Tuple				      =    np.random.randn(3,4    )
							SCREAMING_SNAKE_CASE_  :		Optional[Any]				      =    tf.constant(_A    )
							self.assertTrue(np.allclose(transpose(_A    ),transpose(_A    ).numpy()    )    )

							SCREAMING_SNAKE_CASE_  :		List[str]				      =    np.random.randn(3,4,5    )
							SCREAMING_SNAKE_CASE_  :		Union[str, Any]				      =    tf.constant(_A    )
							self.assertTrue(np.allclose(transpose(_A,axes=(1, 2, 0)    ),transpose(_A,axes=(1, 2, 0)    ).numpy()    )    )

					@require_flax
					def 				__UpperCamelCase   (    self      :       List[str]    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		str				      =    np.random.randn(3,4    )
							SCREAMING_SNAKE_CASE_  :		Tuple				      =    jnp.array(_A    )
							self.assertTrue(np.allclose(transpose(_A    ),np.asarray(transpose(_A    )    )    )    )

							SCREAMING_SNAKE_CASE_  :		Union[str, Any]				      =    np.random.randn(3,4,5    )
							SCREAMING_SNAKE_CASE_  :		List[Any]				      =    jnp.array(_A    )
							self.assertTrue(np.allclose(transpose(_A,axes=(1, 2, 0)    ),np.asarray(transpose(_A,axes=(1, 2, 0)    )    )    )    )

					def 				__UpperCamelCase   (    self      :       Dict    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Tuple				      =    np.random.randn(3,4    )
							self.assertTrue(np.allclose(reshape(_A,(4, 3)    ),np.reshape(_A,(4, 3)    )    )    )

							SCREAMING_SNAKE_CASE_  :		Any				      =    np.random.randn(3,4,5    )
							self.assertTrue(np.allclose(reshape(_A,(12, 5)    ),np.reshape(_A,(12, 5)    )    )    )

					@require_torch
					def 				__UpperCamelCase   (    self      :       Optional[Any]    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		List[Any]				      =    np.random.randn(3,4    )
							SCREAMING_SNAKE_CASE_  :		List[str]				      =    torch.tensor(_A    )
							self.assertTrue(np.allclose(reshape(_A,(4, 3)    ),reshape(_A,(4, 3)    ).numpy()    )    )

							SCREAMING_SNAKE_CASE_  :		Dict				      =    np.random.randn(3,4,5    )
							SCREAMING_SNAKE_CASE_  :		int				      =    torch.tensor(_A    )
							self.assertTrue(np.allclose(reshape(_A,(12, 5)    ),reshape(_A,(12, 5)    ).numpy()    )    )

					@require_tf
					def 				__UpperCamelCase   (    self      :       Dict    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		List[Any]				      =    np.random.randn(3,4    )
							SCREAMING_SNAKE_CASE_  :		Optional[Any]				      =    tf.constant(_A    )
							self.assertTrue(np.allclose(reshape(_A,(4, 3)    ),reshape(_A,(4, 3)    ).numpy()    )    )

							SCREAMING_SNAKE_CASE_  :		int				      =    np.random.randn(3,4,5    )
							SCREAMING_SNAKE_CASE_  :		Any				      =    tf.constant(_A    )
							self.assertTrue(np.allclose(reshape(_A,(12, 5)    ),reshape(_A,(12, 5)    ).numpy()    )    )

					@require_flax
					def 				__UpperCamelCase   (    self      :       Tuple    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		List[str]				      =    np.random.randn(3,4    )
							SCREAMING_SNAKE_CASE_  :		int				      =    jnp.array(_A    )
							self.assertTrue(np.allclose(reshape(_A,(4, 3)    ),np.asarray(reshape(_A,(4, 3)    )    )    )    )

							SCREAMING_SNAKE_CASE_  :		Union[str, Any]				      =    np.random.randn(3,4,5    )
							SCREAMING_SNAKE_CASE_  :		Tuple				      =    jnp.array(_A    )
							self.assertTrue(np.allclose(reshape(_A,(12, 5)    ),np.asarray(reshape(_A,(12, 5)    )    )    )    )

					def 				__UpperCamelCase   (    self      :       Optional[Any]    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		int				      =    np.random.randn(1,3,4    )
							self.assertTrue(np.allclose(squeeze(_A    ),np.squeeze(_A    )    )    )

							SCREAMING_SNAKE_CASE_  :		Any				      =    np.random.randn(1,4,1,5    )
							self.assertTrue(np.allclose(squeeze(_A,axis=2    ),np.squeeze(_A,axis=2    )    )    )

					@require_torch
					def 				__UpperCamelCase   (    self      :       List[str]    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		List[str]				      =    np.random.randn(1,3,4    )
							SCREAMING_SNAKE_CASE_  :		Any				      =    torch.tensor(_A    )
							self.assertTrue(np.allclose(squeeze(_A    ),squeeze(_A    ).numpy()    )    )

							SCREAMING_SNAKE_CASE_  :		Any				      =    np.random.randn(1,4,1,5    )
							SCREAMING_SNAKE_CASE_  :		Dict				      =    torch.tensor(_A    )
							self.assertTrue(np.allclose(squeeze(_A,axis=2    ),squeeze(_A,axis=2    ).numpy()    )    )

					@require_tf
					def 				__UpperCamelCase   (    self      :       Union[str, Any]    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		str				      =    np.random.randn(1,3,4    )
							SCREAMING_SNAKE_CASE_  :		Union[str, Any]				      =    tf.constant(_A    )
							self.assertTrue(np.allclose(squeeze(_A    ),squeeze(_A    ).numpy()    )    )

							SCREAMING_SNAKE_CASE_  :		Any				      =    np.random.randn(1,4,1,5    )
							SCREAMING_SNAKE_CASE_  :		Optional[int]				      =    tf.constant(_A    )
							self.assertTrue(np.allclose(squeeze(_A,axis=2    ),squeeze(_A,axis=2    ).numpy()    )    )

					@require_flax
					def 				__UpperCamelCase   (    self      :       List[Any]    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		List[Any]				      =    np.random.randn(1,3,4    )
							SCREAMING_SNAKE_CASE_  :		List[str]				      =    jnp.array(_A    )
							self.assertTrue(np.allclose(squeeze(_A    ),np.asarray(squeeze(_A    )    )    )    )

							SCREAMING_SNAKE_CASE_  :		str				      =    np.random.randn(1,4,1,5    )
							SCREAMING_SNAKE_CASE_  :		Union[str, Any]				      =    jnp.array(_A    )
							self.assertTrue(np.allclose(squeeze(_A,axis=2    ),np.asarray(squeeze(_A,axis=2    )    )    )    )

					def 				__UpperCamelCase   (    self      :       List[Any]    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Tuple				      =    np.random.randn(3,4    )
							self.assertTrue(np.allclose(expand_dims(_A,axis=1    ),np.expand_dims(_A,axis=1    )    )    )

					@require_torch
					def 				__UpperCamelCase   (    self      :       Dict    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Tuple				      =    np.random.randn(3,4    )
							SCREAMING_SNAKE_CASE_  :		List[Any]				      =    torch.tensor(_A    )
							self.assertTrue(np.allclose(expand_dims(_A,axis=1    ),expand_dims(_A,axis=1    ).numpy()    )    )

					@require_tf
					def 				__UpperCamelCase   (    self      :       Union[str, Any]    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		List[Any]				      =    np.random.randn(3,4    )
							SCREAMING_SNAKE_CASE_  :		Optional[int]				      =    tf.constant(_A    )
							self.assertTrue(np.allclose(expand_dims(_A,axis=1    ),expand_dims(_A,axis=1    ).numpy()    )    )






					@require_flax
					def 				__UpperCamelCase   (    self      :       List[Any]    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		int				      =    np.random.randn(3,4    )
							SCREAMING_SNAKE_CASE_  :		Union[str, Any]				      =    jnp.array(_A    )
							self.assertTrue(np.allclose(expand_dims(_A,axis=1    ),np.asarray(expand_dims(_A,axis=1    )    )    )    )
