

# 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

lowerCAmelCase__								=		get_logger()

lowerCAmelCase__								=		None







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


		"""simple docstring"""




		def __init__(				self	,       __snake_case=None	,       __snake_case=None	,       **__snake_case):
			super().__init__(features=SCREAMING_SNAKE_CASE_)
			import jax
			from jaxlib.xla_client import Device

			if isinstance(SCREAMING_SNAKE_CASE_	,       SCREAMING_SNAKE_CASE_):
				raise ValueError(
				    f'''Expected {device} to be a `str` not {type(SCREAMING_SNAKE_CASE_)}, 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`.')
			_UpperCamelCase   :		Tuple			=						device if isinstance(SCREAMING_SNAKE_CASE_	,       SCREAMING_SNAKE_CASE_) 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:
				_UpperCamelCase   :		List[Any]			=						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])}.''')
				_UpperCamelCase   :		str			=						str(jax.devices()[0])
			_UpperCamelCase   :		Optional[int]			=						jnp_array_kwargs


		@staticmethod
		def 		A__					(				):
			import jax

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


		def 		A__					(				self	,       __snake_case):
			import jax
			import jax.numpy as jnp

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


		def 		A__					(				self	,       __snake_case):
			import jax
			import jax.numpy as jnp

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

			_UpperCamelCase   :		Optional[Any]			=						{}

			if isinstance(SCREAMING_SNAKE_CASE_	,       (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:
					_UpperCamelCase   :		int			=						{'dtype': jnp.intaa}
				else:
					_UpperCamelCase   :		Optional[int]			=						{'dtype': jnp.intaa}
			elif isinstance(SCREAMING_SNAKE_CASE_	,       (np.number, np.ndarray)) and np.issubdtype(value.dtype	,       np.floating):
				_UpperCamelCase   :		int			=						{'dtype': jnp.floataa}
			elif config.PIL_AVAILABLE and "PIL" in sys.modules:
				import PIL.Image

				if isinstance(SCREAMING_SNAKE_CASE_	,       PIL.Image.Image):
					_UpperCamelCase   :		List[str]			=						np.asarray(SCREAMING_SNAKE_CASE_)

        # 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:
				_UpperCamelCase   :		Union[str, Any]			=						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(SCREAMING_SNAKE_CASE_	,       **{**default_dtype, **self.jnp_array_kwargs})


		def 		A__					(				self	,       __snake_case):
			import jax

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

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


		def 		A__					(				self	,       __snake_case):
			return map_nested(self._recursive_tensorize	,       SCREAMING_SNAKE_CASE_	,       map_list=SCREAMING_SNAKE_CASE_)


		def 		A__					(				self	,       __snake_case):
			_UpperCamelCase   :		Any			=						self.numpy_arrow_extractor().extract_row(SCREAMING_SNAKE_CASE_)
			_UpperCamelCase   :		Union[str, Any]			=						self.python_features_decoder.decode_row(SCREAMING_SNAKE_CASE_)
			return self.recursive_tensorize(SCREAMING_SNAKE_CASE_)


		def 		A__					(				self	,       __snake_case):
			_UpperCamelCase   :		Optional[Any]			=						self.numpy_arrow_extractor().extract_column(SCREAMING_SNAKE_CASE_)
			_UpperCamelCase   :		Tuple			=						self.python_features_decoder.decode_column(SCREAMING_SNAKE_CASE_	,       pa_table.column_names[0])
			_UpperCamelCase   :		str			=						self.recursive_tensorize(SCREAMING_SNAKE_CASE_)
			_UpperCamelCase   :		int			=						self._consolidate(SCREAMING_SNAKE_CASE_)
			return column






		def 		A__					(				self	,       __snake_case):
			_UpperCamelCase   :		Any			=						self.numpy_arrow_extractor().extract_batch(SCREAMING_SNAKE_CASE_)
			_UpperCamelCase   :		str			=						self.python_features_decoder.decode_batch(SCREAMING_SNAKE_CASE_)
			_UpperCamelCase   :		int			=						self.recursive_tensorize(SCREAMING_SNAKE_CASE_)
			for column_name in batch:
				_UpperCamelCase   :		str			=						self._consolidate(batch[column_name])
			return batch







from typing import TYPE_CHECKING

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


lowerCAmelCase__								=		{
    """configuration_blip""": [
        """BLIP_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """BlipConfig""",
        """BlipTextConfig""",
        """BlipVisionConfig""",
    ],
    """processing_blip""": ["""BlipProcessor"""],
}

try:
							if not is_vision_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							lowerCAmelCase__								=		["""BlipImageProcessor"""]


try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							lowerCAmelCase__								=		[
							    """BLIP_PRETRAINED_MODEL_ARCHIVE_LIST""",
							    """BlipModel""",
							    """BlipPreTrainedModel""",
							    """BlipForConditionalGeneration""",
							    """BlipForQuestionAnswering""",
							    """BlipVisionModel""",
							    """BlipTextModel""",
							    """BlipForImageTextRetrieval""",
							]

try:
							if not is_tf_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							lowerCAmelCase__								=		[
							    """TF_BLIP_PRETRAINED_MODEL_ARCHIVE_LIST""",
							    """TFBlipModel""",
							    """TFBlipPreTrainedModel""",
							    """TFBlipForConditionalGeneration""",
							    """TFBlipForQuestionAnswering""",
							    """TFBlipVisionModel""",
							    """TFBlipTextModel""",
							    """TFBlipForImageTextRetrieval""",
							]

if TYPE_CHECKING:
							from .configuration_blip import BLIP_PRETRAINED_CONFIG_ARCHIVE_MAP, BlipConfig, BlipTextConfig, BlipVisionConfig
							from .processing_blip import BlipProcessor

							try:
														if not is_vision_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .image_processing_blip import BlipImageProcessor

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_blip import (
														    BLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
														    BlipForConditionalGeneration,
														    BlipForImageTextRetrieval,
														    BlipForQuestionAnswering,
														    BlipModel,
														    BlipPreTrainedModel,
														    BlipTextModel,
														    BlipVisionModel,
														)

							try:
														if not is_tf_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_tf_blip import (
														    TF_BLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
														    TFBlipForConditionalGeneration,
														    TFBlipForImageTextRetrieval,
														    TFBlipForQuestionAnswering,
														    TFBlipModel,
														    TFBlipPreTrainedModel,
														    TFBlipTextModel,
														    TFBlipVisionModel,
														)

else:
							import sys

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




