




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






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






   def 			_a    (						self :							List[str]  )->      Union[str, Any]:
     _lowercase:			int      =     ids_tensor([self.batch_size, self.seq_length]    ,       self.vocab_size  )

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

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

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

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

     _lowercase:			List[Any]      =     self.get_config()

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






   def 			_a    (						self :							Tuple  )->      Optional[int]:
     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 :							Any    ,       UpperCamelCase_ :							Optional[int]    ,       UpperCamelCase_ :							Tuple    ,       UpperCamelCase_ :							Any    ,       UpperCamelCase_ :							int    ,       UpperCamelCase_ :							Tuple    ,       UpperCamelCase_ :							str    ,       UpperCamelCase_ :							Any    ,       UpperCamelCase_ :							Tuple  )->      Optional[Any]:
     _lowercase:			Dict      =     LayoutLMModel(config=UpperCamelCase_  )
     model.to(UpperCamelCase_  )
     model.eval()
     _lowercase:			Optional[int]      =     model(UpperCamelCase_    ,       UpperCamelCase_    ,       attention_mask=UpperCamelCase_    ,       token_type_ids=UpperCamelCase_  )
     _lowercase:			Optional[Any]      =     model(UpperCamelCase_    ,       UpperCamelCase_    ,       token_type_ids=UpperCamelCase_  )
     _lowercase:			str      =     model(UpperCamelCase_    ,       UpperCamelCase_  )
     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 :							Any    ,       UpperCamelCase_ :							List[Any]    ,       UpperCamelCase_ :							int    ,       UpperCamelCase_ :							List[str]    ,       UpperCamelCase_ :							Any    ,       UpperCamelCase_ :							Dict    ,       UpperCamelCase_ :							List[Any]    ,       UpperCamelCase_ :							Dict    ,       UpperCamelCase_ :							Union[str, Any]  )->      Dict:
     _lowercase:			List[Any]      =     LayoutLMForMaskedLM(config=UpperCamelCase_  )
     model.to(UpperCamelCase_  )
     model.eval()
     _lowercase:			int      =     model(UpperCamelCase_    ,       UpperCamelCase_    ,       attention_mask=UpperCamelCase_    ,       token_type_ids=UpperCamelCase_    ,       labels=UpperCamelCase_  )
     self.parent.assertEqual(result.logits.shape    ,       (self.batch_size, self.seq_length, self.vocab_size)  )






   def 			_a    (						self :							List[str]    ,       UpperCamelCase_ :							Optional[Any]    ,       UpperCamelCase_ :							int    ,       UpperCamelCase_ :							int    ,       UpperCamelCase_ :							Dict    ,       UpperCamelCase_ :							Union[str, Any]    ,       UpperCamelCase_ :							Tuple    ,       UpperCamelCase_ :							Tuple    ,       UpperCamelCase_ :							int  )->      str:
     _lowercase:			Tuple      =     self.num_labels
     _lowercase:			Union[str, Any]      =     LayoutLMForSequenceClassification(UpperCamelCase_  )
     model.to(UpperCamelCase_  )
     model.eval()
     _lowercase:			Tuple      =     model(
         UpperCamelCase_    ,       UpperCamelCase_    ,       attention_mask=UpperCamelCase_    ,       token_type_ids=UpperCamelCase_    ,       labels=UpperCamelCase_  )
     self.parent.assertEqual(result.logits.shape    ,       (self.batch_size, self.num_labels)  )






   def 			_a    (						self :							int    ,       UpperCamelCase_ :							int    ,       UpperCamelCase_ :							List[str]    ,       UpperCamelCase_ :							Dict    ,       UpperCamelCase_ :							List[str]    ,       UpperCamelCase_ :							List[str]    ,       UpperCamelCase_ :							List[str]    ,       UpperCamelCase_ :							List[Any]    ,       UpperCamelCase_ :							Dict  )->      int:
     _lowercase:			Union[str, Any]      =     self.num_labels
     _lowercase:			Any      =     LayoutLMForTokenClassification(config=UpperCamelCase_  )
     model.to(UpperCamelCase_  )
     model.eval()
     _lowercase:			Tuple      =     model(UpperCamelCase_    ,       UpperCamelCase_    ,       attention_mask=UpperCamelCase_    ,       token_type_ids=UpperCamelCase_    ,       labels=UpperCamelCase_  )
     self.parent.assertEqual(result.logits.shape    ,       (self.batch_size, self.seq_length, self.num_labels)  )






   def 			_a    (						self :							Any    ,       UpperCamelCase_ :							str    ,       UpperCamelCase_ :							str    ,       UpperCamelCase_ :							Dict    ,       UpperCamelCase_ :							List[Any]    ,       UpperCamelCase_ :							str    ,       UpperCamelCase_ :							List[Any]    ,       UpperCamelCase_ :							Union[str, Any]    ,       UpperCamelCase_ :							Any  )->      Any:
     _lowercase:			int      =     LayoutLMForQuestionAnswering(config=UpperCamelCase_  )
     model.to(UpperCamelCase_  )
     model.eval()
     _lowercase:			Any      =     model(
         UpperCamelCase_    ,       bbox=UpperCamelCase_    ,       attention_mask=UpperCamelCase_    ,       token_type_ids=UpperCamelCase_    ,       start_positions=UpperCamelCase_    ,       end_positions=UpperCamelCase_    ,       )
     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 :							Optional[Any]  )->      Union[str, Any]:
     _lowercase:			int      =     self.prepare_config_and_inputs()
     (
         (
         _lowercase
     )  ,       (
         _lowercase
     )  ,       (
         _lowercase
     )  ,       (
         _lowercase
     )  ,       (
         _lowercase
     )  ,       (
         _lowercase
     )  ,       (
         _lowercase
     )  ,       (
         _lowercase
     )  ,       
     ):			Optional[int]      =     config_and_inputs
     _lowercase:			Optional[int]      =     {
         'input_ids': input_ids,
         'bbox': bbox,
         'token_type_ids': token_type_ids,
         'attention_mask': input_mask,
     }
     return config, inputs_dict

