


import copy
import unittest

from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
		import torch

		from transformers import (
		    MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
		    MODEL_FOR_QUESTION_ANSWERING_MAPPING,
		    MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
		    MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
		    LayoutLMvaConfig,
		    LayoutLMvaForQuestionAnswering,
		    LayoutLMvaForSequenceClassification,
		    LayoutLMvaForTokenClassification,
		    LayoutLMvaModel,
		)
		from transformers.models.layoutlmva.modeling_layoutlmva import LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
		from PIL import Image

		from transformers import LayoutLMvaImageProcessor

class 		__a				:
		def __init__(      self      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE=2      ,   _SCREAMING_SNAKE_CASE=3      ,   _SCREAMING_SNAKE_CASE=4      ,   _SCREAMING_SNAKE_CASE=2      ,   _SCREAMING_SNAKE_CASE=7      ,   _SCREAMING_SNAKE_CASE=True      ,   _SCREAMING_SNAKE_CASE=True      ,   _SCREAMING_SNAKE_CASE=True      ,   _SCREAMING_SNAKE_CASE=True      ,   _SCREAMING_SNAKE_CASE=99      ,   _SCREAMING_SNAKE_CASE=36      ,   _SCREAMING_SNAKE_CASE=3      ,   _SCREAMING_SNAKE_CASE=4      ,   _SCREAMING_SNAKE_CASE=37      ,   _SCREAMING_SNAKE_CASE="gelu"      ,   _SCREAMING_SNAKE_CASE=0.1      ,   _SCREAMING_SNAKE_CASE=0.1      ,   _SCREAMING_SNAKE_CASE=512      ,   _SCREAMING_SNAKE_CASE=16      ,   _SCREAMING_SNAKE_CASE=2      ,   _SCREAMING_SNAKE_CASE=0.02      ,   _SCREAMING_SNAKE_CASE=6      ,   _SCREAMING_SNAKE_CASE=6      ,   _SCREAMING_SNAKE_CASE=3      ,   _SCREAMING_SNAKE_CASE=4      ,   _SCREAMING_SNAKE_CASE=None      ,   _SCREAMING_SNAKE_CASE=1000      ,   )			->	Optional[int]:




									"""simple docstring"""





									_UpperCAmelCase					=      parent
									_UpperCAmelCase					=      batch_size
									_UpperCAmelCase					=      num_channels
									_UpperCAmelCase					=      image_size
									_UpperCAmelCase					=      patch_size
									_UpperCAmelCase					=      text_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					=      coordinate_size
									_UpperCAmelCase					=      shape_size
									_UpperCAmelCase					=      num_labels
									_UpperCAmelCase					=      num_choices
									_UpperCAmelCase					=      scope
									_UpperCAmelCase					=      range_bbox

									# LayoutLMv3's sequence length equals the number of text tokens + number of patches + 1 (we add 1 for the CLS token)
									_UpperCAmelCase					=      text_seq_length
									_UpperCAmelCase					=      (image_size // patch_size) ** 2 + 1
									_UpperCAmelCase					=      self.text_seq_length + self.image_seq_length
		def      UpperCAmelCase__    (      self						)			->	Dict:




									"""simple docstring"""





									_UpperCAmelCase					=      ids_tensor([self.batch_size, self.text_seq_length]      ,   self.vocab_size						)

									_UpperCAmelCase					=      ids_tensor([self.batch_size, self.text_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					=      floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

									_UpperCAmelCase					=      None
									if self.use_input_mask:
																_UpperCAmelCase					=      random_attention_mask([self.batch_size, self.text_seq_length]						)

									_UpperCAmelCase					=      None
									if self.use_token_type_ids:
																_UpperCAmelCase					=      ids_tensor([self.batch_size, self.text_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.text_seq_length]      ,   self.num_labels						)

									_UpperCAmelCase					=      LayoutLMvaConfig(
									    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      ,   coordinate_size=self.coordinate_size      ,   shape_size=self.shape_size      ,   input_size=self.image_size      ,   patch_size=self.patch_size      ,   )

									return config, input_ids, bbox, pixel_values, token_type_ids, input_mask, sequence_labels, token_labels
		def      UpperCAmelCase__    (      self      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE						)			->	int:




									"""simple docstring"""





									_UpperCAmelCase					=      LayoutLMvaModel(config=SCREAMING_SNAKE_CASE_						)
									model.to(SCREAMING_SNAKE_CASE_						)
									model.eval()

									# text + image
									_UpperCAmelCase					=      model(SCREAMING_SNAKE_CASE_      ,   pixel_values=SCREAMING_SNAKE_CASE_						)
									_UpperCAmelCase					=      model(
									    SCREAMING_SNAKE_CASE_      ,   bbox=SCREAMING_SNAKE_CASE_      ,   pixel_values=SCREAMING_SNAKE_CASE_      ,   attention_mask=SCREAMING_SNAKE_CASE_      ,   token_type_ids=SCREAMING_SNAKE_CASE_						)
									_UpperCAmelCase					=      model(SCREAMING_SNAKE_CASE_      ,   bbox=SCREAMING_SNAKE_CASE_      ,   pixel_values=SCREAMING_SNAKE_CASE_      ,   token_type_ids=SCREAMING_SNAKE_CASE_						)
									_UpperCAmelCase					=      model(SCREAMING_SNAKE_CASE_      ,   bbox=SCREAMING_SNAKE_CASE_      ,   pixel_values=SCREAMING_SNAKE_CASE_						)

									self.parent.assertEqual(result.last_hidden_state.shape      ,   (self.batch_size, self.seq_length, self.hidden_size)						)

									# text only
									_UpperCAmelCase					=      model(SCREAMING_SNAKE_CASE_						)
									self.parent.assertEqual(
									    result.last_hidden_state.shape      ,   (self.batch_size, self.text_seq_length, self.hidden_size)						)

									# image only
									_UpperCAmelCase					=      model(pixel_values=SCREAMING_SNAKE_CASE_						)
									self.parent.assertEqual(
									    result.last_hidden_state.shape      ,   (self.batch_size, self.image_seq_length, self.hidden_size)						)
		def      UpperCAmelCase__    (      self      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE						)			->	Tuple:




									"""simple docstring"""





									_UpperCAmelCase					=      self.num_labels
									_UpperCAmelCase					=      LayoutLMvaForSequenceClassification(SCREAMING_SNAKE_CASE_						)
									model.to(SCREAMING_SNAKE_CASE_						)
									model.eval()
									_UpperCAmelCase					=      model(
									    SCREAMING_SNAKE_CASE_      ,   bbox=SCREAMING_SNAKE_CASE_      ,   pixel_values=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.num_labels)						)
		def      UpperCAmelCase__    (      self      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE						)			->	List[str]:




									"""simple docstring"""





									_UpperCAmelCase					=      self.num_labels
									_UpperCAmelCase					=      LayoutLMvaForTokenClassification(config=SCREAMING_SNAKE_CASE_						)
									model.to(SCREAMING_SNAKE_CASE_						)
									model.eval()
									_UpperCAmelCase					=      model(
									    SCREAMING_SNAKE_CASE_      ,   bbox=SCREAMING_SNAKE_CASE_      ,   pixel_values=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.text_seq_length, self.num_labels)						)
		def      UpperCAmelCase__    (      self      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE						)			->	Optional[int]:




									"""simple docstring"""





									_UpperCAmelCase					=      LayoutLMvaForQuestionAnswering(config=SCREAMING_SNAKE_CASE_						)
									model.to(SCREAMING_SNAKE_CASE_						)
									model.eval()
									_UpperCAmelCase					=      model(
									    SCREAMING_SNAKE_CASE_      ,   bbox=SCREAMING_SNAKE_CASE_      ,   pixel_values=SCREAMING_SNAKE_CASE_      ,   attention_mask=SCREAMING_SNAKE_CASE_      ,   token_type_ids=SCREAMING_SNAKE_CASE_      ,   start_positions=SCREAMING_SNAKE_CASE_      ,   end_positions=SCREAMING_SNAKE_CASE_      ,   )
									self.parent.assertEqual(result.start_logits.shape      ,   (self.batch_size, self.seq_length)						)
									self.parent.assertEqual(result.end_logits.shape      ,   (self.batch_size, self.seq_length)						)






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




									"""simple docstring"""





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



@require_torch
class 		__a				(    a__   ,				a__   ,				unittest.TestCase      ):
		_a     :  Any           =     False
		_a     :  List[str]           =     False
		_a     :  Union[str, Any]           =     False

		_a     :  str           =     (
		    (
		        LayoutLMvaModel,
		        LayoutLMvaForSequenceClassification,
		        LayoutLMvaForTokenClassification,
		        LayoutLMvaForQuestionAnswering,
		    )
		    if is_torch_available()
		    else ()
		)
		_a     :  Tuple           =     (
		    {"document-question-answering": LayoutLMvaForQuestionAnswering, "feature-extraction": LayoutLMvaModel}
		    if is_torch_available()
		    else {}
		)
		def      UpperCAmelCase__    (      self      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE						)			->	List[Any]:




									"""simple docstring"""





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




									"""simple docstring"""





									_UpperCAmelCase					=      LayoutLMvaModelTester(self						)
									_UpperCAmelCase					=      ConfigTester(self      ,   config_class=SCREAMING_SNAKE_CASE_      ,   hidden_size=37						)
		def      UpperCAmelCase__    (      self      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE      ,   _SCREAMING_SNAKE_CASE=False						)			->	str:




									"""simple docstring"""





									_UpperCAmelCase					=      copy.deepcopy(SCREAMING_SNAKE_CASE_						)
									if model_class in get_values(SCREAMING_SNAKE_CASE_						):
																_UpperCAmelCase					=      {
																    k: v.unsqueeze(1						).expand(-1      ,   self.model_tester.num_choices      ,   -1						).contiguous()
																    if isinstance(SCREAMING_SNAKE_CASE_      ,   torch.Tensor						) and v.ndim > 1
																    else v
																    for k, v in inputs_dict.items()
																}
									if return_labels:
																if model_class in get_values(SCREAMING_SNAKE_CASE_						):
																							_UpperCAmelCase					=      torch.ones(self.model_tester.batch_size      ,   dtype=torch.long      ,   device=SCREAMING_SNAKE_CASE_						)
																elif model_class in get_values(SCREAMING_SNAKE_CASE_						):
																							_UpperCAmelCase					=      torch.zeros(
																							    self.model_tester.batch_size      ,   dtype=torch.long      ,   device=SCREAMING_SNAKE_CASE_						)
																							_UpperCAmelCase					=      torch.zeros(
																							    self.model_tester.batch_size      ,   dtype=torch.long      ,   device=SCREAMING_SNAKE_CASE_						)
																elif model_class in [
																    *get_values(SCREAMING_SNAKE_CASE_						),
																]:
																							_UpperCAmelCase					=      torch.zeros(
																							    self.model_tester.batch_size      ,   dtype=torch.long      ,   device=SCREAMING_SNAKE_CASE_						)
																elif model_class in [
																    *get_values(SCREAMING_SNAKE_CASE_						),
																]:
																							_UpperCAmelCase					=      torch.zeros(
																							    (self.model_tester.batch_size, self.model_tester.text_seq_length)      ,   dtype=torch.long      ,   device=SCREAMING_SNAKE_CASE_      ,   )

									return inputs_dict
		def      UpperCAmelCase__    (      self						)			->	Tuple:




									"""simple docstring"""





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




									"""simple docstring"""





									_UpperCAmelCase					=      self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE_						)
		def      UpperCAmelCase__    (      self						)			->	Optional[int]:




									"""simple docstring"""





									_UpperCAmelCase					=      self.model_tester.prepare_config_and_inputs()
									for type in ["absolute", "relative_key", "relative_key_query"]:
																_UpperCAmelCase					=      type
																self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE_						)
		def      UpperCAmelCase__    (      self						)			->	Tuple:




									"""simple docstring"""





									_UpperCAmelCase					=      self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_sequence_classification(*SCREAMING_SNAKE_CASE_						)
		def      UpperCAmelCase__    (      self						)			->	Optional[Any]:




									"""simple docstring"""





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




									"""simple docstring"""





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






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




									"""simple docstring"""





									for model_name in LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																_UpperCAmelCase					=      LayoutLMvaModel.from_pretrained(SCREAMING_SNAKE_CASE_						)
																self.assertIsNotNone(SCREAMING_SNAKE_CASE_						)



