





"""simple docstring"""


from manim import *



class      __SCREAMING_SNAKE_CASE    (						_UpperCamelCase   ):







  '''simple docstring'''


  def    __SCREAMING_SNAKE_CASE				(		self   :       Optional[Any]	)		->				Dict:
        _UpperCamelCase      :	int						=       Rectangle(height=0.5					,   width=0.5	)
        _UpperCamelCase      :	List[Any]						=       Rectangle(height=0.46					,   width=0.46	).set_stroke(width=0	)

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

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

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

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

        _UpperCamelCase      :	Any						=       []
        for i, rect in enumerate(__a	):
              rect.set_stroke(__a	)
              # target = fill.copy().set_fill(YELLOW, opacity=0.7)
              # target.move_to(rect)
              # self.add(target)

              _UpperCamelCase      :	Optional[Any]						=       Rectangle(height=0.46 / 4					,   width=0.46 / 3	).set_stroke(width=0.0	).set_fill(__a					,   opacity=0.7	)

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

        _UpperCamelCase      :	List[Any]						=       [mem.copy() for i in range(6	)]
        _UpperCamelCase      :	str						=       VGroup(*__a	).arrange(__a					,   buff=0	)

        _UpperCamelCase      :	Any						=       Text("Loaded Checkpoint"					,   font_size=24	)
        _UpperCamelCase      :	List[str]						=       Group(__a					,   __a	).arrange(__a					,   aligned_edge=__a					,   buff=0.4	)
        checkpoint.move_to([3, 0.5, 0]	)

        _UpperCamelCase      :	Optional[Any]						=       Square(side_length=2.2	)
        key.move_to([-5, 2, 0]	)

        _UpperCamelCase      :	Optional[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(__a					,   __a	)

        _UpperCamelCase      :	Dict						=       MarkupText(
            F'''<span fgcolor=\'{BLUE}\'>●</span> Checkpoint'''					,   font_size=18					,   )

        blue_text.next_to(__a					,   DOWN * 2.4					,   aligned_edge=key_text.get_left()	)

        _UpperCamelCase      :	Optional[int]						=       MarkupText(
            F'''Next, a <i><span fgcolor="{BLUE}">second</span></i> model is loaded into memory,\nwith the weights of a <span fgcolor="{BLUE}">single shard</span>.'''					,   font_size=24					,   )
        step_a.move_to([2, 2, 0]	)
        self.play(Write(__a	)					,   Write(__a	)	)

        self.play(Write(__a					,   run_time=1	)					,   Create(__a					,   run_time=1	)	)

        _UpperCamelCase      :	Optional[int]						=       []
        _UpperCamelCase      :	List[str]						=       []
        for i, rect in enumerate(__a	):
              _UpperCamelCase      :	int						=       fill.copy().set_fill(__a					,   opacity=0.7	)
              target.move_to(__a	)
              first_animations.append(GrowFromCenter(__a					,   run_time=1	)	)

              _UpperCamelCase      :	Tuple						=       target.copy()
              cpu_target.generate_target()
              if i < 5:
                    cpu_target.target.move_to(cpu_left_col_base[i + 1]	)
              else:
                    cpu_target.target.move_to(cpu_right_col_base[i - 5]	)
              second_animations.append(MoveToTarget(__a					,   run_time=1.5	)	)

        self.play(*__a	)
        self.play(*__a	)
        self.wait()







"""simple docstring"""


from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


lowerCamelCase__				  =   {
    "configuration_mask2former": [
        "MASK2FORMER_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "Mask2FormerConfig",
    ],
}

try:
  if not is_vision_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  lowerCamelCase__				  =   ["Mask2FormerImageProcessor"]

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  lowerCamelCase__				  =   [
      "MASK2FORMER_PRETRAINED_MODEL_ARCHIVE_LIST",
      "Mask2FormerForUniversalSegmentation",
      "Mask2FormerModel",
      "Mask2FormerPreTrainedModel",
  ]

if TYPE_CHECKING:
  from .configuration_maskaformer import MASK2FORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, MaskaFormerConfig

  try:
    if not is_vision_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .image_processing_maskaformer import MaskaFormerImageProcessor

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_maskaformer import (
        MASK2FORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
        MaskaFormerForUniversalSegmentation,
        MaskaFormerModel,
        MaskaFormerPreTrainedModel,
    )


else:
  import sys

  lowerCamelCase__				  =   _LazyModule(__name__, globals()["__file__"], _import_structure)
