



'''simple docstring'''


import copy
import unittest

from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

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


if is_torch_available():
						import torch

						from transformers import (
						    MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
						    MODEL_FOR_QUESTION_ANSWERING_MAPPING,
						    MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
						    MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
						    LayoutLMvaConfig,
						    LayoutLMvaForQuestionAnswering,
						    LayoutLMvaForSequenceClassification,
						    LayoutLMvaForTokenClassification,
						    LayoutLMvaModel,
						)
						from transformers.models.layoutlmva.modeling_layoutlmva import LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
						from PIL import Image

						from transformers import LayoutLMvaImageProcessor




class      __UpperCamelCase       :







	def __init__(    self ,				_lowerCAmelCase ,				_lowerCAmelCase=2 ,				_lowerCAmelCase=3 ,				_lowerCAmelCase=4 ,				_lowerCAmelCase=2 ,				_lowerCAmelCase=7 ,				_lowerCAmelCase=True ,				_lowerCAmelCase=True ,				_lowerCAmelCase=True ,				_lowerCAmelCase=True ,				_lowerCAmelCase=99 ,				_lowerCAmelCase=36 ,				_lowerCAmelCase=3 ,				_lowerCAmelCase=4 ,				_lowerCAmelCase=37 ,				_lowerCAmelCase="gelu" ,				_lowerCAmelCase=0.1 ,				_lowerCAmelCase=0.1 ,				_lowerCAmelCase=512 ,				_lowerCAmelCase=16 ,				_lowerCAmelCase=2 ,				_lowerCAmelCase=0.02 ,				_lowerCAmelCase=6 ,				_lowerCAmelCase=6 ,				_lowerCAmelCase=3 ,				_lowerCAmelCase=4 ,				_lowerCAmelCase=None ,				_lowerCAmelCase=1000 ,				)    ->    Dict:
							'''simple docstring'''






							lowercase        =							parent
							lowercase        =							batch_size
							lowercase        =							num_channels
							lowercase        =							image_size
							lowercase        =							patch_size
							lowercase        =							text_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        =							coordinate_size
							lowercase        =							shape_size
							lowercase        =							num_labels
							lowercase        =							num_choices
							lowercase        =							scope
							lowercase        =							range_bbox

							# LayoutLMv3's sequence length equals the number of text tokens + number of patches + 1 (we add 1 for the CLS token)
							lowercase        =							text_seq_length
							lowercase        =							(image_size // patch_size) ** 2 + 1
							lowercase        =							self.text_seq_length + self.image_seq_length







	def   _a   (    self						)    ->    int:
							'''simple docstring'''






							lowercase        =							ids_tensor([self.batch_size, self.text_seq_length] ,				self.vocab_size						)

							lowercase        =							ids_tensor([self.batch_size, self.text_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        =							floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

							lowercase        =							None
							if self.use_input_mask:
													lowercase        =							random_attention_mask([self.batch_size, self.text_seq_length]						)

							lowercase        =							None
							if self.use_token_type_ids:
													lowercase        =							ids_tensor([self.batch_size, self.text_seq_length] ,				self.type_vocab_size						)

							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.text_seq_length] ,				self.num_labels						)

							lowercase        =							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   _a   (    self ,				_lowerCAmelCase ,				_lowerCAmelCase ,				_lowerCAmelCase ,				_lowerCAmelCase ,				_lowerCAmelCase ,				_lowerCAmelCase ,				_lowerCAmelCase ,				_lowerCAmelCase						)    ->    List[str]:
							'''simple docstring'''






							lowercase        =							LayoutLMvaModel(config=_lowerCAmelCase						)
							model.to(_lowerCAmelCase						)
							model.eval()

							# text + image
							lowercase        =							model(_lowerCAmelCase ,				pixel_values=_lowerCAmelCase						)
							lowercase        =							model(
							    _lowerCAmelCase ,				bbox=_lowerCAmelCase ,				pixel_values=_lowerCAmelCase ,				attention_mask=_lowerCAmelCase ,				token_type_ids=_lowerCAmelCase						)
							lowercase        =							model(_lowerCAmelCase ,				bbox=_lowerCAmelCase ,				pixel_values=_lowerCAmelCase ,				token_type_ids=_lowerCAmelCase						)
							lowercase        =							model(_lowerCAmelCase ,				bbox=_lowerCAmelCase ,				pixel_values=_lowerCAmelCase						)

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

							# text only
							lowercase        =							model(_lowerCAmelCase						)
							self.parent.assertEqual(
							    result.last_hidden_state.shape ,				(self.batch_size, self.text_seq_length, self.hidden_size)						)

							# image only
							lowercase        =							model(pixel_values=_lowerCAmelCase						)
							self.parent.assertEqual(
							    result.last_hidden_state.shape ,				(self.batch_size, self.image_seq_length, self.hidden_size)						)







	def   _a   (    self ,				_lowerCAmelCase ,				_lowerCAmelCase ,				_lowerCAmelCase ,				_lowerCAmelCase ,				_lowerCAmelCase ,				_lowerCAmelCase ,				_lowerCAmelCase ,				_lowerCAmelCase						)    ->    Optional[int]:
							'''simple docstring'''






							lowercase        =							self.num_labels
							lowercase        =							LayoutLMvaForSequenceClassification(_lowerCAmelCase						)
							model.to(_lowerCAmelCase						)
							model.eval()
							lowercase        =							model(
							    _lowerCAmelCase ,				bbox=_lowerCAmelCase ,				pixel_values=_lowerCAmelCase ,				attention_mask=_lowerCAmelCase ,				token_type_ids=_lowerCAmelCase ,				labels=_lowerCAmelCase ,				)
							self.parent.assertEqual(result.logits.shape ,				(self.batch_size, self.num_labels)						)







	def   _a   (    self ,				_lowerCAmelCase ,				_lowerCAmelCase ,				_lowerCAmelCase ,				_lowerCAmelCase ,				_lowerCAmelCase ,				_lowerCAmelCase ,				_lowerCAmelCase ,				_lowerCAmelCase						)    ->    int:
							'''simple docstring'''






							lowercase        =							self.num_labels
							lowercase        =							LayoutLMvaForTokenClassification(config=_lowerCAmelCase						)
							model.to(_lowerCAmelCase						)
							model.eval()
							lowercase        =							model(
							    _lowerCAmelCase ,				bbox=_lowerCAmelCase ,				pixel_values=_lowerCAmelCase ,				attention_mask=_lowerCAmelCase ,				token_type_ids=_lowerCAmelCase ,				labels=_lowerCAmelCase ,				)
							self.parent.assertEqual(result.logits.shape ,				(self.batch_size, self.text_seq_length, self.num_labels)						)







	def   _a   (    self ,				_lowerCAmelCase ,				_lowerCAmelCase ,				_lowerCAmelCase ,				_lowerCAmelCase ,				_lowerCAmelCase ,				_lowerCAmelCase ,				_lowerCAmelCase ,				_lowerCAmelCase						)    ->    Any:
							'''simple docstring'''






							lowercase        =							LayoutLMvaForQuestionAnswering(config=_lowerCAmelCase						)
							model.to(_lowerCAmelCase						)
							model.eval()
							lowercase        =							model(
							    _lowerCAmelCase ,				bbox=_lowerCAmelCase ,				pixel_values=_lowerCAmelCase ,				attention_mask=_lowerCAmelCase ,				token_type_ids=_lowerCAmelCase ,				start_positions=_lowerCAmelCase ,				end_positions=_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						)    ->    int:
							'''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,
							    """pixel_values""": pixel_values,
							    """token_type_ids""": token_type_ids,
							    """attention_mask""": input_mask,
							}
							return config, inputs_dict




@require_torch
class      __UpperCamelCase       (_UpperCAmelCase			,   _UpperCAmelCase			,   unittest.TestCase			):
	__A			  =					False
	__A			  =					False
	__A			  =					False

	__A			  =					(
	    (
	        LayoutLMvaModel,
	        LayoutLMvaForSequenceClassification,
	        LayoutLMvaForTokenClassification,
	        LayoutLMvaForQuestionAnswering,
	    )
	    if is_torch_available()
	    else ()
	)
	__A			  =					(
	    {'''document-question-answering''': LayoutLMvaForQuestionAnswering, '''feature-extraction''': LayoutLMvaModel}
	    if is_torch_available()
	    else {}
	)







	def   _a   (    self ,				_lowerCAmelCase ,				_lowerCAmelCase ,				_lowerCAmelCase ,				_lowerCAmelCase ,				_lowerCAmelCase						)    ->    List[str]:
							'''simple docstring'''






							return True







	def   _a   (    self						)    ->    int:
							'''simple docstring'''






							lowercase        =							LayoutLMvaModelTester(self						)
							lowercase        =							ConfigTester(self ,				config_class=_lowerCAmelCase ,				hidden_size=37						)







	def   _a   (    self ,				_lowerCAmelCase ,				_lowerCAmelCase ,				_lowerCAmelCase=False						)    ->    Optional[Any]:
							'''simple docstring'''






							lowercase        =							copy.deepcopy(_lowerCAmelCase						)
							if model_class in get_values(_lowerCAmelCase						):
													lowercase        =							{
													    k: v.unsqueeze(1						).expand(-1 ,				self.model_tester.num_choices ,				-1						).contiguous()
													    if isinstance(_lowerCAmelCase ,				torch.Tensor						) and v.ndim > 1
													    else v
													    for k, v in inputs_dict.items()
													}
							if return_labels:
													if model_class in get_values(_lowerCAmelCase						):
																			lowercase        =							torch.ones(self.model_tester.batch_size ,				dtype=torch.long ,				device=_lowerCAmelCase						)
													elif model_class in get_values(_lowerCAmelCase						):
																			lowercase        =							torch.zeros(
																			    self.model_tester.batch_size ,				dtype=torch.long ,				device=_lowerCAmelCase						)
																			lowercase        =							torch.zeros(
																			    self.model_tester.batch_size ,				dtype=torch.long ,				device=_lowerCAmelCase						)
													elif model_class in [
													    *get_values(_lowerCAmelCase						),
													]:
																			lowercase        =							torch.zeros(
																			    self.model_tester.batch_size ,				dtype=torch.long ,				device=_lowerCAmelCase						)
													elif model_class in [
													    *get_values(_lowerCAmelCase						),
													]:
																			lowercase        =							torch.zeros(
																			    (self.model_tester.batch_size, self.model_tester.text_seq_length) ,				dtype=torch.long ,				device=_lowerCAmelCase ,				)

							return inputs_dict







	def   _a   (    self						)    ->    Any:
							'''simple docstring'''






							self.config_tester.run_common_tests()







	def   _a   (    self						)    ->    str:
							'''simple docstring'''






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







	def   _a   (    self						)    ->    Dict:
							'''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(*_lowerCAmelCase						)







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






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







	def   _a   (    self						)    ->    Union[str, 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[Any]:
							'''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:
							'''simple docstring'''






							for model_name in LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													lowercase        =							LayoutLMvaModel.from_pretrained(_lowerCAmelCase						)
													self.assertIsNotNone(_lowerCAmelCase						)







def      SCREAMING_SNAKE_CASE				(				):
						lowercase        =							Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""						)
						return image




@require_torch
class      __UpperCamelCase       (unittest.TestCase			):







	@cached_property
	def   _a   (    self						)    ->    int:
							'''simple docstring'''






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







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






							lowercase        =							LayoutLMvaModel.from_pretrained("""microsoft/layoutlmv3-base"""						).to(_lowerCAmelCase						)

							lowercase        =							self.default_image_processor
							lowercase        =							prepare_img()
							lowercase        =							image_processor(images=_lowerCAmelCase ,				return_tensors="""pt"""						).pixel_values.to(_lowerCAmelCase						)

							lowercase        =							torch.tensor([[1, 2]]						)
							lowercase        =							torch.tensor([[1, 2, 3, 4], [5, 6, 7, 8]]						).unsqueeze(0						)

							# forward pass
							lowercase        =							model(
							    input_ids=input_ids.to(_lowerCAmelCase						) ,				bbox=bbox.to(_lowerCAmelCase						) ,				pixel_values=pixel_values.to(_lowerCAmelCase						) ,				)

							# verify the logits
							lowercase        =							torch.Size((1, 199, 768)						)
							self.assertEqual(outputs.last_hidden_state.shape ,				_lowerCAmelCase						)

							lowercase        =							torch.tensor(
							    [[-0.0529, 0.3618, 0.1632], [-0.1587, -0.1667, -0.0400], [-0.1557, -0.1671, -0.0505]]						).to(_lowerCAmelCase						)

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







'''simple docstring'''


def      SCREAMING_SNAKE_CASE				(				lowercase_    :      Union[str, Any] ,  lowercase_    :      str						):
						lowercase        =							""""""
						for i in table:
												res += inp[i - 1]
						return res







def      SCREAMING_SNAKE_CASE				(				lowercase_    :      List[Any]						):
						return data[1:] + data[0]







def      SCREAMING_SNAKE_CASE				(				lowercase_    :      Tuple ,  lowercase_    :      Dict						):
						lowercase        =							""""""
						for i in range(len(lowercase_						)						):
												if a[i] == b[i]:
																		res += "0"
												else:
																		res += "1"
						return res







def      SCREAMING_SNAKE_CASE				(				lowercase_    :      str ,  lowercase_    :      str						):
						lowercase        =							int("""0b""" + data[0] + data[-1] ,  2						)
						lowercase        =							int("""0b""" + data[1:3] ,  2						)
						return bin(s[row][col]						)[2:]







def      SCREAMING_SNAKE_CASE				(				lowercase_    :      Dict ,  lowercase_    :      Tuple ,  lowercase_    :      Tuple ,  lowercase_    :      str ,  lowercase_    :      Any						):
						lowercase        =							message[:4]
						lowercase        =							message[4:]
						lowercase        =							apply_table(lowercase_ ,  lowercase_						)
						lowercase        =							xor(lowercase_ ,  lowercase_						)
						lowercase        =							apply_sbox(lowercase_ ,  temp[:4]						)  # noqa: E741
						lowercase        =							apply_sbox(lowercase_ ,  temp[4:]						)
						lowercase        =							"""0""" * (2 - len(lowercase_						)) + l  # noqa: E741
						lowercase        =							"""0""" * (2 - len(lowercase_						)) + r
						lowercase        =							apply_table(l + r ,  lowercase_						)
						lowercase        =							xor(lowercase_ ,  lowercase_						)
						return temp + right


if __name__ == "__main__":
						lowercase_      :				Tuple   					=    input('''Enter 10 bit key: ''')
						lowercase_      :				Any   					=    input('''Enter 8 bit message: ''')

						lowercase_      :				Dict   					=    [6, 3, 7, 4, 8, 5, 10, 9]
						lowercase_      :				str   					=    [3, 5, 2, 7, 4, 10, 1, 9, 8, 6]
						lowercase_      :				List[Any]   					=    [2, 4, 3, 1]
						lowercase_      :				List[str]   					=    [2, 6, 3, 1, 4, 8, 5, 7]
						lowercase_      :				Tuple   					=    [4, 1, 3, 5, 7, 2, 8, 6]
						lowercase_      :				Optional[Any]   					=    [4, 1, 2, 3, 2, 3, 4, 1]
						lowercase_      :				List[str]   					=    [[1, 0, 3, 2], [3, 2, 1, 0], [0, 2, 1, 3], [3, 1, 3, 2]]
						lowercase_      :				List[Any]   					=    [[0, 1, 2, 3], [2, 0, 1, 3], [3, 0, 1, 0], [2, 1, 0, 3]]

						# key generation
						lowercase_      :				Union[str, Any]   					=    apply_table(key, paa_table)
						lowercase_      :				Optional[Any]   					=    temp[:5]
						lowercase_      :				int   					=    temp[5:]
						lowercase_      :				List[str]   					=    left_shift(left)
						lowercase_      :				int   					=    left_shift(right)
						lowercase_      :				Tuple   					=    apply_table(left + right, pa_table)
						lowercase_      :				List[str]   					=    left_shift(left)
						lowercase_      :				Optional[Any]   					=    left_shift(right)
						lowercase_      :				Union[str, Any]   					=    left_shift(left)
						lowercase_      :				Union[str, Any]   					=    left_shift(right)
						lowercase_      :				Optional[int]   					=    apply_table(left + right, pa_table)

						# encryption
						lowercase_      :				int   					=    apply_table(message, IP)
						lowercase_      :				Dict   					=    function(expansion, sa, sa, keya, temp)
						lowercase_      :				Any   					=    temp[4:] + temp[:4]
						lowercase_      :				List[Any]   					=    function(expansion, sa, sa, keya, temp)
						lowercase_      :				Tuple   					=    apply_table(temp, IP_inv)
						print('''Cipher text is:''', CT)

						# decryption
						lowercase_      :				List[str]   					=    apply_table(CT, IP)
						lowercase_      :				Optional[int]   					=    function(expansion, sa, sa, keya, temp)
						lowercase_      :				Optional[Any]   					=    temp[4:] + temp[:4]
						lowercase_      :				Optional[int]   					=    function(expansion, sa, sa, keya, temp)
						lowercase_      :				Optional[Any]   					=    apply_table(temp, IP_inv)
						print('''Plain text after decypting is:''', PT)