@require_torch
class   UpperCAmelCase    (      A ,       A ,       unittest.TestCase ):
   __SCREAMING_SNAKE_CASE		:				Union[str, Any]      					=       (
       (
           LayoutLMModel,
           LayoutLMForMaskedLM,
           LayoutLMForSequenceClassification,
           LayoutLMForTokenClassification,
           LayoutLMForQuestionAnswering,
       )
       if is_torch_available()
       else None
   )
   __SCREAMING_SNAKE_CASE		:				Optional[int]      					=       (
       {
           "document-question-answering": LayoutLMForQuestionAnswering,
           "feature-extraction": LayoutLMModel,
           "fill-mask": LayoutLMForMaskedLM,
           "text-classification": LayoutLMForSequenceClassification,
           "token-classification": LayoutLMForTokenClassification,
           "zero-shot": LayoutLMForSequenceClassification,
       }
       if is_torch_available()
       else {}
   )
   __SCREAMING_SNAKE_CASE		:				Tuple      					=       True






   def 			_a    (						self :							List[str]  )->      Optional[Any]:
     _lowercase:			Optional[Any]      =     LayoutLMModelTester(self  )
     _lowercase:			Tuple      =     ConfigTester(self    ,       config_class=UpperCamelCase_    ,       hidden_size=37  )






   def 			_a    (						self :							Any  )->      Any:
     self.config_tester.run_common_tests()






   def 			_a    (						self :							Union[str, Any]  )->      Any:
     _lowercase:			List[Any]      =     self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_model(*UpperCamelCase_  )






   def 			_a    (						self :							Optional[int]  )->      int:
     _lowercase:			Dict      =     self.model_tester.prepare_config_and_inputs()
     for type in ["absolute", "relative_key", "relative_key_query"]:
       _lowercase:			Any      =     type
       self.model_tester.create_and_check_model(*UpperCamelCase_  )






   def 			_a    (						self :							int  )->      Optional[Any]:
     _lowercase:			Any      =     self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_masked_lm(*UpperCamelCase_  )






   def 			_a    (						self :							Optional[int]  )->      Tuple:
     _lowercase:			Union[str, Any]      =     self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_sequence_classification(*UpperCamelCase_  )






   def 			_a    (						self :							Dict  )->      Dict:
     _lowercase:			Any      =     self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_token_classification(*UpperCamelCase_  )






   def 			_a    (						self :							List[Any]  )->      List[Any]:
     _lowercase:			Union[str, Any]      =     self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_question_answering(*UpperCamelCase_  )






   @unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.'  )
   def 			_a    (						self :							List[str]  )->      List[Any]:
     pass


