


"""simple docstring"""
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 			_UpperCAmelCase (							__snake_case,				__snake_case,				unittest.TestCase				):






		'''simple docstring'''

		lowerCamelCase__				=IFInpaintingSuperResolutionPipeline
		lowerCamelCase__				=TEXT_GUIDED_IMAGE_INPAINTING_PARAMS - {'width', 'height'}
		lowerCamelCase__				=TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS.union({'original_image'}				)
		lowerCamelCase__				=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'''					):
				__snake_case	:						Tuple						=				torch.manual_seed(a_					)
			else:
				__snake_case	:						str						=				torch.Generator(device=a_					).manual_seed(a_					)

			__snake_case	:						Union[str, Any]						=				floats_tensor((1, 3, 16, 16)				,       rng=random.Random(a_					)					).to(a_					)
			__snake_case	:						str						=				floats_tensor((1, 3, 32, 32)				,       rng=random.Random(a_					)					).to(a_					)
			__snake_case	:						Union[str, Any]						=				floats_tensor((1, 3, 32, 32)				,       rng=random.Random(a_					)					).to(a_					)

			__snake_case	:						List[str]						=				{
			    '''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				,       )






'''simple docstring'''

from typing import TYPE_CHECKING

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


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

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

try:
  if not is_tf_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  __a: int          =   [
      """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

  __a: Dict          =   _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)

