



"""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

lowercase__		:    Tuple				   =     get_logger()

lowercase__		:    Optional[dict]				   =     None







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




      """simple docstring"""




      def __init__(				self    :				Tuple   ,      SCREAMING_SNAKE_CASE_    :				List[Any]=None   ,      SCREAMING_SNAKE_CASE_    :				str=None   ,      **SCREAMING_SNAKE_CASE_    :				Optional[Any]	):
        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`.'	)
        lowerCAmelCase_       :    Union[str, Any]								=			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:
          lowerCAmelCase_       :    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]	)}."	)
          lowerCAmelCase_       :    Dict								=			str(jax.devices()[0]	)
        lowerCAmelCase_       :    str								=			jnp_array_kwargs



      @staticmethod
      def 					SCREAMING_SNAKE_CASE__			(				):
        import jax

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



      def 					SCREAMING_SNAKE_CASE__			(				self    :				Tuple   ,      SCREAMING_SNAKE_CASE_    :				Tuple	):
        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 					SCREAMING_SNAKE_CASE__			(				self    :				List[Any]   ,      SCREAMING_SNAKE_CASE_    :				Optional[Any]	):
        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()

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

          if isinstance(SCREAMING_SNAKE_CASE_   ,      PIL.Image.Image	):
            lowerCAmelCase_       :    List[Any]								=			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:
          lowerCAmelCase_       :    Dict								=			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 					SCREAMING_SNAKE_CASE__			(				self    :				List[Any]   ,      SCREAMING_SNAKE_CASE_    :				int	):
        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	):
          lowerCAmelCase_       :    Tuple								=			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 					SCREAMING_SNAKE_CASE__			(				self    :				Optional[int]   ,      SCREAMING_SNAKE_CASE_    :				dict	):
        return map_nested(self._recursive_tensorize   ,      SCREAMING_SNAKE_CASE_   ,      map_list=SCREAMING_SNAKE_CASE_	)



      def 					SCREAMING_SNAKE_CASE__			(				self    :				str   ,      SCREAMING_SNAKE_CASE_    :				pa.Table	):
        lowerCAmelCase_       :    List[str]								=			self.numpy_arrow_extractor().extract_row(SCREAMING_SNAKE_CASE_	)
        lowerCAmelCase_       :    List[str]								=			self.python_features_decoder.decode_row(SCREAMING_SNAKE_CASE_	)
        return self.recursive_tensorize(SCREAMING_SNAKE_CASE_	)



      def 					SCREAMING_SNAKE_CASE__			(				self    :				str   ,      SCREAMING_SNAKE_CASE_    :				pa.Table	):
        lowerCAmelCase_       :    Union[str, Any]								=			self.numpy_arrow_extractor().extract_column(SCREAMING_SNAKE_CASE_	)
        lowerCAmelCase_       :    Dict								=			self.python_features_decoder.decode_column(SCREAMING_SNAKE_CASE_   ,      pa_table.column_names[0]	)
        lowerCAmelCase_       :    Optional[int]								=			self.recursive_tensorize(SCREAMING_SNAKE_CASE_	)
        lowerCAmelCase_       :    Dict								=			self._consolidate(SCREAMING_SNAKE_CASE_	)
        return column





      def 					SCREAMING_SNAKE_CASE__			(				self    :				Any   ,      SCREAMING_SNAKE_CASE_    :				pa.Table	):
        lowerCAmelCase_       :    int								=			self.numpy_arrow_extractor().extract_batch(SCREAMING_SNAKE_CASE_	)
        lowerCAmelCase_       :    Dict								=			self.python_features_decoder.decode_batch(SCREAMING_SNAKE_CASE_	)
        lowerCAmelCase_       :    Optional[int]								=			self.recursive_tensorize(SCREAMING_SNAKE_CASE_	)
        for column_name in batch:
          lowerCAmelCase_       :    List[str]								=			self._consolidate(batch[column_name]	)
        return batch










"""simple docstring"""







import re

def     UpperCamelCase_   (   lowerCAmelCase__				:    str						)						->       bool:

  """simple docstring"""




  lowerCAmelCase_       :    str								=			re.compile(
      R'^(?:0|94|\+94|0{2}94)' R'7(0|1|2|4|5|6|7|8)' R'(-| |)' R'\d{7}$'						)

  return bool(re.search(lowerCAmelCase__   ,       lowerCAmelCase__						)						)


if __name__ == "__main__":
     lowercase__		:    Optional[int]				   =     """0094702343221"""

     print(is_sri_lankan_phone_number(phone))





