




"""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  SCREAMING_SNAKE_CASE__   (   _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 					__lowercase	(							self			:     Any   ):
										return self._get_superresolution_dummy_components()


						def 					__lowercase	(							self			:     Optional[int]  ,  lowerCAmelCase			:     Tuple  ,  lowerCAmelCase			:     Dict=0   ):
										if str(lowerCAmelCase   ).startswith("""mps"""   ):
														lowerCAmelCase		=			torch.manual_seed(lowerCAmelCase   )
										else:
														lowerCAmelCase		=			torch.Generator(device=lowerCAmelCase   ).manual_seed(lowerCAmelCase   )

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

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


						def 					__lowercase	(							self			:     int   ):
										self._test_save_load_optional_components()


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


						def 					__lowercase	(							self			:     str   ):
										self._test_save_load_local()




						def 					__lowercase	(							self			:     Optional[int]   ):
										self._test_inference_batch_single_identical(
										    expected_max_diff=1e-2  ,  )











"""simple docstring"""







def 							lowercase   (snake_case__				:	list	)       ->					bool:


				'''simple docstring'''






				if not isinstance(snake_case__ ,    snake_case__	):
								raise ValueError("""Input series is not valid, valid series - [2, 4, 8]"""	)
				if len(snake_case__	) == 0:
								raise ValueError("""Input list must be a non empty list"""	)
				if len(snake_case__	) == 1:
								return True
				try:
								lowerCAmelCase		=			series[1] / series[0]
								for index in range(len(snake_case__	) - 1	):
												if series[index + 1] / series[index] != common_ratio:
																return False
				except ZeroDivisionError:
								return False
				return True





def 							lowercase   (snake_case__				:	list	)       ->					float:


				'''simple docstring'''






				if not isinstance(snake_case__ ,    snake_case__	):
								raise ValueError("""Input series is not valid, valid series - [2, 4, 8]"""	)
				if len(snake_case__	) == 0:
								raise ValueError("""Input list must be a non empty list"""	)
				lowerCAmelCase		=			1
				for value in series:
								answer *= value
				return pow(snake_case__ ,    1 / len(snake_case__	)	)


if __name__ == "__main__":
		import doctest

		doctest.testmod()





