

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__						:
		"""simple docstring"""







		def __init__(    self      ,      lowercase      ,      lowercase=99      ,      lowercase=13      ,      lowercase=16      ,      lowercase=7      ,      lowercase=True      ,      lowercase=True      ,      lowercase=True      ,      lowercase=False      ,      lowercase=True      ,      lowercase=2      ,      lowercase=32      ,      lowercase=4      ,      lowercase=4      ,      lowercase=30      ,      lowercase=0      ,      lowercase=1      ,      lowercase=2      ,      lowercase=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      UpperCamelCase		(    self       )  ->						List[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      UpperCamelCase		(    self      ,      lowercase      ,      lowercase      ,      lowercase      ,      lowercase      ,      )  ->						List[str]:
						'''simple docstring'''






						A__        =			True
						A__        =			TrOCRDecoder(config=lowercase       ).to(lowercase       ).eval()
						A__        =			input_ids[:2]

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

						self.parent.assertTrue(len(lowercase       ) == len(lowercase       )       )
						self.parent.assertTrue(len(lowercase       ) == len(lowercase       ) + 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(lowercase       )["last_hidden_state"]
						A__        =			model(lowercase      ,      past_key_values=lowercase       )["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(lowercase      ,      lowercase      ,      atol=1e-3       )


		def      UpperCamelCase		(    self       )  ->						int:
						'''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__						(					snake_case							,	snake_case							,	snake_case							,	unittest.TestCase			):
		"""simple docstring"""







		__lowerCamelCase        =       (TrOCRDecoder, TrOCRForCausalLM) if is_torch_available() else ()
		__lowerCamelCase        =       (TrOCRForCausalLM,) if is_torch_available() else ()
		__lowerCamelCase        =       {'text-generation': TrOCRForCausalLM} if is_torch_available() else {}
		__lowerCamelCase        =       True
		__lowerCamelCase        =       False


		def      UpperCamelCase		(    self       )  ->						Optional[Any]:
						'''simple docstring'''






						A__        =			TrOCRStandaloneDecoderModelTester(self      ,      is_training=lowercase       )
						A__        =			ConfigTester(self      ,      config_class=lowercase       )


		def      UpperCamelCase		(    self       )  ->						List[Any]:
						'''simple docstring'''






						pass


		def      UpperCamelCase		(    self       )  ->						Dict:
						'''simple docstring'''






						pass


		def      UpperCamelCase		(    self       )  ->						Union[str, Any]:
						'''simple docstring'''






						pass


		def      UpperCamelCase		(    self       )  ->						str:
						'''simple docstring'''






						self.config_tester.run_common_tests()


		def      UpperCamelCase		(    self       )  ->						Optional[Any]:
						'''simple docstring'''






						A__        =			self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_decoder_model_past(*lowercase       )


		def      UpperCamelCase		(    self       )  ->						Union[str, Any]:
						'''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       )  ->						Optional[int]:
						'''simple docstring'''






						pass




def 					lowerCAmelCase__							(	SCREAMING_SNAKE_CASE_:							int      )			->      int:




				'''simple docstring'''





				if divisor % 5 == 0 or divisor % 2 == 0:
								return 0
				A__        =			1
				A__        =			1
				while repunit:
								A__        =			(1_0 * repunit + 1) % divisor
								repunit_index += 1
				return repunit_index



def 					lowerCAmelCase__							(	SCREAMING_SNAKE_CASE_:							int = 1_0_0_0_0_0_0      )			->      int:




				'''simple docstring'''





				A__        =			limit - 1
				if divisor % 2 == 0:
								divisor += 1
				while least_divisible_repunit(SCREAMING_SNAKE_CASE_      ) <= limit:
								divisor += 2
				return divisor


if __name__ == "__main__":
	print(f"""{solution() = }""")

