



import unittest

from transformers import LayoutLMConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
			import torch

			from transformers import (
			    LayoutLMForMaskedLM,
			    LayoutLMForQuestionAnswering,
			    LayoutLMForSequenceClassification,
			    LayoutLMForTokenClassification,
			    LayoutLMModel,
			)
class       _lowerCAmelCase :






			"""simple docstring"""





			def __init__(					self						:							Optional[Any]      ,  lowercase						:							int      ,  lowercase						:							Dict=13      ,  lowercase						:							List[str]=7      ,  lowercase						:							List[str]=True      ,  lowercase						:							List[str]=True      ,  lowercase						:							Union[str, Any]=True      ,  lowercase						:							str=True      ,  lowercase						:							Dict=99      ,  lowercase						:							Tuple=32      ,  lowercase						:							List[Any]=5      ,  lowercase						:							List[str]=4      ,  lowercase						:							int=37      ,  lowercase						:							str="gelu"      ,  lowercase						:							Dict=0.1      ,  lowercase						:							List[Any]=0.1      ,  lowercase						:							Tuple=512      ,  lowercase						:							int=16      ,  lowercase						:							List[Any]=2      ,  lowercase						:							Dict=0.02      ,  lowercase						:							Optional[Any]=3      ,  lowercase						:							Optional[Any]=4      ,  lowercase						:							int=None      ,  lowercase						:							Any=1_000      ,  )    ->       List[str]:
									"""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 		snake_case__      (					self						:							Optional[Any] )    ->       Dict:
									"""simple docstring"""







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

									__lowercase											=					ids_tensor([self.batch_size, self.seq_length, 4]      ,  self.range_bbox )
									# 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											=					None
									if self.use_input_mask:
															__lowercase											=					ids_tensor([self.batch_size, self.seq_length]      ,  vocab_size=2 )

									__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											=					self.get_config()

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





			def 		snake_case__      (					self						:							Tuple )    ->       Tuple:
									"""simple docstring"""







									return 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      ,  )





			def 		snake_case__      (					self						:							Optional[Any]      ,  lowercase						:							List[str]      ,  lowercase						:							Optional[int]      ,  lowercase						:							Dict      ,  lowercase						:							List[str]      ,  lowercase						:							str      ,  lowercase						:							List[Any]      ,  lowercase						:							Tuple      ,  lowercase						:							str )    ->       List[str]:
									"""simple docstring"""







									__lowercase											=					LayoutLMModel(config=lowercase )
									model.to(lowercase )
									model.eval()
									__lowercase											=					model(lowercase      ,  lowercase      ,  attention_mask=lowercase      ,  token_type_ids=lowercase )
									__lowercase											=					model(lowercase      ,  lowercase      ,  token_type_ids=lowercase )
									__lowercase											=					model(lowercase      ,  lowercase )
									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 		snake_case__      (					self						:							List[str]      ,  lowercase						:							Tuple      ,  lowercase						:							Union[str, Any]      ,  lowercase						:							Optional[int]      ,  lowercase						:							Union[str, Any]      ,  lowercase						:							List[str]      ,  lowercase						:							Tuple      ,  lowercase						:							Tuple      ,  lowercase						:							Dict )    ->       Union[str, Any]:
									"""simple docstring"""







									__lowercase											=					LayoutLMForMaskedLM(config=lowercase )
									model.to(lowercase )
									model.eval()
									__lowercase											=					model(lowercase      ,  lowercase      ,  attention_mask=lowercase      ,  token_type_ids=lowercase      ,  labels=lowercase )
									self.parent.assertEqual(result.logits.shape      ,  (self.batch_size, self.seq_length, self.vocab_size) )





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







									__lowercase											=					self.num_labels
									__lowercase											=					LayoutLMForSequenceClassification(lowercase )
									model.to(lowercase )
									model.eval()
									__lowercase											=					model(
									    lowercase      ,  lowercase      ,  attention_mask=lowercase      ,  token_type_ids=lowercase      ,  labels=lowercase )
									self.parent.assertEqual(result.logits.shape      ,  (self.batch_size, self.num_labels) )





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







									__lowercase											=					self.num_labels
									__lowercase											=					LayoutLMForTokenClassification(config=lowercase )
									model.to(lowercase )
									model.eval()
									__lowercase											=					model(lowercase      ,  lowercase      ,  attention_mask=lowercase      ,  token_type_ids=lowercase      ,  labels=lowercase )
									self.parent.assertEqual(result.logits.shape      ,  (self.batch_size, self.seq_length, self.num_labels) )





			def 		snake_case__      (					self						:							str      ,  lowercase						:							Optional[Any]      ,  lowercase						:							Optional[Any]      ,  lowercase						:							List[str]      ,  lowercase						:							int      ,  lowercase						:							int      ,  lowercase						:							Any      ,  lowercase						:							Any      ,  lowercase						:							List[Any] )    ->       Union[str, Any]:
									"""simple docstring"""







									__lowercase											=					LayoutLMForQuestionAnswering(config=lowercase )
									model.to(lowercase )
									model.eval()
									__lowercase											=					model(
									    lowercase      ,  bbox=lowercase      ,  attention_mask=lowercase      ,  token_type_ids=lowercase      ,  start_positions=lowercase      ,  end_positions=lowercase      ,  )
									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 		snake_case__      (					self						:							Any )    ->       Union[str, Any]:
									"""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_torch
