





from __future__ import annotations

from string import ascii_letters







def    UpperCAmelCase				(  _lowerCamelCase   :	List[str]      , _lowerCamelCase   :	List[Any]      , _lowerCamelCase   :	Dict = None  ):





						'''simple docstring'''


						SCREAMING_SNAKE_CASE__  :					Optional[Any] =       alphabet or ascii_letters

						# The final result string
						SCREAMING_SNAKE_CASE__  :					Optional[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
																		SCREAMING_SNAKE_CASE__  :					List[str] =       (alpha.index(_UpperCamelCase  ) + key) % len(_UpperCamelCase  )

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

						return result







def    UpperCAmelCase				(  _lowerCamelCase   :	Optional[int]      , _lowerCamelCase   :	List[Any]      , _lowerCamelCase   :	Any = None  ):





						'''simple docstring'''


						key *= -1

						return encrypt(_UpperCamelCase      , _UpperCamelCase      , _UpperCamelCase  )







def    UpperCAmelCase				(  _lowerCamelCase   :	List[str]      , _lowerCamelCase   :	List[str] = None  ):





						'''simple docstring'''


						SCREAMING_SNAKE_CASE__  :					List[str] =       alphabet or ascii_letters

						# To store data on all the combinations
						SCREAMING_SNAKE_CASE__  :					Any =       {}

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

						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
								__lowercase							:Dict							=	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":
												__lowercase							:List[str]							=	input("Please enter the string to be encrypted: ")
												__lowercase							:Optional[Any]							=	int(input("Please enter off-set: ").strip())

												print(encrypt(input_string, key))
								elif choice == "2":
												__lowercase							:Union[str, Any]							=	input("Please enter the string to be decrypted: ")
												__lowercase							:Dict							=	int(input("Please enter off-set: ").strip())

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

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

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




from typing import TYPE_CHECKING

# rely on isort to merge the imports
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available, is_torch_available


UpperCAmelCase__			:   Optional[int]      			=    {
    'configuration_ernie_m': ['ERNIE_M_PRETRAINED_CONFIG_ARCHIVE_MAP', 'ErnieMConfig'],
}

try:
					if not is_sentencepiece_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					UpperCAmelCase__			:   List[Any]      			=    ['ErnieMTokenizer']

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					UpperCAmelCase__			:   Dict      			=    [
					    'ERNIE_M_PRETRAINED_MODEL_ARCHIVE_LIST',
					    'ErnieMForMultipleChoice',
					    'ErnieMForQuestionAnswering',
					    'ErnieMForSequenceClassification',
					    'ErnieMForTokenClassification',
					    'ErnieMModel',
					    'ErnieMPreTrainedModel',
					    'ErnieMForInformationExtraction',
					]


if TYPE_CHECKING:
					from .configuration_ernie_m import ERNIE_M_PRETRAINED_CONFIG_ARCHIVE_MAP, ErnieMConfig

					try:
										if not is_sentencepiece_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .tokenization_ernie_m import ErnieMTokenizer

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_ernie_m import (
										    ERNIE_M_PRETRAINED_MODEL_ARCHIVE_LIST,
										    ErnieMForInformationExtraction,
										    ErnieMForMultipleChoice,
										    ErnieMForQuestionAnswering,
										    ErnieMForSequenceClassification,
										    ErnieMForTokenClassification,
										    ErnieMModel,
										    ErnieMPreTrainedModel,
										)


else:
					import sys

					UpperCAmelCase__			:   Union[str, Any]      			=    _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
