from manim import *




class 					_snake_case						(						_lowercase				):
					def    _lowerCamelCase (  self:				Optional[Any]     )    ->				Tuple:
												__UpperCAmelCase						:			Tuple         =   Rectangle(height=0.5	,  width=0.5     )
												__UpperCAmelCase						:			Union[str, Any]         =   Rectangle(height=0.46	,  width=0.46     ).set_stroke(width=0     )
												__UpperCAmelCase						:			str         =   Rectangle(height=0.25	,  width=0.25     )

												__UpperCAmelCase						:			Optional[int]         =   [mem.copy() for i in range(6     )]
												__UpperCAmelCase						:			Optional[int]         =   [mem.copy() for i in range(6     )]
												__UpperCAmelCase						:			Any         =   VGroup(*__lowerCamelCase     ).arrange(__lowerCamelCase	,  buff=0     )
												__UpperCAmelCase						:			str         =   VGroup(*__lowerCamelCase     ).arrange(__lowerCamelCase	,  buff=0     )
												__UpperCAmelCase						:			Tuple         =   VGroup(__lowerCamelCase	,  __lowerCamelCase     ).arrange(__lowerCamelCase	,  buff=0     )
												__UpperCAmelCase						:			str         =   Text("CPU"	,  font_size=24     )
												__UpperCAmelCase						:			List[str]         =   Group(__lowerCamelCase	,  __lowerCamelCase     ).arrange(__lowerCamelCase	,  buff=0.5	,  aligned_edge=__lowerCamelCase     )
												cpu.move_to([-2.5, -0.5, 0]     )
												self.add(__lowerCamelCase     )

												__UpperCAmelCase						:			Tuple         =   [mem.copy() for i in range(4     )]
												__UpperCAmelCase						:			Optional[int]         =   VGroup(*__lowerCamelCase     ).arrange(__lowerCamelCase	,  buff=0     )
												__UpperCAmelCase						:			str         =   Text("GPU"	,  font_size=24     )
												__UpperCAmelCase						:			Dict         =   Group(__lowerCamelCase	,  __lowerCamelCase     ).arrange(__lowerCamelCase	,  buff=0.5	,  aligned_edge=__lowerCamelCase     )
												gpu.move_to([-1, -1, 0]     )
												self.add(__lowerCamelCase     )

												__UpperCAmelCase						:			Dict         =   [mem.copy() for i in range(6     )]
												__UpperCAmelCase						:			Dict         =   VGroup(*__lowerCamelCase     ).arrange(__lowerCamelCase	,  buff=0     )

												__UpperCAmelCase						:			int         =   Text("Model"	,  font_size=24     )
												__UpperCAmelCase						:			Optional[Any]         =   Group(__lowerCamelCase	,  __lowerCamelCase     ).arrange(__lowerCamelCase	,  buff=0.5	,  aligned_edge=__lowerCamelCase     )
												model.move_to([3, -1.0, 0]     )
												self.add(__lowerCamelCase     )

												__UpperCAmelCase						:			List[Any]         =   []
												__UpperCAmelCase						:			Optional[Any]         =   []

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

																			__UpperCAmelCase						:			Optional[int]         =   Rectangle(height=0.46 / 4	,  width=0.46 / 3     ).set_stroke(width=0.0     ).set_fill(__lowerCamelCase	,  opacity=0.7     )

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

												self.add(*__lowerCamelCase	,  *__lowerCamelCase     )

												__UpperCAmelCase						:			Optional[Any]         =   [meta_mem.copy() for i in range(6     )]
												__UpperCAmelCase						:			Tuple         =   [meta_mem.copy() for i in range(6     )]
												__UpperCAmelCase						:			List[Any]         =   VGroup(*__lowerCamelCase     ).arrange(__lowerCamelCase	,  buff=0     )
												__UpperCAmelCase						:			Optional[Any]         =   VGroup(*__lowerCamelCase     ).arrange(__lowerCamelCase	,  buff=0     )
												__UpperCAmelCase						:			Dict         =   VGroup(__lowerCamelCase	,  __lowerCamelCase     ).arrange(__lowerCamelCase	,  buff=0     )
												__UpperCAmelCase						:			Optional[Any]         =   Text("Disk"	,  font_size=24     )
												__UpperCAmelCase						:			Any         =   Group(__lowerCamelCase	,  __lowerCamelCase     ).arrange(__lowerCamelCase	,  buff=0.5	,  aligned_edge=__lowerCamelCase     )
												disk.move_to([-4.0, -1.25, 0]     )
												self.add(__lowerCamelCase	,  __lowerCamelCase     )

												__UpperCAmelCase						:			Union[str, Any]         =   []

												for i in range(6     ):
																			__UpperCAmelCase						:			Tuple         =   fill.copy().set_fill(__lowerCamelCase	,  opacity=0.8     )
																			target.move_to(disk_left_col_base[i]     ).scale(0.5     )
																			cpu_disk_arr.append(__lowerCamelCase     )

												self.add(*__lowerCamelCase     )

												__UpperCAmelCase						:			List[Any]         =   Square(side_length=2.2     )
												key.move_to([-5, 2, 0]     )

												__UpperCAmelCase						:			str         =   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(__lowerCamelCase	,  __lowerCamelCase     )

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

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

												__UpperCAmelCase						:			Optional[int]         =   MarkupText(f'''The offloaded weights are all sent to the CPU.'''	,  font_size=24     )
												step_a.move_to([2, 2, 0]     )

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

												for i in range(6     ):
																			__UpperCAmelCase						:			Union[str, Any]         =   cpu_disk_arr[i]
																			__UpperCAmelCase						:			Union[str, Any]         =   rect.copy().set_fill(__lowerCamelCase	,  opacity=0.8     ).scale(2.0     )
																			cpa.generate_target()
																			cpa.target.move_to(model_base[i]     )

																			if i == 0:
																										rect.set_fill(__lowerCamelCase	,  opacity=0.8     )
																										rect.generate_target()
																										rect.target.move_to(cpu_left_col_base[0]     ).scale(2.0     )

																										self.remove(
																										    *__lowerCamelCase	,  *__lowerCamelCase	,  )

																			else:
																										rect.generate_target()
																										rect.target.move_to(cpu_left_col_base[i]     ).scale(2.0     )
																			self.play(MoveToTarget(__lowerCamelCase     )	,  MoveToTarget(__lowerCamelCase     )	,  model_base[i].animate.set_stroke(__lowerCamelCase     )     )
												self.play(FadeOut(__lowerCamelCase     )     )

												__UpperCAmelCase						:			List[Any]         =   MarkupText(
												    f'''Finally, hooks are added to each weight in the model\nto transfer the weights from CPU to GPU\n\t\tand back when needed.'''	,  font_size=24	,  )
												step_a.move_to([2, 2, 0]     )

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

												__UpperCAmelCase						:			int         =   []
												__UpperCAmelCase						:			Any         =   []
												for i in range(6     ):
																			__UpperCAmelCase						:			Optional[Any]         =   Arrow(start=__lowerCamelCase	,  end=__lowerCamelCase	,  color=__lowerCamelCase	,  buff=0.5     )
																			a.next_to(model_base[i].get_left()	,  __lowerCamelCase	,  buff=0.2     )
																			arrows.append(__lowerCamelCase     )
																			animations.append(Write(__lowerCamelCase     )     )
												self.play(*__lowerCamelCase     )
												self.wait()





