





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


    '''simple docstring'''







    def __init__(       self   ,				A_   ,				A_=99   ,				A_=13   ,				A_=16   ,				A_=7   ,				A_=True   ,				A_=True   ,				A_=True   ,				A_=False   ,				A_=True   ,				A_=2   ,				A_=32   ,				A_=4   ,				A_=4   ,				A_=30   ,				A_=0   ,				A_=1   ,				A_=2   ,				A_=None   ,				):





        '''simple docstring'''

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

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

        SCREAMING_SNAKE_CASE__											=			None
        SCREAMING_SNAKE_CASE__											=			decoder_seq_length
        SCREAMING_SNAKE_CASE__											=			2
        SCREAMING_SNAKE_CASE__											=			1



    def  lowercase_					(       self     ):





        '''simple docstring'''

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

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

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

        SCREAMING_SNAKE_CASE__											=			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  lowercase_					(       self   ,				A_   ,				A_   ,				A_   ,				A_   ,				):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			True
        SCREAMING_SNAKE_CASE__											=			TrOCRDecoder(config=A_     ).to(A_     ).eval()
        SCREAMING_SNAKE_CASE__											=			input_ids[:2]

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

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

        SCREAMING_SNAKE_CASE__											=			outputs['''past_key_values''']

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

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

        SCREAMING_SNAKE_CASE__											=			model(A_     )['''last_hidden_state''']
        SCREAMING_SNAKE_CASE__											=			model(A_   ,				past_key_values=A_     )['''last_hidden_state''']

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

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




    def  lowercase_					(       self     ):





        '''simple docstring'''

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

        SCREAMING_SNAKE_CASE__											=			{'''input_ids''': input_ids, '''attention_mask''': attention_mask}
        return config, inputs_dict





@require_torch
class 					__snake_case	(  __SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE			,     unittest.TestCase    ):


    '''simple docstring'''







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



    def  lowercase_					(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			TrOCRStandaloneDecoderModelTester(self   ,				is_training=A_     )
        SCREAMING_SNAKE_CASE__											=			ConfigTester(self   ,				config_class=A_     )



    def  lowercase_					(       self     ):





        '''simple docstring'''

        pass



    def  lowercase_					(       self     ):





        '''simple docstring'''

        pass



    def  lowercase_					(       self     ):





        '''simple docstring'''

        pass



    def  lowercase_					(       self     ):





        '''simple docstring'''

        self.config_tester.run_common_tests()



    def  lowercase_					(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_decoder_model_past(*A_     )



    def  lowercase_					(       self     ):





        '''simple docstring'''

        return




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





        '''simple docstring'''

        pass

from typing import Optional
from urllib.parse import quote

import huggingface_hub as hfh
from packaging import version


def 				lowerCAmelCase__       (			a__    ,     a__    ,     a__ = None )      ->str:




  '''simple docstring'''

  if version.parse(hfh.__version__ ).release < version.parse("0.11.0" ).release:
    # old versions of hfh don't url-encode the file path
    _UpperCamelCase           =    quote(a__ )
  return hfh.hf_hub_url(a__    ,     a__    ,     repo_type="dataset"    ,     revision=a__ )




