




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 			a__    :






						def __init__(   self		,			_A		,			_A=9_9		,			_A=1_3		,			_A=1_6		,			_A=7		,			_A=True		,			_A=True		,			_A=True		,			_A=False		,			_A=True		,			_A=2		,			_A=3_2		,			_A=4		,			_A=4		,			_A=3_0		,			_A=0		,			_A=1		,			_A=2		,			_A=None		,			):




											"""simple docstring"""



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

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

											__lowerCAmelCase				   =       None
											__lowerCAmelCase				   =       decoder_seq_length
											__lowerCAmelCase				   =       2
											__lowerCAmelCase				   =       1






						def 				__SCREAMING_SNAKE_CASE(   self			):




											"""simple docstring"""



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

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

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

											__lowerCAmelCase				   =       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 				__SCREAMING_SNAKE_CASE(   self		,			_A		,			_A		,			_A		,			_A		,			):




											"""simple docstring"""



											__lowerCAmelCase				   =       True
											__lowerCAmelCase				   =       TrOCRDecoder(config=_A			).to(_A			).eval()
											__lowerCAmelCase				   =       input_ids[:2]

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

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

											__lowerCAmelCase				   =       outputs["past_key_values"]

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

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

											__lowerCAmelCase				   =       model(_A			)["last_hidden_state"]
											__lowerCAmelCase				   =       model(_A		,			past_key_values=_A			)["last_hidden_state"]

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

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






						def 				__SCREAMING_SNAKE_CASE(   self			):




											"""simple docstring"""



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

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






@require_torch
class 			a__    (					snake_case__ ,				snake_case__ ,				snake_case__ ,				unittest.TestCase      ):
						_a							:    List[Any]					=    (TrOCRDecoder, TrOCRForCausalLM) if is_torch_available() else ()
						_a							:    Dict					=    (TrOCRForCausalLM,) if is_torch_available() else ()
						_a							:    Union[str, Any]					=    {"""text-generation""": TrOCRForCausalLM} if is_torch_available() else {}
						_a							:    List[Any]					=    True
						_a							:    Dict					=    False






						def 				__SCREAMING_SNAKE_CASE(   self			):




											"""simple docstring"""



											__lowerCAmelCase				   =       TrOCRStandaloneDecoderModelTester(self		,			is_training=_A			)
											__lowerCAmelCase				   =       ConfigTester(self		,			config_class=_A			)






						def 				__SCREAMING_SNAKE_CASE(   self			):




											"""simple docstring"""



											pass






						def 				__SCREAMING_SNAKE_CASE(   self			):




											"""simple docstring"""



											pass






						def 				__SCREAMING_SNAKE_CASE(   self			):




											"""simple docstring"""



											pass






						def 				__SCREAMING_SNAKE_CASE(   self			):




											"""simple docstring"""



											self.config_tester.run_common_tests()






						def 				__SCREAMING_SNAKE_CASE(   self			):




											"""simple docstring"""



											__lowerCAmelCase				   =       self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_decoder_model_past(*_A			)






						def 				__SCREAMING_SNAKE_CASE(   self			):




											"""simple docstring"""



											return






						@unittest.skip("The model doesn't support left padding"			)  # and it's not used enough to be worth fixing :)
						def 				__SCREAMING_SNAKE_CASE(   self			):




											"""simple docstring"""



											pass






import inspect
import warnings
from typing import Any, Dict, Optional, Union

from packaging import version







def 						_snake_case(  *SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__ = None					,	SCREAMING_SNAKE_CASE__=True					,	SCREAMING_SNAKE_CASE__=2				) ->    Optional[Any]:
       from .. import __version__

       lowercase							:     int       	=      take_from
       lowercase							:     Tuple       	=      ()
       if not isinstance(args[0]					,	SCREAMING_SNAKE_CASE__				):
              lowercase							:     Dict       	=      (args,)

       for attribute, version_name, message in args:
              if version.parse(version.parse(SCREAMING_SNAKE_CASE__				).base_version				) >= version.parse(SCREAMING_SNAKE_CASE__				):
                     raise ValueError(
                         f"The deprecation tuple {(attribute, version_name, message)} should be removed since diffusers'"
                         f" version {__version__} is >= {version_name}"				)

              lowercase							:     int       	=      None
              if isinstance(SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__				) and attribute in deprecated_kwargs:
                     values += (deprecated_kwargs.pop(SCREAMING_SNAKE_CASE__				),)
                     lowercase							:     Union[str, Any]       	=      f"The `{attribute}` argument is deprecated and will be removed in version {version_name}."
              elif hasattr(SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__				):
                     values += (getattr(SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__				),)
                     lowercase							:     int       	=      f"The `{attribute}` attribute is deprecated and will be removed in version {version_name}."
              elif deprecated_kwargs is None:
                     lowercase							:     Dict       	=      f"`{attribute}` is deprecated and will be removed in version {version_name}."

              if warning is not None:
                     lowercase							:     Dict       	=      warning + """ """ if standard_warn else """"""
                     warnings.warn(warning + message					,	SCREAMING_SNAKE_CASE__					,	stacklevel=SCREAMING_SNAKE_CASE__				)

       if isinstance(SCREAMING_SNAKE_CASE__					,	SCREAMING_SNAKE_CASE__				) and len(SCREAMING_SNAKE_CASE__				) > 0:
              lowercase							:     str       	=      inspect.getouterframes(inspect.currentframe()				)[1]
              lowercase							:     List[str]       	=      call_frame.filename
              lowercase							:     Tuple       	=      call_frame.lineno
              lowercase							:     List[str]       	=      call_frame.function
              lowercase	,			lowercase							:     Optional[Any]       	=      next(iter(deprecated_kwargs.items()				)				)
              raise TypeError(f"{function} in {filename} line {line_number-1} got an unexpected keyword argument `{key}`"				)

       if len(SCREAMING_SNAKE_CASE__				) == 0:
              return
       elif len(SCREAMING_SNAKE_CASE__				) == 1:
              return values[0]
       return values
