



import unittest

from transformers import LiltConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, 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 import (
           LiltForQuestionAnswering,
           LiltForSequenceClassification,
           LiltForTokenClassification,
           LiltModel,
       )
       from transformers.models.lilt.modeling_lilt import LILT_PRETRAINED_MODEL_ARCHIVE_LIST



class        _SCREAMING_SNAKE_CASE		:





   def __init__(self    ,  UpperCAmelCase    ,  UpperCAmelCase=1_3    ,  UpperCAmelCase=7    ,  UpperCAmelCase=True    ,  UpperCAmelCase=True    ,  UpperCAmelCase=True    ,  UpperCAmelCase=True    ,  UpperCAmelCase=9_9    ,  UpperCAmelCase=2_4    ,  UpperCAmelCase=2    ,  UpperCAmelCase=6    ,  UpperCAmelCase=3_7    ,  UpperCAmelCase="gelu"    ,  UpperCAmelCase=0.1    ,  UpperCAmelCase=0.1    ,  UpperCAmelCase=5_1_2    ,  UpperCAmelCase=1_6    ,  UpperCAmelCase=2    ,  UpperCAmelCase=0.02    ,  UpperCAmelCase=3    ,  UpperCAmelCase=None    ,  UpperCAmelCase=1_0_0_0    ,  ):
       '''simple docstring'''







       __UpperCAmelCase			 =parent
       __UpperCAmelCase			 =batch_size
       __UpperCAmelCase			 =seq_length
       __UpperCAmelCase			 =is_training
       __UpperCAmelCase			 =use_input_mask
       __UpperCAmelCase			 =use_token_type_ids
       __UpperCAmelCase			 =use_labels
       __UpperCAmelCase			 =vocab_size
       __UpperCAmelCase			 =hidden_size
       __UpperCAmelCase			 =num_hidden_layers
       __UpperCAmelCase			 =num_attention_heads
       __UpperCAmelCase			 =intermediate_size
       __UpperCAmelCase			 =hidden_act
       __UpperCAmelCase			 =hidden_dropout_prob
       __UpperCAmelCase			 =attention_probs_dropout_prob
       __UpperCAmelCase			 =max_position_embeddings
       __UpperCAmelCase			 =type_vocab_size
       __UpperCAmelCase			 =type_sequence_label_size
       __UpperCAmelCase			 =initializer_range
       __UpperCAmelCase			 =num_labels
       __UpperCAmelCase			 =scope
       __UpperCAmelCase			 =range_bbox





   def 	A__      (self):
       '''simple docstring'''







       __UpperCAmelCase			 =ids_tensor([self.batch_size, self.seq_length]    ,  self.vocab_size)

       __UpperCAmelCase			 =ids_tensor([self.batch_size, self.seq_length, 4]    ,  self.range_bbox)
       # Ensure that bbox is legal
       for i in range(bbox.shape[0]):
           for j in range(bbox.shape[1]):
               if bbox[i, j, 3] < bbox[i, j, 1]:
                   __UpperCAmelCase			 =bbox[i, j, 3]
                   __UpperCAmelCase			 =bbox[i, j, 1]
                   __UpperCAmelCase			 =t
               if bbox[i, j, 2] < bbox[i, j, 0]:
                   __UpperCAmelCase			 =bbox[i, j, 2]
                   __UpperCAmelCase			 =bbox[i, j, 0]
                   __UpperCAmelCase			 =t

       __UpperCAmelCase			 =None
       if self.use_input_mask:
           __UpperCAmelCase			 =ids_tensor([self.batch_size, self.seq_length]    ,  vocab_size=2)

       __UpperCAmelCase			 =None
       if self.use_token_type_ids:
           __UpperCAmelCase			 =ids_tensor([self.batch_size, self.seq_length]    ,  self.type_vocab_size)

       __UpperCAmelCase			 =None
       __UpperCAmelCase			 =None
       if self.use_labels:
           __UpperCAmelCase			 =ids_tensor([self.batch_size]    ,  self.type_sequence_label_size)
           __UpperCAmelCase			 =ids_tensor([self.batch_size, self.seq_length]    ,  self.num_labels)

       __UpperCAmelCase			 =self.get_config()

       return config, input_ids, bbox, token_type_ids, input_mask, sequence_labels, token_labels





   def 	A__      (self):
       '''simple docstring'''







       return LiltConfig(
           vocab_size=self.vocab_size    ,  hidden_size=self.hidden_size    ,  num_hidden_layers=self.num_hidden_layers    ,  num_attention_heads=self.num_attention_heads    ,  intermediate_size=self.intermediate_size    ,  hidden_act=self.hidden_act    ,  hidden_dropout_prob=self.hidden_dropout_prob    ,  attention_probs_dropout_prob=self.attention_probs_dropout_prob    ,  max_position_embeddings=self.max_position_embeddings    ,  type_vocab_size=self.type_vocab_size    ,  initializer_range=self.initializer_range    ,  )





   def 	A__      (self    ,  UpperCAmelCase    ,  UpperCAmelCase    ,  UpperCAmelCase    ,  UpperCAmelCase    ,  UpperCAmelCase    ,  UpperCAmelCase    ,  UpperCAmelCase    ,  ):
       '''simple docstring'''







       __UpperCAmelCase			 =LiltModel(config=UpperCAmelCase)
       model.to(UpperCAmelCase)
       model.eval()
       __UpperCAmelCase			 =model(UpperCAmelCase    ,  bbox=UpperCAmelCase    ,  attention_mask=UpperCAmelCase    ,  token_type_ids=UpperCAmelCase)
       __UpperCAmelCase			 =model(UpperCAmelCase    ,  bbox=UpperCAmelCase    ,  token_type_ids=UpperCAmelCase)
       __UpperCAmelCase			 =model(UpperCAmelCase    ,  bbox=UpperCAmelCase)

       self.parent.assertEqual(result.last_hidden_state.shape    ,  (self.batch_size, self.seq_length, self.hidden_size))
       self.parent.assertEqual(result.pooler_output.shape    ,  (self.batch_size, self.hidden_size))





   def 	A__      (self    ,  UpperCAmelCase    ,  UpperCAmelCase    ,  UpperCAmelCase    ,  UpperCAmelCase    ,  UpperCAmelCase    ,  UpperCAmelCase    ,  UpperCAmelCase    ,  ):
       '''simple docstring'''







       __UpperCAmelCase			 =self.num_labels
       __UpperCAmelCase			 =LiltForTokenClassification(config=UpperCAmelCase)
       model.to(UpperCAmelCase)
       model.eval()
       __UpperCAmelCase			 =model(
           UpperCAmelCase    ,  bbox=UpperCAmelCase    ,  attention_mask=UpperCAmelCase    ,  token_type_ids=UpperCAmelCase    ,  labels=UpperCAmelCase)
       self.parent.assertEqual(result.logits.shape    ,  (self.batch_size, self.seq_length, self.num_labels))





   def 	A__      (self    ,  UpperCAmelCase    ,  UpperCAmelCase    ,  UpperCAmelCase    ,  UpperCAmelCase    ,  UpperCAmelCase    ,  UpperCAmelCase    ,  UpperCAmelCase    ,  ):
       '''simple docstring'''







       __UpperCAmelCase			 =LiltForQuestionAnswering(config=UpperCAmelCase)
       model.to(UpperCAmelCase)
       model.eval()
       __UpperCAmelCase			 =model(
           UpperCAmelCase    ,  bbox=UpperCAmelCase    ,  attention_mask=UpperCAmelCase    ,  token_type_ids=UpperCAmelCase    ,  start_positions=UpperCAmelCase    ,  end_positions=UpperCAmelCase    ,  )
       self.parent.assertEqual(result.start_logits.shape    ,  (self.batch_size, self.seq_length))
       self.parent.assertEqual(result.end_logits.shape    ,  (self.batch_size, self.seq_length))






   def 	A__      (self):
       '''simple docstring'''







       __UpperCAmelCase			 =self.prepare_config_and_inputs()
       (
           (
           __UpperCAmelCase      
       ) , (
           __UpperCAmelCase      
       ) , (
           __UpperCAmelCase      
       ) , (
           __UpperCAmelCase      
       ) , (
           __UpperCAmelCase      
       ) , (
           __UpperCAmelCase      
       ) , (
           __UpperCAmelCase      
       ) ,       
       )			 =config_and_inputs
       __UpperCAmelCase			 ={
           '''input_ids''': input_ids,
           '''bbox''': bbox,
           '''token_type_ids''': token_type_ids,
           '''attention_mask''': input_mask,
       }
       return config, inputs_dict







