





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			,  lowerCAmelCase_			,  lowerCAmelCase_=2			,  lowerCAmelCase_=3			,  lowerCAmelCase_=4			,  lowerCAmelCase_=2			,  lowerCAmelCase_=7			,  lowerCAmelCase_=True			,  lowerCAmelCase_=True			,  lowerCAmelCase_=True			,  lowerCAmelCase_=True			,  lowerCAmelCase_=99			,  lowerCAmelCase_=36			,  lowerCAmelCase_=3			,  lowerCAmelCase_=4			,  lowerCAmelCase_=37			,  lowerCAmelCase_="gelu"			,  lowerCAmelCase_=0.1			,  lowerCAmelCase_=0.1			,  lowerCAmelCase_=512			,  lowerCAmelCase_=16			,  lowerCAmelCase_=2			,  lowerCAmelCase_=0.02			,  lowerCAmelCase_=6			,  lowerCAmelCase_=6			,  lowerCAmelCase_=3			,  lowerCAmelCase_=4			,  lowerCAmelCase_=None			,  lowerCAmelCase_=1000			,  )						->							Tuple:
										_snake_case													=			parent
										_snake_case													=			batch_size
										_snake_case													=			num_channels
										_snake_case													=			image_size
										_snake_case													=			patch_size
										_snake_case													=			text_seq_length
										_snake_case													=			is_training
										_snake_case													=			use_input_mask
										_snake_case													=			use_token_type_ids
										_snake_case													=			use_labels
										_snake_case													=			vocab_size
										_snake_case													=			hidden_size
										_snake_case													=			num_hidden_layers
										_snake_case													=			num_attention_heads
										_snake_case													=			intermediate_size
										_snake_case													=			hidden_act
										_snake_case													=			hidden_dropout_prob
										_snake_case													=			attention_probs_dropout_prob
										_snake_case													=			max_position_embeddings
										_snake_case													=			type_vocab_size
										_snake_case													=			type_sequence_label_size
										_snake_case													=			initializer_range
										_snake_case													=			coordinate_size
										_snake_case													=			shape_size
										_snake_case													=			num_labels
										_snake_case													=			num_choices
										_snake_case													=			scope
										_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)
										_snake_case													=			text_seq_length
										_snake_case													=			(image_size // patch_size) ** 2 + 1
										_snake_case													=			self.text_seq_length + self.image_seq_length




					def 		lowerCAmelCase     (						self					)						->							Union[str, Any]:
										_snake_case													=			ids_tensor([self.batch_size, self.text_seq_length]			,  self.vocab_size					)

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

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

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

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

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

										_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			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_					)						->							List[str]:
										_snake_case													=			LayoutLMvaModel(config=lowerCAmelCase_					)
										model.to(lowerCAmelCase_					)
										model.eval()

										# text + image
										_snake_case													=			model(lowerCAmelCase_			,  pixel_values=lowerCAmelCase_					)
										_snake_case													=			model(
										    lowerCAmelCase_			,  bbox=lowerCAmelCase_			,  pixel_values=lowerCAmelCase_			,  attention_mask=lowerCAmelCase_			,  token_type_ids=lowerCAmelCase_					)
										_snake_case													=			model(lowerCAmelCase_			,  bbox=lowerCAmelCase_			,  pixel_values=lowerCAmelCase_			,  token_type_ids=lowerCAmelCase_					)
										_snake_case													=			model(lowerCAmelCase_			,  bbox=lowerCAmelCase_			,  pixel_values=lowerCAmelCase_					)

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

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

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




					def 		lowerCAmelCase     (						self			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_					)						->							str:
										_snake_case													=			self.num_labels
										_snake_case													=			LayoutLMvaForSequenceClassification(lowerCAmelCase_					)
										model.to(lowerCAmelCase_					)
										model.eval()
										_snake_case													=			model(
										    lowerCAmelCase_			,  bbox=lowerCAmelCase_			,  pixel_values=lowerCAmelCase_			,  attention_mask=lowerCAmelCase_			,  token_type_ids=lowerCAmelCase_			,  labels=lowerCAmelCase_			,  )
										self.parent.assertEqual(result.logits.shape			,  (self.batch_size, self.num_labels)					)




					def 		lowerCAmelCase     (						self			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_					)						->							Optional[Any]:
										_snake_case													=			self.num_labels
										_snake_case													=			LayoutLMvaForTokenClassification(config=lowerCAmelCase_					)
										model.to(lowerCAmelCase_					)
										model.eval()
										_snake_case													=			model(
										    lowerCAmelCase_			,  bbox=lowerCAmelCase_			,  pixel_values=lowerCAmelCase_			,  attention_mask=lowerCAmelCase_			,  token_type_ids=lowerCAmelCase_			,  labels=lowerCAmelCase_			,  )
										self.parent.assertEqual(result.logits.shape			,  (self.batch_size, self.text_seq_length, self.num_labels)					)




					def 		lowerCAmelCase     (						self			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_					)						->							Optional[int]:
										_snake_case													=			LayoutLMvaForQuestionAnswering(config=lowerCAmelCase_					)
										model.to(lowerCAmelCase_					)
										model.eval()
										_snake_case													=			model(
										    lowerCAmelCase_			,  bbox=lowerCAmelCase_			,  pixel_values=lowerCAmelCase_			,  attention_mask=lowerCAmelCase_			,  token_type_ids=lowerCAmelCase_			,  start_positions=lowerCAmelCase_			,  end_positions=lowerCAmelCase_			,  )
										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					)						->							Tuple:
										_snake_case													=			self.prepare_config_and_inputs()
										(
										    _snake_case      
										)													=			config_and_inputs
										_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      UpperCamelCase_						(					SCREAMING_SNAKE_CASE__							,					SCREAMING_SNAKE_CASE__							,					unittest.TestCase   ):
					lowerCAmelCase_							=		False
					lowerCAmelCase_							=		False
					lowerCAmelCase_							=		False

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




					def 		lowerCAmelCase     (						self			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_					)						->							List[str]:
										# `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					)						->							Dict:
										_snake_case													=			LayoutLMvaModelTester(self					)
										_snake_case													=			ConfigTester(self			,  config_class=lowerCAmelCase_			,  hidden_size=37					)




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

										return inputs_dict




					def 		lowerCAmelCase     (						self					)						->							Union[str, Any]:
										self.config_tester.run_common_tests()




					def 		lowerCAmelCase     (						self					)						->							List[str]:
										_snake_case													=			self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*lowerCAmelCase_					)




					def 		lowerCAmelCase     (						self					)						->							List[str]:
										_snake_case													=			self.model_tester.prepare_config_and_inputs()
										for type in ["absolute", "relative_key", "relative_key_query"]:
															_snake_case													=			type
															self.model_tester.create_and_check_model(*lowerCAmelCase_					)




					def 		lowerCAmelCase     (						self					)						->							Dict:
										_snake_case													=			self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_sequence_classification(*lowerCAmelCase_					)




					def 		lowerCAmelCase     (						self					)						->							Union[str, Any]:
										_snake_case													=			self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_token_classification(*lowerCAmelCase_					)




					def 		lowerCAmelCase     (						self					)						->							Union[str, Any]:
										_snake_case													=			self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_question_answering(*lowerCAmelCase_					)






					@slow
					def 		lowerCAmelCase     (						self					)						->							str:
										for model_name in LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
															_snake_case													=			LayoutLMvaModel.from_pretrained(lowerCAmelCase_					)
															self.assertIsNotNone(lowerCAmelCase_					)





