


# Lint as: python3
import sys
from collections.abc import Mapping
from typing import TYPE_CHECKING, Dict, Optional

import numpy as np
import pyarrow as pa

from .. import config
from ..utils.logging import get_logger
from ..utils.py_utils import map_nested
from .formatting import TensorFormatter


if TYPE_CHECKING:
    import jax
    import jaxlib

__UpperCamelCase     :    Any 	=				get_logger()

__UpperCamelCase     :    Dict 	=				None



class 				_UpperCamelCase			(    TensorFormatter[Mapping, "jax.Array", Mapping]    ):

   '''simple docstring'''







   def __init__(	self	:			int							,	_lowerCamelCase	:			Any=None							,	_lowerCamelCase	:			List[Any]=None							,	**_lowerCamelCase	:			Dict				):






         '''simple docstring'''



         super().__init__(features=_lowerCamelCase				)
         import jax
         from jaxlib.xla_client import Device

         if isinstance(_lowerCamelCase							,	_lowerCamelCase				):
               raise ValueError(
                   F"""Expected {device} to be a `str` not {type(_lowerCamelCase				)}, as `jaxlib.xla_extension.Device` """
                   """is not serializable neither with `pickle` nor with `dill`. Instead you can surround """
                   """the device with `str()` to get its string identifier that will be internally mapped """
                   """to the actual `jaxlib.xla_extension.Device`."""				)
         __lowerCamelCase  :   Optional[int]							    =    device if isinstance(_lowerCamelCase							,	_lowerCamelCase				) else str(jax.devices()[0]				)
         # using global variable since `jaxlib.xla_extension.Device` is not serializable neither
         # with `pickle` nor with `dill`, so we need to use a global variable instead
         global DEVICE_MAPPING
         if DEVICE_MAPPING is None:
               __lowerCamelCase  :   str							    =    self._map_devices_to_str()
         if self.device not in list(DEVICE_MAPPING.keys()				):
               logger.warning(
                   F"""Device with string identifier {self.device} not listed among the available """
                   F"""devices: {list(DEVICE_MAPPING.keys()				)}, so falling back to the default """
                   F"""device: {str(jax.devices()[0]				)}."""				)
               __lowerCamelCase  :   Any							    =    str(jax.devices()[0]				)
         __lowerCamelCase  :   Optional[int]							    =    jnp_array_kwargs

   @staticmethod
   def 	_snake_case     (	):






         '''simple docstring'''



         import jax

         return {str(_lowerCamelCase				): device for device in jax.devices()}

   def 	_snake_case     (	self	:			str							,	_lowerCamelCase	:			List[Any]				):






         '''simple docstring'''



         import jax
         import jax.numpy as jnp

         if isinstance(_lowerCamelCase							,	_lowerCamelCase				) and column:
               if all(
                   isinstance(_lowerCamelCase							,	jax.Array				) and x.shape == column[0].shape and x.dtype == column[0].dtype for x in column				):
                     return jnp.stack(_lowerCamelCase							,	axis=0				)
         return column

   def 	_snake_case     (	self	:			Optional[int]							,	_lowerCamelCase	:			Tuple				):






         '''simple docstring'''



         import jax
         import jax.numpy as jnp

         if isinstance(_lowerCamelCase							,	(str, bytes, type(_lowerCamelCase				))				):
               return value
         elif isinstance(_lowerCamelCase							,	(np.character, np.ndarray)				) and np.issubdtype(value.dtype							,	np.character				):
               return value.tolist()

         __lowerCamelCase  :   Optional[Any]							    =    {}

         if isinstance(_lowerCamelCase							,	(np.number, np.ndarray)				) and np.issubdtype(value.dtype							,	np.integer				):
               # the default int precision depends on the jax config
               # see https://jax.readthedocs.io/en/latest/notebooks/Common_Gotchas_in_JAX.html#double-64bit-precision
               if jax.config.jax_enable_xaa:
                     __lowerCamelCase  :   List[Any]							    =    {"dtype": jnp.intaa}
               else:
                     __lowerCamelCase  :   List[Any]							    =    {"dtype": jnp.intaa}
         elif isinstance(_lowerCamelCase							,	(np.number, np.ndarray)				) and np.issubdtype(value.dtype							,	np.floating				):
               __lowerCamelCase  :   Tuple							    =    {"dtype": jnp.floataa}
         elif config.PIL_AVAILABLE and "PIL" in sys.modules:
               import PIL.Image

               if isinstance(_lowerCamelCase							,	PIL.Image.Image				):
                     __lowerCamelCase  :   Any							    =    np.asarray(_lowerCamelCase				)

        # using global variable since `jaxlib.xla_extension.Device` is not serializable neither
        # with `pickle` nor with `dill`, so we need to use a global variable instead
         global DEVICE_MAPPING
         if DEVICE_MAPPING is None:
               __lowerCamelCase  :   int							    =    self._map_devices_to_str()

         with jax.default_device(DEVICE_MAPPING[self.device]				):
               # calling jnp.array on a np.ndarray does copy the data
               # see https://github.com/google/jax/issues/4486
               return jnp.array(_lowerCamelCase							,	**{**default_dtype, **self.jnp_array_kwargs}				)

   def 	_snake_case     (	self	:			str							,	_lowerCamelCase	:			str				):






         '''simple docstring'''



         import jax

         # support for torch, tf, jax etc.
         if config.TORCH_AVAILABLE and "torch" in sys.modules:
               import torch

               if isinstance(_lowerCamelCase							,	torch.Tensor				):
                     return self._tensorize(data_struct.detach().cpu().numpy()[()]				)
         if hasattr(_lowerCamelCase							,	"""__array__"""				) and not isinstance(_lowerCamelCase							,	jax.Array				):
               __lowerCamelCase  :   Optional[int]							    =    data_struct.__array__()
         # support for nested types like struct of list of struct
         if isinstance(_lowerCamelCase							,	np.ndarray				):
               if data_struct.dtype == object:  # jax arrays cannot be instantied from an array of objects
                     return self._consolidate([self.recursive_tensorize(_lowerCamelCase				) for substruct in data_struct]				)
         elif isinstance(_lowerCamelCase							,	(list, tuple)				):
               return self._consolidate([self.recursive_tensorize(_lowerCamelCase				) for substruct in data_struct]				)
         return self._tensorize(_lowerCamelCase				)

   def 	_snake_case     (	self	:			Dict							,	_lowerCamelCase	:			dict				):






         '''simple docstring'''



         return map_nested(self._recursive_tensorize							,	_lowerCamelCase							,	map_list=_lowerCamelCase				)

   def 	_snake_case     (	self	:			Union[str, Any]							,	_lowerCamelCase	:			pa.Table				):






         '''simple docstring'''



         __lowerCamelCase  :   Optional[Any]							    =    self.numpy_arrow_extractor().extract_row(_lowerCamelCase				)
         __lowerCamelCase  :   int							    =    self.python_features_decoder.decode_row(_lowerCamelCase				)
         return self.recursive_tensorize(_lowerCamelCase				)

   def 	_snake_case     (	self	:			Any							,	_lowerCamelCase	:			pa.Table				):






         '''simple docstring'''



         __lowerCamelCase  :   str							    =    self.numpy_arrow_extractor().extract_column(_lowerCamelCase				)
         __lowerCamelCase  :   Optional[int]							    =    self.python_features_decoder.decode_column(_lowerCamelCase							,	pa_table.column_names[0]				)
         __lowerCamelCase  :   int							    =    self.recursive_tensorize(_lowerCamelCase				)
         __lowerCamelCase  :   Union[str, Any]							    =    self._consolidate(_lowerCamelCase				)
         return column


   def 	_snake_case     (	self	:			Tuple							,	_lowerCamelCase	:			pa.Table				):






         '''simple docstring'''



         __lowerCamelCase  :   List[Any]							    =    self.numpy_arrow_extractor().extract_batch(_lowerCamelCase				)
         __lowerCamelCase  :   Any							    =    self.python_features_decoder.decode_batch(_lowerCamelCase				)
         __lowerCamelCase  :   Any							    =    self.recursive_tensorize(_lowerCamelCase				)
         for column_name in batch:
               __lowerCamelCase  :   List[str]							    =    self._consolidate(batch[column_name]				)
         return batch







