from manim import *
class SCREAMING_SNAKE_CASE_		(      __lowerCAmelCase		):







   def 						lowerCamelCase_	(     self						:						List[Any]				):





    """simple docstring"""


    UpperCamelCase			  =      Rectangle(height=0.5   ,   width=0.5				)
    UpperCamelCase			  =      Rectangle(height=0.4_6   ,   width=0.4_6				).set_stroke(width=0				)

    UpperCamelCase			  =      Rectangle(height=0.2_5   ,   width=0.2_5				)

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

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

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

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

    UpperCamelCase			  =      []
    UpperCamelCase			  =      []

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

     UpperCamelCase			  =      Rectangle(height=0.4_6   ,   width=0.4_6				).set_stroke(width=0.0				).set_fill(lowerCamelCase_   ,   opacity=0.8				)
     cpu_target.move_to(cpu_left_col_base[i]				)
     model_cpu_arr.append(lowerCamelCase_				)

    self.add(*lowerCamelCase_   ,   *lowerCamelCase_				)

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

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

    UpperCamelCase			  =      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			  =      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			  =      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(lowerCamelCase_				)				)

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

    self.play(Write(lowerCamelCase_				)				)

    input.generate_target()
    input.target.next_to(model_arr[0]   ,   direction=lowerCamelCase_   ,   buff=0.0_2				)
    self.play(MoveToTarget(lowerCamelCase_				)				)

    self.play(FadeOut(lowerCamelCase_				)				)

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

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

    UpperCamelCase			  =      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(lowerCamelCase_   ,   run_time=3				)				)

    UpperCamelCase			  =      {"""run_time""": 1, """fade_in""": True, """fade_out""": True, """buff""": 0.0_2}

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

    UpperCamelCase			  =      a.copy()
    for i in range(6				):
     a_c.next_to(model_arr[i].get_right() + 0.0_2   ,   lowerCamelCase_   ,   buff=0.2				)

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

     UpperCamelCase			  =      AnimationGroup(
         FadeOut(lowerCamelCase_   ,   run_time=0.5				)   ,   MoveToTarget(lowerCamelCase_   ,   run_time=0.5				)   ,   FadeIn(lowerCamelCase_   ,   run_time=0.5				)   ,   lag_ratio=0.2				)

     self.play(lowerCamelCase_				)

     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:
       UpperCamelCase			  =      0.7

      self.play(
          Circumscribe(model_arr[i]   ,   **lowerCamelCase_				)   ,   Circumscribe(cpu_left_col_base[i]   ,   **lowerCamelCase_				)   ,   Circumscribe(cpu_left_col_base[i + 1]   ,   color=lowerCamelCase_   ,   **lowerCamelCase_				)   ,   Circumscribe(gpu_rect[0]   ,   color=lowerCamelCase_   ,   **lowerCamelCase_				)   ,   Circumscribe(model_arr[i + 1]   ,   color=lowerCamelCase_   ,   **lowerCamelCase_				)   ,   )
      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.0_2   ,   buff=0.2				)

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

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

     UpperCamelCase			  =      a_c
     UpperCamelCase			  =      a_c.copy()

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

    UpperCamelCase			  =      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(lowerCamelCase_   ,   run_time=3				)   ,   MoveToTarget(lowerCamelCase_				)				)

    self.wait()

from datetime import datetime

import requests
from bsa import BeautifulSoup

if __name__ == "__main__":
     _SCREAMING_SNAKE_CASE 		=      input("""Enter image url: """).strip()
     print(F'''Downloading image from {url} ...''')
     _SCREAMING_SNAKE_CASE 		=      BeautifulSoup(requests.get(url).content, """html.parser""")
     # The image URL is in the content field of the first meta tag with property og:image
     _SCREAMING_SNAKE_CASE 		=      soup.find("""meta""", {"""property""": """og:image"""})["""content"""]
     _SCREAMING_SNAKE_CASE 		=      requests.get(image_url).content
     _SCREAMING_SNAKE_CASE 		=      F'''{datetime.now():%Y-%m-%d_%H:%M:%S}.jpg'''
     with open(file_name, """wb""") as fp:
          fp.write(image_data)
     print(F'''Done. Image saved to disk as {file_name}.''')
