





# 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	:	Optional[Any]		     =       get_logger()

UpperCAmelCase	:	Optional[dict]		     =       None







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







      def __init__(    self		,      lowerCAmelCase__=None		,      lowerCAmelCase__=None		,      **lowerCAmelCase__							)   ->						Any:



        '''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`."							)
        a__	:					List[Any]										=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:
          a__	:					int										=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]							)}.'''							)
          a__	:					int										=str(jax.devices()[0]							)
        a__	:					Union[str, Any]										=jnp_array_kwargs







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



        '''simple docstring'''




        import jax

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







      def    _lowercase  (    self		,      lowerCAmelCase__							)   ->						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    _lowercase  (    self		,      lowerCAmelCase__							)   ->						Any:



        '''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()

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

          if isinstance(lowerCAmelCase__		,      PIL.Image.Image							):
            a__	:					Tuple										=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:
          a__	:					List[str]										=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    _lowercase  (    self		,      lowerCAmelCase__							)   ->						List[Any]:



        '''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							):
          a__	:					List[Any]										=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    _lowercase  (    self		,      lowerCAmelCase__							)   ->						int:



        '''simple docstring'''




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







      def    _lowercase  (    self		,      lowerCAmelCase__							)   ->						Mapping:



        '''simple docstring'''




        a__	:					Dict										=self.numpy_arrow_extractor().extract_row(lowerCAmelCase__							)
        a__	:					List[Any]										=self.python_features_decoder.decode_row(lowerCAmelCase__							)
        return self.recursive_tensorize(lowerCAmelCase__							)







      def    _lowercase  (    self		,      lowerCAmelCase__							)   ->						"jax.Array":



        '''simple docstring'''




        a__	:					Optional[int]										=self.numpy_arrow_extractor().extract_column(lowerCAmelCase__							)
        a__	:					str										=self.python_features_decoder.decode_column(lowerCAmelCase__		,      pa_table.column_names[0]							)
        a__	:					int										=self.recursive_tensorize(lowerCAmelCase__							)
        a__	:					Tuple										=self._consolidate(lowerCAmelCase__							)
        return column







      def    _lowercase  (    self		,      lowerCAmelCase__							)   ->						Mapping:



        '''simple docstring'''




        a__	:					Optional[int]										=self.numpy_arrow_extractor().extract_batch(lowerCAmelCase__							)
        a__	:					Any										=self.python_features_decoder.decode_batch(lowerCAmelCase__							)
        a__	:					List[str]										=self.recursive_tensorize(lowerCAmelCase__							)
        for column_name in batch:
          a__	:					int										=self._consolidate(batch[column_name]							)
        return batch













import numpy as np
def      _A       (		SCREAMING_SNAKE_CASE     :   np.array						):





  """simple docstring"""



  return 1 / (1 + np.exp(-vector						))


if __name__ == "__main__":
     import doctest

     doctest.testmod()






