




'''simple docstring'''


from __future__ import annotations

import os
import tempfile
import unittest

import numpy as np
from huggingface_hub import hf_hub_download

from transformers import is_tensorflow_text_available, is_tf_available
from transformers.testing_utils import require_tensorflow_text, require_tf, slow

from ..test_modeling_tf_common import floats_tensor
from .test_framework_agnostic import GenerationIntegrationTestsMixin


if is_tf_available():
				import tensorflow as tf

				from transformers import (
				    AutoTokenizer,
				    TFAutoModelForCausalLM,
				    TFAutoModelForSeqaSeqLM,
				    TFAutoModelForSpeechSeqaSeq,
				    TFAutoModelForVisionaSeq,
				    TFBartForConditionalGeneration,
				    TFLogitsProcessorList,
				    TFMinLengthLogitsProcessor,
				    tf_top_k_top_p_filtering,
				)

if is_tensorflow_text_available():
				import tensorflow_text as text

@require_tf
class       A   (		unittest.TestCase   ):







							def        __lowerCAmelCase      (  self	:  Optional[Any] )      ->							List[str]:


														"""simple docstring"""


														_a     					=    tf.convert_to_tensor(
														    [
														        [
														            8.2_2_2_0_9_9_1,  # 3rd highest value; idx. 0
														            -0.5_6_2_0_0_4_4,
														            5.2_3_2_2_9_7_5_2,
														            4.0_3_8_6_3_9_3,
														            -6.8_7_9_8_3_7_8,
														            -0.5_4_7_8_5_8_0_2,
														            -3.2_0_1_2_1_5_3,
														            2.9_2_7_7_7_1_7_6,
														            1.8_8_1_7_1_9_5_3,
														            7.3_5_3_4_1_2_7_6,  # 5th highest value; idx. 9
														            8.4_3_2_0_7_8_3_3,  # 2nd highest value; idx. 10
														            -9.8_5_7_1_1_8_3_6,
														            -5.9_6_2_0_9_2_3_6,
														            -1.1_3_0_3_9_1_6_1,
														            -7.1_1_1_5_2_9_4,
														            -0.8_3_6_9_6_3_3,
														            -5.3_1_8_6_4_0_8,
														            7.0_6_4_2_7_4_0_7,
														            0.8_1_3_6_9_3_4_4,
														            -0.8_2_0_2_3_8_1_7,
														            -5.9_1_7_9_7_9_6,
														            0.5_8_8_1_3_4_4_3,
														            -6.9_9_7_7_8_4_3_8,
														            4.7_1_5_5_1_1_8_9,
														            -0.1_8_7_7_1_6_3_7,
														            7.4_4_0_2_0_7_5_9,  # 4th highest value; idx. 25
														            9.3_8_4_5_0_9_8_7,  # 1st highest value; idx. 26
														            2.1_2_6_6_2_9_4_1,
														            -9.3_2_5_6_2_0_3_8,
														            2.3_5_6_5_2_5_2_2,
														        ],  # cummulative prob of 5 highest values <= 0.6
														        [
														            0.5_8_4_2_5_5_1_8,
														            4.5_3_1_3_9_2_3_8,
														            -5.5_7_5_1_0_4_6_4,
														            -6.2_8_0_3_0_6_9_9,
														            -7.1_9_5_2_9_5_0_3,
														            -4.0_2_1_2_2_5_5_1,
														            1.3_9_3_3_7_0_3_7,
														            -6.0_6_7_0_7_0_5_7,
														            1.5_9_4_8_0_5_1_7,
														            -9.6_4_3_1_1_9,
														            0.0_3_9_0_7_7_9_9,
														            0.6_7_2_3_1_7_6_2,
														            -8.8_8_2_0_6_7_2_6,
														            6.2_7_1_1_5_9_2_2,  # 4th highest value; idx. 13
														            2.2_8_5_2_0_7_2_3,
														            4.8_2_7_6_7_5_0_6,
														            4.3_0_4_2_1_3_6_8,
														            8.8_2_7_5_3_1_3,  # 2nd highest value; idx. 17
														            5.4_4_0_2_9_9_5_8,  # 5th highest value; idx. 18
														            -4.4_7_3_5_7_9_4,
														            7.3_8_5_7_9_5_3_6,  # 3rd highest value; idx. 20
														            -2.9_1_0_5_1_6_6_3,
														            2.6_1_9_4_6_0_7_7,
														            -2.5_6_7_4_7_6_2,
														            -9.4_8_9_5_9_3_0_2,
														            -4.0_2_9_2_2_6_4_5,
														            -1.3_5_4_1_6_9_1_8,
														            9.6_7_7_0_2_3_2_3,  # 1st highest value; idx. 27
														            -5.8_9_4_7_8_5_5_3,
														            1.8_5_3_7_0_4_6_7,
														        ],  # cummulative prob of 5 highest values <= 0.6
														    ]							,      dtype=tf.floataa							,      )

														_a     					=    tf.convert_to_tensor(
														    [[0, 0], [0, 9], [0, 10], [0, 25], [0, 26], [1, 13], [1, 17], [1, 18], [1, 20], [1, 27]]							,      dtype=tf.intaa							,      )  # expected non filtered idx as noted above

														_a     					=    tf.convert_to_tensor(
														    [8.2_2_2_0_9_9, 7.3_5_3_4_1_2_6, 8.4_3_2_0_7_8, 7.4_4_0_2_0_7_5, 9.3_8_4_5_1, 6.2_7_1_1_5_9, 8.8_2_7_5_3_1, 5.4_4_0_2_9_9_5, 7.3_8_5_7_9_5_6, 9.6_7_7_0_2_3]							,      dtype=tf.floataa							,      )  # expected non filtered values as noted above

														_a     					=    tf_top_k_top_p_filtering(lowerCAmelCase_							,      top_k=10							,      top_p=0.6							,      min_tokens_to_keep=4 )

														_a     					=    output[output != -float('''inf''' )]
														_a     					=    tf.cast(
														    tf.where(tf.not_equal(lowerCAmelCase_							,      tf.constant(-float('''inf''' )							,      dtype=tf.floataa ) ) )							,      dtype=tf.intaa							,      )

														tf.debugging.assert_near(lowerCAmelCase_							,      lowerCAmelCase_							,      rtol=1e-12 )
														tf.debugging.assert_equal(lowerCAmelCase_							,      lowerCAmelCase_ )



