


'''simple docstring'''






import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
						import torch

if is_vision_available():
						from PIL import Image

						from transformers import EfficientNetImageProcessor






class      SCREAMING_SNAKE_CASE_	( unittest.TestCase		):




			def __init__(      self					,      lowercase					,      lowercase=1_3					,      lowercase=3					,      lowercase=1_8					,      lowercase=3_0					,      lowercase=4_0_0					,      lowercase=True					,      lowercase=None					,      lowercase=True					,      lowercase=[0.5, 0.5, 0.5]					,      lowercase=[0.5, 0.5, 0.5]					,      )			->						List[str]:


								'''simple docstring'''






								__SCREAMING_SNAKE_CASE					:							List[str]			   = size if size is not None else {'''height''': 1_8, '''width''': 1_8}
								__SCREAMING_SNAKE_CASE					:							List[Any]			   = parent
								__SCREAMING_SNAKE_CASE					:							Tuple			   = batch_size
								__SCREAMING_SNAKE_CASE					:							Optional[Any]			   = num_channels
								__SCREAMING_SNAKE_CASE					:							Dict			   = image_size
								__SCREAMING_SNAKE_CASE					:							List[str]			   = min_resolution
								__SCREAMING_SNAKE_CASE					:							Any			   = max_resolution
								__SCREAMING_SNAKE_CASE					:							Union[str, Any]			   = do_resize
								__SCREAMING_SNAKE_CASE					:							List[Any]			   = size
								__SCREAMING_SNAKE_CASE					:							Tuple			   = do_normalize
								__SCREAMING_SNAKE_CASE					:							Optional[int]			   = image_mean
								__SCREAMING_SNAKE_CASE					:							int			   = image_std




			def 			_snake_case   (      self       )			->						Union[str, Any]:


								'''simple docstring'''






								return {
								    "image_mean": self.image_mean,
								    "image_std": self.image_std,
								    "do_normalize": self.do_normalize,
								    "do_resize": self.do_resize,
								    "size": self.size,
								}






@require_torch
@require_vision
class      SCREAMING_SNAKE_CASE_	( snake_case					,					unittest.TestCase		):
			__a					:      int					=  EfficientNetImageProcessor if is_vision_available() else None




			def 			_snake_case   (      self       )			->						Optional[int]:


								'''simple docstring'''






								__SCREAMING_SNAKE_CASE					:							Any			   = EfficientNetImageProcessorTester(self       )




			@property
			def 			_snake_case   (      self       )			->						Any:


								'''simple docstring'''






								return self.image_processor_tester.prepare_image_processor_dict()




			def 			_snake_case   (      self       )			->						Dict:


								'''simple docstring'''






								__SCREAMING_SNAKE_CASE					:							Optional[Any]			   = self.image_processing_class(**self.image_processor_dict       )
								self.assertTrue(hasattr(lowercase					,      '''image_mean'''       )       )
								self.assertTrue(hasattr(lowercase					,      '''image_std'''       )       )
								self.assertTrue(hasattr(lowercase					,      '''do_normalize'''       )       )
								self.assertTrue(hasattr(lowercase					,      '''do_resize'''       )       )
								self.assertTrue(hasattr(lowercase					,      '''size'''       )       )




			def 			_snake_case   (      self       )			->						Tuple:


								'''simple docstring'''






								__SCREAMING_SNAKE_CASE					:							List[str]			   = self.image_processing_class.from_dict(self.image_processor_dict       )
								self.assertEqual(image_processor.size					,      {'''height''': 1_8, '''width''': 1_8}       )

								__SCREAMING_SNAKE_CASE					:							List[Any]			   = self.image_processing_class.from_dict(self.image_processor_dict					,      size=4_2       )
								self.assertEqual(image_processor.size					,      {'''height''': 4_2, '''width''': 4_2}       )




			def 			_snake_case   (      self       )			->						Any:


								'''simple docstring'''






								__SCREAMING_SNAKE_CASE					:							Any			   = self.image_processing_class(**self.image_processor_dict       )
								# create random PIL images
								__SCREAMING_SNAKE_CASE					:							int			   = prepare_image_inputs(self.image_processor_tester					,      equal_resolution=lowercase       )
								for image in image_inputs:
													self.assertIsInstance(lowercase					,      Image.Image       )

								# Test not batched input
								__SCREAMING_SNAKE_CASE					:							Optional[Any]			   = image_processing(image_inputs[0]					,      return_tensors='''pt'''       ).pixel_values
								self.assertEqual(
								    encoded_images.shape					,      (
								        1,
								        self.image_processor_tester.num_channels,
								        self.image_processor_tester.size['''height'''],
								        self.image_processor_tester.size['''width'''],
								    )					,      )

								# Test batched
								__SCREAMING_SNAKE_CASE					:							Any			   = image_processing(lowercase					,      return_tensors='''pt'''       ).pixel_values
								self.assertEqual(
								    encoded_images.shape					,      (
								        self.image_processor_tester.batch_size,
								        self.image_processor_tester.num_channels,
								        self.image_processor_tester.size['''height'''],
								        self.image_processor_tester.size['''width'''],
								    )					,      )




			def 			_snake_case   (      self       )			->						Union[str, Any]:


								'''simple docstring'''






								__SCREAMING_SNAKE_CASE					:							str			   = self.image_processing_class(**self.image_processor_dict       )
								# create random numpy tensors
								__SCREAMING_SNAKE_CASE					:							List[str]			   = prepare_image_inputs(self.image_processor_tester					,      equal_resolution=lowercase					,      numpify=lowercase       )
								for image in image_inputs:
													self.assertIsInstance(lowercase					,      np.ndarray       )

								# Test not batched input
								__SCREAMING_SNAKE_CASE					:							Dict			   = image_processing(image_inputs[0]					,      return_tensors='''pt'''       ).pixel_values
								self.assertEqual(
								    encoded_images.shape					,      (
								        1,
								        self.image_processor_tester.num_channels,
								        self.image_processor_tester.size['''height'''],
								        self.image_processor_tester.size['''width'''],
								    )					,      )

								# Test batched
								__SCREAMING_SNAKE_CASE					:							Any			   = image_processing(lowercase					,      return_tensors='''pt'''       ).pixel_values
								self.assertEqual(
								    encoded_images.shape					,      (
								        self.image_processor_tester.batch_size,
								        self.image_processor_tester.num_channels,
								        self.image_processor_tester.size['''height'''],
								        self.image_processor_tester.size['''width'''],
								    )					,      )




			def 			_snake_case   (      self       )			->						int:


								'''simple docstring'''






								__SCREAMING_SNAKE_CASE					:							Any			   = self.image_processing_class(**self.image_processor_dict       )
								# create random PyTorch tensors
								__SCREAMING_SNAKE_CASE					:							str			   = prepare_image_inputs(self.image_processor_tester					,      equal_resolution=lowercase					,      torchify=lowercase       )
								for image in image_inputs:
													self.assertIsInstance(lowercase					,      torch.Tensor       )

								# Test not batched input
								__SCREAMING_SNAKE_CASE					:							int			   = image_processing(image_inputs[0]					,      return_tensors='''pt'''       ).pixel_values
								self.assertEqual(
								    encoded_images.shape					,      (
								        1,
								        self.image_processor_tester.num_channels,
								        self.image_processor_tester.size['''height'''],
								        self.image_processor_tester.size['''width'''],
								    )					,      )

								# Test batched
								__SCREAMING_SNAKE_CASE					:							List[Any]			   = image_processing(lowercase					,      return_tensors='''pt'''       ).pixel_values
								self.assertEqual(
								    encoded_images.shape					,      (
								        self.image_processor_tester.batch_size,
								        self.image_processor_tester.num_channels,
								        self.image_processor_tester.size['''height'''],
								        self.image_processor_tester.size['''width'''],
								    )					,      )






