






"""simple docstring"""







import random
import unittest

import torch

from diffusers import IFImgaImgPipeline
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				):





							"""simple docstring"""





							_SCREAMING_SNAKE_CASE     =IFImgaImgPipeline
							_SCREAMING_SNAKE_CASE     =TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'width', 'height'}
							_SCREAMING_SNAKE_CASE     =TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
							_SCREAMING_SNAKE_CASE     =PipelineTesterMixin.required_optional_params - {'latents'}




							def 			lowercase		( self:  str     ):

												'''simple docstring'''

												return self._get_dummy_components()




							def 			lowercase		( self:  List[str]					,		__A:  Tuple					,		__A:  Dict=0     ):

												'''simple docstring'''

												if str(__A     ).startswith('''mps'''     ):
																	a__ 							=	torch.manual_seed(__A     )
												else:
																	a__ 							=	torch.Generator(device=__A     ).manual_seed(__A     )

												a__ 							=	floats_tensor((1, 3, 32, 32)					,		rng=random.Random(__A     )     ).to(__A     )

												a__ 							=	{
												    '''prompt''': '''A painting of a squirrel eating a burger''',
												    '''image''': image,
												    '''generator''': generator,
												    '''num_inference_steps''': 2,
												    '''output_type''': '''numpy''',
												}

												return inputs




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

												'''simple docstring'''

												self._test_save_load_optional_components()




							@unittest.skipIf(
							    torch_device != '''cuda''' or not is_xformers_available()					,		reason='''XFormers attention is only available with CUDA and `xformers` installed'''					,		)
							def 			lowercase		( self:  List[Any]     ):

												'''simple docstring'''

												self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3     )




							@unittest.skipIf(torch_device != '''cuda'''					,		reason='''float16 requires CUDA'''     )
							def 			lowercase		( self:  Dict     ):

												'''simple docstring'''

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




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

												'''simple docstring'''

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




							def 			lowercase		( self:  List[str]     ):

												'''simple docstring'''

												self._test_attention_slicing_forward_pass(expected_max_diff=1e-2     )




							def 			lowercase		( self:  str     ):

												'''simple docstring'''

												self._test_save_load_local()





							def 			lowercase		( self:  Dict     ):

												'''simple docstring'''

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










"""simple docstring"""







from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available


__a							:						int   							=			{
    'configuration_markuplm': ['MARKUPLM_PRETRAINED_CONFIG_ARCHIVE_MAP', 'MarkupLMConfig'],
    'feature_extraction_markuplm': ['MarkupLMFeatureExtractor'],
    'processing_markuplm': ['MarkupLMProcessor'],
    'tokenization_markuplm': ['MarkupLMTokenizer'],
}

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

try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	__a							:						List[Any]   							=			[
	    'MARKUPLM_PRETRAINED_MODEL_ARCHIVE_LIST',
	    'MarkupLMForQuestionAnswering',
	    'MarkupLMForSequenceClassification',
	    'MarkupLMForTokenClassification',
	    'MarkupLMModel',
	    'MarkupLMPreTrainedModel',
	]


if TYPE_CHECKING:
	from .configuration_markuplm import MARKUPLM_PRETRAINED_CONFIG_ARCHIVE_MAP, MarkupLMConfig
	from .feature_extraction_markuplm import MarkupLMFeatureExtractor
	from .processing_markuplm import MarkupLMProcessor
	from .tokenization_markuplm import MarkupLMTokenizer

	try:
		if not is_tokenizers_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .tokenization_markuplm_fast import MarkupLMTokenizerFast

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_markuplm import (
		    MARKUPLM_PRETRAINED_MODEL_ARCHIVE_LIST,
		    MarkupLMForQuestionAnswering,
		    MarkupLMForSequenceClassification,
		    MarkupLMForTokenClassification,
		    MarkupLMModel,
		    MarkupLMPreTrainedModel,
		)


else:
	import sys

	__a							:						Tuple   							=			_LazyModule(__name__, globals()['__file__'], _import_structure)


