


from typing import Dict, List, Optional, Union

import numpy as np

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 TensorType, is_vision_available, logging


if is_vision_available():
	import PIL


a : Optional[Any]		=				logging.get_logger(__name__)


def 		lowercase_  (     _UpperCamelCase  ):


			'''simple docstring'''







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

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

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

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





class 	lowerCamelCase_       (				lowerCAmelCase__				):



					'''simple docstring'''







					__UpperCAmelCase            =				["pixel_values"]






					def __init__(				self ,       snake_case_ = True ,       snake_case_ = None ,       snake_case_ = PILImageResampling.BILINEAR ,       snake_case_ = True ,       snake_case_ = None ,       snake_case_ = True ,       snake_case_ = 1 / 2_5_5 ,       snake_case_ = True ,       snake_case_ = None ,       snake_case_ = None ,       **snake_case_ ,       )   ->			None:







								'''simple docstring'''

								super().__init__(**snake_case_						)
								__lowercase 					=   size if size is not None else {'''shortest_edge''': 2_2_4}
								__lowercase 					=   get_size_dict(snake_case_ ,       default_to_square=snake_case_						)
								__lowercase 					=   crop_size if crop_size is not None else {'''height''': 2_2_4, '''width''': 2_2_4}
								__lowercase 					=   get_size_dict(snake_case_ ,       param_name='''crop_size'''						)

								__lowercase 					=   do_resize
								__lowercase 					=   size
								__lowercase 					=   do_center_crop
								__lowercase 					=   crop_size
								__lowercase 					=   resample
								__lowercase 					=   do_rescale
								__lowercase 					=   rescale_factor
								__lowercase 					=   do_normalize
								__lowercase 					=   image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
								__lowercase 					=   image_std if image_std is not None else IMAGENET_STANDARD_STD






					def A      (				self ,       snake_case_ ,       snake_case_ ,       snake_case_ = PILImageResampling.BILINEAR ,       snake_case_ = None ,       **snake_case_ ,       )   ->			np.ndarray:







								'''simple docstring'''

								__lowercase 					=   get_size_dict(snake_case_ ,       default_to_square=snake_case_						)
								if "shortest_edge" in size:
											__lowercase 					=   get_resize_output_image_size(snake_case_ ,       size['''shortest_edge'''] ,       default_to_square=snake_case_						)
								elif "height" in size and "width" in size:
											__lowercase 					=   (size['''height'''], size['''width'''])
								else:
											raise ValueError(F'Size must have \'height\' and \'width\' or \'shortest_edge\' as keys. Got {size.keys()}'						)
								return resize(snake_case_ ,       size=snake_case_ ,       resample=snake_case_ ,       data_format=snake_case_ ,       **snake_case_						)






					def A      (				self ,       snake_case_ ,       snake_case_ ,       snake_case_ = None ,       **snake_case_ ,       )   ->			np.ndarray:







								'''simple docstring'''

								__lowercase 					=   get_size_dict(snake_case_						)
								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(snake_case_ ,       size=(size['''height'''], size['''width''']) ,       data_format=snake_case_ ,       **snake_case_						)






					def A      (				self ,       snake_case_ ,       snake_case_ ,       snake_case_ = None ,       **snake_case_ ,       )   ->			int:







								'''simple docstring'''

								return rescale(snake_case_ ,       scale=snake_case_ ,       data_format=snake_case_ ,       **snake_case_						)






					def A      (				self ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ = None ,       **snake_case_ ,       )   ->			np.ndarray:







								'''simple docstring'''

								return normalize(snake_case_ ,       mean=snake_case_ ,       std=snake_case_ ,       data_format=snake_case_ ,       **snake_case_						)






					def A      (				self ,       snake_case_ ,       snake_case_ = None ,       snake_case_ = None ,       snake_case_ = None ,       snake_case_ = None ,       snake_case_ = None ,       snake_case_ = None ,       snake_case_ = None ,       snake_case_ = None ,       snake_case_ = None ,       snake_case_ = None ,       snake_case_ = ChannelDimension.FIRST ,       )   ->			np.ndarray:







								'''simple docstring'''

								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.'''						)

								# All transformations expect numpy arrays.
								__lowercase 					=   to_numpy_array(snake_case_						)

								if do_resize:
											__lowercase 					=   self.resize(image=snake_case_ ,       size=snake_case_ ,       resample=snake_case_						)

								if do_center_crop:
											__lowercase 					=   self.center_crop(snake_case_ ,       size=snake_case_						)

								if do_rescale:
											__lowercase 					=   self.rescale(image=snake_case_ ,       scale=snake_case_						)

								if do_normalize:
											__lowercase 					=   self.normalize(image=snake_case_ ,       mean=snake_case_ ,       std=snake_case_						)

								__lowercase 					=   to_channel_dimension_format(snake_case_ ,       snake_case_						)
								return image






					def A      (				self ,       snake_case_ ,       snake_case_ = None ,       snake_case_ = None ,       snake_case_ = None ,       snake_case_ = None ,       snake_case_ = None ,       snake_case_ = None ,       snake_case_ = None ,       snake_case_ = None ,       snake_case_ = None ,       snake_case_ = None ,       snake_case_ = None ,       snake_case_ = ChannelDimension.FIRST ,       **snake_case_ ,       )   ->			PIL.Image.Image:







								'''simple docstring'''

								__lowercase 					=   do_resize if do_resize is not None else self.do_resize
								__lowercase 					=   resample if resample is not None else self.resample
								__lowercase 					=   do_center_crop if do_center_crop is not None else self.do_center_crop
								__lowercase 					=   do_rescale if do_rescale is not None else self.do_rescale
								__lowercase 					=   rescale_factor if rescale_factor is not None else self.rescale_factor
								__lowercase 					=   do_normalize if do_normalize is not None else self.do_normalize
								__lowercase 					=   image_mean if image_mean is not None else self.image_mean
								__lowercase 					=   image_std if image_std is not None else self.image_std

								__lowercase 					=   size if size is not None else self.size
								__lowercase 					=   get_size_dict(snake_case_ ,       default_to_square=snake_case_						)
								__lowercase 					=   crop_size if crop_size is not None else self.crop_size
								__lowercase 					=   get_size_dict(snake_case_ ,       param_name='''crop_size'''						)

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

								__lowercase 					=   make_batched(snake_case_						)

								__lowercase 					=   [
								    [
								        self._preprocess_image(
								            image=snake_case_ ,       do_resize=snake_case_ ,       size=snake_case_ ,       resample=snake_case_ ,       do_center_crop=snake_case_ ,       crop_size=snake_case_ ,       do_rescale=snake_case_ ,       rescale_factor=snake_case_ ,       do_normalize=snake_case_ ,       image_mean=snake_case_ ,       image_std=snake_case_ ,       data_format=snake_case_ ,       )
								        for img in video
								    ]
								    for video in videos
								]

								__lowercase 					=   {'''pixel_values''': videos}
								return BatchFeature(data=snake_case_ ,       tensor_type=snake_case_						)






from dataclasses import dataclass
from typing import List, Optional, Union

import numpy as np
import PIL

from ...utils import BaseOutput, OptionalDependencyNotAvailable, is_torch_available, is_transformers_available
from .timesteps import (
    fastaa_timesteps,
    smartaa_timesteps,
    smartaa_timesteps,
    smartaaa_timesteps,
    smartaaa_timesteps,
    superaa_timesteps,
    superaa_timesteps,
    superaaa_timesteps,
)
@dataclass
class 	lowerCamelCase_       (				lowerCAmelCase__				):



					'''simple docstring'''







					__UpperCAmelCase            =				42
					__UpperCAmelCase            =				42
					__UpperCAmelCase            =				42


try:
	if not (is_transformers_available() and is_torch_available()):
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	from ...utils.dummy_torch_and_transformers_objects import *  # noqa F403
else:
	from .pipeline_if import IFPipeline
	from .pipeline_if_imgaimg import IFImgaImgPipeline
	from .pipeline_if_imgaimg_superresolution import IFImgaImgSuperResolutionPipeline
	from .pipeline_if_inpainting import IFInpaintingPipeline
	from .pipeline_if_inpainting_superresolution import IFInpaintingSuperResolutionPipeline
	from .pipeline_if_superresolution import IFSuperResolutionPipeline
	from .safety_checker import IFSafetyChecker
	from .watermark import IFWatermarker


