






from __future__ import annotations

import unittest

import numpy as np

from transformers import LayoutLMConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

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


if is_tf_available():
						import tensorflow as tf

						from transformers.models.layoutlm.modeling_tf_layoutlm import (
						    TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST,
						    TFLayoutLMForMaskedLM,
						    TFLayoutLMForQuestionAnswering,
						    TFLayoutLMForSequenceClassification,
						    TFLayoutLMForTokenClassification,
						    TFLayoutLMModel,
						)


class 							__UpperCamelCase     :







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







		__lowercase   							=	parent
		__lowercase   							=	batch_size
		__lowercase   							=	seq_length
		__lowercase   							=	is_training
		__lowercase   							=	use_input_mask
		__lowercase   							=	use_token_type_ids
		__lowercase   							=	use_labels
		__lowercase   							=	vocab_size
		__lowercase   							=	hidden_size
		__lowercase   							=	num_hidden_layers
		__lowercase   							=	num_attention_heads
		__lowercase   							=	intermediate_size
		__lowercase   							=	hidden_act
		__lowercase   							=	hidden_dropout_prob
		__lowercase   							=	attention_probs_dropout_prob
		__lowercase   							=	max_position_embeddings
		__lowercase   							=	type_vocab_size
		__lowercase   							=	type_sequence_label_size
		__lowercase   							=	initializer_range
		__lowercase   							=	num_labels
		__lowercase   							=	num_choices
		__lowercase   							=	scope
		__lowercase   							=	range_bbox







	def 			_a (	self   :				Optional[Any]      )		->			List[Any]:
		"""simple docstring"""







		__lowercase   							=	ids_tensor([self.batch_size, self.seq_length]							,					self.vocab_size      )

		# convert bbox to numpy since TF does not support item assignment
		__lowercase   							=	ids_tensor([self.batch_size, self.seq_length, 4]							,					self.range_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]:
					__lowercase   							=	bbox[i, j, 3]
					__lowercase   							=	bbox[i, j, 1]
					__lowercase   							=	t
				if bbox[i, j, 2] < bbox[i, j, 0]:
					__lowercase   							=	bbox[i, j, 2]
					__lowercase   							=	bbox[i, j, 0]
					__lowercase   							=	t
		__lowercase   							=	tf.convert_to_tensor(_lowerCAmelCase      )

		__lowercase   							=	None
		if self.use_input_mask:
			__lowercase   							=	random_attention_mask([self.batch_size, self.seq_length]      )

		__lowercase   							=	None
		if self.use_token_type_ids:
			__lowercase   							=	ids_tensor([self.batch_size, self.seq_length]							,					self.type_vocab_size      )

		__lowercase   							=	None
		__lowercase   							=	None
		__lowercase   							=	None
		if self.use_labels:
			__lowercase   							=	ids_tensor([self.batch_size]							,					self.type_sequence_label_size      )
			__lowercase   							=	ids_tensor([self.batch_size, self.seq_length]							,					self.num_labels      )
			__lowercase   							=	ids_tensor([self.batch_size]							,					self.num_choices      )

		__lowercase   							=	LayoutLMConfig(
		    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							,					)

		return config, input_ids, bbox, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels







	def 			_a (	self   :				List[str]							,					_lowerCAmelCase   :				int							,					_lowerCAmelCase   :				Tuple							,					_lowerCAmelCase   :				List[str]							,					_lowerCAmelCase   :				Optional[int]							,					_lowerCAmelCase   :				Tuple							,					_lowerCAmelCase   :				Optional[Any]							,					_lowerCAmelCase   :				Any							,					_lowerCAmelCase   :				List[Any]      )		->			Tuple:
		"""simple docstring"""







		__lowercase   							=	TFLayoutLMModel(config=_lowerCAmelCase      )

		__lowercase   							=	model(_lowerCAmelCase							,					_lowerCAmelCase							,					attention_mask=_lowerCAmelCase							,					token_type_ids=_lowerCAmelCase      )
		__lowercase   							=	model(_lowerCAmelCase							,					_lowerCAmelCase							,					token_type_ids=_lowerCAmelCase      )
		__lowercase   							=	model(_lowerCAmelCase							,					_lowerCAmelCase      )
		self.parent.assertEqual(result.last_hidden_state.shape							,					(self.batch_size, self.seq_length, self.hidden_size)      )
		self.parent.assertEqual(result.pooler_output.shape							,					(self.batch_size, self.hidden_size)      )







	def 			_a (	self   :				Any							,					_lowerCAmelCase   :				Tuple							,					_lowerCAmelCase   :				Optional[Any]							,					_lowerCAmelCase   :				Dict							,					_lowerCAmelCase   :				Optional[int]							,					_lowerCAmelCase   :				Union[str, Any]							,					_lowerCAmelCase   :				Dict							,					_lowerCAmelCase   :				int							,					_lowerCAmelCase   :				Union[str, Any]      )		->			Tuple:
		"""simple docstring"""







		__lowercase   							=	TFLayoutLMForMaskedLM(config=_lowerCAmelCase      )

		__lowercase   							=	model(_lowerCAmelCase							,					_lowerCAmelCase							,					attention_mask=_lowerCAmelCase							,					token_type_ids=_lowerCAmelCase							,					labels=_lowerCAmelCase      )
		self.parent.assertEqual(result.logits.shape							,					(self.batch_size, self.seq_length, self.vocab_size)      )







	def 			_a (	self   :				Tuple							,					_lowerCAmelCase   :				List[str]							,					_lowerCAmelCase   :				Optional[Any]							,					_lowerCAmelCase   :				List[str]							,					_lowerCAmelCase   :				int							,					_lowerCAmelCase   :				str							,					_lowerCAmelCase   :				Tuple							,					_lowerCAmelCase   :				Any							,					_lowerCAmelCase   :				int      )		->			Optional[Any]:
		"""simple docstring"""







		__lowercase   							=	self.num_labels
		__lowercase   							=	TFLayoutLMForSequenceClassification(config=_lowerCAmelCase      )

		__lowercase   							=	model(_lowerCAmelCase							,					_lowerCAmelCase							,					attention_mask=_lowerCAmelCase							,					token_type_ids=_lowerCAmelCase      )
		self.parent.assertEqual(result.logits.shape							,					(self.batch_size, self.num_labels)      )







	def 			_a (	self   :				List[Any]							,					_lowerCAmelCase   :				List[Any]							,					_lowerCAmelCase   :				Dict							,					_lowerCAmelCase   :				List[Any]							,					_lowerCAmelCase   :				Any							,					_lowerCAmelCase   :				Optional[int]							,					_lowerCAmelCase   :				Any							,					_lowerCAmelCase   :				Any							,					_lowerCAmelCase   :				Dict      )		->			Dict:
		"""simple docstring"""







		__lowercase   							=	self.num_labels
		__lowercase   							=	TFLayoutLMForTokenClassification(config=_lowerCAmelCase      )

		__lowercase   							=	model(_lowerCAmelCase							,					_lowerCAmelCase							,					attention_mask=_lowerCAmelCase							,					token_type_ids=_lowerCAmelCase							,					labels=_lowerCAmelCase      )
		self.parent.assertEqual(result.logits.shape							,					(self.batch_size, self.seq_length, self.num_labels)      )







	def 			_a (	self   :				str							,					_lowerCAmelCase   :				int							,					_lowerCAmelCase   :				List[Any]							,					_lowerCAmelCase   :				Tuple							,					_lowerCAmelCase   :				Optional[Any]							,					_lowerCAmelCase   :				int							,					_lowerCAmelCase   :				Optional[Any]							,					_lowerCAmelCase   :				List[str]							,					_lowerCAmelCase   :				Optional[int]      )		->			Optional[int]:
		"""simple docstring"""







		__lowercase   							=	TFLayoutLMForQuestionAnswering(config=_lowerCAmelCase      )

		__lowercase   							=	model(_lowerCAmelCase							,					_lowerCAmelCase							,					attention_mask=_lowerCAmelCase							,					token_type_ids=_lowerCAmelCase      )
		self.parent.assertEqual(result.start_logits.shape							,					(self.batch_size, self.seq_length)      )
		self.parent.assertEqual(result.end_logits.shape							,					(self.batch_size, self.seq_length)      )







	def 			_a (	self   :				str      )		->			List[str]:
		"""simple docstring"""







		__lowercase   							=	self.prepare_config_and_inputs()
		(
		    (
		    __lowercase
		)							,    (
		    __lowercase
		)							,    (
		    __lowercase
		)							,    (
		    __lowercase
		)							,    (
		    __lowercase
		)							,    (
		    __lowercase
		)							,    (
		    __lowercase
		)							,    (
		    __lowercase
		)							,    
		)   							=	config_and_inputs
		__lowercase   							=	{
		    """input_ids""": input_ids,
		    """bbox""": bbox,
		    """token_type_ids""": token_type_ids,
		    """attention_mask""": input_mask,
		}
		return config, inputs_dict


