






'''simple docstring'''







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






			def __init__(			self   :      Dict	,    __SCREAMING_SNAKE_CASE   :      List[Any]	,    __SCREAMING_SNAKE_CASE   :      List[str]=13	,    __SCREAMING_SNAKE_CASE   :      Tuple=7	,    __SCREAMING_SNAKE_CASE   :      Union[str, Any]=True	,    __SCREAMING_SNAKE_CASE   :      List[str]=True	,    __SCREAMING_SNAKE_CASE   :      Optional[int]=True	,    __SCREAMING_SNAKE_CASE   :      Dict=True	,    __SCREAMING_SNAKE_CASE   :      int=99	,    __SCREAMING_SNAKE_CASE   :      Optional[Any]=32	,    __SCREAMING_SNAKE_CASE   :      int=2	,    __SCREAMING_SNAKE_CASE   :      Any=4	,    __SCREAMING_SNAKE_CASE   :      str=37	,    __SCREAMING_SNAKE_CASE   :      Optional[int]="gelu"	,    __SCREAMING_SNAKE_CASE   :      Dict=0.1	,    __SCREAMING_SNAKE_CASE   :      Union[str, Any]=0.1	,    __SCREAMING_SNAKE_CASE   :      Union[str, Any]=512	,    __SCREAMING_SNAKE_CASE   :      Optional[Any]=16	,    __SCREAMING_SNAKE_CASE   :      Tuple=2	,    __SCREAMING_SNAKE_CASE   :      int=0.02	,    __SCREAMING_SNAKE_CASE   :      Optional[int]=3	,    __SCREAMING_SNAKE_CASE   :      Optional[int]=4	,    __SCREAMING_SNAKE_CASE   :      Optional[Any]=None	,    __SCREAMING_SNAKE_CASE   :      List[Any]=1000	,    )      ->      List[str]:
							a_		:	List[str]									=   parent
							a_		:	Union[str, Any]									=   batch_size
							a_		:	Optional[Any]									=   seq_length
							a_		:	Optional[int]									=   is_training
							a_		:	int									=   use_input_mask
							a_		:	Union[str, Any]									=   use_token_type_ids
							a_		:	Optional[int]									=   use_labels
							a_		:	Union[str, Any]									=   vocab_size
							a_		:	Dict									=   hidden_size
							a_		:	int									=   num_hidden_layers
							a_		:	Union[str, Any]									=   num_attention_heads
							a_		:	Union[str, Any]									=   intermediate_size
							a_		:	str									=   hidden_act
							a_		:	List[str]									=   hidden_dropout_prob
							a_		:	List[Any]									=   attention_probs_dropout_prob
							a_		:	List[str]									=   max_position_embeddings
							a_		:	Any									=   type_vocab_size
							a_		:	Union[str, Any]									=   type_sequence_label_size
							a_		:	str									=   initializer_range
							a_		:	int									=   num_labels
							a_		:	Union[str, Any]									=   num_choices
							a_		:	List[Any]									=   scope
							a_		:	Any									=   range_bbox






			def       SCREAMING_SNAKE_CASE   (			self   :      Tuple       )      ->      Optional[Any]:
							a_		:	int									=   ids_tensor([self.batch_size, self.seq_length]	,    self.vocab_size       )

							# convert bbox to numpy since TF does not support item assignment
							a_		:	int									=   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]:
																			a_		:	Union[str, Any]									=   bbox[i, j, 3]
																			a_		:	Optional[Any]									=   bbox[i, j, 1]
																			a_		:	List[str]									=   t
															if bbox[i, j, 2] < bbox[i, j, 0]:
																			a_		:	Tuple									=   bbox[i, j, 2]
																			a_		:	Any									=   bbox[i, j, 0]
																			a_		:	Dict									=   t
							a_		:	int									=   tf.convert_to_tensor(__SCREAMING_SNAKE_CASE       )

							a_		:	Tuple									=   None
							if self.use_input_mask:
											a_		:	Optional[int]									=   random_attention_mask([self.batch_size, self.seq_length]       )

							a_		:	List[str]									=   None
							if self.use_token_type_ids:
											a_		:	Optional[Any]									=   ids_tensor([self.batch_size, self.seq_length]	,    self.type_vocab_size       )

							a_		:	str									=   None
							a_		:	Dict									=   None
							a_		:	int									=   None
							if self.use_labels:
											a_		:	Union[str, Any]									=   ids_tensor([self.batch_size]	,    self.type_sequence_label_size       )
											a_		:	Union[str, Any]									=   ids_tensor([self.batch_size, self.seq_length]	,    self.num_labels       )
											a_		:	Optional[int]									=   ids_tensor([self.batch_size]	,    self.num_choices       )

							a_		:	int									=   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       SCREAMING_SNAKE_CASE   (			self   :      List[Any]	,    __SCREAMING_SNAKE_CASE   :      List[Any]	,    __SCREAMING_SNAKE_CASE   :      Optional[Any]	,    __SCREAMING_SNAKE_CASE   :      List[str]	,    __SCREAMING_SNAKE_CASE   :      Union[str, Any]	,    __SCREAMING_SNAKE_CASE   :      List[str]	,    __SCREAMING_SNAKE_CASE   :      Tuple	,    __SCREAMING_SNAKE_CASE   :      Union[str, Any]	,    __SCREAMING_SNAKE_CASE   :      Any       )      ->      Tuple:
							a_		:	Tuple									=   TFLayoutLMModel(config=__SCREAMING_SNAKE_CASE       )

							a_		:	Optional[int]									=   model(__SCREAMING_SNAKE_CASE	,    __SCREAMING_SNAKE_CASE	,    attention_mask=__SCREAMING_SNAKE_CASE	,    token_type_ids=__SCREAMING_SNAKE_CASE       )
							a_		:	Optional[int]									=   model(__SCREAMING_SNAKE_CASE	,    __SCREAMING_SNAKE_CASE	,    token_type_ids=__SCREAMING_SNAKE_CASE       )
							a_		:	Any									=   model(__SCREAMING_SNAKE_CASE	,    __SCREAMING_SNAKE_CASE       )
							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       SCREAMING_SNAKE_CASE   (			self   :      Union[str, Any]	,    __SCREAMING_SNAKE_CASE   :      Tuple	,    __SCREAMING_SNAKE_CASE   :      List[str]	,    __SCREAMING_SNAKE_CASE   :      int	,    __SCREAMING_SNAKE_CASE   :      Union[str, Any]	,    __SCREAMING_SNAKE_CASE   :      Dict	,    __SCREAMING_SNAKE_CASE   :      Optional[Any]	,    __SCREAMING_SNAKE_CASE   :      str	,    __SCREAMING_SNAKE_CASE   :      int       )      ->      List[str]:
							a_		:	Dict									=   TFLayoutLMForMaskedLM(config=__SCREAMING_SNAKE_CASE       )

							a_		:	Union[str, Any]									=   model(__SCREAMING_SNAKE_CASE	,    __SCREAMING_SNAKE_CASE	,    attention_mask=__SCREAMING_SNAKE_CASE	,    token_type_ids=__SCREAMING_SNAKE_CASE	,    labels=__SCREAMING_SNAKE_CASE       )
							self.parent.assertEqual(result.logits.shape	,    (self.batch_size, self.seq_length, self.vocab_size)       )






			def       SCREAMING_SNAKE_CASE   (			self   :      Dict	,    __SCREAMING_SNAKE_CASE   :      Optional[int]	,    __SCREAMING_SNAKE_CASE   :      Union[str, Any]	,    __SCREAMING_SNAKE_CASE   :      int	,    __SCREAMING_SNAKE_CASE   :      Union[str, Any]	,    __SCREAMING_SNAKE_CASE   :      Optional[Any]	,    __SCREAMING_SNAKE_CASE   :      Optional[Any]	,    __SCREAMING_SNAKE_CASE   :      Union[str, Any]	,    __SCREAMING_SNAKE_CASE   :      Union[str, Any]       )      ->      int:
							a_		:	Dict									=   self.num_labels
							a_		:	Union[str, Any]									=   TFLayoutLMForSequenceClassification(config=__SCREAMING_SNAKE_CASE       )

							a_		:	Tuple									=   model(__SCREAMING_SNAKE_CASE	,    __SCREAMING_SNAKE_CASE	,    attention_mask=__SCREAMING_SNAKE_CASE	,    token_type_ids=__SCREAMING_SNAKE_CASE       )
							self.parent.assertEqual(result.logits.shape	,    (self.batch_size, self.num_labels)       )






			def       SCREAMING_SNAKE_CASE   (			self   :      str	,    __SCREAMING_SNAKE_CASE   :      Any	,    __SCREAMING_SNAKE_CASE   :      Dict	,    __SCREAMING_SNAKE_CASE   :      List[Any]	,    __SCREAMING_SNAKE_CASE   :      Union[str, Any]	,    __SCREAMING_SNAKE_CASE   :      Union[str, Any]	,    __SCREAMING_SNAKE_CASE   :      str	,    __SCREAMING_SNAKE_CASE   :      int	,    __SCREAMING_SNAKE_CASE   :      int       )      ->      Union[str, Any]:
							a_		:	List[Any]									=   self.num_labels
							a_		:	int									=   TFLayoutLMForTokenClassification(config=__SCREAMING_SNAKE_CASE       )

							a_		:	Any									=   model(__SCREAMING_SNAKE_CASE	,    __SCREAMING_SNAKE_CASE	,    attention_mask=__SCREAMING_SNAKE_CASE	,    token_type_ids=__SCREAMING_SNAKE_CASE	,    labels=__SCREAMING_SNAKE_CASE       )
							self.parent.assertEqual(result.logits.shape	,    (self.batch_size, self.seq_length, self.num_labels)       )






			def       SCREAMING_SNAKE_CASE   (			self   :      Dict	,    __SCREAMING_SNAKE_CASE   :      Union[str, Any]	,    __SCREAMING_SNAKE_CASE   :      Tuple	,    __SCREAMING_SNAKE_CASE   :      Union[str, Any]	,    __SCREAMING_SNAKE_CASE   :      Union[str, Any]	,    __SCREAMING_SNAKE_CASE   :      int	,    __SCREAMING_SNAKE_CASE   :      List[Any]	,    __SCREAMING_SNAKE_CASE   :      Optional[Any]	,    __SCREAMING_SNAKE_CASE   :      Optional[Any]       )      ->      Union[str, Any]:
							a_		:	List[str]									=   TFLayoutLMForQuestionAnswering(config=__SCREAMING_SNAKE_CASE       )

							a_		:	List[Any]									=   model(__SCREAMING_SNAKE_CASE	,    __SCREAMING_SNAKE_CASE	,    attention_mask=__SCREAMING_SNAKE_CASE	,    token_type_ids=__SCREAMING_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       SCREAMING_SNAKE_CASE   (			self   :      Any       )      ->      Union[str, Any]:
							a_		:	List[str]									=   self.prepare_config_and_inputs()
							(
							    (
							    a_
							)					,      (
							    a_
							)					,      (
							    a_
							)					,      (
							    a_
							)					,      (
							    a_
							)					,      (
							    a_
							)					,      (
							    a_
							)					,      (
							    a_
							)					,      
							)		:	str									=   config_and_inputs
							a_		:	str									=   {
							    '''input_ids''': input_ids,
							    '''bbox''': bbox,
							    '''token_type_ids''': token_type_ids,
							    '''attention_mask''': input_mask,
							}
							return config, inputs_dict





@require_tf
class 						SCREAMING_SNAKE_CASE       (       SCREAMING_SNAKE_CASE_						, SCREAMING_SNAKE_CASE_						, unittest.TestCase							):
			snake_case__	=					(
			    (
			        TFLayoutLMModel,
			        TFLayoutLMForMaskedLM,
			        TFLayoutLMForTokenClassification,
			        TFLayoutLMForSequenceClassification,
			        TFLayoutLMForQuestionAnswering,
			    )
			    if is_tf_available()
			    else ()
			)
			snake_case__	=					(
			    {
			        "feature-extraction": TFLayoutLMModel,
			        "fill-mask": TFLayoutLMForMaskedLM,
			        "text-classification": TFLayoutLMForSequenceClassification,
			        "token-classification": TFLayoutLMForTokenClassification,
			        "zero-shot": TFLayoutLMForSequenceClassification,
			    }
			    if is_tf_available()
			    else {}
			)
			snake_case__	=					False
			snake_case__	=					True
			snake_case__	=					10






			def       SCREAMING_SNAKE_CASE   (			self   :      str       )      ->      Dict:
							a_		:	Union[str, Any]									=   TFLayoutLMModelTester(self       )
							a_		:	str									=   ConfigTester(self	,    config_class=__SCREAMING_SNAKE_CASE	,    hidden_size=37       )






			def       SCREAMING_SNAKE_CASE   (			self   :      Dict       )      ->      Optional[int]:
							self.config_tester.run_common_tests()






			def       SCREAMING_SNAKE_CASE   (			self   :      Tuple       )      ->      int:
							a_		:	Union[str, Any]									=   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*__SCREAMING_SNAKE_CASE       )






			def       SCREAMING_SNAKE_CASE   (			self   :      Any       )      ->      Optional[int]:
							a_		:	int									=   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_masked_lm(*__SCREAMING_SNAKE_CASE       )






			def       SCREAMING_SNAKE_CASE   (			self   :      List[str]       )      ->      Tuple:
							a_		:	Tuple									=   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_sequence_classification(*__SCREAMING_SNAKE_CASE       )






			def       SCREAMING_SNAKE_CASE   (			self   :      List[Any]       )      ->      Optional[Any]:
							a_		:	Dict									=   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_token_classification(*__SCREAMING_SNAKE_CASE       )






			def       SCREAMING_SNAKE_CASE   (			self   :      int       )      ->      Union[str, Any]:
							a_		:	Union[str, Any]									=   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_question_answering(*__SCREAMING_SNAKE_CASE       )






			@slow
			def       SCREAMING_SNAKE_CASE   (			self   :      str       )      ->      Union[str, Any]:
							for model_name in TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											a_		:	Any									=   TFLayoutLMModel.from_pretrained(__SCREAMING_SNAKE_CASE       )
											self.assertIsNotNone(__SCREAMING_SNAKE_CASE       )







			@unittest.skip('''Onnx compliancy broke with TF 2.10'''       )
			def       SCREAMING_SNAKE_CASE   (			self   :      int       )      ->      Dict:
							pass





