


import unittest

from transformers import TrOCRConfig
from transformers.testing_utils import is_torch_available, require_torch, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
       import torch

       from transformers.models.trocr.modeling_trocr import TrOCRDecoder, TrOCRForCausalLM







@require_torch
class        UpperCamelCase__   :

     def __init__(     self       :   Dict							,					UpperCamelCase__       :   List[str]							,					UpperCamelCase__       :   Any=99							,					UpperCamelCase__       :   Any=13							,					UpperCamelCase__       :   Optional[int]=16							,					UpperCamelCase__       :   Optional[int]=7							,					UpperCamelCase__       :   List[Any]=True							,					UpperCamelCase__       :   Optional[int]=True							,					UpperCamelCase__       :   int=True							,					UpperCamelCase__       :   Optional[int]=False							,					UpperCamelCase__       :   Any=True							,					UpperCamelCase__       :   Tuple=2							,					UpperCamelCase__       :   List[str]=32							,					UpperCamelCase__       :   int=4							,					UpperCamelCase__       :   Tuple=4							,					UpperCamelCase__       :   List[str]=30							,					UpperCamelCase__       :   List[str]=0							,					UpperCamelCase__       :   str=1							,					UpperCamelCase__       :   str=2							,					UpperCamelCase__       :   Any=None							,					):






          '''simple docstring'''






          lowercase_  							=			parent
          lowercase_  							=			batch_size
          lowercase_  							=			decoder_seq_length
          # For common tests
          lowercase_  							=			self.decoder_seq_length
          lowercase_  							=			is_training
          lowercase_  							=			use_attention_mask
          lowercase_  							=			use_labels

          lowercase_  							=			vocab_size
          lowercase_  							=			d_model
          lowercase_  							=			d_model
          lowercase_  							=			decoder_layers
          lowercase_  							=			decoder_layers
          lowercase_  							=			decoder_ffn_dim
          lowercase_  							=			decoder_attention_heads
          lowercase_  							=			decoder_attention_heads
          lowercase_  							=			eos_token_id
          lowercase_  							=			bos_token_id
          lowercase_  							=			pad_token_id
          lowercase_  							=			decoder_start_token_id
          lowercase_  							=			use_cache
          lowercase_  							=			max_position_embeddings

          lowercase_  							=			None
          lowercase_  							=			decoder_seq_length
          lowercase_  							=			2
          lowercase_  							=			1

     def   UpperCAmelCase__       (     self       :   Tuple       ):






          '''simple docstring'''






          lowercase_  							=			ids_tensor([self.batch_size, self.decoder_seq_length]							,					self.vocab_size       )

          lowercase_  							=			None
          if self.use_attention_mask:
               lowercase_  							=			ids_tensor([self.batch_size, self.decoder_seq_length]							,					vocab_size=2       )

          lowercase_  							=			None
          if self.use_labels:
               lowercase_  							=			ids_tensor([self.batch_size, self.decoder_seq_length]							,					self.vocab_size       )

          lowercase_  							=			TrOCRConfig(
              vocab_size=self.vocab_size							,					d_model=self.d_model							,					decoder_layers=self.decoder_layers							,					decoder_ffn_dim=self.decoder_ffn_dim							,					decoder_attention_heads=self.decoder_attention_heads							,					eos_token_id=self.eos_token_id							,					bos_token_id=self.bos_token_id							,					use_cache=self.use_cache							,					pad_token_id=self.pad_token_id							,					decoder_start_token_id=self.decoder_start_token_id							,					max_position_embeddings=self.max_position_embeddings							,					)

          return (config, input_ids, attention_mask, lm_labels)

     def   UpperCAmelCase__       (     self       :   Optional[int]							,					UpperCamelCase__       :   Tuple							,					UpperCamelCase__       :   List[str]							,					UpperCamelCase__       :   str							,					UpperCamelCase__       :   List[Any]							,					):






          '''simple docstring'''






          lowercase_  							=			True
          lowercase_  							=			TrOCRDecoder(config=_SCREAMING_SNAKE_CASE       ).to(_SCREAMING_SNAKE_CASE       ).eval()
          lowercase_  							=			input_ids[:2]

          input_ids[input_ids == 0] += 1
          # first forward pass
          lowercase_  							=			model(_SCREAMING_SNAKE_CASE							,					use_cache=_SCREAMING_SNAKE_CASE       )
          lowercase_  							=			model(_SCREAMING_SNAKE_CASE       )
          lowercase_  							=			model(_SCREAMING_SNAKE_CASE							,					use_cache=_SCREAMING_SNAKE_CASE       )

          self.parent.assertTrue(len(_SCREAMING_SNAKE_CASE       ) == len(_SCREAMING_SNAKE_CASE       )       )
          self.parent.assertTrue(len(_SCREAMING_SNAKE_CASE       ) == len(_SCREAMING_SNAKE_CASE       ) + 1       )

          lowercase_  							=			outputs["""past_key_values"""]

          # create hypothetical next token and extent to next_input_ids
          lowercase_  							=			ids_tensor((2, 1)							,					config.vocab_size - 1       ) + 1

          # append to next input_ids and
          lowercase_  							=			torch.cat([input_ids, next_tokens]							,					dim=-1       )

          lowercase_  							=			model(_SCREAMING_SNAKE_CASE       )["""last_hidden_state"""]
          lowercase_  							=			model(_SCREAMING_SNAKE_CASE							,					past_key_values=_SCREAMING_SNAKE_CASE       )["""last_hidden_state"""]

          # select random slice
          lowercase_  							=			ids_tensor((1,)							,					output_from_past.shape[-1]       ).item()
          lowercase_  							=			output_from_no_past[:, next_input_ids.shape[-1] - 1, random_slice_idx].detach()
          lowercase_  							=			output_from_past[:, 0, random_slice_idx].detach()

          # test that outputs are equal for slice
          assert torch.allclose(_SCREAMING_SNAKE_CASE							,					_SCREAMING_SNAKE_CASE							,					atol=1e-3       )







     def   UpperCAmelCase__       (     self       :   Optional[int]       ):






          '''simple docstring'''






          lowercase_  							=			self.prepare_config_and_inputs()
          lowercase_							,					lowercase_							,					lowercase_							,					lowercase_  							=			config_and_inputs

          lowercase_  							=			{"""input_ids""": input_ids, """attention_mask""": attention_mask}
          return config, inputs_dict







