

from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_torch_available,
)


_lowerCAmelCase      :    Dict						       =    {
    "auto_factory": ["get_values"],
    "configuration_auto": ["ALL_PRETRAINED_CONFIG_ARCHIVE_MAP", "CONFIG_MAPPING", "MODEL_NAMES_MAPPING", "AutoConfig"],
    "feature_extraction_auto": ["FEATURE_EXTRACTOR_MAPPING", "AutoFeatureExtractor"],
    "image_processing_auto": ["IMAGE_PROCESSOR_MAPPING", "AutoImageProcessor"],
    "processing_auto": ["PROCESSOR_MAPPING", "AutoProcessor"],
    "tokenization_auto": ["TOKENIZER_MAPPING", "AutoTokenizer"],
}

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						_lowerCAmelCase      :    Any						       =    [
						    "MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING",
						    "MODEL_FOR_AUDIO_FRAME_CLASSIFICATION_MAPPING",
						    "MODEL_FOR_AUDIO_XVECTOR_MAPPING",
						    "MODEL_FOR_BACKBONE_MAPPING",
						    "MODEL_FOR_CAUSAL_IMAGE_MODELING_MAPPING",
						    "MODEL_FOR_CAUSAL_LM_MAPPING",
						    "MODEL_FOR_CTC_MAPPING",
						    "MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING",
						    "MODEL_FOR_DEPTH_ESTIMATION_MAPPING",
						    "MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING",
						    "MODEL_FOR_IMAGE_SEGMENTATION_MAPPING",
						    "MODEL_FOR_INSTANCE_SEGMENTATION_MAPPING",
						    "MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING",
						    "MODEL_FOR_MASKED_LM_MAPPING",
						    "MODEL_FOR_MASK_GENERATION_MAPPING",
						    "MODEL_FOR_MULTIPLE_CHOICE_MAPPING",
						    "MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING",
						    "MODEL_FOR_OBJECT_DETECTION_MAPPING",
						    "MODEL_FOR_PRETRAINING_MAPPING",
						    "MODEL_FOR_QUESTION_ANSWERING_MAPPING",
						    "MODEL_FOR_SEMANTIC_SEGMENTATION_MAPPING",
						    "MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING",
						    "MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING",
						    "MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING",
						    "MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING",
						    "MODEL_FOR_TEXT_ENCODING_MAPPING",
						    "MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING",
						    "MODEL_FOR_UNIVERSAL_SEGMENTATION_MAPPING",
						    "MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING",
						    "MODEL_FOR_VISION_2_SEQ_MAPPING",
						    "MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING",
						    "MODEL_MAPPING",
						    "MODEL_WITH_LM_HEAD_MAPPING",
						    "MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING",
						    "MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING",
						    "AutoModel",
						    "AutoBackbone",
						    "AutoModelForAudioClassification",
						    "AutoModelForAudioFrameClassification",
						    "AutoModelForAudioXVector",
						    "AutoModelForCausalLM",
						    "AutoModelForCTC",
						    "AutoModelForDepthEstimation",
						    "AutoModelForImageClassification",
						    "AutoModelForImageSegmentation",
						    "AutoModelForInstanceSegmentation",
						    "AutoModelForMaskGeneration",
						    "AutoModelForTextEncoding",
						    "AutoModelForMaskedImageModeling",
						    "AutoModelForMaskedLM",
						    "AutoModelForMultipleChoice",
						    "AutoModelForNextSentencePrediction",
						    "AutoModelForObjectDetection",
						    "AutoModelForPreTraining",
						    "AutoModelForQuestionAnswering",
						    "AutoModelForSemanticSegmentation",
						    "AutoModelForSeq2SeqLM",
						    "AutoModelForSequenceClassification",
						    "AutoModelForSpeechSeq2Seq",
						    "AutoModelForTableQuestionAnswering",
						    "AutoModelForTokenClassification",
						    "AutoModelForUniversalSegmentation",
						    "AutoModelForVideoClassification",
						    "AutoModelForVision2Seq",
						    "AutoModelForVisualQuestionAnswering",
						    "AutoModelForDocumentQuestionAnswering",
						    "AutoModelWithLMHead",
						    "AutoModelForZeroShotImageClassification",
						    "AutoModelForZeroShotObjectDetection",
						]

