



from manim import *






class    SCREAMING_SNAKE_CASE			(							lowerCamelCase__					):





							def 						UpperCamelCase_					(   self		:		List[Any]	):

											'''simple docstring'''
											__a       =		Rectangle(height=0.5      ,				width=0.5	)
											__a       =		Rectangle(height=0.46      ,				width=0.46	).set_stroke(width=0	)

											__a       =		Rectangle(height=0.25      ,				width=0.25	)

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

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

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

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

											__a       =		[]
											__a       =		[]

											for i, rect in enumerate(__lowercase	):
															__a       =		fill.copy().set_fill(__lowercase      ,				opacity=0.8	)
															target.move_to(__lowercase	)
															model_arr.append(__lowercase	)

															__a       =		Rectangle(height=0.46      ,				width=0.46	).set_stroke(width=0.0	).set_fill(__lowercase      ,				opacity=0.8	)
															cpu_target.move_to(cpu_left_col_base[i]	)
															model_cpu_arr.append(__lowercase	)

											self.add(*__lowercase      ,				*__lowercase	)

											__a       =		[meta_mem.copy() for i in range(6	)]
											__a       =		[meta_mem.copy() for i in range(6	)]
											__a       =		VGroup(*__lowercase	).arrange(__lowercase      ,				buff=0	)
											__a       =		VGroup(*__lowercase	).arrange(__lowercase      ,				buff=0	)
											__a       =		VGroup(__lowercase      ,				__lowercase	).arrange(__lowercase      ,				buff=0	)
											__a       =		Text("""Disk"""      ,				font_size=24	)
											__a       =		Group(__lowercase      ,				__lowercase	).arrange(__lowercase      ,				buff=0.5      ,				aligned_edge=__lowercase	)
											disk.move_to([-4, -1.25, 0]	)
											self.add(__lowercase      ,				__lowercase	)

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

											__a       =		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	)

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

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

											__a       =		MarkupText(
											    F"Now watch as an input is passed through the model\nand how the memory is utilized and handled."      ,				font_size=24      ,				)
											step_a.move_to([2, 2, 0]	)

											self.play(Write(__lowercase	)	)

											__a       =		Square(0.3	)
											input.set_fill(__lowercase      ,				opacity=1.0	)
											input.set_stroke(width=0.0	)
											input.next_to(model_base[0]      ,				__lowercase      ,				buff=0.5	)

											self.play(Write(__lowercase	)	)

											input.generate_target()
											input.target.next_to(model_arr[0]      ,				direction=__lowercase      ,				buff=0.02	)
											self.play(MoveToTarget(__lowercase	)	)

											self.play(FadeOut(__lowercase	)	)

											__a       =		Arrow(start=__lowercase      ,				end=__lowercase      ,				color=__lowercase      ,				buff=0.5	)
											a.next_to(model_arr[0].get_left()      ,				__lowercase      ,				buff=0.2	)

											model_cpu_arr[0].generate_target()
											model_cpu_arr[0].target.move_to(gpu_rect[0]	)

											__a       =		MarkupText(
											    F"As the input reaches a layer, the hook triggers\nand weights are moved from the CPU\nto the GPU and back."      ,				font_size=24      ,				)
											step_a.move_to([2, 2, 0]	)

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

											__a       =		{"""run_time""": 1, """fade_in""": True, """fade_out""": True, """buff""": 0.02}

											self.play(
											    Write(__lowercase	)      ,				Circumscribe(model_arr[0]      ,				color=__lowercase      ,				**__lowercase	)      ,				Circumscribe(model_cpu_arr[0]      ,				color=__lowercase      ,				**__lowercase	)      ,				Circumscribe(gpu_rect[0]      ,				color=__lowercase      ,				**__lowercase	)      ,				)
											self.play(MoveToTarget(model_cpu_arr[0]	)	)

											__a       =		a.copy()
											for i in range(6	):
															a_c.next_to(model_arr[i].get_right() + 0.02      ,				__lowercase      ,				buff=0.2	)

															input.generate_target()
															input.target.move_to(model_arr[i].get_right() + 0.02	)

															__a       =		AnimationGroup(
															    FadeOut(__lowercase      ,				run_time=0.5	)      ,				MoveToTarget(__lowercase      ,				run_time=0.5	)      ,				FadeIn(__lowercase      ,				run_time=0.5	)      ,				lag_ratio=0.2	)

															self.play(__lowercase	)

															model_cpu_arr[i].generate_target()
															model_cpu_arr[i].target.move_to(cpu_left_col_base[i]	)

															if i < 5:
																			model_cpu_arr[i + 1].generate_target()
																			model_cpu_arr[i + 1].target.move_to(gpu_rect[0]	)
																			if i >= 1:
																							__a       =		0.7

																			self.play(
																			    Circumscribe(model_arr[i]      ,				**__lowercase	)      ,				Circumscribe(cpu_left_col_base[i]      ,				**__lowercase	)      ,				Circumscribe(cpu_left_col_base[i + 1]      ,				color=__lowercase      ,				**__lowercase	)      ,				Circumscribe(gpu_rect[0]      ,				color=__lowercase      ,				**__lowercase	)      ,				Circumscribe(model_arr[i + 1]      ,				color=__lowercase      ,				**__lowercase	)      ,				)
																			if i < 1:
																							self.play(
																							    MoveToTarget(model_cpu_arr[i]	)      ,				MoveToTarget(model_cpu_arr[i + 1]	)      ,				)
																			else:
																							self.play(
																							    MoveToTarget(model_cpu_arr[i]      ,				run_time=0.7	)      ,				MoveToTarget(model_cpu_arr[i + 1]      ,				run_time=0.7	)      ,				)
															else:
																			model_cpu_arr[i].generate_target()
																			model_cpu_arr[i].target.move_to(cpu_left_col_base[-1]	)
																			input.generate_target()
																			input.target.next_to(model_arr[-1].get_right()      ,				RIGHT + 0.02      ,				buff=0.2	)

																			self.play(
																			    Circumscribe(model_arr[-1]      ,				color=__lowercase      ,				**__lowercase	)      ,				Circumscribe(cpu_left_col_base[-1]      ,				color=__lowercase      ,				**__lowercase	)      ,				Circumscribe(gpu_rect[0]      ,				color=__lowercase      ,				**__lowercase	)      ,				)

																			self.play(MoveToTarget(model_cpu_arr[i]	)	)

															__a       =		a_c
															__a       =		a_c.copy()

											input.generate_target()
											input.target.next_to(model_base[-1]      ,				RIGHT + 0.02      ,				buff=0.5	)
											self.play(
											    FadeOut(__lowercase	)      ,				FadeOut(__lowercase      ,				run_time=0.5	)      ,				)

											__a       =		MarkupText(F"Inference on a model too large for GPU memory\nis successfully completed."      ,				font_size=24	)
											step_a.move_to([2, 2, 0]	)

											self.play(Write(__lowercase      ,				run_time=3	)      ,				MoveToTarget(__lowercase	)	)

											self.wait()











