




import random
import unittest

import torch

from diffusers import IFInpaintingPipeline
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_INPAINTING_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_INPAINTING_PARAMS,
)
from ..test_pipelines_common import PipelineTesterMixin
from . import IFPipelineTesterMixin


@skip_mps
class    SCREAMING_SNAKE_CASE_				(       _UpperCamelCase	,  _UpperCamelCase	,  unittest.TestCase   ):



	"""simple docstring"""


	__magic_name__   :       List[Any]      	=		IFInpaintingPipeline
	__magic_name__   :       Optional[Any]      	=		TEXT_GUIDED_IMAGE_INPAINTING_PARAMS - {'width', 'height'}
	__magic_name__   :       Tuple      	=		TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
	__magic_name__   :       List[Any]      	=		PipelineTesterMixin.required_optional_params - {'latents'}






	def 					lowerCamelCase__     (					self		:						Any	)	->       int:







						"""simple docstring"""







						return self._get_dummy_components()






	def 					lowerCamelCase__     (					self		:						Optional[int]					,     lowerCAmelCase		:						Optional[Any]					,     lowerCAmelCase		:						int=0	)	->       Union[str, Any]:







						"""simple docstring"""







						if str(lowerCAmelCase	).startswith("""mps"""	):
											__UpperCamelCase					:	List[str]             =      torch.manual_seed(lowerCAmelCase	)
						else:
											__UpperCamelCase					:	str             =      torch.Generator(device=lowerCAmelCase	).manual_seed(lowerCAmelCase	)

						__UpperCamelCase					:	Dict             =      floats_tensor((1, 3, 32, 32)					,     rng=random.Random(lowerCAmelCase	)	).to(lowerCAmelCase	)
						__UpperCamelCase					:	List[Any]             =      floats_tensor((1, 3, 32, 32)					,     rng=random.Random(lowerCAmelCase	)	).to(lowerCAmelCase	)

						__UpperCamelCase					:	int             =      {
						    """prompt""": """A painting of a squirrel eating a burger""",
						    """image""": image,
						    """mask_image""": mask_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 					lowerCamelCase__     (					self		:						Optional[int]	)	->       Optional[Any]:







						"""simple docstring"""







						self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3	)






	def 					lowerCamelCase__     (					self		:						Any	)	->       Dict:







						"""simple docstring"""







						self._test_save_load_optional_components()






	@unittest.skipIf(torch_device != """cuda"""					,     reason="""float16 requires CUDA"""	)
	def 					lowerCamelCase__     (					self		:						List[str]	)	->       Optional[int]:







						"""simple docstring"""







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






	def 					lowerCamelCase__     (					self		:						Tuple	)	->       List[Any]:







						"""simple docstring"""







						self._test_attention_slicing_forward_pass(expected_max_diff=1E-2	)






	def 					lowerCamelCase__     (					self		:						str	)	->       Any:







						"""simple docstring"""







						self._test_save_load_local()






	def 					lowerCamelCase__     (					self		:						Optional[Any]	)	->       Optional[int]:







						"""simple docstring"""







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












from tempfile import TemporaryDirectory
from unittest import TestCase
from unittest.mock import MagicMock, patch

from transformers import AutoModel, TFAutoModel
from transformers.onnx import FeaturesManager
from transformers.testing_utils import SMALL_MODEL_IDENTIFIER, require_tf, require_torch