@require_tf
class       A   (		unittest.TestCase					,_a   ):
							# setting framework_dependent_parameters needs to be gated, just like its contents' imports
							if is_tf_available():
														lowercase_          =    {
														    'AutoModelForCausalLM': TFAutoModelForCausalLM,
														    'AutoModelForSpeechSeq2Seq': TFAutoModelForSpeechSeqaSeq,
														    'AutoModelForSeq2SeqLM': TFAutoModelForSeqaSeqLM,
														    'AutoModelForVision2Seq': TFAutoModelForVisionaSeq,
														    'LogitsProcessorList': TFLogitsProcessorList,
														    'MinLengthLogitsProcessor': TFMinLengthLogitsProcessor,
														    'create_tensor_fn': tf.convert_to_tensor,
														    'floats_tensor': floats_tensor,
														    'return_tensors': 'tf',
														}







							@slow
							def        __lowerCAmelCase      (  self	:  str )      ->							Optional[Any]:


														"""simple docstring"""


														_a     					=    TFAutoModelForCausalLM.from_pretrained('''hf-internal-testing/tiny-random-gpt2''' )
														_a     					=    2
														_a     					=    2

														class       A   (		tf.Module   ):







																					def __init__(  self	:  List[Any]							,      lowerCAmelCase_	:  Any )      ->							Any:


																												"""simple docstring"""


																												super(lowerCAmelCase_							,      self ).__init__()
																												_a     					=    model







																					@tf.function(
																					    input_signature=(
																					        tf.TensorSpec((None, input_length)							,      tf.intaa							,      name='''input_ids''' ),
																					        tf.TensorSpec((None, input_length)							,      tf.intaa							,      name='''attention_mask''' ),
																					    )							,      jit_compile=lowerCAmelCase_							,      )
																					def        __lowerCAmelCase      (  self	:  str							,      lowerCAmelCase_	:  Any							,      lowerCAmelCase_	:  Optional[int] )      ->							str:


																												"""simple docstring"""


																												_a     					=    self.model.generate(
																												    input_ids=lowerCAmelCase_							,      attention_mask=lowerCAmelCase_							,      max_new_tokens=lowerCAmelCase_							,      return_dict_in_generate=lowerCAmelCase_							,      )
																												return {"sequences": outputs["sequences"]}



														_a     					=    [[2, 0], [1_02, 1_03]]
														_a     					=    [[1, 0], [1, 1]]
														_a     					=    DummyModel(model=lowerCAmelCase_ )
														with tempfile.TemporaryDirectory() as tmp_dir:
																					tf.saved_model.save(lowerCAmelCase_							,      lowerCAmelCase_							,      signatures={'''serving_default''': dummy_model.serving} )
																					_a     					=    tf.saved_model.load(lowerCAmelCase_ ).signatures['''serving_default''']
																					for batch_size in range(1							,      len(lowerCAmelCase_ ) + 1 ):
																												_a     					=    {
																												    '''input_ids''': tf.constant(dummy_input_ids[:batch_size] ),
																												    '''attention_mask''': tf.constant(dummy_attention_masks[:batch_size] ),
																												}
																												_a     					=    serving_func(**lowerCAmelCase_ )['''sequences''']
																												_a     					=    test_model.generate(**lowerCAmelCase_							,      max_new_tokens=lowerCAmelCase_ )
																												tf.debugging.assert_equal(lowerCAmelCase_							,      lowerCAmelCase_ )







							@slow
							def        __lowerCAmelCase      (  self	:  int )      ->							Optional[int]:


														"""simple docstring"""


														_a     					=    TFAutoModelForCausalLM.from_pretrained('''hf-internal-testing/tiny-random-gpt2''' )
														_a     					=    1
														_a     					=    2

														class       A   (		tf.Module   ):







																					def __init__(  self	:  Tuple							,      lowerCAmelCase_	:  List[str] )      ->							str:


																												"""simple docstring"""


																												super(lowerCAmelCase_							,      self ).__init__()
																												_a     					=    model







																					@tf.function(
																					    input_signature=(
																					        tf.TensorSpec((batch_size, None)							,      tf.intaa							,      name='''input_ids''' ),
																					        tf.TensorSpec((batch_size, None)							,      tf.intaa							,      name='''attention_mask''' ),
																					    )							,      jit_compile=lowerCAmelCase_							,      )
																					def        __lowerCAmelCase      (  self	:  Any							,      lowerCAmelCase_	:  Dict							,      lowerCAmelCase_	:  Optional[int] )      ->							Optional[Any]:


																												"""simple docstring"""


																												_a     					=    self.model.generate(
																												    input_ids=lowerCAmelCase_							,      attention_mask=lowerCAmelCase_							,      max_new_tokens=lowerCAmelCase_							,      return_dict_in_generate=lowerCAmelCase_							,      )
																												return {"sequences": outputs["sequences"]}



														_a     					=    [[2], [1_02, 1_03]]
														_a     					=    [[1], [1, 1]]
														_a     					=    DummyModel(model=lowerCAmelCase_ )
														with tempfile.TemporaryDirectory() as tmp_dir:
																					tf.saved_model.save(lowerCAmelCase_							,      lowerCAmelCase_							,      signatures={'''serving_default''': dummy_model.serving} )
																					_a     					=    tf.saved_model.load(lowerCAmelCase_ ).signatures['''serving_default''']
																					for input_row in range(len(lowerCAmelCase_ ) ):
																												_a     					=    {
																												    '''input_ids''': tf.constant([dummy_input_ids[input_row]] ),
																												    '''attention_mask''': tf.constant([dummy_attention_masks[input_row]] ),
																												}
																												_a     					=    serving_func(**lowerCAmelCase_ )['''sequences''']
																												_a     					=    test_model.generate(**lowerCAmelCase_							,      max_new_tokens=lowerCAmelCase_ )
																												tf.debugging.assert_equal(lowerCAmelCase_							,      lowerCAmelCase_ )







							@slow
							@require_tensorflow_text
							def        __lowerCAmelCase      (  self	:  Tuple )      ->							str:


														"""simple docstring"""


														with tempfile.TemporaryDirectory() as tmp_dir:
																					# file needed to load the TF tokenizer
																					hf_hub_download(repo_id='''google/flan-t5-small'''							,      filename='''spiece.model'''							,      local_dir=lowerCAmelCase_ )

																					class       A   (		tf.keras.layers.Layer   ):







																												def __init__(  self	:  Any )      ->							int:


																																			"""simple docstring"""


																																			super().__init__()
																																			_a     					=    text.SentencepieceTokenizer(
																																			    model=tf.io.gfile.GFile(os.path.join(lowerCAmelCase_							,      '''spiece.model''' )							,      '''rb''' ).read() )
																																			_a     					=    TFAutoModelForSeqaSeqLM.from_pretrained('''hf-internal-testing/tiny-random-t5''' )







																												def        __lowerCAmelCase      (  self	:  Any							,      lowerCAmelCase_	:  Any							,      *lowerCAmelCase_	:  str							,      **lowerCAmelCase_	:  List[str] )      ->							List[str]:


																																			"""simple docstring"""


																																			_a     					=    self.tokenizer.tokenize(lowerCAmelCase_ )
																																			_a					,							_a     					=    text.pad_model_inputs(
																																			    lowerCAmelCase_							,      max_seq_length=64							,      pad_value=self.model.config.pad_token_id )
																																			_a     					=    self.model.generate(input_ids=lowerCAmelCase_							,      attention_mask=lowerCAmelCase_ )
																																			return self.tokenizer.detokenize(lowerCAmelCase_ )



																					_a     					=    CompleteSentenceTransformer()
																					_a     					=    tf.keras.layers.Input(shape=(1,)							,      dtype=tf.string							,      name='''inputs''' )
																					_a     					=    complete_model(lowerCAmelCase_ )
																					_a     					=    tf.keras.Model(lowerCAmelCase_							,      lowerCAmelCase_ )
																					keras_model.save(lowerCAmelCase_ )







							def        __lowerCAmelCase      (  self	:  int )      ->							Optional[Any]:


														"""simple docstring"""


														_a     					=    {
														    '''do_sample''': True,
														    '''num_beams''': 1,
														    '''top_p''': 0.7,
														    '''top_k''': 10,
														    '''temperature''': 0.7,
														}
														_a     					=    14

														_a     					=    AutoTokenizer.from_pretrained('''hf-internal-testing/tiny-random-gpt2''' )
														_a     					=    '''Hello, my dog is cute and'''
														_a     					=    tokenizer(lowerCAmelCase_							,      return_tensors='''tf''' )
														_a     					=    TFAutoModelForCausalLM.from_pretrained('''hf-internal-testing/tiny-random-gpt2''' )

														_a     					=    6_38
														# forces the generation to happen on CPU, to avoid GPU-related quirks
														with tf.device(''':/CPU:0''' ):
																					tf.random.set_seed(0 )
																					_a     					=    model.generate(**lowerCAmelCase_							,      eos_token_id=lowerCAmelCase_							,      **lowerCAmelCase_ )
														self.assertTrue(expectation == len(generated_tokens[0] ) )

														_a     					=    [6_38, 1_98]
														with tf.device(''':/CPU:0''' ):
																					tf.random.set_seed(0 )
																					_a     					=    model.generate(**lowerCAmelCase_							,      eos_token_id=lowerCAmelCase_							,      **lowerCAmelCase_ )
														self.assertTrue(expectation == len(generated_tokens[0] ) )







							def        __lowerCAmelCase      (  self	:  Optional[int] )      ->							Union[str, Any]:


														"""simple docstring"""


														_a     					=    AutoTokenizer.from_pretrained('''hf-internal-testing/tiny-random-bart''' )
														_a     					=    '''Hugging Face is a technology company based in New York and Paris.'''
														_a     					=    bart_tokenizer(lowerCAmelCase_							,      return_tensors='''tf''' ).input_ids
														_a     					=    TFBartForConditionalGeneration.from_pretrained('''hf-internal-testing/tiny-random-bart''' )
														_a     					=    bart_model.generate(lowerCAmelCase_ ).numpy()

														class       A   (		_a   ):







																					def        __lowerCAmelCase      (  self	:  int							,      lowerCAmelCase_	:  int							,      lowerCAmelCase_	:  int=None							,      **lowerCAmelCase_	:  Dict )      ->							Optional[Any]:


																												"""simple docstring"""


																												return super().call(lowerCAmelCase_							,      **lowerCAmelCase_ )



														_a     					=    FakeBart.from_pretrained('''hf-internal-testing/tiny-random-bart''' )
														_a     					=    bart_model.generate(lowerCAmelCase_							,      foo='''bar''' ).numpy()
														self.assertTrue(np.array_equal(lowerCAmelCase_							,      lowerCAmelCase_ ) )

														class       A   (		bart_model.model.encoder.__class__   ):







																					def        __lowerCAmelCase      (  self	:  List[str]							,      lowerCAmelCase_	:  Any							,      **lowerCAmelCase_	:  int )      ->							Optional[Any]:


																												"""simple docstring"""


																												return super().call(lowerCAmelCase_							,      **lowerCAmelCase_ )



														_a     					=    FakeEncoder(bart_model.config							,      bart_model.model.shared )
														_a     					=    fake_encoder

														# Normal generation still works (the output will be different because the encoder weights are different)
														_a     					=    bart_model.generate(lowerCAmelCase_ ).numpy()
														with self.assertRaises(lowerCAmelCase_ ):
																					# FakeEncoder.call() accepts **kwargs -> no filtering -> value error due to unexpected input "foo"
																					bart_model.generate(lowerCAmelCase_							,      foo='''bar''' )







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


														"""simple docstring"""


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

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

														_a     					=    None
														_a     					=    decoder_seq_length
														_a     					=    2
														_a     					=    1







							def        __lowerCAmelCase      (  self	:  str )      ->							str:


														"""simple docstring"""


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

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

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

														_a     					=    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        __lowerCAmelCase      (  self	:  List[str]							,      lowerCAmelCase_	:  Any							,      lowerCAmelCase_	:  Dict							,      lowerCAmelCase_	:  Optional[Any]							,      lowerCAmelCase_	:  int							,      )      ->							int:


														"""simple docstring"""


														_a     					=    True
														_a     					=    TrOCRDecoder(config=lowerCAmelCase_ ).to(lowerCAmelCase_ ).eval()
														_a     					=    input_ids[:2]

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

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

														_a     					=    outputs['''past_key_values''']

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

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

														_a     					=    model(lowerCAmelCase_ )['''last_hidden_state''']
														_a     					=    model(lowerCAmelCase_							,      past_key_values=lowerCAmelCase_ )['''last_hidden_state''']

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

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







							def        __lowerCAmelCase      (  self	:  int )      ->							List[str]:


														"""simple docstring"""


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

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



