

'''simple docstring'''






import inspect
import unittest

import torch
import torch.nn as nn

from accelerate.hooks import (
    AlignDevicesHook,
    ModelHook,
    SequentialHook,
    add_hook_to_module,
    attach_align_device_hook,
    remove_hook_from_module,
    remove_hook_from_submodules,
)
from accelerate.test_utils import require_multi_gpu






class      lowercase_      (nn.Module ):




  """simple docstring"""




  def __init__( self  :	Tuple     ):
   super().__init__()
   __lowercase				    =					nn.Linear(3   ,4     )
   __lowercase				    =					nn.BatchNormad(4     )
   __lowercase				    =					nn.Linear(4   ,5     )






  def    SCREAMING_SNAKE_CASE ( self  :	List[str]   ,lowercase__  :	List[Any]     ):
   return self.lineara(self.batchnorm(self.lineara(lowercase__     )     )     )






class      lowercase_      (lowerCamelCase__ ):




  """simple docstring"""




  def    SCREAMING_SNAKE_CASE ( self  :	List[Any]   ,lowercase__  :	Dict   ,*lowercase__  :	List[str]   ,**lowercase__  :	List[str]     ):
   return (args[0] + 1,) + args[1:], kwargs






class      lowercase_      (lowerCamelCase__ ):




  """simple docstring"""




  def    SCREAMING_SNAKE_CASE ( self  :	List[str]   ,lowercase__  :	Optional[Any]   ,lowercase__  :	Optional[Any]     ):
   return output + 1






