





import copy
import os
from collections import OrderedDict
from typing import TYPE_CHECKING, Any, Dict, Mapping, Optional, Union


if TYPE_CHECKING:
       from ...processing_utils import ProcessorMixin
       from ...utils import TensorType

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


a__: Any							   =						logging.get_logger(__name__)

a__: str							   =						{
    'google/owlvit-base-patch32': 'https://huggingface.co/google/owlvit-base-patch32/resolve/main/config.json',
    'google/owlvit-base-patch16': 'https://huggingface.co/google/owlvit-base-patch16/resolve/main/config.json',
    'google/owlvit-large-patch14': 'https://huggingface.co/google/owlvit-large-patch14/resolve/main/config.json',
}




class        SCREAMING_SNAKE_CASE__					(		UpperCamelCase__ ):
 __SCREAMING_SNAKE_CASE							=      '''owlvit_text_model'''



 def __init__(				self,__lowerCamelCase=4_9408,__lowerCamelCase=512,__lowerCamelCase=2048,__lowerCamelCase=12,__lowerCamelCase=8,__lowerCamelCase=16,__lowerCamelCase="quick_gelu",__lowerCamelCase=1E-5,__lowerCamelCase=0.0,__lowerCamelCase=0.02,__lowerCamelCase=1.0,__lowerCamelCase=0,__lowerCamelCase=4_9406,__lowerCamelCase=4_9407,**__lowerCamelCase,):
        super().__init__(pad_token_id=__lowerCamelCase,bos_token_id=__lowerCamelCase,eos_token_id=__lowerCamelCase,**__lowerCamelCase					)

        A__		   =		vocab_size
        A__		   =		hidden_size
        A__		   =		intermediate_size
        A__		   =		num_hidden_layers
        A__		   =		num_attention_heads
        A__		   =		max_position_embeddings
        A__		   =		hidden_act
        A__		   =		layer_norm_eps
        A__		   =		attention_dropout
        A__		   =		initializer_range
        A__		   =		initializer_factor




 @classmethod
 def 							UpperCamelCase     (				cls,__lowerCamelCase,**__lowerCamelCase					):
        cls._set_token_in_kwargs(__lowerCamelCase					)

        A__   ,      A__		   =		cls.get_config_dict(__lowerCamelCase,**__lowerCamelCase					)

        # get the text config dict if we are loading from OwlViTConfig
        if config_dict.get('''model_type'''					) == "owlvit":
               A__		   =		config_dict['''text_config''']

        if "model_type" in config_dict and hasattr(cls,'''model_type'''					) and config_dict["model_type"] != cls.model_type:
               logger.warning(
                   f"You are using a model of type {config_dict['model_type']} to instantiate a model of type "
                   f"{cls.model_type}. This is not supported for all configurations of models and can yield errors."					)

        return cls.from_dict(__lowerCamelCase,**__lowerCamelCase					)




class        SCREAMING_SNAKE_CASE__					(		UpperCamelCase__ ):
 __SCREAMING_SNAKE_CASE							=      '''owlvit_vision_model'''



 def __init__(				self,__lowerCamelCase=768,__lowerCamelCase=3072,__lowerCamelCase=12,__lowerCamelCase=12,__lowerCamelCase=3,__lowerCamelCase=768,__lowerCamelCase=32,__lowerCamelCase="quick_gelu",__lowerCamelCase=1E-5,__lowerCamelCase=0.0,__lowerCamelCase=0.02,__lowerCamelCase=1.0,**__lowerCamelCase,):
        super().__init__(**__lowerCamelCase					)

        A__		   =		hidden_size
        A__		   =		intermediate_size
        A__		   =		num_hidden_layers
        A__		   =		num_attention_heads
        A__		   =		num_channels
        A__		   =		image_size
        A__		   =		patch_size
        A__		   =		hidden_act
        A__		   =		layer_norm_eps
        A__		   =		attention_dropout
        A__		   =		initializer_range
        A__		   =		initializer_factor




 @classmethod
 def 							UpperCamelCase     (				cls,__lowerCamelCase,**__lowerCamelCase					):
        cls._set_token_in_kwargs(__lowerCamelCase					)

        A__   ,      A__		   =		cls.get_config_dict(__lowerCamelCase,**__lowerCamelCase					)

        # get the vision config dict if we are loading from OwlViTConfig
        if config_dict.get('''model_type'''					) == "owlvit":
               A__		   =		config_dict['''vision_config''']

        if "model_type" in config_dict and hasattr(cls,'''model_type'''					) and config_dict["model_type"] != cls.model_type:
               logger.warning(
                   f"You are using a model of type {config_dict['model_type']} to instantiate a model of type "
                   f"{cls.model_type}. This is not supported for all configurations of models and can yield errors."					)

        return cls.from_dict(__lowerCamelCase,**__lowerCamelCase					)




