






from __future__ import annotations

from string import ascii_letters




def 						__SCREAMING_SNAKE_CASE   (					_UpperCamelCase  ,						_UpperCamelCase  ,						_UpperCamelCase = None							):


   """simple docstring"""




   lowercase_		:      List[str]          =       alphabet or ascii_letters

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

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

   return result




def 						__SCREAMING_SNAKE_CASE   (					_UpperCamelCase  ,						_UpperCamelCase  ,						_UpperCamelCase = None							):


   """simple docstring"""




   key *= -1

   return encrypt(_UpperCamelCase  ,						_UpperCamelCase  ,						_UpperCamelCase							)




def 						__SCREAMING_SNAKE_CASE   (					_UpperCamelCase  ,						_UpperCamelCase = None							):


   """simple docstring"""




   lowercase_		:      Tuple          =       alphabet or ascii_letters

   # To store data on all the combinations
   lowercase_		:      int          =       {}

   # Cycle through each combination
   for key in range(1  ,						len(_UpperCamelCase							) + 1							):
      # Decrypt the message and store the result in the data
      lowercase_		:      Dict          =       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__	=     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'''
UpperCamelCase__	=     (1, 153, 370, 371, 1634, 24678051, 115132219018763992565095597973971522401)
UpperCamelCase__	=     (-153, -1, 0, 1.2, 200, "A", [], {}, None)




def 						__SCREAMING_SNAKE_CASE   (					_UpperCamelCase							):


   """simple docstring"""




   if not isinstance(_UpperCamelCase  ,						_UpperCamelCase							) or n < 1:
      return False

   # Initialization of sum and number of digits.
   lowercase_		:      Optional[int]          =       0
   lowercase_		:      Any          =       0
   lowercase_		:      Optional[Any]          =       n
   # Calculation of digits of the number
   while temp > 0:
      number_of_digits += 1
      temp //= 10
   # Dividing number into separate digits and find Armstrong number
   lowercase_		:      int          =       n
   while temp > 0:
      lowercase_		:      Any          =       temp % 10
      total += rem**number_of_digits
      temp //= 10
   return n == total




def 						__SCREAMING_SNAKE_CASE   (					_UpperCamelCase							):


   """simple docstring"""




   if not isinstance(_UpperCamelCase  ,						_UpperCamelCase							) or n < 1:
      return False

   # Init a "histogram" of the digits
   lowercase_		:      Optional[Any]          =       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
   lowercase_		:      Tuple          =       0
   lowercase_		:      Any          =       0
   lowercase_		:      Tuple          =       n
   while temp > 0:
      lowercase_      ,						lowercase_		:      Optional[Any]          =       divmod(_UpperCamelCase  ,						10							)
      digit_histogram[rem] += 1
      digit_total += 1

   for cnt, i in zip(_UpperCamelCase  ,						range(len(_UpperCamelCase							)							)							):
      total += cnt * i**digit_total

   return n == total




def 						__SCREAMING_SNAKE_CASE   (					_UpperCamelCase							):


   """simple docstring"""




   if not isinstance(_UpperCamelCase  ,						_UpperCamelCase							) or n < 1:
      return False
   lowercase_		:      List[str]          =       len(str(_UpperCamelCase							)							)  # the power that all digits will be raised to
   # check if sum of each digit multiplied expo times is equal to number
   return n == sum(int(_UpperCamelCase							) ** expo for i in str(_UpperCamelCase							)							)




def 						__SCREAMING_SNAKE_CASE   (					):


   """simple docstring"""




   lowercase_		:      Dict          =       int(input("Enter an integer to see if it is an Armstrong number: "							).strip()							)
   print(F"""{num} is {"" if armstrong_number(_UpperCamelCase							) else "not "}an Armstrong number."""							)
   print(F"""{num} is {"" if narcissistic_number(_UpperCamelCase							) else "not "}an Armstrong number."""							)
   print(F"""{num} is {"" if pluperfect_number(_UpperCamelCase							) else "not "}an Armstrong number."""							)


if __name__ == "__main__":
 import doctest

 doctest.testmod()
 main()




