
from __future__ import annotations

from random import random
from typing import Generic, TypeVar

UpperCamelCase_   	=	TypeVar("KT")
UpperCamelCase_   	=	TypeVar("VT")

class       a		(   Generic[KT, VT]					):







							def __init__(						self  :  Optional[Any]      ,				snake_case__  :  KT | str = "root"      ,				snake_case__  :  VT | None = None ):
								"""simple docstring"""







								__lowerCAmelCase         =							key
								__lowerCAmelCase         =							value
								__lowerCAmelCase         =							[]







							def __repr__(						self  :  Tuple ):
								"""simple docstring"""







								return F"Node({self.key}: {self.value})"







							@property
							def       UpperCAmelCase__					(						self  :  str ):
								"""simple docstring"""







								return len(self.forward )

class       a		(   Generic[KT, VT]					):







							def __init__(						self  :  str      ,				snake_case__  :  float = 0.5      ,				snake_case__  :  int = 16 ):
								"""simple docstring"""







								__lowerCAmelCase         =							Node[KT, VT]()
								__lowerCAmelCase         =							0
								__lowerCAmelCase         =							p
								__lowerCAmelCase         =							max_level







							def __str__(						self  :  Any ):
								"""simple docstring"""







								__lowerCAmelCase         =							list(self )

								if len(snake_case__ ) == 0:
									return F"SkipList(level={self.level})"

								__lowerCAmelCase         =							max((len(str(snake_case__ ) ) for item in items)      ,				default=4 )
								__lowerCAmelCase         =							max(snake_case__      ,				4 ) + 4

								__lowerCAmelCase         =							self.head
								__lowerCAmelCase         =							[]

								__lowerCAmelCase         =							node.forward.copy()
								lines.append(F"[{node.key}]".ljust(snake_case__      ,				"-" ) + "* " * len(snake_case__ ) )
								lines.append(" " * label_size + "| " * len(snake_case__ ) )

								while len(node.forward ) != 0:
									__lowerCAmelCase         =							node.forward[0]

									lines.append(
									    F"[{node.key}]".ljust(snake_case__      ,				"-" )
									    + " ".join(str(n.key ) if n.key == node.key else "|" for n in forwards ) )
									lines.append(" " * label_size + "| " * len(snake_case__ ) )
									__lowerCAmelCase         =							node.forward

								lines.append("None".ljust(snake_case__ ) + "* " * len(snake_case__ ) )
								return F"SkipList(level={self.level})\n" + "\n".join(snake_case__ )







							def __iter__(						self  :  List[Any] ):
								"""simple docstring"""







								__lowerCAmelCase         =							self.head

								while len(node.forward ) != 0:
									yield node.forward[0].key
									__lowerCAmelCase         =							node.forward[0]







							def       UpperCAmelCase__					(						self  :  Optional[int] ):
								"""simple docstring"""







								__lowerCAmelCase         =							1
								while random() < self.p and level < self.max_level:
									level += 1

								return level







							def       UpperCAmelCase__					(						self  :  List[Any]      ,				snake_case__  :  int ):
								"""simple docstring"""







								__lowerCAmelCase         =							[]

								__lowerCAmelCase         =							self.head

								for i in reversed(range(self.level ) ):
									# i < node.level - When node level is lesser than `i` decrement `i`.
									# node.forward[i].key < key - Jumping to node with key value higher
									#                             or equal to searched key would result
									#                             in skipping searched key.
									while i < node.level and node.forward[i].key < key:
										__lowerCAmelCase         =							node.forward[i]
									# Each leftmost node (relative to searched node) will potentially have to
									# be updated.
									update_vector.append(snake_case__ )

								update_vector.reverse()  # Note that we were inserting values in reverse order.

								# len(node.forward) != 0 - If current node doesn't contain any further
								#                          references then searched key is not present.
								# node.forward[0].key == key - Next node key should be equal to search key
								#                              if key is present.
								if len(node.forward ) != 0 and node.forward[0].key == key:
									return node.forward[0], update_vector
								else:
									return None, update_vector







							def       UpperCAmelCase__					(						self  :  List[str]      ,				snake_case__  :  KT ):
								"""simple docstring"""







								__lowerCAmelCase   ,						__lowerCAmelCase         =							self._locate_node(snake_case__ )

								if node is not None:
									for i, update_node in enumerate(snake_case__ ):
										# Remove or replace all references to removed node.
										if update_node.level > i and update_node.forward[i].key == key:
											if node.level > i:
												__lowerCAmelCase         =							node.forward[i]
											else:
												__lowerCAmelCase         =							update_node.forward[:i]







							def       UpperCAmelCase__					(						self  :  Optional[int]      ,				snake_case__  :  KT      ,				snake_case__  :  VT ):
								"""simple docstring"""







								__lowerCAmelCase   ,						__lowerCAmelCase         =							self._locate_node(snake_case__ )
								if node is not None:
									__lowerCAmelCase         =							value
								else:
									__lowerCAmelCase         =							self.random_level()

									if level > self.level:
										# After level increase we have to add additional nodes to head.
										for _ in range(self.level - 1      ,				snake_case__ ):
											update_vector.append(self.head )
										__lowerCAmelCase         =							level

									__lowerCAmelCase         =							Node(snake_case__      ,				snake_case__ )

									for i, update_node in enumerate(update_vector[:level] ):
										# Change references to pass through new node.
										if update_node.level > i:
											new_node.forward.append(update_node.forward[i] )

										if update_node.level < i + 1:
											update_node.forward.append(snake_case__ )
										else:
											__lowerCAmelCase         =							new_node







							def       UpperCAmelCase__					(						self  :  str      ,				snake_case__  :  VT ):
								"""simple docstring"""







								__lowerCAmelCase   ,						__lowerCAmelCase         =							self._locate_node(snake_case__ )

								if node is not None:
									return node.value

								return None