def 		_lowerCamelCase					(       )      ->		Optional[Any]:





  """simple docstring"""





  _lowercase:			int      =     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=UpperCamelCase				)  # noqa: E231
  _lowercase:			Optional[int]      =     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=UpperCamelCase				)  # noqa: E231
  _lowercase:			Any      =     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=UpperCamelCase				)  # noqa: E231
  _lowercase:			Any      =     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=UpperCamelCase				)  # noqa: E231
  # these are sequence labels (i.e. at the token level)
  _lowercase:			Tuple      =     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=UpperCamelCase				)  # noqa: E231
  # fmt: on

  return input_ids, attention_mask, bbox, token_type_ids, labels





@require_torch
class   UpperCAmelCase    (      unittest.TestCase ):






   @slow
   def 			_a    (						self :							Dict  )->      int:
     _lowercase:			Optional[int]      =     LayoutLMModel.from_pretrained('microsoft/layoutlm-base-uncased'  ).to(UpperCamelCase_  )

     _lowercase  ,       _lowercase  ,       _lowercase  ,       _lowercase  ,       _lowercase:			Optional[Any]      =     prepare_layoutlm_batch_inputs()

     # forward pass
     _lowercase:			List[str]      =     model(input_ids=UpperCamelCase_    ,       bbox=UpperCamelCase_    ,       attention_mask=UpperCamelCase_    ,       token_type_ids=UpperCamelCase_  )

     # test the sequence output on [0, :3, :3]
     _lowercase:			Any      =     torch.tensor(
         [[0.1_785, -0.1_947, -0.0_425], [-0.3_254, -0.2_807, 0.2_553], [-0.5_391, -0.3_322, 0.3_364]]    ,       device=UpperCamelCase_    ,       )

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

     # test the pooled output on [1, :3]
     _lowercase:			Dict      =     torch.tensor([-0.6_580, -0.0_214, 0.8_552]    ,       device=UpperCamelCase_  )

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






   @slow
   def 			_a    (						self :							Optional[int]  )->      Optional[Any]:
     # initialize model with randomly initialized sequence classification head
     _lowercase:			Optional[int]      =     LayoutLMForSequenceClassification.from_pretrained('microsoft/layoutlm-base-uncased'    ,       num_labels=2  ).to(
         UpperCamelCase_  )

     _lowercase  ,       _lowercase  ,       _lowercase  ,       _lowercase  ,       _lowercase:			str      =     prepare_layoutlm_batch_inputs()

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

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

     # test the shape of the logits
     _lowercase:			int      =     outputs.logits
     _lowercase:			List[Any]      =     torch.Size((2, 2)  )
     self.assertEqual(logits.shape    ,       UpperCamelCase_  )






   @slow
   def 			_a    (						self :							str  )->      List[Any]:
     # initialize model with randomly initialized token classification head
     _lowercase:			List[Any]      =     LayoutLMForTokenClassification.from_pretrained('microsoft/layoutlm-base-uncased'    ,       num_labels=13  ).to(
         UpperCamelCase_  )

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

     # forward pass
     _lowercase:			Dict      =     model(
         input_ids=UpperCamelCase_    ,       bbox=UpperCamelCase_    ,       attention_mask=UpperCamelCase_    ,       token_type_ids=UpperCamelCase_    ,       labels=UpperCamelCase_  )

     # 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:			int      =     outputs.logits
     _lowercase:			str      =     torch.Size((2, 25, 13)  )
     self.assertEqual(logits.shape    ,       UpperCamelCase_  )






   @slow
   def 			_a    (						self :							Optional[Any]  )->      int:
     # initialize model with randomly initialized token classification head
     _lowercase:			int      =     LayoutLMForQuestionAnswering.from_pretrained('microsoft/layoutlm-base-uncased'  ).to(UpperCamelCase_  )

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

     # forward pass
     _lowercase:			Any      =     model(input_ids=UpperCamelCase_    ,       bbox=UpperCamelCase_    ,       attention_mask=UpperCamelCase_    ,       token_type_ids=UpperCamelCase_  )

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






