






'''simple docstring'''







from __future__ import annotations

from string import ascii_letters






def  lowerCAmelCase__		(					a_  :     str			,						a_  :     int			,						a_  :     str | None = None			)   -> List[str]:
       UpperCAmelCase__	:   int												=	alphabet or ascii_letters

       # The final result string
       UpperCAmelCase__	:   Union[str, Any]												=	""""""

       for character in input_string:
              if character not in alpha:
                     # Append without encryption if character is not in the alphabet
                     result += character
              else:
                     # Get the index of the new key and make sure it isn't too large
                     UpperCAmelCase__	:   Any												=	(alpha.index(_a			) + key) % len(_a			)

                     # Append the encoded character to the alphabet
                     result += alpha[new_key]

       return result






def  lowerCAmelCase__		(					a_  :     str			,						a_  :     int			,						a_  :     str | None = None			)   -> Optional[Any]:
       key *= -1

       return encrypt(_a			,						_a			,						_a			)






def  lowerCAmelCase__		(					a_  :     str			,						a_  :     str | None = None			)   -> List[str]:
       UpperCAmelCase__	:   Dict												=	alphabet or ascii_letters

       # To store data on all the combinations
       UpperCAmelCase__	:   List[Any]												=	{}

       # Cycle through each combination
       for key in range(1			,						len(_a			) + 1			):
              # Decrypt the message and store the result in the data
              UpperCAmelCase__	:   Optional[Any]												=	decrypt(_a			,						_a			,						_a			)

       return brute_force_data


if __name__ == "__main__":
  while True:
    print(f'\n{"-" * 10}\n Menu\n{"-" * 10}')
    print(*["1.Encrypt", "2.Decrypt", "3.BruteForce", "4.Quit"], sep="\n")

    # get user input
    UpperCamelCase_					=				input("\nWhat would you like to do?: ").strip() or "4"

    # run functions based on what the user chose
    if choice not in ("1", "2", "3", "4"):
      print("Invalid choice, please enter a valid choice")
    elif choice == "1":
      UpperCamelCase_					=				input("Please enter the string to be encrypted: ")
      UpperCamelCase_					=				int(input("Please enter off-set: ").strip())

      print(encrypt(input_string, key))
    elif choice == "2":
      UpperCamelCase_					=				input("Please enter the string to be decrypted: ")
      UpperCamelCase_					=				int(input("Please enter off-set: ").strip())

      print(decrypt(input_string, key))
    elif choice == "3":
      UpperCamelCase_					=				input("Please enter the string to be decrypted: ")
      UpperCamelCase_					=				brute_force(input_string)

      for key, value in brute_force_data.items():
        print(f'Key: {key} | Message: {value}')

    elif choice == "4":
      print("Goodbye.")
      break




import copy

from ...configuration_utils import PretrainedConfig
from ...utils import logging


UpperCamelCase_									=   logging.get_logger(__name__)

UpperCamelCase_									=   {}







class       _snake_case				(     __snake_case ):






   '''simple docstring'''






   A__      : List[str]       =						"fsmt_decoder"


   def __init__(    self:     Optional[Any]  ,lowerCamelCase_:     Tuple=0  ,lowerCamelCase_:     List[str]=0							)	->      Any:
       super().__init__()
       UpperCAmelCase_     :       Optional[Any]  		=					vocab_size
       UpperCAmelCase_     :       Union[str, Any]  		=					bos_token_id







