




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  :






			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		,					)      ->       Union[str, Any]:
						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    SCREAMING_SNAKE_CASE__    (       self)      ->       List[Any]:
						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    SCREAMING_SNAKE_CASE__    (       self		,					a		,					a		,					a		,					a		,					)      ->       Optional[int]:
						SCREAMING_SNAKE_CASE						= True
						SCREAMING_SNAKE_CASE						= TrOCRDecoder(config=UpperCamelCase_).to(UpperCamelCase_).eval()
						SCREAMING_SNAKE_CASE						= input_ids[:2]

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

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







			def    SCREAMING_SNAKE_CASE__    (       self)      ->       Optional[int]:
						SCREAMING_SNAKE_CASE						= self.prepare_config_and_inputs()
						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  (  A__   ,    A__   ,    A__   ,    unittest.TestCase					):
			_lowercase		:    Dict			     =							(TrOCRDecoder, TrOCRForCausalLM) if is_torch_available() else ()
			_lowercase		:    Dict			     =							(TrOCRForCausalLM,) if is_torch_available() else ()
			_lowercase		:    Union[str, Any]			     =							{'''text-generation''': TrOCRForCausalLM} if is_torch_available() else {}
			_lowercase		:    Any			     =							True
			_lowercase		:    Dict			     =							False






			def    SCREAMING_SNAKE_CASE__    (       self)      ->       Optional[Any]:
						SCREAMING_SNAKE_CASE						= TrOCRStandaloneDecoderModelTester(self		,					is_training=UpperCamelCase_)
						SCREAMING_SNAKE_CASE						= ConfigTester(self		,					config_class=UpperCamelCase_)






			def    SCREAMING_SNAKE_CASE__    (       self)      ->       Optional[int]:
						pass






			def    SCREAMING_SNAKE_CASE__    (       self)      ->       str:
						pass






			def    SCREAMING_SNAKE_CASE__    (       self)      ->       Tuple:
						pass






			def    SCREAMING_SNAKE_CASE__    (       self)      ->       str:
						self.config_tester.run_common_tests()






			def    SCREAMING_SNAKE_CASE__    (       self)      ->       int:
						SCREAMING_SNAKE_CASE						= self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_decoder_model_past(*UpperCamelCase_)






			def    SCREAMING_SNAKE_CASE__    (       self)      ->       Tuple:
						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)      ->       List[Any]:
						pass












from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_sentencepiece_available,
    is_torch_available,
)


a_		:						int             =    {
    'configuration_speecht5': [
        'SPEECHT5_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'SPEECHT5_PRETRAINED_HIFIGAN_CONFIG_ARCHIVE_MAP',
        'SpeechT5Config',
        'SpeechT5HifiGanConfig',
    ],
    'feature_extraction_speecht5': ['SpeechT5FeatureExtractor'],
    'processing_speecht5': ['SpeechT5Processor'],
}

try:
				if not is_sentencepiece_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				a_		:						Optional[Any]             =    ['SpeechT5Tokenizer']

try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				a_		:						Optional[int]             =    [
				    'SPEECHT5_PRETRAINED_MODEL_ARCHIVE_LIST',
				    'SpeechT5ForSpeechToText',
				    'SpeechT5ForSpeechToSpeech',
				    'SpeechT5ForTextToSpeech',
				    'SpeechT5Model',
				    'SpeechT5PreTrainedModel',
				    'SpeechT5HifiGan',
				]

if TYPE_CHECKING:
				from .configuration_speechta import (
				    SPEECHT5_PRETRAINED_CONFIG_ARCHIVE_MAP,
				    SPEECHT5_PRETRAINED_HIFIGAN_CONFIG_ARCHIVE_MAP,
				    SpeechTaConfig,
				    SpeechTaHifiGanConfig,
				)
				from .feature_extraction_speechta import SpeechTaFeatureExtractor
				from .processing_speechta import SpeechTaProcessor

				try:
								if not is_sentencepiece_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .tokenization_speechta import SpeechTaTokenizer

				try:
								if not is_torch_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_speechta import (
								    SPEECHT5_PRETRAINED_MODEL_ARCHIVE_LIST,
								    SpeechTaForSpeechToSpeech,
								    SpeechTaForSpeechToText,
								    SpeechTaForTextToSpeech,
								    SpeechTaHifiGan,
								    SpeechTaModel,
								    SpeechTaPreTrainedModel,
								)

else:
				import sys

				a_		:						Dict             =    _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)




