

import random
import unittest

import torch

from diffusers import IFImgaImgSuperResolutionPipeline
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 						__magic_name__    (       _snake_case	,						_snake_case	,						unittest.TestCase    ):
 UpperCAmelCase							    =						IFImgaImgSuperResolutionPipeline
 UpperCAmelCase							    =						TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"""width""", """height"""}
 UpperCAmelCase							    =						TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({"""original_image"""}    )
 UpperCAmelCase							    =						PipelineTesterMixin.required_optional_params - {"""latents"""}


 def _UpperCamelCase	(						self		: Tuple    )    ->      Optional[Any]:
   return self._get_superresolution_dummy_components()


 def _UpperCamelCase	(						self		: Optional[int]			,						lowerCAmelCase__		: Any			,						lowerCAmelCase__		: Union[str, Any]=0    )    ->      List[str]:
   if str(lowerCAmelCase__    ).startswith("mps"    ):
     UpperCAmelCase					      =  torch.manual_seed(lowerCAmelCase__    )
   else:
     UpperCAmelCase					      =  torch.Generator(device=lowerCAmelCase__    ).manual_seed(lowerCAmelCase__    )

   UpperCAmelCase					      =  floats_tensor((1, 3, 3_2, 3_2)			,						rng=random.Random(lowerCAmelCase__    )    ).to(lowerCAmelCase__    )
   UpperCAmelCase					      =  floats_tensor((1, 3, 1_6, 1_6)			,						rng=random.Random(lowerCAmelCase__    )    ).to(lowerCAmelCase__    )

   UpperCAmelCase					      =  {
       "prompt": "A painting of a squirrel eating a burger",
       "image": image,
       "original_image": original_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		: Optional[Any]    )    ->      Union[str, Any]:
   self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3    )


 def _UpperCamelCase	(						self		: str    )    ->      Optional[int]:
   self._test_save_load_optional_components()


 @unittest.skipIf(torch_device != "cuda"			,						reason="float16 requires CUDA"    )
 def _UpperCamelCase	(						self		: str    )    ->      Dict:
   # 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		: Any    )    ->      Union[str, Any]:
   self._test_attention_slicing_forward_pass(expected_max_diff=1e-2    )


 def _UpperCamelCase	(						self		: Any    )    ->      Tuple:
   self._test_save_load_local()


 def _UpperCamelCase	(						self		: Any    )    ->      Union[str, Any]:
   self._test_inference_batch_single_identical(
       expected_max_diff=1e-2			,						)






def      _lowerCAmelCase(	__A			):
  UpperCAmelCase					      =  0
  while num > 0:
    digit_sum += num % 10
    num //= 10
  return digit_sum
def      _lowerCAmelCase(	__A = 100			):
  UpperCAmelCase					      =  1
  UpperCAmelCase					      =  2

  for i in range(2   ,       max_n + 1			):
    UpperCAmelCase					      =  pre_numerator
    UpperCAmelCase					      =  2 * i // 3 if i % 3 == 0 else 1
    UpperCAmelCase					      =  cur_numerator
    UpperCAmelCase					      =  e_cont * pre_numerator + temp

  return sum_digits(__A			)


if __name__ == "__main__":
      print(f"{solution() = }")



