





from __future__ import annotations

import copy
import inspect
import unittest

import numpy as np

from transformers import is_tf_available, is_vision_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_tf, slow
from transformers.utils import cached_property

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
					import tensorflow as tf

					from transformers import (
					    TF_LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST,
					    TF_MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
					    TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
					    TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
					    TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
					    LayoutLMvaConfig,
					    TFLayoutLMvaForQuestionAnswering,
					    TFLayoutLMvaForSequenceClassification,
					    TFLayoutLMvaForTokenClassification,
					    TFLayoutLMvaModel,
					)

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_=2			,  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			,  )						->							List[str]:
										_snake_case													=			parent
										_snake_case													=			batch_size
										_snake_case													=			num_channels
										_snake_case													=			image_size
										_snake_case													=			patch_size
										_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					)						->							List[str]:
										_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					)
										_snake_case													=			bbox.numpy()
										# 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													=			tmp_coordinate
																				if bbox[i, j, 2] < bbox[i, j, 0]:
																									_snake_case													=			bbox[i, j, 2]
																									_snake_case													=			bbox[i, j, 0]
																									_snake_case													=			tmp_coordinate
										_snake_case													=			tf.constant(__lowercase					)

										_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_					)						->							int:
										_snake_case													=			TFLayoutLMvaModel(config=__lowercase					)

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

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

										# text only
										_snake_case													=			model(__lowercase			,  training=__lowercase					)
										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': pixel_values}			,  training=__lowercase					)
										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_					)						->							Tuple:
										_snake_case													=			self.num_labels
										_snake_case													=			TFLayoutLMvaForSequenceClassification(config=__lowercase					)
										_snake_case													=			model(
										    __lowercase			,  bbox=__lowercase			,  pixel_values=__lowercase			,  attention_mask=__lowercase			,  token_type_ids=__lowercase			,  labels=__lowercase			,  training=__lowercase			,  )
										self.parent.assertEqual(result.logits.shape			,  (self.batch_size, self.num_labels)					)




					def 		lowerCAmelCase     (						self			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_					)						->							Optional[Any]:
										_snake_case													=			self.num_labels
										_snake_case													=			TFLayoutLMvaForTokenClassification(config=__lowercase					)
										_snake_case													=			model(
										    __lowercase			,  bbox=__lowercase			,  pixel_values=__lowercase			,  attention_mask=__lowercase			,  token_type_ids=__lowercase			,  labels=__lowercase			,  training=__lowercase			,  )
										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_					)						->							Union[str, Any]:
										_snake_case													=			2
										_snake_case													=			TFLayoutLMvaForQuestionAnswering(config=__lowercase					)
										_snake_case													=			model(
										    __lowercase			,  bbox=__lowercase			,  pixel_values=__lowercase			,  attention_mask=__lowercase			,  token_type_ids=__lowercase			,  start_positions=__lowercase			,  end_positions=__lowercase			,  training=__lowercase			,  )
										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					)						->							Dict:
										_snake_case													=			self.prepare_config_and_inputs()
										((_snake_case)							,       (_snake_case)							,       (_snake_case)							,       (_snake_case)							,       (_snake_case)							,       (_snake_case)							,       (_snake_case)							,       (_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_tf
class      UpperCamelCase_						(					__A							,					__A							,					unittest.TestCase   ):
					lowerCAmelCase_							=		(
					    (
					        TFLayoutLMvaModel,
					        TFLayoutLMvaForQuestionAnswering,
					        TFLayoutLMvaForSequenceClassification,
					        TFLayoutLMvaForTokenClassification,
					    )
					    if is_tf_available()
					    else ()
					)
					lowerCAmelCase_							=		(
					    {'document-question-answering': TFLayoutLMvaForQuestionAnswering, 'feature-extraction': TFLayoutLMvaModel}
					    if is_tf_available()
					    else {}
					)

					lowerCAmelCase_							=		False
					lowerCAmelCase_							=		False
					lowerCAmelCase_							=		False




					def 		lowerCAmelCase     (						self			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_					)						->							Optional[int]:
										return True




					def 		lowerCAmelCase     (						self			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_=False					)						->							Union[str, Any]:
										_snake_case													=			copy.deepcopy(__lowercase					)

										if model_class in get_values(__lowercase					):
															_snake_case													=			{
															    k: tf.tile(tf.expand_dims(__lowercase			,  1					)			,  (1, self.model_tester.num_choices) + (1,) * (v.ndim - 1)					)
															    if isinstance(__lowercase			,  tf.Tensor					) and v.ndim > 0
															    else v
															    for k, v in inputs_dict.items()
															}

										if return_labels:
															if model_class in get_values(__lowercase					):
																				_snake_case													=			tf.ones(self.model_tester.batch_size			,  dtype=tf.intaa					)
															elif model_class in get_values(__lowercase					):
																				_snake_case													=			tf.zeros(self.model_tester.batch_size			,  dtype=tf.intaa					)
																				_snake_case													=			tf.zeros(self.model_tester.batch_size			,  dtype=tf.intaa					)
															elif model_class in get_values(__lowercase					):
																				_snake_case													=			tf.zeros(self.model_tester.batch_size			,  dtype=tf.intaa					)
															elif model_class in get_values(__lowercase					):
																				_snake_case													=			tf.zeros(
																				    (self.model_tester.batch_size, self.model_tester.text_seq_length)			,  dtype=tf.intaa					)

										return inputs_dict




					def 		lowerCAmelCase     (						self					)						->							Optional[Any]:
										_snake_case													=			TFLayoutLMvaModelTester(self					)
										_snake_case													=			ConfigTester(self			,  config_class=__lowercase			,  hidden_size=37					)




					def 		lowerCAmelCase     (						self					)						->							Tuple:
										self.config_tester.run_common_tests()




					def 		lowerCAmelCase     (						self					)						->							str:
										_snake_case							,       _snake_case													=			self.model_tester.prepare_config_and_inputs_for_common()
										for model_class in self.all_model_classes:
															_snake_case													=			model_class(__lowercase					)
															if getattr(__lowercase			,  'hf_compute_loss'			,  __lowercase					):
																				# The number of elements in the loss should be the same as the number of elements in the label
																				_snake_case													=			self._prepare_for_class(inputs_dict.copy()			,  __lowercase			,  return_labels=__lowercase					)
																				_snake_case													=			prepared_for_class[
																				    sorted(prepared_for_class.keys() - inputs_dict.keys()			,  reverse=__lowercase					)[0]
																				]
																				_snake_case													=			added_label.shape.as_list()[:1]

																				# Test that model correctly compute the loss with kwargs
																				_snake_case													=			self._prepare_for_class(inputs_dict.copy()			,  __lowercase			,  return_labels=__lowercase					)
																				_snake_case													=			prepared_for_class.pop('input_ids'					)

																				_snake_case													=			model(__lowercase			,  **__lowercase					)[0]
																				self.assertTrue(loss.shape.as_list() == expected_loss_size or loss.shape.as_list() == [1]					)

																				# Test that model correctly compute the loss when we mask some positions
																				_snake_case													=			self._prepare_for_class(inputs_dict.copy()			,  __lowercase			,  return_labels=__lowercase					)
																				_snake_case													=			prepared_for_class.pop('input_ids'					)
																				if "labels" in prepared_for_class:
																									_snake_case													=			prepared_for_class['labels'].numpy()
																									if len(labels.shape					) > 1 and labels.shape[1] != 1:
																														_snake_case													=			-100
																														_snake_case													=			tf.convert_to_tensor(__lowercase					)
																														_snake_case													=			model(__lowercase			,  **__lowercase					)[0]
																														self.assertTrue(loss.shape.as_list() == expected_loss_size or loss.shape.as_list() == [1]					)
																														self.assertTrue(not np.any(np.isnan(loss.numpy()					)					)					)

                # Test that model correctly compute the loss with a dict
																				_snake_case													=			self._prepare_for_class(inputs_dict.copy()			,  __lowercase			,  return_labels=__lowercase					)
																				_snake_case													=			model(__lowercase					)[0]
																				self.assertTrue(loss.shape.as_list() == expected_loss_size or loss.shape.as_list() == [1]					)

																				# Test that model correctly compute the loss with a tuple
																				_snake_case													=			self._prepare_for_class(inputs_dict.copy()			,  __lowercase			,  return_labels=__lowercase					)

																				# Get keys that were added with the _prepare_for_class function
																				_snake_case													=			prepared_for_class.keys() - inputs_dict.keys()
																				_snake_case													=			inspect.signature(model.call					).parameters
																				_snake_case													=			list(signature.keys()					)

																				# Create a dictionary holding the location of the tensors in the tuple
																				_snake_case													=			{0: 'input_ids'}
																				for label_key in label_keys:
																									_snake_case													=			signature_names.index(__lowercase					)
																									_snake_case													=			label_key
																				_snake_case													=			sorted(tuple_index_mapping.items()					)
																				# Initialize a list with their default values, update the values and convert to a tuple
																				_snake_case													=			[]

																				for name in signature_names:
																									if name != "kwargs":
																														list_input.append(signature[name].default					)

																				for index, value in sorted_tuple_index_mapping:
																									_snake_case													=			prepared_for_class[value]

																				_snake_case													=			tuple(__lowercase					)

																				# Send to model
																				_snake_case													=			model(tuple_input[:-1]					)[0]

																				self.assertTrue(loss.shape.as_list() == expected_loss_size or loss.shape.as_list() == [1]					)




					def 		lowerCAmelCase     (						self					)						->							str:
										(
										    (
										    _snake_case   
										)							,       (
										    _snake_case   
										)							,       (
										    _snake_case   
										)							,       (
										    _snake_case   
										)							,       (
										    _snake_case   
										)							,       (
										    _snake_case   
										)							,       (
										    _snake_case   
										)							,       (
										    _snake_case   
										)							,          
										)													=			self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(__lowercase			,  __lowercase			,  __lowercase			,  __lowercase			,  __lowercase			,  __lowercase					)




					def 		lowerCAmelCase     (						self					)						->							Dict:
										(
										    (
										    _snake_case   
										)							,       (
										    _snake_case   
										)							,       (
										    _snake_case   
										)							,       (
										    _snake_case   
										)							,       (
										    _snake_case   
										)							,       (
										    _snake_case   
										)							,       (
										    _snake_case   
										)							,       (
										    _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(__lowercase			,  __lowercase			,  __lowercase			,  __lowercase			,  __lowercase			,  __lowercase					)




					def 		lowerCAmelCase     (						self					)						->							Dict:
										(
										    (
										    _snake_case   
										)							,       (
										    _snake_case   
										)							,       (
										    _snake_case   
										)							,       (
										    _snake_case   
										)							,       (
										    _snake_case   
										)							,       (
										    _snake_case   
										)							,       (
										    _snake_case   
										)							,       (
										    _snake_case   
										)							,          
										)													=			self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_sequence_classification(
										    __lowercase			,  __lowercase			,  __lowercase			,  __lowercase			,  __lowercase			,  __lowercase			,  __lowercase					)




					def 		lowerCAmelCase     (						self					)						->							List[Any]:
										(
										    (
										    _snake_case   
										)							,       (
										    _snake_case   
										)							,       (
										    _snake_case   
										)							,       (
										    _snake_case   
										)							,       (
										    _snake_case   
										)							,       (
										    _snake_case   
										)							,       (
										    _snake_case   
										)							,       (
										    _snake_case   
										)							,          
										)													=			self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_token_classification(
										    __lowercase			,  __lowercase			,  __lowercase			,  __lowercase			,  __lowercase			,  __lowercase			,  __lowercase					)




					def 		lowerCAmelCase     (						self					)						->							List[str]:
										(
										    (
										    _snake_case   
										)							,       (
										    _snake_case   
										)							,       (
										    _snake_case   
										)							,       (
										    _snake_case   
										)							,       (
										    _snake_case   
										)							,       (
										    _snake_case   
										)							,       (
										    _snake_case   
										)							,       (
										    _snake_case   
										)							,          
										)													=			self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_question_answering(
										    __lowercase			,  __lowercase			,  __lowercase			,  __lowercase			,  __lowercase			,  __lowercase			,  __lowercase					)






					@slow
					def 		lowerCAmelCase     (						self					)						->							Dict:
										for model_name in TF_LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
															_snake_case													=			TFLayoutLMvaModel.from_pretrained(__lowercase					)
															self.assertIsNotNone(__lowercase					)





def   lowerCamelCase__       (       )     ->	Optional[Any]:



					'''simple docstring'''




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




@require_tf
class      UpperCamelCase_						(					unittest.TestCase   ):




					@cached_property
					def 		lowerCAmelCase     (						self					)						->							str:
										return LayoutLMvaImageProcessor(apply_ocr=__lowercase					) if is_vision_available() else None






					@slow
					def 		lowerCAmelCase     (						self					)						->							List[str]:
										_snake_case													=			TFLayoutLMvaModel.from_pretrained('microsoft/layoutlmv3-base'					)

										_snake_case													=			self.default_image_processor
										_snake_case													=			prepare_img()
										_snake_case													=			image_processor(images=__lowercase			,  return_tensors='tf'					).pixel_values

										_snake_case													=			tf.constant([[1, 2]]					)
										_snake_case													=			tf.expand_dims(tf.constant([[1, 2, 3, 4], [5, 6, 7, 8]]					)			,  axis=0					)

										# forward pass
										_snake_case													=			model(input_ids=__lowercase			,  bbox=__lowercase			,  pixel_values=__lowercase			,  training=__lowercase					)

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

										_snake_case													=			tf.constant(
										    [[-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]]					)

										self.assertTrue(np.allclose(outputs.last_hidden_state[0, :3, :3]			,  __lowercase			,  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) = }")



