"""simple docstring"""




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 			__snake_case  (      lowerCAmelCase__   ,lowerCAmelCase__   ,unittest.TestCase     ):
					__lowerCamelCase	 =       IFSuperResolutionPipeline
					__lowerCamelCase	 =       TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"""width""", """height"""}
					__lowerCamelCase	 =       TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
					__lowerCamelCase	 =       PipelineTesterMixin.required_optional_params - {"""latents"""}




					def       __a      (       self		)					->  Dict:



									'''simple docstring'''







									return self._get_superresolution_dummy_components()




					def       __a      (       self   ,	__UpperCamelCase   ,	__UpperCamelCase=0		)					->  Union[str, Any]:



									'''simple docstring'''







									if str(UpperCamelCase__		).startswith('mps'		):
													snake_case__ :     List[str] 							=				torch.manual_seed(UpperCamelCase__		)
									else:
													snake_case__ :     Any 							=				torch.Generator(device=UpperCamelCase__		).manual_seed(UpperCamelCase__		)

									snake_case__ :     str 							=				floats_tensor((1, 3, 32, 32)   ,	rng=random.Random(UpperCamelCase__		)		).to(UpperCamelCase__		)

									snake_case__ :     Union[str, Any] 							=				{
									    "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       __a      (       self		)					->  int:



									'''simple docstring'''







									self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3		)




					def       __a      (       self		)					->  Dict:



									'''simple docstring'''







									self._test_save_load_optional_components()




					@unittest.skipIf(torch_device != 'cuda'   ,	reason='float16 requires CUDA'		)
					def       __a      (       self		)					->  List[Any]:



									'''simple docstring'''







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




					def       __a      (       self		)					->  List[str]:



									'''simple docstring'''







									self._test_attention_slicing_forward_pass(expected_max_diff=1E-2		)




					def       __a      (       self		)					->  int:



									'''simple docstring'''







									self._test_save_load_local()




					def       __a      (       self		)					->  Dict:



									'''simple docstring'''







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



def 			UpperCamelCase__						(    A__   )       -> int:
				if number != int(A__   ):
								raise ValueError('factorial() only accepts integral values'   )
				if number < 0:
								raise ValueError('factorial() not defined for negative values'   )
				snake_case__ :     Optional[Any] 							=				1
				for i in range(1      ,			number + 1   ):
								value *= i
				return value
def 			UpperCamelCase__						(    A__   )       -> int:
				if not isinstance(A__      ,			A__   ):
								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()

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


