




"""simple docstring"""







import os
import time
import warnings
from dataclasses import dataclass, field
from enum import Enum
from typing import List, Optional, Union

import torch
from filelock import FileLock
from torch.utils.data import Dataset

from ...tokenization_utils_base import PreTrainedTokenizerBase
from ...utils import logging
from ..processors.glue import glue_convert_examples_to_features, glue_output_modes, glue_processors
from ..processors.utils import InputFeatures


SCREAMING_SNAKE_CASE_	     =       logging.get_logger(__name__)

@dataclass
class 				snake_case_			:







   """simple docstring"""




   A_				      =       field(metadata={'''help''': '''The name of the task to train on: ''' + ''', '''.join(glue_processors.keys()			)}			)
   A_				      =       field(
       metadata={'''help''': '''The input data dir. Should contain the .tsv files (or other data files) for the task.'''}			)
   A_				      =       field(
       default=128	, metadata={
           '''help''': (
               '''The maximum total input sequence length after tokenization. Sequences longer '''
               '''than this will be truncated, sequences shorter will be padded.'''
           )
       }	, )
   A_				      =       field(
       default=lowerCamelCase_	, metadata={'''help''': '''Overwrite the cached training and evaluation sets'''}			)







   def   UpperCAmelCase__			(		self)				->   int:
       UpperCamelCase              =	self.task_name.lower()

class 				snake_case_			(					lowerCamelCase_			):







   """simple docstring"""




   A_				      =       '''train'''
   A_				      =       '''dev'''
   A_				      =       '''test'''

class 				snake_case_			(					lowerCamelCase_			):







   """simple docstring"""




   A_				      =       42
   A_				      =       42
   A_				      =       42







   def __init__(		self       ,					lowerCamelCase_       ,					lowerCamelCase_       ,					lowerCamelCase_ = None       ,					lowerCamelCase_ = Split.train       ,					lowerCamelCase_ = None       ,					)				->   int:
       warnings.warn(
           '''This dataset will be removed from the library soon, preprocessing should be handled with the 🤗 Datasets '''
           '''library. You can have a look at this example script for pointers: '''
           '''https://github.com/huggingface/transformers/blob/main/examples/pytorch/text-classification/run_glue.py'''       ,					lowerCamelCase_       ,					)
       UpperCamelCase              =	args
       UpperCamelCase              =	glue_processors[args.task_name]()
       UpperCamelCase              =	glue_output_modes[args.task_name]
       if isinstance(lowerCamelCase_       ,					lowerCamelCase_):
           try:
               UpperCamelCase              =	Split[mode]
           except KeyError:
               raise KeyError('''mode is not a valid split name''')
        # Load data features from cache or dataset file
       UpperCamelCase              =	os.path.join(
           cache_dir if cache_dir is not None else args.data_dir       ,					F'cached_{mode.value}_{tokenizer.__class__.__name__}_{args.max_seq_length}_{args.task_name}'       ,					)
       UpperCamelCase              =	self.processor.get_labels()
       if args.task_name in ["mnli", "mnli-mm"] and tokenizer.__class__.__name__ in (
           "RobertaTokenizer",
           "RobertaTokenizerFast",
           "XLMRobertaTokenizer",
           "BartTokenizer",
           "BartTokenizerFast",
       ):
           # HACK(label indices are swapped in RoBERTa pretrained model)
           UpperCamelCase       ,	UpperCamelCase              =	label_list[2], label_list[1]
       UpperCamelCase              =	label_list

       # Make sure only the first process in distributed training processes the dataset,
       # and the others will use the cache.
       UpperCamelCase              =	cached_features_file + '''.lock'''
       with FileLock(lowerCamelCase_):
           if os.path.exists(lowerCamelCase_) and not args.overwrite_cache:
               UpperCamelCase              =	time.time()
               UpperCamelCase              =	torch.load(lowerCamelCase_)
               logger.info(
                   F'Loading features from cached file {cached_features_file} [took %.3f s]'       ,					time.time() - start)
           else:
               logger.info(F'Creating features from dataset file at {args.data_dir}')

               if mode == Split.dev:
                   UpperCamelCase              =	self.processor.get_dev_examples(args.data_dir)
               elif mode == Split.test:
                   UpperCamelCase              =	self.processor.get_test_examples(args.data_dir)
               else:
                   UpperCamelCase              =	self.processor.get_train_examples(args.data_dir)
               if limit_length is not None:
                   UpperCamelCase              =	examples[:limit_length]
               UpperCamelCase              =	glue_convert_examples_to_features(
                   lowerCamelCase_       ,					lowerCamelCase_       ,					max_length=args.max_seq_length       ,					label_list=lowerCamelCase_       ,					output_mode=self.output_mode       ,					)
               UpperCamelCase              =	time.time()
               torch.save(self.features       ,					lowerCamelCase_)
               # ^ This seems to take a lot of time so I want to investigate why and how we can improve.
               logger.info(
                   F'Saving features into cached file {cached_features_file} [took {time.time() - start:.3f} s]')







   def __len__(		self)				->   Any:
       return len(self.features)







   def __getitem__(		self       ,					lowerCamelCase_)				->   InputFeatures:
       return self.features[i]







   def   UpperCAmelCase__			(		self)				->   List[Any]:
       return self.label_list