class       _snake_case				(     __snake_case ):






   '''simple docstring'''






   A__      : Dict       =						"fsmt"
   A__      : int       =						{"num_attention_heads": "encoder_attention_heads", "hidden_size": "d_model"}


   def __init__(    self:     int  ,lowerCamelCase_:     Optional[Any]=["en", "de"]  ,lowerCamelCase_:     Any=42024  ,lowerCamelCase_:     Any=42024  ,lowerCamelCase_:     List[str]="relu"  ,lowerCamelCase_:     Any=1024  ,lowerCamelCase_:     Optional[int]=200  ,lowerCamelCase_:     str=1024  ,lowerCamelCase_:     Any=4096  ,lowerCamelCase_:     Dict=12  ,lowerCamelCase_:     Tuple=16  ,lowerCamelCase_:     List[Any]=0.0  ,lowerCamelCase_:     str=4096  ,lowerCamelCase_:     Union[str, Any]=12  ,lowerCamelCase_:     Any=16  ,lowerCamelCase_:     List[str]=0.0  ,lowerCamelCase_:     str=0.0  ,lowerCamelCase_:     Optional[int]=0.1  ,lowerCamelCase_:     List[Any]=0.0  ,lowerCamelCase_:     Tuple=0.0_2  ,lowerCamelCase_:     str=2  ,lowerCamelCase_:     List[str]=True  ,lowerCamelCase_:     Dict=True  ,lowerCamelCase_:     Any=False  ,lowerCamelCase_:     Any=5  ,lowerCamelCase_:     Optional[int]=1.0  ,lowerCamelCase_:     List[str]=False  ,lowerCamelCase_:     List[Any]=True  ,lowerCamelCase_:     List[str]=1  ,lowerCamelCase_:     int=0  ,lowerCamelCase_:     Optional[Any]=2  ,lowerCamelCase_:     Any=2  ,**lowerCamelCase_:     Optional[Any]  ,)	->      int:
       UpperCAmelCase_     :       Dict  		=					langs
       UpperCAmelCase_     :       Tuple  		=					src_vocab_size
       UpperCAmelCase_     :       Optional[int]  		=					tgt_vocab_size
       UpperCAmelCase_     :       Optional[Any]  		=					d_model  # encoder_embed_dim and decoder_embed_dim

       UpperCAmelCase_     :       List[str]  		=					encoder_ffn_dim
       UpperCAmelCase_     :       List[Any]  		=					encoder_layers
       UpperCAmelCase_     :       List[Any]  		=					encoder_attention_heads
       UpperCAmelCase_     :       Union[str, Any]  		=					encoder_layerdrop
       UpperCAmelCase_     :       List[Any]  		=					decoder_layerdrop
       UpperCAmelCase_     :       str  		=					decoder_ffn_dim
       UpperCAmelCase_     :       Optional[int]  		=					decoder_layers
       UpperCAmelCase_     :       int  		=					decoder_attention_heads
       UpperCAmelCase_     :       List[Any]  		=					max_position_embeddings
       UpperCAmelCase_     :       Dict  		=					init_std  # Normal(0, this parameter)
       UpperCAmelCase_     :       Dict  		=					activation_function

       UpperCAmelCase_     :       List[str]  		=					DecoderConfig(vocab_size=lowerCamelCase_  ,bos_token_id=lowerCamelCase_							)
       if "decoder" in common_kwargs:
           del common_kwargs["decoder"]

       UpperCAmelCase_     :       Any  		=					scale_embedding  # scale factor will be sqrt(d_model) if True

       # 3 Types of Dropout
       UpperCAmelCase_     :       int  		=					attention_dropout
       UpperCAmelCase_     :       int  		=					activation_dropout
       UpperCAmelCase_     :       Any  		=					dropout

       UpperCAmelCase_     :       Any  		=					use_cache
       super().__init__(
           pad_token_id=lowerCamelCase_  ,bos_token_id=lowerCamelCase_  ,eos_token_id=lowerCamelCase_  ,decoder_start_token_id=lowerCamelCase_  ,is_encoder_decoder=lowerCamelCase_  ,tie_word_embeddings=lowerCamelCase_  ,forced_eos_token_id=lowerCamelCase_  ,max_length=lowerCamelCase_  ,num_beams=lowerCamelCase_  ,length_penalty=lowerCamelCase_  ,early_stopping=lowerCamelCase_  ,**lowerCamelCase_  ,)






   def       A__    (    self:     List[str]							)	->      Union[str, Any]:
       UpperCAmelCase_     :       str  		=					copy.deepcopy(self.__dict__							)
       UpperCAmelCase_     :       int  		=					self.decoder.to_dict()
       UpperCAmelCase_     :       Dict  		=					self.__class__.model_type
       return output
