






'''simple docstring'''




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      _UpperCAmelCase    (  unittest.TestCase		):




   """simple docstring"""

   def __init__(	self				:			int   ,   __UpperCAmelCase				:			Dict   ,   __UpperCAmelCase				:			str=7   ,   __UpperCAmelCase				:			List[str]=3   ,   __UpperCAmelCase				:			Any=30   ,   __UpperCAmelCase				:			int=400   ,   __UpperCAmelCase				:			Tuple=True   ,   __UpperCAmelCase				:			Optional[Any]=None   ,   __UpperCAmelCase				:			Tuple=True   ,   __UpperCAmelCase				:			Dict=[0.5, 0.5, 0.5]   ,   __UpperCAmelCase				:			Union[str, Any]=[0.5, 0.5, 0.5]   ,   __UpperCAmelCase				:			Union[str, Any]=False   ,   ):





         '''simple docstring'''





         _A      =			size if size is not None else {"height": 30, "width": 30}
         _A      =			parent
         _A      =			batch_size
         _A      =			num_channels
         _A      =			min_resolution
         _A      =			max_resolution
         _A      =			do_resize
         _A      =			size
         _A      =			do_normalize
         _A      =			image_mean
         _A      =			image_std
         _A      =			do_reduce_labels

   def 		lowerCAmelCase				(	self				:			List[str]	):





         '''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       __lowercase		(    ) ->		List[Any]:

      '''simple docstring'''


      _A      =			load_dataset("hf-internal-testing/fixtures_ade20k"     ,						split="test" )

      _A      =			Image.open(dataset[0]["file"] )
      _A      =			Image.open(dataset[1]["file"] )

      return image, map

def       __lowercase		(    ) ->		Tuple:

      '''simple docstring'''


      _A      =			load_dataset("hf-internal-testing/fixtures_ade20k"     ,						split="test" )

      _A      =			Image.open(dataset[0]["file"] )
      _A      =			Image.open(dataset[1]["file"] )
      _A      =			Image.open(dataset[2]["file"] )
      _A      =			Image.open(dataset[3]["file"] )

      return [imagea, imagea], [mapa, mapa]


@require_torch
@require_vision
class      _UpperCAmelCase    (  snake_case_							,					unittest.TestCase		):




   """simple docstring"""

   snake_case					       =		SegformerImageProcessor if is_vision_available() else None

   def 		lowerCAmelCase				(	self				:			int	):





         '''simple docstring'''





         _A      =			SegformerImageProcessingTester(self	)

   @property
   def 		lowerCAmelCase				(	self				:			Optional[int]	):





         '''simple docstring'''





         return self.image_processor_tester.prepare_image_processor_dict()

   def 		lowerCAmelCase				(	self				:			List[Any]	):





         '''simple docstring'''





         _A      =			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 		lowerCAmelCase				(	self				:			Union[str, Any]	):





         '''simple docstring'''





         _A      =			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	)

         _A      =			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 		lowerCAmelCase				(	self				:			Union[str, Any]	):





         '''simple docstring'''





         pass

   def 		lowerCAmelCase				(	self				:			Optional[Any]	):





         '''simple docstring'''





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

         # Test not batched input
         _A      =			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
         _A      =			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 		lowerCAmelCase				(	self				:			Optional[Any]	):





         '''simple docstring'''





         _A      =			self.image_processing_class(**self.image_processor_dict	)
         # create random numpy tensors
         _A      =			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
         _A      =			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
         _A      =			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 		lowerCAmelCase				(	self				:			str	):





         '''simple docstring'''





         _A      =			self.image_processing_class(**self.image_processor_dict	)
         # create random PyTorch tensors
         _A      =			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
         _A      =			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
         _A      =			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 		lowerCAmelCase				(	self				:			Tuple	):





         '''simple docstring'''





         _A      =			self.image_processing_class(**self.image_processor_dict	)
         # create random PyTorch tensors
         _A      =			prepare_image_inputs(self.image_processor_tester   ,   equal_resolution=__UpperCAmelCase   ,   torchify=__UpperCAmelCase	)
         _A      =			[]
         for image in image_inputs:
               self.assertIsInstance(__UpperCAmelCase   ,   torch.Tensor	)
               maps.append(torch.zeros(image.shape[-2:]	).long()	)

         # Test not batched input
         _A      =			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
         _A      =			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)
         _A  ,			_A      =			prepare_semantic_single_inputs()

         _A      =			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)
         _A  ,			_A      =			prepare_semantic_batch_inputs()

         _A      =			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 		lowerCAmelCase				(	self				:			str	):





         '''simple docstring'''





         _A      =			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
         _A  ,			_A      =			prepare_semantic_single_inputs()
         _A      =			image_processing(__UpperCAmelCase   ,   __UpperCAmelCase   ,   return_tensors="pt"	)
         self.assertTrue(encoding["labels"].min().item() >= 0	)
         self.assertTrue(encoding["labels"].max().item() <= 150	)

         _A      =			True
         _A      =			image_processing(__UpperCAmelCase   ,   __UpperCAmelCase   ,   return_tensors="pt"	)
         self.assertTrue(encoding["labels"].min().item() >= 0	)
         self.assertTrue(encoding["labels"].max().item() <= 255	)













'''simple docstring'''




def       __lowercase		(    __lowercase ) ->		int:

      '''simple docstring'''


      _A      =			str(__lowercase ).strip()
      if not bin_string:
            raise ValueError("Empty string was passed to the function" )
      _A      =			bin_string[0] == "-"
      if is_negative:
            _A      =			bin_string[1:]
      if not all(char in "01" for char in bin_string ):
            raise ValueError("Non-binary value was passed to the function" )
      _A      =			0
      for char in bin_string:
            _A      =			2 * decimal_number + int(__lowercase )
      return -decimal_number if is_negative else decimal_number


if __name__ == "__main__":
    from doctest import testmod

    testmod()





