



from __future__ import annotations

from string import ascii_letters







def       lowerCamelCase_  (    _a       :						str   ,		_a       :						int   ,		_a       :						str | None = None    ):



    '''simple docstring'''




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



    '''simple docstring'''




    key *= -1

    return encrypt(_a   ,		_a   ,		_a    )







def       lowerCamelCase_  (    _a       :						str   ,		_a       :						str | None = None    ):



    '''simple docstring'''




    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





'''simple docstring'''

import torch

from transformers import PreTrainedModel

from .custom_configuration import CustomConfig, NoSuperInitConfig



class 		lowerCamelCase__   (    A  ):




					'''simple docstring'''



					A_         =    CustomConfig




					def __init__(	self					:						int  ,	UpperCamelCase_					:						List[str]       )	->							int:



						'''simple docstring'''





						super().__init__(UpperCamelCase_       )
						_lowercase       :							List[Any]  	=		torch.nn.Linear(config.hidden_size  ,	config.hidden_size       )




					def     __UpperCAmelCase  (	self					:						Optional[int]  ,	UpperCamelCase_					:						Any       )	->							Union[str, Any]:



						'''simple docstring'''





						return self.linear(UpperCamelCase_       )




					def     __UpperCAmelCase  (	self					:						Optional[int]  ,	UpperCamelCase_					:						Optional[Any]       )	->							str:



						'''simple docstring'''





						pass






class 		lowerCamelCase__   (    A  ):




					'''simple docstring'''



					A_         =    NoSuperInitConfig




					def __init__(	self					:						Optional[int]  ,	UpperCamelCase_					:						Dict       )	->							Optional[Any]:



						'''simple docstring'''





						super().__init__(UpperCamelCase_       )
						_lowercase       :							List[str]  	=		torch.nn.Linear(config.attribute  ,	config.attribute       )




					def     __UpperCAmelCase  (	self					:						Optional[Any]  ,	UpperCamelCase_					:						Optional[int]       )	->							List[Any]:



						'''simple docstring'''





						return self.linear(UpperCamelCase_       )




					def     __UpperCAmelCase  (	self					:						Optional[Any]  ,	UpperCamelCase_					:						int       )	->							List[str]:



						'''simple docstring'''





						pass
