




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					:					Tuple       ,     SCREAMING_SNAKE_CASE__					:					Dict       ,     SCREAMING_SNAKE_CASE__					:					int=13       ,     SCREAMING_SNAKE_CASE__					:					List[Any]=7       ,     SCREAMING_SNAKE_CASE__					:					Dict=True       ,     SCREAMING_SNAKE_CASE__					:					Dict=True       ,     SCREAMING_SNAKE_CASE__					:					int=True       ,     SCREAMING_SNAKE_CASE__					:					Optional[int]=True       ,     SCREAMING_SNAKE_CASE__					:					List[Any]=99       ,     SCREAMING_SNAKE_CASE__					:					List[str]=24       ,     SCREAMING_SNAKE_CASE__					:					Optional[Any]=2       ,     SCREAMING_SNAKE_CASE__					:					Optional[int]=6       ,     SCREAMING_SNAKE_CASE__					:					List[Any]=37       ,     SCREAMING_SNAKE_CASE__					:					Dict="gelu"       ,     SCREAMING_SNAKE_CASE__					:					Any=0.1       ,     SCREAMING_SNAKE_CASE__					:					List[Any]=0.1       ,     SCREAMING_SNAKE_CASE__					:					Optional[int]=512       ,     SCREAMING_SNAKE_CASE__					:					Optional[Any]=16       ,     SCREAMING_SNAKE_CASE__					:					List[Any]=2       ,     SCREAMING_SNAKE_CASE__					:					int=0.02       ,     SCREAMING_SNAKE_CASE__					:					Dict=3       ,     SCREAMING_SNAKE_CASE__					:					List[Any]=None       ,     SCREAMING_SNAKE_CASE__					:					List[Any]=1_000       ,     )				->	Dict:
         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        a				(	self					:					List[Any]       )				->	Optional[Any]:
         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        a				(	self					:					int       )				->	int:
         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					:					Optional[int]       ,     SCREAMING_SNAKE_CASE__					:					Tuple       ,     SCREAMING_SNAKE_CASE__					:					Dict       ,     SCREAMING_SNAKE_CASE__					:					Optional[Any]       ,     SCREAMING_SNAKE_CASE__					:					Tuple       ,     SCREAMING_SNAKE_CASE__					:					Optional[Any]       ,     SCREAMING_SNAKE_CASE__					:					List[str]       ,     SCREAMING_SNAKE_CASE__					:					Dict       ,     )				->	Tuple:
         lowerCAmelCase__          =			LiltModel(config=SCREAMING_SNAKE_CASE__       )
         model.to(SCREAMING_SNAKE_CASE__       )
         model.eval()
         lowerCAmelCase__          =			model(SCREAMING_SNAKE_CASE__       ,     bbox=SCREAMING_SNAKE_CASE__       ,     attention_mask=SCREAMING_SNAKE_CASE__       ,     token_type_ids=SCREAMING_SNAKE_CASE__       )
         lowerCAmelCase__          =			model(SCREAMING_SNAKE_CASE__       ,     bbox=SCREAMING_SNAKE_CASE__       ,     token_type_ids=SCREAMING_SNAKE_CASE__       )
         lowerCAmelCase__          =			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        a				(	self					:					Union[str, Any]       ,     SCREAMING_SNAKE_CASE__					:					Dict       ,     SCREAMING_SNAKE_CASE__					:					int       ,     SCREAMING_SNAKE_CASE__					:					str       ,     SCREAMING_SNAKE_CASE__					:					int       ,     SCREAMING_SNAKE_CASE__					:					Any       ,     SCREAMING_SNAKE_CASE__					:					Tuple       ,     SCREAMING_SNAKE_CASE__					:					List[Any]       ,     )				->	Optional[int]:
         lowerCAmelCase__          =			self.num_labels
         lowerCAmelCase__          =			LiltForTokenClassification(config=SCREAMING_SNAKE_CASE__       )
         model.to(SCREAMING_SNAKE_CASE__       )
         model.eval()
         lowerCAmelCase__          =			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        a				(	self					:					int       ,     SCREAMING_SNAKE_CASE__					:					Tuple       ,     SCREAMING_SNAKE_CASE__					:					List[Any]       ,     SCREAMING_SNAKE_CASE__					:					Tuple       ,     SCREAMING_SNAKE_CASE__					:					Any       ,     SCREAMING_SNAKE_CASE__					:					int       ,     SCREAMING_SNAKE_CASE__					:					List[Any]       ,     SCREAMING_SNAKE_CASE__					:					List[Any]       ,     )				->	Optional[int]:
         lowerCAmelCase__          =			LiltForQuestionAnswering(config=SCREAMING_SNAKE_CASE__       )
         model.to(SCREAMING_SNAKE_CASE__       )
         model.eval()
         lowerCAmelCase__          =			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        a				(	self					:					Dict       )				->	List[str]:
         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	(   UpperCamelCase__     ,    UpperCamelCase__     ,    UpperCamelCase__     ,    unittest.TestCase   ):




    """simple docstring"""

    snake_case__ =				(
        (
            LiltModel,
            LiltForSequenceClassification,
            LiltForTokenClassification,
            LiltForQuestionAnswering,
        )
        if is_torch_available()
        else ()
    )
    snake_case__ =				(
        {
            "feature-extraction": LiltModel,
            "question-answering": LiltForQuestionAnswering,
            "text-classification": LiltForSequenceClassification,
            "token-classification": LiltForTokenClassification,
            "zero-shot": LiltForSequenceClassification,
        }
        if is_torch_available()
        else {}
    )
    snake_case__ =				False
    snake_case__ =				False


    def        a				(	self					:					Any       ,     SCREAMING_SNAKE_CASE__					:					Dict       ,     SCREAMING_SNAKE_CASE__					:					Union[str, Any]       ,     SCREAMING_SNAKE_CASE__					:					List[Any]       ,     SCREAMING_SNAKE_CASE__					:					str       ,     SCREAMING_SNAKE_CASE__					:					List[Any]       )				->	int:
         return True


    def        a				(	self					:					List[Any]       )				->	str:
         lowerCAmelCase__          =			LiltModelTester(self       )
         lowerCAmelCase__          =			ConfigTester(self       ,     config_class=SCREAMING_SNAKE_CASE__       ,     hidden_size=37       )


    def        a				(	self					:					Tuple       )				->	Dict:
         self.config_tester.run_common_tests()


    def        a				(	self					:					Tuple       )				->	Dict:
         lowerCAmelCase__          =			self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE__       )


    def        a				(	self					:					Any       )				->	Any:
         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(*SCREAMING_SNAKE_CASE__       )


    def        a				(	self					:					Any       )				->	Optional[int]:
         lowerCAmelCase__          =			self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_token_classification(*SCREAMING_SNAKE_CASE__       )


    def        a				(	self					:					Dict       )				->	List[Any]:
         lowerCAmelCase__          =			self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_question_answering(*SCREAMING_SNAKE_CASE__       )


    @slow
    def        a				(	self					:					Optional[int]       )				->	Optional[Any]:
         for model_name in LILT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              lowerCAmelCase__          =			LiltModel.from_pretrained(SCREAMING_SNAKE_CASE__       )
              self.assertIsNotNone(SCREAMING_SNAKE_CASE__       )






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




    """simple docstring"""

    def        a				(	self					:					Optional[int]       )				->	List[Any]:
         lowerCAmelCase__          =			LiltModel.from_pretrained("SCUT-DLVCLab/lilt-roberta-en-base"       ).to(SCREAMING_SNAKE_CASE__       )

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

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

         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=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       )       )






