



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



	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__=1_000					,			):
							A__					=  parent
							A__					=  batch_size
							A__					=  num_channels
							A__					=  image_size
							A__					=  patch_size
							A__					=  text_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__					=  coordinate_size
							A__					=  shape_size
							A__					=  num_labels
							A__					=  num_choices
							A__					=  scope
							A__					=  range_bbox

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



	def 					__A				(  self						):
							A__					=  ids_tensor([self.batch_size, self.text_seq_length]					,			self.vocab_size						)

							A__					=  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]:
																									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__					=  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

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

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

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

							# text + image
							A__					=  model(snake_case_					,			pixel_values=snake_case_						)
							A__					=  model(
							    snake_case_					,			bbox=snake_case_					,			pixel_values=snake_case_					,			attention_mask=snake_case_					,			token_type_ids=snake_case_						)
							A__					=  model(snake_case_					,			bbox=snake_case_					,			pixel_values=snake_case_					,			token_type_ids=snake_case_						)
							A__					=  model(snake_case_					,			bbox=snake_case_					,			pixel_values=snake_case_						)

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

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

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



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



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



	def 					__A				(  self					,			UpperCAmelCase__					,			UpperCAmelCase__					,			UpperCAmelCase__					,			UpperCAmelCase__					,			UpperCAmelCase__					,			UpperCAmelCase__					,			UpperCAmelCase__					,			UpperCAmelCase__						):
							A__					=  LayoutLMvaForQuestionAnswering(config=snake_case_						)
							model.to(snake_case_						)
							model.eval()
							A__					=  model(
							    snake_case_					,			bbox=snake_case_					,			pixel_values=snake_case_					,			attention_mask=snake_case_					,			token_type_ids=snake_case_					,			start_positions=snake_case_					,			end_positions=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						):
							A__					=  self.prepare_config_and_inputs()
							(
							    A__							
							)					=  config_and_inputs
							A__					=  {
							    """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       UpperCamelCase							(		_a  ,							_a  ,							unittest.TestCase      ):
	lowerCAmelCase			:       List[str]								=			False
	lowerCAmelCase			:       Optional[Any]								=			False
	lowerCAmelCase			:       Tuple								=			False

	lowerCAmelCase			:       Union[str, Any]								=			(
	    (
	        LayoutLMvaModel,
	        LayoutLMvaForSequenceClassification,
	        LayoutLMvaForTokenClassification,
	        LayoutLMvaForQuestionAnswering,
	    )
	    if is_torch_available()
	    else ()
	)
	lowerCAmelCase			:       List[Any]								=			(
	    {"""document-question-answering""": LayoutLMvaForQuestionAnswering, """feature-extraction""": LayoutLMvaModel}
	    if is_torch_available()
	    else {}
	)



	def 					__A				(  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 					__A				(  self						):
							A__					=  LayoutLMvaModelTester(self						)
							A__					=  ConfigTester(self					,			config_class=snake_case_					,			hidden_size=37						)



	def 					__A				(  self					,			UpperCAmelCase__					,			UpperCAmelCase__					,			UpperCAmelCase__=False						):
							A__					=  copy.deepcopy(snake_case_						)
							if model_class in get_values(snake_case_						):
													A__					=  {
													    k: v.unsqueeze(1						).expand(-1					,			self.model_tester.num_choices					,			-1						).contiguous()
													    if isinstance(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(snake_case_						):
																			A__					=  torch.ones(self.model_tester.batch_size					,			dtype=torch.long					,			device=snake_case_						)
													elif model_class in get_values(snake_case_						):
																			A__					=  torch.zeros(
																			    self.model_tester.batch_size					,			dtype=torch.long					,			device=snake_case_						)
																			A__					=  torch.zeros(
																			    self.model_tester.batch_size					,			dtype=torch.long					,			device=snake_case_						)
													elif model_class in [
													    *get_values(snake_case_						),
													]:
																			A__					=  torch.zeros(
																			    self.model_tester.batch_size					,			dtype=torch.long					,			device=snake_case_						)
													elif model_class in [
													    *get_values(snake_case_						),
													]:
																			A__					=  torch.zeros(
																			    (self.model_tester.batch_size, self.model_tester.text_seq_length)					,			dtype=torch.long					,			device=snake_case_					,			)

							return inputs_dict



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



	def 					__A				(  self						):
							A__					=  self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*snake_case_						)



	def 					__A				(  self						):
							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(*snake_case_						)



	def 					__A				(  self						):
							A__					=  self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_sequence_classification(*snake_case_						)



	def 					__A				(  self						):
							A__					=  self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_token_classification(*snake_case_						)



	def 					__A				(  self						):
							A__					=  self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_question_answering(*snake_case_						)



	@slow
	def 					__A				(  self						):
							for model_name in LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													A__					=  LayoutLMvaModel.from_pretrained(snake_case_						)
													self.assertIsNotNone(snake_case_						)





def    UpperCamelCase		(  )->  Optional[int]:





						"""simple docstring"""





						A__					=  Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"							)
						return image






@require_torch
class       UpperCamelCase							(		unittest.TestCase      ):



	@cached_property
	def 					__A				(  self						):
							return LayoutLMvaImageProcessor(apply_ocr=snake_case_						) if is_vision_available() else None



	@slow
	def 					__A				(  self						):
							A__					=  LayoutLMvaModel.from_pretrained("microsoft/layoutlmv3-base"						).to(snake_case_						)

							A__					=  self.default_image_processor
							A__					=  prepare_img()
							A__					=  image_processor(images=snake_case_					,			return_tensors="pt"						).pixel_values.to(snake_case_						)

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

							# forward pass
							A__					=  model(
							    input_ids=input_ids.to(snake_case_						)					,			bbox=bbox.to(snake_case_						)					,			pixel_values=pixel_values.to(snake_case_						)					,			)

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

							A__					=  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(snake_case_						)

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










'''simple docstring'''





# flake8: noqa
# Lint as: python3
__a  			=						[
    "VerificationMode",
    "Version",
    "disable_progress_bar",
    "enable_progress_bar",
    "is_progress_bar_enabled",
    "experimental",
]

from .info_utils import VerificationMode
from .logging import disable_progress_bar, enable_progress_bar, is_progress_bar_enabled
from .version import Version
from .experimental import experimental
