






"""simple docstring"""







import warnings

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding







class 							_SCREAMING_SNAKE_CASE    (	__snake_case				):





							"""simple docstring"""





							_SCREAMING_SNAKE_CASE     =['image_processor', 'tokenizer']
							_SCREAMING_SNAKE_CASE     ='AutoImageProcessor'
							_SCREAMING_SNAKE_CASE     ='AutoTokenizer'




							def __init__( self:  List[Any]					,		__A:  int=None					,		__A:  Optional[int]=None					,		**__A:  str     ):

												'''simple docstring'''

												a__ 							=	None
												if "feature_extractor" in kwargs:
																	warnings.warn(
																	    '''The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`'''
																	    ''' instead.'''					,		__A					,		)
																	a__ 							=	kwargs.pop('''feature_extractor'''     )

												a__ 							=	image_processor if image_processor is not None else feature_extractor
												if image_processor is None:
																	raise ValueError('''You have to specify an image_processor.'''     )
												if tokenizer is None:
																	raise ValueError('''You have to specify a tokenizer.'''     )

												super().__init__(__A					,		__A     )
												a__ 							=	self.image_processor




							def __call__( self:  Dict					,		__A:  Optional[Any]=None					,		__A:  str=None					,		__A:  int=None					,		**__A:  List[str]     ):

												'''simple docstring'''

												if text is None and images is None:
																	raise ValueError('''You have to specify either text or images. Both cannot be none.'''     )

												if text is not None:
																	a__ 							=	self.tokenizer(__A					,		return_tensors=__A					,		**__A     )

												if images is not None:
																	a__ 							=	self.image_processor(__A					,		return_tensors=__A					,		**__A     )

												if text is not None and images is not None:
																	a__ 							=	image_features.pixel_values
																	return encoding
												elif text is not None:
																	return encoding
												else:
																	return BatchEncoding(data=dict(**__A     )					,		tensor_type=__A     )




							def 			lowercase		( self:  str					,		*__A:  Optional[Any]					,		**__A:  int     ):

												'''simple docstring'''

												return self.tokenizer.batch_decode(*__A					,		**__A     )




							def 			lowercase		( self:  List[Any]					,		*__A:  List[Any]					,		**__A:  List[str]     ):

												'''simple docstring'''

												return self.tokenizer.decode(*__A					,		**__A     )




							@property
							def 			lowercase		( self:  List[str]     ):

												'''simple docstring'''

												a__ 							=	self.tokenizer.model_input_names
												a__ 							=	self.image_processor.model_input_names
												return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names     )     )




							@property
							def 			lowercase		( self:  str     ):

												'''simple docstring'''

												warnings.warn(
												    '''`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead.'''					,		__A					,		)
												return self.image_processor_class





							@property
							def 			lowercase		( self:  List[Any]     ):

												'''simple docstring'''

												warnings.warn(
												    '''`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead.'''					,		__A					,		)
												return self.image_processor










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





							"""simple docstring"""





							def __init__( self:  Union[str, Any]					,		__A:  Union[str, Any]=None					,		**__A:  Union[str, Any]     ):

												'''simple docstring'''

												super().__init__(features=__A     )
												a__ 							=	tf_tensor_kwargs
												import tensorflow as tf  # noqa: import tf at initialization




							def 			lowercase		( self:  Optional[int]					,		__A:  List[Any]     ):

												'''simple docstring'''

												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 			lowercase		( self:  int					,		__A:  Optional[Any]     ):

												'''simple docstring'''

												import tensorflow as tf

												if value is None:
																	return value

												a__ 							=	{}

												if isinstance(__A					,		(np.number, np.ndarray)     ) and np.issubdtype(value.dtype					,		np.integer     ):
																	a__ 							=	{'''dtype''': tf.intaa}
												elif isinstance(__A					,		(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(__A					,		PIL.Image.Image     ):
																						a__ 							=	np.asarray(__A     )

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




							def 			lowercase		( self:  List[Any]					,		__A:  str     ):

												'''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(__A					,		torch.Tensor     ):
																						return self._tensorize(data_struct.detach().cpu().numpy()[()]     )
												if hasattr(__A					,		'''__array__'''     ) and not isinstance(__A					,		tf.Tensor     ):
																	a__ 							=	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 			lowercase		( self:  int					,		__A:  dict     ):

												'''simple docstring'''

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




							def 			lowercase		( self:  Tuple					,		__A:  pa.Table     ):

												'''simple docstring'''

												a__ 							=	self.numpy_arrow_extractor().extract_row(__A     )
												a__ 							=	self.python_features_decoder.decode_row(__A     )
												return self.recursive_tensorize(__A     )




							def 			lowercase		( self:  Dict					,		__A:  pa.Table     ):

												'''simple docstring'''

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





							def 			lowercase		( self:  Tuple					,		__A:  pa.Table     ):

												'''simple docstring'''

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


