






from collections import defaultdict
from typing import Optional

from ..image_utils import load_image
from ..utils import (
    add_end_docstrings,
    is_torch_available,
    logging,
    requires_backends,
)
from .base import PIPELINE_INIT_ARGS, ChunkPipeline


if is_torch_available():
			import torch

			from ..models.auto.modeling_auto import MODEL_FOR_MASK_GENERATION_MAPPING

UpperCAmelCase__      			=						logging.get_logger(__name__)




@add_end_docstrings(__UpperCamelCase      )
class 							snake_case_       (    __UpperCamelCase      ):

						"""simple docstring"""



						def __init__(self:					int ,					**__UpperCAmelCase:					Optional[Any]   )    ->     str:




											'''simple docstring'''



											super().__init__(**__UpperCAmelCase   )
											requires_backends(self ,					"vision"   )
											requires_backends(self ,					"torch"   )

											if self.framework != "pt":
																raise ValueError(f'The {self.__class__} is only available in PyTorch.'   )

											self.check_model_type(__UpperCAmelCase   )



						def        UpperCAmelCase__					(self:					Optional[int] ,					**__UpperCAmelCase:					Optional[int]   )    ->     List[Any]:




											'''simple docstring'''



											__a					:						Any      =					{}
											__a					:						Union[str, Any]      =					{}
											__a					:						List[str]      =					{}
											# preprocess args
											if "points_per_batch" in kwargs:
																__a					:						Dict      =					kwargs["points_per_batch"]
											if "points_per_crop" in kwargs:
																__a					:						Tuple      =					kwargs["points_per_crop"]
											if "crops_n_layers" in kwargs:
																__a					:						Dict      =					kwargs["crops_n_layers"]
											if "crop_overlap_ratio" in kwargs:
																__a					:						int      =					kwargs["crop_overlap_ratio"]
											if "crop_n_points_downscale_factor" in kwargs:
																__a					:						Optional[int]      =					kwargs["crop_n_points_downscale_factor"]
											# postprocess args
											if "pred_iou_thresh" in kwargs:
																__a					:						int      =					kwargs["pred_iou_thresh"]
											if "stability_score_offset" in kwargs:
																__a					:						Any      =					kwargs["stability_score_offset"]
											if "mask_threshold" in kwargs:
																__a					:						int      =					kwargs["mask_threshold"]
											if "stability_score_thresh" in kwargs:
																__a					:						Any      =					kwargs["stability_score_thresh"]
											if "crops_nms_thresh" in kwargs:
																__a					:						int      =					kwargs["crops_nms_thresh"]
											if "output_rle_mask" in kwargs:
																__a					:						Optional[Any]      =					kwargs["output_rle_mask"]
											if "output_bboxes_mask" in kwargs:
																__a					:						Optional[Any]      =					kwargs["output_bboxes_mask"]
											return preprocess_kwargs, forward_params, postprocess_kwargs



						def __call__(self:					Union[str, Any] ,					__UpperCAmelCase:					str ,					*__UpperCAmelCase:					Optional[Any] ,					__UpperCAmelCase:					str=None ,					__UpperCAmelCase:					Union[str, Any]=None ,					**__UpperCAmelCase:					Optional[int]   )    ->     Tuple:




											'''simple docstring'''



											return super().__call__(__UpperCAmelCase ,					*__UpperCAmelCase ,					num_workers=__UpperCAmelCase ,					batch_size=__UpperCAmelCase ,					**__UpperCAmelCase   )



						def        UpperCAmelCase__					(self:					Optional[Any] ,					__UpperCAmelCase:					List[str] ,					__UpperCAmelCase:					int=64 ,					__UpperCAmelCase:					int = 0 ,					__UpperCAmelCase:					float = 512 / 1500 ,					__UpperCAmelCase:					Optional[int] = 32 ,					__UpperCAmelCase:					Optional[int] = 1 ,					)    ->     str:




											'''simple docstring'''



											__a					:						Union[str, Any]      =					load_image(__UpperCAmelCase   )
											__a					:						List[str]      =					self.image_processor.size["longest_edge"]
											__a      ,			__a      ,			__a      ,			__a					:						int      =					self.image_processor.generate_crop_boxes(
											    __UpperCAmelCase ,					__UpperCAmelCase ,					__UpperCAmelCase ,					__UpperCAmelCase ,					__UpperCAmelCase ,					__UpperCAmelCase   )
											__a					:						Union[str, Any]      =					self.image_processor(images=__UpperCAmelCase ,					return_tensors="pt"   )

											with self.device_placement():
																if self.framework == "pt":
																					__a					:						str      =					self.get_inference_context()
																					with inference_context():
																										__a					:						int      =					self._ensure_tensor_on_device(__UpperCAmelCase ,					device=self.device   )
																										__a					:						Union[str, Any]      =					self.model.get_image_embeddings(model_inputs.pop("pixel_values"   )   )
																										__a					:						Optional[Any]      =					image_embeddings

											__a					:						Dict      =					grid_points.shape[1]
											__a					:						Any      =					points_per_batch if points_per_batch is not None else n_points

											if points_per_batch <= 0:
																raise ValueError(
																    "Cannot have points_per_batch<=0. Must be >=1 to returned batched outputs. "
																    "To return all points at once, set points_per_batch to None"   )

											for i in range(0 ,					__UpperCAmelCase ,					__UpperCAmelCase   ):
																__a					:						List[str]      =					grid_points[:, i : i + points_per_batch, :, :]
																__a					:						str      =					input_labels[:, i : i + points_per_batch]
																__a					:						str      =					i == n_points - points_per_batch
																yield {
																    "input_points": batched_points,
																    "input_labels": labels,
																    "input_boxes": crop_boxes,
																    "is_last": is_last,
																    **model_inputs,
																}



						def        UpperCAmelCase__					(self:					Any ,					__UpperCAmelCase:					Optional[Any] ,					__UpperCAmelCase:					Any=0.88 ,					__UpperCAmelCase:					Optional[int]=0.95 ,					__UpperCAmelCase:					Optional[int]=0 ,					__UpperCAmelCase:					int=1 ,					)    ->     List[str]:




											'''simple docstring'''



											__a					:						List[Any]      =					model_inputs.pop("input_boxes"   )
											__a					:						Optional[Any]      =					model_inputs.pop("is_last"   )
											__a					:						Dict      =					model_inputs.pop("original_sizes"   ).tolist()
											__a					:						int      =					model_inputs.pop("reshaped_input_sizes"   ).tolist()

											__a					:						Optional[Any]      =					self.model(**__UpperCAmelCase   )

											# post processing happens here in order to avoid CPU GPU copies of ALL the masks
											__a					:						Union[str, Any]      =					model_outputs["pred_masks"]
											__a					:						Optional[Any]      =					self.image_processor.post_process_masks(
											    __UpperCAmelCase ,					__UpperCAmelCase ,					__UpperCAmelCase ,					__UpperCAmelCase ,					binarize=__UpperCAmelCase   )
											__a					:						Optional[Any]      =					model_outputs["iou_scores"]
											__a      ,			__a      ,			__a					:						Dict      =					self.image_processor.filter_masks(
											    masks[0] ,					iou_scores[0] ,					original_sizes[0] ,					input_boxes[0] ,					__UpperCAmelCase ,					__UpperCAmelCase ,					__UpperCAmelCase ,					__UpperCAmelCase ,					)
											return {
											    "masks": masks,
											    "is_last": is_last,
											    "boxes": boxes,
											    "iou_scores": iou_scores,
											}



						def        UpperCAmelCase__					(self:					Any ,					__UpperCAmelCase:					str ,					__UpperCAmelCase:					List[str]=False ,					__UpperCAmelCase:					int=False ,					__UpperCAmelCase:					List[str]=0.7 ,					)    ->     Dict:




											'''simple docstring'''



											__a					:						Dict      =					[]
											__a					:						Optional[Any]      =					[]
											__a					:						Optional[Any]      =					[]
											for model_output in model_outputs:
																all_scores.append(model_output.pop("iou_scores"   )   )
																all_masks.extend(model_output.pop("masks"   )   )
																all_boxes.append(model_output.pop("boxes"   )   )

											__a					:						Any      =					torch.cat(__UpperCAmelCase   )
											__a					:						Union[str, Any]      =					torch.cat(__UpperCAmelCase   )
											__a      ,			__a      ,			__a      ,			__a					:						Tuple      =					self.image_processor.post_process_for_mask_generation(
											    __UpperCAmelCase ,					__UpperCAmelCase ,					__UpperCAmelCase ,					__UpperCAmelCase   )

											__a					:						Optional[int]      =					defaultdict(__UpperCAmelCase   )
											for output in model_outputs:
																for k, v in output.items():
																					extra[k].append(__UpperCAmelCase   )

											__a					:						int      =					{}
											if output_rle_mask:
																__a					:						Optional[int]      =					rle_mask

											if output_bboxes_mask:
																__a					:						List[str]      =					bounding_boxes

											return {"masks": output_masks, "scores": iou_scores, **optional, **extra}













