



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    :



			def __init__(						self   :  Dict ,		A   :  int ,		A   :  Any=2 ,		A   :  Optional[int]=3 ,		A   :  List[str]=4 ,		A   :  Dict=2 ,		A   :  str=7 ,		A   :  Any=True ,		A   :  Dict=True ,		A   :  Union[str, Any]=True ,		A   :  Union[str, Any]=True ,		A   :  str=99 ,		A   :  Tuple=36 ,		A   :  List[Any]=3 ,		A   :  int=4 ,		A   :  Any=37 ,		A   :  str="gelu" ,		A   :  Optional[int]=0.1 ,		A   :  Optional[int]=0.1 ,		A   :  Union[str, Any]=5_12 ,		A   :  int=16 ,		A   :  Union[str, Any]=2 ,		A   :  int=0.0_2 ,		A   :  Dict=6 ,		A   :  Optional[Any]=6 ,		A   :  Union[str, Any]=3 ,		A   :  Optional[int]=4 ,		A   :  Tuple=None ,		A   :  Union[str, Any]=10_00 ,		)   ->    Dict:



						"""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     _lowerCamelCase       (						self   :  List[str])   ->    str:



						"""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     _lowerCamelCase       (						self   :  List[Any] ,		A   :  List[str] ,		A   :  Union[str, Any] ,		A   :  List[Any] ,		A   :  Optional[int] ,		A   :  List[Any] ,		A   :  Dict ,		A   :  Optional[Any] ,		A   :  int)   ->    Optional[int]:



						"""simple docstring"""






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

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

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

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

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



			def     _lowerCamelCase       (						self   :  Optional[int] ,		A   :  Union[str, Any] ,		A   :  Any ,		A   :  List[str] ,		A   :  str ,		A   :  Dict ,		A   :  Any ,		A   :  List[str] ,		A   :  Tuple)   ->    Optional[Any]:



						"""simple docstring"""






						_UpperCAmelCase		       =   self.num_labels
						_UpperCAmelCase		       =   LayoutLMvaForSequenceClassification(A)
						model.to(A)
						model.eval()
						_UpperCAmelCase		       =   model(
						    A ,		bbox=A ,		pixel_values=A ,		attention_mask=A ,		token_type_ids=A ,		labels=A ,		)
						self.parent.assertEqual(result.logits.shape ,		(self.batch_size, self.num_labels))



			def     _lowerCamelCase       (						self   :  Optional[Any] ,		A   :  Optional[Any] ,		A   :  Dict ,		A   :  Dict ,		A   :  Tuple ,		A   :  Optional[Any] ,		A   :  Optional[Any] ,		A   :  List[str] ,		A   :  Any)   ->    str:



						"""simple docstring"""






						_UpperCAmelCase		       =   self.num_labels
						_UpperCAmelCase		       =   LayoutLMvaForTokenClassification(config=A)
						model.to(A)
						model.eval()
						_UpperCAmelCase		       =   model(
						    A ,		bbox=A ,		pixel_values=A ,		attention_mask=A ,		token_type_ids=A ,		labels=A ,		)
						self.parent.assertEqual(result.logits.shape ,		(self.batch_size, self.text_seq_length, self.num_labels))



			def     _lowerCamelCase       (						self   :  List[Any] ,		A   :  Union[str, Any] ,		A   :  str ,		A   :  int ,		A   :  Optional[Any] ,		A   :  Tuple ,		A   :  Tuple ,		A   :  Dict ,		A   :  List[Any])   ->    Dict:



						"""simple docstring"""






						_UpperCAmelCase		       =   LayoutLMvaForQuestionAnswering(config=A)
						model.to(A)
						model.eval()
						_UpperCAmelCase		       =   model(
						    A ,		bbox=A ,		pixel_values=A ,		attention_mask=A ,		token_type_ids=A ,		start_positions=A ,		end_positions=A ,		)
						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   :  Union[str, Any])   ->    Any:



						"""simple docstring"""






						_UpperCAmelCase		       =   self.prepare_config_and_inputs()
						(
						    (
						    _UpperCAmelCase       
						)       ,     (
						    _UpperCAmelCase       
						)       ,     (
						    _UpperCAmelCase       
						)       ,     (
						    _UpperCAmelCase       
						)       ,     (
						    _UpperCAmelCase       
						)       ,     (
						    _UpperCAmelCase       
						)       ,     (
						    _UpperCAmelCase       
						)       ,     (
						    _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 			__lowerCAmelCase    (			snake_case_				,						snake_case_				,						unittest.TestCase						):
			UpperCamelCase   					=     False
			UpperCamelCase   					=     False
			UpperCamelCase   					=     False

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



			def     _lowerCamelCase       (						self   :  Optional[Any] ,		A   :  List[Any] ,		A   :  Tuple ,		A   :  Optional[int] ,		A   :  Optional[Any] ,		A   :  Optional[Any])   ->    int:



						"""simple docstring"""






						return True



			def     _lowerCamelCase       (						self   :  Optional[Any])   ->    Optional[Any]:



						"""simple docstring"""






						_UpperCAmelCase		       =   LayoutLMvaModelTester(self)
						_UpperCAmelCase		       =   ConfigTester(self ,		config_class=A ,		hidden_size=37)



			def     _lowerCamelCase       (						self   :  Optional[Any] ,		A   :  Any ,		A   :  Union[str, Any] ,		A   :  List[Any]=False)   ->    List[str]:



						"""simple docstring"""






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

						return inputs_dict



			def     _lowerCamelCase       (						self   :  Union[str, Any])   ->    Tuple:



						"""simple docstring"""






						self.config_tester.run_common_tests()



			def     _lowerCamelCase       (						self   :  Union[str, Any])   ->    Any:



						"""simple docstring"""






						_UpperCAmelCase		       =   self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*A)



			def     _lowerCamelCase       (						self   :  Any)   ->    str:



						"""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(*A)



			def     _lowerCamelCase       (						self   :  List[Any])   ->    Dict:



						"""simple docstring"""






						_UpperCAmelCase		       =   self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_sequence_classification(*A)



			def     _lowerCamelCase       (						self   :  Union[str, Any])   ->    str:



						"""simple docstring"""






						_UpperCAmelCase		       =   self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_token_classification(*A)



			def     _lowerCamelCase       (						self   :  Any)   ->    str:



						"""simple docstring"""






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



			@slow
			def     _lowerCamelCase       (						self   :  str)   ->    List[str]:



						"""simple docstring"""






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





def 							A	(     )				-> Dict:







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







@require_torch
class 			__lowerCAmelCase    (			unittest.TestCase						):



			@cached_property
			def     _lowerCamelCase       (						self   :  Optional[Any])   ->    List[str]:



						"""simple docstring"""






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



			@slow
			def     _lowerCamelCase       (						self   :  Optional[int])   ->    List[Any]:



						"""simple docstring"""






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

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

						_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(A) ,		bbox=bbox.to(A) ,		pixel_values=pixel_values.to(A) ,		)

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

						_UpperCAmelCase		       =   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(A)

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







'''simple docstring'''

import os

from huggingface_hub.constants import HUGGINGFACE_HUB_CACHE, hf_cache_home


lowercase_					= HUGGINGFACE_HUB_CACHE


lowercase_					= """config.json"""
lowercase_					= """diffusion_pytorch_model.bin"""
lowercase_					= """diffusion_flax_model.msgpack"""
lowercase_					= """model.onnx"""
lowercase_					= """diffusion_pytorch_model.safetensors"""
lowercase_					= """weights.pb"""
lowercase_					= """https://huggingface.co"""
lowercase_					= default_cache_path
lowercase_					= """diffusers_modules"""
lowercase_					= os.getenv("""HF_MODULES_CACHE""", os.path.join(hf_cache_home, """modules"""))
lowercase_					= ["""fp16""", """non-ema"""]
lowercase_					= """.self_attn"""



