from manim import *




class 			UpperCAmelCase_      (   _A       ):




							'''simple docstring'''



							def    _UpperCAmelCase     (					self       :	Optional[int]			)			->					Union[str, Any]:
										SCREAMING_SNAKE_CASE           =					Rectangle(height=0.5       ,     width=0.5			)
										SCREAMING_SNAKE_CASE           =					Rectangle(height=0.25       ,     width=0.25			)
										SCREAMING_SNAKE_CASE           =					Rectangle(height=0.46       ,     width=0.46			).set_stroke(width=0			)

										SCREAMING_SNAKE_CASE           =					[mem.copy() for i in range(6			)]
										SCREAMING_SNAKE_CASE           =					[mem.copy() for i in range(6			)]
										SCREAMING_SNAKE_CASE           =					VGroup(*UpperCamelCase__			).arrange(UpperCamelCase__       ,     buff=0			)
										SCREAMING_SNAKE_CASE           =					VGroup(*UpperCamelCase__			).arrange(UpperCamelCase__       ,     buff=0			)
										SCREAMING_SNAKE_CASE           =					VGroup(UpperCamelCase__       ,     UpperCamelCase__			).arrange(UpperCamelCase__       ,     buff=0			)
										SCREAMING_SNAKE_CASE           =					Text("""CPU"""       ,     font_size=24			)
										SCREAMING_SNAKE_CASE           =					Group(UpperCamelCase__       ,     UpperCamelCase__			).arrange(UpperCamelCase__       ,     buff=0.5       ,     aligned_edge=UpperCamelCase__			)
										cpu.move_to([-2.5, -0.5, 0]			)
										self.add(UpperCamelCase__			)

										SCREAMING_SNAKE_CASE           =					[mem.copy() for i in range(4			)]
										SCREAMING_SNAKE_CASE           =					VGroup(*UpperCamelCase__			).arrange(UpperCamelCase__       ,     buff=0			)
										SCREAMING_SNAKE_CASE           =					Text("""GPU"""       ,     font_size=24			)
										SCREAMING_SNAKE_CASE           =					Group(UpperCamelCase__       ,     UpperCamelCase__			).arrange(UpperCamelCase__       ,     buff=0.5       ,     aligned_edge=UpperCamelCase__			)
										gpu.move_to([-1, -1, 0]			)
										self.add(UpperCamelCase__			)

										SCREAMING_SNAKE_CASE           =					[mem.copy() for i in range(6			)]
										SCREAMING_SNAKE_CASE           =					VGroup(*UpperCamelCase__			).arrange(UpperCamelCase__       ,     buff=0			)

										SCREAMING_SNAKE_CASE           =					Text("""Model"""       ,     font_size=24			)
										SCREAMING_SNAKE_CASE           =					Group(UpperCamelCase__       ,     UpperCamelCase__			).arrange(UpperCamelCase__       ,     buff=0.5       ,     aligned_edge=UpperCamelCase__			)
										model.move_to([3, -1.0, 0]			)
										self.add(UpperCamelCase__			)

										SCREAMING_SNAKE_CASE           =					[]
										SCREAMING_SNAKE_CASE           =					[]
										SCREAMING_SNAKE_CASE           =					[]

										for i, rect in enumerate(UpperCamelCase__			):
													rect.set_stroke(UpperCamelCase__			)

													SCREAMING_SNAKE_CASE           =					Rectangle(height=0.46 / 4       ,     width=0.46 / 3			).set_stroke(width=0.0			).set_fill(UpperCamelCase__       ,     opacity=0.7			)

													if i == 0:
																cpu_target.next_to(cpu_left_col_base[0].get_corner(DOWN + LEFT			)       ,     buff=0.02       ,     direction=UpperCamelCase__			)
																cpu_target.set_x(cpu_target.get_x() + 0.1			)
													elif i == 3:
																cpu_target.next_to(model_cpu_arr[0]       ,     direction=UpperCamelCase__       ,     buff=0.0			)
													else:
																cpu_target.next_to(model_cpu_arr[i - 1]       ,     direction=UpperCamelCase__       ,     buff=0.0			)
													self.add(UpperCamelCase__			)
													model_cpu_arr.append(UpperCamelCase__			)

										self.add(*UpperCamelCase__       ,     *UpperCamelCase__       ,     *UpperCamelCase__			)

										SCREAMING_SNAKE_CASE           =					[mem.copy() for i in range(6			)]
										SCREAMING_SNAKE_CASE           =					VGroup(*UpperCamelCase__			).arrange(UpperCamelCase__       ,     buff=0			)

										SCREAMING_SNAKE_CASE           =					Text("""Loaded Checkpoint"""       ,     font_size=24			)
										SCREAMING_SNAKE_CASE           =					Group(UpperCamelCase__       ,     UpperCamelCase__			).arrange(UpperCamelCase__       ,     buff=0.5       ,     aligned_edge=UpperCamelCase__			)
										checkpoint.move_to([3, 0.5, 0]			)

										self.add(UpperCamelCase__			)

										SCREAMING_SNAKE_CASE           =					[]
										SCREAMING_SNAKE_CASE           =					[]

										for i, rect in enumerate(UpperCamelCase__			):
													SCREAMING_SNAKE_CASE           =					fill.copy().set_fill(UpperCamelCase__       ,     opacity=0.7			)
													target.move_to(UpperCamelCase__			)
													ckpt_arr.append(UpperCamelCase__			)

													SCREAMING_SNAKE_CASE           =					target.copy()
													if i < 5:
																cpu_target.move_to(cpu_left_col_base[i + 1]			)
													else:
																cpu_target.move_to(cpu_right_col_base[i - 5]			)
													ckpt_cpu_arr.append(UpperCamelCase__			)
										self.add(*UpperCamelCase__       ,     *UpperCamelCase__			)

										SCREAMING_SNAKE_CASE           =					Square(side_length=2.2			)
										key.move_to([-5, 2, 0]			)

										SCREAMING_SNAKE_CASE           =					MarkupText(
										    f"""<b>Key:</b>\n\n<span fgcolor=\'{YELLOW}\'>●</span> Empty Model"""       ,     font_size=18       ,     )

										key_text.move_to([-5, 2.4, 0]			)

										self.add(UpperCamelCase__       ,     UpperCamelCase__			)

										SCREAMING_SNAKE_CASE           =					MarkupText(
										    f"""<span fgcolor=\'{BLUE}\'>●</span> Checkpoint"""       ,     font_size=18       ,     )

										blue_text.next_to(UpperCamelCase__       ,     DOWN * 2.4       ,     aligned_edge=key_text.get_left()			)
										self.add(UpperCamelCase__			)

										SCREAMING_SNAKE_CASE           =					MarkupText(
										    f"""Based on the passed in configuration, weights are stored in\na variety of np.memmaps on disk or to a particular device."""       ,     font_size=24       ,     )
										step_a.move_to([2, 2, 0]			)

										SCREAMING_SNAKE_CASE           =					[meta_mem.copy() for i in range(6			)]
										SCREAMING_SNAKE_CASE           =					[meta_mem.copy() for i in range(6			)]
										SCREAMING_SNAKE_CASE           =					VGroup(*UpperCamelCase__			).arrange(UpperCamelCase__       ,     buff=0			)
										SCREAMING_SNAKE_CASE           =					VGroup(*UpperCamelCase__			).arrange(UpperCamelCase__       ,     buff=0			)
										SCREAMING_SNAKE_CASE           =					VGroup(UpperCamelCase__       ,     UpperCamelCase__			).arrange(UpperCamelCase__       ,     buff=0			)
										SCREAMING_SNAKE_CASE           =					Text("""Disk"""       ,     font_size=24			)
										SCREAMING_SNAKE_CASE           =					Group(UpperCamelCase__       ,     UpperCamelCase__			).arrange(UpperCamelCase__       ,     buff=0.5       ,     aligned_edge=UpperCamelCase__			)
										disk.move_to([-4.0, -1.25, 0]			)
										self.play(Write(UpperCamelCase__       ,     run_time=3			)       ,     Write(UpperCamelCase__       ,     run_time=1			)       ,     Create(UpperCamelCase__       ,     run_time=1			)			)

										SCREAMING_SNAKE_CASE           =					[]
										for i, rect in enumerate(UpperCamelCase__			):
													SCREAMING_SNAKE_CASE           =					rect.copy()
													target.generate_target()
													target.target.move_to(disk_left_col_base[i]			).scale(0.5			)
													animations.append(MoveToTarget(UpperCamelCase__       ,     run_time=1.5			)			)
										self.play(*UpperCamelCase__			)

										self.play(FadeOut(UpperCamelCase__			)			)

										SCREAMING_SNAKE_CASE           =					MarkupText(f"""Then, the checkpoint is removed from memory\nthrough garbage collection."""       ,     font_size=24			)
										step_a.move_to([2, 2, 0]			)

										self.play(Write(UpperCamelCase__       ,     run_time=3			)			)

										self.play(
										    FadeOut(UpperCamelCase__       ,     UpperCamelCase__       ,     *UpperCamelCase__       ,     *UpperCamelCase__			)       ,     )

										self.wait()