class        SCREAMING_SNAKE_CASE__					(		UpperCamelCase__ ):
 __SCREAMING_SNAKE_CASE							=      '''owlvit'''
 __SCREAMING_SNAKE_CASE							=      True



 def __init__(				self,__lowerCamelCase=None,__lowerCamelCase=None,__lowerCamelCase=512,__lowerCamelCase=2.6592,__lowerCamelCase=True,**__lowerCamelCase,):
        super().__init__(**__lowerCamelCase					)

        if text_config is None:
               A__		   =		{}
               logger.info('''text_config is None. Initializing the OwlViTTextConfig with default values.'''					)

        if vision_config is None:
               A__		   =		{}
               logger.info('''vision_config is None. initializing the OwlViTVisionConfig with default values.'''					)

        A__		   =		OwlViTTextConfig(**__lowerCamelCase					)
        A__		   =		OwlViTVisionConfig(**__lowerCamelCase					)

        A__		   =		projection_dim
        A__		   =		logit_scale_init_value
        A__		   =		return_dict
        A__		   =		1.0



 @classmethod
 def 							UpperCamelCase     (				cls,__lowerCamelCase,**__lowerCamelCase					):
        cls._set_token_in_kwargs(__lowerCamelCase					)

        A__   ,      A__		   =		cls.get_config_dict(__lowerCamelCase,**__lowerCamelCase					)

        if "model_type" in config_dict and hasattr(cls,'''model_type'''					) and config_dict["model_type"] != cls.model_type:
               logger.warning(
                   f"You are using a model of type {config_dict['model_type']} to instantiate a model of type "
                   f"{cls.model_type}. This is not supported for all configurations of models and can yield errors."					)

        return cls.from_dict(__lowerCamelCase,**__lowerCamelCase					)



 @classmethod
 def 							UpperCamelCase     (				cls,__lowerCamelCase,__lowerCamelCase,**__lowerCamelCase					):
        A__		   =		{}
        A__		   =		text_config
        A__		   =		vision_config

        return cls.from_dict(__lowerCamelCase,**__lowerCamelCase					)




 def 							UpperCamelCase     (				self					):
        A__		   =		copy.deepcopy(self.__dict__					)
        A__		   =		self.text_config.to_dict()
        A__		   =		self.vision_config.to_dict()
        A__		   =		self.__class__.model_type
        return output




class        SCREAMING_SNAKE_CASE__					(		UpperCamelCase__ ):



 @property
 def 							UpperCamelCase     (				self					):
        return OrderedDict(
            [
                ('''input_ids''', {0: '''batch''', 1: '''sequence'''}),
                ('''pixel_values''', {0: '''batch''', 1: '''num_channels''', 2: '''height''', 3: '''width'''}),
                ('''attention_mask''', {0: '''batch''', 1: '''sequence'''}),
            ]					)



 @property
 def 							UpperCamelCase     (				self					):
        return OrderedDict(
            [
                ('''logits_per_image''', {0: '''batch'''}),
                ('''logits_per_text''', {0: '''batch'''}),
                ('''text_embeds''', {0: '''batch'''}),
                ('''image_embeds''', {0: '''batch'''}),
            ]					)



 @property
 def 							UpperCamelCase     (				self					):
        return 1E-4



 def 							UpperCamelCase     (				self,__lowerCamelCase,__lowerCamelCase = -1,__lowerCamelCase = -1,__lowerCamelCase = None,):
        A__		   =		super().generate_dummy_inputs(
            processor.tokenizer,batch_size=__lowerCamelCase,seq_length=__lowerCamelCase,framework=__lowerCamelCase					)
        A__		   =		super().generate_dummy_inputs(
            processor.image_processor,batch_size=__lowerCamelCase,framework=__lowerCamelCase					)
        return {**text_input_dict, **image_input_dict}




 @property
 def 							UpperCamelCase     (				self					):
        return 14












import shutil
import tempfile
import unittest

import numpy as np

from transformers.testing_utils import (
    is_pt_tf_cross_test,
    require_tf,
    require_torch,
    require_torchvision,
    require_vision,
)
from transformers.utils import is_tf_available, is_torch_available, is_vision_available


if is_vision_available():
       from PIL import Image

       from transformers import AutoProcessor, SamImageProcessor, SamProcessor

if is_torch_available():
       import torch

if is_tf_available():
       import tensorflow as tf