class      lowercase_      (unittest.TestCase ):




  """simple docstring"""




  def    SCREAMING_SNAKE_CASE ( self  :	str     ):
   __lowercase				    =					ModelForTest()
   __lowercase				    =					ModelHook()

   add_hook_to_module(lowercase__   ,lowercase__     )
   self.assertEqual(test_model._hf_hook   ,lowercase__     )
   self.assertTrue(hasattr(lowercase__   ,'''_old_forward'''     )     )

   # Check adding the hook did not change the name or the signature
   self.assertEqual(test_model.forward.__name__   ,'''forward'''     )
   self.assertListEqual(list(inspect.signature(test_model.forward     ).parameters     )   ,['''x''']     )

   remove_hook_from_module(lowercase__     )
   self.assertFalse(hasattr(lowercase__   ,'''_hf_hook'''     )     )
   self.assertFalse(hasattr(lowercase__   ,'''_old_forward'''     )     )






  def    SCREAMING_SNAKE_CASE ( self  :	List[str]     ):
   __lowercase				    =					ModelForTest()
   __lowercase				    =					ModelHook()

   add_hook_to_module(lowercase__   ,lowercase__     )
   add_hook_to_module(lowercase__   ,lowercase__   ,append=lowercase__     )

   self.assertEqual(isinstance(test_model._hf_hook   ,lowercase__     )   ,lowercase__     )
   self.assertEqual(len(test_model._hf_hook.hooks     )   ,2     )
   self.assertTrue(hasattr(lowercase__   ,'''_old_forward'''     )     )

   # Check adding the hook did not change the name or the signature
   self.assertEqual(test_model.forward.__name__   ,'''forward'''     )
   self.assertListEqual(list(inspect.signature(test_model.forward     ).parameters     )   ,['''x''']     )

   remove_hook_from_module(lowercase__     )
   self.assertFalse(hasattr(lowercase__   ,'''_hf_hook'''     )     )
   self.assertFalse(hasattr(lowercase__   ,'''_old_forward'''     )     )






  def    SCREAMING_SNAKE_CASE ( self  :	Optional[int]     ):
   __lowercase				    =					ModelForTest()
   __lowercase				    =					torch.randn(2   ,3     )
   __lowercase				    =					test_model(x + 1     )
   __lowercase				    =					test_model(x + 2     )

   __lowercase				    =					PreForwardHook()
   add_hook_to_module(lowercase__   ,lowercase__     )
   __lowercase				    =					test_model(lowercase__     )
   self.assertTrue(torch.allclose(lowercase__   ,lowercase__   ,atol=1e-5     )     )

   # Attaching a hook to a model when it already has one replaces, does not chain
   __lowercase				    =					PreForwardHook()
   add_hook_to_module(lowercase__   ,lowercase__     )
   __lowercase				    =					test_model(lowercase__     )
   self.assertTrue(torch.allclose(lowercase__   ,lowercase__   ,atol=1e-5     )     )

   # You need to use the sequential hook to chain two or more hooks
   __lowercase				    =					SequentialHook(PreForwardHook()   ,PreForwardHook()     )
   add_hook_to_module(lowercase__   ,lowercase__     )

   __lowercase				    =					test_model(lowercase__     )
   assert torch.allclose(lowercase__   ,lowercase__   ,atol=1e-5     )






  def    SCREAMING_SNAKE_CASE ( self  :	Optional[int]     ):
   __lowercase				    =					ModelForTest()
   __lowercase				    =					torch.randn(2   ,3     )
   __lowercase				    =					test_model(lowercase__     )

   __lowercase				    =					PostForwardHook()
   add_hook_to_module(lowercase__   ,lowercase__     )
   __lowercase				    =					test_model(lowercase__     )
   self.assertTrue(torch.allclose(lowercase__   ,output + 1   ,atol=1e-5     )     )

   # Attaching a hook to a model when it already has one replaces, does not chain
   __lowercase				    =					PostForwardHook()
   add_hook_to_module(lowercase__   ,lowercase__     )
   __lowercase				    =					test_model(lowercase__     )
   self.assertTrue(torch.allclose(lowercase__   ,output + 1   ,atol=1e-5     )     )

   # You need to use the sequential hook to chain two or more hooks
   __lowercase				    =					SequentialHook(PostForwardHook()   ,PostForwardHook()     )
   add_hook_to_module(lowercase__   ,lowercase__     )

   __lowercase				    =					test_model(lowercase__     )
   assert torch.allclose(lowercase__   ,output + 2   ,atol=1e-5     )






  def    SCREAMING_SNAKE_CASE ( self  :	int     ):
   __lowercase				    =					ModelForTest()
   __lowercase				    =					torch.randn(2   ,3     )
   __lowercase				    =					test_model(lowercase__     )

   __lowercase				    =					PostForwardHook()
   add_hook_to_module(lowercase__   ,lowercase__     )
   __lowercase				    =					test_model(lowercase__     )
   self.assertTrue(torch.allclose(lowercase__   ,output + 1     )     )
   self.assertTrue(outputa.requires_grad     )

   __lowercase				    =					True
   __lowercase				    =					test_model(lowercase__     )
   self.assertFalse(outputa.requires_grad     )






  @require_multi_gpu
  def    SCREAMING_SNAKE_CASE ( self  :	Dict     ):
   __lowercase				    =					ModelForTest()
   # Everything is on CPU
   self.assertEqual(model.lineara.weight.device   ,torch.device('''cpu'''     )     )
   self.assertEqual(model.batchnorm.weight.device   ,torch.device('''cpu'''     )     )
   self.assertEqual(model.lineara.weight.device   ,torch.device('''cpu'''     )     )

   # This will move each submodule on different devices
   add_hook_to_module(model.lineara   ,AlignDevicesHook(execution_device=0     )     )
   add_hook_to_module(model.batchnorm   ,AlignDevicesHook(execution_device=0     )     )
   add_hook_to_module(model.lineara   ,AlignDevicesHook(execution_device=1     )     )

   self.assertEqual(model.lineara.weight.device   ,torch.device(0     )     )
   self.assertEqual(model.batchnorm.weight.device   ,torch.device(0     )     )
   self.assertEqual(model.batchnorm.running_mean.device   ,torch.device(0     )     )
   self.assertEqual(model.lineara.weight.device   ,torch.device(1     )     )

   # We can still make a forward pass. The input does not need to be on any particular device
   __lowercase				    =					torch.randn(2   ,3     )
   __lowercase				    =					model(lowercase__     )
   self.assertEqual(output.device   ,torch.device(1     )     )

   # We can add a general hook to put back output on same device as input.
   add_hook_to_module(lowercase__   ,AlignDevicesHook(io_same_device=lowercase__     )     )
   __lowercase				    =					torch.randn(2   ,3     ).to(0     )
   __lowercase				    =					model(lowercase__     )
   self.assertEqual(output.device   ,torch.device(0     )     )






  def    SCREAMING_SNAKE_CASE ( self  :	str     ):
   __lowercase				    =					ModelForTest()

   # Everything is on CPU
   self.assertEqual(model.lineara.weight.device   ,torch.device('''cpu'''     )     )
   self.assertEqual(model.batchnorm.weight.device   ,torch.device('''cpu'''     )     )
   self.assertEqual(model.lineara.weight.device   ,torch.device('''cpu'''     )     )

   # This will move each submodule on different devices
   __lowercase				    =					{'''execution_device''': 0 if torch.cuda.is_available() else '''cpu''', '''offload''': True}

   add_hook_to_module(model.lineara   ,AlignDevicesHook(**lowercase__     )     )
   add_hook_to_module(model.batchnorm   ,AlignDevicesHook(**lowercase__     )     )
   add_hook_to_module(model.lineara   ,AlignDevicesHook(**lowercase__     )     )

   # Parameters have been offloaded, so on the meta device
   self.assertEqual(model.lineara.weight.device   ,torch.device('''meta'''     )     )
   self.assertEqual(model.batchnorm.weight.device   ,torch.device('''meta'''     )     )
   self.assertEqual(model.lineara.weight.device   ,torch.device('''meta'''     )     )
   # Buffers are not included in the offload by default, so are on the execution device
   __lowercase				    =					torch.device(hook_kwargs['''execution_device''']     )
   self.assertEqual(model.batchnorm.running_mean.device   ,lowercase__     )

   __lowercase				    =					torch.randn(2   ,3     )
   __lowercase				    =					model(lowercase__     )
   self.assertEqual(output.device   ,lowercase__     )

   # Removing hooks loads back the weights in the model.
   remove_hook_from_module(model.lineara     )
   remove_hook_from_module(model.batchnorm     )
   remove_hook_from_module(model.lineara     )
   self.assertEqual(model.lineara.weight.device   ,torch.device('''cpu'''     )     )
   self.assertEqual(model.batchnorm.weight.device   ,torch.device('''cpu'''     )     )
   self.assertEqual(model.lineara.weight.device   ,torch.device('''cpu'''     )     )

   # Now test with buffers included in the offload
   __lowercase				    =					{
       '''execution_device''': 0 if torch.cuda.is_available() else '''cpu''',
       '''offload''': True,
       '''offload_buffers''': True,
   }

   add_hook_to_module(model.lineara   ,AlignDevicesHook(**lowercase__     )     )
   add_hook_to_module(model.batchnorm   ,AlignDevicesHook(**lowercase__     )     )
   add_hook_to_module(model.lineara   ,AlignDevicesHook(**lowercase__     )     )

   # Parameters have been offloaded, so on the meta device, buffers included
   self.assertEqual(model.lineara.weight.device   ,torch.device('''meta'''     )     )
   self.assertEqual(model.batchnorm.weight.device   ,torch.device('''meta'''     )     )
   self.assertEqual(model.lineara.weight.device   ,torch.device('''meta'''     )     )
   self.assertEqual(model.batchnorm.running_mean.device   ,torch.device('''meta'''     )     )

   __lowercase				    =					torch.randn(2   ,3     )
   __lowercase				    =					model(lowercase__     )
   self.assertEqual(output.device   ,lowercase__     )

   # Removing hooks loads back the weights in the model.
   remove_hook_from_module(model.lineara     )
   remove_hook_from_module(model.batchnorm     )
   remove_hook_from_module(model.lineara     )
   self.assertEqual(model.lineara.weight.device   ,torch.device('''cpu'''     )     )
   self.assertEqual(model.batchnorm.weight.device   ,torch.device('''cpu'''     )     )
   self.assertEqual(model.lineara.weight.device   ,torch.device('''cpu'''     )     )






  def    SCREAMING_SNAKE_CASE ( self  :	int     ):
   __lowercase				    =					ModelForTest()

   # Everything is on CPU
   self.assertEqual(model.lineara.weight.device   ,torch.device('''cpu'''     )     )
   self.assertEqual(model.batchnorm.weight.device   ,torch.device('''cpu'''     )     )
   self.assertEqual(model.lineara.weight.device   ,torch.device('''cpu'''     )     )

   # This will move each submodule on different devices
   __lowercase				    =					0 if torch.cuda.is_available() else '''cpu'''
   attach_align_device_hook(lowercase__   ,execution_device=lowercase__   ,offload=lowercase__     )

   # Parameters have been offloaded, so on the meta device
   self.assertEqual(model.lineara.weight.device   ,torch.device('''meta'''     )     )
   self.assertEqual(model.batchnorm.weight.device   ,torch.device('''meta'''     )     )
   self.assertEqual(model.lineara.weight.device   ,torch.device('''meta'''     )     )
   # Buffers are not included in the offload by default, so are on the execution device
   __lowercase				    =					torch.device(lowercase__     )
   self.assertEqual(model.batchnorm.running_mean.device   ,lowercase__     )

   __lowercase				    =					torch.randn(2   ,3     )
   __lowercase				    =					model(lowercase__     )
   self.assertEqual(output.device   ,lowercase__     )

   # Removing hooks loads back the weights in the model.
   remove_hook_from_submodules(lowercase__     )
   self.assertEqual(model.lineara.weight.device   ,torch.device('''cpu'''     )     )
   self.assertEqual(model.batchnorm.weight.device   ,torch.device('''cpu'''     )     )
   self.assertEqual(model.lineara.weight.device   ,torch.device('''cpu'''     )     )

   # Now test with buffers included in the offload
   attach_align_device_hook(lowercase__   ,execution_device=lowercase__   ,offload=lowercase__   ,offload_buffers=lowercase__     )

   # Parameters have been offloaded, so on the meta device, buffers included
   self.assertEqual(model.lineara.weight.device   ,torch.device('''meta'''     )     )
   self.assertEqual(model.batchnorm.weight.device   ,torch.device('''meta'''     )     )
   self.assertEqual(model.lineara.weight.device   ,torch.device('''meta'''     )     )
   self.assertEqual(model.batchnorm.running_mean.device   ,torch.device('''meta'''     )     )

   __lowercase				    =					torch.randn(2   ,3     )
   __lowercase				    =					model(lowercase__     )
   self.assertEqual(output.device   ,lowercase__     )

   # Removing hooks loads back the weights in the model.
   remove_hook_from_submodules(lowercase__     )
   self.assertEqual(model.lineara.weight.device   ,torch.device('''cpu'''     )     )
   self.assertEqual(model.batchnorm.weight.device   ,torch.device('''cpu'''     )     )
   self.assertEqual(model.lineara.weight.device   ,torch.device('''cpu'''     )     )






  def    SCREAMING_SNAKE_CASE ( self  :	List[Any]     ):
   __lowercase				    =					ModelForTest()

   # Everything is on CPU
   self.assertEqual(model.lineara.weight.device   ,torch.device('''cpu'''     )     )
   self.assertEqual(model.batchnorm.weight.device   ,torch.device('''cpu'''     )     )
   self.assertEqual(model.lineara.weight.device   ,torch.device('''cpu'''     )     )

   # This will move each submodule on different devices
   __lowercase				    =					0 if torch.cuda.is_available() else '''cpu'''
   attach_align_device_hook(
       lowercase__   ,execution_device=lowercase__   ,offload=lowercase__   ,weights_map=model.state_dict()     )

   # Parameters have been offloaded, so on the meta device
   self.assertEqual(model.lineara.weight.device   ,torch.device('''meta'''     )     )
   self.assertEqual(model.batchnorm.weight.device   ,torch.device('''meta'''     )     )
   self.assertEqual(model.lineara.weight.device   ,torch.device('''meta'''     )     )
   # Buffers are not included in the offload by default, so are on the execution device
   __lowercase				    =					torch.device(lowercase__     )
   self.assertEqual(model.batchnorm.running_mean.device   ,lowercase__     )

   __lowercase				    =					torch.randn(2   ,3     )
   __lowercase				    =					model(lowercase__     )
   self.assertEqual(output.device   ,lowercase__     )

   # Removing hooks loads back the weights in the model.
   remove_hook_from_submodules(lowercase__     )
   self.assertEqual(model.lineara.weight.device   ,torch.device('''cpu'''     )     )
   self.assertEqual(model.batchnorm.weight.device   ,torch.device('''cpu'''     )     )
   self.assertEqual(model.lineara.weight.device   ,torch.device('''cpu'''     )     )

   # Now test with buffers included in the offload
   attach_align_device_hook(
       lowercase__   ,execution_device=lowercase__   ,offload=lowercase__   ,weights_map=model.state_dict()   ,offload_buffers=lowercase__   ,)

   # Parameters have been offloaded, so on the meta device, buffers included
   self.assertEqual(model.lineara.weight.device   ,torch.device('''meta'''     )     )
   self.assertEqual(model.batchnorm.weight.device   ,torch.device('''meta'''     )     )
   self.assertEqual(model.lineara.weight.device   ,torch.device('''meta'''     )     )
   self.assertEqual(model.batchnorm.running_mean.device   ,torch.device('''meta'''     )     )

   __lowercase				    =					torch.randn(2   ,3     )
   __lowercase				    =					model(lowercase__     )
   self.assertEqual(output.device   ,lowercase__     )

   # Removing hooks loads back the weights in the model.
   remove_hook_from_submodules(lowercase__     )
   self.assertEqual(model.lineara.weight.device   ,torch.device('''cpu'''     )     )
   self.assertEqual(model.batchnorm.weight.device   ,torch.device('''cpu'''     )     )
   self.assertEqual(model.lineara.weight.device   ,torch.device('''cpu'''     )     )