'''simple docstring'''






import random
import unittest

import torch

from diffusers import IFSuperResolutionPipeline
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		):
			__a					:      Dict					=  IFSuperResolutionPipeline
			__a					:      Dict					=  TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'''width''', '''height'''}
			__a					:      Tuple					=  TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
			__a					:      Tuple					=  PipelineTesterMixin.required_optional_params - {'''latents'''}




			def 			_snake_case   (      self       )			->						Dict:


								'''simple docstring'''






								return self._get_superresolution_dummy_components()




			def 			_snake_case   (      self					,      lowercase					,      lowercase=0       )			->						Union[str, Any]:


								'''simple docstring'''






								if str(lowercase       ).startswith('''mps'''       ):
													__SCREAMING_SNAKE_CASE					:							Optional[int]			   = torch.manual_seed(lowercase       )
								else:
													__SCREAMING_SNAKE_CASE					:							int			   = torch.Generator(device=lowercase       ).manual_seed(lowercase       )

								__SCREAMING_SNAKE_CASE					:							Optional[Any]			   = floats_tensor((1, 3, 3_2, 3_2)					,      rng=random.Random(lowercase       )       ).to(lowercase       )

								__SCREAMING_SNAKE_CASE					:							List[str]			   = {
								    '''prompt''': '''A painting of a squirrel eating a burger''',
								    '''image''': 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 			_snake_case   (      self       )			->						List[str]:


								'''simple docstring'''






								self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3       )




			def 			_snake_case   (      self       )			->						int:


								'''simple docstring'''






								self._test_save_load_optional_components()




			@unittest.skipIf(torch_device != '''cuda'''					,      reason='''float16 requires CUDA'''       )
			def 			_snake_case   (      self       )			->						Union[str, Any]:


								'''simple docstring'''






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




			def 			_snake_case   (      self       )			->						Optional[int]:


								'''simple docstring'''






								self._test_attention_slicing_forward_pass(expected_max_diff=1e-2       )




			def 			_snake_case   (      self       )			->						Optional[int]:


								'''simple docstring'''






								self._test_save_load_local()




			def 			_snake_case   (      self       )			->						List[str]:


								'''simple docstring'''






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