@require_vision
@require_torchvision
class        SCREAMING_SNAKE_CASE__					(		unittest.TestCase ):



 def 							UpperCamelCase     (				self					):
        A__		   =		tempfile.mkdtemp()
        A__		   =		SamImageProcessor()
        A__		   =		SamProcessor(__lowerCamelCase					)
        processor.save_pretrained(self.tmpdirname					)



 def 							UpperCamelCase     (				self,**__lowerCamelCase					):
        return AutoProcessor.from_pretrained(self.tmpdirname,**__lowerCamelCase					).image_processor



 def 							UpperCamelCase     (				self					):
        shutil.rmtree(self.tmpdirname					)



 def 							UpperCamelCase     (				self					):
        A__		   =		[np.random.randint(255,size=(3, 30, 400),dtype=np.uinta					)]

        A__		   =		[Image.fromarray(np.moveaxis(__lowerCamelCase,0,-1					)					) for x in image_inputs]

        return image_inputs



 def 							UpperCamelCase     (				self					):
        A__		   =		SamProcessor(image_processor=self.get_image_processor()					)
        processor.save_pretrained(self.tmpdirname					)

        A__		   =		self.get_image_processor(do_normalize=__lowerCamelCase,padding_value=1.0					)

        A__		   =		SamProcessor.from_pretrained(self.tmpdirname,do_normalize=__lowerCamelCase,padding_value=1.0					)

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



 def 							UpperCamelCase     (				self					):
        A__		   =		self.get_image_processor()

        A__		   =		SamProcessor(image_processor=__lowerCamelCase					)

        A__		   =		self.prepare_image_inputs()

        A__		   =		image_processor(__lowerCamelCase,return_tensors='''np'''					)
        A__		   =		processor(images=__lowerCamelCase,return_tensors='''np'''					)

        input_feat_extract.pop('''original_sizes'''					)  # pop original_sizes as it is popped in the processor
        input_feat_extract.pop('''reshaped_input_sizes'''					)  # pop original_sizes as it is popped in the processor

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




 @require_torch
 def 							UpperCamelCase     (				self					):
        A__		   =		self.get_image_processor()

        A__		   =		SamProcessor(image_processor=__lowerCamelCase					)
        A__		   =		[torch.ones((1, 3, 5, 5)					)]

        A__		   =		[[1764, 2646]]

        A__		   =		[[683, 1024]]
        A__		   =		processor.post_process_masks(__lowerCamelCase,__lowerCamelCase,__lowerCamelCase					)
        self.assertEqual(masks[0].shape,(1, 3, 1764, 2646)					)

        A__		   =		processor.post_process_masks(
            __lowerCamelCase,torch.tensor(__lowerCamelCase					),torch.tensor(__lowerCamelCase					)					)
        self.assertEqual(masks[0].shape,(1, 3, 1764, 2646)					)

        # should also work with np
        A__		   =		[np.ones((1, 3, 5, 5)					)]
        A__		   =		processor.post_process_masks(__lowerCamelCase,np.array(__lowerCamelCase					),np.array(__lowerCamelCase					)					)

        self.assertEqual(masks[0].shape,(1, 3, 1764, 2646)					)

        A__		   =		[[1, 0], [0, 1]]
        with self.assertRaises(__lowerCamelCase					):
               A__		   =		processor.post_process_masks(__lowerCamelCase,np.array(__lowerCamelCase					),np.array(__lowerCamelCase					)					)