def 		_UpperCAmelCase (				):
				# Here we prepare a batch of 2 sequences to test a LayoutLM forward pass on:
				# fmt: off
				a_		:	Optional[Any]									=   tf.convert_to_tensor([[1_01,10_19,10_14,10_16,10_37,1_28_49,47_47,10_04,1_42_46,22_78,54_39,45_24,50_02,29_30,21_93,29_30,43_41,32_08,10_05,10_55,21_71,28_48,1_13_00,35_31,1_02],[1_01,40_70,40_34,70_20,10_24,30_58,10_15,10_13,28_61,10_13,60_70,1_92_74,27_72,62_05,2_78_14,1_61_47,1_61_47,43_43,20_47,1_02_83,1_09_69,1_43_89,10_12,23_38,1_02]]   )  # noqa: E231
				a_		:	Optional[Any]									=   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
				a_		:	List[str]									=   tf.convert_to_tensor([[[0,0,0,0],[4_23,2_37,4_40,2_51],[4_27,2_72,4_41,2_87],[4_19,1_15,4_37,1_29],[9_61,8_85,9_92,9_12],[2_56,38,3_30,58],[2_56,38,3_30,58],[3_36,42,3_53,57],[3_60,39,4_01,56],[3_60,39,4_01,56],[4_11,39,4_71,59],[4_79,41,5_28,59],[5_33,39,6_30,60],[67,1_13,1_34,1_31],[1_41,1_15,2_09,1_32],[68,1_49,1_33,1_66],[1_41,1_49,1_87,1_64],[1_95,1_48,2_87,1_65],[1_95,1_48,2_87,1_65],[1_95,1_48,2_87,1_65],[2_95,1_48,3_49,1_65],[4_41,1_49,4_92,1_66],[4_97,1_49,5_46,1_64],[64,2_01,1_25,2_18],[10_00,10_00,10_00,10_00]],[[0,0,0,0],[6_62,1_50,7_54,1_66],[6_65,1_99,7_42,2_11],[5_19,2_13,5_54,2_28],[5_19,2_13,5_54,2_28],[1_34,4_33,1_87,4_54],[1_30,4_67,2_04,4_80],[1_30,4_67,2_04,4_80],[1_30,4_67,2_04,4_80],[1_30,4_67,2_04,4_80],[1_30,4_67,2_04,4_80],[3_14,4_69,3_76,4_82],[5_04,6_84,5_82,7_06],[9_41,8_25,9_73,9_00],[9_41,8_25,9_73,9_00],[9_41,8_25,9_73,9_00],[9_41,8_25,9_73,9_00],[6_10,7_49,6_52,7_65],[1_30,6_59,1_68,6_72],[1_76,6_57,2_37,6_72],[2_38,6_57,3_12,6_72],[4_43,6_53,6_28,6_72],[4_43,6_53,6_28,6_72],[7_16,3_01,8_25,3_17],[10_00,10_00,10_00,10_00]]]   )  # noqa: E231
				a_		:	List[Any]									=   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)
				a_		:	Any									=   tf.convert_to_tensor([[-1_00,10,10,10,9,1,-1_00,7,7,-1_00,7,7,4,2,5,2,8,8,-1_00,-1_00,5,0,3,2,-1_00],[-1_00,12,12,12,-1_00,12,10,-1_00,-1_00,-1_00,-1_00,10,12,9,-1_00,-1_00,-1_00,10,10,10,9,12,-1_00,10,-1_00]]   )  # noqa: E231
				# fmt: on

				return input_ids, attention_mask, bbox, token_type_ids, labels





