'''simple docstring'''

from manim import *



class 			UpperCAmelCase  (						a__					):





       '''simple docstring'''



       def _lowerCAmelCase(						self )  ->  int:
        lowercase__				:    str  =					Rectangle(height=0.5	,   width=0.5 )
        lowercase__				:    List[str]  =					Rectangle(height=0.4_6	,   width=0.4_6 ).set_stroke(width=0 )

        lowercase__				:    Dict  =					Rectangle(height=0.2_5	,   width=0.2_5 )

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

        lowercase__				:    Tuple  =					[mem.copy() for i in range(4 )]
        lowercase__				:    Tuple  =					VGroup(*__lowerCAmelCase ).arrange(__lowerCAmelCase	,   buff=0 )
        lowercase__				:    Optional[int]  =					Text('''GPU'''	,   font_size=24 )
        lowercase__				:    int  =					Group(__lowerCAmelCase	,   __lowerCAmelCase ).arrange(__lowerCAmelCase	,   buff=0.5	,   aligned_edge=__lowerCAmelCase )
        gpu.move_to([-1, -1, 0] )
        self.add(__lowerCAmelCase )

        lowercase__				:    List[str]  =					[mem.copy() for i in range(6 )]
        lowercase__				:    Dict  =					VGroup(*__lowerCAmelCase ).arrange(__lowerCAmelCase	,   buff=0 )

        lowercase__				:    Tuple  =					Text('''Model'''	,   font_size=24 )
        lowercase__				:    Dict  =					Group(__lowerCAmelCase	,   __lowerCAmelCase ).arrange(__lowerCAmelCase	,   buff=0.5	,   aligned_edge=__lowerCAmelCase )
        model.move_to([3, -1.0, 0] )
        self.add(__lowerCAmelCase )

        lowercase__				:    Any  =					[]
        lowercase__				:    int  =					[]

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

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

        lowercase__				:    int  =					[meta_mem.copy() for i in range(6 )]
        lowercase__				:    int  =					[meta_mem.copy() for i in range(6 )]
        lowercase__				:    Tuple  =					VGroup(*__lowerCAmelCase ).arrange(__lowerCAmelCase	,   buff=0 )
        lowercase__				:    Optional[Any]  =					VGroup(*__lowerCAmelCase ).arrange(__lowerCAmelCase	,   buff=0 )
        lowercase__				:    List[str]  =					VGroup(__lowerCAmelCase	,   __lowerCAmelCase ).arrange(__lowerCAmelCase	,   buff=0 )
        lowercase__				:    Optional[Any]  =					Text('''Disk'''	,   font_size=24 )
        lowercase__				:    Union[str, Any]  =					Group(__lowerCAmelCase	,   __lowerCAmelCase ).arrange(__lowerCAmelCase	,   buff=0.5	,   aligned_edge=__lowerCAmelCase )
        disk.move_to([-4, -1.2_5, 0] )
        self.add(__lowerCAmelCase	,   __lowerCAmelCase )

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

        lowercase__				:    Union[str, Any]  =					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 )

        lowercase__				:    str  =					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 )

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

        lowercase__				:    List[str]  =					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 ) )

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

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

        lowercase__				:    int  =					{'''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] ) )

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

         lowercase__				:    Optional[Any]  =					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:
           lowercase__				:    Union[str, Any]  =					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] ) )

         lowercase__				:    int  =					a_c
         lowercase__				:    List[Any]  =					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 )	,   )

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


'''simple docstring'''

import requests

__a: str          =   """https://newsapi.org/v1/articles?source=bbc-news&sortBy=top&apiKey="""
def 			__UpperCamelCase       (   UpperCAmelCase     ):
 # fetching a list of articles in json format
 lowercase__				:    Optional[Any]  =					requests.get(_NEWS_API + bbc_news_api_key     ).json()
 # each article in the list is a dict
 for i, article in enumerate(bbc_news_page['''articles''']		,     1     ):
  print(F"""{i}.) {article['title']}"""     )


if __name__ == "__main__":
  fetch_bbc_news(bbc_news_api_key="""<Your BBC News API key goes here>""")

