
import json
import os
from pathlib import Path
from shutil import copyfile
from typing import Any, Dict, List, Optional, Tuple, Union

import sentencepiece

from ...tokenization_utils import BatchEncoding, PreTrainedTokenizer
from ...utils import logging


_UpperCAmelCase					: Any      =       logging.get_logger(__name__)

_UpperCAmelCase					: List[str]      =       """▁"""

_UpperCAmelCase					: Tuple      =       {
    """vocab_file""": """vocab.json""",
    """spm_file""": """sentencepiece.bpe.model""",
    """tokenizer_config_file""": """tokenizer_config.json""",
}

_UpperCAmelCase					: Optional[Any]      =       {
    """vocab_file""": {
        """facebook/m2m100_418M""": """https://huggingface.co/facebook/m2m100_418M/resolve/main/vocab.json""",
        """facebook/m2m100_1.2B""": """https://huggingface.co/facebook/m2m100_1.2B/resolve/main/vocab.json""",
    },
    """spm_file""": {
        """facebook/m2m100_418M""": """https://huggingface.co/facebook/m2m100_418M/resolve/main/sentencepiece.bpe.model""",
        """facebook/m2m100_1.2B""": """https://huggingface.co/facebook/m2m100_1.2B/resolve/main/sentencepiece.bpe.model""",
    },
    """tokenizer_config_file""": {
        """facebook/m2m100_418M""": """https://huggingface.co/facebook/m2m100_418M/resolve/main/tokenizer_config.json""",
        """facebook/m2m100_1.2B""": """https://huggingface.co/facebook/m2m100_1.2B/resolve/main/tokenizer_config.json""",
    },
}

_UpperCAmelCase					: Tuple      =       {
    """facebook/m2m100_418M""": 1_024,
}

# fmt: off
_UpperCAmelCase					: Optional[Any]      =       {
    """m2m100""": ["""af""", """am""", """ar""", """ast""", """az""", """ba""", """be""", """bg""", """bn""", """br""", """bs""", """ca""", """ceb""", """cs""", """cy""", """da""", """de""", """el""", """en""", """es""", """et""", """fa""", """ff""", """fi""", """fr""", """fy""", """ga""", """gd""", """gl""", """gu""", """ha""", """he""", """hi""", """hr""", """ht""", """hu""", """hy""", """id""", """ig""", """ilo""", """is""", """it""", """ja""", """jv""", """ka""", """kk""", """km""", """kn""", """ko""", """lb""", """lg""", """ln""", """lo""", """lt""", """lv""", """mg""", """mk""", """ml""", """mn""", """mr""", """ms""", """my""", """ne""", """nl""", """no""", """ns""", """oc""", """or""", """pa""", """pl""", """ps""", """pt""", """ro""", """ru""", """sd""", """si""", """sk""", """sl""", """so""", """sq""", """sr""", """ss""", """su""", """sv""", """sw""", """ta""", """th""", """tl""", """tn""", """tr""", """uk""", """ur""", """uz""", """vi""", """wo""", """xh""", """yi""", """yo""", """zh""", """zu"""],
    """wmt21""": ["""en""", """ha""", """is""", """ja""", """cs""", """ru""", """zh""", """de"""]
}


