






'''simple docstring'''







from manim import *

class _lowercase	(				_lowercase		):




							def 		lowerCamelCase_				(							self:				List[Any]     ):
														lowerCamelCase__					:	List[Any]         =       Rectangle(height=0.5			,							width=0.5     )
														lowerCamelCase__					:	int         =       Rectangle(height=0.25			,							width=0.25     )
														lowerCamelCase__					:	Optional[int]         =       Rectangle(height=0.46			,							width=0.46     ).set_stroke(width=0     )

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

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

														lowerCamelCase__					:	Optional[Any]         =       [mem.copy() for i in range(6     )]
														lowerCamelCase__					:	Tuple         =       VGroup(*UpperCamelCase__     ).arrange(UpperCamelCase__			,							buff=0     )

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

														lowerCamelCase__					:	Optional[int]         =       []
														lowerCamelCase__					:	Tuple         =       []
														lowerCamelCase__					:	Union[str, Any]         =       []

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

																					lowerCamelCase__					:	Dict         =       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__     )

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

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

														self.add(UpperCamelCase__     )

														lowerCamelCase__					:	Dict         =       []
														lowerCamelCase__					:	Dict         =       []

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

																					lowerCamelCase__					:	List[Any]         =       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__     )

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

														lowerCamelCase__					:	int         =       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__     )

														lowerCamelCase__					:	Optional[int]         =       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__     )

														lowerCamelCase__					:	Tuple         =       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]     )

														lowerCamelCase__					:	int         =       [meta_mem.copy() for i in range(6     )]
														lowerCamelCase__					:	Union[str, Any]         =       [meta_mem.copy() for i in range(6     )]
														lowerCamelCase__					:	List[str]         =       VGroup(*UpperCamelCase__     ).arrange(UpperCamelCase__			,							buff=0     )
														lowerCamelCase__					:	Optional[int]         =       VGroup(*UpperCamelCase__     ).arrange(UpperCamelCase__			,							buff=0     )
														lowerCamelCase__					:	List[str]         =       VGroup(UpperCamelCase__			,							UpperCamelCase__     ).arrange(UpperCamelCase__			,							buff=0     )
														lowerCamelCase__					:	Any         =       Text("""Disk"""			,							font_size=24     )
														lowerCamelCase__					:	List[str]         =       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     )     )

														lowerCamelCase__					:	Union[str, Any]         =       []
														for i, rect in enumerate(UpperCamelCase__     ):
																					lowerCamelCase__					:	List[Any]         =       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__     )     )

														lowerCamelCase__					:	Any         =       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()



'''simple docstring'''







import json
import os
import tempfile

from transformers.testing_utils import check_json_file_has_correct_format






class  lowerCAmelCase__   :
					lowerCAmelCase_        =     None






					def 	_snake_case    (   self		):


											"""simple docstring"""





											lowercase_	:     Tuple													=       self.feature_extraction_class(**self.feat_extract_dict		)
											lowercase_	:     Any													=       json.loads(feat_extract.to_json_string()		)
											for key, value in self.feat_extract_dict.items():
																	self.assertEqual(obj[key]				,							__SCREAMING_SNAKE_CASE		)






					def 	_snake_case    (   self		):


											"""simple docstring"""





											lowercase_	:     str													=       self.feature_extraction_class(**self.feat_extract_dict		)

											with tempfile.TemporaryDirectory() as tmpdirname:
																	lowercase_	:     str													=       os.path.join(__SCREAMING_SNAKE_CASE				,							'''feat_extract.json'''		)
																	feat_extract_first.to_json_file(__SCREAMING_SNAKE_CASE		)
																	lowercase_	:     str													=       self.feature_extraction_class.from_json_file(__SCREAMING_SNAKE_CASE		)

											self.assertEqual(feat_extract_second.to_dict()				,							feat_extract_first.to_dict()		)






					def 	_snake_case    (   self		):


											"""simple docstring"""





											lowercase_	:     Tuple													=       self.feature_extraction_class(**self.feat_extract_dict		)

											with tempfile.TemporaryDirectory() as tmpdirname:
																	lowercase_	:     Union[str, Any]													=       feat_extract_first.save_pretrained(__SCREAMING_SNAKE_CASE		)[0]
																	check_json_file_has_correct_format(__SCREAMING_SNAKE_CASE		)
																	lowercase_	:     str													=       self.feature_extraction_class.from_pretrained(__SCREAMING_SNAKE_CASE		)

											self.assertEqual(feat_extract_second.to_dict()				,							feat_extract_first.to_dict()		)






					def 	_snake_case    (   self		):


											"""simple docstring"""





											lowercase_	:     Optional[Any]													=       self.feature_extraction_class()
											self.assertIsNotNone(__SCREAMING_SNAKE_CASE		)



