


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      UpperCAmelCase_ ( UpperCamelCase		,			UpperCamelCase		,			unittest.TestCase   ):

   '''simple docstring'''




   __A			:				Union[str, Any]							=		IFSuperResolutionPipeline
   __A			:				List[Any]							=		TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"width", "height"}
   __A			:				Optional[int]							=		TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
   __A			:				Dict							=		PipelineTesterMixin.required_optional_params - {"latents"}






   def _snake_case   (		self			):






     """simple docstring"""





     return self._get_superresolution_dummy_components()






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






     """simple docstring"""





     if str(__A			).startswith("mps"			):
       lowerCamelCase			: List[Any]   =    torch.manual_seed(__A			)
     else:
       lowerCamelCase			: str   =    torch.Generator(device=__A			).manual_seed(__A			)

     lowerCamelCase			: Optional[int]   =    floats_tensor((1, 3, 32, 32)						,    rng=random.Random(__A			)			).to(__A			)

     lowerCamelCase			: int   =    {
         "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			):






     """simple docstring"""





     self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3			)






   def _snake_case   (		self			):






     """simple docstring"""





     self._test_save_load_optional_components()






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






     """simple docstring"""





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






   def _snake_case   (		self			):






     """simple docstring"""





     self._test_attention_slicing_forward_pass(expected_max_diff=1e-2			)






   def _snake_case   (		self			):






     """simple docstring"""





     self._test_save_load_local()






   def _snake_case   (		self			):






     """simple docstring"""





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







def 		lowercase_(  SCREAMING_SNAKE_CASE_     ):


  '''simple docstring'''

  if number != int(SCREAMING_SNAKE_CASE_     ):
    raise ValueError("factorial() only accepts integral values"     )
  if number < 0:
    raise ValueError("factorial() not defined for negative values"     )
  lowerCamelCase			: Optional[Any]   =    1
  for i in range(1				,						number + 1     ):
    value *= i
  return value






def 		lowercase_(  SCREAMING_SNAKE_CASE_     ):


  '''simple docstring'''

  if not isinstance(SCREAMING_SNAKE_CASE_				,						SCREAMING_SNAKE_CASE_     ):
    raise ValueError("factorial() only accepts integral values"     )
  if n < 0:
    raise ValueError("factorial() not defined for negative values"     )
  return 1 if n == 0 or n == 1 else n * factorial(n - 1     )


if __name__ == "__main__":
   import doctest

   doctest.testmod()

   _snake_case					=					int(input('''Enter a positive integer: ''').strip() or 0)
   print(f'''factorial{n} is {factorial(n)}''')



