

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




							def __init__(   self     :   Optional[int] ,							SCREAMING_SNAKE_CASE_     :   str ,							SCREAMING_SNAKE_CASE_     :   str=13 ,							SCREAMING_SNAKE_CASE_     :   List[Any]=7 ,							SCREAMING_SNAKE_CASE_     :   Any=True ,							SCREAMING_SNAKE_CASE_     :   Optional[int]=True ,							SCREAMING_SNAKE_CASE_     :   int=True ,							SCREAMING_SNAKE_CASE_     :   Any=True ,							SCREAMING_SNAKE_CASE_     :   str=99 ,							SCREAMING_SNAKE_CASE_     :   Optional[Any]=24 ,							SCREAMING_SNAKE_CASE_     :   int=2 ,							SCREAMING_SNAKE_CASE_     :   Optional[Any]=6 ,							SCREAMING_SNAKE_CASE_     :   Optional[int]=37 ,							SCREAMING_SNAKE_CASE_     :   int="gelu" ,							SCREAMING_SNAKE_CASE_     :   Dict=0.1 ,							SCREAMING_SNAKE_CASE_     :   str=0.1 ,							SCREAMING_SNAKE_CASE_     :   str=512 ,							SCREAMING_SNAKE_CASE_     :   int=16 ,							SCREAMING_SNAKE_CASE_     :   Union[str, Any]=2 ,							SCREAMING_SNAKE_CASE_     :   int=0.02 ,							SCREAMING_SNAKE_CASE_     :   str=3 ,							SCREAMING_SNAKE_CASE_     :   Optional[Any]=None ,							SCREAMING_SNAKE_CASE_     :   Optional[Any]=1_000 ,							):
											lowerCAmelCase__      			=						parent
											lowerCAmelCase__      			=						batch_size
											lowerCAmelCase__      			=						seq_length
											lowerCAmelCase__      			=						is_training
											lowerCAmelCase__      			=						use_input_mask
											lowerCAmelCase__      			=						use_token_type_ids
											lowerCAmelCase__      			=						use_labels
											lowerCAmelCase__      			=						vocab_size
											lowerCAmelCase__      			=						hidden_size
											lowerCAmelCase__      			=						num_hidden_layers
											lowerCAmelCase__      			=						num_attention_heads
											lowerCAmelCase__      			=						intermediate_size
											lowerCAmelCase__      			=						hidden_act
											lowerCAmelCase__      			=						hidden_dropout_prob
											lowerCAmelCase__      			=						attention_probs_dropout_prob
											lowerCAmelCase__      			=						max_position_embeddings
											lowerCAmelCase__      			=						type_vocab_size
											lowerCAmelCase__      			=						type_sequence_label_size
											lowerCAmelCase__      			=						initializer_range
											lowerCAmelCase__      			=						num_labels
											lowerCAmelCase__      			=						scope
											lowerCAmelCase__      			=						range_bbox




							def 						__snake_case					(   self     :   List[str]	):
											lowerCAmelCase__      			=						ids_tensor([self.batch_size, self.seq_length] ,							self.vocab_size	)

											lowerCAmelCase__      			=						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]:
																							lowerCAmelCase__      			=						bbox[i, j, 3]
																							lowerCAmelCase__      			=						bbox[i, j, 1]
																							lowerCAmelCase__      			=						t
																			if bbox[i, j, 2] < bbox[i, j, 0]:
																							lowerCAmelCase__      			=						bbox[i, j, 2]
																							lowerCAmelCase__      			=						bbox[i, j, 0]
																							lowerCAmelCase__      			=						t

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

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

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

											lowerCAmelCase__      			=						self.get_config()

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




							def 						__snake_case					(   self     :   Dict	):
											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 						__snake_case					(   self     :   Tuple ,							SCREAMING_SNAKE_CASE_     :   Optional[int] ,							SCREAMING_SNAKE_CASE_     :   List[Any] ,							SCREAMING_SNAKE_CASE_     :   int ,							SCREAMING_SNAKE_CASE_     :   int ,							SCREAMING_SNAKE_CASE_     :   Union[str, Any] ,							SCREAMING_SNAKE_CASE_     :   Any ,							SCREAMING_SNAKE_CASE_     :   str ,							):
											lowerCAmelCase__      			=						LiltModel(config=__lowercase	)
											model.to(__lowercase	)
											model.eval()
											lowerCAmelCase__      			=						model(__lowercase ,							bbox=__lowercase ,							attention_mask=__lowercase ,							token_type_ids=__lowercase	)
											lowerCAmelCase__      			=						model(__lowercase ,							bbox=__lowercase ,							token_type_ids=__lowercase	)
											lowerCAmelCase__      			=						model(__lowercase ,							bbox=__lowercase	)

											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 						__snake_case					(   self     :   Optional[int] ,							SCREAMING_SNAKE_CASE_     :   Dict ,							SCREAMING_SNAKE_CASE_     :   Optional[int] ,							SCREAMING_SNAKE_CASE_     :   List[str] ,							SCREAMING_SNAKE_CASE_     :   Tuple ,							SCREAMING_SNAKE_CASE_     :   List[Any] ,							SCREAMING_SNAKE_CASE_     :   List[str] ,							SCREAMING_SNAKE_CASE_     :   str ,							):
											lowerCAmelCase__      			=						self.num_labels
											lowerCAmelCase__      			=						LiltForTokenClassification(config=__lowercase	)
											model.to(__lowercase	)
											model.eval()
											lowerCAmelCase__      			=						model(
											    __lowercase ,							bbox=__lowercase ,							attention_mask=__lowercase ,							token_type_ids=__lowercase ,							labels=__lowercase	)
											self.parent.assertEqual(result.logits.shape ,							(self.batch_size, self.seq_length, self.num_labels)	)




							def 						__snake_case					(   self     :   Dict ,							SCREAMING_SNAKE_CASE_     :   List[Any] ,							SCREAMING_SNAKE_CASE_     :   Union[str, Any] ,							SCREAMING_SNAKE_CASE_     :   int ,							SCREAMING_SNAKE_CASE_     :   Tuple ,							SCREAMING_SNAKE_CASE_     :   Optional[int] ,							SCREAMING_SNAKE_CASE_     :   Any ,							SCREAMING_SNAKE_CASE_     :   Dict ,							):
											lowerCAmelCase__      			=						LiltForQuestionAnswering(config=__lowercase	)
											model.to(__lowercase	)
											model.eval()
											lowerCAmelCase__      			=						model(
											    __lowercase ,							bbox=__lowercase ,							attention_mask=__lowercase ,							token_type_ids=__lowercase ,							start_positions=__lowercase ,							end_positions=__lowercase ,							)
											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 						__snake_case					(   self     :   Any	):
											lowerCAmelCase__      			=						self.prepare_config_and_inputs()
											(
											    (
											    lowerCAmelCase__       
											)			,		(
											    lowerCAmelCase__       
											)			,		(
											    lowerCAmelCase__       
											)			,		(
											    lowerCAmelCase__       
											)			,		(
											    lowerCAmelCase__       
											)			,		(
											    lowerCAmelCase__       
											)			,		(
											    lowerCAmelCase__       
											)			,		       
											)      			=						config_and_inputs
											lowerCAmelCase__      			=						{
											    '''input_ids''': input_ids,
											    '''bbox''': bbox,
											    '''token_type_ids''': token_type_ids,
											    '''attention_mask''': input_mask,
											}
											return config, inputs_dict



