

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


lowerCAmelCase__						 =			logging.get_logger(__name__)

lowerCAmelCase__						 =			{
    """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__    (       snake_case_      ):
			"""simple docstring"""







			__lowerCamelCase										=							"""owlvit_text_model"""


			def __init__(     self   ,   lowercase=49408   ,   lowercase=512   ,   lowercase=2048   ,   lowercase=12   ,   lowercase=8   ,   lowercase=16   ,   lowercase="quick_gelu"   ,   lowercase=1e-5   ,   lowercase=0.0   ,   lowercase=0.02   ,   lowercase=1.0   ,   lowercase=0   ,   lowercase=49406   ,   lowercase=49407   ,   **lowercase   ,   )	->    Union[str, Any]:
							'''simple docstring'''






							super().__init__(pad_token_id=lowercase   ,   bos_token_id=lowercase   ,   eos_token_id=lowercase   ,   **lowercase							)

							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   ,   lowercase   ,   **lowercase							)	->    List[str]:
							'''simple docstring'''






							cls._set_token_in_kwargs(lowercase							)

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

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

class        a__    (       snake_case_      ):
			"""simple docstring"""







			__lowerCamelCase										=							"""owlvit_vision_model"""


			def __init__(     self   ,   lowercase=768   ,   lowercase=3072   ,   lowercase=12   ,   lowercase=12   ,   lowercase=3   ,   lowercase=768   ,   lowercase=32   ,   lowercase="quick_gelu"   ,   lowercase=1e-5   ,   lowercase=0.0   ,   lowercase=0.02   ,   lowercase=1.0   ,   **lowercase   ,   )	->    Any:
							'''simple docstring'''






							super().__init__(**lowercase							)

							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   ,   lowercase   ,   **lowercase							)	->    Optional[Any]:
							'''simple docstring'''






							cls._set_token_in_kwargs(lowercase							)

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

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

class        a__    (       snake_case_      ):
			"""simple docstring"""







			__lowerCamelCase										=							"""owlvit"""
			__lowerCamelCase										=							True


			def __init__(     self   ,   lowercase=None   ,   lowercase=None   ,   lowercase=512   ,   lowercase=2.6592   ,   lowercase=True   ,   **lowercase   ,   )	->    List[Any]:
							'''simple docstring'''






							super().__init__(**lowercase							)

							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(**lowercase							)
							A__          =      OwlViTVisionConfig(**lowercase							)

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


			@classmethod
			def   UpperCamelCase		(     cls   ,   lowercase   ,   **lowercase							)	->    Any:
							'''simple docstring'''






							cls._set_token_in_kwargs(lowercase							)

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

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


			@classmethod
			def   UpperCamelCase		(     cls   ,   lowercase   ,   lowercase   ,   **lowercase							)	->    List[str]:
							'''simple docstring'''






							A__          =      {}
							A__          =      text_config
							A__          =      vision_config

							return cls.from_dict(lowercase   ,   **lowercase							)


			def   UpperCamelCase		(     self							)	->    Dict:
							'''simple docstring'''






							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__    (       snake_case_      ):
			"""simple docstring"""







			@property
			def   UpperCamelCase		(     self							)	->    Dict:
							'''simple docstring'''






							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							)	->    List[str]:
							'''simple docstring'''






							return OrderedDict(
							    [
							        ("logits_per_image", {0: "batch"}),
							        ("logits_per_text", {0: "batch"}),
							        ("text_embeds", {0: "batch"}),
							        ("image_embeds", {0: "batch"}),
							    ]							)


			@property
			def   UpperCamelCase		(     self							)	->    Union[str, Any]:
							'''simple docstring'''






							return 1e-4


			def   UpperCamelCase		(     self   ,   lowercase   ,   lowercase = -1   ,   lowercase = -1   ,   lowercase = None   ,   )	->    Union[str, Any]:
							'''simple docstring'''






							A__          =      super().generate_dummy_inputs(
							    processor.tokenizer   ,   batch_size=lowercase   ,   seq_length=lowercase   ,   framework=lowercase							)
							A__          =      super().generate_dummy_inputs(
							    processor.image_processor   ,   batch_size=lowercase   ,   framework=lowercase							)
							return {**text_input_dict, **image_input_dict}


			@property
			def   UpperCamelCase		(     self							)	->    Any:
							'''simple docstring'''






							return 14


"""simple docstring"""



from typing import Dict, List, Optional, Union

import numpy as np

from transformers.utils import is_vision_available
from transformers.utils.generic import TensorType

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    center_crop,
    get_resize_output_image_size,
    normalize,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    is_valid_image,
    to_numpy_array,
    valid_images,
)
from ...utils import logging


if is_vision_available():
   import PIL

SCREAMING_SNAKE_CASE__:Tuple									=			logging.get_logger(__name__)



def 	_lowerCamelCase(	a				):
       if isinstance(a   ,    (list, tuple)				) and isinstance(videos[0]   ,    (list, tuple)				) and is_valid_image(videos[0][0]				):
              return videos

       elif isinstance(a   ,    (list, tuple)				) and is_valid_image(videos[0]				):
              return [videos]

       elif is_valid_image(a				):
              return [[videos]]

       raise ValueError(F"Could not make batched video from {videos}"				)






class  snake_case__      (       snake_case_       ):
 _snake_case       :					List[Any]							  =						["""pixel_values"""]


 def __init__( self    ,		lowerCamelCase = True    ,		lowerCamelCase = None    ,		lowerCamelCase = PILImageResampling.BILINEAR    ,		lowerCamelCase = True    ,		lowerCamelCase = None    ,		lowerCamelCase = True    ,		lowerCamelCase = 1 / 255    ,		lowerCamelCase = True    ,		lowerCamelCase = True    ,		lowerCamelCase = None    ,		lowerCamelCase = None    ,		**lowerCamelCase    ,		):
        super().__init__(**lowerCamelCase						)
        __a       =    size if size is not None else {"shortest_edge": 256}
        __a       =    get_size_dict(lowerCamelCase    ,		default_to_square=lowerCamelCase						)
        __a       =    crop_size if crop_size is not None else {"height": 224, "width": 224}
        __a       =    get_size_dict(lowerCamelCase    ,		param_name="crop_size"						)

        __a       =    do_resize
        __a       =    size
        __a       =    do_center_crop
        __a       =    crop_size
        __a       =    resample
        __a       =    do_rescale
        __a       =    rescale_factor
        __a       =    offset
        __a       =    do_normalize
        __a       =    image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
        __a       =    image_std if image_std is not None else IMAGENET_STANDARD_STD


 def 						a__   ( self    ,		lowerCamelCase    ,		lowerCamelCase    ,		lowerCamelCase = PILImageResampling.BILINEAR    ,		lowerCamelCase = None    ,		**lowerCamelCase    ,		):
        __a       =    get_size_dict(lowerCamelCase    ,		default_to_square=lowerCamelCase						)
        if "shortest_edge" in size:
               __a       =    get_resize_output_image_size(lowerCamelCase    ,		size["shortest_edge"]    ,		default_to_square=lowerCamelCase						)
        elif "height" in size and "width" in size:
               __a       =    (size["height"], size["width"])
        else:
               raise ValueError(F"Size must have 'height' and 'width' or 'shortest_edge' as keys. Got {size.keys()}"						)
        return resize(lowerCamelCase    ,		size=lowerCamelCase    ,		resample=lowerCamelCase    ,		data_format=lowerCamelCase    ,		**lowerCamelCase						)


 def 						a__   ( self    ,		lowerCamelCase    ,		lowerCamelCase    ,		lowerCamelCase = None    ,		**lowerCamelCase    ,		):
        __a       =    get_size_dict(lowerCamelCase						)
        if "height" not in size or "width" not in size:
               raise ValueError(F"Size must have 'height' and 'width' as keys. Got {size.keys()}"						)
        return center_crop(lowerCamelCase    ,		size=(size["height"], size["width"])    ,		data_format=lowerCamelCase    ,		**lowerCamelCase						)


 def 						a__   ( self    ,		lowerCamelCase    ,		lowerCamelCase    ,		lowerCamelCase = True    ,		lowerCamelCase = None    ,		**lowerCamelCase    ,		):
        __a       =    image.astype(np.floataa						)
        if offset:
               __a       =    image - (scale / 2)
        return rescale(lowerCamelCase    ,		scale=lowerCamelCase    ,		data_format=lowerCamelCase    ,		**lowerCamelCase						)


 def 						a__   ( self    ,		lowerCamelCase    ,		lowerCamelCase    ,		lowerCamelCase    ,		lowerCamelCase = None    ,		**lowerCamelCase    ,		):
        return normalize(lowerCamelCase    ,		mean=lowerCamelCase    ,		std=lowerCamelCase    ,		data_format=lowerCamelCase    ,		**lowerCamelCase						)


 def 						a__   ( self    ,		lowerCamelCase    ,		lowerCamelCase = None    ,		lowerCamelCase = None    ,		lowerCamelCase = None    ,		lowerCamelCase = None    ,		lowerCamelCase = None    ,		lowerCamelCase = None    ,		lowerCamelCase = None    ,		lowerCamelCase = None    ,		lowerCamelCase = None    ,		lowerCamelCase = None    ,		lowerCamelCase = None    ,		lowerCamelCase = ChannelDimension.FIRST    ,		):
        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_center_crop and crop_size is None:
               raise ValueError("Crop size must be specified if do_center_crop 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."						)

        if offset and not do_rescale:
               raise ValueError("For offset, do_rescale must also be set to True."						)

        # All transformations expect numpy arrays.
        __a       =    to_numpy_array(lowerCamelCase						)

        if do_resize:
               __a       =    self.resize(image=lowerCamelCase    ,		size=lowerCamelCase    ,		resample=lowerCamelCase						)

        if do_center_crop:
               __a       =    self.center_crop(lowerCamelCase    ,		size=lowerCamelCase						)

        if do_rescale:
               __a       =    self.rescale(image=lowerCamelCase    ,		scale=lowerCamelCase    ,		offset=lowerCamelCase						)

        if do_normalize:
               __a       =    self.normalize(image=lowerCamelCase    ,		mean=lowerCamelCase    ,		std=lowerCamelCase						)

        __a       =    to_channel_dimension_format(lowerCamelCase    ,		lowerCamelCase						)
        return image






 def 						a__   ( self    ,		lowerCamelCase    ,		lowerCamelCase = None    ,		lowerCamelCase = None    ,		lowerCamelCase = None    ,		lowerCamelCase = None    ,		lowerCamelCase = None    ,		lowerCamelCase = None    ,		lowerCamelCase = None    ,		lowerCamelCase = None    ,		lowerCamelCase = None    ,		lowerCamelCase = None    ,		lowerCamelCase = None    ,		lowerCamelCase = None    ,		lowerCamelCase = ChannelDimension.FIRST    ,		**lowerCamelCase    ,		):
        __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_center_crop if do_center_crop is not None else self.do_center_crop
        __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       =    offset if offset is not None else self.offset
        __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       =    size if size is not None else self.size
        __a       =    get_size_dict(lowerCamelCase    ,		default_to_square=lowerCamelCase						)
        __a       =    crop_size if crop_size is not None else self.crop_size
        __a       =    get_size_dict(lowerCamelCase    ,		param_name="crop_size"						)

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

        __a       =    make_batched(lowerCamelCase						)

        __a       =    [
            [
                self._preprocess_image(
                    image=lowerCamelCase    ,		do_resize=lowerCamelCase    ,		size=lowerCamelCase    ,		resample=lowerCamelCase    ,		do_center_crop=lowerCamelCase    ,		crop_size=lowerCamelCase    ,		do_rescale=lowerCamelCase    ,		rescale_factor=lowerCamelCase    ,		offset=lowerCamelCase    ,		do_normalize=lowerCamelCase    ,		image_mean=lowerCamelCase    ,		image_std=lowerCamelCase    ,		data_format=lowerCamelCase    ,		)
                for img in video
            ]
            for video in videos
        ]

        __a       =    {"pixel_values": videos}
        return BatchFeature(data=lowerCamelCase    ,		tensor_type=lowerCamelCase						)
