
'''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  UpperCamelCase__  (    SCREAMING_SNAKE_CASE      ,     SCREAMING_SNAKE_CASE      ,     unittest.TestCase):
	UpperCAmelCase__    :    Union[str, Any]										=					IFSuperResolutionPipeline
	UpperCAmelCase__    :    List[str]										=					TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'width', 'height'}
	UpperCAmelCase__    :    List[str]										=					TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
	UpperCAmelCase__    :    List[str]										=					PipelineTesterMixin.required_optional_params - {'latents'}






	def 	lowercase_						(			self  :Optional[Any]			)				->			Optional[Any]:







							'''simple docstring'''



							return self._get_superresolution_dummy_components()






	def 	lowercase_						(			self  :Optional[int]	,				_A  :List[str]	,				_A  :List[Any]=0			)				->			int:







							'''simple docstring'''



							if str(_A			).startswith('mps'			):
													__A       	=			torch.manual_seed(_A			)
							else:
													__A       	=			torch.Generator(device=_A			).manual_seed(_A			)

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

							__A       	=			{
							    '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[Any]			)				->			List[str]:







							'''simple docstring'''



							self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3			)






	def 	lowercase_						(			self  :Optional[Any]			)				->			List[Any]:







							'''simple docstring'''



							self._test_save_load_optional_components()






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







							'''simple docstring'''



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






	def 	lowercase_						(			self  :Tuple			)				->			Tuple:







							'''simple docstring'''



							self._test_attention_slicing_forward_pass(expected_max_diff=1E-2			)






	def 	lowercase_						(			self  :Optional[int]			)				->			Optional[int]:







							'''simple docstring'''



							self._test_save_load_local()






	def 	lowercase_						(			self  :Tuple			)				->			str:







							'''simple docstring'''



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








'''simple docstring'''





from .hash_table import HashTable
from .number_theory.prime_numbers import is_prime, next_prime


class  UpperCamelCase__  (    SCREAMING_SNAKE_CASE):






 def __init__(			self  :Union[str, Any]	,				*_A  :int	,				**_A  :Optional[Any]			)				->			Union[str, Any]:







       '''simple docstring'''



       super().__init__(*_A	,				**_A			)






 def 	lowercase_						(			self  :Dict	,				_A  :Union[str, Any]	,				_A  :Dict			)				->			Dict:







       '''simple docstring'''



       __A       	=			(
           next_prime(value % self.size_table			)
           if not is_prime(value % self.size_table			)
           else value % self.size_table
       )  # gt = bigger than
       return next_prime_gt - (data % next_prime_gt)






 def 	lowercase_						(			self  :List[Any]	,				_A  :int	,				_A  :Tuple	,				_A  :Union[str, Any]			)				->			List[Any]:







       '''simple docstring'''



       return (increment * self.__hash_function_a(_A	,				_A			)) % self.size_table






 def 	lowercase_						(			self  :List[Any]	,				_A  :List[str]	,				_A  :str=None			)				->			List[Any]:







       '''simple docstring'''



       __A       	=			1
       __A       	=			self.hash_function(_A			)

       while self.values[new_key] is not None and self.values[new_key] != key:
             __A       	=			(
                 self.__hash_double_function(_A	,				_A	,				_A			)
                 if self.balanced_factor() >= self.lim_charge
                 else None
             )
             if new_key is None:
                   break
             else:
                   i += 1

       return new_key






