




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__					(      snake_case__				,       snake_case__				,       unittest.TestCase   ):
						_a							:					List[str]      =					IFInpaintingSuperResolutionPipeline
						_a							:					Optional[int]      =					TEXT_GUIDED_IMAGE_INPAINTING_PARAMS - {"""width""", """height"""}
						_a							:					Tuple      =					TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS.union({"""original_image"""}   )
						_a							:					Any      =					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 List, Union

from ..utils import (
    add_end_docstrings,
    is_tf_available,
    is_torch_available,
    is_vision_available,
    logging,
    requires_backends,
)
from .base import PIPELINE_INIT_ARGS, Pipeline


if is_vision_available():
					from PIL import Image

					from ..image_utils import load_image

if is_tf_available():
					import tensorflow as tf

					from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING
					from ..tf_utils import stable_softmax

if is_torch_available():
					from ..models.auto.modeling_auto import MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING

UpperCamelCase__					    =    logging.get_logger(__name__)
@add_end_docstrings(snake_case__   )
class     a__					(      snake_case__   ):






						def __init__(     self	,    *_A	,    **_A    ):




											"""simple docstring"""



											super().__init__(*_A	,    **_A    )
											requires_backends(self	,    "vision"    )
											self.check_model_type(
											    TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING
											    if self.framework == "tf"
											    else MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING    )






						def        __SCREAMING_SNAKE_CASE(     self	,    _A=None    ):




											"""simple docstring"""



											__lowerCAmelCase            = {}
											if top_k is not None:
																__lowerCAmelCase            = top_k
											return {}, {}, postprocess_params






						def __call__(     self	,    _A	,    **_A    ):




											"""simple docstring"""



											return super().__call__(_A	,    **_A    )






						def        __SCREAMING_SNAKE_CASE(     self	,    _A    ):




											"""simple docstring"""



											__lowerCAmelCase            = load_image(_A    )
											__lowerCAmelCase            = self.image_processor(images=_A	,    return_tensors=self.framework    )
											return model_inputs






						def        __SCREAMING_SNAKE_CASE(     self	,    _A    ):




											"""simple docstring"""



											__lowerCAmelCase            = self.model(**_A    )
											return model_outputs






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




											"""simple docstring"""



											if top_k > self.model.config.num_labels:
																__lowerCAmelCase            = self.model.config.num_labels

											if self.framework == "pt":
																__lowerCAmelCase            = model_outputs.logits.softmax(-1    )[0]
																__lowerCAmelCase     ,							__lowerCAmelCase            = probs.topk(_A    )
											elif self.framework == "tf":
																__lowerCAmelCase            = stable_softmax(model_outputs.logits	,    axis=-1    )[0]
																__lowerCAmelCase            = tf.math.top_k(_A	,    k=_A    )
																__lowerCAmelCase     ,							__lowerCAmelCase            = topk.values.numpy(), topk.indices.numpy()
											else:
																raise ValueError(f"""Unsupported framework: {self.framework}"""    )

											__lowerCAmelCase            = scores.tolist()
											__lowerCAmelCase            = ids.tolist()
											return [{"score": score, "label": self.model.config.idalabel[_id]} for score, _id in zip(_A	,    _A    )]




