


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      UpperCAmelCase_ ( UpperCamelCase		,			UpperCamelCase		,			unittest.TestCase   ):

			'''simple docstring'''




			__A			:				Union[str, Any]							=		IFSuperResolutionPipeline
			__A			:				List[Any]							=		TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"width", "height"}
			__A			:				Optional[int]							=		TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
			__A			:				Dict							=		PipelineTesterMixin.required_optional_params - {"latents"}






			def _snake_case   (		self			):






					"""simple docstring"""





					return self._get_superresolution_dummy_components()






			def _snake_case   (		self						,    __A						,    __A=0			):






					"""simple docstring"""





					if str(__A			).startswith("mps"			):
							lowerCamelCase			: List[Any]   =    torch.manual_seed(__A			)
					else:
							lowerCamelCase			: str   =    torch.Generator(device=__A			).manual_seed(__A			)

					lowerCamelCase			: Optional[int]   =    floats_tensor((1, 3, 32, 32)						,    rng=random.Random(__A			)			).to(__A			)

					lowerCamelCase			: int   =    {
					    "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			):






					"""simple docstring"""





					self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3			)






			def _snake_case   (		self			):






					"""simple docstring"""





					self._test_save_load_optional_components()






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






					"""simple docstring"""





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






			def _snake_case   (		self			):






					"""simple docstring"""





					self._test_attention_slicing_forward_pass(expected_max_diff=1e-2			)






			def _snake_case   (		self			):






					"""simple docstring"""





					self._test_save_load_local()






			def _snake_case   (		self			):






					"""simple docstring"""





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







from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_torch_available,
)


_snake_case					=					{
    '''configuration_rwkv''': ['''RWKV_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''RwkvConfig''', '''RwkvOnnxConfig'''],
}

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   _snake_case					=					[
       '''RWKV_PRETRAINED_MODEL_ARCHIVE_LIST''',
       '''RwkvForCausalLM''',
       '''RwkvModel''',
       '''RwkvPreTrainedModel''',
   ]


if TYPE_CHECKING:
   from .configuration_rwkv import RWKV_PRETRAINED_CONFIG_ARCHIVE_MAP, RwkvConfig, RwkvOnnxConfig

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_rwkv import (
          RWKV_PRETRAINED_MODEL_ARCHIVE_LIST,
          RwkvForCausalLM,
          RwkvModel,
          RwkvPreTrainedModel,
      )
else:
   import sys

   _snake_case					=					_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)