from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
    is_vision_available,
)


SCREAMING_SNAKE_CASE__     					=			{
    "configuration_owlvit": [
        "OWLVIT_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "OwlViTConfig",
        "OwlViTOnnxConfig",
        "OwlViTTextConfig",
        "OwlViTVisionConfig",
    ],
    "processing_owlvit": ["OwlViTProcessor"],
}


try:
		if not is_vision_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		SCREAMING_SNAKE_CASE__     					=			["OwlViTFeatureExtractor"]
		SCREAMING_SNAKE_CASE__     					=			["OwlViTImageProcessor"]

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		SCREAMING_SNAKE_CASE__     					=			[
		    "OWLVIT_PRETRAINED_MODEL_ARCHIVE_LIST",
		    "OwlViTModel",
		    "OwlViTPreTrainedModel",
		    "OwlViTTextModel",
		    "OwlViTVisionModel",
		    "OwlViTForObjectDetection",
		]

if TYPE_CHECKING:
		from .configuration_owlvit import (
		    OWLVIT_PRETRAINED_CONFIG_ARCHIVE_MAP,
		    OwlViTConfig,
		    OwlViTOnnxConfig,
		    OwlViTTextConfig,
		    OwlViTVisionConfig,
		)
		from .processing_owlvit import OwlViTProcessor

		try:
				if not is_vision_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .feature_extraction_owlvit import OwlViTFeatureExtractor
				from .image_processing_owlvit import OwlViTImageProcessor

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_owlvit import (
				    OWLVIT_PRETRAINED_MODEL_ARCHIVE_LIST,
				    OwlViTForObjectDetection,
				    OwlViTModel,
				    OwlViTPreTrainedModel,
				    OwlViTTextModel,
				    OwlViTVisionModel,
				)

else:
		import sys

		SCREAMING_SNAKE_CASE__     					=			_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)






