code: 
  '''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
  
  
  
style_context: 
  '''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__)
  
  
  