

'''simple docstring'''







from typing import Dict, Iterable, List, Optional, Union

import numpy as np

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_DEFAULT_MEAN,
    IMAGENET_DEFAULT_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, logging


__lowerCamelCase									=     logging.get_logger(__name__)


class        A__   (   _snake_case      ):
    lowercase						       =		["pixel_values"]



    def __init__(       self		,					UpperCamelCase__ = True		,					UpperCamelCase__ = None		,					UpperCamelCase__ = PILImageResampling.BICUBIC		,					UpperCamelCase__ = True		,					UpperCamelCase__ = None		,					UpperCamelCase__ = True		,					UpperCamelCase__ = 1 / 255		,					UpperCamelCase__ = True		,					UpperCamelCase__ = IMAGENET_DEFAULT_MEAN		,					UpperCamelCase__ = IMAGENET_DEFAULT_STD		,					**UpperCamelCase__		,					)    ->   None:





           '''simple docstring'''
           super().__init__(**UpperCamelCase__							)
           A_						       =   size if size is not None else {"""shortest_edge""": 224}
           A_						       =   get_size_dict(UpperCamelCase__		,					default_to_square=UpperCamelCase__							)
           A_						       =   crop_size if crop_size is not None else {"""height""": 224, """width""": 224}
           A_						       =   get_size_dict(UpperCamelCase__		,					param_name="""crop_size"""							)

           A_						       =   do_resize
           A_						       =   size
           A_						       =   resample
           A_						       =   do_center_crop
           A_						       =   crop_size
           A_						       =   do_rescale
           A_						       =   rescale_factor
           A_						       =   do_normalize
           A_						       =   image_mean if image_mean is not None else IMAGENET_DEFAULT_MEAN
           A_						       =   image_std if image_std is not None else IMAGENET_DEFAULT_STD



    def        snake_case_      (       self		,					UpperCamelCase__		,					UpperCamelCase__		,					UpperCamelCase__ = PILImageResampling.BICUBIC		,					UpperCamelCase__ = None		,					**UpperCamelCase__		,					)    ->   np.ndarray:





           '''simple docstring'''
           A_						       =   get_size_dict(UpperCamelCase__		,					default_to_square=UpperCamelCase__							)
           # size_dict is a dict with either keys "height" and "width" or "shortest_edge"
           if "shortest_edge" in size:
                  A_						       =   int((256 / 224) * size["""shortest_edge"""]							)
                  A_						       =   get_resize_output_image_size(UpperCamelCase__		,					size=UpperCamelCase__		,					default_to_square=UpperCamelCase__							)
                  A_						       =   {"""height""": output_size[0], """width""": output_size[1]}
           if "height" not in size_dict or "width" not in size_dict:
                  raise ValueError(
                      f'''Size dict must have keys \'height\' and \'width\' or \'shortest_edge\'. Got {size_dict.keys()}'''							)
           return resize(
               UpperCamelCase__		,					size=(size_dict["""height"""], size_dict["""width"""])		,					resample=UpperCamelCase__		,					data_format=UpperCamelCase__		,					**UpperCamelCase__							)



    def        snake_case_      (       self		,					UpperCamelCase__		,					UpperCamelCase__		,					UpperCamelCase__ = None		,					**UpperCamelCase__		,					)    ->   np.ndarray:





           '''simple docstring'''
           A_						       =   get_size_dict(UpperCamelCase__							)
           if "height" not in size or "width" not in size:
                  raise ValueError(f'''Size dict must have keys \'height\' and \'width\'. Got {size.keys()}'''							)
           return center_crop(UpperCamelCase__		,					size=(size["""height"""], size["""width"""])		,					data_format=UpperCamelCase__		,					**UpperCamelCase__							)



    def        snake_case_      (       self		,					UpperCamelCase__		,					UpperCamelCase__		,					UpperCamelCase__ = None		,					**UpperCamelCase__		,					)    ->   np.ndarray:





           '''simple docstring'''
           return rescale(UpperCamelCase__		,					scale=UpperCamelCase__		,					data_format=UpperCamelCase__		,					**UpperCamelCase__							)



    def        snake_case_      (       self		,					UpperCamelCase__		,					UpperCamelCase__		,					UpperCamelCase__		,					UpperCamelCase__ = None		,					**UpperCamelCase__		,					)    ->   np.ndarray:





           '''simple docstring'''
           return normalize(UpperCamelCase__		,					mean=UpperCamelCase__		,					std=UpperCamelCase__		,					data_format=UpperCamelCase__		,					**UpperCamelCase__							)







    def        snake_case_      (       self		,					UpperCamelCase__		,					UpperCamelCase__ = None		,					UpperCamelCase__ = None		,					UpperCamelCase__ = None		,					UpperCamelCase__ = None		,					UpperCamelCase__ = None		,					UpperCamelCase__ = None		,					UpperCamelCase__ = None		,					UpperCamelCase__ = None		,					UpperCamelCase__ = None		,					UpperCamelCase__ = None		,					UpperCamelCase__ = None		,					UpperCamelCase__ = ChannelDimension.FIRST		,					**UpperCamelCase__		,					)    ->   BatchFeature:





           '''simple docstring'''
           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_						       =   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(UpperCamelCase__		,					default_to_square=UpperCamelCase__							)
           A_						       =   crop_size if crop_size is not None else self.crop_size
           A_						       =   get_size_dict(UpperCamelCase__		,					param_name="""crop_size"""							)

           A_						       =   make_list_of_images(UpperCamelCase__							)

           if not valid_images(UpperCamelCase__							):
                  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:
                  raise ValueError("""Size 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."""							)

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

           if do_resize:
                  A_						       =   [self.resize(UpperCamelCase__		,					UpperCamelCase__		,					UpperCamelCase__							) for image in images]

           if do_center_crop:
                  A_						       =   [self.center_crop(UpperCamelCase__		,					UpperCamelCase__							) for image in images]

           if do_rescale:
                  A_						       =   [self.rescale(UpperCamelCase__		,					UpperCamelCase__							) for image in images]

           if do_normalize:
                  A_						       =   [self.normalize(UpperCamelCase__		,					UpperCamelCase__		,					UpperCamelCase__							) for image in images]

           A_						       =   [to_channel_dimension_format(UpperCamelCase__		,					UpperCamelCase__							) for image in images]

           A_						       =   {"""pixel_values""": images}
           return BatchFeature(data=UpperCamelCase__		,					tensor_type=UpperCamelCase__							)



