





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_		(      _A    ,       _A    ,       unittest.TestCase):
		lowerCamelCase     :Tuple							=  IFSuperResolutionPipeline
		lowerCamelCase     :int							=  TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"width", "height"}
		lowerCamelCase     :Optional[int]							=  TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
		lowerCamelCase     :Any							=  PipelineTesterMixin.required_optional_params - {"latents"}







		def       __lowercase (		self )					-> Any:
				return self._get_superresolution_dummy_components()







		def       __lowercase (		self      ,  __lowercase      ,  __lowercase=0 )					-> Tuple:
				if str(__lowercase ).startswith('''mps''' ):
						lowerCamelCase :			Any    		=torch.manual_seed(__lowercase )
				else:
						lowerCamelCase :			int    		=torch.Generator(device=__lowercase ).manual_seed(__lowercase )

				lowerCamelCase :			int    		=floats_tensor((1, 3, 3_2, 3_2)      ,  rng=random.Random(__lowercase ) ).to(__lowercase )

				lowerCamelCase :			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       __lowercase (		self )					-> List[str]:
				self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3 )







		def       __lowercase (		self )					-> Tuple:
				self._test_save_load_optional_components()







		@unittest.skipIf(torch_device != '''cuda'''      ,  reason='''float16 requires CUDA''' )
		def       __lowercase (		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       __lowercase (		self )					-> int:
				self._test_attention_slicing_forward_pass(expected_max_diff=1e-2 )







		def       __lowercase (		self )					-> Optional[int]:
				self._test_save_load_local()







		def       __lowercase (		self )					-> Any:
				self._test_inference_batch_single_identical(
				    expected_max_diff=1e-2      ,  )








def        A__						(							SCREAMING_SNAKE_CASE_ = 1_0_0_0		) ->  int:
		lowerCamelCase :			Dict    		=[]
		lowerCamelCase :			Dict    		=[]
		lowerCamelCase :			Union[str, Any]    		=3
		lowerCamelCase :			List[str]    		=5
		lowerCamelCase :			Union[str, Any]    		=1
		while True:
				lowerCamelCase :			Dict    		=z * temp
				if result < n:
						zmulti.append(SCREAMING_SNAKE_CASE_		)
						temp += 1
				else:
						lowerCamelCase :			List[Any]    		=1
						break
		while True:
				lowerCamelCase :			Optional[Any]    		=x * temp
				if result < n:
						xmulti.append(SCREAMING_SNAKE_CASE_		)
						temp += 1
				else:
						break
		lowerCamelCase :			str    		=list(set(xmulti + zmulti		)		)
		return sum(SCREAMING_SNAKE_CASE_		)


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

