





"""simple docstring"""





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 		SCREAMING_SNAKE_CASE_							(    snake_case__       ,  snake_case__       ,  unittest.TestCase   ):
				__snake_case   :       List[Any]	 =		IFImgaImgSuperResolutionPipeline
				__snake_case   :       Tuple	 =		TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"""width""", """height"""}
				__snake_case   :       Tuple	 =		TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({"""original_image"""}   )
				__snake_case   :       Optional[Any]	 =		PipelineTesterMixin.required_optional_params - {"""latents"""}




				def 					__lowercase  (     self  :int			):
											return self._get_superresolution_dummy_components()




				def 					__lowercase  (     self  :List[Any]						,    __lowercase  :List[Any]						,    __lowercase  :Optional[Any]=0			):
											if str(__lowercase			).startswith('''mps'''			):
																		__lowerCamelCase      :      List[str]         =torch.manual_seed(__lowercase			)
											else:
																		__lowerCamelCase      :      str         =torch.Generator(device=__lowercase			).manual_seed(__lowercase			)

											__lowerCamelCase      :      Optional[Any]         =floats_tensor((1, 3, 32, 32)						,    rng=random.Random(__lowercase			)			).to(__lowercase			)
											__lowerCamelCase      :      Dict         =floats_tensor((1, 3, 16, 16)						,    rng=random.Random(__lowercase			)			).to(__lowercase			)

											__lowerCamelCase      :      List[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 					__lowercase  (     self  :Optional[int]			):
											self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3			)




				def 					__lowercase  (     self  :str			):
											self._test_save_load_optional_components()




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




				def 					__lowercase  (     self  :Optional[int]			):
											self._test_save_load_local()




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











"""simple docstring"""





from .glue import GlueDataset, GlueDataTrainingArguments
from .language_modeling import (
    LineByLineTextDataset,
    LineByLineWithRefDataset,
    LineByLineWithSOPTextDataset,
    TextDataset,
    TextDatasetForNextSentencePrediction,
)
from .squad import SquadDataset, SquadDataTrainingArguments