@require_torch
class        _SCREAMING_SNAKE_CASE		(       _lowerCAmelCase			,			_lowerCAmelCase			,			_lowerCAmelCase			,			unittest.TestCase ):
   a_							:      int						= (
       (
           LiltModel,
           LiltForSequenceClassification,
           LiltForTokenClassification,
           LiltForQuestionAnswering,
       )
       if is_torch_available()
       else ()
   )
   a_							:      Dict						= (
       {
           '''feature-extraction''': LiltModel,
           '''question-answering''': LiltForQuestionAnswering,
           '''text-classification''': LiltForSequenceClassification,
           '''token-classification''': LiltForTokenClassification,
           '''zero-shot''': LiltForSequenceClassification,
       }
       if is_torch_available()
       else {}
   )
   a_							:      str						= False
   a_							:      int						= False





   def 	A__      (self    ,  UpperCAmelCase    ,  UpperCAmelCase    ,  UpperCAmelCase    ,  UpperCAmelCase    ,  UpperCAmelCase):
       '''simple docstring'''







       return True





   def 	A__      (self):
       '''simple docstring'''







       __UpperCAmelCase			 =LiltModelTester(self)
       __UpperCAmelCase			 =ConfigTester(self    ,  config_class=UpperCAmelCase    ,  hidden_size=3_7)





   def 	A__      (self):
       '''simple docstring'''







       self.config_tester.run_common_tests()





   def 	A__      (self):
       '''simple docstring'''







       __UpperCAmelCase			 =self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*UpperCAmelCase)





   def 	A__      (self):
       '''simple docstring'''







       __UpperCAmelCase			 =self.model_tester.prepare_config_and_inputs()
       for type in ["absolute", "relative_key", "relative_key_query"]:
           __UpperCAmelCase			 =type
           self.model_tester.create_and_check_model(*UpperCAmelCase)





   def 	A__      (self):
       '''simple docstring'''







       __UpperCAmelCase			 =self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_token_classification(*UpperCAmelCase)





   def 	A__      (self):
       '''simple docstring'''







       __UpperCAmelCase			 =self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_question_answering(*UpperCAmelCase)






   @slow
   def 	A__      (self):
       '''simple docstring'''







       for model_name in LILT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           __UpperCAmelCase			 =LiltModel.from_pretrained(UpperCAmelCase)
           self.assertIsNotNone(UpperCAmelCase)







