



'''simple docstring'''

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







				"""simple docstring"""



				def __init__(self       ,			__lowercase       ,			__lowercase=2       ,			__lowercase=3       ,			__lowercase=4       ,			__lowercase=2       ,			__lowercase=7       ,			__lowercase=True       ,			__lowercase=True       ,			__lowercase=True       ,			__lowercase=True       ,			__lowercase=99       ,			__lowercase=36       ,			__lowercase=3       ,			__lowercase=4       ,			__lowercase=37       ,			__lowercase="gelu"       ,			__lowercase=0.1       ,			__lowercase=0.1       ,			__lowercase=5_12       ,			__lowercase=16       ,			__lowercase=2       ,			__lowercase=0.0_2       ,			__lowercase=6       ,			__lowercase=6       ,			__lowercase=3       ,			__lowercase=4       ,			__lowercase=None       ,			__lowercase=10_00       ,			):
										__lowerCAmelCase							       =				parent
										__lowerCAmelCase							       =				batch_size
										__lowerCAmelCase							       =				num_channels
										__lowerCAmelCase							       =				image_size
										__lowerCAmelCase							       =				patch_size
										__lowerCAmelCase							       =				text_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							       =				coordinate_size
										__lowerCAmelCase							       =				shape_size
										__lowerCAmelCase							       =				num_labels
										__lowerCAmelCase							       =				num_choices
										__lowerCAmelCase							       =				scope
										__lowerCAmelCase							       =				range_bbox

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




				def 					_snake_case  (self		):
										__lowerCAmelCase							       =				ids_tensor([self.batch_size, self.text_seq_length]       ,			self.vocab_size		)

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

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

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

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

										# text + image
										__lowerCAmelCase							       =				model(UpperCAmelCase__       ,			pixel_values=UpperCAmelCase__		)
										__lowerCAmelCase							       =				model(
										    UpperCAmelCase__       ,			bbox=UpperCAmelCase__       ,			pixel_values=UpperCAmelCase__       ,			attention_mask=UpperCAmelCase__       ,			token_type_ids=UpperCAmelCase__		)
										__lowerCAmelCase							       =				model(UpperCAmelCase__       ,			bbox=UpperCAmelCase__       ,			pixel_values=UpperCAmelCase__       ,			token_type_ids=UpperCAmelCase__		)
										__lowerCAmelCase							       =				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
										__lowerCAmelCase							       =				model(UpperCAmelCase__		)
										self.parent.assertEqual(
										    result.last_hidden_state.shape       ,			(self.batch_size, self.text_seq_length, self.hidden_size)		)

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




				def 					_snake_case  (self       ,			__lowercase       ,			__lowercase       ,			__lowercase       ,			__lowercase       ,			__lowercase       ,			__lowercase       ,			__lowercase       ,			__lowercase		):
										__lowerCAmelCase							       =				self.num_labels
										__lowerCAmelCase							       =				LayoutLMvaForSequenceClassification(UpperCAmelCase__		)
										model.to(UpperCAmelCase__		)
										model.eval()
										__lowerCAmelCase							       =				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 					_snake_case  (self       ,			__lowercase       ,			__lowercase       ,			__lowercase       ,			__lowercase       ,			__lowercase       ,			__lowercase       ,			__lowercase       ,			__lowercase		):
										__lowerCAmelCase							       =				self.num_labels
										__lowerCAmelCase							       =				LayoutLMvaForTokenClassification(config=UpperCAmelCase__		)
										model.to(UpperCAmelCase__		)
										model.eval()
										__lowerCAmelCase							       =				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 					_snake_case  (self       ,			__lowercase       ,			__lowercase       ,			__lowercase       ,			__lowercase       ,			__lowercase       ,			__lowercase       ,			__lowercase       ,			__lowercase		):
										__lowerCAmelCase							       =				LayoutLMvaForQuestionAnswering(config=UpperCAmelCase__		)
										model.to(UpperCAmelCase__		)
										model.eval()
										__lowerCAmelCase							       =				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 					_snake_case  (self		):
										__lowerCAmelCase							       =				self.prepare_config_and_inputs()
										(
										    __lowerCAmelCase  
										)							       =				config_and_inputs
										__lowerCAmelCase							       =				{
										    '''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__				( lowercase__							,						lowercase__							,						unittest.TestCase      ):







				"""simple docstring"""



				__UpperCamelCase    :		Optional[int]	=	False
				__UpperCamelCase    :		List[Any]	=	False
				__UpperCamelCase    :		Dict	=	False

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




				def 					_snake_case  (self       ,			__lowercase       ,			__lowercase       ,			__lowercase       ,			__lowercase       ,			__lowercase		):
										return True




				def 					_snake_case  (self		):
										__lowerCAmelCase							       =				LayoutLMvaModelTester(self		)
										__lowerCAmelCase							       =				ConfigTester(self       ,			config_class=UpperCAmelCase__       ,			hidden_size=37		)




				def 					_snake_case  (self       ,			__lowercase       ,			__lowercase       ,			__lowercase=False		):
										__lowerCAmelCase							       =				copy.deepcopy(UpperCAmelCase__		)
										if model_class in get_values(UpperCAmelCase__		):
																__lowerCAmelCase							       =				{
																    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__		):
																						__lowerCAmelCase							       =				torch.ones(self.model_tester.batch_size       ,			dtype=torch.long       ,			device=UpperCAmelCase__		)
																elif model_class in get_values(UpperCAmelCase__		):
																						__lowerCAmelCase							       =				torch.zeros(
																						    self.model_tester.batch_size       ,			dtype=torch.long       ,			device=UpperCAmelCase__		)
																						__lowerCAmelCase							       =				torch.zeros(
																						    self.model_tester.batch_size       ,			dtype=torch.long       ,			device=UpperCAmelCase__		)
																elif model_class in [
																    *get_values(UpperCAmelCase__		),
																]:
																						__lowerCAmelCase							       =				torch.zeros(
																						    self.model_tester.batch_size       ,			dtype=torch.long       ,			device=UpperCAmelCase__		)
																elif model_class in [
																    *get_values(UpperCAmelCase__		),
																]:
																						__lowerCAmelCase							       =				torch.zeros(
																						    (self.model_tester.batch_size, self.model_tester.text_seq_length)       ,			dtype=torch.long       ,			device=UpperCAmelCase__       ,			)

										return inputs_dict




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




				def 					_snake_case  (self		):
										__lowerCAmelCase							       =				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*UpperCAmelCase__		)




				def 					_snake_case  (self		):
										__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(*UpperCAmelCase__		)




				def 					_snake_case  (self		):
										__lowerCAmelCase							       =				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_sequence_classification(*UpperCAmelCase__		)




				def 					_snake_case  (self		):
										__lowerCAmelCase							       =				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_token_classification(*UpperCAmelCase__		)




				def 					_snake_case  (self		):
										__lowerCAmelCase							       =				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_question_answering(*UpperCAmelCase__		)




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

def 							__magic_name__(						):
						__lowerCAmelCase							       =				Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''')
						return image




