





import random
import unittest

import torch

from diffusers import IFSuperResolutionPipeline
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_VARIATION_BATCH_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineTesterMixin
from . import IFPipelineTesterMixin

@skip_mps
class    __A  (    a     ,       a     ,       unittest.TestCase     ):
				__A  =					IFSuperResolutionPipeline
				__A  =					TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'width', 'height'}
				__A  =					TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
				__A  =					PipelineTesterMixin.required_optional_params - {'latents'}


				def _snake_case							(		self				):
								return self._get_superresolution_dummy_components()


				def _snake_case							(		self ,			UpperCAmelCase_ ,			UpperCAmelCase_=0				):



								if str(_A				).startswith("""mps"""				):
												lowerCamelCase									=torch.manual_seed(_A				)
								else:
												lowerCamelCase									=torch.Generator(device=_A				).manual_seed(_A				)

								lowerCamelCase									=floats_tensor((1, 3, 32, 32) ,			rng=random.Random(_A				)				).to(_A				)

								lowerCamelCase									={
								    """prompt""": """A painting of a squirrel eating a burger""",
								    """image""": 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 _snake_case							(		self				):
								self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3				)


				def _snake_case							(		self				):
								self._test_save_load_optional_components()


				@unittest.skipIf(torch_device != """cuda""" ,			reason="""float16 requires CUDA"""				)
				def _snake_case							(		self				):
								super().test_save_load_floataa(expected_max_diff=1E-1				)


				def _snake_case							(		self				):
								self._test_attention_slicing_forward_pass(expected_max_diff=1E-2				)


				def _snake_case							(		self				):
								self._test_save_load_local()


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







'''simple docstring'''





def 							snake_case				(		UpperCAmelCase						)->      int:







      """simple docstring"""
      if not isinstance(UpperCAmelCase   ,	UpperCAmelCase						):
            raise ValueError('double_factorial() only accepts integral values'						)
      if num < 0:
            raise ValueError('double_factorial() not defined for negative values'						)
      __A													=      1
      for i in range(UpperCAmelCase   ,	0   ,	-2						):
            value *= i
      return value


if __name__ == "__main__":
 import doctest

 doctest.testmod()






