
'''simple docstring'''







def       _a		(						_SCREAMING_SNAKE_CASE		: str						,      _SCREAMING_SNAKE_CASE		: str	):
						if not isinstance(_SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE	):
												raise TypeError("plaintext must be a string"	)
						if not isinstance(_SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE	):
												raise TypeError("key must be a string"	)

						if not plaintext:
												raise ValueError("plaintext is empty"	)
						if not key:
												raise ValueError("key is empty"	)

						key += plaintext
						_SCREAMING_SNAKE_CASE					=			plaintext.lower()
						_SCREAMING_SNAKE_CASE					=			key.lower()
						_SCREAMING_SNAKE_CASE					=			0
						_SCREAMING_SNAKE_CASE					=			0
						_SCREAMING_SNAKE_CASE					=			""
						while plaintext_iterator < len(_SCREAMING_SNAKE_CASE	):
												if (
												    ord(plaintext[plaintext_iterator]	) < 97
												    or ord(plaintext[plaintext_iterator]	) > 122
												):
																		ciphertext += plaintext[plaintext_iterator]
																		plaintext_iterator += 1
												elif ord(key[key_iterator]	) < 97 or ord(key[key_iterator]	) > 122:
																		key_iterator += 1
												else:
																		ciphertext += chr(
																		    (
																		        (ord(plaintext[plaintext_iterator]	) - 97 + ord(key[key_iterator]	))
																		        - 97
																		    )
																		    % 26
																		    + 97	)
																		key_iterator += 1
																		plaintext_iterator += 1
						return ciphertext



def       _a		(						_SCREAMING_SNAKE_CASE		: str						,      _SCREAMING_SNAKE_CASE		: str	):
						if not isinstance(_SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE	):
												raise TypeError("ciphertext must be a string"	)
						if not isinstance(_SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE	):
												raise TypeError("key must be a string"	)

						if not ciphertext:
												raise ValueError("ciphertext is empty"	)
						if not key:
												raise ValueError("key is empty"	)

						_SCREAMING_SNAKE_CASE					=			key.lower()
						_SCREAMING_SNAKE_CASE					=			0
						_SCREAMING_SNAKE_CASE					=			0
						_SCREAMING_SNAKE_CASE					=			""
						while ciphertext_iterator < len(_SCREAMING_SNAKE_CASE	):
												if (
												    ord(ciphertext[ciphertext_iterator]	) < 97
												    or ord(ciphertext[ciphertext_iterator]	) > 122
												):
																		plaintext += ciphertext[ciphertext_iterator]
												else:
																		plaintext += chr(
																		    (ord(ciphertext[ciphertext_iterator]	) - ord(key[key_iterator]	)) % 26
																		    + 97	)
																		key += chr(
																		    (ord(ciphertext[ciphertext_iterator]	) - ord(key[key_iterator]	)) % 26
																		    + 97	)
																		key_iterator += 1
												ciphertext_iterator += 1
						return plaintext


if __name__ == "__main__":
						import doctest

						doctest.testmod()
						_snake_case					: Optional[int]     			=					int(input("""Type 1 to encrypt or 2 to decrypt:"""))
						if operation == 1:
												_snake_case					: Union[str, Any]     			=					input("""Typeplaintext to be encrypted:\n""")
												_snake_case					: List[str]     			=					input("""Type the key:\n""")
												print(encrypt(plaintext, key))
						elif operation == 2:
												_snake_case					: str     			=					input("""Type the ciphertext to be decrypted:\n""")
												_snake_case					: List[str]     			=					input("""Type the key:\n""")
												print(decrypt(ciphertext, key))
						decrypt("""jsqqs avvwo""", """coffee""")

'''simple docstring'''







from __future__ import annotations

import random
import string


class       lowerCAmelCase			:




		def __init__(					self       ,    UpperCamelCase = None   ):
								_SCREAMING_SNAKE_CASE					=			passcode or self.__passcode_creator()
								_SCREAMING_SNAKE_CASE					=			self.__make_key_list()
								_SCREAMING_SNAKE_CASE					=			self.__make_shift_key()




		def __str__(					self   ):
								return "".join(self.__passcode   )




		def      lowercase							(					self       ,    UpperCamelCase   ):
								for i in range(1       ,    len(UpperCamelCase   )       ,    2   ):
														iterlist[i] *= -1
								return iterlist




		def      lowercase							(					self   ):
								_SCREAMING_SNAKE_CASE					=			string.ascii_letters + string.digits
								_SCREAMING_SNAKE_CASE					=			[random.choice(UpperCamelCase   ) for _ in range(random.randint(10       ,    20   )   )]
								return password




		def      lowercase							(					self   ):
								_SCREAMING_SNAKE_CASE					=			(
								    string.ascii_letters + string.digits + string.punctuation + " \t\n"
								)

								_SCREAMING_SNAKE_CASE					=			[]

								# creates points known as breakpoints to break the key_list_options at those
								# points and pivot each substring
								_SCREAMING_SNAKE_CASE					=			sorted(set(self.__passcode   )   )
								_SCREAMING_SNAKE_CASE					=			[]

								# algorithm for creating a new shuffled list, keys_l, out of key_list_options
								for i in key_list_options:
														temp_list.extend(UpperCamelCase   )

														# checking breakpoints at which to pivot temporary sublist and add it into
														# keys_l
														if i in breakpoints or i == key_list_options[-1]:
																				keys_l.extend(temp_list[::-1]   )
																				temp_list.clear()

        # returning a shuffled keys_l to prevent brute force guessing of shift key
								return keys_l




		def      lowercase							(					self   ):
								_SCREAMING_SNAKE_CASE					=			sum(self.__neg_pos([ord(UpperCamelCase   ) for x in self.__passcode]   )   )
								return num if num > 0 else len(self.__passcode   )




		def      lowercase							(					self       ,    UpperCamelCase   ):
								_SCREAMING_SNAKE_CASE					=			""

								# decoding shift like Caesar cipher algorithm implementing negative shift or
								# reverse shift or left shift
								for i in encoded_message:
														_SCREAMING_SNAKE_CASE					=			self.__key_list.index(UpperCamelCase   )
														decoded_message += self.__key_list[
														    (position - self.__shift_key) % -len(self.__key_list   )
														]

								return decoded_message




		def      lowercase							(					self       ,    UpperCamelCase   ):
								_SCREAMING_SNAKE_CASE					=			""

								# encoding shift like Caesar cipher algorithm implementing positive shift or
								# forward shift or right shift
								for i in plaintext:
														_SCREAMING_SNAKE_CASE					=			self.__key_list.index(UpperCamelCase   )
														encoded_message += self.__key_list[
														    (position + self.__shift_key) % len(self.__key_list   )
														]

								return encoded_message



def       _a		(						_SCREAMING_SNAKE_CASE		: str = "Hello, this is a modified Caesar cipher"	):
						_SCREAMING_SNAKE_CASE					=			ShuffledShiftCipher()
						return cipa.decrypt(cipa.encrypt(_SCREAMING_SNAKE_CASE	)	)


if __name__ == "__main__":
						import doctest

						doctest.testmod()