code: import unittest
  
  import numpy as np
  from datasets import load_dataset
  
  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 SegformerImageProcessor
  
  
  class _lowercase					(       unittest.TestCase						):
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  
  							def __init__(    self     ,   UpperCAmelCase     ,   UpperCAmelCase=7     ,   UpperCAmelCase=3     ,   UpperCAmelCase=30     ,   UpperCAmelCase=400     ,   UpperCAmelCase=True     ,   UpperCAmelCase=None     ,   UpperCAmelCase=True     ,   UpperCAmelCase=[0.5, 0.5, 0.5]     ,   UpperCAmelCase=[0.5, 0.5, 0.5]     ,   UpperCAmelCase=False     ,   ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				=	size if size is not None else {"""height""": 30, """width""": 30}
  														_lowercase				=	parent
  														_lowercase				=	batch_size
  														_lowercase				=	num_channels
  														_lowercase				=	min_resolution
  														_lowercase				=	max_resolution
  														_lowercase				=	do_resize
  														_lowercase				=	size
  														_lowercase				=	do_normalize
  														_lowercase				=	image_mean
  														_lowercase				=	image_std
  														_lowercase				=	do_reduce_labels
  
  
  
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														return {
  														    "do_resize": self.do_resize,
  														    "size": self.size,
  														    "do_normalize": self.do_normalize,
  														    "image_mean": self.image_mean,
  														    "image_std": self.image_std,
  														    "do_reduce_labels": self.do_reduce_labels,
  														}
  
  
  
  
  
  
  def 					__lowerCAmelCase			(  ):
  
  
  
  							"""simple docstring"""
  
  
  							_lowercase				=	load_dataset("""hf-internal-testing/fixtures_ade20k""" ,split="""test"""					)
  
  							_lowercase				=	Image.open(dataset[0]["""file"""]					)
  							_lowercase				=	Image.open(dataset[1]["""file"""]					)
  
  							return image, map
  
  
  def 					__lowerCAmelCase			(  ):
  
  
  
  							"""simple docstring"""
  
  
  							_lowercase				=	load_dataset("""hf-internal-testing/fixtures_ade20k""" ,split="""test"""					)
  
  							_lowercase				=	Image.open(dataset[0]["""file"""]					)
  							_lowercase				=	Image.open(dataset[1]["""file"""]					)
  							_lowercase				=	Image.open(dataset[2]["""file"""]					)
  							_lowercase				=	Image.open(dataset[3]["""file"""]					)
  
  							return [imagea, imagea], [mapa, mapa]
  
  
  
  
  
  
  
  @require_torch
  @require_vision
  class _lowercase					(       _UpperCAmelCase   ,				unittest.TestCase						):
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  
  							lowerCAmelCase__       =					SegformerImageProcessor if is_vision_available() else None
  
  
  
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				=	SegformerImageProcessingTester(self  )
  
  
  
  							@property
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														return self.image_processor_tester.prepare_image_processor_dict()
  
  
  
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				=	self.image_processing_class(**self.image_processor_dict  )
  														self.assertTrue(hasattr(UpperCAmelCase     ,   """do_resize"""  )  )
  														self.assertTrue(hasattr(UpperCAmelCase     ,   """size"""  )  )
  														self.assertTrue(hasattr(UpperCAmelCase     ,   """do_normalize"""  )  )
  														self.assertTrue(hasattr(UpperCAmelCase     ,   """image_mean"""  )  )
  														self.assertTrue(hasattr(UpperCAmelCase     ,   """image_std"""  )  )
  														self.assertTrue(hasattr(UpperCAmelCase     ,   """do_reduce_labels"""  )  )
  
  
  
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				=	self.image_processing_class.from_dict(self.image_processor_dict  )
  														self.assertEqual(image_processor.size     ,   {"""height""": 30, """width""": 30}  )
  														self.assertEqual(image_processor.do_reduce_labels     ,   UpperCAmelCase  )
  
  														_lowercase				=	self.image_processing_class.from_dict(self.image_processor_dict     ,   size=42     ,   reduce_labels=UpperCAmelCase  )
  														self.assertEqual(image_processor.size     ,   {"""height""": 42, """width""": 42}  )
  														self.assertEqual(image_processor.do_reduce_labels     ,   UpperCAmelCase  )
  
  
  
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														pass
  
  
  
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				=	self.image_processing_class(**self.image_processor_dict  )
  														# create random PIL images
  														_lowercase				=	prepare_image_inputs(self.image_processor_tester     ,   equal_resolution=UpperCAmelCase  )
  														for image in image_inputs:
  																					self.assertIsInstance(UpperCAmelCase     ,   Image.Image  )
  
  														# Test not batched input
  														_lowercase				=	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
  														_lowercase				=	image_processing(UpperCAmelCase     ,   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     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				=	self.image_processing_class(**self.image_processor_dict  )
  														# create random numpy tensors
  														_lowercase				=	prepare_image_inputs(self.image_processor_tester     ,   equal_resolution=UpperCAmelCase     ,   numpify=UpperCAmelCase  )
  														for image in image_inputs:
  																					self.assertIsInstance(UpperCAmelCase     ,   np.ndarray  )
  
  														# Test not batched input
  														_lowercase				=	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
  														_lowercase				=	image_processing(UpperCAmelCase     ,   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     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				=	self.image_processing_class(**self.image_processor_dict  )
  														# create random PyTorch tensors
  														_lowercase				=	prepare_image_inputs(self.image_processor_tester     ,   equal_resolution=UpperCAmelCase     ,   torchify=UpperCAmelCase  )
  														for image in image_inputs:
  																					self.assertIsInstance(UpperCAmelCase     ,   torch.Tensor  )
  
  														# Test not batched input
  														_lowercase				=	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
  														_lowercase				=	image_processing(UpperCAmelCase     ,   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     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				=	self.image_processing_class(**self.image_processor_dict  )
  														# create random PyTorch tensors
  														_lowercase				=	prepare_image_inputs(self.image_processor_tester     ,   equal_resolution=UpperCAmelCase     ,   torchify=UpperCAmelCase  )
  														_lowercase				=	[]
  														for image in image_inputs:
  																					self.assertIsInstance(UpperCAmelCase     ,   torch.Tensor  )
  																					maps.append(torch.zeros(image.shape[-2:]  ).long()  )
  
  														# Test not batched input
  														_lowercase				=	image_processing(image_inputs[0]     ,   maps[0]     ,   return_tensors="""pt"""  )
  														self.assertEqual(
  														    encoding["""pixel_values"""].shape     ,   (
  														        1,
  														        self.image_processor_tester.num_channels,
  														        self.image_processor_tester.size["""height"""],
  														        self.image_processor_tester.size["""width"""],
  														    )     ,   )
  														self.assertEqual(
  														    encoding["""labels"""].shape     ,   (
  														        1,
  														        self.image_processor_tester.size["""height"""],
  														        self.image_processor_tester.size["""width"""],
  														    )     ,   )
  														self.assertEqual(encoding["""labels"""].dtype     ,   torch.long  )
  														self.assertTrue(encoding["""labels"""].min().item() >= 0  )
  														self.assertTrue(encoding["""labels"""].max().item() <= 255  )
  
  														# Test batched
  														_lowercase				=	image_processing(UpperCAmelCase     ,   UpperCAmelCase     ,   return_tensors="""pt"""  )
  														self.assertEqual(
  														    encoding["""pixel_values"""].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"""],
  														    )     ,   )
  														self.assertEqual(
  														    encoding["""labels"""].shape     ,   (
  														        self.image_processor_tester.batch_size,
  														        self.image_processor_tester.size["""height"""],
  														        self.image_processor_tester.size["""width"""],
  														    )     ,   )
  														self.assertEqual(encoding["""labels"""].dtype     ,   torch.long  )
  														self.assertTrue(encoding["""labels"""].min().item() >= 0  )
  														self.assertTrue(encoding["""labels"""].max().item() <= 255  )
  
  														# Test not batched input (PIL images)
  														_lowercase				,       _lowercase				=	prepare_semantic_single_inputs()
  
  														_lowercase				=	image_processing(UpperCAmelCase     ,   UpperCAmelCase     ,   return_tensors="""pt"""  )
  														self.assertEqual(
  														    encoding["""pixel_values"""].shape     ,   (
  														        1,
  														        self.image_processor_tester.num_channels,
  														        self.image_processor_tester.size["""height"""],
  														        self.image_processor_tester.size["""width"""],
  														    )     ,   )
  														self.assertEqual(
  														    encoding["""labels"""].shape     ,   (
  														        1,
  														        self.image_processor_tester.size["""height"""],
  														        self.image_processor_tester.size["""width"""],
  														    )     ,   )
  														self.assertEqual(encoding["""labels"""].dtype     ,   torch.long  )
  														self.assertTrue(encoding["""labels"""].min().item() >= 0  )
  														self.assertTrue(encoding["""labels"""].max().item() <= 255  )
  
  														# Test batched input (PIL images)
  														_lowercase				,       _lowercase				=	prepare_semantic_batch_inputs()
  
  														_lowercase				=	image_processing(UpperCAmelCase     ,   UpperCAmelCase     ,   return_tensors="""pt"""  )
  														self.assertEqual(
  														    encoding["""pixel_values"""].shape     ,   (
  														        2,
  														        self.image_processor_tester.num_channels,
  														        self.image_processor_tester.size["""height"""],
  														        self.image_processor_tester.size["""width"""],
  														    )     ,   )
  														self.assertEqual(
  														    encoding["""labels"""].shape     ,   (
  														        2,
  														        self.image_processor_tester.size["""height"""],
  														        self.image_processor_tester.size["""width"""],
  														    )     ,   )
  														self.assertEqual(encoding["""labels"""].dtype     ,   torch.long  )
  														self.assertTrue(encoding["""labels"""].min().item() >= 0  )
  														self.assertTrue(encoding["""labels"""].max().item() <= 255  )
  
  
  
  							def     _UpperCAmelCase       (    self  ):
  
  
  
  
  
  
  
  														'''simple docstring'''
  
  
  
  
  
  
  														_lowercase				=	self.image_processing_class(**self.image_processor_dict  )
  
  														# ADE20k has 150 classes, and the background is included, so labels should be between 0 and 150
  														_lowercase				,       _lowercase				=	prepare_semantic_single_inputs()
  														_lowercase				=	image_processing(UpperCAmelCase     ,   UpperCAmelCase     ,   return_tensors="""pt"""  )
  														self.assertTrue(encoding["""labels"""].min().item() >= 0  )
  														self.assertTrue(encoding["""labels"""].max().item() <= 150  )
  
  														_lowercase				=	True
  														_lowercase				=	image_processing(UpperCAmelCase     ,   UpperCAmelCase     ,   return_tensors="""pt"""  )
  														self.assertTrue(encoding["""labels"""].min().item() >= 0  )
  														self.assertTrue(encoding["""labels"""].max().item() <= 255  )
  
  
  
style_context: def 					__lowerCAmelCase			(  _A					):
  
  
  
  							"""simple docstring"""
  
  
  							if len(_A					) <= 1:
  														return data
  							else:
  														return [
  														    *quick_sort([e for e in data[1:] if e <= data[0]]					),
  														    data[0],
  														    *quick_sort([e for e in data[1:] if e > data[0]]					),
  														]
  
  
  if __name__ == "__main__":
  				import doctest
  
  				doctest.testmod()
  
  
  