





"""simple docstring"""
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				,       _snake_case				,       _snake_case=99				,       _snake_case=13				,       _snake_case=16				,       _snake_case=7				,       _snake_case=True				,       _snake_case=True				,       _snake_case=True				,       _snake_case=False				,       _snake_case=True				,       _snake_case=2				,       _snake_case=32				,       _snake_case=4				,       _snake_case=4				,       _snake_case=30				,       _snake_case=0				,       _snake_case=1				,       _snake_case=2				,       _snake_case=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    UpperCamelCase__  (     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    UpperCamelCase__  (     self				,       _snake_case				,       _snake_case				,       _snake_case				,       _snake_case				,       ):







  """simple docstring"""






  lowerCAmelCase    				= True
  lowerCAmelCase    				= TrOCRDecoder(config=_snake_case     ).to(_snake_case     ).eval()
  lowerCAmelCase    				= input_ids[:2]

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

  self.parent.assertTrue(len(_snake_case     ) == len(_snake_case     )     )
  self.parent.assertTrue(len(_snake_case     ) == len(_snake_case     ) + 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(_snake_case     )['last_hidden_state']
  lowerCAmelCase    				= model(_snake_case				,       past_key_values=_snake_case     )['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(_snake_case				,       _snake_case				,       atol=1E-3     )



 def    UpperCamelCase__  (     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							(   a__   , a__   , a__   , unittest.TestCase  ):
 snake_case__             =       (TrOCRDecoder, TrOCRForCausalLM) if is_torch_available() else ()
 snake_case__             =       (TrOCRForCausalLM,) if is_torch_available() else ()
 snake_case__             =       {'''text-generation''': TrOCRForCausalLM} if is_torch_available() else {}
 snake_case__             =       True
 snake_case__             =       False



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  lowerCAmelCase    				= TrOCRStandaloneDecoderModelTester(self				,       is_training=_snake_case     )
  lowerCAmelCase    				= ConfigTester(self				,       config_class=_snake_case     )



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  pass



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  pass



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  pass



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  self.config_tester.run_common_tests()



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  lowerCAmelCase    				= self.model_tester.prepare_config_and_inputs()
  self.model_tester.create_and_check_decoder_model_past(*_snake_case     )



 def    UpperCamelCase__  (     self     ):







  """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     ):







  """simple docstring"""






  pass










import unittest

from transformers import MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING, is_vision_available
from transformers.pipelines import pipeline
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_tf,
    require_torch,
    require_vision,
    slow,
)

from .test_pipelines_common import ANY


if is_vision_available():
							from PIL import Image
else:


							class   __lowerCAmelCase  :
												"""simple docstring"""






												@staticmethod
												def      _a				(  *_snake_case       :							Any					,       **_snake_case       :							Optional[int]       ):






															"""simple docstring"""


															pass


@is_pipeline_test
@require_torch
@require_vision
class   __lowerCAmelCase  (		unittest.TestCase   ):
					"""simple docstring"""






					A__					:		Union[str, Any]      							=     MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING



					def      _a				(  self       :							List[Any]					,       _snake_case       :							Union[str, Any]					,       _snake_case       :							Tuple					,       _snake_case       :							Union[str, Any]       ):






								"""simple docstring"""


								A__	  =     pipeline('visual-question-answering'					,       model='hf-internal-testing/tiny-vilt-random-vqa'       )
								A__	  =     [
								    {
								        'image': Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'       ),
								        'question': 'How many cats are there?',
								    },
								    {
								        'image': './tests/fixtures/tests_samples/COCO/000000039769.png',
								        'question': 'How many cats are there?',
								    },
								]
								return vqa_pipeline, examples



					def      _a				(  self       :							Optional[Any]					,       _snake_case       :							Union[str, Any]					,       _snake_case       :							List[str]       ):






								"""simple docstring"""


								A__	  =     vqa_pipeline(_snake_case					,       top_k=1       )
								self.assertEqual(
								    _snake_case					,       [
								        [{'score': ANY(_snake_case       ), 'answer': ANY(_snake_case       )}],
								        [{'score': ANY(_snake_case       ), 'answer': ANY(_snake_case       )}],
								    ]					,       )



					@require_torch
					def      _a				(  self       :							Any       ):






								"""simple docstring"""


								A__	  =     pipeline('visual-question-answering'					,       model='hf-internal-testing/tiny-vilt-random-vqa'       )
								A__	  =     './tests/fixtures/tests_samples/COCO/000000039769.png'
								A__	  =     'How many cats are there?'

								A__	  =     vqa_pipeline(image=_snake_case					,       question='How many cats are there?'					,       top_k=2       )
								self.assertEqual(
								    _snake_case					,       [{'score': ANY(_snake_case       ), 'answer': ANY(_snake_case       )}, {'score': ANY(_snake_case       ), 'answer': ANY(_snake_case       )}]       )

								A__	  =     vqa_pipeline({'image': image, 'question': question}					,       top_k=2       )
								self.assertEqual(
								    _snake_case					,       [{'score': ANY(_snake_case       ), 'answer': ANY(_snake_case       )}, {'score': ANY(_snake_case       ), 'answer': ANY(_snake_case       )}]       )



					@slow
					@require_torch
					def      _a				(  self       :							Any       ):






								"""simple docstring"""


								A__	  =     pipeline('visual-question-answering'					,       model='dandelin/vilt-b32-finetuned-vqa'       )
								A__	  =     './tests/fixtures/tests_samples/COCO/000000039769.png'
								A__	  =     'How many cats are there?'

								A__	  =     vqa_pipeline(image=_snake_case					,       question=_snake_case					,       top_k=2       )
								self.assertEqual(
								    nested_simplify(_snake_case					,       decimals=4       )					,       [{'score': 0.8799, 'answer': '2'}, {'score': 0.296, 'answer': '1'}]       )

								A__	  =     vqa_pipeline({'image': image, 'question': question}					,       top_k=2       )
								self.assertEqual(
								    nested_simplify(_snake_case					,       decimals=4       )					,       [{'score': 0.8799, 'answer': '2'}, {'score': 0.296, 'answer': '1'}]       )

								A__	  =     vqa_pipeline(
								    [{'image': image, 'question': question}, {'image': image, 'question': question}]					,       top_k=2       )
								self.assertEqual(
								    nested_simplify(_snake_case					,       decimals=4       )					,       [[{'score': 0.8799, 'answer': '2'}, {'score': 0.296, 'answer': '1'}]] * 2					,       )



					@require_tf
					@unittest.skip('Visual question answering not implemented in TF'       )
					def      _a				(  self       :							Dict       ):






								"""simple docstring"""


								pass




