

'''simple docstring'''
import tempfile
import unittest

from transformers import SPIECE_UNDERLINE, BatchEncoding, PLBartTokenizer, is_torch_available
from transformers.testing_utils import (
    get_tests_dir,
    nested_simplify,
    require_sentencepiece,
    require_tokenizers,
    require_torch,
)

from ...test_tokenization_common import TokenizerTesterMixin


_lowerCamelCase      					=     get_tests_dir("""fixtures/test_sentencepiece.model""")


if is_torch_available():
					from transformers.models.plbart.modeling_plbart import shift_tokens_right

_lowerCamelCase      					=     5_0003
_lowerCamelCase      					=     5_0002
@require_sentencepiece
@require_tokenizers
class 					_snake_case		(__SCREAMING_SNAKE_CASE			,			unittest.TestCase):
			__A  :	Dict        =PLBartTokenizer
			__A  :	List[Any]        =None
			__A  :	Union[str, Any]        =False






			def 		UpperCamelCase__							(  self     ):
				super().setUp()

				# We have a SentencePiece fixture for testing
				UpperCAmelCase_     :      Any						=  PLBartTokenizer(_snake_case			,language_codes="base"			,keep_accents=_snake_case     )
				tokenizer.save_pretrained(self.tmpdirname     )






			def 		UpperCamelCase__							(  self     ):
				UpperCAmelCase_     :      List[Any]						=  PLBartTokenizer(_snake_case			,language_codes="base"			,keep_accents=_snake_case     )

				UpperCAmelCase_     :      Optional[Any]						=  tokenizer.tokenize("This is a test"     )
				self.assertListEqual(_snake_case			,["▁This", "▁is", "▁a", "▁t", "est"]     )

				self.assertListEqual(
				    tokenizer.convert_tokens_to_ids(_snake_case     )			,[value + tokenizer.fairseq_offset for value in [2_85, 46, 10, 1_70, 3_82]]			,)

				UpperCAmelCase_     :      Optional[Any]						=  tokenizer.tokenize("I was born in 92000, and this is falsé."     )
				self.assertListEqual(
				    _snake_case			,[
				        SPIECE_UNDERLINE + "I",
				        SPIECE_UNDERLINE + "was",
				        SPIECE_UNDERLINE + "b",
				        "or",
				        "n",
				        SPIECE_UNDERLINE + "in",
				        SPIECE_UNDERLINE + "",
				        "9",
				        "2",
				        "0",
				        "0",
				        "0",
				        ",",
				        SPIECE_UNDERLINE + "and",
				        SPIECE_UNDERLINE + "this",
				        SPIECE_UNDERLINE + "is",
				        SPIECE_UNDERLINE + "f",
				        "al",
				        "s",
				        "é",
				        ".",
				    ]			,)
				UpperCAmelCase_     :      Tuple						=  tokenizer.convert_tokens_to_ids(_snake_case     )
				self.assertListEqual(
				    _snake_case			,[
				        value + tokenizer.fairseq_offset
				        for value in [8, 21, 84, 55, 24, 19, 7, 2, 6_02, 3_47, 3_47, 3_47, 3, 12, 66, 46, 72, 80, 6, 2, 4]
				    ]			,)

				UpperCAmelCase_     :      Optional[Any]						=  tokenizer.convert_ids_to_tokens(_snake_case     )
				self.assertListEqual(
				    _snake_case			,[
				        SPIECE_UNDERLINE + "I",
				        SPIECE_UNDERLINE + "was",
				        SPIECE_UNDERLINE + "b",
				        "or",
				        "n",
				        SPIECE_UNDERLINE + "in",
				        SPIECE_UNDERLINE + "",
				        "<unk>",
				        "2",
				        "0",
				        "0",
				        "0",
				        ",",
				        SPIECE_UNDERLINE + "and",
				        SPIECE_UNDERLINE + "this",
				        SPIECE_UNDERLINE + "is",
				        SPIECE_UNDERLINE + "f",
				        "al",
				        "s",
				        "<unk>",
				        ".",
				    ]			,)

				UpperCAmelCase_     :      Any						=  tokenizer.vocab_size
				UpperCAmelCase_     :      int						=  [tokenizer.convert_ids_to_tokens(_snake_case     ) for x in range(end - 4			,_snake_case     )]

				self.assertListEqual(_snake_case			,["__java__", "__python__", "__en_XX__", "<mask>"]     )

				UpperCAmelCase_     :      Dict						=  "java.lang.Exception, python.lang.Exception, javascript, php, ruby, go"
				UpperCAmelCase_     :      List[Any]						=  tokenizer(_snake_case     ).input_ids
				self.assertEqual(
				    tokenizer.decode(_snake_case			,skip_special_tokens=_snake_case			,clean_up_tokenization_spaces=_snake_case     )			,_snake_case			,)






			def 		UpperCamelCase__							(  self     ):
				UpperCAmelCase_     :      int						=  PLBartTokenizer(_snake_case			,language_codes="multi"			,keep_accents=_snake_case     )

				UpperCAmelCase_     :      List[Any]						=  tokenizer.tokenize("This is a test"     )
				self.assertListEqual(_snake_case			,["▁This", "▁is", "▁a", "▁t", "est"]     )

				self.assertListEqual(
				    tokenizer.convert_tokens_to_ids(_snake_case     )			,[value + tokenizer.fairseq_offset for value in [2_85, 46, 10, 1_70, 3_82]]			,)

				UpperCAmelCase_     :      Optional[int]						=  tokenizer.tokenize("I was born in 92000, and this is falsé."     )
				self.assertListEqual(
				    _snake_case			,[
				        SPIECE_UNDERLINE + "I",
				        SPIECE_UNDERLINE + "was",
				        SPIECE_UNDERLINE + "b",
				        "or",
				        "n",
				        SPIECE_UNDERLINE + "in",
				        SPIECE_UNDERLINE + "",
				        "9",
				        "2",
				        "0",
				        "0",
				        "0",
				        ",",
				        SPIECE_UNDERLINE + "and",
				        SPIECE_UNDERLINE + "this",
				        SPIECE_UNDERLINE + "is",
				        SPIECE_UNDERLINE + "f",
				        "al",
				        "s",
				        "é",
				        ".",
				    ]			,)
				UpperCAmelCase_     :      Any						=  tokenizer.convert_tokens_to_ids(_snake_case     )
				self.assertListEqual(
				    _snake_case			,[
				        value + tokenizer.fairseq_offset
				        for value in [8, 21, 84, 55, 24, 19, 7, 2, 6_02, 3_47, 3_47, 3_47, 3, 12, 66, 46, 72, 80, 6, 2, 4]
				    ]			,)

				UpperCAmelCase_     :      Union[str, Any]						=  tokenizer.convert_ids_to_tokens(_snake_case     )
				self.assertListEqual(
				    _snake_case			,[
				        SPIECE_UNDERLINE + "I",
				        SPIECE_UNDERLINE + "was",
				        SPIECE_UNDERLINE + "b",
				        "or",
				        "n",
				        SPIECE_UNDERLINE + "in",
				        SPIECE_UNDERLINE + "",
				        "<unk>",
				        "2",
				        "0",
				        "0",
				        "0",
				        ",",
				        SPIECE_UNDERLINE + "and",
				        SPIECE_UNDERLINE + "this",
				        SPIECE_UNDERLINE + "is",
				        SPIECE_UNDERLINE + "f",
				        "al",
				        "s",
				        "<unk>",
				        ".",
				    ]			,)
				UpperCAmelCase_     :      List[Any]						=  tokenizer.vocab_size
				UpperCAmelCase_     :      List[str]						=  [tokenizer.convert_ids_to_tokens(_snake_case     ) for x in range(end - 7			,_snake_case     )]

				self.assertListEqual(
				    _snake_case			,["__java__", "__python__", "__en_XX__", "__javascript__", "__php__", "__ruby__", "__go__"]     )
				UpperCAmelCase_     :      Tuple						=  "java.lang.Exception, python.lang.Exception, javascript, php, ruby, go"
				UpperCAmelCase_     :      str						=  tokenizer(_snake_case     ).input_ids
				self.assertEqual(
				    tokenizer.decode(_snake_case			,skip_special_tokens=_snake_case			,clean_up_tokenization_spaces=_snake_case     )			,_snake_case			,)




