


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





				"""simple docstring"""







				def __init__(						self       ,		UpperCAmelCase__       ,		UpperCAmelCase__=2       ,		UpperCAmelCase__=3       ,		UpperCAmelCase__=4       ,		UpperCAmelCase__=2       ,		UpperCAmelCase__=7       ,		UpperCAmelCase__=True       ,		UpperCAmelCase__=True       ,		UpperCAmelCase__=True       ,		UpperCAmelCase__=True       ,		UpperCAmelCase__=99       ,		UpperCAmelCase__=36       ,		UpperCAmelCase__=3       ,		UpperCAmelCase__=4       ,		UpperCAmelCase__=37       ,		UpperCAmelCase__="gelu"       ,		UpperCAmelCase__=0.1       ,		UpperCAmelCase__=0.1       ,		UpperCAmelCase__=512       ,		UpperCAmelCase__=16       ,		UpperCAmelCase__=2       ,		UpperCAmelCase__=0.02       ,		UpperCAmelCase__=6       ,		UpperCAmelCase__=6       ,		UpperCAmelCase__=3       ,		UpperCAmelCase__=4       ,		UpperCAmelCase__=None       ,		UpperCAmelCase__=1000       ,		):
								SCREAMING_SNAKE_CASE__     							=				parent
								SCREAMING_SNAKE_CASE__     							=				batch_size
								SCREAMING_SNAKE_CASE__     							=				num_channels
								SCREAMING_SNAKE_CASE__     							=				image_size
								SCREAMING_SNAKE_CASE__     							=				patch_size
								SCREAMING_SNAKE_CASE__     							=				text_seq_length
								SCREAMING_SNAKE_CASE__     							=				is_training
								SCREAMING_SNAKE_CASE__     							=				use_input_mask
								SCREAMING_SNAKE_CASE__     							=				use_token_type_ids
								SCREAMING_SNAKE_CASE__     							=				use_labels
								SCREAMING_SNAKE_CASE__     							=				vocab_size
								SCREAMING_SNAKE_CASE__     							=				hidden_size
								SCREAMING_SNAKE_CASE__     							=				num_hidden_layers
								SCREAMING_SNAKE_CASE__     							=				num_attention_heads
								SCREAMING_SNAKE_CASE__     							=				intermediate_size
								SCREAMING_SNAKE_CASE__     							=				hidden_act
								SCREAMING_SNAKE_CASE__     							=				hidden_dropout_prob
								SCREAMING_SNAKE_CASE__     							=				attention_probs_dropout_prob
								SCREAMING_SNAKE_CASE__     							=				max_position_embeddings
								SCREAMING_SNAKE_CASE__     							=				type_vocab_size
								SCREAMING_SNAKE_CASE__     							=				type_sequence_label_size
								SCREAMING_SNAKE_CASE__     							=				initializer_range
								SCREAMING_SNAKE_CASE__     							=				coordinate_size
								SCREAMING_SNAKE_CASE__     							=				shape_size
								SCREAMING_SNAKE_CASE__     							=				num_labels
								SCREAMING_SNAKE_CASE__     							=				num_choices
								SCREAMING_SNAKE_CASE__     							=				scope
								SCREAMING_SNAKE_CASE__     							=				range_bbox

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



				def   lowerCAmelCase__		(						self     ):
								SCREAMING_SNAKE_CASE__     							=				ids_tensor([self.batch_size, self.text_seq_length]       ,		self.vocab_size     )

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

								SCREAMING_SNAKE_CASE__     							=				floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]     )

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

								SCREAMING_SNAKE_CASE__     							=				None
								if self.use_token_type_ids:
												SCREAMING_SNAKE_CASE__     							=				ids_tensor([self.batch_size, self.text_seq_length]       ,		self.type_vocab_size     )

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

								SCREAMING_SNAKE_CASE__     							=				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   lowerCAmelCase__		(						self       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__     ):
								SCREAMING_SNAKE_CASE__     							=				LayoutLMvaModel(config=UpperCAmelCase__     )
								model.to(UpperCAmelCase__     )
								model.eval()

								# text + image
								SCREAMING_SNAKE_CASE__     							=				model(UpperCAmelCase__       ,		pixel_values=UpperCAmelCase__     )
								SCREAMING_SNAKE_CASE__     							=				model(
								    UpperCAmelCase__       ,		bbox=UpperCAmelCase__       ,		pixel_values=UpperCAmelCase__       ,		attention_mask=UpperCAmelCase__       ,		token_type_ids=UpperCAmelCase__     )
								SCREAMING_SNAKE_CASE__     							=				model(UpperCAmelCase__       ,		bbox=UpperCAmelCase__       ,		pixel_values=UpperCAmelCase__       ,		token_type_ids=UpperCAmelCase__     )
								SCREAMING_SNAKE_CASE__     							=				model(UpperCAmelCase__       ,		bbox=UpperCAmelCase__       ,		pixel_values=UpperCAmelCase__     )

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

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

								# image only
								SCREAMING_SNAKE_CASE__     							=				model(pixel_values=UpperCAmelCase__     )
								self.parent.assertEqual(
								    result.last_hidden_state.shape       ,		(self.batch_size, self.image_seq_length, self.hidden_size)     )



				def   lowerCAmelCase__		(						self       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__     ):
								SCREAMING_SNAKE_CASE__     							=				self.num_labels
								SCREAMING_SNAKE_CASE__     							=				LayoutLMvaForSequenceClassification(UpperCAmelCase__     )
								model.to(UpperCAmelCase__     )
								model.eval()
								SCREAMING_SNAKE_CASE__     							=				model(
								    UpperCAmelCase__       ,		bbox=UpperCAmelCase__       ,		pixel_values=UpperCAmelCase__       ,		attention_mask=UpperCAmelCase__       ,		token_type_ids=UpperCAmelCase__       ,		labels=UpperCAmelCase__       ,		)
								self.parent.assertEqual(result.logits.shape       ,		(self.batch_size, self.num_labels)     )



				def   lowerCAmelCase__		(						self       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__     ):
								SCREAMING_SNAKE_CASE__     							=				self.num_labels
								SCREAMING_SNAKE_CASE__     							=				LayoutLMvaForTokenClassification(config=UpperCAmelCase__     )
								model.to(UpperCAmelCase__     )
								model.eval()
								SCREAMING_SNAKE_CASE__     							=				model(
								    UpperCAmelCase__       ,		bbox=UpperCAmelCase__       ,		pixel_values=UpperCAmelCase__       ,		attention_mask=UpperCAmelCase__       ,		token_type_ids=UpperCAmelCase__       ,		labels=UpperCAmelCase__       ,		)
								self.parent.assertEqual(result.logits.shape       ,		(self.batch_size, self.text_seq_length, self.num_labels)     )



				def   lowerCAmelCase__		(						self       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__     ):
								SCREAMING_SNAKE_CASE__     							=				LayoutLMvaForQuestionAnswering(config=UpperCAmelCase__     )
								model.to(UpperCAmelCase__     )
								model.eval()
								SCREAMING_SNAKE_CASE__     							=				model(
								    UpperCAmelCase__       ,		bbox=UpperCAmelCase__       ,		pixel_values=UpperCAmelCase__       ,		attention_mask=UpperCAmelCase__       ,		token_type_ids=UpperCAmelCase__       ,		start_positions=UpperCAmelCase__       ,		end_positions=UpperCAmelCase__       ,		)
								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   lowerCAmelCase__		(						self     ):
								SCREAMING_SNAKE_CASE__     							=				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__      
								)							,      (
								    SCREAMING_SNAKE_CASE__      
								)							,            
								)     							=				config_and_inputs
								SCREAMING_SNAKE_CASE__     							=				{
								    "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 			lowerCamelCase_		(			lowercase       ,  lowercase       ,  unittest.TestCase   ):





				"""simple docstring"""







				_lowerCAmelCase      :      List[Any]      							=					False
				_lowerCAmelCase      :      Dict      							=					False
				_lowerCAmelCase      :      Optional[Any]      							=					False

				_lowerCAmelCase      :      Any      							=					(
				    (
				        LayoutLMvaModel,
				        LayoutLMvaForSequenceClassification,
				        LayoutLMvaForTokenClassification,
				        LayoutLMvaForQuestionAnswering,
				    )
				    if is_torch_available()
				    else ()
				)
				_lowerCAmelCase      :      Any      							=					(
				    {"document-question-answering": LayoutLMvaForQuestionAnswering, "feature-extraction": LayoutLMvaModel}
				    if is_torch_available()
				    else {}
				)



				def   lowerCAmelCase__		(						self       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__     ):
								# `DocumentQuestionAnsweringPipeline` is expected to work with this model, but it combines the text and visual
								# embedding along the sequence dimension (dim 1), which causes an error during post-processing as `p_mask` has
								# the sequence dimension of the text embedding only.
								# (see the line `embedding_output = torch.cat([embedding_output, visual_embeddings], dim=1)`)
								return True



				def   lowerCAmelCase__		(						self     ):
								SCREAMING_SNAKE_CASE__     							=				LayoutLMvaModelTester(self     )
								SCREAMING_SNAKE_CASE__     							=				ConfigTester(self       ,		config_class=UpperCAmelCase__       ,		hidden_size=37     )



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

								return inputs_dict



				def   lowerCAmelCase__		(						self     ):
								self.config_tester.run_common_tests()



				def   lowerCAmelCase__		(						self     ):
								SCREAMING_SNAKE_CASE__     							=				self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*UpperCAmelCase__     )



				def   lowerCAmelCase__		(						self     ):
								SCREAMING_SNAKE_CASE__     							=				self.model_tester.prepare_config_and_inputs()
								for type in ["absolute", "relative_key", "relative_key_query"]:
												SCREAMING_SNAKE_CASE__     							=				type
												self.model_tester.create_and_check_model(*UpperCAmelCase__     )



				def   lowerCAmelCase__		(						self     ):
								SCREAMING_SNAKE_CASE__     							=				self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_sequence_classification(*UpperCAmelCase__     )



				def   lowerCAmelCase__		(						self     ):
								SCREAMING_SNAKE_CASE__     							=				self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_token_classification(*UpperCAmelCase__     )



				def   lowerCAmelCase__		(						self     ):
								SCREAMING_SNAKE_CASE__     							=				self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_question_answering(*UpperCAmelCase__     )






				@slow
				def   lowerCAmelCase__		(						self     ):
								for model_name in LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
												SCREAMING_SNAKE_CASE__     							=				LayoutLMvaModel.from_pretrained(UpperCAmelCase__     )
												self.assertIsNotNone(UpperCAmelCase__     )