try:
						if not is_tf_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						_lowerCAmelCase      :    List[Any]						       =    [
						    "TF_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING",
						    "TF_MODEL_FOR_CAUSAL_LM_MAPPING",
						    "TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING",
						    "TF_MODEL_FOR_MASK_GENERATION_MAPPING",
						    "TF_MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING",
						    "TF_MODEL_FOR_MASKED_LM_MAPPING",
						    "TF_MODEL_FOR_MULTIPLE_CHOICE_MAPPING",
						    "TF_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING",
						    "TF_MODEL_FOR_PRETRAINING_MAPPING",
						    "TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING",
						    "TF_MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING",
						    "TF_MODEL_FOR_SEMANTIC_SEGMENTATION_MAPPING",
						    "TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING",
						    "TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING",
						    "TF_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING",
						    "TF_MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING",
						    "TF_MODEL_FOR_TEXT_ENCODING_MAPPING",
						    "TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING",
						    "TF_MODEL_FOR_VISION_2_SEQ_MAPPING",
						    "TF_MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING",
						    "TF_MODEL_MAPPING",
						    "TF_MODEL_WITH_LM_HEAD_MAPPING",
						    "TFAutoModel",
						    "TFAutoModelForAudioClassification",
						    "TFAutoModelForCausalLM",
						    "TFAutoModelForImageClassification",
						    "TFAutoModelForMaskedImageModeling",
						    "TFAutoModelForMaskedLM",
						    "TFAutoModelForMaskGeneration",
						    "TFAutoModelForMultipleChoice",
						    "TFAutoModelForNextSentencePrediction",
						    "TFAutoModelForPreTraining",
						    "TFAutoModelForDocumentQuestionAnswering",
						    "TFAutoModelForQuestionAnswering",
						    "TFAutoModelForSemanticSegmentation",
						    "TFAutoModelForSeq2SeqLM",
						    "TFAutoModelForSequenceClassification",
						    "TFAutoModelForSpeechSeq2Seq",
						    "TFAutoModelForTableQuestionAnswering",
						    "TFAutoModelForTextEncoding",
						    "TFAutoModelForTokenClassification",
						    "TFAutoModelForVision2Seq",
						    "TFAutoModelForZeroShotImageClassification",
						    "TFAutoModelWithLMHead",
						]

try:
						if not is_flax_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						_lowerCAmelCase      :    List[str]						       =    [
						    "FLAX_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING",
						    "FLAX_MODEL_FOR_CAUSAL_LM_MAPPING",
						    "FLAX_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING",
						    "FLAX_MODEL_FOR_MASKED_LM_MAPPING",
						    "FLAX_MODEL_FOR_MULTIPLE_CHOICE_MAPPING",
						    "FLAX_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING",
						    "FLAX_MODEL_FOR_PRETRAINING_MAPPING",
						    "FLAX_MODEL_FOR_QUESTION_ANSWERING_MAPPING",
						    "FLAX_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING",
						    "FLAX_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING",
						    "FLAX_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING",
						    "FLAX_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING",
						    "FLAX_MODEL_FOR_VISION_2_SEQ_MAPPING",
						    "FLAX_MODEL_MAPPING",
						    "FlaxAutoModel",
						    "FlaxAutoModelForCausalLM",
						    "FlaxAutoModelForImageClassification",
						    "FlaxAutoModelForMaskedLM",
						    "FlaxAutoModelForMultipleChoice",
						    "FlaxAutoModelForNextSentencePrediction",
						    "FlaxAutoModelForPreTraining",
						    "FlaxAutoModelForQuestionAnswering",
						    "FlaxAutoModelForSeq2SeqLM",
						    "FlaxAutoModelForSequenceClassification",
						    "FlaxAutoModelForSpeechSeq2Seq",
						    "FlaxAutoModelForTokenClassification",
						    "FlaxAutoModelForVision2Seq",
						]


