




import random
import unittest

import torch

from diffusers import IFInpaintingSuperResolutionPipeline
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     a__					(      __a				,       __a				,       unittest.TestCase   ):
						_a							:					str      =					IFInpaintingSuperResolutionPipeline
						_a							:					Union[str, Any]      =					TEXT_GUIDED_IMAGE_INPAINTING_PARAMS - {"""width""", """height"""}
						_a							:					int      =					TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS.union({"""original_image"""}   )
						_a							:					Dict      =					PipelineTesterMixin.required_optional_params - {"""latents"""}






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											return self._get_superresolution_dummy_components()






						def        __SCREAMING_SNAKE_CASE(     self	,    _A	,    _A=0    ):




											"""simple docstring"""



											if str(A__    ).startswith("mps"    ):
																__lowerCAmelCase            = torch.manual_seed(A__    )
											else:
																__lowerCAmelCase            = torch.Generator(device=A__    ).manual_seed(A__    )

											__lowerCAmelCase            = floats_tensor((1, 3, 1_6, 1_6)	,    rng=random.Random(A__    )    ).to(A__    )
											__lowerCAmelCase            = floats_tensor((1, 3, 3_2, 3_2)	,    rng=random.Random(A__    )    ).to(A__    )
											__lowerCAmelCase            = floats_tensor((1, 3, 3_2, 3_2)	,    rng=random.Random(A__    )    ).to(A__    )

											__lowerCAmelCase            = {
											    "prompt": "A painting of a squirrel eating a burger",
											    "image": image,
											    "original_image": original_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    ):




											"""simple docstring"""



											self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3    )






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											self._test_save_load_optional_components()






						@unittest.skipIf(torch_device != "cuda"	,    reason="float16 requires CUDA"    )
						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



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






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											self._test_attention_slicing_forward_pass(expected_max_diff=1E-2    )






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											self._test_save_load_local()






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



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










from typing import TYPE_CHECKING

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


UpperCamelCase__					    =    {
    """configuration_ctrl""": ["""CTRL_PRETRAINED_CONFIG_ARCHIVE_MAP""", """CTRLConfig"""],
    """tokenization_ctrl""": ["""CTRLTokenizer"""],
}

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					UpperCamelCase__					    =    [
					    """CTRL_PRETRAINED_MODEL_ARCHIVE_LIST""",
					    """CTRLForSequenceClassification""",
					    """CTRLLMHeadModel""",
					    """CTRLModel""",
					    """CTRLPreTrainedModel""",
					]

try:
					if not is_tf_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					UpperCamelCase__					    =    [
					    """TF_CTRL_PRETRAINED_MODEL_ARCHIVE_LIST""",
					    """TFCTRLForSequenceClassification""",
					    """TFCTRLLMHeadModel""",
					    """TFCTRLModel""",
					    """TFCTRLPreTrainedModel""",
					]


if TYPE_CHECKING:
					from .configuration_ctrl import CTRL_PRETRAINED_CONFIG_ARCHIVE_MAP, CTRLConfig
					from .tokenization_ctrl import CTRLTokenizer

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_ctrl import (
										    CTRL_PRETRAINED_MODEL_ARCHIVE_LIST,
										    CTRLForSequenceClassification,
										    CTRLLMHeadModel,
										    CTRLModel,
										    CTRLPreTrainedModel,
										)

					try:
										if not is_tf_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_tf_ctrl import (
										    TF_CTRL_PRETRAINED_MODEL_ARCHIVE_LIST,
										    TFCTRLForSequenceClassification,
										    TFCTRLLMHeadModel,
										    TFCTRLModel,
										    TFCTRLPreTrainedModel,
										)

else:
					import sys

					UpperCamelCase__					    =    _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)