def __lowercase     (      ):
				SCREAMING_SNAKE_CASE__     							=				Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"  )
				return image


@require_torch
class 			lowerCamelCase_		(			unittest.TestCase   ):





				"""simple docstring"""







				@cached_property
				def   lowerCAmelCase__		(						self     ):
								return LayoutLMvaImageProcessor(apply_ocr=UpperCAmelCase__     ) if is_vision_available() else None






				@slow
				def   lowerCAmelCase__		(						self     ):
								SCREAMING_SNAKE_CASE__     							=				LayoutLMvaModel.from_pretrained("microsoft/layoutlmv3-base"     ).to(UpperCAmelCase__     )

								SCREAMING_SNAKE_CASE__     							=				self.default_image_processor
								SCREAMING_SNAKE_CASE__     							=				prepare_img()
								SCREAMING_SNAKE_CASE__     							=				image_processor(images=UpperCAmelCase__       ,		return_tensors="pt"     ).pixel_values.to(UpperCAmelCase__     )

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

								# forward pass
								SCREAMING_SNAKE_CASE__     							=				model(
								    input_ids=input_ids.to(UpperCAmelCase__     )       ,		bbox=bbox.to(UpperCAmelCase__     )       ,		pixel_values=pixel_values.to(UpperCAmelCase__     )       ,		)

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

								SCREAMING_SNAKE_CASE__     							=				torch.tensor(
								    [[-0.0_529, 0.3_618, 0.1_632], [-0.1_587, -0.1_667, -0.0_400], [-0.1_557, -0.1_671, -0.0_505]]     ).to(UpperCAmelCase__     )

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




"""simple docstring"""






from transformers import BertTokenizerFast

from .custom_tokenization import CustomTokenizer


class 			lowerCamelCase_		(			lowercase   ):





				"""simple docstring"""







				_lowerCAmelCase      :      List[Any]      							=					CustomTokenizer
				pass
