





from typing import Dict, List, Optional, Tuple, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    center_crop,
    flip_channel_order,
    get_resize_output_image_size,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_torch_available, is_torch_tensor, is_vision_available, logging


if is_vision_available():
					import PIL

if is_torch_available():
					import torch


UpperCamelCase__											= logging.get_logger(__name__)

class        __SCREAMING_SNAKE_CASE					(     SCREAMING_SNAKE_CASE__       ):
							snake_case     :      int						     =       ["""pixel_values"""]






							def __init__(						self  , __lowerCAmelCase = True  , __lowerCAmelCase = None  , __lowerCAmelCase = PILImageResampling.BILINEAR  , __lowerCAmelCase = True  , __lowerCAmelCase = 1 / 255  , __lowerCAmelCase = True  , __lowerCAmelCase = None  , __lowerCAmelCase = True  , **__lowerCAmelCase  , ):
														super().__init__(**snake_case__  )
														UpperCamelCase__				     =			size if size is not None else {"shortest_edge": 224}
														UpperCamelCase__				     =			get_size_dict(snake_case__  , default_to_square=snake_case__  )
														UpperCamelCase__				     =			crop_size if crop_size is not None else {"height": 256, "width": 256}
														UpperCamelCase__				     =			get_size_dict(snake_case__  , param_name="""crop_size"""  )

														UpperCamelCase__				     =			do_resize
														UpperCamelCase__				     =			size
														UpperCamelCase__				     =			resample
														UpperCamelCase__				     =			do_rescale
														UpperCamelCase__				     =			rescale_factor
														UpperCamelCase__				     =			do_center_crop
														UpperCamelCase__				     =			crop_size
														UpperCamelCase__				     =			do_flip_channel_order






							def 				_lowerCamelCase		(						self  , __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase = PIL.Image.BILINEAR  , __lowerCAmelCase = None  , **__lowerCAmelCase  , ):
														UpperCamelCase__				     =			get_size_dict(snake_case__  , default_to_square=snake_case__  )
														if "shortest_edge" not in size:
																					raise ValueError(f"""The `size` dictionary must contain the key `shortest_edge`. Got {size.keys()}"""  )
														UpperCamelCase__				     =			get_resize_output_image_size(snake_case__  , size=size["""shortest_edge"""]  , default_to_square=snake_case__  )
														return resize(snake_case__  , size=snake_case__  , resample=snake_case__  , data_format=snake_case__  , **snake_case__  )






							def 				_lowerCamelCase		(						self  , __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase = None  , **__lowerCAmelCase  , ):
														UpperCamelCase__				     =			get_size_dict(snake_case__  )
														if "height" not in size or "width" not in size:
																					raise ValueError(f"""The `size` dictionary must contain the keys `height` and `width`. Got {size.keys()}"""  )
														return center_crop(snake_case__  , size=(size["""height"""], size["""width"""])  , data_format=snake_case__  , **snake_case__  )






							def 				_lowerCamelCase		(						self  , __lowerCAmelCase  , __lowerCAmelCase  , __lowerCAmelCase = None  , **__lowerCAmelCase  , ):
														return rescale(snake_case__  , scale=snake_case__  , data_format=snake_case__  , **snake_case__  )






							def 				_lowerCamelCase		(						self  , __lowerCAmelCase  , __lowerCAmelCase = None  ):
														return flip_channel_order(snake_case__  , data_format=snake_case__  )






							def 				_lowerCamelCase		(						self  , __lowerCAmelCase  , __lowerCAmelCase = None  , __lowerCAmelCase = None  , __lowerCAmelCase = None  , __lowerCAmelCase = None  , __lowerCAmelCase = None  , __lowerCAmelCase = None  , __lowerCAmelCase = None  , __lowerCAmelCase = None  , __lowerCAmelCase = None  , __lowerCAmelCase = ChannelDimension.FIRST  , **__lowerCAmelCase  , ):
														UpperCamelCase__				     =			do_resize if do_resize is not None else self.do_resize
														UpperCamelCase__				     =			resample if resample is not None else self.resample
														UpperCamelCase__				     =			do_rescale if do_rescale is not None else self.do_rescale
														UpperCamelCase__				     =			rescale_factor if rescale_factor is not None else self.rescale_factor
														UpperCamelCase__				     =			do_center_crop if do_center_crop is not None else self.do_center_crop
														UpperCamelCase__				     =			(
														    do_flip_channel_order if do_flip_channel_order is not None else self.do_flip_channel_order
														)

														UpperCamelCase__				     =			size if size is not None else self.size
														UpperCamelCase__				     =			get_size_dict(snake_case__  , default_to_square=snake_case__  )
														UpperCamelCase__				     =			crop_size if crop_size is not None else self.crop_size
														UpperCamelCase__				     =			get_size_dict(snake_case__  , param_name="""crop_size"""  )

														UpperCamelCase__				     =			make_list_of_images(snake_case__  )

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

														if do_resize and size is None:
																					raise ValueError("""Size must be specified if do_resize is True."""  )

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

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

														# All transformations expect numpy arrays.
														UpperCamelCase__				     =			[to_numpy_array(snake_case__  ) for image in images]

														if do_resize:
																					UpperCamelCase__				     =			[self.resize(image=snake_case__  , size=snake_case__  , resample=snake_case__  ) for image in images]

														if do_center_crop:
																					UpperCamelCase__				     =			[self.center_crop(image=snake_case__  , size=snake_case__  ) for image in images]

														if do_rescale:
																					UpperCamelCase__				     =			[self.rescale(image=snake_case__  , scale=snake_case__  ) for image in images]

														# the pretrained checkpoints assume images are BGR, not RGB
														if do_flip_channel_order:
																					UpperCamelCase__				     =			[self.flip_channel_order(image=snake_case__  ) for image in images]

														UpperCamelCase__				     =			[to_channel_dimension_format(snake_case__  , snake_case__  ) for image in images]

														UpperCamelCase__				     =			{"pixel_values": images}
														return BatchFeature(data=snake_case__  , tensor_type=snake_case__  )







							def 				_lowerCamelCase		(						self  , __lowerCAmelCase  , __lowerCAmelCase = None  ):
														UpperCamelCase__				     =			outputs.logits

														# Resize logits and compute semantic segmentation maps
														if target_sizes is not None:
																					if len(snake_case__  ) != len(snake_case__  ):
																												raise ValueError(
																												    """Make sure that you pass in as many target sizes as the batch dimension of the logits"""  )

																					if is_torch_tensor(snake_case__  ):
																												UpperCamelCase__				     =			target_sizes.numpy()

																					UpperCamelCase__				     =			[]

																					for idx in range(len(snake_case__  )  ):
																												UpperCamelCase__				     =			torch.nn.functional.interpolate(
																												    logits[idx].unsqueeze(dim=0  )  , size=target_sizes[idx]  , mode="""bilinear"""  , align_corners=snake_case__  )
																												UpperCamelCase__				     =			resized_logits[0].argmax(dim=0  )
																												semantic_segmentation.append(snake_case__  )
														else:
																					UpperCamelCase__				     =			logits.argmax(dim=1  )
																					UpperCamelCase__				     =			[semantic_segmentation[i] for i in range(semantic_segmentation.shape[0]  )]

														return semantic_segmentation









import inspect
import unittest

class        __SCREAMING_SNAKE_CASE					(     unittest.TestCase       ):






							def 				_lowerCamelCase		(						self  ):
														try:
																					import diffusers  # noqa: F401
														except ImportError:
																					assert False







							def 				_lowerCamelCase		(						self  ):
														import diffusers
														from diffusers.dependency_versions_table import deps

														UpperCamelCase__				     =			inspect.getmembers(__lowerCAmelCase  , inspect.isclass  )

														for cls_name, cls_module in all_classes:
																					if "dummy_" in cls_module.__module__:
																												for backend in cls_module._backends:
																																			if backend == "k_diffusion":
																																										UpperCamelCase__				     =			"""k-diffusion"""
																																			elif backend == "invisible_watermark":
																																										UpperCamelCase__				     =			"""invisible-watermark"""
																																			assert backend in deps, f"""{backend} is not in the deps table!"""