@require_torch
@require_tf
class    SCREAMING_SNAKE_CASE_				(       _UpperCamelCase   ):



	"""simple docstring"""


	def 					lowerCamelCase__     (					self		:						Dict	)	->       List[Any]:







						"""simple docstring"""







						__UpperCamelCase					:	Optional[Any]             =      SMALL_MODEL_IDENTIFIER
						__UpperCamelCase					:	List[str]             =      """pt"""
						__UpperCamelCase					:	List[Any]             =      """tf"""






	def 					lowerCamelCase__     (					self		:						Any					,     lowerCAmelCase		:						List[Any]	)	->       List[Any]:







						"""simple docstring"""







						__UpperCamelCase					:	str             =      AutoModel.from_pretrained(self.test_model	)
						model_pt.save_pretrained(lowerCAmelCase	)






	def 					lowerCamelCase__     (					self		:						List[Any]					,     lowerCAmelCase		:						Any	)	->       Optional[Any]:







						"""simple docstring"""







						__UpperCamelCase					:	List[str]             =      TFAutoModel.from_pretrained(self.test_model					,     from_pt=lowerCAmelCase	)
						model_tf.save_pretrained(lowerCAmelCase	)






	def 					lowerCamelCase__     (					self		:						str	)	->       Tuple:







						"""simple docstring"""







						__UpperCamelCase					:	Any             =      """mock_framework"""

						# Framework provided - return whatever the user provides
						__UpperCamelCase					:	List[Any]             =      FeaturesManager.determine_framework(self.test_model					,     lowerCAmelCase	)
						self.assertEqual(lowerCAmelCase					,     lowerCAmelCase	)

						# Local checkpoint and framework provided - return provided framework
						# PyTorch checkpoint
						with TemporaryDirectory() as local_pt_ckpt:
											self._setup_pt_ckpt(lowerCAmelCase	)
											__UpperCamelCase					:	Union[str, Any]             =      FeaturesManager.determine_framework(lowerCAmelCase					,     lowerCAmelCase	)
											self.assertEqual(lowerCAmelCase					,     lowerCAmelCase	)

						# TensorFlow checkpoint
						with TemporaryDirectory() as local_tf_ckpt:
											self._setup_tf_ckpt(lowerCAmelCase	)
											__UpperCamelCase					:	Any             =      FeaturesManager.determine_framework(lowerCAmelCase					,     lowerCAmelCase	)
											self.assertEqual(lowerCAmelCase					,     lowerCAmelCase	)






	def 					lowerCamelCase__     (					self		:						Optional[Any]	)	->       str:







						"""simple docstring"""







						with TemporaryDirectory() as local_pt_ckpt:
											self._setup_pt_ckpt(lowerCAmelCase	)
											__UpperCamelCase					:	Optional[Any]             =      FeaturesManager.determine_framework(lowerCAmelCase	)
											self.assertEqual(lowerCAmelCase					,     self.framework_pt	)

						# TensorFlow checkpoint
						with TemporaryDirectory() as local_tf_ckpt:
											self._setup_tf_ckpt(lowerCAmelCase	)
											__UpperCamelCase					:	Union[str, Any]             =      FeaturesManager.determine_framework(lowerCAmelCase	)
											self.assertEqual(lowerCAmelCase					,     self.framework_tf	)

						# Invalid local checkpoint
						with TemporaryDirectory() as local_invalid_ckpt:
											with self.assertRaises(lowerCAmelCase	):
																__UpperCamelCase					:	int             =      FeaturesManager.determine_framework(lowerCAmelCase	)






	def 					lowerCamelCase__     (					self		:						Dict	)	->       Tuple:







						"""simple docstring"""







						__UpperCamelCase					:	str             =      MagicMock(return_value=lowerCAmelCase	)
						with patch("""transformers.onnx.features.is_tf_available"""					,     lowerCAmelCase	):
											__UpperCamelCase					:	Any             =      FeaturesManager.determine_framework(self.test_model	)
											self.assertEqual(lowerCAmelCase					,     self.framework_pt	)

						# PyTorch not in environment -> use TensorFlow
						__UpperCamelCase					:	Optional[int]             =      MagicMock(return_value=lowerCAmelCase	)
						with patch("""transformers.onnx.features.is_torch_available"""					,     lowerCAmelCase	):
											__UpperCamelCase					:	Any             =      FeaturesManager.determine_framework(self.test_model	)
											self.assertEqual(lowerCAmelCase					,     self.framework_tf	)

						# Both in environment -> use PyTorch
						__UpperCamelCase					:	Dict             =      MagicMock(return_value=lowerCAmelCase	)
						__UpperCamelCase					:	Any             =      MagicMock(return_value=lowerCAmelCase	)
						with patch("""transformers.onnx.features.is_tf_available"""					,     lowerCAmelCase	), patch(
						    """transformers.onnx.features.is_torch_available"""					,     lowerCAmelCase	):
											__UpperCamelCase					:	int             =      FeaturesManager.determine_framework(self.test_model	)
											self.assertEqual(lowerCAmelCase					,     self.framework_pt	)

						# Both not in environment -> raise error
						__UpperCamelCase					:	Union[str, Any]             =      MagicMock(return_value=lowerCAmelCase	)
						__UpperCamelCase					:	Tuple             =      MagicMock(return_value=lowerCAmelCase	)
						with patch("""transformers.onnx.features.is_tf_available"""					,     lowerCAmelCase	), patch(
						    """transformers.onnx.features.is_torch_available"""					,     lowerCAmelCase	):
											with self.assertRaises(lowerCAmelCase	):
																__UpperCamelCase					:	str             =      FeaturesManager.determine_framework(self.test_model	)