class 				lowercase					(		UpperCAmelCase__   ):
		__lowercase       :       int	     =				VOCAB_FILES_NAMES
		__lowercase       :       List[Any]	     =				PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
		__lowercase       :       Dict	     =				PRETRAINED_VOCAB_FILES_MAP
		__lowercase       :       List[Any]	     =				["input_ids", "attention_mask"]

		__lowercase       :       Union[str, Any]	     =				[]
		__lowercase       :       int	     =				[]



		def __init__( self				,      A_				,      A_				,      A_=None				,      A_=None				,      A_="<s>"				,      A_="</s>"				,      A_="</s>"				,      A_="<pad>"				,      A_="<unk>"				,      A_="m2m100"				,      A_ = None				,      A_=8				,      **A_				,      )  ->					str:
				"""simple docstring"""
				UpperCamelCase		=     {} if sp_model_kwargs is None else sp_model_kwargs

				UpperCamelCase		=     language_codes
				UpperCamelCase		=     FAIRSEQ_LANGUAGE_CODES[language_codes]
				UpperCamelCase		=     {lang_code: F'''__{lang_code}__''' for lang_code in fairseq_language_code}

				UpperCamelCase		=     kwargs.get('additional_special_tokens'				,      []       )
				kwargs["additional_special_tokens"] += [
				    self.get_lang_token(lowercase_       )
				    for lang_code in fairseq_language_code
				    if self.get_lang_token(lowercase_       ) not in kwargs["additional_special_tokens"]
				]

				super().__init__(
				    src_lang=lowercase_				,      tgt_lang=lowercase_				,      bos_token=lowercase_				,      eos_token=lowercase_				,      sep_token=lowercase_				,      unk_token=lowercase_				,      pad_token=lowercase_				,      language_codes=lowercase_				,      sp_model_kwargs=self.sp_model_kwargs				,      num_madeup_words=lowercase_				,      **lowercase_				,      )

				UpperCamelCase		=     vocab_file
				UpperCamelCase		=     load_json(lowercase_       )
				UpperCamelCase		=     {v: k for k, v in self.encoder.items()}
				UpperCamelCase		=     spm_file
				UpperCamelCase		=     load_spm(lowercase_				,      self.sp_model_kwargs       )

				UpperCamelCase		=     len(self.encoder       )

				UpperCamelCase		=     {
				    self.get_lang_token(lowercase_       ): self.encoder_size + i for i, lang_code in enumerate(lowercase_       )
				}
				UpperCamelCase		=     {lang_code: self.encoder_size + i for i, lang_code in enumerate(lowercase_       )}
				UpperCamelCase		=     {v: k for k, v in self.lang_token_to_id.items()}

				UpperCamelCase		=     src_lang if src_lang is not None else '''en'''
				UpperCamelCase		=     tgt_lang
				UpperCamelCase		=     self.get_lang_id(self._src_lang       )
				self.set_src_lang_special_tokens(self._src_lang       )

				UpperCamelCase		=     num_madeup_words



		@property
		def __UpperCamelCase ( self       )  ->					Optional[int]:
				"""simple docstring"""
				return len(self.encoder       ) + len(self.lang_token_to_id       )



		@property
		def __UpperCamelCase ( self       )  ->					List[Any]:
				"""simple docstring"""
				return self._src_lang



		@src_lang.setter
		def __UpperCamelCase ( self				,      A_       )  ->					Union[str, Any]:
				"""simple docstring"""
				UpperCamelCase		=     new_src_lang
				self.set_src_lang_special_tokens(self._src_lang       )



		def __UpperCamelCase ( self				,      A_       )  ->					List[str]:
				"""simple docstring"""
				return self.sp_model.encode(lowercase_				,      out_type=lowercase_       )



		def __UpperCamelCase ( self				,      A_       )  ->					Optional[Any]:
				"""simple docstring"""


				if token in self.lang_token_to_id:
						return self.lang_token_to_id[token]
				return self.encoder.get(lowercase_				,      self.encoder[self.unk_token]       )



		def __UpperCamelCase ( self				,      A_       )  ->					Optional[Any]:
				"""simple docstring"""


				if index in self.id_to_lang_token:
						return self.id_to_lang_token[index]
				return self.decoder.get(lowercase_				,      self.unk_token       )



		def __UpperCamelCase ( self				,      A_       )  ->					List[str]:
				"""simple docstring"""
				UpperCamelCase		=     []
				UpperCamelCase		=     ''''''
				for token in tokens:
						# make sure that special tokens are not decoded using sentencepiece model
						if token in self.all_special_tokens:
								out_string += self.sp_model.decode(lowercase_       ) + token
								UpperCamelCase		=     []
						else:
								current_sub_tokens.append(lowercase_       )
				out_string += self.sp_model.decode(lowercase_       )
				return out_string.strip()



		def __UpperCamelCase ( self				,      A_				,      A_ = None				,      A_ = False       )  ->					Optional[int]:
				"""simple docstring"""


				if already_has_special_tokens:
						return super().get_special_tokens_mask(
						    token_ids_a=lowercase_				,      token_ids_a=lowercase_				,      already_has_special_tokens=lowercase_       )

				UpperCamelCase		=     [1] * len(self.prefix_tokens       )
				UpperCamelCase		=     [1] * len(self.suffix_tokens       )
				if token_ids_a is None:
						return prefix_ones + ([0] * len(lowercase_       )) + suffix_ones
				return prefix_ones + ([0] * len(lowercase_       )) + ([0] * len(lowercase_       )) + suffix_ones



		def __UpperCamelCase ( self				,      A_				,      A_ = None       )  ->					Any:
				"""simple docstring"""


				if token_ids_a is None:
						return self.prefix_tokens + token_ids_a + self.suffix_tokens
				# We don't expect to process pairs, but leave the pair logic for API consistency
				return self.prefix_tokens + token_ids_a + token_ids_a + self.suffix_tokens



		def __UpperCamelCase ( self       )  ->					List[Any]:
				"""simple docstring"""
				UpperCamelCase		=     {self.convert_ids_to_tokens(lowercase_       ): i for i in range(self.vocab_size       )}
				vocab.update(self.added_tokens_encoder       )
				return vocab



		def __getstate__( self       )  ->					str:
				"""simple docstring"""
				UpperCamelCase		=     self.__dict__.copy()
				UpperCamelCase		=     None
				return state



		def __setstate__( self				,      A_       )  ->					int:
				"""simple docstring"""
				UpperCamelCase		=     d

				# for backward compatibility
				if not hasattr(self				,      'sp_model_kwargs'       ):
						UpperCamelCase		=     {}

				UpperCamelCase		=     load_spm(self.spm_file				,      self.sp_model_kwargs       )



		def __UpperCamelCase ( self				,      A_				,      A_ = None       )  ->					Any:
				"""simple docstring"""
				UpperCamelCase		=     Path(lowercase_       )
				if not save_dir.is_dir():
						raise OSError(F'''{save_directory} should be a directory'''       )
				UpperCamelCase		=     save_dir / (
				    (filename_prefix + '''-''' if filename_prefix else '''''') + self.vocab_files_names['''vocab_file''']
				)
				UpperCamelCase		=     save_dir / (
				    (filename_prefix + '''-''' if filename_prefix else '''''') + self.vocab_files_names['''spm_file''']
				)

				save_json(self.encoder				,      lowercase_       )

				if os.path.abspath(self.spm_file       ) != os.path.abspath(lowercase_       ) and os.path.isfile(self.spm_file       ):
						copyfile(self.spm_file				,      lowercase_       )
				elif not os.path.isfile(self.spm_file       ):
						with open(lowercase_				,      'wb'       ) as fi:
								UpperCamelCase		=     self.sp_model.serialized_model_proto()
								fi.write(lowercase_       )

				return (str(lowercase_       ), str(lowercase_       ))



		def __UpperCamelCase ( self				,      A_				,      A_ = "en"				,      A_ = None				,      A_ = "ro"				,      **A_				,      )  ->					Dict:
				"""simple docstring"""
				UpperCamelCase		=     src_lang
				UpperCamelCase		=     tgt_lang
				self.set_src_lang_special_tokens(self.src_lang       )
				return super().prepare_seqaseq_batch(lowercase_				,      lowercase_				,      **lowercase_       )



		def __UpperCamelCase ( self				,      A_				,      A_				,      A_				,      **A_       )  ->					Union[str, Any]:
				"""simple docstring"""


				if src_lang is None or tgt_lang is None:
						raise ValueError('Translation requires a `src_lang` and a `tgt_lang` for this model'       )
				UpperCamelCase		=     src_lang
				UpperCamelCase		=     self(lowercase_				,      add_special_tokens=lowercase_				,      **lowercase_       )
				UpperCamelCase		=     self.get_lang_id(lowercase_       )
				UpperCamelCase		=     tgt_lang_id
				return inputs



		def __UpperCamelCase ( self       )  ->					Union[str, Any]:
				"""simple docstring"""
				self.set_src_lang_special_tokens(self.src_lang       )



		def __UpperCamelCase ( self       )  ->					Tuple:
				"""simple docstring"""
				self.set_tgt_lang_special_tokens(self.tgt_lang       )



		def __UpperCamelCase ( self				,      A_       )  ->					Optional[int]:
				"""simple docstring"""
				UpperCamelCase		=     self.get_lang_token(lowercase_       )
				UpperCamelCase		=     self.lang_token_to_id[lang_token]
				UpperCamelCase		=     [self.cur_lang_id]
				UpperCamelCase		=     [self.eos_token_id]



		def __UpperCamelCase ( self				,      A_       )  ->					Any:
				"""simple docstring"""
				UpperCamelCase		=     self.get_lang_token(lowercase_       )
				UpperCamelCase		=     self.lang_token_to_id[lang_token]
				UpperCamelCase		=     [self.cur_lang_id]
				UpperCamelCase		=     [self.eos_token_id]



		def __UpperCamelCase ( self				,      A_       )  ->					int:
				"""simple docstring"""
				return self.lang_code_to_token[lang]



		def __UpperCamelCase ( self				,      A_       )  ->					Union[str, Any]:
				"""simple docstring"""
				UpperCamelCase		=     self.get_lang_token(lowercase_       )
				return self.lang_token_to_id[lang_token]