'''simple docstring'''







import warnings
from typing import List

import numpy as np

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


class        A__   (   _snake_case      ):
    lowercase						       =		["image_processor", "tokenizer"]
    lowercase						       =		"OwlViTImageProcessor"
    lowercase						       =		("CLIPTokenizer", "CLIPTokenizerFast")



    def __init__(       self		,					UpperCamelCase__=None		,					UpperCamelCase__=None		,					**UpperCamelCase__							)    ->   str:





           '''simple docstring'''
           A_						       =   None
           if "feature_extractor" in kwargs:
                  warnings.warn(
                      """The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`"""
                      """ instead."""		,					UpperCamelCase__		,					)
                  A_						       =   kwargs.pop("""feature_extractor"""							)

           A_						       =   image_processor if image_processor is not None else feature_extractor
           if image_processor is None:
                  raise ValueError("""You need to specify an `image_processor`."""							)
           if tokenizer is None:
                  raise ValueError("""You need to specify a `tokenizer`."""							)

           super().__init__(UpperCamelCase__		,					UpperCamelCase__							)



    def __call__(       self		,					UpperCamelCase__=None		,					UpperCamelCase__=None		,					UpperCamelCase__=None		,					UpperCamelCase__="max_length"		,					UpperCamelCase__="np"		,					**UpperCamelCase__							)    ->   int:





           '''simple docstring'''

           if text is None and query_images is None and images is None:
                  raise ValueError(
                      """You have to specify at least one text or query image or image. All three cannot be none."""							)

           if text is not None:
                  if isinstance(UpperCamelCase__		,					UpperCamelCase__							) or (isinstance(UpperCamelCase__		,					UpperCamelCase__							) and not isinstance(text[0]		,					UpperCamelCase__							)):
                         A_						       =   [self.tokenizer(UpperCamelCase__		,					padding=UpperCamelCase__		,					return_tensors=UpperCamelCase__		,					**UpperCamelCase__							)]

                  elif isinstance(UpperCamelCase__		,					UpperCamelCase__							) and isinstance(text[0]		,					UpperCamelCase__							):
                         A_						       =   []

                         # Maximum number of queries across batch
                         A_						       =   max([len(UpperCamelCase__							) for t in text]							)

                         # Pad all batch samples to max number of text queries
                         for t in text:
                                if len(UpperCamelCase__							) != max_num_queries:
                                       A_						       =   t + [""" """] * (max_num_queries - len(UpperCamelCase__							))

                                A_						       =   self.tokenizer(UpperCamelCase__		,					padding=UpperCamelCase__		,					return_tensors=UpperCamelCase__		,					**UpperCamelCase__							)
                                encodings.append(UpperCamelCase__							)
                  else:
                         raise TypeError("""Input text should be a string, a list of strings or a nested list of strings"""							)

                  if return_tensors == "np":
                         A_						       =   np.concatenate([encoding["""input_ids"""] for encoding in encodings]		,					axis=0							)
                         A_						       =   np.concatenate([encoding["""attention_mask"""] for encoding in encodings]		,					axis=0							)

                  elif return_tensors == "jax" and is_flax_available():
                         import jax.numpy as jnp

                         A_						       =   jnp.concatenate([encoding["""input_ids"""] for encoding in encodings]		,					axis=0							)
                         A_						       =   jnp.concatenate([encoding["""attention_mask"""] for encoding in encodings]		,					axis=0							)

                  elif return_tensors == "pt" and is_torch_available():
                         import torch

                         A_						       =   torch.cat([encoding["""input_ids"""] for encoding in encodings]		,					dim=0							)
                         A_						       =   torch.cat([encoding["""attention_mask"""] for encoding in encodings]		,					dim=0							)

                  elif return_tensors == "tf" and is_tf_available():
                         import tensorflow as tf

                         A_						       =   tf.stack([encoding["""input_ids"""] for encoding in encodings]		,					axis=0							)
                         A_						       =   tf.stack([encoding["""attention_mask"""] for encoding in encodings]		,					axis=0							)

                  else:
                         raise ValueError("""Target return tensor type could not be returned"""							)

                  A_						       =   BatchEncoding()
                  A_						       =   input_ids
                  A_						       =   attention_mask

           if query_images is not None:
                  A_						       =   BatchEncoding()
                  A_						       =   self.image_processor(
                      UpperCamelCase__		,					return_tensors=UpperCamelCase__		,					**UpperCamelCase__							).pixel_values
                  A_						       =   query_pixel_values

           if images is not None:
                  A_						       =   self.image_processor(UpperCamelCase__		,					return_tensors=UpperCamelCase__		,					**UpperCamelCase__							)

           if text is not None and images is not None:
                  A_						       =   image_features.pixel_values
                  return encoding
           elif query_images is not None and images is not None:
                  A_						       =   image_features.pixel_values
                  return encoding
           elif text is not None or query_images is not None:
                  return encoding
           else:
                  return BatchEncoding(data=dict(**UpperCamelCase__							)		,					tensor_type=UpperCamelCase__							)



    def        snake_case_      (       self		,					*UpperCamelCase__		,					**UpperCamelCase__							)    ->   int:





           '''simple docstring'''
           return self.image_processor.post_process(*UpperCamelCase__		,					**UpperCamelCase__							)



    def        snake_case_      (       self		,					*UpperCamelCase__		,					**UpperCamelCase__							)    ->   List[Any]:





           '''simple docstring'''
           return self.image_processor.post_process_object_detection(*UpperCamelCase__		,					**UpperCamelCase__							)



    def        snake_case_      (       self		,					*UpperCamelCase__		,					**UpperCamelCase__							)    ->   Tuple:





           '''simple docstring'''
           return self.image_processor.post_process_image_guided_detection(*UpperCamelCase__		,					**UpperCamelCase__							)



    def        snake_case_      (       self		,					*UpperCamelCase__		,					**UpperCamelCase__							)    ->   Any:





           '''simple docstring'''
           return self.tokenizer.batch_decode(*UpperCamelCase__		,					**UpperCamelCase__							)



    def        snake_case_      (       self		,					*UpperCamelCase__		,					**UpperCamelCase__							)    ->   List[str]:





           '''simple docstring'''
           return self.tokenizer.decode(*UpperCamelCase__		,					**UpperCamelCase__							)



    @property
    def        snake_case_      (       self							)    ->   Optional[int]:





           '''simple docstring'''
           warnings.warn(
               """`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead."""		,					UpperCamelCase__		,					)
           return self.image_processor_class







    @property
    def        snake_case_      (       self							)    ->   List[str]:





           '''simple docstring'''
           warnings.warn(
               """`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead."""		,					UpperCamelCase__		,					)
           return self.image_processor
