



'''simple docstring'''






# 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

A_							: Optional[Any]						 =	get_logger()

A_							: Optional[dict]						 =	None



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


 """simple docstring"""


 def __init__(							self  ,a_=None  ,a_=None  ,**a_							)		->   str:
        super().__init__(features=a_							)
        import jax
        from jaxlib.xla_client import Device

        if isinstance(a_  ,a_							):
               raise ValueError(
                   f'''Expected {device} to be a `str` not {type(a_							)}, 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  :						Dict			     = device if isinstance(a_  ,a_							) 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  :						Union[str, 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  :						Dict			     = str(jax.devices()[0]							)
        _UpperCAmelCase  :						Tuple			     = jnp_array_kwargs







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

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







 def _snake_case (							self  ,a_							)		->   Optional[Any]:
        import jax
        import jax.numpy as jnp

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







 def _snake_case (							self  ,a_							)		->   Optional[int]:
        import jax
        import jax.numpy as jnp

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

        _UpperCAmelCase  :						Dict			     = {}

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

               if isinstance(a_  ,PIL.Image.Image							):
                      _UpperCAmelCase  :						Optional[Any]			     = np.asarray(a_							)

        # 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  :						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(a_  ,**{**default_dtype, **self.jnp_array_kwargs}							)







 def _snake_case (							self  ,a_							)		->   Optional[int]:
        import jax

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

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







 def _snake_case (							self  ,a_							)		->   List[str]:
        return map_nested(self._recursive_tensorize  ,a_  ,map_list=a_							)







 def _snake_case (							self  ,a_							)		->   Mapping:
        _UpperCAmelCase  :						Tuple			     = self.numpy_arrow_extractor().extract_row(a_							)
        _UpperCAmelCase  :						List[str]			     = self.python_features_decoder.decode_row(a_							)
        return self.recursive_tensorize(a_							)







 def _snake_case (							self  ,a_							)		->   "jax.Array":
        _UpperCAmelCase  :						List[str]			     = self.numpy_arrow_extractor().extract_column(a_							)
        _UpperCAmelCase  :						List[Any]			     = self.python_features_decoder.decode_column(a_  ,pa_table.column_names[0]							)
        _UpperCAmelCase  :						Any			     = self.recursive_tensorize(a_							)
        _UpperCAmelCase  :						Optional[int]			     = self._consolidate(a_							)
        return column







 def _snake_case (							self  ,a_							)		->   Mapping:
        _UpperCAmelCase  :						str			     = self.numpy_arrow_extractor().extract_batch(a_							)
        _UpperCAmelCase  :						str			     = self.python_features_decoder.decode_batch(a_							)
        _UpperCAmelCase  :						str			     = self.recursive_tensorize(a_							)
        for column_name in batch:
               _UpperCAmelCase  :						Dict			     = self._consolidate(batch[column_name]							)
        return batch








'''simple docstring'''






from ...configuration_utils import PretrainedConfig
from ...utils import logging


A_							: Any						 =	logging.get_logger(__name__)

A_							: Any						 =	{
    """microsoft/markuplm-base""": """https://huggingface.co/microsoft/markuplm-base/resolve/main/config.json""",
    """microsoft/markuplm-large""": """https://huggingface.co/microsoft/markuplm-large/resolve/main/config.json""",
}



class 							lowercase       (  _lowerCamelCase				):


 """simple docstring"""


 UpperCAmelCase							=  """markuplm"""







 def __init__(							self  ,a_=30_522  ,a_=768  ,a_=12  ,a_=12  ,a_=3_072  ,a_="gelu"  ,a_=0.1  ,a_=0.1  ,a_=512  ,a_=2  ,a_=0.02  ,a_=1E-1_2  ,a_=0  ,a_=0  ,a_=2  ,a_=256  ,a_=1_024  ,a_=216  ,a_=1_001  ,a_=32  ,a_=50  ,a_="absolute"  ,a_=True  ,a_=None  ,**a_  ,)		->   Union[str, Any]:
        super().__init__(
            pad_token_id=a_  ,bos_token_id=a_  ,eos_token_id=a_  ,**a_  ,)
        _UpperCAmelCase  :						Optional[int]			     = vocab_size
        _UpperCAmelCase  :						Tuple			     = hidden_size
        _UpperCAmelCase  :						str			     = num_hidden_layers
        _UpperCAmelCase  :						Dict			     = num_attention_heads
        _UpperCAmelCase  :						int			     = hidden_act
        _UpperCAmelCase  :						Optional[Any]			     = intermediate_size
        _UpperCAmelCase  :						Tuple			     = hidden_dropout_prob
        _UpperCAmelCase  :						List[str]			     = attention_probs_dropout_prob
        _UpperCAmelCase  :						Optional[int]			     = max_position_embeddings
        _UpperCAmelCase  :						Tuple			     = type_vocab_size
        _UpperCAmelCase  :						Dict			     = initializer_range
        _UpperCAmelCase  :						List[Any]			     = layer_norm_eps
        _UpperCAmelCase  :						Optional[Any]			     = position_embedding_type
        _UpperCAmelCase  :						Any			     = use_cache
        _UpperCAmelCase  :						List[Any]			     = classifier_dropout
        # additional properties
        _UpperCAmelCase  :						Dict			     = max_depth
        _UpperCAmelCase  :						Union[str, Any]			     = max_xpath_tag_unit_embeddings
        _UpperCAmelCase  :						Optional[int]			     = max_xpath_subs_unit_embeddings
        _UpperCAmelCase  :						List[Any]			     = tag_pad_id
        _UpperCAmelCase  :						Tuple			     = subs_pad_id
        _UpperCAmelCase  :						List[str]			     = xpath_unit_hidden_size