def       A       (					lowercase    ,       lowercase )   ->  sentencepiece.SentencePieceProcessor:
		'''simple docstring'''

		UpperCamelCase		=     sentencepiece.SentencePieceProcessor(**__a )
		spm.Load(str(__a ) )
		return spm


def       A       (					lowercase )   ->  Union[Dict, List]:
		'''simple docstring'''

		with open(__a    ,       'r' ) as f:
				return json.load(__a )


def       A       (					lowercase    ,       lowercase )   ->  None:
		'''simple docstring'''

		with open(__a    ,       'w' ) as f:
				json.dump(__a    ,       __a    ,       indent=2 )








"""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 							lowerCAmelCase__				:






      '''simple docstring'''

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




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  List[str]    						=		parent
          SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		batch_size
          SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		seq_length
          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		is_training
          SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		use_input_mask
          SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		use_token_type_ids
          SCREAMING_SNAKE_CASE_      :  int    						=		use_labels
          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		vocab_size
          SCREAMING_SNAKE_CASE_      :  List[str]    						=		hidden_size
          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		num_hidden_layers
          SCREAMING_SNAKE_CASE_      :  List[str]    						=		num_attention_heads
          SCREAMING_SNAKE_CASE_      :  Tuple    						=		intermediate_size
          SCREAMING_SNAKE_CASE_      :  Tuple    						=		hidden_act
          SCREAMING_SNAKE_CASE_      :  int    						=		hidden_dropout_prob
          SCREAMING_SNAKE_CASE_      :  str    						=		attention_probs_dropout_prob
          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		max_position_embeddings
          SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		type_vocab_size
          SCREAMING_SNAKE_CASE_      :  List[str]    						=		type_sequence_label_size
          SCREAMING_SNAKE_CASE_      :  Any    						=		initializer_range
          SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		num_labels
          SCREAMING_SNAKE_CASE_      :  Tuple    						=		scope
          SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		range_bbox
      def _SCREAMING_SNAKE_CASE (						self     :  List[str]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  Tuple    						=		ids_tensor([self.batch_size, self.seq_length]						,	self.vocab_size)

          SCREAMING_SNAKE_CASE_      :  Dict    						=		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]:
                      SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		bbox[i, j, 3]
                      SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		bbox[i, j, 1]
                      SCREAMING_SNAKE_CASE_      :  str    						=		t
                  if bbox[i, j, 2] < bbox[i, j, 0]:
                      SCREAMING_SNAKE_CASE_      :  List[str]    						=		bbox[i, j, 2]
                      SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		bbox[i, j, 0]
                      SCREAMING_SNAKE_CASE_      :  List[str]    						=		t

          SCREAMING_SNAKE_CASE_      :  Tuple    						=		None
          if self.use_input_mask:
              SCREAMING_SNAKE_CASE_      :  List[Any]    						=		ids_tensor([self.batch_size, self.seq_length]						,	vocab_size=2)

          SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		None
          if self.use_token_type_ids:
              SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		ids_tensor([self.batch_size, self.seq_length]						,	self.type_vocab_size)

          SCREAMING_SNAKE_CASE_      :  List[str]    						=		None
          SCREAMING_SNAKE_CASE_      :  List[str]    						=		None
          if self.use_labels:
              SCREAMING_SNAKE_CASE_      :  int    						=		ids_tensor([self.batch_size]						,	self.type_sequence_label_size)
              SCREAMING_SNAKE_CASE_      :  Dict    						=		ids_tensor([self.batch_size, self.seq_length]						,	self.num_labels)

          SCREAMING_SNAKE_CASE_      :  Any    						=		self.get_config()

          return config, input_ids, bbox, token_type_ids, input_mask, sequence_labels, token_labels
      def _SCREAMING_SNAKE_CASE (						self     :  Optional[int]):




          '''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 _SCREAMING_SNAKE_CASE (						self     :  Optional[int]						,	lowercase_     :  Optional[Any]						,	lowercase_     :  Optional[Any]						,	lowercase_     :  str						,	lowercase_     :  Optional[Any]						,	lowercase_     :  int						,	lowercase_     :  Optional[Any]						,	lowercase_     :  int						,	):




          '''simple docstring'''


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




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		self.num_labels
          SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		LiltForTokenClassification(config=lowercase_)
          model.to(lowercase_)
          model.eval()
          SCREAMING_SNAKE_CASE_      :  Tuple    						=		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 _SCREAMING_SNAKE_CASE (						self     :  Tuple						,	lowercase_     :  str						,	lowercase_     :  Union[str, Any]						,	lowercase_     :  Any						,	lowercase_     :  Dict						,	lowercase_     :  List[str]						,	lowercase_     :  List[Any]						,	lowercase_     :  str						,	):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		LiltForQuestionAnswering(config=lowercase_)
          model.to(lowercase_)
          model.eval()
          SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		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 _SCREAMING_SNAKE_CASE (						self     :  Tuple):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  str    						=		self.prepare_config_and_inputs()
          (
              (
              SCREAMING_SNAKE_CASE_
          )						,			(
              SCREAMING_SNAKE_CASE_
          )						,			(
              SCREAMING_SNAKE_CASE_
          )						,			(
              SCREAMING_SNAKE_CASE_
          )						,			(
              SCREAMING_SNAKE_CASE_
          )						,			(
              SCREAMING_SNAKE_CASE_
          )						,			(
              SCREAMING_SNAKE_CASE_
          )						,			
          )      :  List[str]    						=		config_and_inputs
          SCREAMING_SNAKE_CASE_      :  str    						=		{
              '''input_ids''': input_ids,
              '''bbox''': bbox,
              '''token_type_ids''': token_type_ids,
              '''attention_mask''': input_mask,
          }
          return config, inputs_dict




@require_torch
class 							lowerCAmelCase__				(			UpperCAmelCase__				,		UpperCAmelCase__				,		UpperCAmelCase__				,		unittest.TestCase ):






      '''simple docstring'''

      __UpperCamelCase	 =  (
          (
              LiltModel,
              LiltForSequenceClassification,
              LiltForTokenClassification,
              LiltForQuestionAnswering,
          )
          if is_torch_available()
          else ()
      )
      __UpperCamelCase	 =  (
          {
              "feature-extraction": LiltModel,
              "question-answering": LiltForQuestionAnswering,
              "text-classification": LiltForSequenceClassification,
              "token-classification": LiltForTokenClassification,
              "zero-shot": LiltForSequenceClassification,
          }
          if is_torch_available()
          else {}
      )
      __UpperCamelCase	 =  False
      __UpperCamelCase	 =  False
      def _SCREAMING_SNAKE_CASE (						self     :  Any						,	lowercase_     :  List[str]						,	lowercase_     :  Optional[int]						,	lowercase_     :  Optional[int]						,	lowercase_     :  str						,	lowercase_     :  str):




          '''simple docstring'''


          return True
      def _SCREAMING_SNAKE_CASE (						self     :  Tuple):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  Dict    						=		LiltModelTester(self)
          SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		ConfigTester(self						,	config_class=lowercase_						,	hidden_size=37)
      def _SCREAMING_SNAKE_CASE (						self     :  Union[str, Any]):




          '''simple docstring'''


          self.config_tester.run_common_tests()
      def _SCREAMING_SNAKE_CASE (						self     :  List[str]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*lowercase_)
      def _SCREAMING_SNAKE_CASE (						self     :  Tuple):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  Tuple    						=		self.model_tester.prepare_config_and_inputs()
          for type in ["absolute", "relative_key", "relative_key_query"]:
              SCREAMING_SNAKE_CASE_      :  Dict    						=		type
              self.model_tester.create_and_check_model(*lowercase_)
      def _SCREAMING_SNAKE_CASE (						self     :  str):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_token_classification(*lowercase_)
      def _SCREAMING_SNAKE_CASE (						self     :  Tuple):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  List[str]    						=		self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_question_answering(*lowercase_)



      @slow
      def _SCREAMING_SNAKE_CASE (						self     :  Optional[int]):




          '''simple docstring'''


          for model_name in LILT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		LiltModel.from_pretrained(lowercase_)
              self.assertIsNotNone(lowercase_)




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






      '''simple docstring'''

      def _SCREAMING_SNAKE_CASE (						self     :  Optional[int]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  List[str]    						=		LiltModel.from_pretrained('''SCUT-DLVCLab/lilt-roberta-en-base''').to(lowercase_)

          SCREAMING_SNAKE_CASE_      :  str    						=		torch.tensor([[1, 2]]						,	device=lowercase_)
          SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		torch.tensor([[[1, 2, 3, 4], [5, 6, 7, 8]]]						,	device=lowercase_)

          # forward pass
          with torch.no_grad():
              SCREAMING_SNAKE_CASE_      :  Dict    						=		model(input_ids=lowercase_						,	bbox=lowercase_)

          SCREAMING_SNAKE_CASE_      :  str    						=		torch.Size([1, 2, 768])
          SCREAMING_SNAKE_CASE_      :  Dict    						=		torch.tensor(
              [[-0.06_53, 0.09_50, -0.00_61], [-0.05_45, 0.09_26, -0.03_24]]						,	device=lowercase_						,	)

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


