


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 		__a				:
		def __init__(      self      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE=13      ,   _SCREAMING_SNAKE_CASE=7      ,   _SCREAMING_SNAKE_CASE=True      ,   _SCREAMING_SNAKE_CASE=True      ,   _SCREAMING_SNAKE_CASE=True      ,   _SCREAMING_SNAKE_CASE=True      ,   _SCREAMING_SNAKE_CASE=99      ,   _SCREAMING_SNAKE_CASE=24      ,   _SCREAMING_SNAKE_CASE=2      ,   _SCREAMING_SNAKE_CASE=6      ,   _SCREAMING_SNAKE_CASE=37      ,   _SCREAMING_SNAKE_CASE="gelu"      ,   _SCREAMING_SNAKE_CASE=0.1      ,   _SCREAMING_SNAKE_CASE=0.1      ,   _SCREAMING_SNAKE_CASE=512      ,   _SCREAMING_SNAKE_CASE=16      ,   _SCREAMING_SNAKE_CASE=2      ,   _SCREAMING_SNAKE_CASE=0.02      ,   _SCREAMING_SNAKE_CASE=3      ,   _SCREAMING_SNAKE_CASE=None      ,   _SCREAMING_SNAKE_CASE=1000      ,   )			->	List[str]:




									"""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      UpperCAmelCase__    (      self						)			->	int:




									"""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      UpperCAmelCase__    (      self						)			->	Tuple:




									"""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      UpperCAmelCase__    (      self      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   )			->	Tuple:




									"""simple docstring"""





									_UpperCAmelCase					=      LiltModel(config=_SCREAMING_SNAKE_CASE						)
									model.to(_SCREAMING_SNAKE_CASE						)
									model.eval()
									_UpperCAmelCase					=      model(_SCREAMING_SNAKE_CASE      ,   bbox=_SCREAMING_SNAKE_CASE      ,   attention_mask=_SCREAMING_SNAKE_CASE      ,   token_type_ids=_SCREAMING_SNAKE_CASE						)
									_UpperCAmelCase					=      model(_SCREAMING_SNAKE_CASE      ,   bbox=_SCREAMING_SNAKE_CASE      ,   token_type_ids=_SCREAMING_SNAKE_CASE						)
									_UpperCAmelCase					=      model(_SCREAMING_SNAKE_CASE      ,   bbox=_SCREAMING_SNAKE_CASE						)

									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      UpperCAmelCase__    (      self      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   )			->	Optional[Any]:




									"""simple docstring"""





									_UpperCAmelCase					=      self.num_labels
									_UpperCAmelCase					=      LiltForTokenClassification(config=_SCREAMING_SNAKE_CASE						)
									model.to(_SCREAMING_SNAKE_CASE						)
									model.eval()
									_UpperCAmelCase					=      model(
									    _SCREAMING_SNAKE_CASE      ,   bbox=_SCREAMING_SNAKE_CASE      ,   attention_mask=_SCREAMING_SNAKE_CASE      ,   token_type_ids=_SCREAMING_SNAKE_CASE      ,   labels=_SCREAMING_SNAKE_CASE						)
									self.parent.assertEqual(result.logits.shape      ,   (self.batch_size, self.seq_length, self.num_labels)						)
		def      UpperCAmelCase__    (      self      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   )			->	Optional[Any]:




									"""simple docstring"""





									_UpperCAmelCase					=      LiltForQuestionAnswering(config=_SCREAMING_SNAKE_CASE						)
									model.to(_SCREAMING_SNAKE_CASE						)
									model.eval()
									_UpperCAmelCase					=      model(
									    _SCREAMING_SNAKE_CASE      ,   bbox=_SCREAMING_SNAKE_CASE      ,   attention_mask=_SCREAMING_SNAKE_CASE      ,   token_type_ids=_SCREAMING_SNAKE_CASE      ,   start_positions=_SCREAMING_SNAKE_CASE      ,   end_positions=_SCREAMING_SNAKE_CASE      ,   )
									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      UpperCAmelCase__    (      self						)			->	Any:




									"""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 		__a				(    UpperCAmelCase   ,				UpperCAmelCase   ,				UpperCAmelCase   ,				unittest.TestCase      ):
		_a     :  Union[str, Any]           =     (
		    (
		        LiltModel,
		        LiltForSequenceClassification,
		        LiltForTokenClassification,
		        LiltForQuestionAnswering,
		    )
		    if is_torch_available()
		    else ()
		)
		_a     :  int           =     (
		    {
		        'feature-extraction': LiltModel,
		        'question-answering': LiltForQuestionAnswering,
		        'text-classification': LiltForSequenceClassification,
		        'token-classification': LiltForTokenClassification,
		        'zero-shot': LiltForSequenceClassification,
		    }
		    if is_torch_available()
		    else {}
		)
		_a     :  List[str]           =     False
		_a     :  Optional[Any]           =     False
		def      UpperCAmelCase__    (      self      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE						)			->	Optional[int]:




									"""simple docstring"""





									return True
		def      UpperCAmelCase__    (      self						)			->	Optional[Any]:




									"""simple docstring"""





									_UpperCAmelCase					=      LiltModelTester(self						)
									_UpperCAmelCase					=      ConfigTester(self      ,   config_class=_SCREAMING_SNAKE_CASE      ,   hidden_size=37						)
		def      UpperCAmelCase__    (      self						)			->	int:




									"""simple docstring"""





									self.config_tester.run_common_tests()
		def      UpperCAmelCase__    (      self						)			->	List[str]:




									"""simple docstring"""





									_UpperCAmelCase					=      self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*_SCREAMING_SNAKE_CASE						)
		def      UpperCAmelCase__    (      self						)			->	List[str]:




									"""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(*_SCREAMING_SNAKE_CASE						)
		def      UpperCAmelCase__    (      self						)			->	int:




									"""simple docstring"""





									_UpperCAmelCase					=      self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_token_classification(*_SCREAMING_SNAKE_CASE						)
		def      UpperCAmelCase__    (      self						)			->	Any:




									"""simple docstring"""





									_UpperCAmelCase					=      self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_question_answering(*_SCREAMING_SNAKE_CASE						)






		@slow
		def      UpperCAmelCase__    (      self						)			->	int:




									"""simple docstring"""





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



@require_torch
@slow
class 		__a				(    unittest.TestCase      ):
		def      UpperCAmelCase__    (      self						)			->	int:




									"""simple docstring"""





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

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

									# forward pass
									with torch.no_grad():
																_UpperCAmelCase					=      model(input_ids=_SCREAMING_SNAKE_CASE      ,   bbox=_SCREAMING_SNAKE_CASE						)

									_UpperCAmelCase					=      torch.Size([1, 2, 768]						)
									_UpperCAmelCase					=      torch.tensor(
									    [[-0.0653, 0.0950, -0.0061], [-0.0545, 0.0926, -0.0324]]      ,   device=_SCREAMING_SNAKE_CASE      ,   )

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




from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


lowerCAmelCase__  :List[str]             =							{
    '''configuration_x_clip''': [
        '''XCLIP_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''XCLIPConfig''',
        '''XCLIPTextConfig''',
        '''XCLIPVisionConfig''',
    ],
    '''processing_x_clip''': ['''XCLIPProcessor'''],
}

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		lowerCAmelCase__  :Any             =							[
		    '''XCLIP_PRETRAINED_MODEL_ARCHIVE_LIST''',
		    '''XCLIPModel''',
		    '''XCLIPPreTrainedModel''',
		    '''XCLIPTextModel''',
		    '''XCLIPVisionModel''',
		]

if TYPE_CHECKING:
		from .configuration_x_clip import (
		    XCLIP_PRETRAINED_CONFIG_ARCHIVE_MAP,
		    XCLIPConfig,
		    XCLIPTextConfig,
		    XCLIPVisionConfig,
		)
		from .processing_x_clip import XCLIPProcessor

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_x_clip import (
				    XCLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
				    XCLIPModel,
				    XCLIPPreTrainedModel,
				    XCLIPTextModel,
				    XCLIPVisionModel,
				)

else:
		import sys

		lowerCAmelCase__  :str             =							_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
