"""simple docstring"""


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    __UpperCAmelCase						(	TensorFormatter[Mapping, np.ndarray, Mapping]	):

				def __init__(      self	, _lowerCamelCase=None	, **_lowerCamelCase      ):
										super().__init__(features=_lowerCamelCase      )
										lowerCamelCase__					=np_array_kwargs

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

				def 		_a	(      self	, _lowerCamelCase      ):
										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
										elif isinstance(_lowerCamelCase	, np.number      ):
																return value

										lowerCamelCase__					={}

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

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

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

				def 		_a	(      self	, _lowerCamelCase      ):
										# 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	, (np.ndarray, np.character, np.number)      ):
																lowerCamelCase__					=data_struct.__array__()
										# support for nested types like struct of list of struct
										if isinstance(_lowerCamelCase	, np.ndarray      ):
																if data_struct.dtype == object:
																						return self._consolidate([self.recursive_tensorize(_lowerCamelCase      ) for substruct in data_struct]      )
										if isinstance(_lowerCamelCase	, (list, tuple)      ):
																return self._consolidate([self.recursive_tensorize(_lowerCamelCase      ) for substruct in data_struct]      )
										return self._tensorize(_lowerCamelCase      )

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

				def 		_a	(      self	, _lowerCamelCase      ):
										lowerCamelCase__					=self.numpy_arrow_extractor().extract_row(_lowerCamelCase      )
										lowerCamelCase__					=self.python_features_decoder.decode_row(_lowerCamelCase      )
										return self.recursive_tensorize(_lowerCamelCase      )

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






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



"""simple docstring"""


from __future__ import annotations





def 			lowerCamelCase_ (					__lowerCAmelCase				)							->					int | float:




						'''simple docstring'''



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


if __name__ == "__main__":
	import doctest

	doctest.testmod(verbose=True)


