



import sys
from collections.abc import Mapping

import numpy as np
import pyarrow as pa

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

class 	__snake_case (				TensorFormatter[Mapping, np.ndarray, Mapping]):







							'''simple docstring'''






							def __init__(							self					,					a_=None					,					**a_						):
											super().__init__(features=_snake_case						)
											a__			 =						np_array_kwargs


							def _a (							self					,					a_						):
											if isinstance(_snake_case					,					_snake_case						):
															if column and all(
															    isinstance(_snake_case					,					np.ndarray						) and x.shape == column[0].shape and x.dtype == column[0].dtype for x in column						):
																			return np.stack(_snake_case						)
															else:
																			# don't use np.array(column, dtype=object)
																			# since it fails in certain cases
																			# see https://stackoverflow.com/q/51005699
																			a__			 =						np.empty(len(_snake_case						)					,					dtype=_snake_case						)
																			a__			 =						column
																			return out
											return column


							def _a (							self					,					a_						):
											if isinstance(_snake_case					,					(str, bytes, type(_snake_case						))						):
															return value
											elif isinstance(_snake_case					,					(np.character, np.ndarray)						) and np.issubdtype(value.dtype					,					np.character						):
															return value
											elif isinstance(_snake_case					,					np.number						):
															return value

											a__			 =						{}

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

															if isinstance(_snake_case					,					PIL.Image.Image						):
																			return np.asarray(_snake_case					,					**self.np_array_kwargs						)

											return np.asarray(_snake_case					,					**{**default_dtype, **self.np_array_kwargs}						)


							def _a (							self					,					a_						):
											# support for torch, tf, jax etc.
											if config.TORCH_AVAILABLE and "torch" in sys.modules:
															import torch

															if isinstance(_snake_case					,					torch.Tensor						):
																			return self._tensorize(data_struct.detach().cpu().numpy()[()]						)
											if hasattr(_snake_case					,					"""__array__"""						) and not isinstance(_snake_case					,					(np.ndarray, np.character, np.number)						):
															a__			 =						data_struct.__array__()
											# support for nested types like struct of list of struct
											if isinstance(_snake_case					,					np.ndarray						):
															if data_struct.dtype == object:
																			return self._consolidate([self.recursive_tensorize(_snake_case						) for substruct in data_struct]						)
											if isinstance(_snake_case					,					(list, tuple)						):
															return self._consolidate([self.recursive_tensorize(_snake_case						) for substruct in data_struct]						)
											return self._tensorize(_snake_case						)


							def _a (							self					,					a_						):
											return map_nested(self._recursive_tensorize					,					_snake_case					,					map_list=_snake_case						)


							def _a (							self					,					a_						):
											a__			 =						self.numpy_arrow_extractor().extract_row(_snake_case						)
											a__			 =						self.python_features_decoder.decode_row(_snake_case						)
											return self.recursive_tensorize(_snake_case						)


							def _a (							self					,					a_						):
											a__			 =						self.numpy_arrow_extractor().extract_column(_snake_case						)
											a__			 =						self.python_features_decoder.decode_column(_snake_case					,					pa_table.column_names[0]						)
											a__			 =						self.recursive_tensorize(_snake_case						)
											a__			 =						self._consolidate(_snake_case						)
											return column







							def _a (							self					,					a_						):
											a__			 =						self.numpy_arrow_extractor().extract_batch(_snake_case						)
											a__			 =						self.python_features_decoder.decode_batch(_snake_case						)
											a__			 =						self.recursive_tensorize(_snake_case						)
											for column_name in batch:
															a__			 =						self._consolidate(batch[column_name]						)
											return batch






from __future__ import annotations

def      A_ (		__a       :			list[int | float]						):

				"""simple docstring"""
				if len(__a						) == 0:
								raise ValueError("""find_max() arg is an empty sequence"""						)
				a__			 =						nums[0]
				for x in nums:
								if x > max_num:
												a__			 =						x
				return max_num


if __name__ == "__main__":
	import doctest

	doctest.testmod(verbose=True)