@require_torch
@slow
class        _SCREAMING_SNAKE_CASE		(       unittest.TestCase ):





   def 	A__      (self):
       '''simple docstring'''







       __UpperCAmelCase			 =LiltModel.from_pretrained('''SCUT-DLVCLab/lilt-roberta-en-base''').to(UpperCAmelCase)

       __UpperCAmelCase			 =torch.tensor([[1, 2]]    ,  device=UpperCAmelCase)
       __UpperCAmelCase			 =torch.tensor([[[1, 2, 3, 4], [5, 6, 7, 8]]]    ,  device=UpperCAmelCase)

       # forward pass
       with torch.no_grad():
           __UpperCAmelCase			 =model(input_ids=UpperCAmelCase    ,  bbox=UpperCAmelCase)

       __UpperCAmelCase			 =torch.Size([1, 2, 7_6_8])
       __UpperCAmelCase			 =torch.tensor(
           [[-0.0653, 0.0950, -0.0061], [-0.0545, 0.0926, -0.0324]]    ,  device=UpperCAmelCase    ,  )

       self.assertTrue(outputs.last_hidden_state.shape    ,  UpperCAmelCase)
       self.assertTrue(torch.allclose(outputs.last_hidden_state[0, :, :3]    ,  UpperCAmelCase    ,  atol=1e-3))











'''simple docstring'''



from math import isqrt



def  __UpperCAmelCase						(					SCREAMING_SNAKE_CASE__:						int     )	->      bool:

   """simple docstring"""
   return all(number % divisor != 0 for divisor in range(2,       isqrt(SCREAMING_SNAKE_CASE__     ) + 1     )     )



def  __UpperCAmelCase						(					SCREAMING_SNAKE_CASE__:						int = 10**6     )	->      int:

   """simple docstring"""
   __a					  =     0
   __a					  =     1
   __a					  =     7
   while prime_candidate < max_prime:
      primes_count += is_prime(SCREAMING_SNAKE_CASE__     )

      cube_index += 1
      prime_candidate += 6 * cube_index

   return primes_count


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