import unittest
from dataclasses import dataclass
from typing import Optional

from transformers.utils import ModelOutput




@dataclass
class 					_snake_case						(						_lowercase				):
					lowerCamelCase__:		float
					lowerCamelCase__:		Optional[float]  =     None
					lowerCamelCase__:		Optional[float]  =     None




class 					_snake_case						(						unittest.TestCase				):
					def    _lowerCamelCase (  self:				Union[str, Any]     )    ->				List[Any]:
												__UpperCAmelCase						:			str         =   ModelOutputTest(a=30     )
												self.assertEqual(x.a	,  30     )
												self.assertIsNone(x.b     )
												self.assertIsNone(x.c     )
												with self.assertRaises(__lowerCamelCase     ):
																			__UpperCAmelCase						:			List[Any]         =   x.d
					def    _lowerCamelCase (  self:				Optional[int]     )    ->				str:
												__UpperCAmelCase						:			Union[str, Any]         =   ModelOutputTest(a=30	,  b=10     )
												self.assertEqual(x[0]	,  30     )
												self.assertEqual(x[1]	,  10     )
												self.assertEqual(x[:2]	,  (30, 10)     )
												self.assertEqual(x[:]	,  (30, 10)     )

												__UpperCAmelCase						:			Optional[Any]         =   ModelOutputTest(a=30	,  c=10     )
												self.assertEqual(x[0]	,  30     )
												self.assertEqual(x[1]	,  10     )
												self.assertEqual(x[:2]	,  (30, 10)     )
												self.assertEqual(x[:]	,  (30, 10)     )
					def    _lowerCamelCase (  self:				Tuple     )    ->				List[str]:
												__UpperCAmelCase						:			str         =   ModelOutputTest(a=30	,  b=10     )
												self.assertEqual(x["a"]	,  30     )
												self.assertEqual(x["b"]	,  10     )
												with self.assertRaises(__lowerCamelCase     ):
																			__UpperCAmelCase						:			Dict         =   x["c"]

												__UpperCAmelCase						:			Tuple         =   ModelOutputTest(a=30	,  c=10     )
												self.assertEqual(x["a"]	,  30     )
												self.assertEqual(x["c"]	,  10     )
												with self.assertRaises(__lowerCamelCase     ):
																			__UpperCAmelCase						:			Optional[Any]         =   x["b"]
					def    _lowerCamelCase (  self:				str     )    ->				Any:
												__UpperCAmelCase						:			Union[str, Any]         =   ModelOutputTest(a=30     )
												self.assertEqual(list(x.keys()     )	,  ["a"]     )
												self.assertEqual(list(x.values()     )	,  [30]     )
												self.assertEqual(list(x.items()     )	,  [("a", 30)]     )
												self.assertEqual(list(__lowerCamelCase     )	,  ["a"]     )

												__UpperCAmelCase						:			str         =   ModelOutputTest(a=30	,  b=10     )
												self.assertEqual(list(x.keys()     )	,  ["a", "b"]     )
												self.assertEqual(list(x.values()     )	,  [30, 10]     )
												self.assertEqual(list(x.items()     )	,  [("a", 30), ("b", 10)]     )
												self.assertEqual(list(__lowerCamelCase     )	,  ["a", "b"]     )

												__UpperCAmelCase						:			Any         =   ModelOutputTest(a=30	,  c=10     )
												self.assertEqual(list(x.keys()     )	,  ["a", "c"]     )
												self.assertEqual(list(x.values()     )	,  [30, 10]     )
												self.assertEqual(list(x.items()     )	,  [("a", 30), ("c", 10)]     )
												self.assertEqual(list(__lowerCamelCase     )	,  ["a", "c"]     )

												with self.assertRaises(__lowerCamelCase     ):
																			__UpperCAmelCase						:			Dict         =   x.update({"d": 20}     )
												with self.assertRaises(__lowerCamelCase     ):
																			del x["a"]
												with self.assertRaises(__lowerCamelCase     ):
																			__UpperCAmelCase						:			List[Any]         =   x.pop("a"     )
												with self.assertRaises(__lowerCamelCase     ):
																			__UpperCAmelCase						:			str         =   x.setdefault("d"	,  32     )
					def    _lowerCamelCase (  self:				List[str]     )    ->				str:
												__UpperCAmelCase						:			Optional[Any]         =   ModelOutputTest(a=30     )
												__UpperCAmelCase						:			Tuple         =   10
												self.assertEqual(x.a	,  10     )
												self.assertEqual(x["a"]	,  10     )
					def    _lowerCamelCase (  self:				Optional[int]     )    ->				Dict:
												__UpperCAmelCase						:			str         =   ModelOutputTest(a=30     )
												__UpperCAmelCase						:			Optional[int]         =   10
												self.assertEqual(x.a	,  10     )
												self.assertEqual(x["a"]	,  10     )
					def    _lowerCamelCase (  self:				List[Any]     )    ->				Optional[int]:
												__UpperCAmelCase						:			Tuple         =   ModelOutputTest({"a": 30, "b": 10}     )
												self.assertEqual(list(x.keys()     )	,  ["a", "b"]     )
												self.assertEqual(x.a	,  30     )
												self.assertEqual(x.b	,  10     )





					def    _lowerCamelCase (  self:				Optional[int]     )    ->				Union[str, Any]:
												__UpperCAmelCase						:			Dict         =   ModelOutputTest([("a", 30), ("b", 10)]     )
												self.assertEqual(list(x.keys()     )	,  ["a", "b"]     )
												self.assertEqual(x.a	,  30     )
												self.assertEqual(x.b	,  10     )

												with self.assertRaises(__lowerCamelCase     ):
																			__UpperCAmelCase						:			Any         =   ModelOutputTest([("a", 30), (10, 10)]     )

												__UpperCAmelCase						:			Dict         =   ModelOutputTest(a=(30, 30)     )
												self.assertEqual(list(x.keys()     )	,  ["a"]     )
												self.assertEqual(x.a	,  (30, 30)     )