@require_torch
class        UpperCamelCase__   (	__magic_name__							,				__magic_name__							,				__magic_name__							,				unittest.TestCase   ):
     __SCREAMING_SNAKE_CASE       :  Dict						=   (TrOCRDecoder, TrOCRForCausalLM) if is_torch_available() else ()
     __SCREAMING_SNAKE_CASE       :  str						=   (TrOCRForCausalLM,) if is_torch_available() else ()
     __SCREAMING_SNAKE_CASE       :  List[str]						=   {'text-generation': TrOCRForCausalLM} if is_torch_available() else {}
     __SCREAMING_SNAKE_CASE       :  Union[str, Any]						=   True
     __SCREAMING_SNAKE_CASE       :  Tuple						=   False

     def   UpperCAmelCase__       (     self       :   Union[str, Any]       ):






          '''simple docstring'''






          lowercase_  							=			TrOCRStandaloneDecoderModelTester(self							,					is_training=_SCREAMING_SNAKE_CASE       )
          lowercase_  							=			ConfigTester(self							,					config_class=_SCREAMING_SNAKE_CASE       )

     def   UpperCAmelCase__       (     self       :   int       ):






          '''simple docstring'''






          pass

     def   UpperCAmelCase__       (     self       :   Dict       ):






          '''simple docstring'''






          pass

     def   UpperCAmelCase__       (     self       :   Any       ):






          '''simple docstring'''






          pass

     def   UpperCAmelCase__       (     self       :   List[Any]       ):






          '''simple docstring'''






          self.config_tester.run_common_tests()

     def   UpperCAmelCase__       (     self       :   Optional[int]       ):






          '''simple docstring'''






          lowercase_  							=			self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_decoder_model_past(*_SCREAMING_SNAKE_CASE       )

     def   UpperCAmelCase__       (     self       :   int       ):






          '''simple docstring'''






          return







     @unittest.skip("""The model doesn't support left padding"""       )  # and it's not used enough to be worth fixing :)
     def   UpperCAmelCase__       (     self       :   Union[str, Any]       ):






          '''simple docstring'''






          pass






from typing import Dict, Iterable, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    center_crop,
    get_resize_output_image_size,
    normalize,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    IMAGENET_DEFAULT_MEAN,
    IMAGENET_DEFAULT_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, logging


a					  =     logging.get_logger(__name__)







