


'''simple docstring'''



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




				def __init__(		self      :			Any				,   lowerCAmelCase      :			Union[str, Any]				,   lowerCAmelCase      :			Tuple=13				,   lowerCAmelCase      :			str=7				,   lowerCAmelCase      :			List[str]=True				,   lowerCAmelCase      :			List[Any]=True				,   lowerCAmelCase      :			Optional[Any]=True				,   lowerCAmelCase      :			List[Any]=True				,   lowerCAmelCase      :			List[str]=99				,   lowerCAmelCase      :			Optional[Any]=24				,   lowerCAmelCase      :			Optional[Any]=2				,   lowerCAmelCase      :			int=6				,   lowerCAmelCase      :			Any=37				,   lowerCAmelCase      :			Any="gelu"				,   lowerCAmelCase      :			List[Any]=0.1				,   lowerCAmelCase      :			Optional[int]=0.1				,   lowerCAmelCase      :			Dict=512				,   lowerCAmelCase      :			List[Any]=16				,   lowerCAmelCase      :			List[str]=2				,   lowerCAmelCase      :			List[Any]=0.02				,   lowerCAmelCase      :			List[str]=3				,   lowerCAmelCase      :			Any=None				,   lowerCAmelCase      :			Dict=1000				,   )->					Any:

										"""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      :			int				)->					Union[str, Any]:

										"""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      :			Tuple				)->					str:

										"""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      :			Any				,   lowerCAmelCase      :			Optional[int]				,   lowerCAmelCase      :			List[str]				,   lowerCAmelCase      :			Optional[Any]				,   lowerCAmelCase      :			Optional[int]				,   lowerCAmelCase      :			List[str]				,   lowerCAmelCase      :			int				,   lowerCAmelCase      :			Union[str, Any]				,   )->					Any:

										"""simple docstring"""




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

										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      :			List[Any]				,   lowerCAmelCase      :			Union[str, Any]				,   lowerCAmelCase      :			Tuple				,   lowerCAmelCase      :			Tuple				,   lowerCAmelCase      :			List[Any]				,   lowerCAmelCase      :			Optional[Any]				,   lowerCAmelCase      :			Any				,   lowerCAmelCase      :			Optional[Any]				,   )->					Any:

										"""simple docstring"""




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




				def 					a__(		self      :			Union[str, Any]				,   lowerCAmelCase      :			Any				,   lowerCAmelCase      :			Optional[int]				,   lowerCAmelCase      :			List[Any]				,   lowerCAmelCase      :			List[Any]				,   lowerCAmelCase      :			Optional[Any]				,   lowerCAmelCase      :			int				,   lowerCAmelCase      :			Dict				,   )->					Tuple:

										"""simple docstring"""




										UpperCAmelCase					    =     LiltForQuestionAnswering(config=lowerCAmelCase				)
										model.to(lowerCAmelCase				)
										model.eval()
										UpperCAmelCase					    =     model(
										    lowerCAmelCase				,   bbox=lowerCAmelCase				,   attention_mask=lowerCAmelCase				,   token_type_ids=lowerCAmelCase				,   start_positions=lowerCAmelCase				,   end_positions=lowerCAmelCase				,   )
										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      :			Union[str, Any]				)->					Tuple:

										"""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 	UpperCamelCase__(       lowerCAmelCase						,    lowerCAmelCase						,    lowerCAmelCase						,    unittest.TestCase	):
				__magic_name__    :				Dict  		=	(
				    (
				        LiltModel,
				        LiltForSequenceClassification,
				        LiltForTokenClassification,
				        LiltForQuestionAnswering,
				    )
				    if is_torch_available()
				    else ()
				)
				__magic_name__    :				Optional[Any]  		=	(
				    {
				        "feature-extraction": LiltModel,
				        "question-answering": LiltForQuestionAnswering,
				        "text-classification": LiltForSequenceClassification,
				        "token-classification": LiltForTokenClassification,
				        "zero-shot": LiltForSequenceClassification,
				    }
				    if is_torch_available()
				    else {}
				)
				__magic_name__    :				List[Any]  		=	False
				__magic_name__    :				Optional[int]  		=	False




				def 					a__(		self      :			Dict				,   lowerCAmelCase      :			List[str]				,   lowerCAmelCase      :			Dict				,   lowerCAmelCase      :			Union[str, Any]				,   lowerCAmelCase      :			Union[str, Any]				,   lowerCAmelCase      :			int				)->					Tuple:

										"""simple docstring"""




										return True




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

										"""simple docstring"""




										UpperCAmelCase					    =     LiltModelTester(self				)
										UpperCAmelCase					    =     ConfigTester(self				,   config_class=lowerCAmelCase				,   hidden_size=37				)




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

										"""simple docstring"""




										self.config_tester.run_common_tests()




				def 					a__(		self      :			Any				)->					Any:

										"""simple docstring"""




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




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

										"""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(*lowerCAmelCase				)




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

										"""simple docstring"""




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




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

										"""simple docstring"""




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





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

										"""simple docstring"""




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







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




				def 					a__(		self      :			int				)->					str:

										"""simple docstring"""




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

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

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

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

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









'''simple docstring'''



from dataclasses import dataclass, field
from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Optional, Union

import pyarrow as pa


if TYPE_CHECKING:
	from .features import FeatureType






@dataclass
class 	UpperCamelCase__:
				__magic_name__    :				List[str]
				__magic_name__    :				Optional[str]  		=	None
				# Automatically constructed
				__magic_name__    :				ClassVar[str]  		=	"dict"
				__magic_name__    :				ClassVar[Any]  		=	None
				__magic_name__    :				str  		=	field(default="Translation"						,    init=lowerCAmelCase						,    repr=lowerCAmelCase	)




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

										"""simple docstring"""




										return pa.struct({lang: pa.string() for lang in sorted(self.languages				)}				)





				def 					a__(		self      :			int				)->					Union["FeatureType", Dict[str, "FeatureType"]]:

										"""simple docstring"""




										from .features import Value

										return {k: Value('''string'''				) for k in sorted(self.languages				)}







@dataclass
class 	UpperCamelCase__:
				__magic_name__    :				Optional[List]  		=	None
				__magic_name__    :				Optional[int]  		=	None
				__magic_name__    :				Optional[str]  		=	None
				# Automatically constructed
				__magic_name__    :				ClassVar[str]  		=	"dict"
				__magic_name__    :				ClassVar[Any]  		=	None
				__magic_name__    :				str  		=	field(default="TranslationVariableLanguages"						,    init=lowerCAmelCase						,    repr=lowerCAmelCase	)




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

										"""simple docstring"""




										UpperCAmelCase					    =     sorted(set(self.languages				)				) if self.languages else None
										UpperCAmelCase					    =     len(self.languages				) if self.languages else None




				def __call__(		self      :			int				)->					Optional[Any]:

										"""simple docstring"""




										return pa.struct({'''language''': pa.list_(pa.string()				), '''translation''': pa.list_(pa.string()				)}				)




				def 					a__(		self      :			Optional[int]				,   lowerCAmelCase      :			Dict				)->					Tuple:

										"""simple docstring"""




										UpperCAmelCase					    =     set(self.languages				)
										if self.languages and set(lowerCAmelCase				) - lang_set:
																raise ValueError(
																    F"""Some languages in example ({", ".join(sorted(set(lowerCAmelCase				) - lang_set				)				)}) are not in valid set ({", ".join(lowerCAmelCase				)})."""				)

										# Convert dictionary into tuples, splitting out cases where there are
										# multiple translations for a single language.
										UpperCAmelCase					    =     []
										for lang, text in translation_dict.items():
																if isinstance(lowerCAmelCase				,   lowerCAmelCase				):
																						translation_tuples.append((lang, text)				)
																else:
																						translation_tuples.extend([(lang, el) for el in text]				)

        # Ensure translations are in ascending order by language code.
										UpperCAmelCase    ,    UpperCAmelCase					    =     zip(*sorted(lowerCAmelCase				)				)

										return {"language": languages, "translation": translations}





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

										"""simple docstring"""




										from .features import Sequence, Value

										return {
										    "language": Sequence(Value('''string'''				)				),
										    "translation": Sequence(Value('''string'''				)				),
										}





