




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



				def __init__(      self      :		Union[str, Any]		,	_UpperCAmelCase      :		Any		,	_UpperCAmelCase      :		int=2		,	_UpperCAmelCase      :		int=3		,	_UpperCAmelCase      :		str=4		,	_UpperCAmelCase      :		Union[str, Any]=2		,	_UpperCAmelCase      :		Dict=7		,	_UpperCAmelCase      :		int=True		,	_UpperCAmelCase      :		List[str]=True		,	_UpperCAmelCase      :		Any=True		,	_UpperCAmelCase      :		Any=True		,	_UpperCAmelCase      :		str=99		,	_UpperCAmelCase      :		str=36		,	_UpperCAmelCase      :		Any=2		,	_UpperCAmelCase      :		Optional[Any]=4		,	_UpperCAmelCase      :		str=37		,	_UpperCAmelCase      :		Optional[int]="gelu"		,	_UpperCAmelCase      :		List[str]=0.1		,	_UpperCAmelCase      :		Any=0.1		,	_UpperCAmelCase      :		Union[str, Any]=512		,	_UpperCAmelCase      :		str=16		,	_UpperCAmelCase      :		str=2		,	_UpperCAmelCase      :		List[Any]=0.02		,	_UpperCAmelCase      :		Dict=6		,	_UpperCAmelCase      :		List[str]=6		,	_UpperCAmelCase      :		Optional[Any]=3		,	_UpperCAmelCase      :		List[str]=4		,	_UpperCAmelCase      :		Optional[int]=None		,	_UpperCAmelCase      :		Tuple=1000		,	)  ->    Tuple:





								'''simple docstring'''




								_lowerCAmelCase    :    Optional[int]										=      parent
								_lowerCAmelCase    :    Dict										=      batch_size
								_lowerCAmelCase    :    List[Any]										=      num_channels
								_lowerCAmelCase    :    Tuple										=      image_size
								_lowerCAmelCase    :    Dict										=      patch_size
								_lowerCAmelCase    :    str										=      is_training
								_lowerCAmelCase    :    List[str]										=      use_input_mask
								_lowerCAmelCase    :    Any										=      use_token_type_ids
								_lowerCAmelCase    :    Any										=      use_labels
								_lowerCAmelCase    :    Tuple										=      vocab_size
								_lowerCAmelCase    :    List[str]										=      hidden_size
								_lowerCAmelCase    :    List[str]										=      num_hidden_layers
								_lowerCAmelCase    :    Optional[int]										=      num_attention_heads
								_lowerCAmelCase    :    Dict										=      intermediate_size
								_lowerCAmelCase    :    Dict										=      hidden_act
								_lowerCAmelCase    :    Dict										=      hidden_dropout_prob
								_lowerCAmelCase    :    List[str]										=      attention_probs_dropout_prob
								_lowerCAmelCase    :    Tuple										=      max_position_embeddings
								_lowerCAmelCase    :    str										=      type_vocab_size
								_lowerCAmelCase    :    Tuple										=      type_sequence_label_size
								_lowerCAmelCase    :    Optional[int]										=      initializer_range
								_lowerCAmelCase    :    List[str]										=      coordinate_size
								_lowerCAmelCase    :    List[Any]										=      shape_size
								_lowerCAmelCase    :    List[Any]										=      num_labels
								_lowerCAmelCase    :    Any										=      num_choices
								_lowerCAmelCase    :    Dict										=      scope
								_lowerCAmelCase    :    Optional[Any]										=      range_bbox

								# LayoutLMv3's sequence length equals the number of text tokens + number of patches + 1 (we add 1 for the CLS token)
								_lowerCAmelCase    :    Optional[Any]										=      text_seq_length
								_lowerCAmelCase    :    Tuple										=      (image_size // patch_size) ** 2 + 1
								_lowerCAmelCase    :    Optional[int]										=      self.text_seq_length + self.image_seq_length



				def       SCREAMING_SNAKE_CASE       (      self      :		str      )  ->    Tuple:





								'''simple docstring'''




								_lowerCAmelCase    :    int										=      ids_tensor([self.batch_size, self.text_seq_length]		,	self.vocab_size      )

								_lowerCAmelCase    :    Optional[int]										=      ids_tensor([self.batch_size, self.text_seq_length, 4]		,	self.range_bbox      )
								_lowerCAmelCase    :    str										=      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    :    Tuple										=      bbox[i, j, 3]
																				_lowerCAmelCase    :    List[Any]										=      bbox[i, j, 1]
																				_lowerCAmelCase    :    Tuple										=      tmp_coordinate
																if bbox[i, j, 2] < bbox[i, j, 0]:
																				_lowerCAmelCase    :    Tuple										=      bbox[i, j, 2]
																				_lowerCAmelCase    :    Union[str, Any]										=      bbox[i, j, 0]
																				_lowerCAmelCase    :    Union[str, Any]										=      tmp_coordinate
								_lowerCAmelCase    :    List[Any]										=      tf.constant(__UpperCamelCase      )

								_lowerCAmelCase    :    Tuple										=      floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]      )

								_lowerCAmelCase    :    List[str]										=      None
								if self.use_input_mask:
												_lowerCAmelCase    :    Optional[Any]										=      random_attention_mask([self.batch_size, self.text_seq_length]      )

								_lowerCAmelCase    :    Dict										=      None
								if self.use_token_type_ids:
												_lowerCAmelCase    :    List[Any]										=      ids_tensor([self.batch_size, self.text_seq_length]		,	self.type_vocab_size      )

								_lowerCAmelCase    :    Union[str, Any]										=      None
								_lowerCAmelCase    :    List[str]										=      None
								if self.use_labels:
												_lowerCAmelCase    :    int										=      ids_tensor([self.batch_size]		,	self.type_sequence_label_size      )
												_lowerCAmelCase    :    List[str]										=      ids_tensor([self.batch_size, self.text_seq_length]		,	self.num_labels      )

								_lowerCAmelCase    :    List[str]										=      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       SCREAMING_SNAKE_CASE       (      self      :		Union[str, Any]		,	_UpperCAmelCase      :		Union[str, Any]		,	_UpperCAmelCase      :		List[Any]		,	_UpperCAmelCase      :		Optional[int]		,	_UpperCAmelCase      :		Dict		,	_UpperCAmelCase      :		List[str]		,	_UpperCAmelCase      :		int      )  ->    Optional[int]:





								'''simple docstring'''




								_lowerCAmelCase    :    Dict										=      TFLayoutLMvaModel(config=__UpperCamelCase      )

								# text + image
								_lowerCAmelCase    :    Any										=      model(__UpperCamelCase		,	pixel_values=__UpperCamelCase		,	training=__UpperCamelCase      )
								_lowerCAmelCase    :    List[Any]										=      model(
								    __UpperCamelCase		,	bbox=__UpperCamelCase		,	pixel_values=__UpperCamelCase		,	attention_mask=__UpperCamelCase		,	token_type_ids=__UpperCamelCase		,	training=__UpperCamelCase		,	)
								_lowerCAmelCase    :    int										=      model(__UpperCamelCase		,	bbox=__UpperCamelCase		,	pixel_values=__UpperCamelCase		,	training=__UpperCamelCase      )

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

								# text only
								_lowerCAmelCase    :    str										=      model(__UpperCamelCase		,	training=__UpperCamelCase      )
								self.parent.assertEqual(
								    result.last_hidden_state.shape		,	(self.batch_size, self.text_seq_length, self.hidden_size)      )

								# image only
								_lowerCAmelCase    :    Optional[int]										=      model({"""pixel_values""": pixel_values}		,	training=__UpperCamelCase      )
								self.parent.assertEqual(
								    result.last_hidden_state.shape		,	(self.batch_size, self.image_seq_length, self.hidden_size)      )



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





								'''simple docstring'''




								_lowerCAmelCase    :    Any										=      self.num_labels
								_lowerCAmelCase    :    Union[str, Any]										=      TFLayoutLMvaForSequenceClassification(config=__UpperCamelCase      )
								_lowerCAmelCase    :    Optional[int]										=      model(
								    __UpperCamelCase		,	bbox=__UpperCamelCase		,	pixel_values=__UpperCamelCase		,	attention_mask=__UpperCamelCase		,	token_type_ids=__UpperCamelCase		,	labels=__UpperCamelCase		,	training=__UpperCamelCase		,	)
								self.parent.assertEqual(result.logits.shape		,	(self.batch_size, self.num_labels)      )



				def       SCREAMING_SNAKE_CASE       (      self      :		int		,	_UpperCAmelCase      :		Optional[int]		,	_UpperCAmelCase      :		str		,	_UpperCAmelCase      :		Any		,	_UpperCAmelCase      :		Tuple		,	_UpperCAmelCase      :		Optional[int]		,	_UpperCAmelCase      :		Dict		,	_UpperCAmelCase      :		Optional[int]      )  ->    str:





								'''simple docstring'''




								_lowerCAmelCase    :    Dict										=      self.num_labels
								_lowerCAmelCase    :    Any										=      TFLayoutLMvaForTokenClassification(config=__UpperCamelCase      )
								_lowerCAmelCase    :    Dict										=      model(
								    __UpperCamelCase		,	bbox=__UpperCamelCase		,	pixel_values=__UpperCamelCase		,	attention_mask=__UpperCamelCase		,	token_type_ids=__UpperCamelCase		,	labels=__UpperCamelCase		,	training=__UpperCamelCase		,	)
								self.parent.assertEqual(result.logits.shape		,	(self.batch_size, self.text_seq_length, self.num_labels)      )



				def       SCREAMING_SNAKE_CASE       (      self      :		Tuple		,	_UpperCAmelCase      :		str		,	_UpperCAmelCase      :		Union[str, Any]		,	_UpperCAmelCase      :		Optional[int]		,	_UpperCAmelCase      :		Dict		,	_UpperCAmelCase      :		str		,	_UpperCAmelCase      :		Any		,	_UpperCAmelCase      :		Tuple      )  ->    str:





								'''simple docstring'''




								_lowerCAmelCase    :    List[Any]										=      2
								_lowerCAmelCase    :    Optional[Any]										=      TFLayoutLMvaForQuestionAnswering(config=__UpperCamelCase      )
								_lowerCAmelCase    :    Dict										=      model(
								    __UpperCamelCase		,	bbox=__UpperCamelCase		,	pixel_values=__UpperCamelCase		,	attention_mask=__UpperCamelCase		,	token_type_ids=__UpperCamelCase		,	start_positions=__UpperCamelCase		,	end_positions=__UpperCamelCase		,	training=__UpperCamelCase		,	)
								self.parent.assertEqual(result.start_logits.shape		,	(self.batch_size, self.seq_length)      )
								self.parent.assertEqual(result.end_logits.shape		,	(self.batch_size, self.seq_length)      )



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





								'''simple docstring'''




								_lowerCAmelCase    :    List[str]										=      self.prepare_config_and_inputs()
								((_lowerCAmelCase)					,    (_lowerCAmelCase)					,    (_lowerCAmelCase)					,    (_lowerCAmelCase)					,    (_lowerCAmelCase)					,    (_lowerCAmelCase)					,    (_lowerCAmelCase)					,    (_lowerCAmelCase))    :    Any										=      config_and_inputs
								_lowerCAmelCase    :    Optional[Any]										=      {
								    """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        __snake_case  (_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       SCREAMING_SNAKE_CASE       (      self      :		Any		,	_UpperCAmelCase      :		int		,	_UpperCAmelCase      :		Union[str, Any]		,	_UpperCAmelCase      :		str		,	_UpperCAmelCase      :		Any		,	_UpperCAmelCase      :		List[str]      )  ->    List[Any]:





								'''simple docstring'''




								return True



				def       SCREAMING_SNAKE_CASE       (      self      :		Dict		,	_UpperCAmelCase      :		str		,	_UpperCAmelCase      :		Any		,	_UpperCAmelCase      :		List[Any]=False      )  ->    dict:





								'''simple docstring'''




								_lowerCAmelCase    :    Tuple										=      copy.deepcopy(__UpperCamelCase      )

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

								if return_labels:
												if model_class in get_values(__UpperCamelCase      ):
																_lowerCAmelCase    :    Optional[int]										=      tf.ones(self.model_tester.batch_size		,	dtype=tf.intaa      )
												elif model_class in get_values(__UpperCamelCase      ):
																_lowerCAmelCase    :    Optional[int]										=      tf.zeros(self.model_tester.batch_size		,	dtype=tf.intaa      )
																_lowerCAmelCase    :    Dict										=      tf.zeros(self.model_tester.batch_size		,	dtype=tf.intaa      )
												elif model_class in get_values(__UpperCamelCase      ):
																_lowerCAmelCase    :    int										=      tf.zeros(self.model_tester.batch_size		,	dtype=tf.intaa      )
												elif model_class in get_values(__UpperCamelCase      ):
																_lowerCAmelCase    :    Optional[int]										=      tf.zeros(
																    (self.model_tester.batch_size, self.model_tester.text_seq_length)		,	dtype=tf.intaa      )

								return inputs_dict



				def       SCREAMING_SNAKE_CASE       (      self      :		str      )  ->    List[str]:





								'''simple docstring'''




								_lowerCAmelCase    :    Dict										=      TFLayoutLMvaModelTester(self      )
								_lowerCAmelCase    :    Tuple										=      ConfigTester(self		,	config_class=__UpperCamelCase		,	hidden_size=37      )



				def       SCREAMING_SNAKE_CASE       (      self      :		List[Any]      )  ->    Optional[int]:





								'''simple docstring'''




								self.config_tester.run_common_tests()



				def       SCREAMING_SNAKE_CASE       (      self      :		int      )  ->    List[Any]:





								'''simple docstring'''




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

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

																_lowerCAmelCase    :    Dict										=      model(__UpperCamelCase		,	**__UpperCamelCase      )[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    :    List[str]										=      self._prepare_for_class(inputs_dict.copy()		,	__UpperCamelCase		,	return_labels=__UpperCamelCase      )
																_lowerCAmelCase    :    Dict										=      prepared_for_class.pop("""input_ids"""      )
																if "labels" in prepared_for_class:
																				_lowerCAmelCase    :    List[str]										=      prepared_for_class["""labels"""].numpy()
																				if len(labels.shape      ) > 1 and labels.shape[1] != 1:
																								_lowerCAmelCase    :    Any										=      -100
																								_lowerCAmelCase    :    Tuple										=      tf.convert_to_tensor(__UpperCamelCase      )
																								_lowerCAmelCase    :    Optional[int]										=      model(__UpperCamelCase		,	**__UpperCamelCase      )[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    :    List[Any]										=      self._prepare_for_class(inputs_dict.copy()		,	__UpperCamelCase		,	return_labels=__UpperCamelCase      )
																_lowerCAmelCase    :    Optional[Any]										=      model(__UpperCamelCase      )[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    :    str										=      self._prepare_for_class(inputs_dict.copy()		,	__UpperCamelCase		,	return_labels=__UpperCamelCase      )

																# Get keys that were added with the _prepare_for_class function
																_lowerCAmelCase    :    Dict										=      prepared_for_class.keys() - inputs_dict.keys()
																_lowerCAmelCase    :    Union[str, Any]										=      inspect.signature(model.call      ).parameters
																_lowerCAmelCase    :    Tuple										=      list(signature.keys()      )

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

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

																for index, value in sorted_tuple_index_mapping:
																				_lowerCAmelCase    :    Any										=      prepared_for_class[value]

																_lowerCAmelCase    :    Tuple										=      tuple(__UpperCamelCase      )

																# Send to model
																_lowerCAmelCase    :    List[Any]										=      model(tuple_input[:-1]      )[0]

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



				def       SCREAMING_SNAKE_CASE       (      self      :		int      )  ->    Optional[int]:





								'''simple docstring'''




								(
								    (
								    _lowerCAmelCase						
								)					,    (
								    _lowerCAmelCase						
								)					,    (
								    _lowerCAmelCase						
								)					,    (
								    _lowerCAmelCase						
								)					,    (
								    _lowerCAmelCase						
								)					,    (
								    _lowerCAmelCase						
								)					,    (
								    _lowerCAmelCase						
								)					,    (
								    _lowerCAmelCase						
								)					,    						
								)    :    int										=      self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(__UpperCamelCase		,	__UpperCamelCase		,	__UpperCamelCase		,	__UpperCamelCase		,	__UpperCamelCase		,	__UpperCamelCase      )



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





								'''simple docstring'''




								(
								    (
								    _lowerCAmelCase						
								)					,    (
								    _lowerCAmelCase						
								)					,    (
								    _lowerCAmelCase						
								)					,    (
								    _lowerCAmelCase						
								)					,    (
								    _lowerCAmelCase						
								)					,    (
								    _lowerCAmelCase						
								)					,    (
								    _lowerCAmelCase						
								)					,    (
								    _lowerCAmelCase						
								)					,    						
								)    :    Dict										=      self.model_tester.prepare_config_and_inputs()
								for type in ["absolute", "relative_key", "relative_key_query"]:
												_lowerCAmelCase    :    int										=      type
												self.model_tester.create_and_check_model(__UpperCamelCase		,	__UpperCamelCase		,	__UpperCamelCase		,	__UpperCamelCase		,	__UpperCamelCase		,	__UpperCamelCase      )



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





								'''simple docstring'''




								(
								    (
								    _lowerCAmelCase						
								)					,    (
								    _lowerCAmelCase						
								)					,    (
								    _lowerCAmelCase						
								)					,    (
								    _lowerCAmelCase						
								)					,    (
								    _lowerCAmelCase						
								)					,    (
								    _lowerCAmelCase						
								)					,    (
								    _lowerCAmelCase						
								)					,    (
								    _lowerCAmelCase						
								)					,    						
								)    :    Optional[Any]										=      self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_sequence_classification(
								    __UpperCamelCase		,	__UpperCamelCase		,	__UpperCamelCase		,	__UpperCamelCase		,	__UpperCamelCase		,	__UpperCamelCase		,	__UpperCamelCase      )



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





								'''simple docstring'''




								(
								    (
								    _lowerCAmelCase						
								)					,    (
								    _lowerCAmelCase						
								)					,    (
								    _lowerCAmelCase						
								)					,    (
								    _lowerCAmelCase						
								)					,    (
								    _lowerCAmelCase						
								)					,    (
								    _lowerCAmelCase						
								)					,    (
								    _lowerCAmelCase						
								)					,    (
								    _lowerCAmelCase						
								)					,    						
								)    :    List[str]										=      self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_token_classification(
								    __UpperCamelCase		,	__UpperCamelCase		,	__UpperCamelCase		,	__UpperCamelCase		,	__UpperCamelCase		,	__UpperCamelCase		,	__UpperCamelCase      )



				def       SCREAMING_SNAKE_CASE       (      self      :		int      )  ->    List[Any]:





								'''simple docstring'''




								(
								    (
								    _lowerCAmelCase						
								)					,    (
								    _lowerCAmelCase						
								)					,    (
								    _lowerCAmelCase						
								)					,    (
								    _lowerCAmelCase						
								)					,    (
								    _lowerCAmelCase						
								)					,    (
								    _lowerCAmelCase						
								)					,    (
								    _lowerCAmelCase						
								)					,    (
								    _lowerCAmelCase						
								)					,    						
								)    :    Optional[int]										=      self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_question_answering(
								    __UpperCamelCase		,	__UpperCamelCase		,	__UpperCamelCase		,	__UpperCamelCase		,	__UpperCamelCase		,	__UpperCamelCase		,	__UpperCamelCase      )



				@slow
				def       SCREAMING_SNAKE_CASE       (      self      :		List[Any]      )  ->    Union[str, Any]:





								'''simple docstring'''




								for model_name in TF_LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
												_lowerCAmelCase    :    str										=      TFLayoutLMvaModel.from_pretrained(__UpperCamelCase      )
												self.assertIsNotNone(__UpperCamelCase      )






def 							_UpperCAmelCase  ():
				'''simple docstring'''
				_lowerCAmelCase    :    Dict										=      Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""       )
				return image





@require_tf
class        __snake_case  (unittest.TestCase		):



				@cached_property
				def       SCREAMING_SNAKE_CASE       (      self      :		Union[str, Any]      )  ->    List[Any]:





								'''simple docstring'''




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



				@slow
				def       SCREAMING_SNAKE_CASE       (      self      :		Optional[Any]      )  ->    str:





								'''simple docstring'''




								_lowerCAmelCase    :    str										=      TFLayoutLMvaModel.from_pretrained("""microsoft/layoutlmv3-base"""      )

								_lowerCAmelCase    :    Dict										=      self.default_image_processor
								_lowerCAmelCase    :    Optional[int]										=      prepare_img()
								_lowerCAmelCase    :    int										=      image_processor(images=__UpperCamelCase		,	return_tensors="""tf"""      ).pixel_values

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

								# forward pass
								_lowerCAmelCase    :    Union[str, Any]										=      model(input_ids=__UpperCamelCase		,	bbox=__UpperCamelCase		,	pixel_values=__UpperCamelCase		,	training=__UpperCamelCase      )

								# verify the logits
								_lowerCAmelCase    :    str										=      (1, 199, 768)
								self.assertEqual(outputs.last_hidden_state.shape		,	__UpperCamelCase      )

								_lowerCAmelCase    :    Any										=      tf.constant(
								    [[-0.0529, 0.3618, 0.1632], [-0.1587, -0.1667, -0.0400], [-0.1557, -0.1671, -0.0505]]      )

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







def 							_UpperCAmelCase  (UpperCamelCase_ : str       ):
				'''simple docstring'''
				_lowerCAmelCase    :    Dict										=      [0] * len(UpperCamelCase_       )

				for i in range(1      ,    len(UpperCamelCase_       )       ):
								# use last results for better performance - dynamic programming
								_lowerCAmelCase    :    Union[str, Any]										=      prefix_result[i - 1]
								while j > 0 and input_string[i] != input_string[j]:
												_lowerCAmelCase    :    str										=      prefix_result[j - 1]

								if input_string[i] == input_string[j]:
												j += 1
								_lowerCAmelCase    :    Optional[int]										=      j

				return prefix_result




def 							_UpperCAmelCase  (UpperCamelCase_ : str       ):
				'''simple docstring'''
				return max(prefix_function(UpperCamelCase_       )       )


if __name__ == "__main__":
	import doctest

	doctest.testmod()