class        UpperCamelCase__   (	__magic_name__   ):
					__SCREAMING_SNAKE_CASE       :  List[Any]						=   ['pixel_values']

					def __init__(     self       :   List[str]							,					UpperCamelCase__       :   bool = True							,					UpperCamelCase__       :   Dict[str, int] = None							,					UpperCamelCase__       :   PILImageResampling = PILImageResampling.BICUBIC							,					UpperCamelCase__       :   bool = True							,					UpperCamelCase__       :   Dict[str, int] = None							,					UpperCamelCase__       :   bool = True							,					UpperCamelCase__       :   Union[int, float] = 1 / 255							,					UpperCamelCase__       :   bool = True							,					UpperCamelCase__       :   Optional[Union[float, Iterable[float]]] = IMAGENET_DEFAULT_MEAN							,					UpperCamelCase__       :   Optional[Union[float, Iterable[float]]] = IMAGENET_DEFAULT_STD							,					**UpperCamelCase__       :   Dict							,					):






										'''simple docstring'''






										super().__init__(**UpperCamelCase__       )
										lowercase_  							=			size if size is not None else {"""shortest_edge""": 224}
										lowercase_  							=			get_size_dict(UpperCamelCase__							,					default_to_square=UpperCamelCase__       )
										lowercase_  							=			crop_size if crop_size is not None else {"""height""": 224, """width""": 224}
										lowercase_  							=			get_size_dict(UpperCamelCase__							,					param_name="""crop_size"""       )

										lowercase_  							=			do_resize
										lowercase_  							=			size
										lowercase_  							=			resample
										lowercase_  							=			do_center_crop
										lowercase_  							=			crop_size
										lowercase_  							=			do_rescale
										lowercase_  							=			rescale_factor
										lowercase_  							=			do_normalize
										lowercase_  							=			image_mean if image_mean is not None else IMAGENET_DEFAULT_MEAN
										lowercase_  							=			image_std if image_std is not None else IMAGENET_DEFAULT_STD

					def   UpperCAmelCase__       (     self       :   int							,					UpperCamelCase__       :   np.ndarray							,					UpperCamelCase__       :   Dict[str, int]							,					UpperCamelCase__       :   PILImageResampling = PILImageResampling.BICUBIC							,					UpperCamelCase__       :   Optional[Union[str, ChannelDimension]] = None							,					**UpperCamelCase__       :   Optional[int]							,					):






										'''simple docstring'''






										lowercase_  							=			get_size_dict(UpperCamelCase__							,					default_to_square=UpperCamelCase__       )
										# size_dict is a dict with either keys "height" and "width" or "shortest_edge"
										if "shortest_edge" in size:
															lowercase_  							=			int((256 / 224) * size["""shortest_edge"""]       )
															lowercase_  							=			get_resize_output_image_size(UpperCamelCase__							,					size=UpperCamelCase__							,					default_to_square=UpperCamelCase__       )
															lowercase_  							=			{"""height""": output_size[0], """width""": output_size[1]}
										if "height" not in size_dict or "width" not in size_dict:
															raise ValueError(
															    F'''Size dict must have keys \'height\' and \'width\' or \'shortest_edge\'. Got {size_dict.keys()}'''       )
										return resize(
										    UpperCamelCase__							,					size=(size_dict["""height"""], size_dict["""width"""])							,					resample=UpperCamelCase__							,					data_format=UpperCamelCase__							,					**UpperCamelCase__       )

					def   UpperCAmelCase__       (     self       :   str							,					UpperCamelCase__       :   np.ndarray							,					UpperCamelCase__       :   Dict[str, int]							,					UpperCamelCase__       :   Optional[Union[str, ChannelDimension]] = None							,					**UpperCamelCase__       :   str							,					):






										'''simple docstring'''






										lowercase_  							=			get_size_dict(UpperCamelCase__       )
										if "height" not in size or "width" not in size:
															raise ValueError(F'''Size dict must have keys \'height\' and \'width\'. Got {size.keys()}'''       )
										return center_crop(UpperCamelCase__							,					size=(size["""height"""], size["""width"""])							,					data_format=UpperCamelCase__							,					**UpperCamelCase__       )

					def   UpperCAmelCase__       (     self       :   Optional[int]							,					UpperCamelCase__       :   np.ndarray							,					UpperCamelCase__       :   Union[int, float]							,					UpperCamelCase__       :   Optional[Union[str, ChannelDimension]] = None							,					**UpperCamelCase__       :   str							,					):






										'''simple docstring'''






										return rescale(UpperCamelCase__							,					scale=UpperCamelCase__							,					data_format=UpperCamelCase__							,					**UpperCamelCase__       )

					def   UpperCAmelCase__       (     self       :   List[str]							,					UpperCamelCase__       :   np.ndarray							,					UpperCamelCase__       :   Union[float, List[float]]							,					UpperCamelCase__       :   Union[float, List[float]]							,					UpperCamelCase__       :   Optional[Union[str, ChannelDimension]] = None							,					**UpperCamelCase__       :   Optional[int]							,					):






										'''simple docstring'''






										return normalize(UpperCamelCase__							,					mean=UpperCamelCase__							,					std=UpperCamelCase__							,					data_format=UpperCamelCase__							,					**UpperCamelCase__       )







					def   UpperCAmelCase__       (     self       :   Dict							,					UpperCamelCase__       :   ImageInput							,					UpperCamelCase__       :   Optional[bool] = None							,					UpperCamelCase__       :   Optional[Dict[str, int]] = None							,					UpperCamelCase__       :   PILImageResampling = None							,					UpperCamelCase__       :   Optional[bool] = None							,					UpperCamelCase__       :   Optional[Dict[str, int]] = None							,					UpperCamelCase__       :   Optional[bool] = None							,					UpperCamelCase__       :   Optional[float] = None							,					UpperCamelCase__       :   Optional[bool] = None							,					UpperCamelCase__       :   Optional[Union[float, Iterable[float]]] = None							,					UpperCamelCase__       :   Optional[Union[float, Iterable[float]]] = None							,					UpperCamelCase__       :   Optional[TensorType] = None							,					UpperCamelCase__       :   ChannelDimension = ChannelDimension.FIRST							,					**UpperCamelCase__       :   Optional[int]							,					):






										'''simple docstring'''






										lowercase_  							=			do_resize if do_resize is not None else self.do_resize
										lowercase_  							=			resample if resample is not None else self.resample
										lowercase_  							=			do_center_crop if do_center_crop is not None else self.do_center_crop
										lowercase_  							=			do_rescale if do_rescale is not None else self.do_rescale
										lowercase_  							=			rescale_factor if rescale_factor is not None else self.rescale_factor
										lowercase_  							=			do_normalize if do_normalize is not None else self.do_normalize
										lowercase_  							=			image_mean if image_mean is not None else self.image_mean
										lowercase_  							=			image_std if image_std is not None else self.image_std

										lowercase_  							=			size if size is not None else self.size
										lowercase_  							=			get_size_dict(UpperCamelCase__							,					default_to_square=UpperCamelCase__       )
										lowercase_  							=			crop_size if crop_size is not None else self.crop_size
										lowercase_  							=			get_size_dict(UpperCamelCase__							,					param_name="""crop_size"""       )

										lowercase_  							=			make_list_of_images(UpperCamelCase__       )

										if not valid_images(UpperCamelCase__       ):
															raise ValueError(
															    """Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, """
															    """torch.Tensor, tf.Tensor or jax.ndarray."""       )

										if do_resize and size is None:
															raise ValueError("""Size must be specified if do_resize is True."""       )

										if do_center_crop and crop_size is None:
															raise ValueError("""Crop size must be specified if do_center_crop is True."""       )

										if do_rescale and rescale_factor is None:
															raise ValueError("""Rescale factor must be specified if do_rescale is True."""       )

										if do_normalize and (image_mean is None or image_std is None):
															raise ValueError("""Image mean and std must be specified if do_normalize is True."""       )

										# All transformations expect numpy arrays.
										lowercase_  							=			[to_numpy_array(UpperCamelCase__       ) for image in images]

										if do_resize:
															lowercase_  							=			[self.resize(UpperCamelCase__							,					UpperCamelCase__							,					UpperCamelCase__       ) for image in images]

										if do_center_crop:
															lowercase_  							=			[self.center_crop(UpperCamelCase__							,					UpperCamelCase__       ) for image in images]

										if do_rescale:
															lowercase_  							=			[self.rescale(UpperCamelCase__							,					UpperCamelCase__       ) for image in images]

										if do_normalize:
															lowercase_  							=			[self.normalize(UpperCamelCase__							,					UpperCamelCase__							,					UpperCamelCase__       ) for image in images]

										lowercase_  							=			[to_channel_dimension_format(UpperCamelCase__							,					UpperCamelCase__       ) for image in images]

										lowercase_  							=			{"""pixel_values""": images}
										return BatchFeature(data=UpperCamelCase__							,					tensor_type=UpperCamelCase__       )


