# 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__											=					get_logger()

UpperCamelCase__											=					None





class      A							(				TensorFormatter[Mapping, 'jax.Array', Mapping]     ):


   def __init__(self     :						Optional[int]       ,  __UpperCAmelCase     :						Optional[int]=None       ,  __UpperCAmelCase     :						Optional[Any]=None       ,  **__UpperCAmelCase     :						List[str]		)						->				List[str]:
         """simple docstring"""



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

         if isinstance(__UpperCAmelCase       ,  __UpperCAmelCase		):
               raise ValueError(
                   f"""Expected {device} to be a `str` not {type(__UpperCAmelCase		)}, 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__								=  device if isinstance(__UpperCAmelCase       ,  __UpperCAmelCase		) 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__								=  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(jax.devices()[0]		)
         UpperCAmelCase__								=  jnp_array_kwargs


   @staticmethod
   def 			lowercase_      ()						->				Dict[str, "jaxlib.xla_extension.Device"]:
         """simple docstring"""



         import jax

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


   def 			lowercase_      (self     :						List[Any]       ,  __UpperCAmelCase     :						Tuple		)						->				Dict:
         """simple docstring"""



         import jax
         import jax.numpy as jnp

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


   def 			lowercase_      (self     :						Tuple       ,  __UpperCAmelCase     :						int		)						->				str:
         """simple docstring"""



         import jax
         import jax.numpy as jnp

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

         UpperCAmelCase__								=  {}

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

               if isinstance(__UpperCAmelCase       ,  PIL.Image.Image		):
                     UpperCAmelCase__								=  np.asarray(__UpperCAmelCase		)

        # 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__								=  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(__UpperCAmelCase       ,  **{**default_dtype, **self.jnp_array_kwargs}		)


   def 			lowercase_      (self     :						int       ,  __UpperCAmelCase     :						List[Any]		)						->				Any:
         """simple docstring"""



         import jax

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

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


   def 			lowercase_      (self     :						List[str]       ,  __UpperCAmelCase     :						dict		)						->				str:
         """simple docstring"""



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


   def 			lowercase_      (self     :						Dict       ,  __UpperCAmelCase     :						pa.Table		)						->				Mapping:
         """simple docstring"""



         UpperCAmelCase__								=  self.numpy_arrow_extractor().extract_row(__UpperCAmelCase		)
         UpperCAmelCase__								=  self.python_features_decoder.decode_row(__UpperCAmelCase		)
         return self.recursive_tensorize(__UpperCAmelCase		)


   def 			lowercase_      (self     :						Union[str, Any]       ,  __UpperCAmelCase     :						pa.Table		)						->				"jax.Array":
         """simple docstring"""



         UpperCAmelCase__								=  self.numpy_arrow_extractor().extract_column(__UpperCAmelCase		)
         UpperCAmelCase__								=  self.python_features_decoder.decode_column(__UpperCAmelCase       ,  pa_table.column_names[0]		)
         UpperCAmelCase__								=  self.recursive_tensorize(__UpperCAmelCase		)
         UpperCAmelCase__								=  self._consolidate(__UpperCAmelCase		)
         return column





   def 			lowercase_      (self     :						Union[str, Any]       ,  __UpperCAmelCase     :						pa.Table		)						->				Mapping:
         """simple docstring"""



         UpperCAmelCase__								=  self.numpy_arrow_extractor().extract_batch(__UpperCAmelCase		)
         UpperCAmelCase__								=  self.python_features_decoder.decode_batch(__UpperCAmelCase		)
         UpperCAmelCase__								=  self.recursive_tensorize(__UpperCAmelCase		)
         for column_name in batch:
               UpperCAmelCase__								=  self._consolidate(batch[column_name]		)
         return batch






from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


A_       : Optional[int]         =			{'configuration_ibert': ['IBERT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'IBertConfig', 'IBertOnnxConfig']}

try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	A_       : str         =			[
	    'IBERT_PRETRAINED_MODEL_ARCHIVE_LIST',
	    'IBertForMaskedLM',
	    'IBertForMultipleChoice',
	    'IBertForQuestionAnswering',
	    'IBertForSequenceClassification',
	    'IBertForTokenClassification',
	    'IBertModel',
	    'IBertPreTrainedModel',
	]

if TYPE_CHECKING:
	from .configuration_ibert import IBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, IBertConfig, IBertOnnxConfig

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_ibert import (
		    IBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
		    IBertForMaskedLM,
		    IBertForMultipleChoice,
		    IBertForQuestionAnswering,
		    IBertForSequenceClassification,
		    IBertForTokenClassification,
		    IBertModel,
		    IBertPreTrainedModel,
		)

else:
	import sys

	A_       : Union[str, Any]         =			_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)