@require_torch
class       a__				( unittest.TestCase      ):







				"""simple docstring"""



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




				@slow
				def 					_snake_case  (self		):
										__lowerCAmelCase							       =				LayoutLMvaModel.from_pretrained('''microsoft/layoutlmv3-base'''		).to(UpperCAmelCase__		)

										__lowerCAmelCase							       =				self.default_image_processor
										__lowerCAmelCase							       =				prepare_img()
										__lowerCAmelCase							       =				image_processor(images=UpperCAmelCase__       ,			return_tensors='''pt'''		).pixel_values.to(UpperCAmelCase__		)

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

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

										# verify the logits
										__lowerCAmelCase							       =				torch.Size((1, 1_99, 7_68)		)
										self.assertEqual(outputs.last_hidden_state.shape       ,			UpperCAmelCase__		)

										__lowerCAmelCase							       =				torch.tensor(
										    [[-0.0_5_2_9, 0.3_6_1_8, 0.1_6_3_2], [-0.1_5_8_7, -0.1_6_6_7, -0.0_4_0_0], [-0.1_5_5_7, -0.1_6_7_1, -0.0_5_0_5]]		).to(UpperCAmelCase__		)

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





'''simple docstring'''

import sys

from .dependency_versions_table import deps
from .utils.versions import require_version, require_version_core


# define which module versions we always want to check at run time
# (usually the ones defined in `install_requires` in setup.py)
#
# order specific notes:
# - tqdm must be checked before tokenizers

_UpperCAmelCase				: Tuple							    =				"""python tqdm regex requests packaging filelock numpy tokenizers""".split()
if sys.version_info < (3, 7):
	pkgs_to_check_at_runtime.append("""dataclasses""")
if sys.version_info < (3, 8):
	pkgs_to_check_at_runtime.append("""importlib_metadata""")

for pkg in pkgs_to_check_at_runtime:
	if pkg in deps:
		if pkg == "tokenizers":
			# must be loaded here, or else tqdm check may fail
			from .utils import is_tokenizers_available

			if not is_tokenizers_available():
				continue  # not required, check version only if installed

		require_version_core(deps[pkg])
	else:
		raise ValueError(f"""can't find {pkg} in {deps.keys()}, check dependency_versions_table.py""")

def 							__magic_name__(						lowerCamelCase,				lowerCamelCase=None):
						require_version(deps[pkg],				lowerCamelCase)

