



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



	'''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				,     )					->  Optional[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       a__						(self )					->  Dict:


						"""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       a__						(self				,     A				,     A				,     A				,     A				,     )					->  List[Any]:


						"""simple docstring"""



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

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

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



	def       a__						(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    (						A     ,     A     ,     A     ,     unittest.TestCase		):



	'''simple docstring'''







	__lowerCamelCase					: Union[str, Any]    = (TrOCRDecoder, TrOCRForCausalLM) if is_torch_available() else ()
	__lowerCamelCase					: Union[str, Any]    = (TrOCRForCausalLM,) if is_torch_available() else ()
	__lowerCamelCase					: Optional[int]    = {'text-generation': TrOCRForCausalLM} if is_torch_available() else {}
	__lowerCamelCase					: Dict    = True
	__lowerCamelCase					: List[Any]    = False



	def       a__						(self )					->  str:


						"""simple docstring"""



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



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


						"""simple docstring"""



						pass



	def       a__						(self )					->  Optional[int]:


						"""simple docstring"""



						pass



	def       a__						(self )					->  Optional[Any]:


						"""simple docstring"""



						pass



	def       a__						(self )					->  Optional[int]:


						"""simple docstring"""



						self.config_tester.run_common_tests()



	def       a__						(self )					->  Union[str, Any]:


						"""simple docstring"""



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



	def       a__						(self )					->  Tuple:


						"""simple docstring"""



						return



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


						"""simple docstring"""



						pass








'''simple docstring'''





from __future__ import annotations

lowercase_	 =						[True] * 1_000_001
lowercase_	 =						2
while i * i <= 1_000_000:
  if seive[i]:
    for j in range(i * i, 1_000_001, i):
      lowercase_	 =						False
  i += 1




def lowerCAmelCase						(__A):



     """simple docstring"""



     return seive[n]




def lowerCAmelCase						(__A):



     """simple docstring"""



     return any(digit in '''02468''' for digit in str(__A))




def lowerCAmelCase						(__A = 1_000_000):



     """simple docstring"""



     _a											=						[2]  # result already includes the number 2.
     for num in range(3						,			limit + 1						,			2):
          if is_prime(__A) and not contains_an_even_digit(__A):
               _a											=						str(__A)
               _a											=						[int(str_num[j:] + str_num[:j]) for j in range(len(__A))]
               if all(is_prime(__A) for i in list_nums):
                    result.append(__A)
     return result




def lowerCAmelCase						():



     """simple docstring"""



     return len(find_circular_primes())


if __name__ == "__main__":
  print(F"""{len(find_circular_primes()) = }""")



