



from manim import *







class     __lowerCAmelCase					(    _UpperCAmelCase		):

			'''simple docstring'''





			def 					_lowerCamelCase (		self     :						List[str])     ->					int:



						"""simple docstring"""






						_UpperCAmelCase	 =     Rectangle(height=0.5				,	width=0.5)
						_UpperCAmelCase	 =     Rectangle(height=0.4_6				,	width=0.4_6).set_stroke(width=0)

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

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

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

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

						_UpperCAmelCase	 =     []
						for i, rect in enumerate(lowercase__):
									rect.set_stroke(lowercase__)
									# target = fill.copy().set_fill(YELLOW, opacity=0.7)
									# target.move_to(rect)
									# self.add(target)

									_UpperCAmelCase	 =     Rectangle(height=0.4_6 / 4				,	width=0.4_6 / 3).set_stroke(width=0.0).set_fill(lowercase__				,	opacity=0.7)

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

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

						_UpperCAmelCase	 =     Text('Loaded Checkpoint'				,	font_size=24)
						_UpperCAmelCase	 =     Group(lowercase__				,	lowercase__).arrange(lowercase__				,	aligned_edge=lowercase__				,	buff=0.4)
						checkpoint.move_to([3, 0.5, 0])

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

						_UpperCAmelCase	 =     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(lowercase__				,	lowercase__)

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

						blue_text.next_to(lowercase__				,	DOWN * 2.4				,	aligned_edge=key_text.get_left())

						_UpperCAmelCase	 =     MarkupText(
						    F"Next, a <i><span fgcolor=\"{BLUE}\">second</span></i> model is loaded into memory,\nwith the weights of a <span fgcolor=\"{BLUE}\">single shard</span>."				,	font_size=24				,	)
						step_a.move_to([2, 2, 0])
						self.play(Write(lowercase__)				,	Write(lowercase__))

						self.play(Write(lowercase__				,	run_time=1)				,	Create(lowercase__				,	run_time=1))

						_UpperCAmelCase	 =     []
						_UpperCAmelCase	 =     []
						for i, rect in enumerate(lowercase__):
									_UpperCAmelCase	 =     fill.copy().set_fill(lowercase__				,	opacity=0.7)
									target.move_to(lowercase__)
									first_animations.append(GrowFromCenter(lowercase__				,	run_time=1))

									_UpperCAmelCase	 =     target.copy()
									cpu_target.generate_target()
									if i < 5:
												cpu_target.target.move_to(cpu_left_col_base[i + 1])
									else:
												cpu_target.target.move_to(cpu_right_col_base[i - 5])
									second_animations.append(MoveToTarget(lowercase__				,	run_time=1.5))

						self.play(*lowercase__)
						self.play(*lowercase__)
						self.wait()





import unittest

from knapsack import knapsack as k







class     __lowerCAmelCase					(    unittest.TestCase		):



			def 					_lowerCamelCase (		self     :						Optional[Any])     ->					Any:



						"""simple docstring"""






						_UpperCAmelCase	 =     0
						_UpperCAmelCase	 =     [0]
						_UpperCAmelCase	 =     [0]
						_UpperCAmelCase	 =     len(A)
						self.assertEqual(k.knapsack(A				,	A				,	A				,	A)				,	0)

						_UpperCAmelCase	 =     [60]
						_UpperCAmelCase	 =     [10]
						_UpperCAmelCase	 =     len(A)
						self.assertEqual(k.knapsack(A				,	A				,	A				,	A)				,	0)



			def 					_lowerCamelCase (		self     :						str)     ->					List[str]:



						"""simple docstring"""






						_UpperCAmelCase	 =     3
						_UpperCAmelCase	 =     [1, 2, 3]
						_UpperCAmelCase	 =     [3, 2, 1]
						_UpperCAmelCase	 =     len(A)
						self.assertEqual(k.knapsack(A				,	A				,	A				,	A)				,	5)



			def 					_lowerCamelCase (		self     :						Tuple)     ->					Tuple:



						"""simple docstring"""






						_UpperCAmelCase	 =     50
						_UpperCAmelCase	 =     [60, 1_00, 1_20]
						_UpperCAmelCase	 =     [10, 20, 30]
						_UpperCAmelCase	 =     len(A)
						self.assertEqual(k.knapsack(A				,	A				,	A				,	A)				,	2_20)


if __name__ == "__main__":
							unittest.main()
