



"""simple docstring"""






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    ,       a    ,       a=13    ,       a=7    ,       a=True    ,       a=True    ,       a=True    ,       a=True    ,       a=99    ,       a=32    ,       a=5    ,       a=4    ,       a=37    ,       a="gelu"    ,       a=0.1    ,       a=0.1    ,       a=5_12    ,       a=16    ,       a=2    ,       a=0.02    ,       a=3    ,       a=4    ,       a=None    ,       a=10_00    ,       ):




										"""simple docstring"""





										snake_case_						:str								=						parent
										snake_case_						:Optional[int]								=						batch_size
										snake_case_						:Optional[Any]								=						seq_length
										snake_case_						:Optional[Any]								=						is_training
										snake_case_						:Any								=						use_input_mask
										snake_case_						:List[str]								=						use_token_type_ids
										snake_case_						:Any								=						use_labels
										snake_case_						:Tuple								=						vocab_size
										snake_case_						:List[Any]								=						hidden_size
										snake_case_						:int								=						num_hidden_layers
										snake_case_						:Union[str, Any]								=						num_attention_heads
										snake_case_						:Tuple								=						intermediate_size
										snake_case_						:Any								=						hidden_act
										snake_case_						:Dict								=						hidden_dropout_prob
										snake_case_						:Optional[Any]								=						attention_probs_dropout_prob
										snake_case_						:Optional[int]								=						max_position_embeddings
										snake_case_						:str								=						type_vocab_size
										snake_case_						:List[str]								=						type_sequence_label_size
										snake_case_						:str								=						initializer_range
										snake_case_						:int								=						num_labels
										snake_case_						:List[str]								=						num_choices
										snake_case_						:Optional[int]								=						scope
										snake_case_						:Union[str, Any]								=						range_bbox







					def 		_a (      self   ):




										"""simple docstring"""





										snake_case_						:Optional[int]								=						ids_tensor([self.batch_size, self.seq_length]    ,       self.vocab_size   )

										snake_case_						:int								=						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]:
																									snake_case_						:str								=						bbox[i, j, 3]
																									snake_case_						:List[str]								=						bbox[i, j, 1]
																									snake_case_						:List[Any]								=						t
																				if bbox[i, j, 2] < bbox[i, j, 0]:
																									snake_case_						:Tuple								=						bbox[i, j, 2]
																									snake_case_						:str								=						bbox[i, j, 0]
																									snake_case_						:Optional[Any]								=						t

										snake_case_						:Any								=						None
										if self.use_input_mask:
															snake_case_						:str								=						ids_tensor([self.batch_size, self.seq_length]    ,       vocab_size=2   )

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

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

										snake_case_						:Tuple								=						self.get_config()

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







					def 		_a (      self   ):




										"""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 		_a (      self    ,       a    ,       a    ,       a    ,       a    ,       a    ,       a    ,       a    ,       a   ):




										"""simple docstring"""





										snake_case_						:List[str]								=						LayoutLMModel(config=a   )
										model.to(a   )
										model.eval()
										snake_case_						:Optional[Any]								=						model(a    ,       a    ,       attention_mask=a    ,       token_type_ids=a   )
										snake_case_						:Dict								=						model(a    ,       a    ,       token_type_ids=a   )
										snake_case_						:Tuple								=						model(a    ,       a   )
										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    ,       a    ,       a    ,       a    ,       a    ,       a    ,       a    ,       a    ,       a   ):




										"""simple docstring"""





										snake_case_						:Tuple								=						LayoutLMForMaskedLM(config=a   )
										model.to(a   )
										model.eval()
										snake_case_						:List[Any]								=						model(a    ,       a    ,       attention_mask=a    ,       token_type_ids=a    ,       labels=a   )
										self.parent.assertEqual(result.logits.shape    ,       (self.batch_size, self.seq_length, self.vocab_size)   )







					def 		_a (      self    ,       a    ,       a    ,       a    ,       a    ,       a    ,       a    ,       a    ,       a   ):




										"""simple docstring"""





										snake_case_						:Optional[Any]								=						self.num_labels
										snake_case_						:Optional[int]								=						LayoutLMForSequenceClassification(a   )
										model.to(a   )
										model.eval()
										snake_case_						:Optional[int]								=						model(
										    a    ,       a    ,       attention_mask=a    ,       token_type_ids=a    ,       labels=a   )
										self.parent.assertEqual(result.logits.shape    ,       (self.batch_size, self.num_labels)   )







					def 		_a (      self    ,       a    ,       a    ,       a    ,       a    ,       a    ,       a    ,       a    ,       a   ):




										"""simple docstring"""





										snake_case_						:Dict								=						self.num_labels
										snake_case_						:str								=						LayoutLMForTokenClassification(config=a   )
										model.to(a   )
										model.eval()
										snake_case_						:List[str]								=						model(a    ,       a    ,       attention_mask=a    ,       token_type_ids=a    ,       labels=a   )
										self.parent.assertEqual(result.logits.shape    ,       (self.batch_size, self.seq_length, self.num_labels)   )







					def 		_a (      self    ,       a    ,       a    ,       a    ,       a    ,       a    ,       a    ,       a    ,       a   ):




										"""simple docstring"""





										snake_case_						:Any								=						LayoutLMForQuestionAnswering(config=a   )
										model.to(a   )
										model.eval()
										snake_case_						:List[Any]								=						model(
										    a    ,       bbox=a    ,       attention_mask=a    ,       token_type_ids=a    ,       start_positions=a    ,       end_positions=a    ,       )
										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   ):




										"""simple docstring"""





										snake_case_						:Optional[Any]								=						self.prepare_config_and_inputs()
										(
										    (
										    snake_case_
										)	,  (
										    snake_case_
										)	,  (
										    snake_case_
										)	,  (
										    snake_case_
										)	,  (
										    snake_case_
										)	,  (
										    snake_case_
										)	,  (
										    snake_case_
										)	,  (
										    snake_case_
										)	,  
										)						:List[Any]								=						config_and_inputs
										snake_case_						:Tuple								=						{
										    "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'''


					a__        =     (
					    (
					        LayoutLMModel,
					        LayoutLMForMaskedLM,
					        LayoutLMForSequenceClassification,
					        LayoutLMForTokenClassification,
					        LayoutLMForQuestionAnswering,
					    )
					    if is_torch_available()
					    else None
					)
					a__        =     (
					    {
					        'document-question-answering': LayoutLMForQuestionAnswering,
					        'feature-extraction': LayoutLMModel,
					        'fill-mask': LayoutLMForMaskedLM,
					        'text-classification': LayoutLMForSequenceClassification,
					        'token-classification': LayoutLMForTokenClassification,
					        'zero-shot': LayoutLMForSequenceClassification,
					    }
					    if is_torch_available()
					    else {}
					)
					a__        =     True







					def 		_a (      self   ):




										"""simple docstring"""





										snake_case_						:int								=						LayoutLMModelTester(self   )
										snake_case_						:Optional[Any]								=						ConfigTester(self    ,       config_class=a    ,       hidden_size=37   )







					def 		_a (      self   ):




										"""simple docstring"""





										self.config_tester.run_common_tests()







					def 		_a (      self   ):




										"""simple docstring"""





										snake_case_						:Any								=						self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*a   )







					def 		_a (      self   ):




										"""simple docstring"""





										snake_case_						:Tuple								=						self.model_tester.prepare_config_and_inputs()
										for type in ["absolute", "relative_key", "relative_key_query"]:
															snake_case_						:int								=						type
															self.model_tester.create_and_check_model(*a   )







					def 		_a (      self   ):




										"""simple docstring"""





										snake_case_						:str								=						self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_masked_lm(*a   )







					def 		_a (      self   ):




										"""simple docstring"""





										snake_case_						:Tuple								=						self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_sequence_classification(*a   )







					def 		_a (      self   ):




										"""simple docstring"""





										snake_case_						:Optional[Any]								=						self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_token_classification(*a   )







					def 		_a (      self   ):




										"""simple docstring"""





										snake_case_						:Optional[int]								=						self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_question_answering(*a   )







					@unittest.skip("Will be fixed soon by reducing the size of the model used for common tests."   )
					def 		_a (      self   ):




										"""simple docstring"""





										pass



def      A      (			):




					"""simple docstring"""
					# Here we prepare a batch of 2 sequences to test a LayoutLM forward pass on:
					# fmt: off
					snake_case_						:Optional[Any]								=						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=_A							)  # noqa: E231
					snake_case_						:str								=						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=_A							)  # noqa: E231
					snake_case_						:str								=						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=_A							)  # noqa: E231
					snake_case_						:List[str]								=						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=_A							)  # noqa: E231
					# these are sequence labels (i.e. at the token level)
					snake_case_						:List[str]								=						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=_A							)  # noqa: E231
					# fmt: on

					return input_ids, attention_mask, bbox, token_type_ids, labels

@require_torch
class 	__lowerCAmelCase							(unittest.TestCase  ):


					'''simple docstring'''


					@slow
					def 		_a (      self   ):




										"""simple docstring"""





										snake_case_						:List[Any]								=						LayoutLMModel.from_pretrained("microsoft/layoutlm-base-uncased"   ).to(a   )

										snake_case_	,  snake_case_	,  snake_case_	,  snake_case_	,  snake_case_						:List[str]								=						prepare_layoutlm_batch_inputs()

										# forward pass
										snake_case_						:int								=						model(input_ids=a    ,       bbox=a    ,       attention_mask=a    ,       token_type_ids=a   )

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

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

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

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







					@slow
					def 		_a (      self   ):




										"""simple docstring"""





										snake_case_						:str								=						LayoutLMForSequenceClassification.from_pretrained("microsoft/layoutlm-base-uncased"    ,       num_labels=2   ).to(
										    a   )

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

										# forward pass
										snake_case_						:List[str]								=						model(
										    input_ids=a    ,       bbox=a    ,       attention_mask=a    ,       token_type_ids=a    ,       labels=torch.tensor([1, 1]    ,       device=a   )    ,       )

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

										# test the shape of the logits
										snake_case_						:str								=						outputs.logits
										snake_case_						:Dict								=						torch.Size((2, 2)   )
										self.assertEqual(logits.shape    ,       a   )







					@slow
					def 		_a (      self   ):




										"""simple docstring"""





										snake_case_						:int								=						LayoutLMForTokenClassification.from_pretrained("microsoft/layoutlm-base-uncased"    ,       num_labels=13   ).to(
										    a   )

										snake_case_	,  snake_case_	,  snake_case_	,  snake_case_	,  snake_case_						:List[Any]								=						prepare_layoutlm_batch_inputs()

										# forward pass
										snake_case_						:Any								=						model(
										    input_ids=a    ,       bbox=a    ,       attention_mask=a    ,       token_type_ids=a    ,       labels=a   )

										# 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
										snake_case_						:List[Any]								=						outputs.logits
										snake_case_						:Dict								=						torch.Size((2, 25, 13)   )
										self.assertEqual(logits.shape    ,       a   )







					@slow
					def 		_a (      self   ):




										"""simple docstring"""





										snake_case_						:Dict								=						LayoutLMForQuestionAnswering.from_pretrained("microsoft/layoutlm-base-uncased"   ).to(a   )

										snake_case_	,  snake_case_	,  snake_case_	,  snake_case_	,  snake_case_						:str								=						prepare_layoutlm_batch_inputs()

										# forward pass
										snake_case_						:Any								=						model(input_ids=a    ,       bbox=a    ,       attention_mask=a    ,       token_type_ids=a   )

										# test the shape of the logits
										snake_case_						:List[Any]								=						torch.Size((2, 25)   )
										self.assertEqual(outputs.start_logits.shape    ,       a   )
										self.assertEqual(outputs.end_logits.shape    ,       a   )






"""simple docstring"""






def      A      (			_A,     _A							):




					"""simple docstring"""
					if not isinstance(_A,     _A							):
										raise TypeError("plaintext must be a string"							)
					if not isinstance(_A,     _A							):
										raise TypeError("key must be a string"							)

					if not plaintext:
										raise ValueError("plaintext is empty"							)
					if not key:
										raise ValueError("key is empty"							)

					key += plaintext
					snake_case_						:Optional[int]								=						plaintext.lower()
					snake_case_						:Union[str, Any]								=						key.lower()
					snake_case_						:Any								=						0
					snake_case_						:str								=						0
					snake_case_						:Union[str, Any]								=						""
					while plaintext_iterator < len(_A							):
										if (
										    ord(plaintext[plaintext_iterator]							) < 97
										    or ord(plaintext[plaintext_iterator]							) > 122
										):
															ciphertext += plaintext[plaintext_iterator]
															plaintext_iterator += 1
										elif ord(key[key_iterator]							) < 97 or ord(key[key_iterator]							) > 122:
															key_iterator += 1
										else:
															ciphertext += chr(
															    (
															        (ord(plaintext[plaintext_iterator]							) - 97 + ord(key[key_iterator]							))
															        - 97
															    )
															    % 26
															    + 97							)
															key_iterator += 1
															plaintext_iterator += 1
					return ciphertext
def      A      (			_A,     _A							):




					"""simple docstring"""
					if not isinstance(_A,     _A							):
										raise TypeError("ciphertext must be a string"							)
					if not isinstance(_A,     _A							):
										raise TypeError("key must be a string"							)

					if not ciphertext:
										raise ValueError("ciphertext is empty"							)
					if not key:
										raise ValueError("key is empty"							)

					snake_case_						:Tuple								=						key.lower()
					snake_case_						:Tuple								=						0
					snake_case_						:int								=						0
					snake_case_						:int								=						""
					while ciphertext_iterator < len(_A							):
										if (
										    ord(ciphertext[ciphertext_iterator]							) < 97
										    or ord(ciphertext[ciphertext_iterator]							) > 122
										):
															plaintext += ciphertext[ciphertext_iterator]
										else:
															plaintext += chr(
															    (ord(ciphertext[ciphertext_iterator]							) - ord(key[key_iterator]							)) % 26
															    + 97							)
															key += chr(
															    (ord(ciphertext[ciphertext_iterator]							) - ord(key[key_iterator]							)) % 26
															    + 97							)
															key_iterator += 1
										ciphertext_iterator += 1
					return plaintext


if __name__ == "__main__":
				import doctest

				doctest.testmod()
				__UpperCAmelCase      :      Dict   					=					int(input('Type 1 to encrypt or 2 to decrypt:'))
				if operation == 1:
								__UpperCAmelCase      :      List[str]   					=					input('Typeplaintext to be encrypted:\n')
								__UpperCAmelCase      :      Optional[int]   					=					input('Type the key:\n')
								print(encrypt(plaintext, key))
				elif operation == 2:
								__UpperCAmelCase      :      List[Any]   					=					input('Type the ciphertext to be decrypted:\n')
								__UpperCAmelCase      :      Dict   					=					input('Type the key:\n')
								print(decrypt(ciphertext, key))
				decrypt('jsqqs avvwo', 'coffee')

