

"""simple docstring"""




# Lint as: python3
import sys
from collections.abc import Mapping
from typing import TYPE_CHECKING

import numpy as np
import pyarrow as pa

from .. import config
from ..utils.py_utils import map_nested
from .formatting import TensorFormatter


if TYPE_CHECKING:
						import tensorflow as tf





class 				lowerCamelCase  (TensorFormatter[Mapping, 'tf.Tensor', Mapping]     ):

			def __init__(   self			:  Optional[Any]      ,			__UpperCAmelCase			:  List[str]=None      ,			**__UpperCAmelCase			:  Optional[Any]    )				->      Dict:
						super().__init__(features=_A    )
						SCREAMING_SNAKE_CASE__									= tf_tensor_kwargs
						import tensorflow as tf  # noqa: import tf at initialization

			def    SCREAMING_SNAKE_CASE			(   self			:  Dict      ,			__UpperCAmelCase			:  List[str]    )				->      Union[str, Any]:
						import tensorflow as tf

						if isinstance(_A      ,			_A    ) and column:
									if all(
									    isinstance(_A      ,			tf.Tensor    ) and x.shape == column[0].shape and x.dtype == column[0].dtype for x in column    ):
												return tf.stack(_A    )
									elif all(
									    isinstance(_A      ,			(tf.Tensor, tf.RaggedTensor)    ) and x.ndim == 1 and x.dtype == column[0].dtype
									    for x in column    ):
												# only rag 1-D tensors, otherwise some dimensions become ragged even though they were consolidated
												return tf.ragged.stack(_A    )

						return column

			def    SCREAMING_SNAKE_CASE			(   self			:  List[str]      ,			__UpperCAmelCase			:  List[Any]    )				->      Dict:
						import tensorflow as tf

						if value is None:
									return value

						SCREAMING_SNAKE_CASE__									= {}

						if isinstance(_A      ,			(np.number, np.ndarray)    ) and np.issubdtype(value.dtype      ,			np.integer    ):
									SCREAMING_SNAKE_CASE__									= {'''dtype''': tf.intaa}
						elif isinstance(_A      ,			(np.number, np.ndarray)    ) and np.issubdtype(value.dtype      ,			np.floating    ):
									SCREAMING_SNAKE_CASE__									= {'''dtype''': tf.floataa}
						elif config.PIL_AVAILABLE and "PIL" in sys.modules:
									import PIL.Image

									if isinstance(_A      ,			PIL.Image.Image    ):
												SCREAMING_SNAKE_CASE__									= np.asarray(_A    )

						return tf.convert_to_tensor(_A      ,			**{**default_dtype, **self.tf_tensor_kwargs}    )

			def    SCREAMING_SNAKE_CASE			(   self			:  Optional[Any]      ,			__UpperCAmelCase			:  Tuple    )				->      Dict:
						import tensorflow as tf

						# 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      ,			tf.Tensor    ):
									SCREAMING_SNAKE_CASE__									= data_struct.__array__()
						# support for nested types like struct of list of struct
						if isinstance(_A      ,			np.ndarray    ):
									if data_struct.dtype == object:  # tf tensors 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    SCREAMING_SNAKE_CASE			(   self			:  str      ,			__UpperCAmelCase			:  dict    )				->      str:
						return map_nested(self._recursive_tensorize      ,			_A      ,			map_list=_A    )

			def    SCREAMING_SNAKE_CASE			(   self			:  List[str]      ,			__UpperCAmelCase			:  pa.Table    )				->      Tuple:
						SCREAMING_SNAKE_CASE__									= self.numpy_arrow_extractor().extract_row(_A    )
						SCREAMING_SNAKE_CASE__									= self.python_features_decoder.decode_row(_A    )
						return self.recursive_tensorize(_A    )

			def    SCREAMING_SNAKE_CASE			(   self			:  List[str]      ,			__UpperCAmelCase			:  pa.Table    )				->      Optional[Any]:
						SCREAMING_SNAKE_CASE__									= self.numpy_arrow_extractor().extract_column(_A    )
						SCREAMING_SNAKE_CASE__									= self.python_features_decoder.decode_column(_A      ,			pa_table.column_names[0]    )
						SCREAMING_SNAKE_CASE__									= self.recursive_tensorize(_A    )
						SCREAMING_SNAKE_CASE__									= self._consolidate(_A    )
						return column





			def    SCREAMING_SNAKE_CASE			(   self			:  List[str]      ,			__UpperCAmelCase			:  pa.Table    )				->      str:
						SCREAMING_SNAKE_CASE__									= self.numpy_arrow_extractor().extract_batch(_A    )
						SCREAMING_SNAKE_CASE__									= self.python_features_decoder.decode_batch(_A    )
						SCREAMING_SNAKE_CASE__									= self.recursive_tensorize(_A    )
						for column_name in batch:
									SCREAMING_SNAKE_CASE__									= self._consolidate(batch[column_name]    )
						return batch





"""simple docstring"""




def 		A    (       snake_case__						,			snake_case__      ):




			'''simple docstring'''


			return a + b


if __name__ == "__main__":
						A_							:     List[str]     =	5
						A_							:     Optional[int]     =	6
						print(F'The sum of {a} + {b} is {add(a, b)}')


