
'''simple docstring'''

from __future__ import annotations

from string import ascii_letters







def 						snake_case__	(      UpperCamelCase			,UpperCamelCase			,UpperCamelCase = None	) ->      str:
		_UpperCamelCase       : Union[str, Any]    =      alphabet or ascii_letters

		# The final result string
		_UpperCamelCase       : str    =      ''''''

		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       : str    =      (alpha.index(UpperCamelCase	) + key) % len(UpperCamelCase	)

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

		return result







def 						snake_case__	(      UpperCamelCase			,UpperCamelCase			,UpperCamelCase = None	) ->      str:
		key *= -1

		return encrypt(UpperCamelCase			,UpperCamelCase			,UpperCamelCase	)







def 						snake_case__	(      UpperCamelCase			,UpperCamelCase = None	) ->      dict[int, str]:
		_UpperCamelCase       : Dict    =      alphabet or ascii_letters

		# To store data on all the combinations
		_UpperCamelCase       : List[str]    =      {}

		# Cycle through each combination
		for key in range(1			,len(UpperCamelCase	) + 1	):
				# Decrypt the message and store the result in the data
				_UpperCamelCase       : Optional[int]    =      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
		_UpperCAmelCase   :      Optional[int] 						=  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   :      int 						=  input("""Please enter the string to be encrypted: """)
			_UpperCAmelCase   :      List[str] 						=  int(input("""Please enter off-set: """).strip())

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

			print(decrypt(input_string, key))
		elif choice == "3":
			_UpperCAmelCase   :      Optional[Any] 						=  input("""Please enter the string to be decrypted: """)
			_UpperCAmelCase   :      str 						=  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'''

from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_torch_available,
)


_UpperCAmelCase   :      int 						=  {
    """configuration_gptsan_japanese""": ["""GPTSAN_JAPANESE_PRETRAINED_CONFIG_ARCHIVE_MAP""", """GPTSanJapaneseConfig"""],
    """tokenization_gptsan_japanese""": ["""GPTSanJapaneseTokenizer"""],
}

try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	_UpperCAmelCase   :      int 						=  [
	    """GPTSAN_JAPANESE_PRETRAINED_MODEL_ARCHIVE_LIST""",
	    """GPTSanJapaneseForConditionalGeneration""",
	    """GPTSanJapaneseModel""",
	    """GPTSanJapanesePreTrainedModel""",
	]
	_UpperCAmelCase   :      str 						=  [
	    """GPTSanJapaneseTokenizer""",
	]


if TYPE_CHECKING:
	from .configuration_gptsan_japanese import GPTSAN_JAPANESE_PRETRAINED_CONFIG_ARCHIVE_MAP, GPTSanJapaneseConfig
	from .tokenization_gptsan_japanese import GPTSanJapaneseTokenizer

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_gptsan_japanese import (
		    GPTSAN_JAPANESE_PRETRAINED_MODEL_ARCHIVE_LIST,
		    GPTSanJapaneseForConditionalGeneration,
		    GPTSanJapaneseModel,
		    GPTSanJapanesePreTrainedModel,
		)
		from .tokenization_gptsan_japanese import GPTSanJapaneseTokenizer


else:
	import sys

	_UpperCAmelCase   :      List[str] 						=  _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)





