




from manim import *





class 	lowerCamelCase_							(				_SCREAMING_SNAKE_CASE ):


 '''simple docstring'''







 def 				lowerCAmelCase_  (							self  :		List[str]						):
       SCREAMING_SNAKE_CASE_     						=      Rectangle(height=0.5    ,    width=0.5						)
       SCREAMING_SNAKE_CASE_     						=      Rectangle(height=0.46    ,    width=0.46						).set_stroke(width=0						)

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

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

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

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

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

       SCREAMING_SNAKE_CASE_     						=      []
       SCREAMING_SNAKE_CASE_     						=      []

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

             SCREAMING_SNAKE_CASE_     						=      Rectangle(height=0.46    ,    width=0.46						).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						)

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

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

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

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

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

       SCREAMING_SNAKE_CASE_     						=      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.02						)
       self.play(MoveToTarget(_lowerCAmelCase						)						)

       self.play(FadeOut(_lowerCAmelCase						)						)

       SCREAMING_SNAKE_CASE_     						=      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]						)

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

       SCREAMING_SNAKE_CASE_     						=      {'run_time': 1, 'fade_in': True, 'fade_out': True, 'buff': 0.02}

       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]						)						)

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

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

             SCREAMING_SNAKE_CASE_     						=      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:
                         SCREAMING_SNAKE_CASE_     						=      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.02    ,    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]						)						)

             SCREAMING_SNAKE_CASE_     						=      a_c
             SCREAMING_SNAKE_CASE_     						=      a_c.copy()

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

       SCREAMING_SNAKE_CASE_     						=      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 pathlib import PurePosixPath
from typing import Optional

import fsspec
from fsspec import AbstractFileSystem
from huggingface_hub.hf_api import DatasetInfo

from ..utils.file_utils import get_authentication_headers_for_url
from ..utils.hub import hf_hub_url





class 	lowerCamelCase_							(				_SCREAMING_SNAKE_CASE ):


 '''simple docstring'''







 lowercase_       =   ""
 lowercase_       =   "hf-legacy"  # "hf://"" is reserved for hffs



 def __init__(							self  :		Optional[int]    ,    _lowerCAmelCase  :		Optional[DatasetInfo] = None    ,    _lowerCAmelCase  :		Optional[str] = None    ,    **_lowerCAmelCase  :		int    ,    ):
       super().__init__(self    ,    **_lowerCAmelCase						)
       SCREAMING_SNAKE_CASE_     						=      repo_info
       SCREAMING_SNAKE_CASE_     						=      token
       SCREAMING_SNAKE_CASE_     						=      None



 def 				lowerCAmelCase_  (							self  :		Tuple						):
       if self.dir_cache is None:
             SCREAMING_SNAKE_CASE_     						=      {}
             for hf_file in self.repo_info.siblings:
                   # TODO(QL): add sizes
                   SCREAMING_SNAKE_CASE_     						=      {
                       'name': hf_file.rfilename,
                       'size': None,
                       'type': 'file',
                   }
                   self.dir_cache.update(
                       {
                           str(_lowerCAmelCase						): {'name': str(_lowerCAmelCase						), 'size': None, 'type': 'directory'}
                           for d in list(PurePosixPath(hf_file.rfilename						).parents						)[:-1]
                       }						)



 def 				lowerCAmelCase_  (							self  :		Optional[int]    ,    _lowerCAmelCase  :		str    ,    _lowerCAmelCase  :		str = "rb"    ,    **_lowerCAmelCase  :		Optional[Any]    ,    ):
       if not isinstance(self.repo_info    ,    _lowerCAmelCase						):
             raise NotImplementedError(F"Open is only implemented for dataset repositories, but got {self.repo_info}"						)
       SCREAMING_SNAKE_CASE_     						=      hf_hub_url(self.repo_info.id    ,    _lowerCAmelCase    ,    revision=self.repo_info.sha						)
       return fsspec.open(
           _lowerCAmelCase    ,    mode=_lowerCAmelCase    ,    headers=get_authentication_headers_for_url(_lowerCAmelCase    ,    use_auth_token=self.token						)    ,    client_kwargs={'trust_env': True}    ,    ).open()



 def 				lowerCAmelCase_  (							self  :		List[Any]    ,    _lowerCAmelCase  :		Any    ,    **_lowerCAmelCase  :		Dict						):
       self._get_dirs()
       SCREAMING_SNAKE_CASE_     						=      self._strip_protocol(_lowerCAmelCase						)
       if path in self.dir_cache:
             return self.dir_cache[path]
       else:
             raise FileNotFoundError(_lowerCAmelCase						)




 def 				lowerCAmelCase_  (							self  :		Optional[Any]    ,    _lowerCAmelCase  :		Any    ,    _lowerCAmelCase  :		Any=False    ,    **_lowerCAmelCase  :		str						):
       self._get_dirs()
       SCREAMING_SNAKE_CASE_     						=      PurePosixPath(path.strip('/'						)						)
       SCREAMING_SNAKE_CASE_     						=      {}
       for p, f in self.dir_cache.items():
             SCREAMING_SNAKE_CASE_     						=      PurePosixPath(p.strip('/'						)						)
             SCREAMING_SNAKE_CASE_     						=      p.parent
             if root == path:
                   SCREAMING_SNAKE_CASE_     						=      f
       SCREAMING_SNAKE_CASE_     						=      list(paths.values()						)
       if detail:
             return out
       else:
             return sorted(f['name'] for f in out						)