if TYPE_CHECKING:
						from .auto_factory import get_values
						from .configuration_auto import ALL_PRETRAINED_CONFIG_ARCHIVE_MAP, CONFIG_MAPPING, MODEL_NAMES_MAPPING, AutoConfig
						from .feature_extraction_auto import FEATURE_EXTRACTOR_MAPPING, AutoFeatureExtractor
						from .image_processing_auto import IMAGE_PROCESSOR_MAPPING, AutoImageProcessor
						from .processing_auto import PROCESSOR_MAPPING, AutoProcessor
						from .tokenization_auto import TOKENIZER_MAPPING, AutoTokenizer

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_auto import (
												    MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING,
												    MODEL_FOR_AUDIO_FRAME_CLASSIFICATION_MAPPING,
												    MODEL_FOR_AUDIO_XVECTOR_MAPPING,
												    MODEL_FOR_BACKBONE_MAPPING,
												    MODEL_FOR_CAUSAL_IMAGE_MODELING_MAPPING,
												    MODEL_FOR_CAUSAL_LM_MAPPING,
												    MODEL_FOR_CTC_MAPPING,
												    MODEL_FOR_DEPTH_ESTIMATION_MAPPING,
												    MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING,
												    MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
												    MODEL_FOR_IMAGE_SEGMENTATION_MAPPING,
												    MODEL_FOR_INSTANCE_SEGMENTATION_MAPPING,
												    MODEL_FOR_MASK_GENERATION_MAPPING,
												    MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING,
												    MODEL_FOR_MASKED_LM_MAPPING,
												    MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
												    MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING,
												    MODEL_FOR_OBJECT_DETECTION_MAPPING,
												    MODEL_FOR_PRETRAINING_MAPPING,
												    MODEL_FOR_QUESTION_ANSWERING_MAPPING,
												    MODEL_FOR_SEMANTIC_SEGMENTATION_MAPPING,
												    MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
												    MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
												    MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING,
												    MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING,
												    MODEL_FOR_TEXT_ENCODING_MAPPING,
												    MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
												    MODEL_FOR_UNIVERSAL_SEGMENTATION_MAPPING,
												    MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING,
												    MODEL_FOR_VISION_2_SEQ_MAPPING,
												    MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING,
												    MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING,
												    MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING,
												    MODEL_MAPPING,
												    MODEL_WITH_LM_HEAD_MAPPING,
												    AutoBackbone,
												    AutoModel,
												    AutoModelForAudioClassification,
												    AutoModelForAudioFrameClassification,
												    AutoModelForAudioXVector,
												    AutoModelForCausalLM,
												    AutoModelForCTC,
												    AutoModelForDepthEstimation,
												    AutoModelForDocumentQuestionAnswering,
												    AutoModelForImageClassification,
												    AutoModelForImageSegmentation,
												    AutoModelForInstanceSegmentation,
												    AutoModelForMaskedImageModeling,
												    AutoModelForMaskedLM,
												    AutoModelForMaskGeneration,
												    AutoModelForMultipleChoice,
												    AutoModelForNextSentencePrediction,
												    AutoModelForObjectDetection,
												    AutoModelForPreTraining,
												    AutoModelForQuestionAnswering,
												    AutoModelForSemanticSegmentation,
												    AutoModelForSeqaSeqLM,
												    AutoModelForSequenceClassification,
												    AutoModelForSpeechSeqaSeq,
												    AutoModelForTableQuestionAnswering,
												    AutoModelForTextEncoding,
												    AutoModelForTokenClassification,
												    AutoModelForUniversalSegmentation,
												    AutoModelForVideoClassification,
												    AutoModelForVisionaSeq,
												    AutoModelForVisualQuestionAnswering,
												    AutoModelForZeroShotImageClassification,
												    AutoModelForZeroShotObjectDetection,
												    AutoModelWithLMHead,
												)

						try:
												if not is_tf_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_tf_auto import (
												    TF_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING,
												    TF_MODEL_FOR_CAUSAL_LM_MAPPING,
												    TF_MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING,
												    TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
												    TF_MODEL_FOR_MASK_GENERATION_MAPPING,
												    TF_MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING,
												    TF_MODEL_FOR_MASKED_LM_MAPPING,
												    TF_MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
												    TF_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING,
												    TF_MODEL_FOR_PRETRAINING_MAPPING,
												    TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
												    TF_MODEL_FOR_SEMANTIC_SEGMENTATION_MAPPING,
												    TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
												    TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
												    TF_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING,
												    TF_MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING,
												    TF_MODEL_FOR_TEXT_ENCODING_MAPPING,
												    TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
												    TF_MODEL_FOR_VISION_2_SEQ_MAPPING,
												    TF_MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING,
												    TF_MODEL_MAPPING,
												    TF_MODEL_WITH_LM_HEAD_MAPPING,
												    TFAutoModel,
												    TFAutoModelForAudioClassification,
												    TFAutoModelForCausalLM,
												    TFAutoModelForDocumentQuestionAnswering,
												    TFAutoModelForImageClassification,
												    TFAutoModelForMaskedImageModeling,
												    TFAutoModelForMaskedLM,
												    TFAutoModelForMaskGeneration,
												    TFAutoModelForMultipleChoice,
												    TFAutoModelForNextSentencePrediction,
												    TFAutoModelForPreTraining,
												    TFAutoModelForQuestionAnswering,
												    TFAutoModelForSemanticSegmentation,
												    TFAutoModelForSeqaSeqLM,
												    TFAutoModelForSequenceClassification,
												    TFAutoModelForSpeechSeqaSeq,
												    TFAutoModelForTableQuestionAnswering,
												    TFAutoModelForTextEncoding,
												    TFAutoModelForTokenClassification,
												    TFAutoModelForVisionaSeq,
												    TFAutoModelForZeroShotImageClassification,
												    TFAutoModelWithLMHead,
												)

						try:
												if not is_flax_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_flax_auto import (
												    FLAX_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING,
												    FLAX_MODEL_FOR_CAUSAL_LM_MAPPING,
												    FLAX_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
												    FLAX_MODEL_FOR_MASKED_LM_MAPPING,
												    FLAX_MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
												    FLAX_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING,
												    FLAX_MODEL_FOR_PRETRAINING_MAPPING,
												    FLAX_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
												    FLAX_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
												    FLAX_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
												    FLAX_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING,
												    FLAX_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
												    FLAX_MODEL_FOR_VISION_2_SEQ_MAPPING,
												    FLAX_MODEL_MAPPING,
												    FlaxAutoModel,
												    FlaxAutoModelForCausalLM,
												    FlaxAutoModelForImageClassification,
												    FlaxAutoModelForMaskedLM,
												    FlaxAutoModelForMultipleChoice,
												    FlaxAutoModelForNextSentencePrediction,
												    FlaxAutoModelForPreTraining,
												    FlaxAutoModelForQuestionAnswering,
												    FlaxAutoModelForSeqaSeqLM,
												    FlaxAutoModelForSequenceClassification,
												    FlaxAutoModelForSpeechSeqaSeq,
												    FlaxAutoModelForTokenClassification,
												    FlaxAutoModelForVisionaSeq,
												)