@require_tf
class 							__UpperCamelCase     (  _lowerCAmelCase ,      _lowerCAmelCase ,      unittest.TestCase ):
	__snake_case						:List[Any] =							(
	    (
	        TFLayoutLMModel,
	        TFLayoutLMForMaskedLM,
	        TFLayoutLMForTokenClassification,
	        TFLayoutLMForSequenceClassification,
	        TFLayoutLMForQuestionAnswering,
	    )
	    if is_tf_available()
	    else ()
	)
	__snake_case						:Union[str, Any] =							(
	    {
	        'feature-extraction': TFLayoutLMModel,
	        'fill-mask': TFLayoutLMForMaskedLM,
	        'text-classification': TFLayoutLMForSequenceClassification,
	        'token-classification': TFLayoutLMForTokenClassification,
	        'zero-shot': TFLayoutLMForSequenceClassification,
	    }
	    if is_tf_available()
	    else {}
	)
	__snake_case						:str =							False
	__snake_case						:Dict =							True
	__snake_case						:Tuple =							1_0







	def 			_a (	self   :				Dict      )		->			Union[str, Any]:
		"""simple docstring"""







		__lowercase   							=	TFLayoutLMModelTester(self      )
		__lowercase   							=	ConfigTester(self							,					config_class=_lowerCAmelCase							,					hidden_size=37      )







	def 			_a (	self   :				List[str]      )		->			Optional[int]:
		"""simple docstring"""







		self.config_tester.run_common_tests()







	def 			_a (	self   :				List[Any]      )		->			int:
		"""simple docstring"""







		__lowercase   							=	self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_model(*_lowerCAmelCase      )







	def 			_a (	self   :				int      )		->			Optional[Any]:
		"""simple docstring"""







		__lowercase   							=	self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_for_masked_lm(*_lowerCAmelCase      )







	def 			_a (	self   :				Any      )		->			int:
		"""simple docstring"""







		__lowercase   							=	self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_for_sequence_classification(*_lowerCAmelCase      )







	def 			_a (	self   :				List[Any]      )		->			List[Any]:
		"""simple docstring"""







		__lowercase   							=	self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_for_token_classification(*_lowerCAmelCase      )







	def 			_a (	self   :				List[str]      )		->			Optional[int]:
		"""simple docstring"""







		__lowercase   							=	self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_for_question_answering(*_lowerCAmelCase      )







	@slow
	def 			_a (	self   :				Any      )		->			Any:
		"""simple docstring"""







		for model_name in TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
			__lowercase   							=	TFLayoutLMModel.from_pretrained(_lowerCAmelCase      )
			self.assertIsNotNone(_lowerCAmelCase      )







	@unittest.skip("""Onnx compliancy broke with TF 2.10"""      )
	def 			_a (	self   :				str      )		->			Any:
		"""simple docstring"""







		pass