import time
from contextlib import contextmanager
from pathlib import Path

import pytest
import requests
from huggingface_hub.hf_api import HfApi, HfFolder


UpperCamelCase								=					'__DUMMY_TRANSFORMERS_USER__'
UpperCamelCase								=					'Dummy User'
UpperCamelCase								=					'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'

UpperCamelCase								=					'https://hub-ci.huggingface.co'
UpperCamelCase								=					CI_HUB_ENDPOINT + '/datasets/{repo_id}/resolve/{revision}/{path}'
UpperCamelCase								=					CI_HUB_ENDPOINT + '/{repo_id}/resolve/{revision}/{filename}'
UpperCamelCase								=					Path('~/.huggingface/hub_ci_token').expanduser()



@pytest.fixture
def 							_A       (						lowerCAmelCase_					: Dict      ):
     """simple docstring"""

     monkeypatch.setattr(
         "huggingface_hub.file_download.HUGGINGFACE_CO_URL_TEMPLATE"       ,    lowerCAmelCase_      )



@pytest.fixture
def 							_A       (						lowerCAmelCase_					: int      ):
     """simple docstring"""

     monkeypatch.setattr("datasets.config.HF_ENDPOINT"       ,    lowerCAmelCase_      )
     monkeypatch.setattr("datasets.config.HUB_DATASETS_URL"       ,    lowerCAmelCase_      )



@pytest.fixture
def 							_A       (						lowerCAmelCase_					: str      ):
     """simple docstring"""

     monkeypatch.setattr("huggingface_hub.hf_api.HfFolder.path_token"       ,    lowerCAmelCase_      )



@pytest.fixture
def 							_A       (						lowerCAmelCase_					: int       ,    lowerCAmelCase_					: List[Any]      ):
     """simple docstring"""

     HfFolder.save_token(lowerCAmelCase_      )
     yield
     HfFolder.delete_token()



@pytest.fixture(scope="session"      )
def 							_A       (						):
     """simple docstring"""

     return HfApi(endpoint=lowerCAmelCase_      )



@pytest.fixture(scope="session"      )
def 							_A       (						lowerCAmelCase_					: HfApi      ):
     """simple docstring"""

     lowerCAmelCase__          =			HfFolder.get_token()
     HfFolder.save_token(lowerCAmelCase_      )
     yield CI_HUB_USER_TOKEN
     if previous_token is not None:
          HfFolder.save_token(lowerCAmelCase_      )



