






"""simple docstring"""



import random
import sys

from . import cryptomath_module as cryptomath

a  :						Dict					       =							(
    r''' !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`'''
    r'''abcdefghijklmnopqrstuvwxyz{|}~'''
)




def       snake_case__		(   _SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE			)    ->None:
 if mode == "encrypt":
  if key_a == 1:
   sys.exit(
       """The affine cipher becomes weak when key """
       """A is set to 1. Choose different key"""			)
  if key_b == 0:
   sys.exit(
       """The affine cipher becomes weak when key """
       """B is set to 0. Choose different key"""			)
 if key_a < 0 or key_b < 0 or key_b > len(_SCREAMING_SNAKE_CASE			) - 1:
  sys.exit(
      """Key A must be greater than 0 and key B must """
      F'''be between 0 and {len(_SCREAMING_SNAKE_CASE			) - 1}.'''			)
 if cryptomath.gcd(_SCREAMING_SNAKE_CASE       ,	len(_SCREAMING_SNAKE_CASE			)			) != 1:
  sys.exit(
      F'''Key A {key_a} and the symbol set size {len(_SCREAMING_SNAKE_CASE			)} '''
      """are not relatively prime. Choose a different key."""			)




def       snake_case__		(   _SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE			)    ->str:
 UpperCAmelCase__						,	UpperCAmelCase__ 						=				divmod(_SCREAMING_SNAKE_CASE       ,	len(_SCREAMING_SNAKE_CASE			)			)
 check_keys(_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE       ,	"""encrypt"""			)
 UpperCAmelCase__ 						=				""""""
 for symbol in message:
  if symbol in SYMBOLS:
   UpperCAmelCase__ 						=				SYMBOLS.find(_SCREAMING_SNAKE_CASE			)
   cipher_text += SYMBOLS[(sym_index * key_a + key_b) % len(_SCREAMING_SNAKE_CASE			)]
  else:
   cipher_text += symbol
 return cipher_text




def       snake_case__		(   _SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE			)    ->str:
 UpperCAmelCase__						,	UpperCAmelCase__ 						=				divmod(_SCREAMING_SNAKE_CASE       ,	len(_SCREAMING_SNAKE_CASE			)			)
 check_keys(_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE       ,	"""decrypt"""			)
 UpperCAmelCase__ 						=				""""""
 UpperCAmelCase__ 						=				cryptomath.find_mod_inverse(_SCREAMING_SNAKE_CASE       ,	len(_SCREAMING_SNAKE_CASE			)			)
 for symbol in message:
  if symbol in SYMBOLS:
   UpperCAmelCase__ 						=				SYMBOLS.find(_SCREAMING_SNAKE_CASE			)
   plain_text += SYMBOLS[
       (sym_index - key_b) * mod_inverse_of_key_a % len(_SCREAMING_SNAKE_CASE			)
   ]
  else:
   plain_text += symbol
 return plain_text




def       snake_case__		(   )    ->int:
 while True:
  UpperCAmelCase__ 						=				random.randint(2       ,	len(_SCREAMING_SNAKE_CASE			)			)
  UpperCAmelCase__ 						=				random.randint(2       ,	len(_SCREAMING_SNAKE_CASE			)			)
  if cryptomath.gcd(_SCREAMING_SNAKE_CASE       ,	len(_SCREAMING_SNAKE_CASE			)			) == 1 and key_b % len(_SCREAMING_SNAKE_CASE			) != 0:
   return key_b * len(_SCREAMING_SNAKE_CASE			) + key_b




def       snake_case__		(   )    ->None:
 UpperCAmelCase__ 						=				input("""Enter message: """			).strip()
 UpperCAmelCase__ 						=				int(input("""Enter key [2000 - 9000]: """			).strip()			)
 UpperCAmelCase__ 						=				input("""Encrypt/Decrypt [E/D]: """			).strip().lower()

 if mode.startswith("""e"""			):
  UpperCAmelCase__ 						=				"""encrypt"""
  UpperCAmelCase__ 						=				encrypt_message(_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE			)
 elif mode.startswith("""d"""			):
  UpperCAmelCase__ 						=				"""decrypt"""
  UpperCAmelCase__ 						=				decrypt_message(_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE			)
 print(F'''\n{mode.title()}ed text: \n{translated}'''			)


if __name__ == "__main__":
 import doctest

 doctest.testmod()
 # main()











"""simple docstring"""



from string import ascii_uppercase




def       snake_case__		(   _SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE       ,	_SCREAMING_SNAKE_CASE = False       ,	_SCREAMING_SNAKE_CASE = ascii_uppercase			)    ->str:
 UpperCAmelCase__ 						=				keyword.upper()
 UpperCAmelCase__ 						=				plaintext.upper()
 UpperCAmelCase__ 						=				set(_SCREAMING_SNAKE_CASE			)

 # create a list of unique characters in the keyword - their order matters
 # it determines how we will map plaintext characters to the ciphertext
 UpperCAmelCase__ 						=				[]
 for char in keyword:
  if char in alphabet_set and char not in unique_chars:
   unique_chars.append(_SCREAMING_SNAKE_CASE			)
    # the number of those unique characters will determine the number of rows
 UpperCAmelCase__ 						=				len(_SCREAMING_SNAKE_CASE			)

 # create a shifted version of the alphabet
 UpperCAmelCase__ 						=				unique_chars + [
     char for char in alphabet if char not in unique_chars
 ]

 # create a modified alphabet by splitting the shifted alphabet into rows
 UpperCAmelCase__ 						=				[
     shifted_alphabet[k : k + num_unique_chars_in_keyword]
     for k in range(0       ,	2_6       ,	_SCREAMING_SNAKE_CASE			)
 ]

 # map the alphabet characters to the modified alphabet characters
 # going 'vertically' through the modified alphabet - consider columns first
 UpperCAmelCase__ 						=				{}
 UpperCAmelCase__ 						=				0
 for column in range(_SCREAMING_SNAKE_CASE			):
  for row in modified_alphabet:
   # if current row (the last one) is too short, break out of loop
   if len(_SCREAMING_SNAKE_CASE			) <= column:
    break

   # map current letter to letter in modified alphabet
   UpperCAmelCase__ 						=				row[column]
   letter_index += 1

 if verbose:
  print(_SCREAMING_SNAKE_CASE			)
 # create the encrypted text by mapping the plaintext to the modified alphabet
 return "".join(mapping[char] if char in mapping else char for char in plaintext			)


if __name__ == "__main__":
 # example use
 print(mixed_keyword('''college''', '''UNIVERSITY'''))