from __future__ import annotations

lowerCamelCase__			= """Muhammad Umer Farooq"""
lowerCamelCase__			= """MIT"""
lowerCamelCase__			= """1.0.0"""
lowerCamelCase__			= """Muhammad Umer Farooq"""
lowerCamelCase__			= """contact@muhammadumerfarooq.me"""
lowerCamelCase__			= """Alpha"""

import re
from html.parser import HTMLParser
from urllib import parse

import requests






class    SCREAMING_SNAKE_CASE			(							lowerCamelCase__					):





							def __init__(   self		:		Any      ,				__lowercase		:		str	):

											'''simple docstring'''
											super().__init__()
											__a       =		[]
											__a       =		domain







							def 						UpperCamelCase_					(   self		:		Union[str, Any]      ,				__lowercase		:		str      ,				__lowercase		:		list[tuple[str, str | None]]	):

											'''simple docstring'''
											# Only parse the 'anchor' tag.
											if tag == "a":
															# Check the list of defined attributes.
															for name, value in attrs:
																			# If href is defined, and not empty nor # print it.
																			if name == "href" and value != "#" and value != "":
																							# If not already in urls.
																							if value not in self.urls:
																											__a       =		parse.urljoin(self.domain      ,				__lowercase	)
																											self.urls.append(__lowercase	)



def   lowerCAmelCase__						(							_SCREAMING_SNAKE_CASE       :			str    ):
				"""simple docstring"""







				return ".".join(get_sub_domain_name(_SCREAMING_SNAKE_CASE    ).split("""."""    )[-2:]    )

def   lowerCAmelCase__						(							_SCREAMING_SNAKE_CASE       :			str    ):
				"""simple docstring"""







				return parse.urlparse(_SCREAMING_SNAKE_CASE    ).netloc

def   lowerCAmelCase__						(							_SCREAMING_SNAKE_CASE       :			str = "https://github.com"    ):
				"""simple docstring"""







				__a       =		get_domain_name(_SCREAMING_SNAKE_CASE    )

				# Initialize the parser
				__a       =		Parser(_SCREAMING_SNAKE_CASE    )

				try:
								# Open URL
								__a       =		requests.get(_SCREAMING_SNAKE_CASE    )

								# pass the raw HTML to the parser to get links
								parser.feed(r.text    )

								# Get links and loop through
								__a       =		set()
								for link in parser.urls:
												# open URL.
												# read = requests.get(link)
												try:
																__a       =		requests.get(_SCREAMING_SNAKE_CASE    )
																# Get the valid email.
																__a       =		re.findall("""[a-zA-Z0-9]+@""" + domain				,     read.text    )
																# If not in list then append it.
																for email in emails:
																				valid_emails.add(_SCREAMING_SNAKE_CASE    )
												except ValueError:
																pass
				except ValueError:
								raise SystemExit(1    )

				# Finally return a sorted list of email addresses with no duplicates.
				return sorted(_SCREAMING_SNAKE_CASE    )


if __name__ == "__main__":
						lowerCamelCase__			= emails_from_url("""https://github.com""")
						print(F"""{len(emails)} emails found:""")
						print("""\n""".join(sorted(emails)))