@require_tf
class 						SCREAMING_SNAKE_CASE       (       unittest.TestCase							):






			@slow
			def       SCREAMING_SNAKE_CASE   (			self   :      Optional[int]       )      ->      Tuple:
							a_		:	Dict									=   TFLayoutLMModel.from_pretrained('''microsoft/layoutlm-base-uncased'''       )

							a_					,      a_					,      a_					,      a_					,      a_		:	Any									=   prepare_layoutlm_batch_inputs()

							# forward pass
							a_		:	int									=   model(input_ids=__SCREAMING_SNAKE_CASE	,    bbox=__SCREAMING_SNAKE_CASE	,    attention_mask=__SCREAMING_SNAKE_CASE	,    token_type_ids=__SCREAMING_SNAKE_CASE       )

							# test the sequence output on [0, :3, :3]
							a_		:	Dict									=   tf.convert_to_tensor(
							    [[0.1785, -0.1947, -0.0425], [-0.3254, -0.2807, 0.2553], [-0.5391, -0.3322, 0.3364]]	,    )

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

							# test the pooled output on [1, :3]
							a_		:	Optional[int]									=   tf.convert_to_tensor([-0.6580, -0.0214, 0.8552]       )

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






			@slow
			def       SCREAMING_SNAKE_CASE   (			self   :      Optional[int]       )      ->      List[str]:
							# initialize model with randomly initialized sequence classification head
							a_		:	Any									=   TFLayoutLMForSequenceClassification.from_pretrained('''microsoft/layoutlm-base-uncased'''	,    num_labels=2       )

							a_					,      a_					,      a_					,      a_					,      a_		:	Any									=   prepare_layoutlm_batch_inputs()

							# forward pass
							a_		:	Tuple									=   model(
							    input_ids=__SCREAMING_SNAKE_CASE	,    bbox=__SCREAMING_SNAKE_CASE	,    attention_mask=__SCREAMING_SNAKE_CASE	,    token_type_ids=__SCREAMING_SNAKE_CASE	,    labels=tf.convert_to_tensor([1, 1]       )	,    )

							# test whether we get a loss as a scalar
							a_		:	Union[str, Any]									=   outputs.loss
							a_		:	Any									=   (2,)
							self.assertEqual(loss.shape	,    __SCREAMING_SNAKE_CASE       )

							# test the shape of the logits
							a_		:	str									=   outputs.logits
							a_		:	Dict									=   (2, 2)
							self.assertEqual(logits.shape	,    __SCREAMING_SNAKE_CASE       )






			@slow
			def       SCREAMING_SNAKE_CASE   (			self   :      Union[str, Any]       )      ->      Dict:
							# initialize model with randomly initialized token classification head
							a_		:	int									=   TFLayoutLMForTokenClassification.from_pretrained('''microsoft/layoutlm-base-uncased'''	,    num_labels=13       )

							a_					,      a_					,      a_					,      a_					,      a_		:	str									=   prepare_layoutlm_batch_inputs()

							# forward pass
							a_		:	Dict									=   model(
							    input_ids=__SCREAMING_SNAKE_CASE	,    bbox=__SCREAMING_SNAKE_CASE	,    attention_mask=__SCREAMING_SNAKE_CASE	,    token_type_ids=__SCREAMING_SNAKE_CASE	,    labels=__SCREAMING_SNAKE_CASE       )

							# test the shape of the logits
							a_		:	str									=   outputs.logits
							a_		:	Any									=   tf.convert_to_tensor((2, 25, 13)       )
							self.assertEqual(logits.shape	,    __SCREAMING_SNAKE_CASE       )







			@slow
			def       SCREAMING_SNAKE_CASE   (			self   :      Dict       )      ->      Union[str, Any]:
							# initialize model with randomly initialized token classification head
							a_		:	str									=   TFLayoutLMForQuestionAnswering.from_pretrained('''microsoft/layoutlm-base-uncased'''       )

							a_					,      a_					,      a_					,      a_					,      a_		:	Optional[int]									=   prepare_layoutlm_batch_inputs()

							# forward pass
							a_		:	Optional[Any]									=   model(input_ids=__SCREAMING_SNAKE_CASE	,    bbox=__SCREAMING_SNAKE_CASE	,    attention_mask=__SCREAMING_SNAKE_CASE	,    token_type_ids=__SCREAMING_SNAKE_CASE       )

							# test the shape of the logits
							a_		:	Dict									=   tf.convert_to_tensor((2, 25)       )
							self.assertEqual(outputs.start_logits.shape	,    __SCREAMING_SNAKE_CASE       )
							self.assertEqual(outputs.end_logits.shape	,    __SCREAMING_SNAKE_CASE       )












