


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

	"""simple docstring"""





	snake_case__				:  Any    					=			IFImgaImgSuperResolutionPipeline
	snake_case__				:  List[Any]    					=			TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"width", "height"}
	snake_case__				:  str    					=			TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({"original_image"})
	snake_case__				:  int    					=			PipelineTesterMixin.required_optional_params - {"latents"}




	def   UpperCAmelCase_      ( self			:				Any   )       ->	Any:
						return self._get_superresolution_dummy_components()




	def   UpperCAmelCase_      ( self			:				Optional[int]			,			UpperCAmelCase__			:				str			,			UpperCAmelCase__			:				Dict=0   )       ->	Optional[Any]:
						if str(UpperCAmelCase__   ).startswith("mps"   ):
											__SCREAMING_SNAKE_CASE						   =				torch.manual_seed(UpperCAmelCase__   )
						else:
											__SCREAMING_SNAKE_CASE						   =				torch.Generator(device=UpperCAmelCase__   ).manual_seed(UpperCAmelCase__   )

						__SCREAMING_SNAKE_CASE						   =				floats_tensor((1, 3, 3_2, 3_2)			,			rng=random.Random(UpperCAmelCase__   )   ).to(UpperCAmelCase__   )
						__SCREAMING_SNAKE_CASE						   =				floats_tensor((1, 3, 1_6, 1_6)			,			rng=random.Random(UpperCAmelCase__   )   ).to(UpperCAmelCase__   )

						__SCREAMING_SNAKE_CASE						   =				{
						    "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			:				Dict   )       ->	int:
						self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3   )




	def   UpperCAmelCase_      ( self			:				List[str]   )       ->	str:
						self._test_save_load_optional_components()




	@unittest.skipIf(torch_device != "cuda"			,			reason="float16 requires CUDA"   )
	def   UpperCAmelCase_      ( self			:				Optional[Any]   )       ->	Optional[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   UpperCAmelCase_      ( self			:				List[Any]   )       ->	Optional[int]:
						self._test_attention_slicing_forward_pass(expected_max_diff=1E-2   )




	def   UpperCAmelCase_      ( self			:				Optional[int]   )       ->	Tuple:
						self._test_save_load_local()




	def   UpperCAmelCase_      ( self			:				Optional[int]   )       ->	str:
						self._test_inference_batch_single_identical(
						    expected_max_diff=1E-2			,			)


from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_sentencepiece_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


__a  			=					{
    'configuration_rembert': ['REMBERT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'RemBertConfig', 'RemBertOnnxConfig']
}

try:
						if not is_sentencepiece_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						__a  			=					['RemBertTokenizer']

try:
						if not is_tokenizers_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						__a  			=					['RemBertTokenizerFast']

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						__a  			=					[
						    'REMBERT_PRETRAINED_MODEL_ARCHIVE_LIST',
						    'RemBertForCausalLM',
						    'RemBertForMaskedLM',
						    'RemBertForMultipleChoice',
						    'RemBertForQuestionAnswering',
						    'RemBertForSequenceClassification',
						    'RemBertForTokenClassification',
						    'RemBertLayer',
						    'RemBertModel',
						    'RemBertPreTrainedModel',
						    'load_tf_weights_in_rembert',
						]


try:
						if not is_tf_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						__a  			=					[
						    'TF_REMBERT_PRETRAINED_MODEL_ARCHIVE_LIST',
						    'TFRemBertForCausalLM',
						    'TFRemBertForMaskedLM',
						    'TFRemBertForMultipleChoice',
						    'TFRemBertForQuestionAnswering',
						    'TFRemBertForSequenceClassification',
						    'TFRemBertForTokenClassification',
						    'TFRemBertLayer',
						    'TFRemBertModel',
						    'TFRemBertPreTrainedModel',
						]


if TYPE_CHECKING:
						from .configuration_rembert import REMBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, RemBertConfig, RemBertOnnxConfig

						try:
												if not is_sentencepiece_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .tokenization_rembert import RemBertTokenizer

						try:
												if not is_tokenizers_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .tokenization_rembert_fast import RemBertTokenizerFast

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_rembert import (
												    REMBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
												    RemBertForCausalLM,
												    RemBertForMaskedLM,
												    RemBertForMultipleChoice,
												    RemBertForQuestionAnswering,
												    RemBertForSequenceClassification,
												    RemBertForTokenClassification,
												    RemBertLayer,
												    RemBertModel,
												    RemBertPreTrainedModel,
												    load_tf_weights_in_rembert,
												)

						try:
												if not is_tf_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_tf_rembert import (
												    TF_REMBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
												    TFRemBertForCausalLM,
												    TFRemBertForMaskedLM,
												    TFRemBertForMultipleChoice,
												    TFRemBertForQuestionAnswering,
												    TFRemBertForSequenceClassification,
												    TFRemBertForTokenClassification,
												    TFRemBertLayer,
												    TFRemBertModel,
												    TFRemBertPreTrainedModel,
												)


else:
						import sys

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