def 		_UpperCAmelCase   (	):






	"""simple docstring"""


	__lowerCAmelCase         =							SkipList()
	skip_list.insert("Key1"			,							3  )
	skip_list.insert("Key2"			,							1_2  )
	skip_list.insert("Key3"			,							4_1  )
	skip_list.insert("Key4"			,							-1_9  )

	__lowerCAmelCase         =							skip_list.head
	__lowerCAmelCase         =							{}
	while node.level != 0:
		__lowerCAmelCase         =							node.forward[0]
		__lowerCAmelCase         =							node.value

	assert len(UpperCamelCase  ) == 4
	assert all_values["Key1"] == 3
	assert all_values["Key2"] == 1_2
	assert all_values["Key3"] == 4_1
	assert all_values["Key4"] == -1_9






def 		_UpperCAmelCase   (	):






	"""simple docstring"""


	__lowerCAmelCase         =							SkipList()
	skip_list.insert("Key1"			,							1_0  )
	skip_list.insert("Key1"			,							1_2  )

	skip_list.insert("Key5"			,							7  )
	skip_list.insert("Key7"			,							1_0  )
	skip_list.insert("Key10"			,							5  )

	skip_list.insert("Key7"			,							7  )
	skip_list.insert("Key5"			,							5  )
	skip_list.insert("Key10"			,							1_0  )

	__lowerCAmelCase         =							skip_list.head
	__lowerCAmelCase         =							{}
	while node.level != 0:
		__lowerCAmelCase         =							node.forward[0]
		__lowerCAmelCase         =							node.value

	if len(UpperCamelCase  ) != 4:
		print()
	assert len(UpperCamelCase  ) == 4
	assert all_values["Key1"] == 1_2
	assert all_values["Key7"] == 7
	assert all_values["Key5"] == 5
	assert all_values["Key10"] == 1_0






def 		_UpperCAmelCase   (	):






	"""simple docstring"""


	__lowerCAmelCase         =							SkipList()
	assert skip_list.find("Some key"  ) is None






def 		_UpperCAmelCase   (	):






	"""simple docstring"""


	__lowerCAmelCase         =							SkipList()

	skip_list.insert("Key2"			,							2_0  )
	assert skip_list.find("Key2"  ) == 2_0

	skip_list.insert("Some Key"			,							1_0  )
	skip_list.insert("Key2"			,							8  )
	skip_list.insert("V"			,							1_3  )

	assert skip_list.find("Y"  ) is None
	assert skip_list.find("Key2"  ) == 8
	assert skip_list.find("Some Key"  ) == 1_0
	assert skip_list.find("V"  ) == 1_3






def 		_UpperCAmelCase   (	):






	"""simple docstring"""


	__lowerCAmelCase         =							SkipList()
	skip_list.delete("Some key"  )

	assert len(skip_list.head.forward  ) == 0