import json
import unittest

import numpy as np
from huggingface_hub import hf_hub_download

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 transformers import OneFormerImageProcessor
    from transformers.models.oneformer.image_processing_oneformer import binary_mask_to_rle
    from transformers.models.oneformer.modeling_oneformer import OneFormerForUniversalSegmentationOutput

if is_vision_available():
  from PIL import Image




def       _SCREAMING_SNAKE_CASE (							__snake_case   ,      __snake_case="shi-labs/oneformer_demo" )				->						Any:
       with open(hf_hub_download(__snake_case   ,      __snake_case   ,      repo_type="""dataset""" )   ,      """r""" ) as f:
              _UpperCAmelCase							=    json.load(__snake_case )
       _UpperCAmelCase							=    {}
       _UpperCAmelCase							=    []
       _UpperCAmelCase							=    []
       for key, info in class_info.items():
              _UpperCAmelCase							=    info["""name"""]
              class_names.append(info["""name"""] )
              if info["isthing"]:
                     thing_ids.append(int(__snake_case ) )
       _UpperCAmelCase							=    thing_ids
       _UpperCAmelCase							=    class_names
       return metadata
class 		SCREAMING_SNAKE_CASE__	(  unittest.TestCase     ):

  '''simple docstring'''







  def __init__(      self		:			Optional[Any]       ,				lowerCamelCase		:			Optional[Any]       ,				lowerCamelCase		:			List[Any]=7       ,				lowerCamelCase		:			str=3       ,				lowerCamelCase		:			Union[str, Any]=30       ,				lowerCamelCase		:			Optional[int]=400       ,				lowerCamelCase		:			Union[str, Any]=None       ,				lowerCamelCase		:			int=True       ,				lowerCamelCase		:			List[str]=True       ,				lowerCamelCase		:			Tuple=[0.5, 0.5, 0.5]       ,				lowerCamelCase		:			Tuple=[0.5, 0.5, 0.5]       ,				lowerCamelCase		:			Tuple=10       ,				lowerCamelCase		:			str=False       ,				lowerCamelCase		:			Union[str, Any]=255       ,				lowerCamelCase		:			Tuple="shi-labs/oneformer_demo"       ,				lowerCamelCase		:			Tuple="ade20k_panoptic.json"       ,				lowerCamelCase		:			Optional[Any]=10       ,				)						->	Optional[int]:


         """simple docstring"""
         _UpperCAmelCase							=    parent
         _UpperCAmelCase							=    batch_size
         _UpperCAmelCase							=    num_channels
         _UpperCAmelCase							=    min_resolution
         _UpperCAmelCase							=    max_resolution
         _UpperCAmelCase							=    do_resize
         _UpperCAmelCase							=    {"""shortest_edge""": 32, """longest_edge""": 1333} if size is None else size
         _UpperCAmelCase							=    do_normalize
         _UpperCAmelCase							=    image_mean
         _UpperCAmelCase							=    image_std
         _UpperCAmelCase							=    class_info_file
         _UpperCAmelCase							=    prepare_metadata(lowerCamelCase       ,				lowerCamelCase							)
         _UpperCAmelCase							=    num_text
         _UpperCAmelCase							=    repo_path

         # for the post_process_functions
         _UpperCAmelCase							=    2
         _UpperCAmelCase							=    10
         _UpperCAmelCase							=    10
         _UpperCAmelCase							=    3
         _UpperCAmelCase							=    4
         _UpperCAmelCase							=    num_labels
         _UpperCAmelCase							=    do_reduce_labels
         _UpperCAmelCase							=    ignore_index


  def  lowerCamelCase       (      self		:			int							)						->	Union[str, Any]:


         """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,
             "num_labels": self.num_labels,
             "do_reduce_labels": self.do_reduce_labels,
             "ignore_index": self.ignore_index,
             "class_info_file": self.class_info_file,
             "metadata": self.metadata,
             "num_text": self.num_text,
         }


  def  lowerCamelCase       (      self		:			Any       ,				lowerCamelCase		:			int       ,				lowerCamelCase		:			Tuple=False							)						->	Any:


         """simple docstring"""
         if not batched:
                _UpperCAmelCase							=    image_inputs[0]
                if isinstance(lowerCamelCase       ,				Image.Image							):
                       _UpperCAmelCase	,			_UpperCAmelCase							=    image.size
                else:
                       _UpperCAmelCase	,			_UpperCAmelCase							=    image.shape[1], image.shape[2]
                if w < h:
                       _UpperCAmelCase							=    int(self.size["""shortest_edge"""] * h / w							)
                       _UpperCAmelCase							=    self.size["""shortest_edge"""]
                elif w > h:
                       _UpperCAmelCase							=    self.size["""shortest_edge"""]
                       _UpperCAmelCase							=    int(self.size["""shortest_edge"""] * w / h							)
                else:
                       _UpperCAmelCase							=    self.size["""shortest_edge"""]
                       _UpperCAmelCase							=    self.size["""shortest_edge"""]

         else:
                _UpperCAmelCase							=    []
                for image in image_inputs:
                       _UpperCAmelCase	,			_UpperCAmelCase							=    self.get_expected_values([image]							)
                       expected_values.append((expected_height, expected_width)							)
                _UpperCAmelCase							=    max(lowerCamelCase       ,				key=lambda lowerCamelCase							: item[0]							)[0]
                _UpperCAmelCase							=    max(lowerCamelCase       ,				key=lambda lowerCamelCase							: item[1]							)[1]

         return expected_height, expected_width





  def  lowerCamelCase       (      self		:			str							)						->	Optional[int]:


         """simple docstring"""
         return OneFormerForUniversalSegmentationOutput(
             # +1 for null class
             class_queries_logits=torch.randn((self.batch_size, self.num_queries, self.num_classes + 1)							)       ,				masks_queries_logits=torch.randn((self.batch_size, self.num_queries, self.height, self.width)							)       ,				)



@require_torch
@require_vision
class 		SCREAMING_SNAKE_CASE__	(  UpperCAmelCase					,      unittest.TestCase     ):

  '''simple docstring'''







  _lowerCamelCase    =  OneFormerImageProcessor if (is_vision_available() and is_torch_available()) else None
  # only for test_image_processing_common.test_image_proc_to_json_string
  _lowerCamelCase    =  image_processing_class


  def  lowerCamelCase       (      self		:			Dict							)						->	Union[str, Any]:


         """simple docstring"""
         _UpperCAmelCase							=    OneFormerImageProcessorTester(self							)


  @property
  def  lowerCamelCase       (      self		:			Union[str, Any]							)						->	Dict:


         """simple docstring"""
         return self.image_processing_tester.prepare_image_processor_dict()


  def  lowerCamelCase       (      self		:			Optional[Any]							)						->	List[Any]:


         """simple docstring"""
         _UpperCAmelCase							=    self.image_processing_class(**self.image_processor_dict							)
         self.assertTrue(hasattr(lowerCamelCase       ,				"""image_mean"""							)							)
         self.assertTrue(hasattr(lowerCamelCase       ,				"""image_std"""							)							)
         self.assertTrue(hasattr(lowerCamelCase       ,				"""do_normalize"""							)							)
         self.assertTrue(hasattr(lowerCamelCase       ,				"""do_resize"""							)							)
         self.assertTrue(hasattr(lowerCamelCase       ,				"""size"""							)							)
         self.assertTrue(hasattr(lowerCamelCase       ,				"""ignore_index"""							)							)
         self.assertTrue(hasattr(lowerCamelCase       ,				"""class_info_file"""							)							)
         self.assertTrue(hasattr(lowerCamelCase       ,				"""num_text"""							)							)
         self.assertTrue(hasattr(lowerCamelCase       ,				"""repo_path"""							)							)
         self.assertTrue(hasattr(lowerCamelCase       ,				"""metadata"""							)							)
         self.assertTrue(hasattr(lowerCamelCase       ,				"""do_reduce_labels"""							)							)


  def  lowerCamelCase       (      self		:			Tuple							)						->	Any:


         """simple docstring"""
         pass


  def  lowerCamelCase       (      self		:			Optional[int]							)						->	Optional[int]:


         """simple docstring"""
         # Initialize image_processor
         _UpperCAmelCase							=    self.image_processing_class(**self.image_processor_dict							)
         # create random PIL images
         _UpperCAmelCase							=    prepare_image_inputs(self.image_processing_tester       ,				equal_resolution=lowerCamelCase							)
         for image in image_inputs:
                self.assertIsInstance(lowerCamelCase       ,				Image.Image							)

         # Test not batched input
         _UpperCAmelCase							=    image_processor(image_inputs[0]       ,				["""semantic"""]       ,				return_tensors="""pt"""							).pixel_values

         _UpperCAmelCase	,			_UpperCAmelCase							=    self.image_processing_tester.get_expected_values(lowerCamelCase							)

         self.assertEqual(
             encoded_images.shape       ,				(1, self.image_processing_tester.num_channels, expected_height, expected_width)       ,				)

         # Test batched
         _UpperCAmelCase	,			_UpperCAmelCase							=    self.image_processing_tester.get_expected_values(lowerCamelCase       ,				batched=lowerCamelCase							)

         _UpperCAmelCase							=    image_processor(
             lowerCamelCase       ,				["""semantic"""] * len(lowerCamelCase							)       ,				return_tensors="""pt"""							).pixel_values
         self.assertEqual(
             encoded_images.shape       ,				(
                 self.image_processing_tester.batch_size,
                 self.image_processing_tester.num_channels,
                 expected_height,
                 expected_width,
             )       ,				)


  def  lowerCamelCase       (      self		:			List[Any]							)						->	List[Any]:


         """simple docstring"""
         # Initialize image_processor
         _UpperCAmelCase							=    self.image_processing_class(**self.image_processor_dict							)
         # create random numpy tensors
         _UpperCAmelCase							=    prepare_image_inputs(self.image_processing_tester       ,				equal_resolution=lowerCamelCase       ,				numpify=lowerCamelCase							)
         for image in image_inputs:
                self.assertIsInstance(lowerCamelCase       ,				np.ndarray							)

         # Test not batched input
         _UpperCAmelCase							=    image_processor(image_inputs[0]       ,				["""semantic"""]       ,				return_tensors="""pt"""							).pixel_values

         _UpperCAmelCase	,			_UpperCAmelCase							=    self.image_processing_tester.get_expected_values(lowerCamelCase							)

         self.assertEqual(
             encoded_images.shape       ,				(1, self.image_processing_tester.num_channels, expected_height, expected_width)       ,				)

         # Test batched
         _UpperCAmelCase	,			_UpperCAmelCase							=    self.image_processing_tester.get_expected_values(lowerCamelCase       ,				batched=lowerCamelCase							)

         _UpperCAmelCase							=    image_processor(
             lowerCamelCase       ,				["""semantic"""] * len(lowerCamelCase							)       ,				return_tensors="""pt"""							).pixel_values
         self.assertEqual(
             encoded_images.shape       ,				(
                 self.image_processing_tester.batch_size,
                 self.image_processing_tester.num_channels,
                 expected_height,
                 expected_width,
             )       ,				)


  def  lowerCamelCase       (      self		:			List[str]							)						->	Tuple:


         """simple docstring"""
         # Initialize image_processor
         _UpperCAmelCase							=    self.image_processing_class(**self.image_processor_dict							)
         # create random PyTorch tensors
         _UpperCAmelCase							=    prepare_image_inputs(self.image_processing_tester       ,				equal_resolution=lowerCamelCase       ,				torchify=lowerCamelCase							)
         for image in image_inputs:
                self.assertIsInstance(lowerCamelCase       ,				torch.Tensor							)

         # Test not batched input
         _UpperCAmelCase							=    image_processor(image_inputs[0]       ,				["""semantic"""]       ,				return_tensors="""pt"""							).pixel_values

         _UpperCAmelCase	,			_UpperCAmelCase							=    self.image_processing_tester.get_expected_values(lowerCamelCase							)

         self.assertEqual(
             encoded_images.shape       ,				(1, self.image_processing_tester.num_channels, expected_height, expected_width)       ,				)

         # Test batched
         _UpperCAmelCase	,			_UpperCAmelCase							=    self.image_processing_tester.get_expected_values(lowerCamelCase       ,				batched=lowerCamelCase							)

         _UpperCAmelCase							=    image_processor(
             lowerCamelCase       ,				["""semantic"""] * len(lowerCamelCase							)       ,				return_tensors="""pt"""							).pixel_values
         self.assertEqual(
             encoded_images.shape       ,				(
                 self.image_processing_tester.batch_size,
                 self.image_processing_tester.num_channels,
                 expected_height,
                 expected_width,
             )       ,				)


  def  lowerCamelCase       (      self		:			Tuple       ,				lowerCamelCase		:			Tuple=False       ,				lowerCamelCase		:			Union[str, Any]=False       ,				lowerCamelCase		:			Union[str, Any]="np"							)						->	str:


         """simple docstring"""
         _UpperCAmelCase							=    self.image_processing_class(**self.image_processor_dict							)
         # prepare image and target
         _UpperCAmelCase							=    self.image_processing_tester.num_labels
         _UpperCAmelCase							=    None
         _UpperCAmelCase							=    None
         _UpperCAmelCase							=    prepare_image_inputs(self.image_processing_tester       ,				equal_resolution=lowerCamelCase							)
         if with_segmentation_maps:
                _UpperCAmelCase							=    num_labels
                if is_instance_map:
                       _UpperCAmelCase							=    list(range(lowerCamelCase							)							) * 2
                       _UpperCAmelCase							=    dict(enumerate(lowerCamelCase							)							)
                _UpperCAmelCase							=    [
                    np.random.randint(0       ,				high * 2       ,				(img.size[1], img.size[0])							).astype(np.uinta							) for img in image_inputs
                ]
                if segmentation_type == "pil":
                       _UpperCAmelCase							=    [Image.fromarray(lowerCamelCase							) for annotation in annotations]

         _UpperCAmelCase							=    image_processor(
             lowerCamelCase       ,				["""semantic"""] * len(lowerCamelCase							)       ,				lowerCamelCase       ,				return_tensors="""pt"""       ,				instance_id_to_semantic_id=lowerCamelCase       ,				pad_and_return_pixel_mask=lowerCamelCase       ,				)

         return inputs


  def  lowerCamelCase       (      self		:			Any							)						->	Dict:


         """simple docstring"""
         pass


  def  lowerCamelCase       (      self		:			Dict							)						->	List[Any]:


         """simple docstring"""
         def common(lowerCamelCase		:			List[Any]=False       ,				lowerCamelCase		:			List[Any]=None							):
                _UpperCAmelCase							=    self.comm_get_image_processor_inputs(
                    with_segmentation_maps=lowerCamelCase       ,				is_instance_map=lowerCamelCase       ,				segmentation_type=lowerCamelCase							)

                _UpperCAmelCase							=    inputs["""mask_labels"""]
                _UpperCAmelCase							=    inputs["""class_labels"""]
                _UpperCAmelCase							=    inputs["""pixel_values"""]
                _UpperCAmelCase							=    inputs["""text_inputs"""]

                # check the batch_size
                for mask_label, class_label, text_input in zip(lowerCamelCase       ,				lowerCamelCase       ,				lowerCamelCase							):
                       self.assertEqual(mask_label.shape[0]       ,				class_label.shape[0]							)
                       # this ensure padding has happened
                       self.assertEqual(mask_label.shape[1:]       ,				pixel_values.shape[2:]							)
                       self.assertEqual(len(lowerCamelCase							)       ,				self.image_processing_tester.num_text							)

         common()
         common(is_instance_map=lowerCamelCase							)
         common(is_instance_map=lowerCamelCase       ,				segmentation_type="""pil"""							)
         common(is_instance_map=lowerCamelCase       ,				segmentation_type="""pil"""							)


  def  lowerCamelCase       (      self		:			int							)						->	List[Any]:


         """simple docstring"""
         _UpperCAmelCase							=    np.zeros((20, 50)							)
         _UpperCAmelCase							=    1
         _UpperCAmelCase							=    1
         _UpperCAmelCase							=    1

         _UpperCAmelCase							=    binary_mask_to_rle(lowerCamelCase							)
         self.assertEqual(len(lowerCamelCase							)       ,				4							)
         self.assertEqual(rle[0]       ,				21							)
         self.assertEqual(rle[1]       ,				45							)


  def  lowerCamelCase       (      self		:			Optional[Any]							)						->	Optional[Any]:


         """simple docstring"""
         _UpperCAmelCase							=    self.image_processing_class(
             num_labels=self.image_processing_tester.num_classes       ,				max_seq_length=77       ,				task_seq_length=77       ,				class_info_file="""ade20k_panoptic.json"""       ,				num_text=self.image_processing_tester.num_text       ,				repo_path="""shi-labs/oneformer_demo"""       ,				)
         _UpperCAmelCase							=    self.image_processing_tester.get_fake_oneformer_outputs()

         _UpperCAmelCase							=    fature_extractor.post_process_semantic_segmentation(lowerCamelCase							)

         self.assertEqual(len(lowerCamelCase							)       ,				self.image_processing_tester.batch_size							)
         self.assertEqual(
             segmentation[0].shape       ,				(
                 self.image_processing_tester.height,
                 self.image_processing_tester.width,
             )       ,				)

         _UpperCAmelCase							=    [(1, 4) for i in range(self.image_processing_tester.batch_size							)]
         _UpperCAmelCase							=    fature_extractor.post_process_semantic_segmentation(lowerCamelCase       ,				target_sizes=lowerCamelCase							)

         self.assertEqual(segmentation[0].shape       ,				target_sizes[0]							)


  def  lowerCamelCase       (      self		:			Dict							)						->	Any:


         """simple docstring"""
         _UpperCAmelCase							=    self.image_processing_class(
             num_labels=self.image_processing_tester.num_classes       ,				max_seq_length=77       ,				task_seq_length=77       ,				class_info_file="""ade20k_panoptic.json"""       ,				num_text=self.image_processing_tester.num_text       ,				repo_path="""shi-labs/oneformer_demo"""       ,				)
         _UpperCAmelCase							=    self.image_processing_tester.get_fake_oneformer_outputs()
         _UpperCAmelCase							=    image_processor.post_process_instance_segmentation(lowerCamelCase       ,				threshold=0							)

         self.assertTrue(len(lowerCamelCase							) == self.image_processing_tester.batch_size							)
         for el in segmentation:
                self.assertTrue("""segmentation""" in el							)
                self.assertTrue("""segments_info""" in el							)
                self.assertEqual(type(el["""segments_info"""]							)       ,				lowerCamelCase							)
                self.assertEqual(
                    el["""segmentation"""].shape       ,				(self.image_processing_tester.height, self.image_processing_tester.width)							)





  def  lowerCamelCase       (      self		:			Dict							)						->	Optional[Any]:


         """simple docstring"""
         _UpperCAmelCase							=    self.image_processing_class(
             num_labels=self.image_processing_tester.num_classes       ,				max_seq_length=77       ,				task_seq_length=77       ,				class_info_file="""ade20k_panoptic.json"""       ,				num_text=self.image_processing_tester.num_text       ,				repo_path="""shi-labs/oneformer_demo"""       ,				)
         _UpperCAmelCase							=    self.image_processing_tester.get_fake_oneformer_outputs()
         _UpperCAmelCase							=    image_processor.post_process_panoptic_segmentation(lowerCamelCase       ,				threshold=0							)

         self.assertTrue(len(lowerCamelCase							) == self.image_processing_tester.batch_size							)
         for el in segmentation:
                self.assertTrue("""segmentation""" in el							)
                self.assertTrue("""segments_info""" in el							)
                self.assertEqual(type(el["""segments_info"""]							)       ,				lowerCamelCase							)
                self.assertEqual(
                    el["""segmentation"""].shape       ,				(self.image_processing_tester.height, self.image_processing_tester.width)							)