

SCREAMING_SNAKE_CASE_          =   'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

def 				__SCREAMING_SNAKE_CASE				(					) ->							List[Any]:
				_UpperCAmelCase							:		Union[str, Any]					=     input("Enter message: "			)
				_UpperCAmelCase							:		Dict					=     input("Enter key [alphanumeric]: "			)
				_UpperCAmelCase							:		str					=     input("Encrypt/Decrypt [e/d]: "			)

				if mode.lower().startswith("e"			):
								_UpperCAmelCase							:		Union[str, Any]					=     "encrypt"
								_UpperCAmelCase							:		Dict					=     encrypt_message(_a	,   _a			)
				elif mode.lower().startswith("d"			):
								_UpperCAmelCase							:		Dict					=     "decrypt"
								_UpperCAmelCase							:		Dict					=     decrypt_message(_a	,   _a			)

				print(F'\n{mode.title()}ed message:'			)
				print(_a			)

def 				__SCREAMING_SNAKE_CASE				(					lowerCAmelCase:	List[Any]	,   lowerCAmelCase:	int			) ->							str:
				return translate_message(_a	,   _a	,   "encrypt"			)

def 				__SCREAMING_SNAKE_CASE				(					lowerCAmelCase:	List[str]	,   lowerCAmelCase:	str			) ->							Any:
				return translate_message(_a	,   _a	,   "decrypt"			)

def 				__SCREAMING_SNAKE_CASE				(					lowerCAmelCase:	List[str]	,   lowerCAmelCase:	int	,   lowerCAmelCase:	Optional[int]			) ->							Any:
				_UpperCAmelCase							:		Tuple					=     []
				_UpperCAmelCase							:		int					=     0
				_UpperCAmelCase							:		Tuple					=     key.upper()

				for symbol in message:
								_UpperCAmelCase							:		int					=     LETTERS.find(symbol.upper()			)
								if num != -1:
												if mode == "encrypt":
																num += LETTERS.find(key[key_index]			)
												elif mode == "decrypt":
																num -= LETTERS.find(key[key_index]			)

												num %= len(_a			)

												if symbol.isupper():
																translated.append(LETTERS[num]			)
												elif symbol.islower():
																translated.append(LETTERS[num].lower()			)

												key_index += 1
												if key_index == len(_a			):
																_UpperCAmelCase							:		str					=     0
								else:
												translated.append(_a			)
				return "".join(_a			)


if __name__ == "__main__":
					main()





import argparse

from transformers import CLIPImageProcessor, CLIPVisionModelWithProjection

from diffusers import UnCLIPImageVariationPipeline, UnCLIPPipeline


if __name__ == "__main__":
			a_      =     argparse.ArgumentParser()

			parser.add_argument('--dump_path', default=None, type=str, required=True, help='Path to the output model.')

			parser.add_argument(
			    '--txt2img_unclip',
			    default='kakaobrain/karlo-v1-alpha',
			    type=str,
			    required=False,
			    help='The pretrained txt2img unclip.',
			)

			a_      =     parser.parse_args()

			a_      =     UnCLIPPipeline.from_pretrained(args.txtaimg_unclip)

			a_      =     CLIPImageProcessor()
			a_      =     CLIPVisionModelWithProjection.from_pretrained('openai/clip-vit-large-patch14')

			a_      =     UnCLIPImageVariationPipeline(
			    decoder=txtaimg.decoder,
			    text_encoder=txtaimg.text_encoder,
			    tokenizer=txtaimg.tokenizer,
			    text_proj=txtaimg.text_proj,
			    feature_extractor=feature_extractor,
			    image_encoder=image_encoder,
			    super_res_first=txtaimg.super_res_first,
			    super_res_last=txtaimg.super_res_last,
			    decoder_scheduler=txtaimg.decoder_scheduler,
			    super_res_scheduler=txtaimg.super_res_scheduler,
			)

			imgaimg.save_pretrained(args.dump_path)