





"""simple docstring"""




# Lint as: python3
import sys
from collections.abc import Mapping
from typing import TYPE_CHECKING, Dict, Optional

import numpy as np
import pyarrow as pa

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


if TYPE_CHECKING:
						import jax
						import jaxlib

UpperCamelCase_									=get_logger()

UpperCamelCase_									=None




class 			_a						(				TensorFormatter[Mapping, '''jax.Array''', Mapping]    ):






				def __init__(			self		:   Tuple,			lowerCAmelCase__		:   Tuple=None,			lowerCAmelCase__		:   List[Any]=None,			**lowerCAmelCase__		:   List[Any]							)     ->				Any:




										'''simple docstring'''



										super().__init__(features=lowerCAmelCase__							)
										import jax
										from jaxlib.xla_client import Device

										if isinstance(lowerCAmelCase__,			lowerCAmelCase__							):
																raise ValueError(
																    f"""Expected {device} to be a `str` not {type(lowerCAmelCase__							)}, as `jaxlib.xla_extension.Device` """
																    '''is not serializable neither with `pickle` nor with `dill`. Instead you can surround '''
																    '''the device with `str()` to get its string identifier that will be internally mapped '''
																    '''to the actual `jaxlib.xla_extension.Device`.'''							)
										_UpperCamelCase      : Optional[int]         =   device if isinstance(lowerCAmelCase__,			lowerCAmelCase__							) else str(jax.devices()[0]							)
										# using global variable since `jaxlib.xla_extension.Device` is not serializable neither
										# with `pickle` nor with `dill`, so we need to use a global variable instead
										global DEVICE_MAPPING
										if DEVICE_MAPPING is None:
																_UpperCamelCase      : Optional[int]         =   self._map_devices_to_str()
										if self.device not in list(DEVICE_MAPPING.keys()							):
																logger.warning(
																    f"""Device with string identifier {self.device} not listed among the available """
																    f"""devices: {list(DEVICE_MAPPING.keys()							)}, so falling back to the default """
																    f"""device: {str(jax.devices()[0]							)}."""							)
																_UpperCamelCase      : List[str]         =   str(jax.devices()[0]							)
										_UpperCamelCase      : Optional[Any]         =   jnp_array_kwargs






				@staticmethod
				def     snake_case     (			)     ->				Dict[str, "jaxlib.xla_extension.Device"]:




										'''simple docstring'''



										import jax

										return {str(lowerCAmelCase__							): device for device in jax.devices()}






				def     snake_case     (			self		:   List[Any],			lowerCAmelCase__		:   Tuple							)     ->				Tuple:




										'''simple docstring'''



										import jax
										import jax.numpy as jnp

										if isinstance(lowerCAmelCase__,			lowerCAmelCase__							) and column:
																if all(
																    isinstance(lowerCAmelCase__,			jax.Array							) and x.shape == column[0].shape and x.dtype == column[0].dtype for x in column							):
																						return jnp.stack(lowerCAmelCase__,			axis=0							)
										return column






				def     snake_case     (			self		:   Union[str, Any],			lowerCAmelCase__		:   int							)     ->				Union[str, Any]:




										'''simple docstring'''



										import jax
										import jax.numpy as jnp

										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.tolist()

										_UpperCamelCase      : Any         =   {}

										if isinstance(lowerCAmelCase__,			(np.number, np.ndarray)							) and np.issubdtype(value.dtype,			np.integer							):
																# the default int precision depends on the jax config
																# see https://jax.readthedocs.io/en/latest/notebooks/Common_Gotchas_in_JAX.html#double-64bit-precision
																if jax.config.jax_enable_xaa:
																						_UpperCamelCase      : Optional[int]         =   {'''dtype''': jnp.intaa}
																else:
																						_UpperCamelCase      : str         =   {'''dtype''': jnp.intaa}
										elif isinstance(lowerCAmelCase__,			(np.number, np.ndarray)							) and np.issubdtype(value.dtype,			np.floating							):
																_UpperCamelCase      : List[Any]         =   {'''dtype''': jnp.floataa}
										elif config.PIL_AVAILABLE and "PIL" in sys.modules:
																import PIL.Image

																if isinstance(lowerCAmelCase__,			PIL.Image.Image							):
																						_UpperCamelCase      : str         =   np.asarray(lowerCAmelCase__							)

        # using global variable since `jaxlib.xla_extension.Device` is not serializable neither
        # with `pickle` nor with `dill`, so we need to use a global variable instead
										global DEVICE_MAPPING
										if DEVICE_MAPPING is None:
																_UpperCamelCase      : Any         =   self._map_devices_to_str()

										with jax.default_device(DEVICE_MAPPING[self.device]							):
																# calling jnp.array on a np.ndarray does copy the data
																# see https://github.com/google/jax/issues/4486
																return jnp.array(lowerCAmelCase__,			**{**default_dtype, **self.jnp_array_kwargs}							)






				def     snake_case     (			self		:   Union[str, Any],			lowerCAmelCase__		:   List[str]							)     ->				Tuple:




										'''simple docstring'''



										import jax

										# 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__,			jax.Array							):
																_UpperCamelCase      : int         =   data_struct.__array__()
										# support for nested types like struct of list of struct
										if isinstance(lowerCAmelCase__,			np.ndarray							):
																if data_struct.dtype == object:  # jax arrays cannot be instantied from an array of objects
																						return self._consolidate([self.recursive_tensorize(lowerCAmelCase__							) for substruct in data_struct]							)
										elif isinstance(lowerCAmelCase__,			(list, tuple)							):
																return self._consolidate([self.recursive_tensorize(lowerCAmelCase__							) for substruct in data_struct]							)
										return self._tensorize(lowerCAmelCase__							)






				def     snake_case     (			self		:   int,			lowerCAmelCase__		:   dict							)     ->				List[str]:




										'''simple docstring'''



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






				def     snake_case     (			self		:   str,			lowerCAmelCase__		:   pa.Table							)     ->				Mapping:




										'''simple docstring'''



										_UpperCamelCase      : int         =   self.numpy_arrow_extractor().extract_row(lowerCAmelCase__							)
										_UpperCamelCase      : Union[str, Any]         =   self.python_features_decoder.decode_row(lowerCAmelCase__							)
										return self.recursive_tensorize(lowerCAmelCase__							)






				def     snake_case     (			self		:   Optional[Any],			lowerCAmelCase__		:   pa.Table							)     ->				"jax.Array":




										'''simple docstring'''



										_UpperCamelCase      : Union[str, Any]         =   self.numpy_arrow_extractor().extract_column(lowerCAmelCase__							)
										_UpperCamelCase      : Any         =   self.python_features_decoder.decode_column(lowerCAmelCase__,			pa_table.column_names[0]							)
										_UpperCamelCase      : int         =   self.recursive_tensorize(lowerCAmelCase__							)
										_UpperCamelCase      : List[Any]         =   self._consolidate(lowerCAmelCase__							)
										return column






				def     snake_case     (			self		:   Union[str, Any],			lowerCAmelCase__		:   pa.Table							)     ->				Mapping:




										'''simple docstring'''



										_UpperCamelCase      : Tuple         =   self.numpy_arrow_extractor().extract_batch(lowerCAmelCase__							)
										_UpperCamelCase      : str         =   self.python_features_decoder.decode_batch(lowerCAmelCase__							)
										_UpperCamelCase      : Optional[Any]         =   self.recursive_tensorize(lowerCAmelCase__							)
										for column_name in batch:
																_UpperCamelCase      : Any         =   self._consolidate(batch[column_name]							)
										return batch










