



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    _lowercase (TensorFormatter[Mapping, np.ndarray, Mapping]   ):
				'''simple docstring'''







				def __init__(			self  ,			snake_case__=None  ,			**snake_case__     ):

									'''simple docstring'''


									super().__init__(features=snake_case__     )
									UpperCamelCase_			= np_array_kwargs

				def    _lowerCamelCase       (			self  ,			snake_case__     ):

									'''simple docstring'''


									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
																			UpperCamelCase_			= np.empty(len(snake_case__     )  ,			dtype=snake_case__     )
																			UpperCamelCase_			= column
																			return out
									return column

				def    _lowerCamelCase       (			self  ,			snake_case__     ):

									'''simple docstring'''


									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

									UpperCamelCase_			= {}

									if isinstance(snake_case__  ,			np.ndarray     ) and np.issubdtype(value.dtype  ,			np.integer     ):
														UpperCamelCase_			= {"dtype": np.intaa}
									elif isinstance(snake_case__  ,			np.ndarray     ) and np.issubdtype(value.dtype  ,			np.floating     ):
														UpperCamelCase_			= {"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    _lowerCamelCase       (			self  ,			snake_case__     ):

									'''simple docstring'''


									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)     ):
														UpperCamelCase_			= 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    _lowerCamelCase       (			self  ,			snake_case__     ):

									'''simple docstring'''


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

				def    _lowerCamelCase       (			self  ,			snake_case__     ):

									'''simple docstring'''


									UpperCamelCase_			= self.numpy_arrow_extractor().extract_row(snake_case__     )
									UpperCamelCase_			= self.python_features_decoder.decode_row(snake_case__     )
									return self.recursive_tensorize(snake_case__     )

				def    _lowerCamelCase       (			self  ,			snake_case__     ):

									'''simple docstring'''


									UpperCamelCase_			= self.numpy_arrow_extractor().extract_column(snake_case__     )
									UpperCamelCase_			= self.python_features_decoder.decode_column(snake_case__  ,			pa_table.column_names[0]     )
									UpperCamelCase_			= self.recursive_tensorize(snake_case__     )
									UpperCamelCase_			= self._consolidate(snake_case__     )
									return column

				def    _lowerCamelCase       (			self  ,			snake_case__     ):

									'''simple docstring'''


									UpperCamelCase_			= self.numpy_arrow_extractor().extract_batch(snake_case__     )
									UpperCamelCase_			= self.python_features_decoder.decode_batch(snake_case__     )
									UpperCamelCase_			= self.recursive_tensorize(snake_case__     )
									for column_name in batch:
														UpperCamelCase_			= self._consolidate(batch[column_name]     )
									return batch


"""simple docstring"""




def 				a__			(					lowerCAmelCase						:							str		):






     '''simple docstring'''
     UpperCAmelCase__				:			Optional[Any]							=    str(lowerCAmelCase		).strip()
     if not oct_string:
          raise ValueError("Empty string was passed to the function"		)
     UpperCAmelCase__				:			Tuple							=    oct_string[0] == "-"
     if is_negative:
          UpperCAmelCase__				:			List[Any]							=    oct_string[1:]
     if not oct_string.isdigit() or not all(0 <= int(lowerCAmelCase		) <= 7 for char in oct_string		):
          raise ValueError("Non-octal value was passed to the function"		)
     UpperCAmelCase__				:			Optional[int]							=    0
     for char in oct_string:
          UpperCAmelCase__				:			Tuple							=    8 * decimal_number + int(lowerCAmelCase		)
     if is_negative:
          UpperCAmelCase__				:			int							=    -decimal_number
     return decimal_number


if __name__ == "__main__":
    from doctest import testmod

    testmod()