def 					snake_case	(  ):




	'''simple docstring'''







	__lowercase   							=	tf.convert_to_tensor([[101,1_019,1_014,1_016,1_037,12_849,4_747,1_004,14_246,2_278,5_439,4_524,5_002,2_930,2_193,2_930,4_341,3_208,1_005,1_055,2_171,2_848,11_300,3_531,102],[101,4_070,4_034,7_020,1_024,3_058,1_015,1_013,2_861,1_013,6_070,19_274,2_772,6_205,27_814,16_147,16_147,4_343,2_047,10_283,10_969,14_389,1_012,2_338,102]]       )  # noqa: E231
	__lowercase   							=	tf.convert_to_tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],]       )  # noqa: E231
	__lowercase   							=	tf.convert_to_tensor([[[0,0,0,0],[423,237,440,251],[427,272,441,287],[419,115,437,129],[961,885,992,912],[256,38,330,58],[256,38,330,58],[336,42,353,57],[360,39,401,56],[360,39,401,56],[411,39,471,59],[479,41,528,59],[533,39,630,60],[67,113,134,131],[141,115,209,132],[68,149,133,166],[141,149,187,164],[195,148,287,165],[195,148,287,165],[195,148,287,165],[295,148,349,165],[441,149,492,166],[497,149,546,164],[64,201,125,218],[1_000,1_000,1_000,1_000]],[[0,0,0,0],[662,150,754,166],[665,199,742,211],[519,213,554,228],[519,213,554,228],[134,433,187,454],[130,467,204,480],[130,467,204,480],[130,467,204,480],[130,467,204,480],[130,467,204,480],[314,469,376,482],[504,684,582,706],[941,825,973,900],[941,825,973,900],[941,825,973,900],[941,825,973,900],[610,749,652,765],[130,659,168,672],[176,657,237,672],[238,657,312,672],[443,653,628,672],[443,653,628,672],[716,301,825,317],[1_000,1_000,1_000,1_000]]]       )  # noqa: E231
	__lowercase   							=	tf.convert_to_tensor([[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]       )  # noqa: E231
	# these are sequence labels (i.e. at the token level)
	__lowercase   							=	tf.convert_to_tensor([[-100,10,10,10,9,1,-100,7,7,-100,7,7,4,2,5,2,8,8,-100,-100,5,0,3,2,-100],[-100,12,12,12,-100,12,10,-100,-100,-100,-100,10,12,9,-100,-100,-100,10,10,10,9,12,-100,10,-100]]       )  # noqa: E231
	# fmt: on

	return input_ids, attention_mask, bbox, token_type_ids, labels




@require_tf
class 							__UpperCamelCase     (  unittest.TestCase ):







	@slow
	def 			_a (	self   :				str      )		->			str:
		"""simple docstring"""







		__lowercase   							=	TFLayoutLMModel.from_pretrained("""microsoft/layoutlm-base-uncased"""      )

		__lowercase							,    __lowercase							,    __lowercase							,    __lowercase							,    __lowercase   							=	prepare_layoutlm_batch_inputs()

		# forward pass
		__lowercase   							=	model(input_ids=_lowerCAmelCase							,					bbox=_lowerCAmelCase							,					attention_mask=_lowerCAmelCase							,					token_type_ids=_lowerCAmelCase      )

		# test the sequence output on [0, :3, :3]
		__lowercase   							=	tf.convert_to_tensor(
		    [[0.1_785, -0.1_947, -0.0_425], [-0.3_254, -0.2_807, 0.2_553], [-0.5_391, -0.3_322, 0.3_364]]							,					)

		self.assertTrue(np.allclose(outputs.last_hidden_state[0, :3, :3]							,					_lowerCAmelCase							,					atol=1e-3      )      )

		# test the pooled output on [1, :3]
		__lowercase   							=	tf.convert_to_tensor([-0.6_580, -0.0_214, 0.8_552]      )

		self.assertTrue(np.allclose(outputs.pooler_output[1, :3]							,					_lowerCAmelCase							,					atol=1e-3      )      )







	@slow
	def 			_a (	self   :				int      )		->			Any:
		"""simple docstring"""







		__lowercase   							=	TFLayoutLMForSequenceClassification.from_pretrained("""microsoft/layoutlm-base-uncased"""							,					num_labels=2      )

		__lowercase							,    __lowercase							,    __lowercase							,    __lowercase							,    __lowercase   							=	prepare_layoutlm_batch_inputs()

		# forward pass
		__lowercase   							=	model(
		    input_ids=_lowerCAmelCase							,					bbox=_lowerCAmelCase							,					attention_mask=_lowerCAmelCase							,					token_type_ids=_lowerCAmelCase							,					labels=tf.convert_to_tensor([1, 1]      )							,					)

		# test whether we get a loss as a scalar
		__lowercase   							=	outputs.loss
		__lowercase   							=	(2,)
		self.assertEqual(loss.shape							,					_lowerCAmelCase      )

		# test the shape of the logits
		__lowercase   							=	outputs.logits
		__lowercase   							=	(2, 2)
		self.assertEqual(logits.shape							,					_lowerCAmelCase      )







	@slow
	def 			_a (	self   :				List[str]      )		->			int:
		"""simple docstring"""







		__lowercase   							=	TFLayoutLMForTokenClassification.from_pretrained("""microsoft/layoutlm-base-uncased"""							,					num_labels=13      )

		__lowercase							,    __lowercase							,    __lowercase							,    __lowercase							,    __lowercase   							=	prepare_layoutlm_batch_inputs()

		# forward pass
		__lowercase   							=	model(
		    input_ids=_lowerCAmelCase							,					bbox=_lowerCAmelCase							,					attention_mask=_lowerCAmelCase							,					token_type_ids=_lowerCAmelCase							,					labels=_lowerCAmelCase      )

		# test the shape of the logits
		__lowercase   							=	outputs.logits
		__lowercase   							=	tf.convert_to_tensor((2, 25, 13)      )
		self.assertEqual(logits.shape							,					_lowerCAmelCase      )







	@slow
	def 			_a (	self   :				List[Any]      )		->			Union[str, Any]:
		"""simple docstring"""







		__lowercase   							=	TFLayoutLMForQuestionAnswering.from_pretrained("""microsoft/layoutlm-base-uncased"""      )

		__lowercase							,    __lowercase							,    __lowercase							,    __lowercase							,    __lowercase   							=	prepare_layoutlm_batch_inputs()

		# forward pass
		__lowercase   							=	model(input_ids=_lowerCAmelCase							,					bbox=_lowerCAmelCase							,					attention_mask=_lowerCAmelCase							,					token_type_ids=_lowerCAmelCase      )

		# test the shape of the logits
		__lowercase   							=	tf.convert_to_tensor((2, 25)      )
		self.assertEqual(outputs.start_logits.shape							,					_lowerCAmelCase      )
		self.assertEqual(outputs.end_logits.shape							,					_lowerCAmelCase      )




"""simple docstring"""





# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import TYPE_CHECKING

from ..models.auto import AutoModelForVisionaSeq
from ..utils import requires_backends
from .base import PipelineTool


if TYPE_CHECKING:
							from PIL import Image







class 							SCREAMING_SNAKE_CASE   (						a_			):






					"""simple docstring"""



					lowercase__												=			"Salesforce/blip-image-captioning-base"
					lowercase__												=			(
					    "This is a tool that generates a description of an image. It takes an input named `image` which should be the "
					    "image to caption, and returns a text that contains the description in English."
					)
					lowercase__												=			"image_captioner"
					lowercase__												=			AutoModelForVisionaSeq

					lowercase__												=			["image"]
					lowercase__												=			["text"]







					def __init__(			self     :							int  ,*lowercase_     :							int  ,**lowercase_     :							List[str]						):
						requires_backends(self  ,['''vision''']						)
						super().__init__(*lowercase_  ,**lowercase_						)







					def 			__lowerCAmelCase					(			self     :							List[str]  ,lowercase_     :							"Image"						):
						return self.pre_processor(images=lowercase_  ,return_tensors='''pt'''						)







					def 			__lowerCAmelCase					(			self     :							List[Any]  ,lowercase_     :							Any						):
						return self.model.generate(**lowercase_						)







					def 			__lowerCAmelCase					(			self     :							Dict  ,lowercase_     :							Union[str, Any]						):
						return self.pre_processor.batch_decode(lowercase_  ,skip_special_tokens=lowercase_						)[0].strip()