'''simple docstring'''





from typing import Callable, List, Optional, Union

import PIL
import torch
from transformers import (
    CLIPImageProcessor,
    CLIPSegForImageSegmentation,
    CLIPSegProcessor,
    CLIPTextModel,
    CLIPTokenizer,
)

from diffusers import DiffusionPipeline
from diffusers.configuration_utils import FrozenDict
from diffusers.models import AutoencoderKL, UNetaDConditionModel
from diffusers.pipelines.stable_diffusion import StableDiffusionInpaintPipeline
from diffusers.pipelines.stable_diffusion.safety_checker import StableDiffusionSafetyChecker
from diffusers.schedulers import DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler
from diffusers.utils import deprecate, is_accelerate_available, logging


_UpperCamelCase											=		logging.get_logger(__name__)  # pylint: disable=invalid-name






class    lowerCamelCase_       (							SCREAMING_SNAKE_CASE_	):
  """simple docstring"""




  def __init__(					self :      Union[str, Any]     ,      _a :      CLIPSegForImageSegmentation     ,      _a :      CLIPSegProcessor     ,      _a :      AutoencoderKL     ,      _a :      CLIPTextModel     ,      _a :      CLIPTokenizer     ,      _a :      UNetaDConditionModel     ,      _a :      Union[DDIMScheduler, PNDMScheduler, LMSDiscreteScheduler]     ,      _a :      StableDiffusionSafetyChecker     ,      _a :      CLIPImageProcessor     ,      )   ->   int:
    super().__init__()

    if hasattr(scheduler.config     ,      'steps_offset'  ) and scheduler.config.steps_offset != 1:
      __lowerCamelCase			:			int       			=					(
          f'The configuration file of this scheduler: {scheduler} is outdated. `steps_offset`'
          f' should be set to 1 instead of {scheduler.config.steps_offset}. Please make sure '
          'to update the config accordingly as leaving `steps_offset` might led to incorrect results'
          ' in future versions. If you have downloaded this checkpoint from the Hugging Face Hub,'
          ' it would be very nice if you could open a Pull request for the `scheduler/scheduler_config.json`'
          ' file'
      )
      deprecate('steps_offset!=1'     ,      '1.0.0'     ,      _a     ,      standard_warn=_a  )
      __lowerCamelCase			:			int       			=					dict(scheduler.config  )
      __lowerCamelCase			:			Any       			=					1
      __lowerCamelCase			:			List[Any]       			=					FrozenDict(_a  )

    if hasattr(scheduler.config     ,      'skip_prk_steps'  ) and scheduler.config.skip_prk_steps is False:
      __lowerCamelCase			:			str       			=					(
          f'The configuration file of this scheduler: {scheduler} has not set the configuration'
          ' `skip_prk_steps`. `skip_prk_steps` should be set to True in the configuration file. Please make'
          ' sure to update the config accordingly as not setting `skip_prk_steps` in the config might lead to'
          ' incorrect results in future versions. If you have downloaded this checkpoint from the Hugging Face'
          ' Hub, it would be very nice if you could open a Pull request for the'
          ' `scheduler/scheduler_config.json` file'
      )
      deprecate('skip_prk_steps not set'     ,      '1.0.0'     ,      _a     ,      standard_warn=_a  )
      __lowerCamelCase			:			Dict       			=					dict(scheduler.config  )
      __lowerCamelCase			:			Tuple       			=					True
      __lowerCamelCase			:			Union[str, Any]       			=					FrozenDict(_a  )

    if safety_checker is None:
      logger.warning(
          f'You have disabled the safety checker for {self.__class__} by passing `safety_checker=None`. Ensure'
          ' that you abide to the conditions of the Stable Diffusion license and do not expose unfiltered'
          ' results in services or applications open to the public. Both the diffusers team and Hugging Face'
          ' strongly recommend to keep the safety filter enabled in all public facing circumstances, disabling'
          ' it only for use-cases that involve analyzing network behavior or auditing its results. For more'
          ' information, please have a look at https://github.com/huggingface/diffusers/pull/254 .'  )

    self.register_modules(
        segmentation_model=_a     ,      segmentation_processor=_a     ,      vae=_a     ,      text_encoder=_a     ,      tokenizer=_a     ,      unet=_a     ,      scheduler=_a     ,      safety_checker=_a     ,      feature_extractor=_a     ,      )




  def 		_lowercase	(					self :      Optional[int]     ,      _a :      Optional[Union[str, int]] = "auto"  )   ->   List[str]:
    if slice_size == "auto":
      # half the attention head size is usually a good trade-off between
      # speed and memory
      __lowerCamelCase			:			List[Any]       			=					self.unet.config.attention_head_dim // 2
    self.unet.set_attention_slice(_a  )




  def 		_lowercase	(					self :      Optional[Any]  )   ->   int:
    self.enable_attention_slicing(_a  )




  def 		_lowercase	(					self :      str  )   ->   Any:
    if is_accelerate_available():
      from accelerate import cpu_offload
    else:
      raise ImportError('Please install accelerate via `pip install accelerate`'  )

    __lowerCamelCase			:			Dict       			=					torch.device('cuda'  )

    for cpu_offloaded_model in [self.unet, self.text_encoder, self.vae, self.safety_checker]:
      if cpu_offloaded_model is not None:
        cpu_offload(_a     ,      _a  )




  @property
  # Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._execution_device
  def 		_lowercase	(					self :      Dict  )   ->   int:
    if self.device != torch.device('meta'  ) or not hasattr(self.unet     ,      '_hf_hook'  ):
      return self.device
    for module in self.unet.modules():
      if (
          hasattr(_a     ,      '_hf_hook'  )
          and hasattr(module._hf_hook     ,      'execution_device'  )
          and module._hf_hook.execution_device is not None
      ):
        return torch.device(module._hf_hook.execution_device  )
    return self.device




  @torch.no_grad()
  def __call__(					self :      List[str]     ,      _a :      Union[str, List[str]]     ,      _a :      Union[torch.FloatTensor, PIL.Image.Image]     ,      _a :      str     ,      _a :      int = 512     ,      _a :      int = 512     ,      _a :      int = 50     ,      _a :      float = 7.5     ,      _a :      Optional[Union[str, List[str]]] = None     ,      _a :      Optional[int] = 1     ,      _a :      float = 0.0     ,      _a :      Optional[torch.Generator] = None     ,      _a :      Optional[torch.FloatTensor] = None     ,      _a :      Optional[str] = "pil"     ,      _a :      bool = True     ,      _a :      Optional[Callable[[int, int, torch.FloatTensor], None]] = None     ,      _a :      int = 1     ,      **_a :      Optional[Any]     ,      )   ->   int:
    __lowerCamelCase			:			Union[str, Any]       			=					self.segmentation_processor(
        text=[text]     ,      images=[image]     ,      padding='max_length'     ,      return_tensors='pt'  ).to(self.device  )
    __lowerCamelCase			:			Union[str, Any]       			=					self.segmentation_model(**_a  )
    __lowerCamelCase			:			List[str]       			=					torch.sigmoid(outputs.logits  ).cpu().detach().unsqueeze(-1  ).numpy()
    __lowerCamelCase			:			Optional[Any]       			=					self.numpy_to_pil(_a  )[0].resize(image.size  )

    # Run inpainting pipeline with the generated mask
    __lowerCamelCase			:			Tuple       			=					StableDiffusionInpaintPipeline(
        vae=self.vae     ,      text_encoder=self.text_encoder     ,      tokenizer=self.tokenizer     ,      unet=self.unet     ,      scheduler=self.scheduler     ,      safety_checker=self.safety_checker     ,      feature_extractor=self.feature_extractor     ,      )
    return inpainting_pipeline(
        prompt=_a     ,      image=_a     ,      mask_image=_a     ,      height=_a     ,      width=_a     ,      num_inference_steps=_a     ,      guidance_scale=_a     ,      negative_prompt=_a     ,      num_images_per_prompt=_a     ,      eta=_a     ,      generator=_a     ,      latents=_a     ,      output_type=_a     ,      return_dict=_a     ,      callback=_a     ,      callback_steps=_a     ,      )






