






import random
import unittest

import torch

from diffusers import IFImgaImgPipeline
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(					snake_case__     ,       snake_case__     ,       unittest.TestCase      ):
 lowercase :       int		      =		IFImgaImgPipeline
 lowercase :       int		      =		TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'''width''', '''height'''}
 lowercase :       Optional[int]		      =		TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
 lowercase :       Optional[Any]		      =		PipelineTesterMixin.required_optional_params - {'''latents'''}



 def 						__UpperCAmelCase    (	self   :   Optional[Any]	):

    """simple docstring"""






    return self._get_dummy_components()



 def 						__UpperCAmelCase    (	self   :   Any ,		UpperCAmelCase__   :   Optional[Any] ,		UpperCAmelCase__   :   Optional[int]=0	):

    """simple docstring"""






    if str(__snake_case	).startswith("""mps"""	):
       lowercase__						:	Any         = torch.manual_seed(__snake_case	)
    else:
       lowercase__						:	str         = torch.Generator(device=__snake_case	).manual_seed(__snake_case	)

    lowercase__						:	int         = floats_tensor((1, 3, 32, 32) ,		rng=random.Random(__snake_case	)	).to(__snake_case	)

    lowercase__						:	Optional[Any]         = {
        """prompt""": """A painting of a squirrel eating a burger""",
        """image""": image,
        """generator""": generator,
        """num_inference_steps""": 2,
        """output_type""": """numpy""",
    }

    return inputs



 def 						__UpperCAmelCase    (	self   :   Optional[Any]	):

    """simple docstring"""






    self._test_save_load_optional_components()



 @unittest.skipIf(
     torch_device != """cuda""" or not is_xformers_available() ,		reason="""XFormers attention is only available with CUDA and `xformers` installed""" ,		)
 def 						__UpperCAmelCase    (	self   :   str	):

    """simple docstring"""






    self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3	)



 @unittest.skipIf(torch_device != """cuda""" ,		reason="""float16 requires CUDA"""	)
 def 						__UpperCAmelCase    (	self   :   Tuple	):

    """simple docstring"""






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



 @unittest.skipIf(torch_device != """cuda""" ,		reason="""float16 requires CUDA"""	)
 def 						__UpperCAmelCase    (	self   :   Any	):

    """simple docstring"""






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



 def 						__UpperCAmelCase    (	self   :   Optional[Any]	):

    """simple docstring"""






    self._test_attention_slicing_forward_pass(expected_max_diff=1e-2	)



 def 						__UpperCAmelCase    (	self   :   List[Any]	):

    """simple docstring"""






    self._test_save_load_local()







 def 						__UpperCAmelCase    (	self   :   Optional[Any]	):

    """simple docstring"""






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










def       a__						(  A					):

   if not isinstance(A		,				A					) or number < 0:
      raise ValueError("""Input must be a non-negative integer"""					)

   lowercase__						:	str         = number & ~(number - 1)
   lowercase__						:	Optional[int]         = 0
   while intermediate:
      intermediate >>= 1
      index += 1
   return index - 1


if __name__ == "__main__":
 import doctest

 doctest.testmod(verbose=True)


