
'''simple docstring'''

from __future__ import annotations

from string import ascii_letters


def 	_UpperCAmelCase				(  _lowerCamelCase						:       Optional[Any]  ,      _lowerCamelCase						:       Union[str, Any]  ,      _lowerCamelCase						:       List[str] = None		)    ->						str:
  _lowerCAmelCase       :  Union[str, Any]   				=					alphabet or ascii_letters

  # The final result string
  _lowerCAmelCase       :  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
      _lowerCAmelCase       :  str   				=					(alpha.index(_lowerCamelCase		) + key) % len(_lowerCamelCase		)

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

  return result


def 	_UpperCAmelCase				(  _lowerCamelCase						:       Optional[Any]  ,      _lowerCamelCase						:       Optional[Any]  ,      _lowerCamelCase						:       Optional[int] = None		)    ->						str:
  key *= -1

  return encrypt(_lowerCamelCase  ,      _lowerCamelCase  ,      _lowerCamelCase		)


def 	_UpperCAmelCase				(  _lowerCamelCase						:       Dict  ,      _lowerCamelCase						:       Tuple = None		)    ->						dict[int, str]:
  _lowerCAmelCase       :  Dict   				=					alphabet or ascii_letters

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

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

  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'''

from typing import TYPE_CHECKING

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


UpperCamelCase_     			=       {
    """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_     			=       [
         """GPTSAN_JAPANESE_PRETRAINED_MODEL_ARCHIVE_LIST""",
         """GPTSanJapaneseForConditionalGeneration""",
         """GPTSanJapaneseModel""",
         """GPTSanJapanesePreTrainedModel""",
     ]
     UpperCamelCase_     			=       [
         """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_     			=       _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)