import json
import os
import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers import CLIPTokenizer, CLIPTokenizerFast
from transformers.models.clip.tokenization_clip import VOCAB_FILES_NAMES
from transformers.testing_utils import require_vision
from transformers.utils import IMAGE_PROCESSOR_NAME, is_vision_available


if is_vision_available():
			from PIL import Image

			from transformers import OwlViTImageProcessor, OwlViTProcessor




@require_vision
class 							snake_case_       (    unittest.TestCase      ):

						"""simple docstring"""



						def        UpperCAmelCase__					(self:					int   )    ->     str:




											'''simple docstring'''



											__a					:						Union[str, Any]      =					tempfile.mkdtemp()

											# fmt: off
											__a					:						Dict      =					["", "l", "o", "w", "e", "r", "s", "t", "i", "d", "n", "lo", "l</w>", "w</w>", "r</w>", "t</w>", "low</w>", "er</w>", "lowest</w>", "newer</w>", "wider", "<unk>", "<|startoftext|>", "<|endoftext|>"]
											# fmt: on
											__a					:						str      =					dict(zip(__UpperCAmelCase ,					range(len(__UpperCAmelCase   )   )   )   )
											__a					:						Union[str, Any]      =					["#version: 0.2", "l o", "lo w</w>", "e r</w>", ""]
											__a					:						Union[str, Any]      =					{"unk_token": "<unk>"}

											__a					:						Dict      =					os.path.join(self.tmpdirname ,					VOCAB_FILES_NAMES["vocab_file"]   )
											__a					:						int      =					os.path.join(self.tmpdirname ,					VOCAB_FILES_NAMES["merges_file"]   )
											with open(self.vocab_file ,					"w" ,					encoding="utf-8"   ) as fp:
																fp.write(json.dumps(__UpperCAmelCase   ) + "\n"   )
											with open(self.merges_file ,					"w" ,					encoding="utf-8"   ) as fp:
																fp.write("\n".join(__UpperCAmelCase   )   )

											__a					:						str      =					{
											    "do_resize": True,
											    "size": 20,
											    "do_center_crop": True,
											    "crop_size": 18,
											    "do_normalize": True,
											    "image_mean": [0.48_14_54_66, 0.4_57_82_75, 0.40_82_10_73],
											    "image_std": [0.26_86_29_54, 0.26_13_02_58, 0.27_57_77_11],
											}
											__a					:						Any      =					os.path.join(self.tmpdirname ,					__UpperCAmelCase   )
											with open(self.image_processor_file ,					"w" ,					encoding="utf-8"   ) as fp:
																json.dump(__UpperCAmelCase ,					__UpperCAmelCase   )



						def        UpperCAmelCase__					(self:					Tuple ,					**__UpperCAmelCase:					Dict   )    ->     List[str]:




											'''simple docstring'''



											return CLIPTokenizer.from_pretrained(self.tmpdirname ,					pad_token="!" ,					**__UpperCAmelCase   )



						def        UpperCAmelCase__					(self:					Optional[Any] ,					**__UpperCAmelCase:					int   )    ->     Any:




											'''simple docstring'''



											return CLIPTokenizerFast.from_pretrained(self.tmpdirname ,					pad_token="!" ,					**__UpperCAmelCase   )



						def        UpperCAmelCase__					(self:					List[Any] ,					**__UpperCAmelCase:					Dict   )    ->     Optional[int]:




											'''simple docstring'''



											return OwlViTImageProcessor.from_pretrained(self.tmpdirname ,					**__UpperCAmelCase   )



						def        UpperCAmelCase__					(self:					str   )    ->     int:




											'''simple docstring'''



											shutil.rmtree(self.tmpdirname   )



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




											'''simple docstring'''



											__a					:						Dict      =					[np.random.randint(255 ,					size=(3, 30, 400) ,					dtype=np.uinta   )]

											__a					:						Any      =					[Image.fromarray(np.moveaxis(__UpperCAmelCase ,					0 ,					-1   )   ) for x in image_inputs]

											return image_inputs



						def        UpperCAmelCase__					(self:					Tuple   )    ->     Optional[Any]:




											'''simple docstring'''



											__a					:						Dict      =					self.get_tokenizer()
											__a					:						Dict      =					self.get_rust_tokenizer()
											__a					:						List[str]      =					self.get_image_processor()

											__a					:						Any      =					OwlViTProcessor(tokenizer=__UpperCAmelCase ,					image_processor=__UpperCAmelCase   )
											processor_slow.save_pretrained(self.tmpdirname   )
											__a					:						str      =					OwlViTProcessor.from_pretrained(self.tmpdirname ,					use_fast=__UpperCAmelCase   )

											__a					:						Union[str, Any]      =					OwlViTProcessor(tokenizer=__UpperCAmelCase ,					image_processor=__UpperCAmelCase   )
											processor_fast.save_pretrained(self.tmpdirname   )
											__a					:						List[Any]      =					OwlViTProcessor.from_pretrained(self.tmpdirname   )

											self.assertEqual(processor_slow.tokenizer.get_vocab() ,					tokenizer_slow.get_vocab()   )
											self.assertEqual(processor_fast.tokenizer.get_vocab() ,					tokenizer_fast.get_vocab()   )
											self.assertEqual(tokenizer_slow.get_vocab() ,					tokenizer_fast.get_vocab()   )
											self.assertIsInstance(processor_slow.tokenizer ,					__UpperCAmelCase   )
											self.assertIsInstance(processor_fast.tokenizer ,					__UpperCAmelCase   )

											self.assertEqual(processor_slow.image_processor.to_json_string() ,					image_processor.to_json_string()   )
											self.assertEqual(processor_fast.image_processor.to_json_string() ,					image_processor.to_json_string()   )
											self.assertIsInstance(processor_slow.image_processor ,					__UpperCAmelCase   )
											self.assertIsInstance(processor_fast.image_processor ,					__UpperCAmelCase   )



						def        UpperCAmelCase__					(self:					str   )    ->     Dict:




											'''simple docstring'''



											__a					:						Tuple      =					OwlViTProcessor(tokenizer=self.get_tokenizer() ,					image_processor=self.get_image_processor()   )
											processor.save_pretrained(self.tmpdirname   )

											__a					:						Optional[Any]      =					self.get_tokenizer(bos_token="(BOS)" ,					eos_token="(EOS)"   )
											__a					:						str      =					self.get_image_processor(do_normalize=__UpperCAmelCase   )

											__a					:						str      =					OwlViTProcessor.from_pretrained(
											    self.tmpdirname ,					bos_token="(BOS)" ,					eos_token="(EOS)" ,					do_normalize=__UpperCAmelCase   )

											self.assertEqual(processor.tokenizer.get_vocab() ,					tokenizer_add_kwargs.get_vocab()   )
											self.assertIsInstance(processor.tokenizer ,					__UpperCAmelCase   )

											self.assertEqual(processor.image_processor.to_json_string() ,					image_processor_add_kwargs.to_json_string()   )
											self.assertIsInstance(processor.image_processor ,					__UpperCAmelCase   )



						def        UpperCAmelCase__					(self:					Optional[int]   )    ->     Dict:




											'''simple docstring'''



											__a					:						Optional[Any]      =					self.get_image_processor()
											__a					:						str      =					self.get_tokenizer()

											__a					:						List[str]      =					OwlViTProcessor(tokenizer=__UpperCAmelCase ,					image_processor=__UpperCAmelCase   )

											__a					:						List[str]      =					self.prepare_image_inputs()

											__a					:						Optional[Any]      =					image_processor(__UpperCAmelCase ,					return_tensors="np"   )
											__a					:						int      =					processor(images=__UpperCAmelCase ,					return_tensors="np"   )

											for key in input_image_proc.keys():
																self.assertAlmostEqual(input_image_proc[key].sum() ,					input_processor[key].sum() ,					delta=1E-2   )



						def        UpperCAmelCase__					(self:					Dict   )    ->     Optional[int]:




											'''simple docstring'''



											__a					:						int      =					self.get_image_processor()
											__a					:						Tuple      =					self.get_tokenizer()

											__a					:						Optional[int]      =					OwlViTProcessor(tokenizer=__UpperCAmelCase ,					image_processor=__UpperCAmelCase   )

											__a					:						Dict      =					"lower newer"

											__a					:						Any      =					processor(text=__UpperCAmelCase ,					return_tensors="np"   )

											__a					:						List[str]      =					tokenizer(__UpperCAmelCase ,					return_tensors="np"   )

											for key in encoded_tok.keys():
																self.assertListEqual(encoded_tok[key][0].tolist() ,					encoded_processor[key][0].tolist()   )



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




											'''simple docstring'''



											__a					:						Dict      =					self.get_image_processor()
											__a					:						List[str]      =					self.get_tokenizer()

											__a					:						Optional[Any]      =					OwlViTProcessor(tokenizer=__UpperCAmelCase ,					image_processor=__UpperCAmelCase   )

											__a					:						Optional[int]      =					"lower newer"
											__a					:						int      =					self.prepare_image_inputs()

											__a					:						Optional[int]      =					processor(text=__UpperCAmelCase ,					images=__UpperCAmelCase   )

											self.assertListEqual(list(inputs.keys()   ) ,					["input_ids", "attention_mask", "pixel_values"]   )

											# test if it raises when no input is passed
											with pytest.raises(__UpperCAmelCase   ):
																processor()



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




											'''simple docstring'''



											__a					:						Dict      =					"google/owlvit-base-patch32"
											__a					:						Dict      =					OwlViTProcessor.from_pretrained(__UpperCAmelCase   )

											__a					:						List[str]      =					["cat", "nasa badge"]
											__a					:						List[Any]      =					processor(text=__UpperCAmelCase   )

											__a					:						Any      =					16
											self.assertListEqual(list(inputs.keys()   ) ,					["input_ids", "attention_mask"]   )
											self.assertEqual(inputs["input_ids"].shape ,					(2, seq_length)   )

											# test if it raises when no input is passed
											with pytest.raises(__UpperCAmelCase   ):
																processor()



						def        UpperCAmelCase__					(self:					Any   )    ->     Optional[int]:




											'''simple docstring'''



											__a					:						Optional[int]      =					"google/owlvit-base-patch32"
											__a					:						Optional[int]      =					OwlViTProcessor.from_pretrained(__UpperCAmelCase   )

											__a					:						Tuple      =					[["cat", "nasa badge"], ["person"]]
											__a					:						List[Any]      =					processor(text=__UpperCAmelCase   )

											__a					:						Tuple      =					16
											__a					:						Optional[Any]      =					len(__UpperCAmelCase   )
											__a					:						Optional[Any]      =					max([len(__UpperCAmelCase   ) for texts in input_texts]   )

											self.assertListEqual(list(inputs.keys()   ) ,					["input_ids", "attention_mask"]   )
											self.assertEqual(inputs["input_ids"].shape ,					(batch_size * num_max_text_queries, seq_length)   )

											# test if it raises when no input is passed
											with pytest.raises(__UpperCAmelCase   ):
																processor()



						def        UpperCAmelCase__					(self:					Tuple   )    ->     Dict:




											'''simple docstring'''



											__a					:						int      =					"google/owlvit-base-patch32"
											__a					:						Dict      =					OwlViTProcessor.from_pretrained(__UpperCAmelCase   )

											__a					:						List[str]      =					["cat", "nasa badge"]
											__a					:						List[Any]      =					processor(text=__UpperCAmelCase   )

											__a					:						int      =					16
											__a					:						Union[str, Any]      =					inputs["input_ids"]
											__a					:						Optional[int]      =					[
											    [49406, 2368, 49407, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
											    [49406, 6841, 11301, 49407, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
											]

											self.assertListEqual(list(inputs.keys()   ) ,					["input_ids", "attention_mask"]   )
											self.assertEqual(inputs["input_ids"].shape ,					(2, seq_length)   )
											self.assertListEqual(list(input_ids[0]   ) ,					predicted_ids[0]   )
											self.assertListEqual(list(input_ids[1]   ) ,					predicted_ids[1]   )



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




											'''simple docstring'''



											__a					:						Union[str, Any]      =					self.get_image_processor()
											__a					:						List[str]      =					self.get_tokenizer()

											__a					:						Tuple      =					OwlViTProcessor(tokenizer=__UpperCAmelCase ,					image_processor=__UpperCAmelCase   )

											__a					:						str      =					self.prepare_image_inputs()
											__a					:						Any      =					self.prepare_image_inputs()

											__a					:						str      =					processor(images=__UpperCAmelCase ,					query_images=__UpperCAmelCase   )

											self.assertListEqual(list(inputs.keys()   ) ,					["query_pixel_values", "pixel_values"]   )

											# test if it raises when no input is passed
											with pytest.raises(__UpperCAmelCase   ):
																processor()



						def        UpperCAmelCase__					(self:					Any   )    ->     Tuple:




											'''simple docstring'''



											__a					:						int      =					self.get_image_processor()
											__a					:						Tuple      =					self.get_tokenizer()

											__a					:						Optional[int]      =					OwlViTProcessor(tokenizer=__UpperCAmelCase ,					image_processor=__UpperCAmelCase   )

											__a					:						List[str]      =					[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

											__a					:						Tuple      =					processor.batch_decode(__UpperCAmelCase   )
											__a					:						str      =					tokenizer.batch_decode(__UpperCAmelCase   )

											self.assertListEqual(__UpperCAmelCase ,					__UpperCAmelCase   )





