

"""simple docstring"""



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        a    (							_lowercase,						_lowercase,						unittest.TestCase					):



    """simple docstring"""



    UpperCAmelCase    			=       IFSuperResolutionPipeline
    UpperCAmelCase    			=       TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"width", "height"}
    UpperCAmelCase    			=       TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
    UpperCAmelCase    			=       PipelineTesterMixin.required_optional_params - {"latents"}

    def 					UpperCamelCase						(  self:			Optional[Any]							):






         """simple docstring"""


         return self._get_superresolution_dummy_components()

    def 					UpperCamelCase						(  self:			Optional[int]     ,    UpperCamelCase:			int     ,    UpperCamelCase:			Union[str, Any]=0							):






         """simple docstring"""


         if str(__SCREAMING_SNAKE_CASE							).startswith("""mps"""							):
              A__				      =	torch.manual_seed(__SCREAMING_SNAKE_CASE							)
         else:
              A__				      =	torch.Generator(device=__SCREAMING_SNAKE_CASE							).manual_seed(__SCREAMING_SNAKE_CASE							)

         A__				      =	floats_tensor((1, 3, 32, 32)     ,    rng=random.Random(__SCREAMING_SNAKE_CASE							)							).to(__SCREAMING_SNAKE_CASE							)

         A__				      =	{
             """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 					UpperCamelCase						(  self:			Dict							):






         """simple docstring"""


         self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3							)

    def 					UpperCamelCase						(  self:			Union[str, Any]							):






         """simple docstring"""


         self._test_save_load_optional_components()

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






         """simple docstring"""


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

    def 					UpperCamelCase						(  self:			List[str]							):






         """simple docstring"""


         self._test_attention_slicing_forward_pass(expected_max_diff=1e-2							)

    def 					UpperCamelCase						(  self:			Union[str, Any]							):






         """simple docstring"""


         self._test_save_load_local()





    def 					UpperCamelCase						(  self:			Tuple							):






         """simple docstring"""


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







from typing import TYPE_CHECKING

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


_SCREAMING_SNAKE_CASE:    Optional[Any]     						=							{
    '''configuration_sam''': [
        '''SAM_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''SamConfig''',
        '''SamMaskDecoderConfig''',
        '''SamPromptEncoderConfig''',
        '''SamVisionConfig''',
    ],
    '''processing_sam''': ['''SamProcessor'''],
}


try:
			if not is_torch_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			_SCREAMING_SNAKE_CASE:    Dict     						=							[
			    '''SAM_PRETRAINED_MODEL_ARCHIVE_LIST''',
			    '''SamModel''',
			    '''SamPreTrainedModel''',
			]
try:
			if not is_tf_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			_SCREAMING_SNAKE_CASE:    Optional[Any]     						=							[
			    '''TF_SAM_PRETRAINED_MODEL_ARCHIVE_LIST''',
			    '''TFSamModel''',
			    '''TFSamPreTrainedModel''',
			]
try:
			if not is_vision_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			_SCREAMING_SNAKE_CASE:    List[Any]     						=							['''SamImageProcessor''']


if TYPE_CHECKING:
			from .configuration_sam import (
			    SAM_PRETRAINED_CONFIG_ARCHIVE_MAP,
			    SamConfig,
			    SamMaskDecoderConfig,
			    SamPromptEncoderConfig,
			    SamVisionConfig,
			)
			from .processing_sam import SamProcessor

			try:
						if not is_torch_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_sam import SAM_PRETRAINED_MODEL_ARCHIVE_LIST, SamModel, SamPreTrainedModel

			try:
						if not is_tf_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_tf_sam import TF_SAM_PRETRAINED_MODEL_ARCHIVE_LIST, TFSamModel, TFSamPreTrainedModel

			try:
						if not is_vision_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .image_processing_sam import SamImageProcessor

else:
			import sys

			_SCREAMING_SNAKE_CASE:    Union[str, Any]     						=							_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)