def 		_UpperCAmelCase   (	):






	"""simple docstring"""


	__lowerCAmelCase         =							SkipList()

	skip_list.insert("Key1"			,							1_2  )
	skip_list.insert("V"			,							1_3  )
	skip_list.insert("X"			,							1_4  )
	skip_list.insert("Key2"			,							1_5  )

	skip_list.delete("V"  )
	skip_list.delete("Key2"  )

	assert skip_list.find("V"  ) is None
	assert skip_list.find("Key2"  ) is None






def 		_UpperCAmelCase   (	):






	"""simple docstring"""


	__lowerCAmelCase         =							SkipList()

	skip_list.insert("Key1"			,							1_2  )
	skip_list.insert("V"			,							1_3  )
	skip_list.insert("X"			,							1_4  )
	skip_list.insert("Key2"			,							1_5  )

	skip_list.delete("V"  )
	assert skip_list.find("V"  ) is None
	assert skip_list.find("X"  ) == 1_4
	assert skip_list.find("Key1"  ) == 1_2
	assert skip_list.find("Key2"  ) == 1_5

	skip_list.delete("X"  )
	assert skip_list.find("V"  ) is None
	assert skip_list.find("X"  ) is None
	assert skip_list.find("Key1"  ) == 1_2
	assert skip_list.find("Key2"  ) == 1_5

	skip_list.delete("Key1"  )
	assert skip_list.find("V"  ) is None
	assert skip_list.find("X"  ) is None
	assert skip_list.find("Key1"  ) is None
	assert skip_list.find("Key2"  ) == 1_5

	skip_list.delete("Key2"  )
	assert skip_list.find("V"  ) is None
	assert skip_list.find("X"  ) is None
	assert skip_list.find("Key1"  ) is None
	assert skip_list.find("Key2"  ) is None






def 		_UpperCAmelCase   (	):






	"""simple docstring"""


	__lowerCAmelCase         =							SkipList()

	skip_list.insert("Key1"			,							1_2  )
	skip_list.insert("V"			,							1_3  )
	skip_list.insert("X"			,							1_4_2  )
	skip_list.insert("Key2"			,							1_5  )

	skip_list.delete("X"  )

	def traverse_keys(UpperCamelCase:     Union[str, Any]  ):
		yield node.key
		for forward_node in node.forward:
			yield from traverse_keys(UpperCamelCase  )

	assert len(set(traverse_keys(skip_list.head  )  )  ) == 4






def 		_UpperCAmelCase   (	):






	"""simple docstring"""


	def is_sorted(UpperCamelCase:     Union[str, Any]  ):
		return all(next_item >= item for item, next_item in zip(UpperCamelCase			,							lst[1:]  )  )

	__lowerCAmelCase         =							SkipList()
	for i in range(1_0  ):
		skip_list.insert(UpperCamelCase			,							UpperCamelCase  )
	assert is_sorted(list(UpperCamelCase  )  )
	skip_list.delete(5  )
	skip_list.delete(8  )
	skip_list.delete(2  )
	assert is_sorted(list(UpperCamelCase  )  )
	skip_list.insert(-1_2			,							-1_2  )
	skip_list.insert(7_7			,							7_7  )
	assert is_sorted(list(UpperCamelCase  )  )






def 		_UpperCAmelCase   (	):






	"""simple docstring"""


	for _ in range(1_0_0  ):
		# Repeat test 100 times due to the probabilistic nature of skip list
		# random values == random bugs
		test_insert()
		test_insert_overrides_existing_value()

		test_searching_empty_list_returns_none()
		test_search()

		test_deleting_item_from_empty_list_do_nothing()
		test_deleted_items_are_not_founded_by_find_method()
		test_delete_removes_only_given_key()
		test_delete_doesnt_leave_dead_nodes()

		test_iter_always_yields_sorted_values()






def 		_UpperCAmelCase   (	):






	"""simple docstring"""


	__lowerCAmelCase         =							SkipList()
	skip_list.insert(2			,							"2"  )
	skip_list.insert(4			,							"4"  )
	skip_list.insert(6			,							"4"  )
	skip_list.insert(4			,							"5"  )
	skip_list.insert(8			,							"4"  )
	skip_list.insert(9			,							"4"  )

	skip_list.delete(4  )

	print(UpperCamelCase  )