import random
import sys

UpperCAmelCase__    :							str       		=     'ABCDEFGHIJKLMNOPQRSTUVWXYZ'


def 		_lowerCamelCase					(       )      ->		None:





  """simple docstring"""





  _lowercase:			Any      =     input('Enter message: '				)
  _lowercase:			List[str]      =     'LFWOAYUISVKMNXPBDCRJTQEGHZ'
  _lowercase:			Tuple      =     input('Encrypt/Decrypt [e/d]: '				)

  check_valid_key(UpperCamelCase				)

  if resp.lower().startswith('e'				):
    _lowercase:			int      =     'encrypt'
    _lowercase:			Optional[int]      =     encrypt_message(UpperCamelCase       ,  UpperCamelCase				)
  elif resp.lower().startswith('d'				):
    _lowercase:			str      =     'decrypt'
    _lowercase:			Dict      =     decrypt_message(UpperCamelCase       ,  UpperCamelCase				)

  print(F'\n{mode.title()}ion: \n{translated}'				)


def 		_lowerCamelCase					(       UpperCamelCase				)      ->		None:





  """simple docstring"""





  _lowercase:			List[Any]      =     list(UpperCamelCase				)
  _lowercase:			Union[str, Any]      =     list(UpperCamelCase				)
  key_list.sort()
  letters_list.sort()

  if key_list != letters_list:
    sys.exit('Error in the key or symbol set.'				)


def 		_lowerCamelCase					(       UpperCamelCase       ,  UpperCamelCase				)      ->		str:





  """simple docstring"""





  return translate_message(UpperCamelCase       ,  UpperCamelCase       ,  'encrypt'				)


def 		_lowerCamelCase					(       UpperCamelCase       ,  UpperCamelCase				)      ->		str:





  """simple docstring"""





  return translate_message(UpperCamelCase       ,  UpperCamelCase       ,  'decrypt'				)


def 		_lowerCamelCase					(       UpperCamelCase       ,  UpperCamelCase       ,  UpperCamelCase				)      ->		str:





  """simple docstring"""





  _lowercase:			Optional[int]      =     ''
  _lowercase:			Any      =     LETTERS
  _lowercase:			Tuple      =     key

  if mode == "decrypt":
    _lowercase  ,       _lowercase:			Tuple      =     chars_b, chars_a

  for symbol in message:
    if symbol.upper() in chars_a:
      _lowercase:			int      =     chars_a.find(symbol.upper()				)
      if symbol.isupper():
        translated += chars_b[sym_index].upper()
      else:
        translated += chars_b[sym_index].lower()
    else:
      translated += symbol

  return translated


def 		_lowerCamelCase					(       )      ->		str:





  """simple docstring"""





  _lowercase:			Union[str, Any]      =     list(UpperCamelCase				)
  random.shuffle(UpperCamelCase				)
  return "".join(UpperCamelCase				)


if __name__ == "__main__":
   main()
