





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 						_A( snake_case__    ,			snake_case__    ,			unittest.TestCase       ):


				"""simple docstring"""


				UpperCamelCase   :  List[Any]    =     IFSuperResolutionPipeline
				UpperCamelCase   :  str    =     TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'''width''', '''height'''}
				UpperCamelCase   :  Optional[int]    =     TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
				UpperCamelCase   :  Optional[int]    =     PipelineTesterMixin.required_optional_params - {'''latents'''}



				def  UpperCAmelCase_		(      self					):
									return self._get_superresolution_dummy_components()



				def  UpperCAmelCase_		(      self					, _A					, _A=0					):
									if str(_A					).startswith('mps'					):
														__A     :						Dict          =    torch.manual_seed(_A					)
									else:
														__A     :						List[Any]          =    torch.Generator(device=_A					).manual_seed(_A					)

									__A     :						Any          =    floats_tensor((1, 3, 32, 32)					, rng=random.Random(_A					)					).to(_A					)

									__A     :						List[str]          =    {
									    '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  UpperCAmelCase_		(      self					):
									self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3					)



				def  UpperCAmelCase_		(      self					):
									self._test_save_load_optional_components()



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



				def  UpperCAmelCase_		(      self					):
									self._test_save_load_local()





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











from .hash_table import HashTable





class 						_A( snake_case__       ):


				"""simple docstring"""


				def __init__(      self					, *_A					, **_A					):
									super().__init__(*_A					, **_A					)





				def  UpperCAmelCase_		(      self					, _A					, _A=None					):
									__A     :						Optional[int]          =    1
									__A     :						Union[str, Any]          =    self.hash_function(key + i * i					)

									while self.values[new_key] is not None and self.values[new_key] != key:
														i += 1
														__A     :						Tuple          =    (
														    self.hash_function(key + i * i					)
														    if not self.balanced_factor() >= self.lim_charge
														    else None
														)

														if new_key is None:
																			break

									return new_key




