


'''simple docstring'''


from manim import *





class    lowercase__  (						_snake_case ):





							'''simple docstring'''


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

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

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

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

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

											_SCREAMING_SNAKE_CASE			:	List[Any]							=				[]
											_SCREAMING_SNAKE_CASE			:	str							=				[]

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

															_SCREAMING_SNAKE_CASE			:	int							=				Rectangle(height=0.46 / 4   , width=0.46 / 3  ).set_stroke(width=0.0  ).set_fill(__snake_case   , opacity=0.7  )

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

											self.add(*__snake_case   , *__snake_case  )

											_SCREAMING_SNAKE_CASE			:	str							=				[meta_mem.copy() for i in range(6  )]
											_SCREAMING_SNAKE_CASE			:	str							=				[meta_mem.copy() for i in range(6  )]
											_SCREAMING_SNAKE_CASE			:	Any							=				VGroup(*__snake_case  ).arrange(__snake_case   , buff=0  )
											_SCREAMING_SNAKE_CASE			:	int							=				VGroup(*__snake_case  ).arrange(__snake_case   , buff=0  )
											_SCREAMING_SNAKE_CASE			:	Tuple							=				VGroup(__snake_case   , __snake_case  ).arrange(__snake_case   , buff=0  )
											_SCREAMING_SNAKE_CASE			:	int							=				Text("""Disk"""   , font_size=24  )
											_SCREAMING_SNAKE_CASE			:	Union[str, Any]							=				Group(__snake_case   , __snake_case  ).arrange(__snake_case   , buff=0.5   , aligned_edge=__snake_case  )
											disk.move_to([-4.0, -1.25, 0]  )
											self.add(__snake_case   , __snake_case  )

											_SCREAMING_SNAKE_CASE			:	Optional[Any]							=				[]

											for i in range(6  ):
															_SCREAMING_SNAKE_CASE			:	List[Any]							=				fill.copy().set_fill(__snake_case   , opacity=0.8  )
															target.move_to(disk_left_col_base[i]  ).scale(0.5  )
															cpu_disk_arr.append(__snake_case  )

											self.add(*__snake_case  )

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

											_SCREAMING_SNAKE_CASE			:	Dict							=				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(__snake_case   , __snake_case  )

											_SCREAMING_SNAKE_CASE			:	str							=				MarkupText(
											    f"""<span fgcolor='{BLUE}'>●</span> Checkpoint"""   , font_size=18   , )

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

											_SCREAMING_SNAKE_CASE			:	Union[str, Any]							=				MarkupText(f"""The offloaded weights are all sent to the CPU."""   , font_size=24  )
											step_a.move_to([2, 2, 0]  )

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

											for i in range(6  ):
															_SCREAMING_SNAKE_CASE			:	Optional[int]							=				cpu_disk_arr[i]
															_SCREAMING_SNAKE_CASE			:	Optional[Any]							=				rect.copy().set_fill(__snake_case   , opacity=0.8  ).scale(2.0  )
															cpa.generate_target()
															cpa.target.move_to(model_base[i]  )

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

																			self.remove(
																			    *__snake_case   , *__snake_case   , )

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

											_SCREAMING_SNAKE_CASE			:	Optional[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(__snake_case   , run_time=3  )  )

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



'''simple docstring'''


import bsa
import requests







def       snake_case_       (  SCREAMING_SNAKE_CASE__					):







				"""simple docstring"""





				return {
				    "name": soup.ha.a.text,
				    "genre": soup.find("""span"""							,				class_="""genre"""					).text.strip(),
				    "rating": soup.strong.text,
				    "page_link": f"""https://www.imdb.com{soup.a.get("href"					)}""",
				}







def       snake_case_       (  SCREAMING_SNAKE_CASE__ = 5					):







				"""simple docstring"""





				_SCREAMING_SNAKE_CASE			:	List[str]							=				int(float(SCREAMING_SNAKE_CASE__					)					)
				if num_movies < 1:
								return ()
				_SCREAMING_SNAKE_CASE			:	Optional[Any]							=				(
				    """https://www.imdb.com/search/title?title_type="""
				    f"""feature&sort=num_votes,desc&count={num_movies}"""
				)
				_SCREAMING_SNAKE_CASE			:	Any							=				bsa.BeautifulSoup(requests.get(SCREAMING_SNAKE_CASE__					).content							,				"""html.parser"""					)
				return tuple(
				    get_movie_data_from_soup(SCREAMING_SNAKE_CASE__					)
				    for movie in source.find_all("""div"""							,				class_="""lister-item mode-advanced"""					)					)


if __name__ == "__main__":
				import json

				UpperCAmelCase_		:       List[str]							       =		int(input('How many movies would you like to see? '))
				print(
				    ', '.join(
				        json.dumps(movie, indent=4) for movie in get_imdb_top_movies(num_movies)
				    )
				)