'''simple docstring'''







from __future__ import annotations





def 		_UpperCAmelCase (				__A				: str    ,		__A				: str   ):
				a_		:	int									=   get_failure_array(__A   )

				# 2) Step through text searching for pattern
				a_					,      a_		:	Any									=   0, 0  # index into text, pattern
				while i < len(__A   ):
								if pattern[j] == text[i]:
												if j == (len(__A   ) - 1):
																return True
												j += 1

								# if this is a prefix in our pattern
								# just go back far enough to continue
								elif j > 0:
												a_		:	Any									=   failure[j - 1]
												continue
								i += 1
				return False





def 		_UpperCAmelCase (				__A				: str   ):
				a_		:	Optional[Any]									=   [0]
				a_		:	Any									=   0
				a_		:	int									=   1
				while j < len(__A   ):
								if pattern[i] == pattern[j]:
												i += 1
								elif i > 0:
												a_		:	List[Any]									=   failure[i - 1]
												continue
								j += 1
								failure.append(__A   )
				return failure


if __name__ == "__main__":
		# Test 1)
		__lowerCAmelCase									=   'abc1abc12'
		__lowerCAmelCase									=   'alskfjaldsabc1abc1abc12k23adsfabcabc'
		__lowerCAmelCase									=   'alskfjaldsk23adsfabcabc'
		assert kmp(pattern, texta) and not kmp(pattern, texta)

		# Test 2)
		__lowerCAmelCase									=   'ABABX'
		__lowerCAmelCase									=   'ABABZABABYABABX'
		assert kmp(pattern, text)

		# Test 3)
		__lowerCAmelCase									=   'AAAB'
		__lowerCAmelCase									=   'ABAAAAAB'
		assert kmp(pattern, text)

		# Test 4)
		__lowerCAmelCase									=   'abcdabcy'
		__lowerCAmelCase									=   'abcxabcdabxabcdabcdabcy'
		assert kmp(pattern, text)

		# Test 5)
		__lowerCAmelCase									=   'aabaabaaa'
		assert get_failure_array(pattern) == [0, 1, 0, 1, 2, 3, 4, 5, 2]




