



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 					snake_case__						(       UpperCamelCase__				,     UpperCamelCase__				,     unittest.TestCase     ):






     """simple docstring"""


     _SCREAMING_SNAKE_CASE						=	IFImgaImgSuperResolutionPipeline
     _SCREAMING_SNAKE_CASE						=	TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"""width""", """height"""}
     _SCREAMING_SNAKE_CASE						=	TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({"""original_image"""}     )
     _SCREAMING_SNAKE_CASE						=	PipelineTesterMixin.required_optional_params - {"""latents"""}






     def    lowercase_   (       self  :  Tuple					)   ->List[Any]:
            return self._get_superresolution_dummy_components()






     def    lowercase_   (       self  :  List[Any], _snake_case  :  List[Any], _snake_case  :  Any=0					)   ->Any:
            if str(_a					).startswith('mps'					):
                   snake_case__							:	Tuple   	=	torch.manual_seed(_a					)
            else:
                   snake_case__							:	Tuple   	=	torch.Generator(device=_a					).manual_seed(_a					)

            snake_case__							:	List[Any]   	=	floats_tensor((1, 3, 3_2, 3_2), rng=random.Random(_a					)					).to(_a					)
            snake_case__							:	Dict   	=	floats_tensor((1, 3, 1_6, 1_6), rng=random.Random(_a					)					).to(_a					)

            snake_case__							:	Optional[int]   	=	{
                """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    lowercase_   (       self  :  Any					)   ->Optional[int]:
            self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3					)






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






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






     def    lowercase_   (       self  :  Dict					)   ->List[Any]:
            self._test_save_load_local()






     def    lowercase_   (       self  :  List[str]					)   ->str:
            self._test_inference_batch_single_identical(
                expected_max_diff=1e-2, )












def 				lowerCAmelCase_	(     snake_case_     ):
      if n_term == "":
            return []
      _A							:     list			=						[]
      for temp in range(int(snake_case_     )     ):
            series.append(f'''1/{temp + 1}''' if series else """1"""     )
      return series


if __name__ == "__main__":
  _snake_case										=       input("Enter the last number (nth term) of the Harmonic Series")
  print("Formula of Harmonic Series => 1+1/2+1/3 ..... 1/n")
  print(harmonic_series(nth_term))

