

from manim import *

class 				UpperCAmelCase_		(			__lowercase   ):
							"""simple docstring"""







							def 				__lowercase				(			self       )    ->    str:
												_a	:    Dict         =		Rectangle(height=0.5       ,							width=0.5       )
												_a	:    Tuple         =		Rectangle(height=0.46       ,							width=0.46       ).set_stroke(width=0       )

												_a	:    str         =		[mem.copy() for i in range(6       )]
												_a	:    Dict         =		[mem.copy() for i in range(6       )]
												_a	:    Optional[Any]         =		VGroup(*_a       ).arrange(_a       ,							buff=0       )
												_a	:    Union[str, Any]         =		VGroup(*_a       ).arrange(_a       ,							buff=0       )
												_a	:    str         =		VGroup(_a       ,							_a       ).arrange(_a       ,							buff=0       )
												_a	:    Any         =		Text('''CPU'''       ,							font_size=2_4       )
												_a	:    List[Any]         =		Group(_a       ,							_a       ).arrange(_a       ,							buff=0.5       ,							aligned_edge=_a       )
												cpu.move_to([-2.5, -0.5, 0]       )
												self.add(_a       )

												_a	:    Optional[int]         =		[mem.copy() for i in range(4       )]
												_a	:    List[Any]         =		VGroup(*_a       ).arrange(_a       ,							buff=0       )
												_a	:    int         =		Text('''GPU'''       ,							font_size=2_4       )
												_a	:    int         =		Group(_a       ,							_a       ).arrange(_a       ,							buff=0.5       ,							aligned_edge=_a       )
												gpu.move_to([-1, -1, 0]       )
												self.add(_a       )

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

												_a	:    List[Any]         =		Text('''Model'''       ,							font_size=2_4       )
												_a	:    List[Any]         =		Group(_a       ,							_a       ).arrange(_a       ,							buff=0.5       ,							aligned_edge=_a       )
												model.move_to([3, -1.0, 0]       )
												self.add(_a       )

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

																	_a	:    Tuple         =		Rectangle(height=0.46 / 4       ,							width=0.46 / 3       ).set_stroke(width=0.0       ).set_fill(_a       ,							opacity=0.7       )

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

												_a	:    str         =		[mem.copy() for i in range(6       )]
												_a	:    int         =		VGroup(*_a       ).arrange(_a       ,							buff=0       )

												_a	:    Dict         =		Text('''Loaded Checkpoint'''       ,							font_size=2_4       )
												_a	:    Any         =		Group(_a       ,							_a       ).arrange(_a       ,							aligned_edge=_a       ,							buff=0.4       )
												checkpoint.move_to([3, 0.5, 0]       )

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

												_a	:    Any         =		MarkupText(
												    F"""<b>Key:</b>\n\n<span fgcolor=\'{YELLOW}\'>●</span> Empty Model"""       ,							font_size=1_8       ,							)

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

												self.add(_a       ,							_a       )

												_a	:    int         =		MarkupText(
												    F"""<span fgcolor=\'{BLUE}\'>●</span> Checkpoint"""       ,							font_size=1_8       ,							)

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

												_a	:    Optional[Any]         =		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=2_4       ,							)
												step_a.move_to([2, 2, 0]       )
												self.play(Write(_a       )       ,							Write(_a       )       )

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

												_a	:    Tuple         =		[]
												_a	:    List[str]         =		[]
												for i, rect in enumerate(_a       ):
																	_a	:    Union[str, Any]         =		fill.copy().set_fill(_a       ,							opacity=0.7       )
																	target.move_to(_a       )
																	first_animations.append(GrowFromCenter(_a       ,							run_time=1       )       )

																	_a	:    Optional[Any]         =		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(_a       ,							run_time=1.5       )       )

												self.play(*_a       )
												self.play(*_a       )
												self.wait()





from PIL import Image




def 	_SCREAMING_SNAKE_CASE					(		_lowerCamelCase :			Image						,  _lowerCamelCase :			int)					->    Image:






							'''simple docstring'''





							__UpperCamelCase	:   str			   =					(259 * (level + 255)) / (255 * (259 - level))

							def contrast(_lowerCamelCase :			int) -> int:
														return int(128 + factor * (c - 128))

							return img.point(_lowerCamelCase)


if __name__ == "__main__":
		# Load image
		with Image.open('image_data/lena.jpg') as img:
				# Change contrast to 170
				lowercase  :					Tuple													=       change_contrast(img, 170)
				cont_img.save('image_data/lena_high_contrast.png', format='png')