@pytest.fixture
def 							_A       (						lowerCAmelCase_					: Tuple      ):
     """simple docstring"""

     def _cleanup_repo(lowerCAmelCase_					: Optional[Any]      ):
          hf_api.delete_repo(lowerCAmelCase_       ,    token=lowerCAmelCase_       ,    repo_type="dataset"      )

     return _cleanup_repo



@pytest.fixture
def 							_A       (						lowerCAmelCase_					: Union[str, Any]      ):
     """simple docstring"""

     @contextmanager
     def _temporary_repo(lowerCAmelCase_					: str      ):
          try:
               yield repo_id
          finally:
               cleanup_repo(lowerCAmelCase_      )

     return _temporary_repo



@pytest.fixture(scope="session"      )
def 							_A       (						lowerCAmelCase_					: HfApi       ,    lowerCAmelCase_					: Union[str, Any]       ,    lowerCAmelCase_					: Any      ):
     """simple docstring"""

     lowerCAmelCase__          =			F'repo_txt_data-{int(time.time() * 1_0E3      )}'
     lowerCAmelCase__          =			F'{CI_HUB_USER}/{repo_name}'
     hf_api.create_repo(lowerCAmelCase_       ,    token=lowerCAmelCase_       ,    repo_type="dataset"       ,    private=lowerCAmelCase_      )
     hf_api.upload_file(
         token=lowerCAmelCase_       ,    path_or_fileobj=str(lowerCAmelCase_      )       ,    path_in_repo="data/text_data.txt"       ,    repo_id=lowerCAmelCase_       ,    repo_type="dataset"       ,    )
     yield repo_id
     try:
          hf_api.delete_repo(lowerCAmelCase_       ,    token=lowerCAmelCase_       ,    repo_type="dataset"      )
     except (requests.exceptions.HTTPError, ValueError):  # catch http error and token invalid error
          pass



@pytest.fixture()
def 							_A       (						lowerCAmelCase_					: Optional[Any]       ,    lowerCAmelCase_					: Optional[Any]       ,    lowerCAmelCase_					: int      ):
     """simple docstring"""

     return hf_private_dataset_repo_txt_data_



@pytest.fixture(scope="session"      )
def 							_A       (						lowerCAmelCase_					: HfApi       ,    lowerCAmelCase_					: Tuple       ,    lowerCAmelCase_					: Tuple      ):
     """simple docstring"""

     lowerCAmelCase__          =			F'repo_zipped_txt_data-{int(time.time() * 1_0E3      )}'
     lowerCAmelCase__          =			F'{CI_HUB_USER}/{repo_name}'
     hf_api.create_repo(lowerCAmelCase_       ,    token=lowerCAmelCase_       ,    repo_type="dataset"       ,    private=lowerCAmelCase_      )
     hf_api.upload_file(
         token=lowerCAmelCase_       ,    path_or_fileobj=str(lowerCAmelCase_      )       ,    path_in_repo="data.zip"       ,    repo_id=lowerCAmelCase_       ,    repo_type="dataset"       ,    )
     yield repo_id
     try:
          hf_api.delete_repo(lowerCAmelCase_       ,    token=lowerCAmelCase_       ,    repo_type="dataset"      )
     except (requests.exceptions.HTTPError, ValueError):  # catch http error and token invalid error
          pass



@pytest.fixture()
def 							_A       (						lowerCAmelCase_					: int       ,    lowerCAmelCase_					: List[str]       ,    lowerCAmelCase_					: Tuple      ):
     """simple docstring"""

     return hf_private_dataset_repo_zipped_txt_data_



@pytest.fixture(scope="session"      )
def 							_A       (						lowerCAmelCase_					: HfApi       ,    lowerCAmelCase_					: List[str]       ,    lowerCAmelCase_					: int      ):
     """simple docstring"""

     lowerCAmelCase__          =			F'repo_zipped_img_data-{int(time.time() * 1_0E3      )}'
     lowerCAmelCase__          =			F'{CI_HUB_USER}/{repo_name}'
     hf_api.create_repo(lowerCAmelCase_       ,    token=lowerCAmelCase_       ,    repo_type="dataset"       ,    private=lowerCAmelCase_      )
     hf_api.upload_file(
         token=lowerCAmelCase_       ,    path_or_fileobj=str(lowerCAmelCase_      )       ,    path_in_repo="data.zip"       ,    repo_id=lowerCAmelCase_       ,    repo_type="dataset"       ,    )
     yield repo_id
     try:
          hf_api.delete_repo(lowerCAmelCase_       ,    token=lowerCAmelCase_       ,    repo_type="dataset"      )
     except (requests.exceptions.HTTPError, ValueError):  # catch http error and token invalid error
          pass






@pytest.fixture()
def 							_A       (						lowerCAmelCase_					: Optional[Any]       ,    lowerCAmelCase_					: Dict       ,    lowerCAmelCase_					: List[str]      ):
     """simple docstring"""

     return hf_private_dataset_repo_zipped_img_data_