def   lowerCamelCase__       (       )     ->	Optional[Any]:



					'''simple docstring'''




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




@require_torch
class      UpperCamelCase_						(					unittest.TestCase   ):




					@cached_property
					def 		lowerCAmelCase     (						self					)						->							Optional[Any]:
										return LayoutLMvaImageProcessor(apply_ocr=lowerCAmelCase_					) if is_vision_available() else None






					@slow
					def 		lowerCAmelCase     (						self					)						->							Optional[int]:
										_snake_case													=			LayoutLMvaModel.from_pretrained('microsoft/layoutlmv3-base'					).to(lowerCAmelCase_					)

										_snake_case													=			self.default_image_processor
										_snake_case													=			prepare_img()
										_snake_case													=			image_processor(images=lowerCAmelCase_			,  return_tensors='pt'					).pixel_values.to(lowerCAmelCase_					)

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

										# forward pass
										_snake_case													=			model(
										    input_ids=input_ids.to(lowerCAmelCase_					)			,  bbox=bbox.to(lowerCAmelCase_					)			,  pixel_values=pixel_values.to(lowerCAmelCase_					)			,  )

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

										_snake_case													=			torch.tensor(
										    [[-0.05_29, 0.36_18, 0.16_32], [-0.15_87, -0.16_67, -0.04_00], [-0.15_57, -0.16_71, -0.05_05]]					).to(lowerCAmelCase_					)

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










from collections.abc import Sequence





def   lowerCamelCase__       (       UpperCamelCase__     :    Sequence[float]    ,      UpperCamelCase__     :    bool = False  )     ->	float:



					'''simple docstring'''




					if not arr:
										return 0

					_snake_case													=			0 if allow_empty_subarrays else float('-inf'  )
					_snake_case													=			0.0
					for num in arr:
										_snake_case													=			max(0 if allow_empty_subarrays else num    ,      curr_sum + num  )
										_snake_case													=			max(UpperCamelCase__    ,      UpperCamelCase__  )

					return max_sum


if __name__ == "__main__":
					from doctest import testmod

					testmod()

					UpperCAmelCase_ 							=       [-2, 1, -3, 4, -1, 2, 1, -5, 4]
					print(F"{max_subarray_sum(nums) = }")



