






from typing import Dict, List, Optional, Union

import numpy as np

from transformers.utils import is_vision_available
from transformers.utils.generic import TensorType

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    center_crop,
    get_resize_output_image_size,
    normalize,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    is_valid_image,
    to_numpy_array,
    valid_images,
)
from ...utils import logging


if is_vision_available():
			import PIL

snake_case    				=		logging.get_logger(__name__)


def   lowerCamelCase__			(     lowercase				):

		"""simple docstring"""






		if isinstance(lowercase						,     (list, tuple)				) and isinstance(videos[0]						,     (list, tuple)				) and is_valid_image(videos[0][0]				):
				return videos

		elif isinstance(lowercase						,     (list, tuple)				) and is_valid_image(videos[0]				):
				return [videos]

		elif is_valid_image(lowercase				):
				return [[videos]]

		raise ValueError(F'''Could not make batched video from {videos}'''				)


class  SCREAMING_SNAKE_CASE			(			lowerCAmelCase					):
					'''simple docstring'''


					UpperCamelCase_							:		Dict			=	['''pixel_values''']


					def __init__(				self       :	str					, UpperCAmelCase_       :	bool = True					, UpperCAmelCase_       :	Dict[str, int] = None					, UpperCAmelCase_       :	PILImageResampling = PILImageResampling.BILINEAR					, UpperCAmelCase_       :	bool = True					, UpperCAmelCase_       :	Dict[str, int] = None					, UpperCAmelCase_       :	bool = True					, UpperCAmelCase_       :	Union[int, float] = 1 / 255					, UpperCAmelCase_       :	bool = True					, UpperCAmelCase_       :	bool = True					, UpperCAmelCase_       :	Optional[Union[float, List[float]]] = None					, UpperCAmelCase_       :	Optional[Union[float, List[float]]] = None					, **UpperCAmelCase_       :	Any					, ):
							super().__init__(**UpperCAmelCase_      )
							SCREAMING_SNAKE_CASE       :      str							=    size if size is not None else {"shortest_edge": 256}
							SCREAMING_SNAKE_CASE       :      Tuple							=    get_size_dict(UpperCAmelCase_					, default_to_square=UpperCAmelCase_      )
							SCREAMING_SNAKE_CASE       :      Optional[int]							=    crop_size if crop_size is not None else {"height": 224, "width": 224}
							SCREAMING_SNAKE_CASE       :      List[str]							=    get_size_dict(UpperCAmelCase_					, param_name="crop_size"      )

							SCREAMING_SNAKE_CASE       :      str							=    do_resize
							SCREAMING_SNAKE_CASE       :      Optional[int]							=    size
							SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    do_center_crop
							SCREAMING_SNAKE_CASE       :      Tuple							=    crop_size
							SCREAMING_SNAKE_CASE       :      Any							=    resample
							SCREAMING_SNAKE_CASE       :      str							=    do_rescale
							SCREAMING_SNAKE_CASE       :      int							=    rescale_factor
							SCREAMING_SNAKE_CASE       :      int							=    offset
							SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    do_normalize
							SCREAMING_SNAKE_CASE       :      Dict							=    image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
							SCREAMING_SNAKE_CASE       :      Any							=    image_std if image_std is not None else IMAGENET_STANDARD_STD


					def 				_A       (				self       :	Optional[int]					, UpperCAmelCase_       :	np.ndarray					, UpperCAmelCase_       :	Dict[str, int]					, UpperCAmelCase_       :	PILImageResampling = PILImageResampling.BILINEAR					, UpperCAmelCase_       :	Optional[Union[str, ChannelDimension]] = None					, **UpperCAmelCase_       :	List[Any]					, ):
							SCREAMING_SNAKE_CASE       :      Optional[int]							=    get_size_dict(UpperCAmelCase_					, default_to_square=UpperCAmelCase_      )
							if "shortest_edge" in size:
									SCREAMING_SNAKE_CASE       :      Dict							=    get_resize_output_image_size(UpperCAmelCase_					, size["shortest_edge"]					, default_to_square=UpperCAmelCase_      )
							elif "height" in size and "width" in size:
									SCREAMING_SNAKE_CASE       :      Tuple							=    (size["height"], size["width"])
							else:
									raise ValueError(f'''Size must have \'height\' and \'width\' or \'shortest_edge\' as keys. Got {size.keys()}'''      )
							return resize(UpperCAmelCase_					, size=UpperCAmelCase_					, resample=UpperCAmelCase_					, data_format=UpperCAmelCase_					, **UpperCAmelCase_      )


					def 				_A       (				self       :	int					, UpperCAmelCase_       :	np.ndarray					, UpperCAmelCase_       :	Dict[str, int]					, UpperCAmelCase_       :	Optional[Union[str, ChannelDimension]] = None					, **UpperCAmelCase_       :	List[str]					, ):
							SCREAMING_SNAKE_CASE       :      Dict							=    get_size_dict(UpperCAmelCase_      )
							if "height" not in size or "width" not in size:
									raise ValueError(f'''Size must have \'height\' and \'width\' as keys. Got {size.keys()}'''      )
							return center_crop(UpperCAmelCase_					, size=(size["height"], size["width"])					, data_format=UpperCAmelCase_					, **UpperCAmelCase_      )


					def 				_A       (				self       :	List[Any]					, UpperCAmelCase_       :	np.ndarray					, UpperCAmelCase_       :	Union[int, float]					, UpperCAmelCase_       :	bool = True					, UpperCAmelCase_       :	Optional[Union[str, ChannelDimension]] = None					, **UpperCAmelCase_       :	Union[str, Any]					, ):
							SCREAMING_SNAKE_CASE       :      Optional[Any]							=    image.astype(np.floataa      )
							if offset:
									SCREAMING_SNAKE_CASE       :      str							=    image - (scale / 2)
							return rescale(UpperCAmelCase_					, scale=UpperCAmelCase_					, data_format=UpperCAmelCase_					, **UpperCAmelCase_      )


					def 				_A       (				self       :	Any					, UpperCAmelCase_       :	np.ndarray					, UpperCAmelCase_       :	Union[float, List[float]]					, UpperCAmelCase_       :	Union[float, List[float]]					, UpperCAmelCase_       :	Optional[Union[str, ChannelDimension]] = None					, **UpperCAmelCase_       :	List[Any]					, ):
							return normalize(UpperCAmelCase_					, mean=UpperCAmelCase_					, std=UpperCAmelCase_					, data_format=UpperCAmelCase_					, **UpperCAmelCase_      )


					def 				_A       (				self       :	List[str]					, UpperCAmelCase_       :	ImageInput					, UpperCAmelCase_       :	bool = None					, UpperCAmelCase_       :	Dict[str, int] = None					, UpperCAmelCase_       :	PILImageResampling = None					, UpperCAmelCase_       :	bool = None					, UpperCAmelCase_       :	Dict[str, int] = None					, UpperCAmelCase_       :	bool = None					, UpperCAmelCase_       :	float = None					, UpperCAmelCase_       :	bool = None					, UpperCAmelCase_       :	bool = None					, UpperCAmelCase_       :	Optional[Union[float, List[float]]] = None					, UpperCAmelCase_       :	Optional[Union[float, List[float]]] = None					, UpperCAmelCase_       :	Optional[ChannelDimension] = ChannelDimension.FIRST					, ):
							if do_resize and size is None or resample is None:
									raise ValueError("Size and resample must be specified if do_resize is True."      )

							if do_center_crop and crop_size is None:
									raise ValueError("Crop size must be specified if do_center_crop is True."      )

							if do_rescale and rescale_factor is None:
									raise ValueError("Rescale factor must be specified if do_rescale is True."      )

							if do_normalize and (image_mean is None or image_std is None):
									raise ValueError("Image mean and std must be specified if do_normalize is True."      )

							if offset and not do_rescale:
									raise ValueError("For offset, do_rescale must also be set to True."      )

							# All transformations expect numpy arrays.
							SCREAMING_SNAKE_CASE       :      Optional[int]							=    to_numpy_array(UpperCAmelCase_      )

							if do_resize:
									SCREAMING_SNAKE_CASE       :      Dict							=    self.resize(image=UpperCAmelCase_					, size=UpperCAmelCase_					, resample=UpperCAmelCase_      )

							if do_center_crop:
									SCREAMING_SNAKE_CASE       :      Dict							=    self.center_crop(UpperCAmelCase_					, size=UpperCAmelCase_      )

							if do_rescale:
									SCREAMING_SNAKE_CASE       :      Tuple							=    self.rescale(image=UpperCAmelCase_					, scale=UpperCAmelCase_					, offset=UpperCAmelCase_      )

							if do_normalize:
									SCREAMING_SNAKE_CASE       :      Optional[int]							=    self.normalize(image=UpperCAmelCase_					, mean=UpperCAmelCase_					, std=UpperCAmelCase_      )

							SCREAMING_SNAKE_CASE       :      Optional[int]							=    to_channel_dimension_format(UpperCAmelCase_					, UpperCAmelCase_      )
							return image






					def 				_A       (				self       :	Optional[int]					, UpperCAmelCase_       :	ImageInput					, UpperCAmelCase_       :	bool = None					, UpperCAmelCase_       :	Dict[str, int] = None					, UpperCAmelCase_       :	PILImageResampling = None					, UpperCAmelCase_       :	bool = None					, UpperCAmelCase_       :	Dict[str, int] = None					, UpperCAmelCase_       :	bool = None					, UpperCAmelCase_       :	float = None					, UpperCAmelCase_       :	bool = None					, UpperCAmelCase_       :	bool = None					, UpperCAmelCase_       :	Optional[Union[float, List[float]]] = None					, UpperCAmelCase_       :	Optional[Union[float, List[float]]] = None					, UpperCAmelCase_       :	Optional[Union[str, TensorType]] = None					, UpperCAmelCase_       :	ChannelDimension = ChannelDimension.FIRST					, **UpperCAmelCase_       :	int					, ):
							SCREAMING_SNAKE_CASE       :      Dict							=    do_resize if do_resize is not None else self.do_resize
							SCREAMING_SNAKE_CASE       :      Any							=    resample if resample is not None else self.resample
							SCREAMING_SNAKE_CASE       :      Optional[Any]							=    do_center_crop if do_center_crop is not None else self.do_center_crop
							SCREAMING_SNAKE_CASE       :      Optional[int]							=    do_rescale if do_rescale is not None else self.do_rescale
							SCREAMING_SNAKE_CASE       :      List[str]							=    rescale_factor if rescale_factor is not None else self.rescale_factor
							SCREAMING_SNAKE_CASE       :      List[str]							=    offset if offset is not None else self.offset
							SCREAMING_SNAKE_CASE       :      str							=    do_normalize if do_normalize is not None else self.do_normalize
							SCREAMING_SNAKE_CASE       :      List[Any]							=    image_mean if image_mean is not None else self.image_mean
							SCREAMING_SNAKE_CASE       :      Any							=    image_std if image_std is not None else self.image_std

							SCREAMING_SNAKE_CASE       :      List[Any]							=    size if size is not None else self.size
							SCREAMING_SNAKE_CASE       :      Optional[int]							=    get_size_dict(UpperCAmelCase_					, default_to_square=UpperCAmelCase_      )
							SCREAMING_SNAKE_CASE       :      List[str]							=    crop_size if crop_size is not None else self.crop_size
							SCREAMING_SNAKE_CASE       :      List[Any]							=    get_size_dict(UpperCAmelCase_					, param_name="crop_size"      )

							if not valid_images(UpperCAmelCase_      ):
									raise ValueError(
									    "Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, "
									    "torch.Tensor, tf.Tensor or jax.ndarray."      )

							SCREAMING_SNAKE_CASE       :      Optional[Any]							=    make_batched(UpperCAmelCase_      )

							SCREAMING_SNAKE_CASE       :      Optional[int]							=    [
							    [
							        self._preprocess_image(
							            image=UpperCAmelCase_					, do_resize=UpperCAmelCase_					, size=UpperCAmelCase_					, resample=UpperCAmelCase_					, do_center_crop=UpperCAmelCase_					, crop_size=UpperCAmelCase_					, do_rescale=UpperCAmelCase_					, rescale_factor=UpperCAmelCase_					, offset=UpperCAmelCase_					, do_normalize=UpperCAmelCase_					, image_mean=UpperCAmelCase_					, image_std=UpperCAmelCase_					, data_format=UpperCAmelCase_					, )
							        for img in video
							    ]
							    for video in videos
							]

							SCREAMING_SNAKE_CASE       :      Optional[int]							=    {"pixel_values": videos}
							return BatchFeature(data=UpperCAmelCase_					, tensor_type=UpperCAmelCase_      )














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			(			lowerCAmelCase      ,		lowerCAmelCase      ,		unittest.TestCase					):
     '''simple docstring'''


     UpperCamelCase_							:		Optional[Any]			=	IFImgaImgSuperResolutionPipeline
     UpperCamelCase_							:		Any			=	TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'''width''', '''height'''}
     UpperCamelCase_							:		Optional[Any]			=	TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({'''original_image'''}					)
     UpperCamelCase_							:		str			=	PipelineTesterMixin.required_optional_params - {'''latents'''}


     def 				_A       (				self       :	List[Any]      ):
       return self._get_superresolution_dummy_components()


     def 				_A       (				self       :	Any					, UpperCAmelCase_       :	int					, UpperCAmelCase_       :	List[str]=0      ):
       if str(UpperCAmelCase_      ).startswith("mps"      ):
         SCREAMING_SNAKE_CASE       :      Any							=    torch.manual_seed(UpperCAmelCase_      )
       else:
         SCREAMING_SNAKE_CASE       :      List[str]							=    torch.Generator(device=UpperCAmelCase_      ).manual_seed(UpperCAmelCase_      )

       SCREAMING_SNAKE_CASE       :      Any							=    floats_tensor((1, 3, 32, 32)					, rng=random.Random(UpperCAmelCase_      )      ).to(UpperCAmelCase_      )
       SCREAMING_SNAKE_CASE       :      Any							=    floats_tensor((1, 3, 16, 16)					, rng=random.Random(UpperCAmelCase_      )      ).to(UpperCAmelCase_      )

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


     def 				_A       (				self       :	Optional[Any]      ):
       self._test_save_load_optional_components()


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


     def 				_A       (				self       :	Tuple      ):
       self._test_save_load_local()






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






