


'''simple docstring'''

import unittest

from transformers import DonutProcessor


lowerCamelCase							:   Tuple  						=	'naver-clova-ix/donut-base'
class   __lowerCAmelCase						(unittest.TestCase     ):





      '''simple docstring'''






      def       UpperCamelCase__		(self    :    int ):

             '''simple docstring'''







             lowercase__      			= DonutProcessor.from_pretrained(UpperCamelCase )






      def       UpperCamelCase__		(self    :    Tuple ):

             '''simple docstring'''







             lowercase__      			= {
                 '''name''': '''John Doe''',
                 '''age''': '''99''',
                 '''city''': '''Atlanta''',
                 '''state''': '''GA''',
                 '''zip''': '''30301''',
                 '''phone''': '''123-4567''',
                 '''nicknames''': [{'''nickname''': '''Johnny'''}, {'''nickname''': '''JD'''}],
             }

             lowercase__      			= (
                 '''<s_name>John Doe</s_name><s_age>99</s_age><s_city>Atlanta</s_city>'''
                 '''<s_state>GA</s_state><s_zip>30301</s_zip><s_phone>123-4567</s_phone>'''
                 '''<s_nicknames><s_nickname>Johnny</s_nickname>'''
                 '''<sep/><s_nickname>JD</s_nickname></s_nicknames>'''
             )
             lowercase__      			= self.processor.tokenajson(UpperCamelCase )

             self.assertDictEqual(UpperCamelCase   ,						UpperCamelCase )








'''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   __lowerCAmelCase						:





      '''simple docstring'''






      def __init__(self    :    str   ,						UpperCamelCase    :    Tuple   ,						UpperCamelCase    :    Optional[int]=99   ,						UpperCamelCase    :    Optional[int]=13   ,						UpperCamelCase    :    Tuple=16   ,						UpperCamelCase    :    Union[str, Any]=7   ,						UpperCamelCase    :    List[Any]=True   ,						UpperCamelCase    :    List[str]=True   ,						UpperCamelCase    :    str=True   ,						UpperCamelCase    :    Tuple=False   ,						UpperCamelCase    :    str=True   ,						UpperCamelCase    :    Tuple=2   ,						UpperCamelCase    :    Optional[int]=32   ,						UpperCamelCase    :    Any=4   ,						UpperCamelCase    :    Optional[int]=4   ,						UpperCamelCase    :    Tuple=30   ,						UpperCamelCase    :    str=0   ,						UpperCamelCase    :    Tuple=1   ,						UpperCamelCase    :    List[Any]=2   ,						UpperCamelCase    :    str=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    :    str ):

             '''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    :    Tuple   ,						UpperCamelCase    :    List[Any]   ,						UpperCamelCase    :    Optional[Any]   ,						UpperCamelCase    :    Tuple   ,						UpperCamelCase    :    List[str]   ,						):

             '''simple docstring'''







             lowercase__      			= True
             lowercase__      			= TrOCRDecoder(config=UpperCamelCase ).to(UpperCamelCase ).eval()
             lowercase__      			= input_ids[:2]

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

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






      def       UpperCamelCase__		(self    :    Optional[Any] ):

             '''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   __lowerCAmelCase						(lowercase_  ,     lowercase_  ,     lowercase_  ,     unittest.TestCase     ):





      '''simple docstring'''






      lowerCAmelCase__					:     List[str]  					=							(TrOCRDecoder, TrOCRForCausalLM) if is_torch_available() else ()
      lowerCAmelCase__					:     List[Any]  					=							(TrOCRForCausalLM,) if is_torch_available() else ()
      lowerCAmelCase__					:     Optional[Any]  					=							{"""text-generation""": TrOCRForCausalLM} if is_torch_available() else {}
      lowerCAmelCase__					:     Optional[Any]  					=							True
      lowerCAmelCase__					:     List[str]  					=							False



      def       UpperCamelCase__		(self    :    Any ):

             '''simple docstring'''







             lowercase__      			= TrOCRStandaloneDecoderModelTester(self   ,						is_training=UpperCamelCase )
             lowercase__      			= ConfigTester(self   ,						config_class=UpperCamelCase )



      def       UpperCamelCase__		(self    :    List[str] ):

             '''simple docstring'''







             pass



      def       UpperCamelCase__		(self    :    Optional[int] ):

             '''simple docstring'''







             pass



      def       UpperCamelCase__		(self    :    Any ):

             '''simple docstring'''







             pass



      def       UpperCamelCase__		(self    :    Any ):

             '''simple docstring'''







             self.config_tester.run_common_tests()



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

             '''simple docstring'''







             lowercase__      			= self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_decoder_model_past(*UpperCamelCase )



      def       UpperCamelCase__		(self    :    Optional[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    :    List[str] ):

             '''simple docstring'''







             pass




