




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






 def 	_UpperCamelCase   (self					:     int						)					->      Any:






    """simple docstring"""


    return self._get_superresolution_dummy_components()






 def 	_UpperCamelCase   (self					:     str						,		a					:     Tuple						,		a					:     List[str]=0						)					->      Optional[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 	_UpperCamelCase   (self					:     Any						)					->      Union[str, Any]:






    """simple docstring"""


    self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3						)






 def 	_UpperCamelCase   (self					:     List[str]						)					->      List[Any]:






    """simple docstring"""


    self._test_save_load_optional_components()






 @unittest.skipIf(torch_device != 'cuda'						,		reason='float16 requires CUDA'						)
 def 	_UpperCamelCase   (self					:     Union[str, Any]						)					->      Union[str, Any]:






    """simple docstring"""


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






 def 	_UpperCamelCase   (self					:     str						)					->      Dict:






    """simple docstring"""


    self._test_attention_slicing_forward_pass(expected_max_diff=1e-2						)






 def 	_UpperCamelCase   (self					:     List[str]						)					->      str:






    """simple docstring"""


    self._test_save_load_local()






 def 	_UpperCamelCase   (self					:     List[Any]						)					->      List[str]:






    """simple docstring"""


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








'''simple docstring'''







def 	_A			(   UpperCAmelCase	):






   '''simple docstring'''







   if not isinstance(UpperCAmelCase			,UpperCAmelCase	) or not all(
       isinstance(UpperCAmelCase			,UpperCAmelCase	) and item >= 0 for item in citations	):
      raise ValueError('The citations should be a list of non negative integers.'	)

   citations.sort()
   A__         =    len(UpperCAmelCase	)

   for i in range(UpperCAmelCase	):
      if citations[len_citations - 1 - i] <= i:
         return i

   return len_citations


if __name__ == "__main__":
    import doctest

    doctest.testmod()