@require_vision
@require_tf
class        SCREAMING_SNAKE_CASE__					(		unittest.TestCase ):



 def 							UpperCamelCase     (				self					):
        A__		   =		tempfile.mkdtemp()
        A__		   =		SamImageProcessor()
        A__		   =		SamProcessor(__lowerCamelCase					)
        processor.save_pretrained(self.tmpdirname					)



 def 							UpperCamelCase     (				self,**__lowerCamelCase					):
        return AutoProcessor.from_pretrained(self.tmpdirname,**__lowerCamelCase					).image_processor



 def 							UpperCamelCase     (				self					):
        shutil.rmtree(self.tmpdirname					)



 def 							UpperCamelCase     (				self					):
        A__		   =		[np.random.randint(255,size=(3, 30, 400),dtype=np.uinta					)]

        A__		   =		[Image.fromarray(np.moveaxis(__lowerCamelCase,0,-1					)					) for x in image_inputs]

        return image_inputs



 def 							UpperCamelCase     (				self					):
        A__		   =		SamProcessor(image_processor=self.get_image_processor()					)
        processor.save_pretrained(self.tmpdirname					)

        A__		   =		self.get_image_processor(do_normalize=__lowerCamelCase,padding_value=1.0					)

        A__		   =		SamProcessor.from_pretrained(self.tmpdirname,do_normalize=__lowerCamelCase,padding_value=1.0					)

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



 def 							UpperCamelCase     (				self					):
        A__		   =		self.get_image_processor()

        A__		   =		SamProcessor(image_processor=__lowerCamelCase					)

        A__		   =		self.prepare_image_inputs()

        A__		   =		image_processor(__lowerCamelCase,return_tensors='''np'''					)
        A__		   =		processor(images=__lowerCamelCase,return_tensors='''np'''					)

        input_feat_extract.pop('''original_sizes'''					)  # pop original_sizes as it is popped in the processor
        input_feat_extract.pop('''reshaped_input_sizes'''					)  # pop reshaped_input_sizes as it is popped in the processor

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




 @require_tf
 def 							UpperCamelCase     (				self					):
        A__		   =		self.get_image_processor()

        A__		   =		SamProcessor(image_processor=__lowerCamelCase					)
        A__		   =		[tf.ones((1, 3, 5, 5)					)]

        A__		   =		[[1764, 2646]]

        A__		   =		[[683, 1024]]
        A__		   =		processor.post_process_masks(__lowerCamelCase,__lowerCamelCase,__lowerCamelCase,return_tensors='''tf'''					)
        self.assertEqual(masks[0].shape,(1, 3, 1764, 2646)					)

        A__		   =		processor.post_process_masks(
            __lowerCamelCase,tf.convert_to_tensor(__lowerCamelCase					),tf.convert_to_tensor(__lowerCamelCase					),return_tensors='''tf''',)
        self.assertEqual(masks[0].shape,(1, 3, 1764, 2646)					)

        # should also work with np
        A__		   =		[np.ones((1, 3, 5, 5)					)]
        A__		   =		processor.post_process_masks(
            __lowerCamelCase,np.array(__lowerCamelCase					),np.array(__lowerCamelCase					),return_tensors='''tf'''					)

        self.assertEqual(masks[0].shape,(1, 3, 1764, 2646)					)

        A__		   =		[[1, 0], [0, 1]]
        with self.assertRaises(tf.errors.InvalidArgumentError					):
               A__		   =		processor.post_process_masks(
                   __lowerCamelCase,np.array(__lowerCamelCase					),np.array(__lowerCamelCase					),return_tensors='''tf'''					)




@require_vision
@require_torchvision
class        SCREAMING_SNAKE_CASE__					(		unittest.TestCase ):



 def 							UpperCamelCase     (				self					):
        A__		   =		tempfile.mkdtemp()
        A__		   =		SamImageProcessor()
        A__		   =		SamProcessor(__lowerCamelCase					)
        processor.save_pretrained(self.tmpdirname					)



 def 							UpperCamelCase     (				self,**__lowerCamelCase					):
        return AutoProcessor.from_pretrained(self.tmpdirname,**__lowerCamelCase					).image_processor



 def 							UpperCamelCase     (				self					):
        shutil.rmtree(self.tmpdirname					)



 def 							UpperCamelCase     (				self					):
        A__		   =		[np.random.randint(255,size=(3, 30, 400),dtype=np.uinta					)]

        A__		   =		[Image.fromarray(np.moveaxis(__lowerCamelCase,0,-1					)					) for x in image_inputs]

        return image_inputs



 @is_pt_tf_cross_test
 def 							UpperCamelCase     (				self					):
        A__		   =		self.get_image_processor()

        A__		   =		SamProcessor(image_processor=__lowerCamelCase					)
        A__		   =		np.random.randint(0,2,size=(1, 3, 5, 5)					).astype(np.floataa					)
        A__		   =		[tf.convert_to_tensor(__lowerCamelCase					)]
        A__		   =		[torch.tensor(__lowerCamelCase					)]

        A__		   =		[[1764, 2646]]

        A__		   =		[[683, 1024]]
        A__		   =		processor.post_process_masks(
            __lowerCamelCase,__lowerCamelCase,__lowerCamelCase,return_tensors='''tf'''					)
        A__		   =		processor.post_process_masks(
            __lowerCamelCase,__lowerCamelCase,__lowerCamelCase,return_tensors='''pt'''					)

        self.assertTrue(np.all(tf_masks[0].numpy() == pt_masks[0].numpy()					)					)




 @is_pt_tf_cross_test
 def 							UpperCamelCase     (				self					):
        A__		   =		self.get_image_processor()

        A__		   =		SamProcessor(image_processor=__lowerCamelCase					)

        A__		   =		self.prepare_image_inputs()

        A__		   =		image_processor(__lowerCamelCase,return_tensors='''pt'''					)['''pixel_values'''].numpy()
        A__		   =		processor(images=__lowerCamelCase,return_tensors='''pt'''					)['''pixel_values'''].numpy()

        A__		   =		image_processor(__lowerCamelCase,return_tensors='''tf'''					)['''pixel_values'''].numpy()
        A__		   =		processor(images=__lowerCamelCase,return_tensors='''tf'''					)['''pixel_values'''].numpy()

        self.assertTrue(np.allclose(__lowerCamelCase,__lowerCamelCase					)					)
        self.assertTrue(np.allclose(__lowerCamelCase,__lowerCamelCase					)					)
        self.assertTrue(np.allclose(__lowerCamelCase,__lowerCamelCase					)					)





