
"""simple docstring"""




from manim import *







class   _lowercase						(       lowerCAmelCase_				):


     '''simple docstring'''





     def  lowerCAmelCase__       (      self  )->					Tuple:
          UpperCAmelCase__							: str 							=						Rectangle(height=0.5 ,			width=0.5  )
          UpperCAmelCase__							: List[str] 							=						Rectangle(height=0.46 ,			width=0.46  ).set_stroke(width=0  )

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

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

          UpperCAmelCase__							: Optional[int] 							=						[mem.copy() for i in range(6  )]
          UpperCAmelCase__							: List[str] 							=						VGroup(*__UpperCamelCase  ).arrange(__UpperCamelCase ,			buff=0  )

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

          UpperCAmelCase__							: List[str] 							=						[]
          for i, rect in enumerate(__UpperCamelCase  ):
               rect.set_stroke(__UpperCamelCase  )
               # target = fill.copy().set_fill(YELLOW, opacity=0.7)
               # target.move_to(rect)
               # self.add(target)

               UpperCAmelCase__							: int 							=						Rectangle(height=0.46 / 4 ,			width=0.46 / 3  ).set_stroke(width=0.0  ).set_fill(__UpperCamelCase ,			opacity=0.7  )

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

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

          UpperCAmelCase__							: Tuple 							=						Text("Loaded Checkpoint" ,			font_size=24  )
          UpperCAmelCase__							: Any 							=						Group(__UpperCamelCase ,			__UpperCamelCase  ).arrange(__UpperCamelCase ,			aligned_edge=__UpperCamelCase ,			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__							: 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(__UpperCamelCase ,			__UpperCamelCase  )

          UpperCAmelCase__							: str 							=						MarkupText(
              F"<span fgcolor='{BLUE}'>●</span> Checkpoint" ,			font_size=18 ,			)

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

          UpperCAmelCase__							: Optional[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(__UpperCamelCase  ) ,			Write(__UpperCamelCase  )  )

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

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

               UpperCAmelCase__							: List[str] 							=						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(__UpperCamelCase ,			run_time=1.5  )  )

          self.play(*__UpperCamelCase  )
          self.play(*__UpperCamelCase  )
          self.wait()





"""simple docstring"""




import unittest

import numpy as np

from diffusers import LMSDiscreteScheduler, OnnxStableDiffusionInpaintPipeline
from diffusers.utils.testing_utils import (
    is_onnx_available,
    load_image,
    nightly,
    require_onnxruntime,
    require_torch_gpu,
)

from ..test_pipelines_onnx_common import OnnxPipelineTesterMixin


if is_onnx_available():
    import onnxruntime as ort







class   _lowercase						(       lowerCAmelCase_	,   unittest.TestCase				):


     '''simple docstring'''





     pass







@nightly
@require_onnxruntime
@require_torch_gpu
class   _lowercase						(       unittest.TestCase				):


     '''simple docstring'''





     @property
     def  lowerCAmelCase__       (      self  )->					int:
          return (
              "CUDAExecutionProvider",
              {
                  "gpu_mem_limit": "15000000000",  # 15GB
                  "arena_extend_strategy": "kSameAsRequested",
              },
          )



     @property
     def  lowerCAmelCase__       (      self  )->					Any:
          UpperCAmelCase__							: Tuple 							=						ort.SessionOptions()
          UpperCAmelCase__							: List[str] 							=						False
          return options



     def  lowerCAmelCase__       (      self  )->					List[str]:
          UpperCAmelCase__							: Union[str, Any] 							=						load_image(
              "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
              "/in_paint/overture-creations-5sI6fQgYIuo.png"  )
          UpperCAmelCase__							: int 							=						load_image(
              "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
              "/in_paint/overture-creations-5sI6fQgYIuo_mask.png"  )
          UpperCAmelCase__							: str 							=						OnnxStableDiffusionInpaintPipeline.from_pretrained(
              "runwayml/stable-diffusion-inpainting" ,			revision="onnx" ,			safety_checker=__UpperCamelCase ,			feature_extractor=__UpperCamelCase ,			provider=self.gpu_provider ,			sess_options=self.gpu_options ,			)
          pipe.set_progress_bar_config(disable=__UpperCamelCase  )

          UpperCAmelCase__							: int 							=						"A red cat sitting on a park bench"

          UpperCAmelCase__							: Tuple 							=						np.random.RandomState(0  )
          UpperCAmelCase__							: Any 							=						pipe(
              prompt=__UpperCamelCase ,			image=__UpperCamelCase ,			mask_image=__UpperCamelCase ,			guidance_scale=7.5 ,			num_inference_steps=10 ,			generator=__UpperCamelCase ,			output_type="np" ,			)
          UpperCAmelCase__							: Tuple 							=						output.images
          UpperCAmelCase__							: Dict 							=						images[0, 2_55:2_58, 2_55:2_58, -1]

          assert images.shape == (1, 5_12, 5_12, 3)
          UpperCAmelCase__							: Union[str, Any] 							=						np.array([0.2514, 0.3007, 0.3517, 0.1790, 0.2382, 0.3167, 0.1944, 0.2273, 0.2464]  )

          assert np.abs(image_slice.flatten() - expected_slice  ).max() < 1E-3



     def  lowerCAmelCase__       (      self  )->					Tuple:
          UpperCAmelCase__							: Tuple 							=						load_image(
              "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
              "/in_paint/overture-creations-5sI6fQgYIuo.png"  )
          UpperCAmelCase__							: Tuple 							=						load_image(
              "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
              "/in_paint/overture-creations-5sI6fQgYIuo_mask.png"  )
          UpperCAmelCase__							: Optional[Any] 							=						LMSDiscreteScheduler.from_pretrained(
              "runwayml/stable-diffusion-inpainting" ,			subfolder="scheduler" ,			revision="onnx"  )
          UpperCAmelCase__							: Optional[Any] 							=						OnnxStableDiffusionInpaintPipeline.from_pretrained(
              "runwayml/stable-diffusion-inpainting" ,			revision="onnx" ,			scheduler=__UpperCamelCase ,			safety_checker=__UpperCamelCase ,			feature_extractor=__UpperCamelCase ,			provider=self.gpu_provider ,			sess_options=self.gpu_options ,			)
          pipe.set_progress_bar_config(disable=__UpperCamelCase  )

          UpperCAmelCase__							: int 							=						"A red cat sitting on a park bench"

          UpperCAmelCase__							: List[str] 							=						np.random.RandomState(0  )
          UpperCAmelCase__							: str 							=						pipe(
              prompt=__UpperCamelCase ,			image=__UpperCamelCase ,			mask_image=__UpperCamelCase ,			guidance_scale=7.5 ,			num_inference_steps=20 ,			generator=__UpperCamelCase ,			output_type="np" ,			)
          UpperCAmelCase__							: List[str] 							=						output.images
          UpperCAmelCase__							: List[Any] 							=						images[0, 2_55:2_58, 2_55:2_58, -1]

          assert images.shape == (1, 5_12, 5_12, 3)
          UpperCAmelCase__							: int 							=						np.array([0.0086, 0.0077, 0.0083, 0.0093, 0.0107, 0.0139, 0.0094, 0.0097, 0.0125]  )

          assert np.abs(image_slice.flatten() - expected_slice  ).max() < 1E-3