@require_torch
class  lowerCAmelCase_       (				lowercase__     ,    lowercase__     ,    lowercase__     ,    unittest.TestCase					):
							UpperCamelCase_		:str		      =    (
							    (
							        LiltModel,
							        LiltForSequenceClassification,
							        LiltForTokenClassification,
							        LiltForQuestionAnswering,
							    )
							    if is_torch_available()
							    else ()
							)
							UpperCamelCase_		:Optional[int]		      =    (
							    {
							        """feature-extraction""": LiltModel,
							        """question-answering""": LiltForQuestionAnswering,
							        """text-classification""": LiltForSequenceClassification,
							        """token-classification""": LiltForTokenClassification,
							        """zero-shot""": LiltForSequenceClassification,
							    }
							    if is_torch_available()
							    else {}
							)
							UpperCamelCase_		:Any		      =    False
							UpperCamelCase_		:Dict		      =    False




							def 						__snake_case					(   self     :   int ,							SCREAMING_SNAKE_CASE_     :   Optional[Any] ,							SCREAMING_SNAKE_CASE_     :   List[str] ,							SCREAMING_SNAKE_CASE_     :   List[Any] ,							SCREAMING_SNAKE_CASE_     :   int ,							SCREAMING_SNAKE_CASE_     :   str	):
											return True




							def 						__snake_case					(   self     :   List[str]	):
											lowerCAmelCase__      			=						LiltModelTester(self	)
											lowerCAmelCase__      			=						ConfigTester(self ,							config_class=__lowercase ,							hidden_size=37	)




							def 						__snake_case					(   self     :   Optional[int]	):
											self.config_tester.run_common_tests()




							def 						__snake_case					(   self     :   Any	):
											lowerCAmelCase__      			=						self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*__lowercase	)




							def 						__snake_case					(   self     :   str	):
											lowerCAmelCase__      			=						self.model_tester.prepare_config_and_inputs()
											for type in ["absolute", "relative_key", "relative_key_query"]:
															lowerCAmelCase__      			=						type
															self.model_tester.create_and_check_model(*__lowercase	)




							def 						__snake_case					(   self     :   List[Any]	):
											lowerCAmelCase__      			=						self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_token_classification(*__lowercase	)




							def 						__snake_case					(   self     :   Any	):
											lowerCAmelCase__      			=						self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_question_answering(*__lowercase	)




							@slow
							def 						__snake_case					(   self     :   Optional[int]	):
											for model_name in LILT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
															lowerCAmelCase__      			=						LiltModel.from_pretrained(__lowercase	)
															self.assertIsNotNone(__lowercase	)



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




							def 						__snake_case					(   self     :   Optional[Any]	):
											lowerCAmelCase__      			=						LiltModel.from_pretrained('''SCUT-DLVCLab/lilt-roberta-en-base'''	).to(__lowercase	)

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

											# forward pass
											with torch.no_grad():
															lowerCAmelCase__      			=						model(input_ids=__lowercase ,							bbox=__lowercase	)

											lowerCAmelCase__      			=						torch.Size([1, 2, 768]	)
											lowerCAmelCase__      			=						torch.tensor(
											    [[-0.0_653, 0.0_950, -0.0_061], [-0.0_545, 0.0_926, -0.0_324]] ,							device=__lowercase ,							)

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













from .glue import GlueDataset, GlueDataTrainingArguments
from .language_modeling import (
    LineByLineTextDataset,
    LineByLineWithRefDataset,
    LineByLineWithSOPTextDataset,
    TextDataset,
    TextDatasetForNextSentencePrediction,
)
from .squad import SquadDataset, SquadDataTrainingArguments





