




'''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        _a    :






					def __init__(			self ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE=13 ,_SCREAMING_SNAKE_CASE=7 ,_SCREAMING_SNAKE_CASE=True ,_SCREAMING_SNAKE_CASE=True ,_SCREAMING_SNAKE_CASE=True ,_SCREAMING_SNAKE_CASE=True ,_SCREAMING_SNAKE_CASE=99 ,_SCREAMING_SNAKE_CASE=32 ,_SCREAMING_SNAKE_CASE=2 ,_SCREAMING_SNAKE_CASE=4 ,_SCREAMING_SNAKE_CASE=37 ,_SCREAMING_SNAKE_CASE="gelu" ,_SCREAMING_SNAKE_CASE=0.1 ,_SCREAMING_SNAKE_CASE=0.1 ,_SCREAMING_SNAKE_CASE=512 ,_SCREAMING_SNAKE_CASE=16 ,_SCREAMING_SNAKE_CASE=2 ,_SCREAMING_SNAKE_CASE=0.0_2 ,_SCREAMING_SNAKE_CASE=3 ,_SCREAMING_SNAKE_CASE=4 ,_SCREAMING_SNAKE_CASE=None ,_SCREAMING_SNAKE_CASE=1_000 ,)							->      Optional[Any]:
										_snake_case							=				parent
										_snake_case							=				batch_size
										_snake_case							=				seq_length
										_snake_case							=				is_training
										_snake_case							=				use_input_mask
										_snake_case							=				use_token_type_ids
										_snake_case							=				use_labels
										_snake_case							=				vocab_size
										_snake_case							=				hidden_size
										_snake_case							=				num_hidden_layers
										_snake_case							=				num_attention_heads
										_snake_case							=				intermediate_size
										_snake_case							=				hidden_act
										_snake_case							=				hidden_dropout_prob
										_snake_case							=				attention_probs_dropout_prob
										_snake_case							=				max_position_embeddings
										_snake_case							=				type_vocab_size
										_snake_case							=				type_sequence_label_size
										_snake_case							=				initializer_range
										_snake_case							=				num_labels
										_snake_case							=				num_choices
										_snake_case							=				scope
										_snake_case							=				range_bbox






					def     _lowercase     (			self   )							->      int:
										_snake_case							=				ids_tensor([self.batch_size, self.seq_length] ,self.vocab_size   )

										# convert bbox to numpy since TF does not support item assignment
										_snake_case							=				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]:
																									_snake_case							=				bbox[i, j, 3]
																									_snake_case							=				bbox[i, j, 1]
																									_snake_case							=				t
																				if bbox[i, j, 2] < bbox[i, j, 0]:
																									_snake_case							=				bbox[i, j, 2]
																									_snake_case							=				bbox[i, j, 0]
																									_snake_case							=				t
										_snake_case							=				tf.convert_to_tensor(_SCREAMING_SNAKE_CASE   )

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

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

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

										_snake_case							=				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     _lowercase     (			self ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE   )							->      Dict:
										_snake_case							=				TFLayoutLMModel(config=_SCREAMING_SNAKE_CASE   )

										_snake_case							=				model(_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,attention_mask=_SCREAMING_SNAKE_CASE ,token_type_ids=_SCREAMING_SNAKE_CASE   )
										_snake_case							=				model(_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,token_type_ids=_SCREAMING_SNAKE_CASE   )
										_snake_case							=				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     _lowercase     (			self ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE   )							->      str:
										_snake_case							=				TFLayoutLMForMaskedLM(config=_SCREAMING_SNAKE_CASE   )

										_snake_case							=				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     _lowercase     (			self ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE   )							->      Optional[Any]:
										_snake_case							=				self.num_labels
										_snake_case							=				TFLayoutLMForSequenceClassification(config=_SCREAMING_SNAKE_CASE   )

										_snake_case							=				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     _lowercase     (			self ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE   )							->      Any:
										_snake_case							=				self.num_labels
										_snake_case							=				TFLayoutLMForTokenClassification(config=_SCREAMING_SNAKE_CASE   )

										_snake_case							=				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     _lowercase     (			self ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE   )							->      Optional[Any]:
										_snake_case							=				TFLayoutLMForQuestionAnswering(config=_SCREAMING_SNAKE_CASE   )

										_snake_case							=				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     _lowercase     (			self   )							->      Dict:
										_snake_case							=				self.prepare_config_and_inputs()
										(
										    (
										    _snake_case 
										)							, (
										    _snake_case 
										)							, (
										    _snake_case 
										)							, (
										    _snake_case 
										)							, (
										    _snake_case 
										)							, (
										    _snake_case 
										)							, (
										    _snake_case 
										)							, (
										    _snake_case 
										)							,  
										)							=				config_and_inputs
										_snake_case							=				{
										    "input_ids": input_ids,
										    "bbox": bbox,
										    "token_type_ids": token_type_ids,
										    "attention_mask": input_mask,
										}
										return config, inputs_dict







@require_tf
class        _a    (						__lowerCAmelCase , __lowerCAmelCase , unittest.TestCase							):
					SCREAMING_SNAKE_CASE_							:   List[str]       =						(
					    (
					        TFLayoutLMModel,
					        TFLayoutLMForMaskedLM,
					        TFLayoutLMForTokenClassification,
					        TFLayoutLMForSequenceClassification,
					        TFLayoutLMForQuestionAnswering,
					    )
					    if is_tf_available()
					    else ()
					)
					SCREAMING_SNAKE_CASE_							:   List[str]       =						(
					    {
					        """feature-extraction""": TFLayoutLMModel,
					        """fill-mask""": TFLayoutLMForMaskedLM,
					        """text-classification""": TFLayoutLMForSequenceClassification,
					        """token-classification""": TFLayoutLMForTokenClassification,
					        """zero-shot""": TFLayoutLMForSequenceClassification,
					    }
					    if is_tf_available()
					    else {}
					)
					SCREAMING_SNAKE_CASE_							:   Optional[Any]       =						False
					SCREAMING_SNAKE_CASE_							:   Optional[Any]       =						True
					SCREAMING_SNAKE_CASE_							:   List[str]       =						10






					def     _lowercase     (			self   )							->      Optional[Any]:
										_snake_case							=				TFLayoutLMModelTester(self   )
										_snake_case							=				ConfigTester(self ,config_class=_SCREAMING_SNAKE_CASE ,hidden_size=37   )






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






					def     _lowercase     (			self   )							->      str:
										_snake_case							=				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*_SCREAMING_SNAKE_CASE   )






					def     _lowercase     (			self   )							->      str:
										_snake_case							=				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_masked_lm(*_SCREAMING_SNAKE_CASE   )






					def     _lowercase     (			self   )							->      Optional[Any]:
										_snake_case							=				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_sequence_classification(*_SCREAMING_SNAKE_CASE   )






					def     _lowercase     (			self   )							->      Dict:
										_snake_case							=				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_token_classification(*_SCREAMING_SNAKE_CASE   )






					def     _lowercase     (			self   )							->      List[str]:
										_snake_case							=				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_question_answering(*_SCREAMING_SNAKE_CASE   )






					@slow
					def     _lowercase     (			self   )							->      int:
										for model_name in TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
															_snake_case							=				TFLayoutLMModel.from_pretrained(_SCREAMING_SNAKE_CASE   )
															self.assertIsNotNone(_SCREAMING_SNAKE_CASE   )






					@unittest.skip("Onnx compliancy broke with TF 2.10"   )
					def     _lowercase     (			self   )							->      int:
										pass







def      __a     (       )						->			str:

					"""simple docstring"""




					_snake_case							=				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
					_snake_case							=				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
					_snake_case							=				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
					_snake_case							=				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)
					_snake_case							=				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        _a    (						unittest.TestCase							):






					@slow
					def     _lowercase     (			self   )							->      Optional[int]:
										_snake_case							=				TFLayoutLMModel.from_pretrained("microsoft/layoutlm-base-uncased"   )

										_snake_case							, _snake_case							, _snake_case							, _snake_case							, _snake_case							=				prepare_layoutlm_batch_inputs()

										# forward pass
										_snake_case							=				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]
										_snake_case							=				tf.convert_to_tensor(
										    [[0.1_7_8_5, -0.1_9_4_7, -0.0_4_2_5], [-0.3_2_5_4, -0.2_8_0_7, 0.2_5_5_3], [-0.5_3_9_1, -0.3_3_2_2, 0.3_3_6_4]] ,)

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

										# test the pooled output on [1, :3]
										_snake_case							=				tf.convert_to_tensor([-0.6_5_8_0, -0.0_2_1_4, 0.8_5_5_2]   )

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






					@slow
					def     _lowercase     (			self   )							->      Dict:
										# initialize model with randomly initialized sequence classification head
										_snake_case							=				TFLayoutLMForSequenceClassification.from_pretrained("microsoft/layoutlm-base-uncased" ,num_labels=2   )

										_snake_case							, _snake_case							, _snake_case							, _snake_case							, _snake_case							=				prepare_layoutlm_batch_inputs()

										# forward pass
										_snake_case							=				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
										_snake_case							=				outputs.loss
										_snake_case							=				(2,)
										self.assertEqual(loss.shape ,_SCREAMING_SNAKE_CASE   )

										# test the shape of the logits
										_snake_case							=				outputs.logits
										_snake_case							=				(2, 2)
										self.assertEqual(logits.shape ,_SCREAMING_SNAKE_CASE   )






					@slow
					def     _lowercase     (			self   )							->      List[str]:
										# initialize model with randomly initialized token classification head
										_snake_case							=				TFLayoutLMForTokenClassification.from_pretrained("microsoft/layoutlm-base-uncased" ,num_labels=13   )

										_snake_case							, _snake_case							, _snake_case							, _snake_case							, _snake_case							=				prepare_layoutlm_batch_inputs()

										# forward pass
										_snake_case							=				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
										_snake_case							=				outputs.logits
										_snake_case							=				tf.convert_to_tensor((2, 25, 13)   )
										self.assertEqual(logits.shape ,_SCREAMING_SNAKE_CASE   )






					@slow
					def     _lowercase     (			self   )							->      Optional[int]:
										# initialize model with randomly initialized token classification head
										_snake_case							=				TFLayoutLMForQuestionAnswering.from_pretrained("microsoft/layoutlm-base-uncased"   )

										_snake_case							, _snake_case							, _snake_case							, _snake_case							, _snake_case							=				prepare_layoutlm_batch_inputs()

										# forward pass
										_snake_case							=				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
										_snake_case							=				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'''





import pprint

import requests

UpperCamelCase_						:      Tuple       =						'''https://zenquotes.io/api'''





def      __a     (       )						->			list:

     """simple docstring"""




     return requests.get(API_ENDPOINT_URL + "/today"   ).json()





def      __a     (       )						->			list:

     """simple docstring"""




     return requests.get(API_ENDPOINT_URL + "/random"   ).json()


if __name__ == "__main__":
   UpperCamelCase_						:      Any       =						random_quotes()
   pprint.pprint(response)


