




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

snake_case__			:    Optional[int]			     =      get_logger()

snake_case__			:    Any			     =      None





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


   '''simple docstring'''







   def __init__(       self  :						List[Any]    ,     lowerCamelCase_  :						List[str]=None    ,     lowerCamelCase_  :						Optional[Any]=None    ,     **lowerCamelCase_  :						Optional[int]      )       ->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`."""      )
     UpperCAmelCase__         = 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:
       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 						UpperCAmelCase							(       )       ->List[Any]:
     '''simple docstring'''







     import jax

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




   def 						UpperCAmelCase							(       self  :						Dict    ,     lowerCamelCase_  :						Tuple      )       ->Optional[int]:
     '''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 						UpperCAmelCase							(       self  :						List[Any]    ,     lowerCamelCase_  :						Any      )       ->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()

     UpperCAmelCase__         = {}

     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:
         UpperCAmelCase__         = {"""dtype""": jnp.intaa}
       else:
         UpperCAmelCase__         = {"""dtype""": jnp.intaa}
     elif isinstance(_lowerCamelCase    ,     (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(_lowerCamelCase    ,     PIL.Image.Image      ):
         UpperCAmelCase__         = 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:
       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(_lowerCamelCase    ,     **{**default_dtype, **self.jnp_array_kwargs}      )




   def 						UpperCAmelCase							(       self  :						List[str]    ,     lowerCamelCase_  :						Dict      )       ->Optional[int]:
     '''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      ):
       UpperCAmelCase__         = 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 						UpperCAmelCase							(       self  :						Union[str, Any]    ,     lowerCamelCase_  :						List[str]      )       ->Any:
     '''simple docstring'''







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




   def 						UpperCAmelCase							(       self  :						Optional[int]    ,     lowerCamelCase_  :						List[str]      )       ->int:
     '''simple docstring'''







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




   def 						UpperCAmelCase							(       self  :						Optional[int]    ,     lowerCamelCase_  :						Optional[Any]      )       ->int:
     '''simple docstring'''







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







   def 						UpperCAmelCase							(       self  :						Union[str, Any]    ,     lowerCamelCase_  :						Optional[int]      )       ->Optional[int]:
     '''simple docstring'''







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







"""simple docstring"""
from .glue import glue_convert_examples_to_features, glue_output_modes, glue_processors, glue_tasks_num_labels
from .squad import SquadExample, SquadFeatures, SquadVaProcessor, SquadVaProcessor, squad_convert_examples_to_features
from .utils import DataProcessor, InputExample, InputFeatures, SingleSentenceClassificationProcessor
from .xnli import xnli_output_modes, xnli_processors, xnli_tasks_num_labels

