



'''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 							lowerCAmelCase_		(	a_  ,      a_  ,      unittest.TestCase						):
    __UpperCAmelCase							=	IFSuperResolutionPipeline
    __UpperCAmelCase							=	TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'width', 'height'}
    __UpperCAmelCase							=	TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
    __UpperCAmelCase							=	PipelineTesterMixin.required_optional_params - {'latents'}





    def 					__snake_case       (    self    :    int     ):



       '''simple docstring'''







       return self._get_superresolution_dummy_components()





    def 					__snake_case       (    self    :    Union[str, Any],    _snake_case    :    Tuple,    _snake_case    :    Optional[Any]=0     ):



       '''simple docstring'''







       if str(_snake_case     ).startswith('''mps'''     ):
          snake_case   :							int						  =torch.manual_seed(_snake_case     )
       else:
          snake_case   :							Optional[int]						  =torch.Generator(device=_snake_case     ).manual_seed(_snake_case     )

       snake_case   :							Dict						  =floats_tensor((1, 3, 32, 32),    rng=random.Random(_snake_case     )     ).to(_snake_case     )

       snake_case   :							Optional[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 					__snake_case       (    self    :    List[Any]     ):



       '''simple docstring'''







       self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3     )





    def 					__snake_case       (    self    :    List[Any]     ):



       '''simple docstring'''







       self._test_save_load_optional_components()





    @unittest.skipIf(torch_device != '''cuda''',    reason='''float16 requires CUDA'''     )
    def 					__snake_case       (    self    :    Optional[Any]     ):



       '''simple docstring'''







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





    def 					__snake_case       (    self    :    Union[str, Any]     ):



       '''simple docstring'''







       self._test_attention_slicing_forward_pass(expected_max_diff=1E-2     )





    def 					__snake_case       (    self    :    List[Any]     ):



       '''simple docstring'''







       self._test_save_load_local()






    def 					__snake_case       (    self    :    List[str]     ):



       '''simple docstring'''







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










'''simple docstring'''





import doctest

import projectq
from projectq.ops import H, Measure
def 		_a   (  lowerCamelCase_							):
   snake_case   :							str						  =quantum_engine.allocate_qubit()
   H | qubit
   Measure | qubit
   return int(lowerCamelCase_							)


if __name__ == "__main__":
      doctest.testmod()

      # initialises a new quantum backend
      A			:   Dict			=      projectq.MainEngine()

      # Generate a list of 10 random numbers
      A			:   Dict			=      [get_random_number(quantum_engine) for _ in range(10)]

      # Flushes the quantum engine from memory
      quantum_engine.flush()

      print("""Random numbers""", random_numbers_list)