def 	lowerCAmelCase__			(      )  ->		Dict:


							'''simple docstring'''





							_UpperCAmelCase					=      Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'	)
							return image







@require_torch
class 		__a				(    unittest.TestCase      ):
		@cached_property
		def      UpperCAmelCase__    (      self						)			->	str:




									"""simple docstring"""





									return LayoutLMvaImageProcessor(apply_ocr=SCREAMING_SNAKE_CASE_						) if is_vision_available() else None






		@slow
		def      UpperCAmelCase__    (      self						)			->	Optional[int]:




									"""simple docstring"""





									_UpperCAmelCase					=      LayoutLMvaModel.from_pretrained('microsoft/layoutlmv3-base'						).to(SCREAMING_SNAKE_CASE_						)

									_UpperCAmelCase					=      self.default_image_processor
									_UpperCAmelCase					=      prepare_img()
									_UpperCAmelCase					=      image_processor(images=SCREAMING_SNAKE_CASE_      ,   return_tensors='pt'						).pixel_values.to(SCREAMING_SNAKE_CASE_						)

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

									# forward pass
									_UpperCAmelCase					=      model(
									    input_ids=input_ids.to(SCREAMING_SNAKE_CASE_						)      ,   bbox=bbox.to(SCREAMING_SNAKE_CASE_						)      ,   pixel_values=pixel_values.to(SCREAMING_SNAKE_CASE_						)      ,   )

									# verify the logits
									_UpperCAmelCase					=      torch.Size((1, 199, 768)						)
									self.assertEqual(outputs.last_hidden_state.shape      ,   SCREAMING_SNAKE_CASE_						)

									_UpperCAmelCase					=      torch.tensor(
									    [[-0.0529, 0.3618, 0.1632], [-0.1587, -0.1667, -0.0400], [-0.1557, -0.1671, -0.0505]]						).to(SCREAMING_SNAKE_CASE_						)

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




from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


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

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

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

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

else:
		import sys

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