




'''simple docstring'''







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 	_snake_case(			UpperCAmelCase       , UpperCAmelCase       , unittest.TestCase      ):
 __snake_case:							Tuple						=					IFInpaintingPipeline
 __snake_case:							List[Any]						=					TEXT_GUIDED_IMAGE_INPAINTING_PARAMS - {'''width''', '''height'''}
 __snake_case:							str						=					TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
 __snake_case:							Optional[int]						=					PipelineTesterMixin.required_optional_params - {'''latents'''}






 def 						_UpperCamelCase (self       :  Optional[int]    )       ->   Optional[int]:






    """simple docstring"""


    return self._get_dummy_components()






 def 						_UpperCamelCase (self       :  Optional[Any]    ,		a       :  Optional[Any]    ,		a       :  List[Any]=0    )       ->   Optional[Any]:






    """simple docstring"""


    if str(a    ).startswith('mps'    ):
       A__       =     torch.manual_seed(a    )
    else:
       A__       =     torch.Generator(device=a    ).manual_seed(a    )

    A__       =     floats_tensor((1, 3, 32, 32)    ,		rng=random.Random(a    )    ).to(a    )
    A__       =     floats_tensor((1, 3, 32, 32)    ,		rng=random.Random(a    )    ).to(a    )

    A__       =     {
        '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 						_UpperCamelCase (self       :  Union[str, Any]    )       ->   Union[str, Any]:






    """simple docstring"""


    self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3    )






 def 						_UpperCamelCase (self       :  Tuple    )       ->   Optional[Any]:






    """simple docstring"""


    self._test_save_load_optional_components()






 @unittest.skipIf(torch_device != 'cuda'    ,		reason='float16 requires CUDA'    )
 def 						_UpperCamelCase (self       :  str    )       ->   Union[str, Any]:






    """simple docstring"""


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






 def 						_UpperCamelCase (self       :  int    )       ->   int:






    """simple docstring"""


    self._test_attention_slicing_forward_pass(expected_max_diff=1e-2    )






 def 						_UpperCamelCase (self       :  Tuple    )       ->   Optional[Any]:






    """simple docstring"""


    self._test_save_load_local()






 def 						_UpperCamelCase (self       :  Optional[Any]    )       ->   Dict:






    """simple docstring"""


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








'''simple docstring'''







from dataclasses import dataclass
from typing import List, Optional, Union

import numpy as np
import PIL

from ...utils import BaseOutput, OptionalDependencyNotAvailable, is_torch_available, is_transformers_available
from .timesteps import (
    fastaa_timesteps,
    smartaa_timesteps,
    smartaa_timesteps,
    smartaaa_timesteps,
    smartaaa_timesteps,
    superaa_timesteps,
    superaa_timesteps,
    superaaa_timesteps,
)

@dataclass
class 	_snake_case(			UpperCAmelCase      ):
 __snake_case:							Union[List[PIL.Image.Image], np.ndarray]
 __snake_case:							Optional[List[bool]]
 __snake_case:							Optional[List[bool]]


try:
    if not (is_transformers_available() and is_torch_available()):
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    from ...utils.dummy_torch_and_transformers_objects import *  # noqa F403
else:
    from .pipeline_if import IFPipeline
    from .pipeline_if_imgaimg import IFImgaImgPipeline
    from .pipeline_if_imgaimg_superresolution import IFImgaImgSuperResolutionPipeline
    from .pipeline_if_inpainting import IFInpaintingPipeline
    from .pipeline_if_inpainting_superresolution import IFInpaintingSuperResolutionPipeline
    from .pipeline_if_superresolution import IFSuperResolutionPipeline
    from .safety_checker import IFSafetyChecker
    from .watermark import IFWatermarker