class       _lowerCAmelCase (			_UpperCAmelCase     ,       _UpperCAmelCase     ,       unittest.TestCase      ):






			"""simple docstring"""





			lowercase__   :	List[Any]  			=      (
			    (
			        LayoutLMModel,
			        LayoutLMForMaskedLM,
			        LayoutLMForSequenceClassification,
			        LayoutLMForTokenClassification,
			        LayoutLMForQuestionAnswering,
			    )
			    if is_torch_available()
			    else None
			)
			lowercase__   :	Dict  			=      (
			    {
			        """document-question-answering""": LayoutLMForQuestionAnswering,
			        """feature-extraction""": LayoutLMModel,
			        """fill-mask""": LayoutLMForMaskedLM,
			        """text-classification""": LayoutLMForSequenceClassification,
			        """token-classification""": LayoutLMForTokenClassification,
			        """zero-shot""": LayoutLMForSequenceClassification,
			    }
			    if is_torch_available()
			    else {}
			)
			lowercase__   :	List[Any]  			=      True





			def 		snake_case__      (					self						:							Dict )    ->       Dict:
									"""simple docstring"""







									__lowercase											=					LayoutLMModelTester(self )
									__lowercase											=					ConfigTester(self      ,  config_class=lowercase      ,  hidden_size=37 )





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







									self.config_tester.run_common_tests()





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







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





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







									__lowercase											=					self.model_tester.prepare_config_and_inputs()
									for type in ["absolute", "relative_key", "relative_key_query"]:
															__lowercase											=					type
															self.model_tester.create_and_check_model(*lowercase )





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







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





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







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





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







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





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







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







			@unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests.""" )
			def 		snake_case__      (					self						:							Optional[int] )    ->       Optional[int]:
									"""simple docstring"""







									pass






def 			UpperCAmelCase__     (     )			->   int:
						# Here we prepare a batch of 2 sequences to test a LayoutLM forward pass on:
						# fmt: off
						__lowercase											=					torch.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]]    ,							device=lowercase__ )  # noqa: E231
						__lowercase											=					torch.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],]    ,							device=lowercase__ )  # noqa: E231
						__lowercase											=					torch.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]]]    ,							device=lowercase__ )  # noqa: E231
						__lowercase											=					torch.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]]    ,							device=lowercase__ )  # noqa: E231
						# these are sequence labels (i.e. at the token level)
						__lowercase											=					torch.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]]    ,							device=lowercase__ )  # noqa: E231
						# fmt: on

						return input_ids, attention_mask, bbox, token_type_ids, labels







@require_torch
class       _lowerCAmelCase (			unittest.TestCase      ):






			"""simple docstring"""





			@slow
			def 		snake_case__      (					self						:							int )    ->       Dict:
									"""simple docstring"""







									__lowercase											=					LayoutLMModel.from_pretrained("""microsoft/layoutlm-base-uncased""" ).to(lowercase )

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

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

									# test the sequence output on [0, :3, :3]
									__lowercase											=					torch.tensor(
									    [[0.1785, -0.1947, -0.0425], [-0.3254, -0.2807, 0.2553], [-0.5391, -0.3322, 0.3364]]      ,  device=lowercase      ,  )

									self.assertTrue(torch.allclose(outputs.last_hidden_state[0, :3, :3]      ,  lowercase      ,  atol=1E-3 ) )

									# test the pooled output on [1, :3]
									__lowercase											=					torch.tensor([-0.6580, -0.0214, 0.8552]      ,  device=lowercase )

									self.assertTrue(torch.allclose(outputs.pooler_output[1, :3]      ,  lowercase      ,  atol=1E-3 ) )





			@slow
			def 		snake_case__      (					self						:							Any )    ->       Optional[Any]:
									"""simple docstring"""







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

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

									# forward pass
									__lowercase											=					model(
									    input_ids=lowercase      ,  bbox=lowercase      ,  attention_mask=lowercase      ,  token_type_ids=lowercase      ,  labels=torch.tensor([1, 1]      ,  device=lowercase )      ,  )

									# test whether we get a loss as a scalar
									__lowercase											=					outputs.loss
									__lowercase											=					torch.Size([] )
									self.assertEqual(loss.shape      ,  lowercase )

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





			@slow
			def 		snake_case__      (					self						:							Any )    ->       Optional[Any]:
									"""simple docstring"""







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

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

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

									# test the loss calculation to be around 2.65
									# expected_loss = torch.tensor(2.65, device=torch_device)

									# The loss is currently somewhat random and can vary between 0.1-0.3 atol.
									# self.assertTrue(torch.allclose(outputs.loss, expected_loss, atol=0.1))

									# test the shape of the logits
									__lowercase											=					outputs.logits
									__lowercase											=					torch.Size((2, 25, 13) )
									self.assertEqual(logits.shape      ,  lowercase )







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







									__lowercase											=					LayoutLMForQuestionAnswering.from_pretrained("""microsoft/layoutlm-base-uncased""" ).to(lowercase )

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

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

									# test the shape of the logits
									__lowercase											=					torch.Size((2, 25) )
									self.assertEqual(outputs.start_logits.shape      ,  lowercase )
									self.assertEqual(outputs.end_logits.shape      ,  lowercase )










from __future__ import annotations






def 			UpperCAmelCase__     (     lowercase__ )			->   list[int]:
						if not list_of_ints:
												return []

						if min(lowercase__ ) < 0:
												raise ValueError("""All numbers must be positive""" )

						__lowercase											=					max(len(bin(lowercase__ )[2:] ) for x in list_of_ints )
						return _msd_radix_sort(lowercase__    ,							lowercase__ )






def 			UpperCAmelCase__     (     lowercase__    ,							lowercase__ )			->   list[int]:
						if bit_position == 0 or len(lowercase__ ) in [0, 1]:
												return list_of_ints

						__lowercase											=					[]
						__lowercase											=					[]
						# Split numbers based on bit at bit_position from the right
						for number in list_of_ints:
												if (number >> (bit_position - 1)) & 1:
																		# number has a one at bit bit_position
																		ones.append(lowercase__ )
												else:
																		# number has a zero at bit bit_position
																		zeros.append(lowercase__ )

    # recursively split both lists further
						__lowercase											=					_msd_radix_sort(lowercase__    ,							bit_position - 1 )
						__lowercase											=					_msd_radix_sort(lowercase__    ,							bit_position - 1 )

						# recombine lists
						__lowercase											=					zeros
						res.extend(lowercase__ )

						return res






def 			UpperCAmelCase__     (     lowercase__ )			->   List[Any]:
						__lowercase											=					len(lowercase__ )
						if not list_of_ints or length == 1:
												return

						if min(lowercase__ ) < 0:
												raise ValueError("""All numbers must be positive""" )

						__lowercase											=					max(len(bin(lowercase__ )[2:] ) for x in list_of_ints )
						_msd_radix_sort_inplace(lowercase__    ,							lowercase__    ,							0    ,							lowercase__ )






def 			UpperCAmelCase__     (     lowercase__    ,							lowercase__    ,							lowercase__    ,							lowercase__ )			->   Optional[Any]:
						if bit_position == 0 or end_index - begin_index <= 1:
												return

						bit_position -= 1

						__lowercase											=					begin_index
						__lowercase											=					end_index - 1
						while i <= j:
												__lowercase											=					False
												if not (list_of_ints[i] >> bit_position) & 1:
																		# found zero at the beginning
																		i += 1
																		__lowercase											=					True
												if (list_of_ints[j] >> bit_position) & 1:
																		# found one at the end
																		j -= 1
																		__lowercase											=					True

												if changed:
																		continue

												__lowercase						,      __lowercase											=					list_of_ints[j], list_of_ints[i]
												j -= 1
												if j != i:
																		i += 1

						_msd_radix_sort_inplace(lowercase__    ,							lowercase__    ,							lowercase__    ,							lowercase__ )
						_msd_radix_sort_inplace(lowercase__    ,							lowercase__    ,							lowercase__    ,							lowercase__ )


if __name__ == "__main__":
			import doctest

			doctest.testmod()





