
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        lowercase      (	_SCREAMING_SNAKE_CASE						,     _SCREAMING_SNAKE_CASE						,     unittest.TestCase     ):
		__lowercase : Optional[int]			  =       IFImgaImgSuperResolutionPipeline
		__lowercase : Union[str, Any]			  =       TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"width", "height"}
		__lowercase : List[str]			  =       TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({"original_image"}     )
		__lowercase : Any			  =       PipelineTesterMixin.required_optional_params - {"latents"}



		def __UpperCamelCase				(				self )						->      List[str]:
				"""simple docstring"""
				return self._get_superresolution_dummy_components()



		def __UpperCamelCase				(				self       ,   A_       ,   A_=0 )						->      Dict:
				"""simple docstring"""
				if str(A_ ).startswith('mps' ):
						UpperCamelCase						=  torch.manual_seed(A_ )
				else:
						UpperCamelCase						=  torch.Generator(device=A_ ).manual_seed(A_ )

				UpperCamelCase						=  floats_tensor((1, 3, 32, 32)       ,   rng=random.Random(A_ ) ).to(A_ )
				UpperCamelCase						=  floats_tensor((1, 3, 16, 16)       ,   rng=random.Random(A_ ) ).to(A_ )

				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 )						->      List[str]:
				"""simple docstring"""
				self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3 )



		def __UpperCamelCase				(				self )						->      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"""
				# 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 )						->      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 )						->      List[Any]:
				"""simple docstring"""
				self._test_inference_batch_single_identical(
				    expected_max_diff=1e-2       ,   )


import pytest

import datasets.config
from datasets.utils.info_utils import is_small_dataset


@pytest.mark.parametrize('dataset_size'					, [None, 400 * 2**20, 600 * 2**20]				)
@pytest.mark.parametrize('input_in_memory_max_size'					, ['default', 0, 100 * 2**20, 900 * 2**20]				)
def    A (      lowercase					, lowercase					, lowercase				)     ->						Union[str, Any]:
		'''simple docstring'''

		if input_in_memory_max_size != "default":
				monkeypatch.setattr(datasets.config					, 'IN_MEMORY_MAX_SIZE'					, lowercase				)
		UpperCamelCase						=  datasets.config.IN_MEMORY_MAX_SIZE
		if input_in_memory_max_size == "default":
				assert in_memory_max_size == 0
		else:
				assert in_memory_max_size == input_in_memory_max_size
		if dataset_size and in_memory_max_size:
				UpperCamelCase						=  dataset_size < in_memory_max_size
		else:
				UpperCamelCase						=  False
		UpperCamelCase						=  is_small_dataset(lowercase				)
		assert result == expected