@require_torch
class       A   (		_a					,_a					,_a					,unittest.TestCase   ):
							lowercase_          =    (TrOCRDecoder, TrOCRForCausalLM) if is_torch_available() else ()
							lowercase_          =    (TrOCRForCausalLM,) if is_torch_available() else ()
							lowercase_          =    {'text-generation': TrOCRForCausalLM} if is_torch_available() else {}
							lowercase_          =    True
							lowercase_          =    False







							def        __lowerCAmelCase      (  self	:  List[str] )      ->							str:


														"""simple docstring"""


														_a     					=    TrOCRStandaloneDecoderModelTester(self							,      is_training=lowerCAmelCase_ )
														_a     					=    ConfigTester(self							,      config_class=lowerCAmelCase_ )







							def        __lowerCAmelCase      (  self	:  List[str] )      ->							Any:


														"""simple docstring"""


														pass







							def        __lowerCAmelCase      (  self	:  Tuple )      ->							Dict:


														"""simple docstring"""


														pass







							def        __lowerCAmelCase      (  self	:  Tuple )      ->							Optional[int]:


														"""simple docstring"""


														pass







							def        __lowerCAmelCase      (  self	:  Union[str, Any] )      ->							Optional[int]:


														"""simple docstring"""


														self.config_tester.run_common_tests()







							def        __lowerCAmelCase      (  self	:  Tuple )      ->							Optional[int]:


														"""simple docstring"""


														_a     					=    self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_decoder_model_past(*lowerCAmelCase_ )







							def        __lowerCAmelCase      (  self	:  Optional[int] )      ->							str:


														"""simple docstring"""


														return







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


														"""simple docstring"""


														pass