from __future__ import annotations




class 			UpperCAmelCase_      :




							'''simple docstring'''



							def __init__(					self       :	Optional[int]       ,     a       :	int = 0			)			->					str:
										SCREAMING_SNAKE_CASE           =					key





							def    _UpperCAmelCase     (					self       :	Tuple       ,     a       :	str       ,     a       :	int			)			->					list[str]:
										assert isinstance(a       ,     a			) and isinstance(a       ,     a			)

										SCREAMING_SNAKE_CASE           =					key or self.__key or 1

										# make sure key is an appropriate size
										key %= 255

										return [chr(ord(a			) ^ key			) for ch in content]





							def    _UpperCAmelCase     (					self       :	Union[str, Any]       ,     a       :	str       ,     a       :	int			)			->					list[str]:
										assert isinstance(a       ,     a			) and isinstance(a       ,     a			)

										SCREAMING_SNAKE_CASE           =					key or self.__key or 1

										# make sure key is an appropriate size
										key %= 255

										return [chr(ord(a			) ^ key			) for ch in content]





							def    _UpperCAmelCase     (					self       :	Union[str, Any]       ,     a       :	str       ,     a       :	int = 0			)			->					str:
										assert isinstance(a       ,     a			) and isinstance(a       ,     a			)

										SCREAMING_SNAKE_CASE           =					key or self.__key or 1

										# make sure key can be any size
										while key > 255:
													key -= 255

										# This will be returned
										SCREAMING_SNAKE_CASE           =					""""""

										for ch in content:
													ans += chr(ord(a			) ^ key			)

										return ans





							def    _UpperCAmelCase     (					self       :	Dict       ,     a       :	str       ,     a       :	int = 0			)			->					str:
										assert isinstance(a       ,     a			) and isinstance(a       ,     a			)

										SCREAMING_SNAKE_CASE           =					key or self.__key or 1

										# make sure key can be any size
										while key > 255:
													key -= 255

										# This will be returned
										SCREAMING_SNAKE_CASE           =					""""""

										for ch in content:
													ans += chr(ord(a			) ^ key			)

										return ans





							def    _UpperCAmelCase     (					self       :	Optional[int]       ,     a       :	str       ,     a       :	int = 0			)			->					bool:
										assert isinstance(a       ,     a			) and isinstance(a       ,     a			)

										try:
													with open(a			) as fin, open("""encrypt.out"""       ,     """w+"""			) as fout:
																# actual encrypt-process
																for line in fin:
																			fout.write(self.encrypt_string(a       ,     a			)			)

										except OSError:
													return False

										return True







							def    _UpperCAmelCase     (					self       :	Dict       ,     a       :	str       ,     a       :	int			)			->					bool:
										assert isinstance(a       ,     a			) and isinstance(a       ,     a			)

										try:
													with open(a			) as fin, open("""decrypt.out"""       ,     """w+"""			) as fout:
																# actual encrypt-process
																for line in fin:
																			fout.write(self.decrypt_string(a       ,     a			)			)

										except OSError:
													return False

										return True


# Tests
# crypt = XORCipher()
# key = 67

# # test encrypt
# print(crypt.encrypt("hallo welt",key))
# # test decrypt
# print(crypt.decrypt(crypt.encrypt("hallo welt",key), key))

# # test encrypt_string
# print(crypt.encrypt_string("hallo welt",key))

# # test decrypt_string
# print(crypt.decrypt_string(crypt.encrypt_string("hallo welt",key),key))

# if (crypt.encrypt_file("test.txt",key)):
#       print("encrypt successful")
# else:
#       print("encrypt unsuccessful")

# if (crypt.decrypt_file("encrypt.out",key)):
#       print("decrypt successful")
# else:
#       print("decrypt unsuccessful")






