





from manim import *


class        __magic_name__	(				lowerCamelCase__				):





     """simple docstring"""



     def     SCREAMING_SNAKE_CASE		(				self							:str	):





        '''simple docstring'''




        A_       :					Tuple        =      Rectangle(height=0.5      ,   width=0.5	)
        A_       :					Dict        =      Rectangle(height=0.46      ,   width=0.46	).set_stroke(width=0	)

        A_       :					Union[str, Any]        =      [mem.copy() for i in range(6	)]
        A_       :					str        =      [mem.copy() for i in range(6	)]
        A_       :					Optional[Any]        =      VGroup(*snake_case	).arrange(snake_case      ,   buff=0	)
        A_       :					Optional[int]        =      VGroup(*snake_case	).arrange(snake_case      ,   buff=0	)
        A_       :					Any        =      VGroup(snake_case      ,   snake_case	).arrange(snake_case      ,   buff=0	)
        A_       :					Union[str, Any]        =      Text("CPU"      ,   font_size=24	)
        A_       :					Tuple        =      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	)

        A_       :					int        =      [mem.copy() for i in range(4	)]
        A_       :					Dict        =      VGroup(*snake_case	).arrange(snake_case      ,   buff=0	)
        A_       :					Any        =      Text("GPU"      ,   font_size=24	)
        A_       :					int        =      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	)

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

        A_       :					Optional[Any]        =      Text("Model"      ,   font_size=24	)
        A_       :					Union[str, 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	)

        A_       :					Optional[int]        =      []
        for i, rect in enumerate(snake_case	):
           rect.set_stroke(snake_case	)
           # target = fill.copy().set_fill(YELLOW, opacity=0.7)
           # target.move_to(rect)
           # self.add(target)

           A_       :					List[Any]        =      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(cpu_targs[0]      ,   direction=snake_case      ,   buff=0.0	)
           else:
              cpu_target.next_to(cpu_targs[i - 1]      ,   direction=snake_case      ,   buff=0.0	)
           self.add(snake_case	)
           cpu_targs.append(snake_case	)

        A_       :					int        =      [mem.copy() for i in range(6	)]
        A_       :					Optional[int]        =      VGroup(*snake_case	).arrange(snake_case      ,   buff=0	)

        A_       :					Optional[Any]        =      Text("Loaded Checkpoint"      ,   font_size=24	)
        A_       :					Optional[Any]        =      Group(snake_case      ,   snake_case	).arrange(snake_case      ,   aligned_edge=snake_case      ,   buff=0.4	)
        checkpoint.move_to([3, 0.5, 0]	)

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

        A_       :					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	)

        A_       :					Optional[int]        =      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()	)

        A_       :					Union[str, Any]        =      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(snake_case	)      ,   Write(snake_case	)	)

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

        A_       :					Any        =      []
        A_       :					Any        =      []
        for i, rect in enumerate(snake_case	):
           A_       :					List[Any]        =      fill.copy().set_fill(snake_case      ,   opacity=0.7	)
           target.move_to(snake_case	)
           first_animations.append(GrowFromCenter(snake_case      ,   run_time=1	)	)

           A_       :					Dict        =      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(snake_case      ,   run_time=1.5	)	)

        self.play(*snake_case	)
        self.play(*snake_case	)
        self.wait()







import random
import unittest

import torch

from diffusers import IFInpaintingPipeline
from diffusers.utils import floats_tensor
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import skip_mps, torch_device

from ..pipeline_params import (
    TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_INPAINTING_PARAMS,
)
from ..test_pipelines_common import PipelineTesterMixin
from . import IFPipelineTesterMixin


@skip_mps
class        __magic_name__	(				lowerCamelCase__     ,					lowerCamelCase__     ,					unittest.TestCase				):





     """simple docstring"""



     __UpperCamelCase            =  IFInpaintingPipeline
     __UpperCamelCase            =  TEXT_GUIDED_IMAGE_INPAINTING_PARAMS - {'''width''', '''height'''}
     __UpperCamelCase            =  TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
     __UpperCamelCase            =  PipelineTesterMixin.required_optional_params - {'''latents'''}



     def     SCREAMING_SNAKE_CASE		(				self							:Optional[Any]	):





        '''simple docstring'''




        return self._get_dummy_components()



     def     SCREAMING_SNAKE_CASE		(				self							:List[Any]      ,   snake_case							:str      ,   snake_case							:List[Any]=0	):





        '''simple docstring'''




        if str(snake_case	).startswith("mps"	):
           A_       :					Optional[Any]        =      torch.manual_seed(snake_case	)
        else:
           A_       :					Any        =      torch.Generator(device=snake_case	).manual_seed(snake_case	)

        A_       :					Optional[Any]        =      floats_tensor((1, 3, 32, 32)      ,   rng=random.Random(snake_case	)	).to(snake_case	)
        A_       :					Any        =      floats_tensor((1, 3, 32, 32)      ,   rng=random.Random(snake_case	)	).to(snake_case	)

        A_       :					List[Any]        =      {
            "prompt": "A painting of a squirrel eating a burger",
            "image": image,
            "mask_image": mask_image,
            "generator": generator,
            "num_inference_steps": 2,
            "output_type": "numpy",
        }

        return inputs



     @unittest.skipIf(
         torch_device != "cuda" or not is_xformers_available()      ,   reason="XFormers attention is only available with CUDA and `xformers` installed"      ,   )
     def     SCREAMING_SNAKE_CASE		(				self							:Any	):





        '''simple docstring'''




        self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3	)



     def     SCREAMING_SNAKE_CASE		(				self							:Optional[int]	):





        '''simple docstring'''




        self._test_save_load_optional_components()



     @unittest.skipIf(torch_device != "cuda"      ,   reason="float16 requires CUDA"	)
     def     SCREAMING_SNAKE_CASE		(				self							:Union[str, Any]	):





        '''simple docstring'''




        super().test_save_load_floataa(expected_max_diff=1e-1	)



     def     SCREAMING_SNAKE_CASE		(				self							:Dict	):





        '''simple docstring'''




        self._test_attention_slicing_forward_pass(expected_max_diff=1e-2	)



     def     SCREAMING_SNAKE_CASE		(				self							:List[Any]	):





        '''simple docstring'''




        self._test_save_load_local()





     def     SCREAMING_SNAKE_CASE		(				self							:Dict	):





        '''simple docstring'''




        self._test_inference_batch_single_identical(
            expected_max_diff=1e-2      ,   )
