


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

lowerCamelCase__    	=     get_logger()

lowerCamelCase__    	=     None






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




			def __init__(		self  :     List[str]	,  lowerCamelCase__  :     Union[str, Any]=None	,  lowerCamelCase__  :     Dict=None	,  **lowerCamelCase__  :     List[str] )   ->str:



					'''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		:       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:
							_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		:       Optional[Any]								=      str(jax.devices()[0] )
					_UpperCAmelCase		:       int								=      jnp_array_kwargs




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



					'''simple docstring'''







					import jax

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




			def 							lowerCAmelCase__    (		self  :     Any	,  lowerCamelCase__  :     Tuple )   ->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 							lowerCAmelCase__    (		self  :     Optional[int]	,  lowerCamelCase__  :     List[str] )   ->Optional[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()

					_UpperCAmelCase		:       Tuple								=      {}

					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		:       Tuple								=      {"dtype": jnp.intaa}
							else:
									_UpperCAmelCase		:       int								=      {"dtype": jnp.intaa}
					elif isinstance(lowerCamelCase__	,  (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(lowerCamelCase__	,  PIL.Image.Image ):
									_UpperCAmelCase		:       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:
							_UpperCAmelCase		:       Tuple								=      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 							lowerCAmelCase__    (		self  :     List[Any]	,  lowerCamelCase__  :     int )   ->Union[str, 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 ):
							_UpperCAmelCase		:       Optional[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 							lowerCAmelCase__    (		self  :     Optional[Any]	,  lowerCamelCase__  :     dict )   ->Optional[Any]:



					'''simple docstring'''







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




			def 							lowerCAmelCase__    (		self  :     Optional[int]	,  lowerCamelCase__  :     pa.Table )   ->Mapping:



					'''simple docstring'''







					_UpperCAmelCase		:       str								=      self.numpy_arrow_extractor().extract_row(lowerCamelCase__ )
					_UpperCAmelCase		:       List[str]								=      self.python_features_decoder.decode_row(lowerCamelCase__ )
					return self.recursive_tensorize(lowerCamelCase__ )




			def 							lowerCAmelCase__    (		self  :     Dict	,  lowerCamelCase__  :     pa.Table )   ->"jax.Array":



					'''simple docstring'''







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






			def 							lowerCAmelCase__    (		self  :     Union[str, Any]	,  lowerCamelCase__  :     pa.Table )   ->Mapping:



					'''simple docstring'''







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







'''simple docstring'''


from __future__ import annotations

import math

import numpy as np
from numpy.linalg import norm






def  __lowerCAmelCase (__lowerCAmelCase      , __lowerCAmelCase   ):
		return math.sqrt(sum(pow(a - b      , 2   ) for a, b in zip(__lowerCAmelCase      , __lowerCAmelCase   )   )   )






def  __lowerCAmelCase (__lowerCAmelCase      , __lowerCAmelCase   ):

		if dataset.ndim != value_array.ndim:
				_UpperCAmelCase		:       Optional[Any]								=      (
				    "Wrong input data's dimensions... "
				    F"""dataset : {dataset.ndim}, value_array : {value_array.ndim}"""
				)
				raise ValueError(__lowerCAmelCase   )

		try:
				if dataset.shape[1] != value_array.shape[1]:
						_UpperCAmelCase		:       Optional[int]								=      (
						    "Wrong input data's shape... "
						    F"""dataset : {dataset.shape[1]}, value_array : {value_array.shape[1]}"""
						)
						raise ValueError(__lowerCAmelCase   )
		except IndexError:
				if dataset.ndim != value_array.ndim:
						raise TypeError("Wrong shape"   )

		if dataset.dtype != value_array.dtype:
				_UpperCAmelCase		:       Union[str, Any]								=      (
				    "Input data have different datatype... "
				    F"""dataset : {dataset.dtype}, value_array : {value_array.dtype}"""
				)
				raise TypeError(__lowerCAmelCase   )

		_UpperCAmelCase		:       Optional[int]								=      []

		for value in value_array:
				_UpperCAmelCase		:       List[str]								=      euclidean(__lowerCAmelCase      , dataset[0]   )
				_UpperCAmelCase		:       Dict								=      dataset[0].tolist()

				for dataset_value in dataset[1:]:
						_UpperCAmelCase		:       int								=      euclidean(__lowerCAmelCase      , __lowerCAmelCase   )

						if dist > temp_dist:
								_UpperCAmelCase		:       Tuple								=      temp_dist
								_UpperCAmelCase		:       Dict								=      dataset_value.tolist()

				answer.append([vector, dist]   )

		return answer






def  __lowerCAmelCase (__lowerCAmelCase      , __lowerCAmelCase   ):
		return np.dot(__lowerCAmelCase      , __lowerCAmelCase   ) / (norm(__lowerCAmelCase   ) * norm(__lowerCAmelCase   ))


if __name__ == "__main__":
						import doctest

						doctest.testmod()



