
'''simple docstring'''







import json
import os
from functools import lru_cache
from typing import TYPE_CHECKING, List, Optional, Tuple

import regex as re

from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...utils import logging


if TYPE_CHECKING:
      from transformers.pipelines.conversational import Conversation

_snake_case				:   Optional[int]     =				logging.get_logger(__name__)


_snake_case				:   Tuple     =				{
    """vocab_file""": """vocab.json""",
    """merges_file""": """merges.txt""",
    """tokenizer_config_file""": """tokenizer_config.json""",
}

_snake_case				:   Union[str, Any]     =				{
    """vocab_file""": {"""facebook/blenderbot-3B""": """https://huggingface.co/facebook/blenderbot-3B/resolve/main/vocab.json"""},
    """merges_file""": {"""facebook/blenderbot-3B""": """https://huggingface.co/facebook/blenderbot-3B/resolve/main/merges.txt"""},
    """tokenizer_config_file""": {
        """facebook/blenderbot-3B""": """https://huggingface.co/facebook/blenderbot-3B/resolve/main/tokenizer_config.json"""
    },
}

_snake_case				:   Dict     =				{"""facebook/blenderbot-3B""": 128}



@lru_cache()
# Copied from transformers.models.roberta.tokenization_roberta.bytes_to_unicode
def 			_a		(	):
      _SCREAMING_SNAKE_CASE				= (
          list(range(ord("!"  )	,			ord("~"  ) + 1  )  ) + list(range(ord("¡"  )	,			ord("¬"  ) + 1  )  ) + list(range(ord("®"  )	,			ord("ÿ"  ) + 1  )  )
      )
      _SCREAMING_SNAKE_CASE				= bs[:]
      _SCREAMING_SNAKE_CASE				= 0
      for b in range(2**8  ):
            if b not in bs:
                  bs.append(_SCREAMING_SNAKE_CASE  )
                  cs.append(2**8 + n  )
                  n += 1
      _SCREAMING_SNAKE_CASE				= [chr(_SCREAMING_SNAKE_CASE  ) for n in cs]
      return dict(zip(_SCREAMING_SNAKE_CASE	,			_SCREAMING_SNAKE_CASE  )  )



def 			_a		(	_SCREAMING_SNAKE_CASE		:   Tuple  ):
      _SCREAMING_SNAKE_CASE				= set()
      _SCREAMING_SNAKE_CASE				= word[0]
      for char in word[1:]:
            pairs.add((prev_char, char)  )
            _SCREAMING_SNAKE_CASE				= char
      return pairs