else:
						import sys

						_lowerCAmelCase      :    str						       =    _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)








# 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 			__magic_name__					(    TensorFormatter[Mapping, 'tf.Tensor', Mapping]   ):





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




						'''simple docstring'''
						super().__init__(features=__snake_case      )
						__a						   =tf_tensor_kwargs
						import tensorflow as tf  # noqa: import tf at initialization





			def 	__magic_name__					(	self      ,						__snake_case      )     ->				int:




						'''simple docstring'''
						import tensorflow as tf

						if isinstance(__snake_case      ,						__snake_case      ) and column:
									if all(
									    isinstance(__snake_case      ,						tf.Tensor      ) and x.shape == column[0].shape and x.dtype == column[0].dtype for x in column      ):
												return tf.stack(__snake_case      )
									elif all(
									    isinstance(__snake_case      ,						(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(__snake_case      )

						return column





			def 	__magic_name__					(	self      ,						__snake_case      )     ->				Any:




						'''simple docstring'''
						import tensorflow as tf

						if value is None:
									return value

						__a						   ={}

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

									if isinstance(__snake_case      ,						PIL.Image.Image      ):
												__a						   =np.asarray(__snake_case      )

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





			def 	__magic_name__					(	self      ,						__snake_case      )     ->				Dict:




						'''simple docstring'''
						import tensorflow as tf

						# 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      ,						tf.Tensor      ):
									__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:  # tf tensors cannot be instantied from an array of objects
												return self._consolidate([self.recursive_tensorize(__snake_case      ) for substruct in data_struct]      )
						elif isinstance(__snake_case      ,						(list, tuple)      ):
									return self._consolidate([self.recursive_tensorize(__snake_case      ) for substruct in data_struct]      )
						return self._tensorize(__snake_case      )





			def 	__magic_name__					(	self      ,						__snake_case      )     ->				Optional[Any]:




						'''simple docstring'''
						return map_nested(self._recursive_tensorize      ,						__snake_case      ,						map_list=__snake_case      )





			def 	__magic_name__					(	self      ,						__snake_case      )     ->				Mapping:




						'''simple docstring'''
						__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 	__magic_name__					(	self      ,						__snake_case      )     ->				"tf.Tensor":




						'''simple docstring'''
						__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 	__magic_name__					(	self      ,						__snake_case      )     ->				Mapping:




						'''simple docstring'''
						__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






