from typing import Dict, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import convert_to_rgb, normalize, rescale, resize, to_channel_dimension_format
from ...image_utils import (
    OPENAI_CLIP_MEAN,
    OPENAI_CLIP_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


if is_vision_available():
  import PIL


SCREAMING_SNAKE_CASE			:						List[Any]				  =		logging.get_logger(__name__)
class  A_			(							a_			):
  _SCREAMING_SNAKE_CASE     					=      ["""pixel_values"""]

  def __init__(		self			:   Any  ,				__SCREAMING_SNAKE_CASE			:   bool = True  ,				__SCREAMING_SNAKE_CASE			:   Dict[str, int] = None  ,				__SCREAMING_SNAKE_CASE			:   PILImageResampling = PILImageResampling.BICUBIC  ,				__SCREAMING_SNAKE_CASE			:   bool = True  ,				__SCREAMING_SNAKE_CASE			:   Union[int, float] = 1 / 2_55  ,				__SCREAMING_SNAKE_CASE			:   bool = True  ,				__SCREAMING_SNAKE_CASE			:   Optional[Union[float, List[float]]] = None  ,				__SCREAMING_SNAKE_CASE			:   Optional[Union[float, List[float]]] = None  ,				__SCREAMING_SNAKE_CASE			:   bool = True  ,				**__SCREAMING_SNAKE_CASE			:   Optional[int]  ,				):
   super().__init__(**__SCREAMING_SNAKE_CASE							)
   __a							=	size if size is not None else {"height": 3_84, "width": 3_84}
   __a							=	get_size_dict(__SCREAMING_SNAKE_CASE  ,				default_to_square=__SCREAMING_SNAKE_CASE							)

   __a							=	do_resize
   __a							=	size
   __a							=	resample
   __a							=	do_rescale
   __a							=	rescale_factor
   __a							=	do_normalize
   __a							=	image_mean if image_mean is not None else OPENAI_CLIP_MEAN
   __a							=	image_std if image_std is not None else OPENAI_CLIP_STD
   __a							=	do_convert_rgb

  def 		_UpperCAmelCase (		self			:   Optional[int]  ,				__SCREAMING_SNAKE_CASE			:   np.ndarray  ,				__SCREAMING_SNAKE_CASE			:   Dict[str, int]  ,				__SCREAMING_SNAKE_CASE			:   PILImageResampling = PILImageResampling.BICUBIC  ,				__SCREAMING_SNAKE_CASE			:   Optional[Union[str, ChannelDimension]] = None  ,				**__SCREAMING_SNAKE_CASE			:   Any  ,				):
   __a							=	get_size_dict(__SCREAMING_SNAKE_CASE  ,				default_to_square=__SCREAMING_SNAKE_CASE							)
   if "height" not in size or "width" not in size:
    raise ValueError(f"""The `size` dictionary must contain the keys `height` and `width`. Got {size.keys()}"""							)
   __a							=	(size["height"], size["width"])
   return resize(__SCREAMING_SNAKE_CASE  ,				size=__SCREAMING_SNAKE_CASE  ,				resample=__SCREAMING_SNAKE_CASE  ,				data_format=__SCREAMING_SNAKE_CASE  ,				**__SCREAMING_SNAKE_CASE							)

  def 		_UpperCAmelCase (		self			:   Tuple  ,				__SCREAMING_SNAKE_CASE			:   np.ndarray  ,				__SCREAMING_SNAKE_CASE			:   Union[int, float]  ,				__SCREAMING_SNAKE_CASE			:   Optional[Union[str, ChannelDimension]] = None  ,				**__SCREAMING_SNAKE_CASE			:   str  ,				):
   return rescale(__SCREAMING_SNAKE_CASE  ,				scale=__SCREAMING_SNAKE_CASE  ,				data_format=__SCREAMING_SNAKE_CASE  ,				**__SCREAMING_SNAKE_CASE							)

  def 		_UpperCAmelCase (		self			:   Optional[Any]  ,				__SCREAMING_SNAKE_CASE			:   np.ndarray  ,				__SCREAMING_SNAKE_CASE			:   Union[float, List[float]]  ,				__SCREAMING_SNAKE_CASE			:   Union[float, List[float]]  ,				__SCREAMING_SNAKE_CASE			:   Optional[Union[str, ChannelDimension]] = None  ,				**__SCREAMING_SNAKE_CASE			:   int  ,				):
   return normalize(__SCREAMING_SNAKE_CASE  ,				mean=__SCREAMING_SNAKE_CASE  ,				std=__SCREAMING_SNAKE_CASE  ,				data_format=__SCREAMING_SNAKE_CASE  ,				**__SCREAMING_SNAKE_CASE							)

  def 		_UpperCAmelCase (		self			:   List[str]  ,				__SCREAMING_SNAKE_CASE			:   ImageInput  ,				__SCREAMING_SNAKE_CASE			:   Optional[bool] = None  ,				__SCREAMING_SNAKE_CASE			:   Optional[Dict[str, int]] = None  ,				__SCREAMING_SNAKE_CASE			:   PILImageResampling = None  ,				__SCREAMING_SNAKE_CASE			:   Optional[bool] = None  ,				__SCREAMING_SNAKE_CASE			:   Optional[float] = None  ,				__SCREAMING_SNAKE_CASE			:   Optional[bool] = None  ,				__SCREAMING_SNAKE_CASE			:   Optional[Union[float, List[float]]] = None  ,				__SCREAMING_SNAKE_CASE			:   Optional[Union[float, List[float]]] = None  ,				__SCREAMING_SNAKE_CASE			:   Optional[Union[str, TensorType]] = None  ,				__SCREAMING_SNAKE_CASE			:   bool = None  ,				__SCREAMING_SNAKE_CASE			:   ChannelDimension = ChannelDimension.FIRST  ,				**__SCREAMING_SNAKE_CASE			:   Any  ,				):
   __a							=	do_resize if do_resize is not None else self.do_resize
   __a							=	resample if resample is not None else self.resample
   __a							=	do_rescale if do_rescale is not None else self.do_rescale
   __a							=	rescale_factor if rescale_factor is not None else self.rescale_factor
   __a							=	do_normalize if do_normalize is not None else self.do_normalize
   __a							=	image_mean if image_mean is not None else self.image_mean
   __a							=	image_std if image_std is not None else self.image_std
   __a							=	do_convert_rgb if do_convert_rgb is not None else self.do_convert_rgb

   __a							=	size if size is not None else self.size
   __a							=	get_size_dict(__SCREAMING_SNAKE_CASE  ,				default_to_square=__SCREAMING_SNAKE_CASE							)

   __a							=	make_list_of_images(__SCREAMING_SNAKE_CASE							)

   if not valid_images(__SCREAMING_SNAKE_CASE							):
    raise ValueError(
        "Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, "
        "torch.Tensor, tf.Tensor or jax.ndarray."							)

   if do_resize and size is None or resample is None:
    raise ValueError("Size and resample must be specified if do_resize is True."							)

   if do_rescale and rescale_factor is None:
    raise ValueError("Rescale factor must be specified if do_rescale is True."							)

   if do_normalize and (image_mean is None or image_std is None):
    raise ValueError("Image mean and std must be specified if do_normalize is True."							)

   # PIL RGBA images are converted to RGB
   if do_convert_rgb:
    __a							=	[convert_to_rgb(__SCREAMING_SNAKE_CASE							) for image in images]

   # All transformations expect numpy arrays.
   __a							=	[to_numpy_array(__SCREAMING_SNAKE_CASE							) for image in images]

   if do_resize:
    __a							=	[self.resize(image=__SCREAMING_SNAKE_CASE  ,				size=__SCREAMING_SNAKE_CASE  ,				resample=__SCREAMING_SNAKE_CASE							) for image in images]

   if do_rescale:
    __a							=	[self.rescale(image=__SCREAMING_SNAKE_CASE  ,				scale=__SCREAMING_SNAKE_CASE							) for image in images]

   if do_normalize:
    __a							=	[self.normalize(image=__SCREAMING_SNAKE_CASE  ,				mean=__SCREAMING_SNAKE_CASE  ,				std=__SCREAMING_SNAKE_CASE							) for image in images]

   __a							=	[to_channel_dimension_format(__SCREAMING_SNAKE_CASE  ,				__SCREAMING_SNAKE_CASE							) for image in images]

   __a							=	BatchFeature(data={"pixel_values": images}  ,				tensor_type=__SCREAMING_SNAKE_CASE							)

   return encoded_outputs



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


SCREAMING_SNAKE_CASE			:						Dict				  =		logging.get_logger(__name__)

SCREAMING_SNAKE_CASE			:						Tuple				  =		{
    """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  A_			(							a_			):
  _SCREAMING_SNAKE_CASE     					=      """owlvit_text_model"""

  def __init__(		self			:   List[str]  ,				__SCREAMING_SNAKE_CASE			:   Union[str, Any]=4_94_08  ,				__SCREAMING_SNAKE_CASE			:   List[Any]=5_12  ,				__SCREAMING_SNAKE_CASE			:   Optional[Any]=20_48  ,				__SCREAMING_SNAKE_CASE			:   Optional[int]=12  ,				__SCREAMING_SNAKE_CASE			:   Tuple=8  ,				__SCREAMING_SNAKE_CASE			:   Optional[Any]=16  ,				__SCREAMING_SNAKE_CASE			:   Tuple="quick_gelu"  ,				__SCREAMING_SNAKE_CASE			:   Union[str, Any]=1E-5  ,				__SCREAMING_SNAKE_CASE			:   Any=0.0  ,				__SCREAMING_SNAKE_CASE			:   List[str]=0.02  ,				__SCREAMING_SNAKE_CASE			:   int=1.0  ,				__SCREAMING_SNAKE_CASE			:   int=0  ,				__SCREAMING_SNAKE_CASE			:   Optional[Any]=4_94_06  ,				__SCREAMING_SNAKE_CASE			:   Optional[Any]=4_94_07  ,				**__SCREAMING_SNAKE_CASE			:   Union[str, Any]  ,				):
   super().__init__(pad_token_id=__SCREAMING_SNAKE_CASE  ,				bos_token_id=__SCREAMING_SNAKE_CASE  ,				eos_token_id=__SCREAMING_SNAKE_CASE  ,				**__SCREAMING_SNAKE_CASE							)

   __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			:   int  ,				__SCREAMING_SNAKE_CASE			:   Union[str, os.PathLike]  ,				**__SCREAMING_SNAKE_CASE			:   Optional[int]							):
   cls._set_token_in_kwargs(__SCREAMING_SNAKE_CASE							)

   __a							,  __a							=	cls.get_config_dict(__SCREAMING_SNAKE_CASE  ,				**__SCREAMING_SNAKE_CASE							)

   # 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(__SCREAMING_SNAKE_CASE  ,				**__SCREAMING_SNAKE_CASE							)
class  A_			(							a_			):
  _SCREAMING_SNAKE_CASE     					=      """owlvit_vision_model"""

  def __init__(		self			:   List[str]  ,				__SCREAMING_SNAKE_CASE			:   Optional[Any]=7_68  ,				__SCREAMING_SNAKE_CASE			:   Any=30_72  ,				__SCREAMING_SNAKE_CASE			:   str=12  ,				__SCREAMING_SNAKE_CASE			:   int=12  ,				__SCREAMING_SNAKE_CASE			:   str=3  ,				__SCREAMING_SNAKE_CASE			:   Optional[Any]=7_68  ,				__SCREAMING_SNAKE_CASE			:   List[Any]=32  ,				__SCREAMING_SNAKE_CASE			:   Dict="quick_gelu"  ,				__SCREAMING_SNAKE_CASE			:   List[Any]=1E-5  ,				__SCREAMING_SNAKE_CASE			:   int=0.0  ,				__SCREAMING_SNAKE_CASE			:   Optional[Any]=0.02  ,				__SCREAMING_SNAKE_CASE			:   Dict=1.0  ,				**__SCREAMING_SNAKE_CASE			:   Optional[int]  ,				):
   super().__init__(**__SCREAMING_SNAKE_CASE							)

   __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			:   List[str]  ,				__SCREAMING_SNAKE_CASE			:   Union[str, os.PathLike]  ,				**__SCREAMING_SNAKE_CASE			:   Tuple							):
   cls._set_token_in_kwargs(__SCREAMING_SNAKE_CASE							)

   __a							,  __a							=	cls.get_config_dict(__SCREAMING_SNAKE_CASE  ,				**__SCREAMING_SNAKE_CASE							)

   # 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(__SCREAMING_SNAKE_CASE  ,				**__SCREAMING_SNAKE_CASE							)
class  A_			(							a_			):
  _SCREAMING_SNAKE_CASE     					=      """owlvit"""
  _SCREAMING_SNAKE_CASE     					=      True

  def __init__(		self			:   Dict  ,				__SCREAMING_SNAKE_CASE			:   Optional[int]=None  ,				__SCREAMING_SNAKE_CASE			:   Tuple=None  ,				__SCREAMING_SNAKE_CASE			:   str=5_12  ,				__SCREAMING_SNAKE_CASE			:   List[Any]=2.65_92  ,				__SCREAMING_SNAKE_CASE			:   Dict=True  ,				**__SCREAMING_SNAKE_CASE			:   List[Any]  ,				):
   super().__init__(**__SCREAMING_SNAKE_CASE							)

   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(**__SCREAMING_SNAKE_CASE							)
   __a							=	OwlViTVisionConfig(**__SCREAMING_SNAKE_CASE							)

   __a							=	projection_dim
   __a							=	logit_scale_init_value
   __a							=	return_dict
   __a							=	1.0

  @classmethod
  def 		_UpperCAmelCase (		cls			:   Tuple  ,				__SCREAMING_SNAKE_CASE			:   Union[str, os.PathLike]  ,				**__SCREAMING_SNAKE_CASE			:   List[str]							):
   cls._set_token_in_kwargs(__SCREAMING_SNAKE_CASE							)

   __a							,  __a							=	cls.get_config_dict(__SCREAMING_SNAKE_CASE  ,				**__SCREAMING_SNAKE_CASE							)

   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(__SCREAMING_SNAKE_CASE  ,				**__SCREAMING_SNAKE_CASE							)

  @classmethod
  def 		_UpperCAmelCase (		cls			:   List[Any]  ,				__SCREAMING_SNAKE_CASE			:   Dict  ,				__SCREAMING_SNAKE_CASE			:   Dict  ,				**__SCREAMING_SNAKE_CASE			:   Optional[Any]							):
   __a							=	{}
   __a							=	text_config
   __a							=	vision_config

   return cls.from_dict(__SCREAMING_SNAKE_CASE  ,				**__SCREAMING_SNAKE_CASE							)

  def 		_UpperCAmelCase (		self			:   Optional[Any]							):
   __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  A_			(							a_			):

  @property
  def 		_UpperCAmelCase (		self			:   Any							):
   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			:   Union[str, Any]							):
   return OrderedDict(
       [
           ("logits_per_image", {0: "batch"}),
           ("logits_per_text", {0: "batch"}),
           ("text_embeds", {0: "batch"}),
           ("image_embeds", {0: "batch"}),
       ]							)

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

  def 		_UpperCAmelCase (		self			:   Any  ,				__SCREAMING_SNAKE_CASE			:   "ProcessorMixin"  ,				__SCREAMING_SNAKE_CASE			:   int = -1  ,				__SCREAMING_SNAKE_CASE			:   int = -1  ,				__SCREAMING_SNAKE_CASE			:   Optional["TensorType"] = None  ,				):
   __a							=	super().generate_dummy_inputs(
       processor.tokenizer  ,				batch_size=__SCREAMING_SNAKE_CASE  ,				seq_length=__SCREAMING_SNAKE_CASE  ,				framework=__SCREAMING_SNAKE_CASE							)
   __a							=	super().generate_dummy_inputs(
       processor.image_processor  ,				batch_size=__SCREAMING_SNAKE_CASE  ,				framework=__SCREAMING_SNAKE_CASE							)
   return {**text_input_dict, **image_input_dict}

  @property
  def 		_UpperCAmelCase (		self			:   Optional[int]							):
   return 14