class 			lowerCAmelCase (				__UpperCAmelCase			):
  a							:					Optional[Any]       =					VOCAB_FILES_NAMES
  a							:					Optional[int]       =					PRETRAINED_VOCAB_FILES_MAP
  a							:					int       =					PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
  a							:					Union[str, Any]       =					['input_ids', 'attention_mask']




  def __init__(				self					,						UpperCamelCase					,						UpperCamelCase					,						UpperCamelCase="replace"					,						UpperCamelCase="<s>"					,						UpperCamelCase="</s>"					,						UpperCamelCase="</s>"					,						UpperCamelCase="<s>"					,						UpperCamelCase="<unk>"					,						UpperCamelCase="<pad>"					,						UpperCamelCase="<mask>"					,						UpperCamelCase=False					,						**UpperCamelCase					,						):
        _SCREAMING_SNAKE_CASE				= AddedToken(UpperCamelCase					,						lstrip=UpperCamelCase					,						rstrip=UpperCamelCase      ) if isinstance(UpperCamelCase					,						UpperCamelCase      ) else bos_token
        _SCREAMING_SNAKE_CASE				= AddedToken(UpperCamelCase					,						lstrip=UpperCamelCase					,						rstrip=UpperCamelCase      ) if isinstance(UpperCamelCase					,						UpperCamelCase      ) else eos_token
        _SCREAMING_SNAKE_CASE				= AddedToken(UpperCamelCase					,						lstrip=UpperCamelCase					,						rstrip=UpperCamelCase      ) if isinstance(UpperCamelCase					,						UpperCamelCase      ) else sep_token
        _SCREAMING_SNAKE_CASE				= AddedToken(UpperCamelCase					,						lstrip=UpperCamelCase					,						rstrip=UpperCamelCase      ) if isinstance(UpperCamelCase					,						UpperCamelCase      ) else cls_token
        _SCREAMING_SNAKE_CASE				= AddedToken(UpperCamelCase					,						lstrip=UpperCamelCase					,						rstrip=UpperCamelCase      ) if isinstance(UpperCamelCase					,						UpperCamelCase      ) else unk_token
        _SCREAMING_SNAKE_CASE				= AddedToken(UpperCamelCase					,						lstrip=UpperCamelCase					,						rstrip=UpperCamelCase      ) if isinstance(UpperCamelCase					,						UpperCamelCase      ) else pad_token

        # Mask token behave like a normal word, i.e. include the space before it
        _SCREAMING_SNAKE_CASE				= AddedToken(UpperCamelCase					,						lstrip=UpperCamelCase					,						rstrip=UpperCamelCase      ) if isinstance(UpperCamelCase					,						UpperCamelCase      ) else mask_token

        super().__init__(
            errors=UpperCamelCase					,						bos_token=UpperCamelCase					,						eos_token=UpperCamelCase					,						unk_token=UpperCamelCase					,						sep_token=UpperCamelCase					,						cls_token=UpperCamelCase					,						pad_token=UpperCamelCase					,						mask_token=UpperCamelCase					,						add_prefix_space=UpperCamelCase					,						**UpperCamelCase					,						)

        with open(UpperCamelCase					,						encoding="utf-8"      ) as vocab_handle:
              _SCREAMING_SNAKE_CASE				= json.load(UpperCamelCase      )
        _SCREAMING_SNAKE_CASE				= {v: k for k, v in self.encoder.items()}
        _SCREAMING_SNAKE_CASE				= errors  # how to handle errors in decoding
        _SCREAMING_SNAKE_CASE				= bytes_to_unicode()
        _SCREAMING_SNAKE_CASE				= {v: k for k, v in self.byte_encoder.items()}
        with open(UpperCamelCase					,						encoding="utf-8"      ) as merges_handle:
              _SCREAMING_SNAKE_CASE				= merges_handle.read().split("\n"      )[1:-1]
        _SCREAMING_SNAKE_CASE				= [tuple(merge.split()      ) for merge in bpe_merges]
        _SCREAMING_SNAKE_CASE				= dict(zip(UpperCamelCase					,						range(len(UpperCamelCase      )      )      )      )
        _SCREAMING_SNAKE_CASE				= {}
        _SCREAMING_SNAKE_CASE				= add_prefix_space

        # Should have added re.IGNORECASE so BPE merges can happen for capitalized versions of contractions
        _SCREAMING_SNAKE_CASE				= re.compile(R"\'s|\'t|\'re|\'ve|\'m|\'ll|\'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+"      )




  @property
  # Copied from transformers.models.roberta.tokenization_roberta.RobertaTokenizer.vocab_size with Roberta->Blenderbot, RoBERTa->Blenderbot
  def     lowercase       (				self      ):
        return len(self.encoder      )




  def     lowercase       (				self      ):
        return dict(self.encoder					,						**self.added_tokens_encoder      )




  def     lowercase       (				self					,						UpperCamelCase      ):







        if token in self.cache:
              return self.cache[token]
        _SCREAMING_SNAKE_CASE				= tuple(UpperCamelCase      )
        _SCREAMING_SNAKE_CASE				= get_pairs(UpperCamelCase      )

        if not pairs:
              return token

        while True:
              _SCREAMING_SNAKE_CASE				= min(UpperCamelCase					,						key=lambda UpperCamelCase      : self.bpe_ranks.get(UpperCamelCase					,						float("inf"      )      )      )
              if bigram not in self.bpe_ranks:
                    break
              _SCREAMING_SNAKE_CASE,							_SCREAMING_SNAKE_CASE				= bigram
              _SCREAMING_SNAKE_CASE				= []
              _SCREAMING_SNAKE_CASE				= 0
              while i < len(UpperCamelCase      ):
                    try:
                          _SCREAMING_SNAKE_CASE				= word.index(UpperCamelCase					,						UpperCamelCase      )
                    except ValueError:
                          new_word.extend(word[i:]      )
                          break
                    else:
                          new_word.extend(word[i:j]      )
                          _SCREAMING_SNAKE_CASE				= j

                    if word[i] == first and i < len(UpperCamelCase      ) - 1 and word[i + 1] == second:
                          new_word.append(first + second      )
                          i += 2
                    else:
                          new_word.append(word[i]      )
                          i += 1
              _SCREAMING_SNAKE_CASE				= tuple(UpperCamelCase      )
              _SCREAMING_SNAKE_CASE				= new_word
              if len(UpperCamelCase      ) == 1:
                    break
              else:
                    _SCREAMING_SNAKE_CASE				= get_pairs(UpperCamelCase      )
        _SCREAMING_SNAKE_CASE				= " ".join(UpperCamelCase      )
        _SCREAMING_SNAKE_CASE				= word
        return word




  def     lowercase       (				self					,						UpperCamelCase      ):
        _SCREAMING_SNAKE_CASE				= []
        for token in re.findall(self.pat					,						UpperCamelCase      ):
              _SCREAMING_SNAKE_CASE				= "".join(
                  self.byte_encoder[b] for b in token.encode("utf-8"      )      )  # Maps all our bytes to unicode strings, avoiding control tokens of the BPE (spaces in our case)
              bpe_tokens.extend(bpe_token for bpe_token in self.bpe(UpperCamelCase      ).split(" "      )      )
        return bpe_tokens




  def     lowercase       (				self					,						UpperCamelCase      ):
        return self.encoder.get(UpperCamelCase					,						self.encoder.get(self.unk_token      )      )




  def     lowercase       (				self					,						UpperCamelCase      ):
        return self.decoder.get(UpperCamelCase      )




  def     lowercase       (				self					,						UpperCamelCase      ):
        _SCREAMING_SNAKE_CASE				= "".join(UpperCamelCase      )
        _SCREAMING_SNAKE_CASE				= bytearray([self.byte_decoder[c] for c in text]      ).decode("utf-8"					,						errors=self.errors      )
        return text




  def     lowercase       (				self					,						UpperCamelCase					,						UpperCamelCase = None      ):







        if not os.path.isdir(UpperCamelCase      ):
              logger.error(F'Vocabulary path ({save_directory}) should be a directory'      )
              return
        _SCREAMING_SNAKE_CASE				= os.path.join(
            UpperCamelCase					,						(filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"]      )
        _SCREAMING_SNAKE_CASE				= os.path.join(
            UpperCamelCase					,						(filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["merges_file"]      )

        with open(UpperCamelCase					,						"w"					,						encoding="utf-8"      ) as f:
              f.write(json.dumps(self.encoder					,						indent=2					,						sort_keys=UpperCamelCase					,						ensure_ascii=UpperCamelCase      ) + "\n"      )

        _SCREAMING_SNAKE_CASE				= 0
        with open(UpperCamelCase					,						"w"					,						encoding="utf-8"      ) as writer:
              writer.write("#version: 0.2\n"      )
              for bpe_tokens, token_index in sorted(self.bpe_ranks.items()					,						key=lambda UpperCamelCase      : kv[1]      ):
                    if index != token_index:
                          logger.warning(
                              F'Saving vocabulary to {merge_file}: BPE merge indices are not consecutive.'
                              " Please check that the tokenizer is not corrupted!"      )
                          _SCREAMING_SNAKE_CASE				= token_index
                    writer.write(" ".join(UpperCamelCase      ) + "\n"      )
                    index += 1

        return vocab_file, merge_file




  def     lowercase       (				self					,						UpperCamelCase					,						UpperCamelCase = None					,						UpperCamelCase = False      ):







        if already_has_special_tokens:
              return super().get_special_tokens_mask(
                  token_ids_a=UpperCamelCase					,						token_ids_a=UpperCamelCase					,						already_has_special_tokens=UpperCamelCase      )

        if token_ids_a is None:
              return [1] + ([0] * len(UpperCamelCase      )) + [1]
        return [1] + ([0] * len(UpperCamelCase      )) + [1, 1] + ([0] * len(UpperCamelCase      )) + [1]




  def     lowercase       (				self					,						UpperCamelCase					,						UpperCamelCase = None      ):
        _SCREAMING_SNAKE_CASE				= [self.sep_token_id]
        _SCREAMING_SNAKE_CASE				= [self.cls_token_id]

        if token_ids_a is None:
              return len(cls + token_ids_a + sep      ) * [0]
        return len(cls + token_ids_a + sep + sep + token_ids_a + sep      ) * [0]




  def     lowercase       (				self					,						UpperCamelCase					,						UpperCamelCase=False					,						**UpperCamelCase      ):
        _SCREAMING_SNAKE_CASE				= kwargs.pop("add_prefix_space"					,						self.add_prefix_space      )
        if (is_split_into_words or add_prefix_space) and (len(UpperCamelCase      ) > 0 and not text[0].isspace()):
              _SCREAMING_SNAKE_CASE				= " " + text
        return (text, kwargs)




  def     lowercase       (				self					,						UpperCamelCase					,						UpperCamelCase = None      ):
        return token_ids_a + [self.eos_token_id]




  def     lowercase       (				self					,						UpperCamelCase      ):
        _SCREAMING_SNAKE_CASE				= []
        for is_user, text in conversation.iter_texts():
              if is_user:
                    # We need to space prefix as it's being done within blenderbot
                    inputs.append(" " + text      )
              else:
                    # Generated responses should contain them already.
                    inputs.append(UpperCamelCase      )

        _SCREAMING_SNAKE_CASE				= "  ".join(UpperCamelCase      )
        _SCREAMING_SNAKE_CASE				= self.encode(UpperCamelCase      )
        if len(UpperCamelCase      ) > self.model_max_length:
              _SCREAMING_SNAKE_CASE				= input_ids[-self.model_max_length :]
              logger.warning(F'Trimmed input from conversation as it was longer than {self.model_max_length} tokens.'      )
        return input_ids

'''simple docstring'''







from copy import deepcopy
from typing import Optional, Union

import numpy as np

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding
from ...utils import TensorType, is_tf_available, is_torch_available


if is_torch_available():
						import torch

if is_tf_available():
						import tensorflow as tf


class 			lowerCAmelCase (				__UpperCAmelCase			):
		a							:					Optional[int]       =					["""image_processor"""]
		a							:					Tuple       =					"""SamImageProcessor"""




		def __init__(				self					,						UpperCamelCase      ):
								super().__init__(UpperCamelCase      )
								_SCREAMING_SNAKE_CASE				= self.image_processor
								_SCREAMING_SNAKE_CASE				= -10
								_SCREAMING_SNAKE_CASE				= self.image_processor.size["longest_edge"]




		def __call__(				self					,						UpperCamelCase=None					,						UpperCamelCase=None					,						UpperCamelCase=None					,						UpperCamelCase=None					,						UpperCamelCase = None					,						**UpperCamelCase					,						):
								_SCREAMING_SNAKE_CASE				= self.image_processor(
								    UpperCamelCase					,						return_tensors=UpperCamelCase					,						**UpperCamelCase					,						)

								# pop arguments that are not used in the foward but used nevertheless
								_SCREAMING_SNAKE_CASE				= encoding_image_processor["original_sizes"]

								if hasattr(UpperCamelCase					,						"numpy"      ):  # Checks if Torch or TF tensor
														_SCREAMING_SNAKE_CASE				= original_sizes.numpy()

								_SCREAMING_SNAKE_CASE,							_SCREAMING_SNAKE_CASE,							_SCREAMING_SNAKE_CASE				= self._check_and_preprocess_points(
								    input_points=UpperCamelCase					,						input_labels=UpperCamelCase					,						input_boxes=UpperCamelCase					,						)

								_SCREAMING_SNAKE_CASE				= self._normalize_and_convert(
								    UpperCamelCase					,						UpperCamelCase					,						input_points=UpperCamelCase					,						input_labels=UpperCamelCase					,						input_boxes=UpperCamelCase					,						return_tensors=UpperCamelCase					,						)

								return encoding_image_processor




		def     lowercase       (				self					,						UpperCamelCase					,						UpperCamelCase					,						UpperCamelCase=None					,						UpperCamelCase=None					,						UpperCamelCase=None					,						UpperCamelCase="pt"					,						):
								if input_points is not None:
														if len(UpperCamelCase      ) != len(UpperCamelCase      ):
																				_SCREAMING_SNAKE_CASE				= [
																				    self._normalize_coordinates(self.target_size					,						UpperCamelCase					,						original_sizes[0]      ) for point in input_points
																				]
														else:
																				_SCREAMING_SNAKE_CASE				= [
																				    self._normalize_coordinates(self.target_size					,						UpperCamelCase					,						UpperCamelCase      )
																				    for point, original_size in zip(UpperCamelCase					,						UpperCamelCase      )
																				]
														# check that all arrays have the same shape
														if not all(point.shape == input_points[0].shape for point in input_points      ):
																				if input_labels is not None:
																										_SCREAMING_SNAKE_CASE,							_SCREAMING_SNAKE_CASE				= self._pad_points_and_labels(UpperCamelCase					,						UpperCamelCase      )

														_SCREAMING_SNAKE_CASE				= np.array(UpperCamelCase      )

								if input_labels is not None:
														_SCREAMING_SNAKE_CASE				= np.array(UpperCamelCase      )

								if input_boxes is not None:
														if len(UpperCamelCase      ) != len(UpperCamelCase      ):
																				_SCREAMING_SNAKE_CASE				= [
																				    self._normalize_coordinates(self.target_size					,						UpperCamelCase					,						original_sizes[0]					,						is_bounding_box=UpperCamelCase      )
																				    for box in input_boxes
																				]
														else:
																				_SCREAMING_SNAKE_CASE				= [
																				    self._normalize_coordinates(self.target_size					,						UpperCamelCase					,						UpperCamelCase					,						is_bounding_box=UpperCamelCase      )
																				    for box, original_size in zip(UpperCamelCase					,						UpperCamelCase      )
																				]
														_SCREAMING_SNAKE_CASE				= np.array(UpperCamelCase      )

								if input_boxes is not None:
														if return_tensors == "pt":
																				_SCREAMING_SNAKE_CASE				= torch.from_numpy(UpperCamelCase      )
																				# boxes batch size of 1 by default
																				_SCREAMING_SNAKE_CASE				= input_boxes.unsqueeze(1      ) if len(input_boxes.shape      ) != 3 else input_boxes
														elif return_tensors == "tf":
																				_SCREAMING_SNAKE_CASE				= tf.convert_to_tensor(UpperCamelCase      )
																				# boxes batch size of 1 by default
																				_SCREAMING_SNAKE_CASE				= tf.expand_dims(UpperCamelCase					,						1      ) if len(input_boxes.shape      ) != 3 else input_boxes
														encoding_image_processor.update({"input_boxes": input_boxes}      )
								if input_points is not None:
														if return_tensors == "pt":
																				_SCREAMING_SNAKE_CASE				= torch.from_numpy(UpperCamelCase      )
																				# point batch size of 1 by default
																				_SCREAMING_SNAKE_CASE				= input_points.unsqueeze(1      ) if len(input_points.shape      ) != 4 else input_points
														elif return_tensors == "tf":
																				_SCREAMING_SNAKE_CASE				= tf.convert_to_tensor(UpperCamelCase      )
																				# point batch size of 1 by default
																				_SCREAMING_SNAKE_CASE				= tf.expand_dims(UpperCamelCase					,						1      ) if len(input_points.shape      ) != 4 else input_points
														encoding_image_processor.update({"input_points": input_points}      )
								if input_labels is not None:
														if return_tensors == "pt":
																				_SCREAMING_SNAKE_CASE				= torch.from_numpy(UpperCamelCase      )
																				# point batch size of 1 by default
																				_SCREAMING_SNAKE_CASE				= input_labels.unsqueeze(1      ) if len(input_labels.shape      ) != 3 else input_labels
														elif return_tensors == "tf":
																				_SCREAMING_SNAKE_CASE				= tf.convert_to_tensor(UpperCamelCase      )
																				# point batch size of 1 by default
																				_SCREAMING_SNAKE_CASE				= tf.expand_dims(UpperCamelCase					,						1      ) if len(input_labels.shape      ) != 3 else input_labels
														encoding_image_processor.update({"input_labels": input_labels}      )

								return encoding_image_processor




		def     lowercase       (				self					,						UpperCamelCase					,						UpperCamelCase      ):
								_SCREAMING_SNAKE_CASE				= max([point.shape[0] for point in input_points]      )
								_SCREAMING_SNAKE_CASE				= []
								for i, point in enumerate(UpperCamelCase      ):
														if point.shape[0] != expected_nb_points:
																				_SCREAMING_SNAKE_CASE				= np.concatenate(
																				    [point, np.zeros((expected_nb_points - point.shape[0], 2)      ) + self.point_pad_value]					,						axis=0      )
																				_SCREAMING_SNAKE_CASE				= np.append(input_labels[i]					,						[self.point_pad_value]      )
														processed_input_points.append(UpperCamelCase      )
								_SCREAMING_SNAKE_CASE				= processed_input_points
								return input_points, input_labels




		def     lowercase       (				self					,						UpperCamelCase					,						UpperCamelCase					,						UpperCamelCase					,						UpperCamelCase=False      ):
								_SCREAMING_SNAKE_CASE,							_SCREAMING_SNAKE_CASE				= original_size
								_SCREAMING_SNAKE_CASE,							_SCREAMING_SNAKE_CASE				= self.image_processor._get_preprocess_shape(UpperCamelCase					,						longest_edge=UpperCamelCase      )
								_SCREAMING_SNAKE_CASE				= deepcopy(UpperCamelCase      ).astype(UpperCamelCase      )

								if is_bounding_box:
														_SCREAMING_SNAKE_CASE				= coords.reshape(-1					,						2					,						2      )

								_SCREAMING_SNAKE_CASE				= coords[..., 0] * (new_w / old_w)
								_SCREAMING_SNAKE_CASE				= coords[..., 1] * (new_h / old_h)

								if is_bounding_box:
														_SCREAMING_SNAKE_CASE				= coords.reshape(-1					,						4      )

								return coords




		def     lowercase       (				self					,						UpperCamelCase=None					,						UpperCamelCase=None					,						UpperCamelCase=None					,						):
								if input_points is not None:
														if hasattr(UpperCamelCase					,						"numpy"      ):  # Checks for TF or Torch tensor
																				_SCREAMING_SNAKE_CASE				= input_points.numpy().tolist()

														if not isinstance(UpperCamelCase					,						UpperCamelCase      ) or not isinstance(input_points[0]					,						UpperCamelCase      ):
																				raise ValueError("Input points must be a list of list of floating points."      )
														_SCREAMING_SNAKE_CASE				= [np.array(UpperCamelCase      ) for input_point in input_points]
								else:
														_SCREAMING_SNAKE_CASE				= None

								if input_labels is not None:
														if hasattr(UpperCamelCase					,						"numpy"      ):
																				_SCREAMING_SNAKE_CASE				= input_labels.numpy().tolist()

														if not isinstance(UpperCamelCase					,						UpperCamelCase      ) or not isinstance(input_labels[0]					,						UpperCamelCase      ):
																				raise ValueError("Input labels must be a list of list integers."      )
														_SCREAMING_SNAKE_CASE				= [np.array(UpperCamelCase      ) for label in input_labels]
								else:
														_SCREAMING_SNAKE_CASE				= None

								if input_boxes is not None:
														if hasattr(UpperCamelCase					,						"numpy"      ):
																				_SCREAMING_SNAKE_CASE				= input_boxes.numpy().tolist()

														if (
														    not isinstance(UpperCamelCase					,						UpperCamelCase      )
														    or not isinstance(input_boxes[0]					,						UpperCamelCase      )
														    or not isinstance(input_boxes[0][0]					,						UpperCamelCase      )
														):
																				raise ValueError("Input boxes must be a list of list of list of floating points."      )
														_SCREAMING_SNAKE_CASE				= [np.array(UpperCamelCase      ).astype(np.floataa      ) for box in input_boxes]
								else:
														_SCREAMING_SNAKE_CASE				= None

								return input_points, input_labels, input_boxes




		@property
		def     lowercase       (				self      ):
								_SCREAMING_SNAKE_CASE				= self.image_processor.model_input_names
								return list(dict.fromkeys(UpperCamelCase      )      )




		def     lowercase       (				self					,						*UpperCamelCase					,						**UpperCamelCase      ):
								return self.image_processor.post_process_masks(*UpperCamelCase					,						**UpperCamelCase      )