"""simple docstring"""




from ...processing_utils import ProcessorMixin




class 			_a						(				_lowerCAmelCase    ):
				UpperCamelCase								=   ['''image_processor''', '''feature_extractor''']
				UpperCamelCase								=   '''TvltImageProcessor'''
				UpperCamelCase								=   '''TvltFeatureExtractor'''






				def __init__(			self		:   Union[str, Any],			lowerCAmelCase__		:   str,			lowerCAmelCase__		:   List[str]							)     ->				Optional[Any]:




										'''simple docstring'''



										super().__init__(image_processor=lowerCAmelCase__,			feature_extractor=lowerCAmelCase__							)

										_UpperCamelCase      : List[str]         =   image_processor
										_UpperCamelCase      : int         =   feature_extractor






				def __call__(			self		:   List[str],			lowerCAmelCase__		:   Optional[int]=None,			lowerCAmelCase__		:   str=None,			lowerCAmelCase__		:   Dict=None,			lowerCAmelCase__		:   str=None,			lowerCAmelCase__		:   Optional[int]=False,			lowerCAmelCase__		:   str=False,			*lowerCAmelCase__		:   List[str],			**lowerCAmelCase__		:   Optional[int],			)     ->				Dict:




										'''simple docstring'''



										if images is None and audio is None:
																raise ValueError('''You need to specify either an `images` or `audio` input to process.'''							)

										_UpperCamelCase      : Optional[int]         =   None
										if images is not None:
																_UpperCamelCase      : Optional[int]         =   self.image_processor(lowerCAmelCase__,			mask_pixel=lowerCAmelCase__,			*lowerCAmelCase__,			**lowerCAmelCase__							)
										if images_mixed is not None:
																_UpperCamelCase      : str         =   self.image_processor(lowerCAmelCase__,			is_mixed=lowerCAmelCase__,			*lowerCAmelCase__,			**lowerCAmelCase__							)
										if audio is not None:
																_UpperCamelCase      : Union[str, Any]         =   self.feature_extractor(
																    lowerCAmelCase__,			*lowerCAmelCase__,			sampling_rate=lowerCAmelCase__,			mask_audio=lowerCAmelCase__,			**lowerCAmelCase__							)

										_UpperCamelCase      : str         =   {}
										if audio is not None:
																output_dict.update(lowerCAmelCase__							)
										if images is not None:
																output_dict.update(lowerCAmelCase__							)
										if images_mixed_dict is not None:
																output_dict.update(lowerCAmelCase__							)
										return output_dict






				@property
				def     snake_case     (			self		:   List[str]							)     ->				Tuple:




										'''simple docstring'''



										_UpperCamelCase      : List[str]         =   self.image_processor.model_input_names
										_UpperCamelCase      : List[Any]         =   self.feature_extractor.model_input_names
										return list(dict.fromkeys(image_processor_input_names + feature_extractor_input_names							)							)