@require_torch
@require_sentencepiece
@require_tokenizers
class 					_snake_case		(unittest.TestCase):
			__A  :	Optional[Any]        ="uclanlp/plbart-python-en_XX"
			__A  :	Any        =[
			    "def maximum(a,b,c):NEW_LINE_INDENTreturn max([a,b,c])",
			    "def sum(a,b,c):NEW_LINE_INDENTreturn sum([a,b,c])",
			]
			__A  :	Optional[int]        =[
			    "Returns the maximum value of a b c.",
			    "Sums the values of a b c.",
			]
			__A  :	List[str]        =[
			    1_34,
			    54_52,
			    3_34_60,
			    3_34_41,
			    3_34_63,
			    3_34_65,
			    3_34_63,
			    3_34_49,
			    9_88,
			    20,
			    3_34_56,
			    19,
			    3_34_56,
			    7_71,
			    39,
			    42_58,
			    8_89,
			    33_18,
			    3_34_41,
			    3_34_63,
			    3_34_65,
			    3_34_63,
			    3_34_49,
			    24_71,
			    2,
			    PYTHON_CODE,
			]






			@classmethod
			def 		UpperCamelCase__							(  cls     ):
				UpperCAmelCase_     :      PLBartTokenizer						=  PLBartTokenizer.from_pretrained(
				    cls.checkpoint_name			,language_codes="base"			,src_lang="python"			,tgt_lang="en_XX"     )
				UpperCAmelCase_     :      Union[str, Any]						=  1
				return cls






			def 		UpperCamelCase__							(  self     ):
				self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["__java__"]			,5_00_01     )
				self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["__python__"]			,5_00_02     )
				self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["__en_XX__"]			,5_00_03     )






			def 		UpperCamelCase__							(  self     ):
				UpperCAmelCase_     :      Any						=  self.tokenizer.batch_encode_plus(self.src_text     ).input_ids[0]
				self.assertListEqual(self.expected_src_tokens			,_snake_case     )






			def 		UpperCamelCase__							(  self     ):
				self.assertIn(_snake_case			,self.tokenizer.all_special_ids     )
				UpperCAmelCase_     :      List[Any]						=  [EN_CODE, 90_37, 3_34_42, 57, 7_52, 1_53, 14, 56, 18, 9, 2]
				UpperCAmelCase_     :      Optional[Any]						=  self.tokenizer.decode(_snake_case			,skip_special_tokens=_snake_case     )
				UpperCAmelCase_     :      Any						=  self.tokenizer.decode(generated_ids[1:]			,skip_special_tokens=_snake_case     )
				self.assertEqual(_snake_case			,_snake_case     )
				self.assertNotIn(self.tokenizer.eos_token			,_snake_case     )






			def 		UpperCamelCase__							(  self     ):
				UpperCAmelCase_     :      Any						=  ["def sum(a,b,c):NEW_LINE_INDENTreturn sum([a,b,c])" * 20]
				self.assertIsInstance(src_text[0]			,_snake_case     )
				UpperCAmelCase_     :      Union[str, Any]						=  10
				UpperCAmelCase_     :      Union[str, Any]						=  self.tokenizer(_snake_case			,max_length=_snake_case			,truncation=_snake_case     ).input_ids[0]
				self.assertEqual(ids[-2]			,2     )
				self.assertEqual(ids[-1]			,_snake_case     )
				self.assertEqual(len(_snake_case     )			,_snake_case     )






			def 		UpperCamelCase__							(  self     ):
				self.assertListEqual(self.tokenizer.convert_tokens_to_ids(["<mask>", "__java__"]     )			,[5_00_04, 5_00_01]     )






			def 		UpperCamelCase__							(  self     ):
				UpperCAmelCase_     :      List[str]						=  tempfile.mkdtemp()
				UpperCAmelCase_     :      str						=  self.tokenizer.fairseq_tokens_to_ids
				self.tokenizer.save_pretrained(_snake_case     )
				UpperCAmelCase_     :      Tuple						=  PLBartTokenizer.from_pretrained(_snake_case     )
				self.assertDictEqual(new_tok.fairseq_tokens_to_ids			,_snake_case     )






			@require_torch
			def 		UpperCamelCase__							(  self     ):
				UpperCAmelCase_     :      Any						=  self.tokenizer(self.src_text			,text_target=self.tgt_text			,padding=_snake_case			,return_tensors="pt"     )
				UpperCAmelCase_     :      Dict						=  shift_tokens_right(batch["labels"]			,self.tokenizer.pad_token_id     )

				# fairseq batch: https://gist.github.com/sshleifer/cba08bc2109361a74ac3760a7e30e4f4
				self.assertEqual(batch.input_ids[1][-2:].tolist()			,[2, PYTHON_CODE]     )
				self.assertEqual(batch.decoder_input_ids[1][0]			,_snake_case     )
				self.assertEqual(batch.decoder_input_ids[1][-1]			,2     )
				self.assertEqual(batch.labels[1][-2:].tolist()			,[2, EN_CODE]     )






			@require_torch
			def 		UpperCamelCase__							(  self     ):
				UpperCAmelCase_     :      str						=  self.tokenizer(
				    self.src_text			,text_target=self.tgt_text			,padding=_snake_case			,truncation=_snake_case			,max_length=len(self.expected_src_tokens     )			,return_tensors="pt"			,)
				UpperCAmelCase_     :      Dict						=  shift_tokens_right(batch["labels"]			,self.tokenizer.pad_token_id     )

				self.assertIsInstance(_snake_case			,_snake_case     )

				self.assertEqual((2, 26)			,batch.input_ids.shape     )
				self.assertEqual((2, 26)			,batch.attention_mask.shape     )
				UpperCAmelCase_     :      str						=  batch.input_ids.tolist()[0]
				self.assertListEqual(self.expected_src_tokens			,_snake_case     )
				self.assertEqual(2			,batch.decoder_input_ids[0, -1]     )  # EOS
				# Test that special tokens are reset
				self.assertEqual(self.tokenizer.prefix_tokens			,[]     )
				self.assertEqual(self.tokenizer.suffix_tokens			,[self.tokenizer.eos_token_id, PYTHON_CODE]     )






			def 		UpperCamelCase__							(  self     ):
				UpperCAmelCase_     :      Optional[Any]						=  self.tokenizer(self.src_text			,padding=_snake_case			,truncation=_snake_case			,max_length=3			,return_tensors="pt"     )
				UpperCAmelCase_     :      Any						=  self.tokenizer(
				    text_target=self.tgt_text			,padding=_snake_case			,truncation=_snake_case			,max_length=10			,return_tensors="pt"     )
				UpperCAmelCase_     :      Union[str, Any]						=  targets["input_ids"]
				UpperCAmelCase_     :      Tuple						=  shift_tokens_right(_snake_case			,self.tokenizer.pad_token_id     )

				self.assertEqual(batch.input_ids.shape[1]			,3     )
				self.assertEqual(batch.decoder_input_ids.shape[1]			,10     )






			@require_torch
			def 		UpperCamelCase__							(  self     ):
				UpperCAmelCase_     :      Optional[Any]						=  self.tokenizer._build_translation_inputs(
				    "A test"			,return_tensors="pt"			,src_lang="en_XX"			,tgt_lang="java"     )

				self.assertEqual(
				    nested_simplify(_snake_case     )			,{
				        # A, test, EOS, en_XX
				        "input_ids": [[1_50, 2_42, 2, 5_00_03]],
				        "attention_mask": [[1, 1, 1, 1]],
				        # java
				        "forced_bos_token_id": 5_00_01,
				    }			,)







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

   def __init__(				self	:    Tuple			,						lowerCamelCase__	:    Optional[int]			,						lowerCamelCase__	:    Dict=1_3			,						lowerCamelCase__	:    Any=7			,						lowerCamelCase__	:    Optional[Any]=True			,						lowerCamelCase__	:    Optional[Any]=True			,						lowerCamelCase__	:    List[Any]=True			,						lowerCamelCase__	:    Union[str, Any]=True			,						lowerCamelCase__	:    Optional[int]=9_9			,						lowerCamelCase__	:    Optional[int]=2_4			,						lowerCamelCase__	:    Optional[int]=2			,						lowerCamelCase__	:    Dict=6			,						lowerCamelCase__	:    List[str]=3_7			,						lowerCamelCase__	:    Optional[Any]="gelu"			,						lowerCamelCase__	:    Dict=0.1			,						lowerCamelCase__	:    Optional[int]=0.1			,						lowerCamelCase__	:    Any=5_1_2			,						lowerCamelCase__	:    int=1_6			,						lowerCamelCase__	:    Union[str, Any]=2			,						lowerCamelCase__	:    Optional[int]=0.02			,						lowerCamelCase__	:    Optional[Any]=3			,						lowerCamelCase__	:    Optional[int]=None			,						lowerCamelCase__	:    Any=1_0_0_0			,						) ->			Any:
         """simple docstring"""





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

   def     UpperCamelCase					(				self	:    int       ) ->			int:
         """simple docstring"""





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

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

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

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

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

         A_							       =		self.get_config()

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

   def     UpperCamelCase					(				self	:    Optional[int]       ) ->			List[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     UpperCamelCase					(				self	:    Dict			,						lowerCamelCase__	:    Any			,						lowerCamelCase__	:    Union[str, Any]			,						lowerCamelCase__	:    List[Any]			,						lowerCamelCase__	:    Any			,						lowerCamelCase__	:    List[Any]			,						lowerCamelCase__	:    List[str]			,						lowerCamelCase__	:    Any			,						) ->			List[Any]:
         """simple docstring"""





         A_							       =		LiltModel(config=lowerCamelCase__       )
         model.to(lowerCamelCase__       )
         model.eval()
         A_							       =		model(lowerCamelCase__			,						bbox=lowerCamelCase__			,						attention_mask=lowerCamelCase__			,						token_type_ids=lowerCamelCase__       )
         A_							       =		model(lowerCamelCase__			,						bbox=lowerCamelCase__			,						token_type_ids=lowerCamelCase__       )
         A_							       =		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     UpperCamelCase					(				self	:    Optional[int]			,						lowerCamelCase__	:    str			,						lowerCamelCase__	:    Union[str, Any]			,						lowerCamelCase__	:    Union[str, Any]			,						lowerCamelCase__	:    Dict			,						lowerCamelCase__	:    List[Any]			,						lowerCamelCase__	:    Dict			,						lowerCamelCase__	:    Optional[Any]			,						) ->			Union[str, Any]:
         """simple docstring"""





         A_							       =		self.num_labels
         A_							       =		LiltForTokenClassification(config=lowerCamelCase__       )
         model.to(lowerCamelCase__       )
         model.eval()
         A_							       =		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     UpperCamelCase					(				self	:    Dict			,						lowerCamelCase__	:    List[Any]			,						lowerCamelCase__	:    str			,						lowerCamelCase__	:    str			,						lowerCamelCase__	:    Dict			,						lowerCamelCase__	:    Any			,						lowerCamelCase__	:    Any			,						lowerCamelCase__	:    List[str]			,						) ->			Any:
         """simple docstring"""





         A_							       =		LiltForQuestionAnswering(config=lowerCamelCase__       )
         model.to(lowerCamelCase__       )
         model.eval()
         A_							       =		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     UpperCamelCase					(				self	:    Optional[int]       ) ->			List[Any]:
         """simple docstring"""





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



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

   def     UpperCamelCase					(				self	:    Optional[Any]			,						lowerCamelCase__	:    Dict			,						lowerCamelCase__	:    int			,						lowerCamelCase__	:    List[str]			,						lowerCamelCase__	:    List[str]			,						lowerCamelCase__	:    List[str]       ) ->			Any:
         """simple docstring"""





         return True

   def     UpperCamelCase					(				self	:    int       ) ->			Any:
         """simple docstring"""





         A_							       =		LiltModelTester(self       )
         A_							       =		ConfigTester(self			,						config_class=lowerCamelCase__			,						hidden_size=3_7       )

   def     UpperCamelCase					(				self	:    int       ) ->			Optional[Any]:
         """simple docstring"""





         self.config_tester.run_common_tests()

   def     UpperCamelCase					(				self	:    Union[str, Any]       ) ->			Dict:
         """simple docstring"""





         A_							       =		self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*lowerCamelCase__       )

   def     UpperCamelCase					(				self	:    Optional[Any]       ) ->			int:
         """simple docstring"""





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

   def     UpperCamelCase					(				self	:    List[Any]       ) ->			int:
         """simple docstring"""





         A_							       =		self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_token_classification(*lowerCamelCase__       )

   def     UpperCamelCase					(				self	:    List[str]       ) ->			Any:
         """simple docstring"""





         A_							       =		self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_question_answering(*lowerCamelCase__       )





   @slow
   def     UpperCamelCase					(				self	:    Any       ) ->			Dict:
         """simple docstring"""





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



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

   def     UpperCamelCase					(				self	:    List[str]       ) ->			Optional[Any]:
         """simple docstring"""





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

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

         # forward pass
         with torch.no_grad():
               A_							       =		model(input_ids=lowerCamelCase__			,						bbox=lowerCamelCase__       )

         A_							       =		torch.Size([1, 2, 7_6_8]       )
         A_							       =		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       )       )





