




import random
import unittest

import torch

from diffusers import IFImgaImgSuperResolutionPipeline
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 						lowercase							(   UpperCamelCase__,UpperCamelCase__,unittest.TestCase		):
     _a							 =						IFImgaImgSuperResolutionPipeline
     _a							 =						TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"width", "height"}
     _a							 =						TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({"original_image"}		)
     _a							 =						PipelineTesterMixin.required_optional_params - {"latents"}

     def 					a__	(  self				)						->							List[Any]:
           return self._get_superresolution_dummy_components()

     def 					a__	(  self		,     _a		,     _a=0				)						->							Any:
           if str(_a				).startswith("""mps"""				):
                 _A							:     Tuple			=						torch.manual_seed(_a				)
           else:
                 _A							:     Tuple			=						torch.Generator(device=_a				).manual_seed(_a				)

           _A							:     List[Any]			=						floats_tensor((1, 3, 32, 32)		,     rng=random.Random(_a				)				).to(_a				)
           _A							:     Dict			=						floats_tensor((1, 3, 16, 16)		,     rng=random.Random(_a				)				).to(_a				)

           _A							:     Optional[int]			=						{
               """prompt""": """A painting of a squirrel eating a burger""",
               """image""": image,
               """original_image""": original_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				)						->							Optional[int]:
           self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3				)

     def 					a__	(  self				)						->							List[Any]:
           self._test_save_load_optional_components()

     @unittest.skipIf(torch_device != """cuda"""		,     reason="""float16 requires CUDA"""				)
     def 					a__	(  self				)						->							Any:
           # Due to non-determinism in save load of the hf-internal-testing/tiny-random-t5 text encoder
           super().test_save_load_floataa(expected_max_diff=1e-1				)

     def 					a__	(  self				)						->							Union[str, Any]:
           self._test_attention_slicing_forward_pass(expected_max_diff=1e-2				)

     def 					a__	(  self				)						->							List[Any]:
           self._test_save_load_local()



     def 					a__	(  self				)						->							str:
           self._test_inference_batch_single_identical(
               expected_max_diff=1e-2		,     )









import math
def 					snake_case_						(   lowerCAmelCase_				:  int					):

							if 1 < number < 4:
														# 2 and 3 are primes
														return True
							elif number < 2 or number % 2 == 0 or number % 3 == 0:
														# Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
														return False

							# All primes number are in format of 6k +/- 1
							for i in range(5				,				int(math.sqrt(lowerCAmelCase_					) + 1					)				,				6					):
														if number % i == 0 or number % (i + 2) == 0:
																					return False
							return True
def 					snake_case_						(   lowerCAmelCase_				:  int = 10001					):

							try:
														__lowercase					:							Optional[int]			=   int(lowerCAmelCase_					)
							except (TypeError, ValueError):
														raise TypeError("""Parameter nth must be int or castable to int."""					) from None
							if nth <= 0:
														raise ValueError("""Parameter nth must be greater than or equal to one."""					)
							__lowercase					:							list[int]			=   []
							__lowercase					:							str			=   2
							while len(lowerCAmelCase_					) < nth:
														if is_prime(lowerCAmelCase_					):
																					primes.append(lowerCAmelCase_					)
																					num += 1
														else:
																					num += 1
							return primes[len(lowerCAmelCase_					) - 1]


if __name__ == "__main__":
	print(f'''{solution() = }''')