if __name__ == "__main__":
					import doctest

					doctest.testmod()
					main()








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







							def __init__(						self  :  Optional[int]      ,				snake_case__  :  Optional[Any]      ,				snake_case__  :  Optional[Any]=2      ,				snake_case__  :  Any=3      ,				snake_case__  :  str=4      ,				snake_case__  :  Tuple=2      ,				snake_case__  :  Optional[Any]=7      ,				snake_case__  :  int=True      ,				snake_case__  :  Dict=True      ,				snake_case__  :  int=True      ,				snake_case__  :  List[Any]=True      ,				snake_case__  :  Union[str, Any]=99      ,				snake_case__  :  str=36      ,				snake_case__  :  Tuple=2      ,				snake_case__  :  Optional[int]=4      ,				snake_case__  :  Optional[Any]=37      ,				snake_case__  :  int="gelu"      ,				snake_case__  :  List[Any]=0.1      ,				snake_case__  :  int=0.1      ,				snake_case__  :  Optional[Any]=512      ,				snake_case__  :  Union[str, Any]=16      ,				snake_case__  :  Optional[int]=2      ,				snake_case__  :  Any=0.0_2      ,				snake_case__  :  List[str]=6      ,				snake_case__  :  Optional[int]=6      ,				snake_case__  :  Any=3      ,				snake_case__  :  str=4      ,				snake_case__  :  int=None      ,				snake_case__  :  Any=1_000      ,				):
								"""simple docstring"""







								__lowerCAmelCase         =							parent
								__lowerCAmelCase         =							batch_size
								__lowerCAmelCase         =							num_channels
								__lowerCAmelCase         =							image_size
								__lowerCAmelCase         =							patch_size
								__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       UpperCAmelCase__					(						self  :  Tuple ):
								"""simple docstring"""







								__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 )
								__lowerCAmelCase         =							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]:
											__lowerCAmelCase         =							bbox[i, j, 3]
											__lowerCAmelCase         =							bbox[i, j, 1]
											__lowerCAmelCase         =							tmp_coordinate
										if bbox[i, j, 2] < bbox[i, j, 0]:
											__lowerCAmelCase         =							bbox[i, j, 2]
											__lowerCAmelCase         =							bbox[i, j, 0]
											__lowerCAmelCase         =							tmp_coordinate
								__lowerCAmelCase         =							tf.constant(snake_case__ )

								__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       UpperCAmelCase__					(						self  :  List[Any]      ,				snake_case__  :  Union[str, Any]      ,				snake_case__  :  Tuple      ,				snake_case__  :  Tuple      ,				snake_case__  :  Optional[int]      ,				snake_case__  :  Any      ,				snake_case__  :  Tuple ):
								"""simple docstring"""







								__lowerCAmelCase         =							TFLayoutLMvaModel(config=snake_case__ )

								# text + image
								__lowerCAmelCase         =							model(snake_case__      ,				pixel_values=snake_case__      ,				training=snake_case__ )
								__lowerCAmelCase         =							model(
								    snake_case__      ,				bbox=snake_case__      ,				pixel_values=snake_case__      ,				attention_mask=snake_case__      ,				token_type_ids=snake_case__      ,				training=snake_case__      ,				)
								__lowerCAmelCase         =							model(snake_case__      ,				bbox=snake_case__      ,				pixel_values=snake_case__      ,				training=snake_case__ )

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

								# text only
								__lowerCAmelCase         =							model(snake_case__      ,				training=snake_case__ )
								self.parent.assertEqual(
								    result.last_hidden_state.shape      ,				(self.batch_size, self.text_seq_length, self.hidden_size) )

								# image only
								__lowerCAmelCase         =							model({"pixel_values": pixel_values}      ,				training=snake_case__ )
								self.parent.assertEqual(
								    result.last_hidden_state.shape      ,				(self.batch_size, self.image_seq_length, self.hidden_size) )







							def       UpperCAmelCase__					(						self  :  Tuple      ,				snake_case__  :  Optional[int]      ,				snake_case__  :  str      ,				snake_case__  :  List[Any]      ,				snake_case__  :  str      ,				snake_case__  :  Any      ,				snake_case__  :  Tuple      ,				snake_case__  :  Optional[int] ):
								"""simple docstring"""







								__lowerCAmelCase         =							self.num_labels
								__lowerCAmelCase         =							TFLayoutLMvaForSequenceClassification(config=snake_case__ )
								__lowerCAmelCase         =							model(
								    snake_case__      ,				bbox=snake_case__      ,				pixel_values=snake_case__      ,				attention_mask=snake_case__      ,				token_type_ids=snake_case__      ,				labels=snake_case__      ,				training=snake_case__      ,				)
								self.parent.assertEqual(result.logits.shape      ,				(self.batch_size, self.num_labels) )







							def       UpperCAmelCase__					(						self  :  Optional[int]      ,				snake_case__  :  Dict      ,				snake_case__  :  Any      ,				snake_case__  :  Optional[Any]      ,				snake_case__  :  int      ,				snake_case__  :  str      ,				snake_case__  :  Any      ,				snake_case__  :  Tuple ):
								"""simple docstring"""







								__lowerCAmelCase         =							self.num_labels
								__lowerCAmelCase         =							TFLayoutLMvaForTokenClassification(config=snake_case__ )
								__lowerCAmelCase         =							model(
								    snake_case__      ,				bbox=snake_case__      ,				pixel_values=snake_case__      ,				attention_mask=snake_case__      ,				token_type_ids=snake_case__      ,				labels=snake_case__      ,				training=snake_case__      ,				)
								self.parent.assertEqual(result.logits.shape      ,				(self.batch_size, self.text_seq_length, self.num_labels) )







							def       UpperCAmelCase__					(						self  :  Tuple      ,				snake_case__  :  str      ,				snake_case__  :  Optional[int]      ,				snake_case__  :  Any      ,				snake_case__  :  Any      ,				snake_case__  :  Dict      ,				snake_case__  :  Dict      ,				snake_case__  :  Optional[Any] ):
								"""simple docstring"""







								__lowerCAmelCase         =							2
								__lowerCAmelCase         =							TFLayoutLMvaForQuestionAnswering(config=snake_case__ )
								__lowerCAmelCase         =							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__      ,				training=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       UpperCAmelCase__					(						self  :  Optional[Any] ):
								"""simple docstring"""







								__lowerCAmelCase         =							self.prepare_config_and_inputs()
								((__lowerCAmelCase)   ,						(__lowerCAmelCase)   ,						(__lowerCAmelCase)   ,						(__lowerCAmelCase)   ,						(__lowerCAmelCase)   ,						(__lowerCAmelCase)   ,						(__lowerCAmelCase)   ,						(__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_tf
class       a		(   __UpperCAmelCase      ,	__UpperCAmelCase      ,	unittest.TestCase					):
							lowercase_		:						List[Any]   							=  (
							    (
							        TFLayoutLMvaModel,
							        TFLayoutLMvaForQuestionAnswering,
							        TFLayoutLMvaForSequenceClassification,
							        TFLayoutLMvaForTokenClassification,
							    )
							    if is_tf_available()
							    else ()
							)
							lowercase_		:						Optional[int]   							=  (
							    {'document-question-answering': TFLayoutLMvaForQuestionAnswering, 'feature-extraction': TFLayoutLMvaModel}
							    if is_tf_available()
							    else {}
							)

							lowercase_		:						Dict   							=  False
							lowercase_		:						str   							=  False
							lowercase_		:						Any   							=  False







							def       UpperCAmelCase__					(						self  :  Optional[Any]      ,				snake_case__  :  Tuple      ,				snake_case__  :  Optional[int]      ,				snake_case__  :  Optional[int]      ,				snake_case__  :  Any      ,				snake_case__  :  int ):
								"""simple docstring"""







								return True







							def       UpperCAmelCase__					(						self  :  Optional[int]      ,				snake_case__  :  Tuple      ,				snake_case__  :  Union[str, Any]      ,				snake_case__  :  Tuple=False ):
								"""simple docstring"""







								__lowerCAmelCase         =							copy.deepcopy(snake_case__ )

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

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

								return inputs_dict







							def       UpperCAmelCase__					(						self  :  Tuple ):
								"""simple docstring"""







								__lowerCAmelCase         =							TFLayoutLMvaModelTester(self )
								__lowerCAmelCase         =							ConfigTester(self      ,				config_class=snake_case__      ,				hidden_size=37 )







							def       UpperCAmelCase__					(						self  :  Union[str, Any] ):
								"""simple docstring"""







								self.config_tester.run_common_tests()







							def       UpperCAmelCase__					(						self  :  List[str] ):
								"""simple docstring"""







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

										# Test that model correctly compute the loss with kwargs
										__lowerCAmelCase         =							self._prepare_for_class(inputs_dict.copy()      ,				snake_case__      ,				return_labels=snake_case__ )
										__lowerCAmelCase         =							prepared_for_class.pop("input_ids" )

										__lowerCAmelCase         =							model(snake_case__      ,				**snake_case__ )[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
										__lowerCAmelCase         =							self._prepare_for_class(inputs_dict.copy()      ,				snake_case__      ,				return_labels=snake_case__ )
										__lowerCAmelCase         =							prepared_for_class.pop("input_ids" )
										if "labels" in prepared_for_class:
											__lowerCAmelCase         =							prepared_for_class["labels"].numpy()
											if len(labels.shape ) > 1 and labels.shape[1] != 1:
												__lowerCAmelCase         =							-100
												__lowerCAmelCase         =							tf.convert_to_tensor(snake_case__ )
												__lowerCAmelCase         =							model(snake_case__      ,				**snake_case__ )[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
										__lowerCAmelCase         =							self._prepare_for_class(inputs_dict.copy()      ,				snake_case__      ,				return_labels=snake_case__ )
										__lowerCAmelCase         =							model(snake_case__ )[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
										__lowerCAmelCase         =							self._prepare_for_class(inputs_dict.copy()      ,				snake_case__      ,				return_labels=snake_case__ )

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

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

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

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

										__lowerCAmelCase         =							tuple(snake_case__ )

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

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







							def       UpperCAmelCase__					(						self  :  Dict ):
								"""simple docstring"""







								(
								    (
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						
								)         =							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(snake_case__      ,				snake_case__      ,				snake_case__      ,				snake_case__      ,				snake_case__      ,				snake_case__ )







							def       UpperCAmelCase__					(						self  :  Any ):
								"""simple docstring"""







								(
								    (
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __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(snake_case__      ,				snake_case__      ,				snake_case__      ,				snake_case__      ,				snake_case__      ,				snake_case__ )







							def       UpperCAmelCase__					(						self  :  str ):
								"""simple docstring"""







								(
								    (
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						
								)         =							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_sequence_classification(
								    snake_case__      ,				snake_case__      ,				snake_case__      ,				snake_case__      ,				snake_case__      ,				snake_case__      ,				snake_case__ )







							def       UpperCAmelCase__					(						self  :  Union[str, Any] ):
								"""simple docstring"""







								(
								    (
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						
								)         =							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_token_classification(
								    snake_case__      ,				snake_case__      ,				snake_case__      ,				snake_case__      ,				snake_case__      ,				snake_case__      ,				snake_case__ )







							def       UpperCAmelCase__					(						self  :  Optional[Any] ):
								"""simple docstring"""







								(
								    (
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						(
								    __lowerCAmelCase
								)   ,						
								)         =							self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_question_answering(
								    snake_case__      ,				snake_case__      ,				snake_case__      ,				snake_case__      ,				snake_case__      ,				snake_case__      ,				snake_case__ )







							@slow
							def       UpperCAmelCase__					(						self  :  int ):
								"""simple docstring"""







								for model_name in TF_LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									__lowerCAmelCase         =							TFLayoutLMvaModel.from_pretrained(snake_case__ )
									self.assertIsNotNone(snake_case__ )






def 		_UpperCAmelCase   (	):






	"""simple docstring"""


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







@require_tf
class       a		(   unittest.TestCase					):







							@cached_property
							def       UpperCAmelCase__					(						self  :  Union[str, Any] ):
								"""simple docstring"""







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







							@slow
							def       UpperCAmelCase__					(						self  :  Tuple ):
								"""simple docstring"""







								__lowerCAmelCase         =							TFLayoutLMvaModel.from_pretrained("microsoft/layoutlmv3-base" )

								__lowerCAmelCase         =							self.default_image_processor
								__lowerCAmelCase         =							prepare_img()
								__lowerCAmelCase         =							image_processor(images=snake_case__      ,				return_tensors="tf" ).pixel_values

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

								# forward pass
								__lowerCAmelCase         =							model(input_ids=snake_case__      ,				bbox=snake_case__      ,				pixel_values=snake_case__      ,				training=snake_case__ )

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

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

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






