
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 UpperCAmelCase   (						__UpperCamelCase							,							__UpperCamelCase							,							unittest.TestCase   ):





   '''simple docstring'''
   __UpperCamelCase		:    Dict 				=    IFImgaImgSuperResolutionPipeline
   __UpperCamelCase		:    List[Any] 				=    TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'''width''', '''height'''}
   __UpperCamelCase		:    Dict 				=    TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({'''original_image'''}   )
   __UpperCamelCase		:    Any 				=    PipelineTesterMixin.required_optional_params - {'''latents'''}


   def  __magic_name__				(					self     :							int     ):

      """simple docstring"""
      return self._get_superresolution_dummy_components()


   def  __magic_name__				(					self     :							List[Any]			,			lowerCAmelCase_     :							List[str]			,			lowerCAmelCase_     :							List[Any]=0     ):

      """simple docstring"""
      if str(lowerCAmelCase_     ).startswith('''mps'''     ):
         _A:  Tuple					=       torch.manual_seed(lowerCAmelCase_     )
      else:
         _A:  Tuple					=       torch.Generator(device=lowerCAmelCase_     ).manual_seed(lowerCAmelCase_     )

      _A:  Optional[int]					=       floats_tensor((1, 3, 3_2, 3_2)			,			rng=random.Random(lowerCAmelCase_     )     ).to(lowerCAmelCase_     )
      _A:  List[Any]					=       floats_tensor((1, 3, 1_6, 1_6)			,			rng=random.Random(lowerCAmelCase_     )     ).to(lowerCAmelCase_     )

      _A:  Optional[Any]					=       {
          '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  __magic_name__				(					self     :							int     ):

      """simple docstring"""
      self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3     )


   def  __magic_name__				(					self     :							Tuple     ):

      """simple docstring"""
      self._test_save_load_optional_components()


   @unittest.skipIf(torch_device != '''cuda'''			,			reason='''float16 requires CUDA'''     )
   def  __magic_name__				(					self     :							str     ):

      """simple docstring"""
      # 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  __magic_name__				(					self     :							List[Any]     ):

      """simple docstring"""
      self._test_attention_slicing_forward_pass(expected_max_diff=1e-2     )


   def  __magic_name__				(					self     :							int     ):

      """simple docstring"""
      self._test_save_load_local()


   def  __magic_name__				(					self     :							str     ):

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










from __future__ import annotations

from typing import Any


def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase )			->     None:
    create_state_space_tree(_UpperCAmelCase						,	[]						,	0 )


def        SCREAMING_SNAKE_CASE      (       _UpperCAmelCase						,	_UpperCAmelCase						,	_UpperCAmelCase )			->     None:

    if index == len(_UpperCAmelCase ):
        print(_UpperCAmelCase )
        return

    create_state_space_tree(_UpperCAmelCase						,	_UpperCAmelCase						,	index + 1 )
    current_subsequence.append(sequence[index] )
    create_state_space_tree(_UpperCAmelCase						,	_UpperCAmelCase						,	index + 1 )
    current_subsequence.pop()


if __name__ == "__main__":
    _UpperCAmelCase				:       list[Any]	   =				[3, 1, 2, 4]
    generate_all_subsequences(seq)

    seq.clear()
    seq.extend(["""A""", """B""", """C"""])
    generate_all_subsequences(seq)





