
"""simple docstring"""



from typing import Dict, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    center_crop,
    get_resize_output_image_size,
    normalize,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    is_valid_image,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


if is_vision_available():
 import PIL


a					:	Union[str, Any]							=		logging.get_logger(__name__)


def  _UpperCamelCase	(						_A      )    ->  List[List[ImageInput]]:





    """simple docstring"""

    if isinstance(_A					,      (list, tuple)      ) and isinstance(videos[0]					,      (list, tuple)      ) and is_valid_image(videos[0][0]      ):
        return videos

    elif isinstance(_A					,      (list, tuple)      ) and is_valid_image(videos[0]      ):
        return [videos]

    elif is_valid_image(_A      ):
        return [[videos]]

    raise ValueError(F"""Could not make batched video from {videos}"""      )







class 		a_						( _UpperCAmelCase	):
    a      :				List[str]     =				['pixel_values']







    def __init__(			self			:       Dict     ,					__UpperCamelCase			:       bool = True     ,					__UpperCamelCase			:       Dict[str, int] = None     ,					__UpperCamelCase			:       PILImageResampling = PILImageResampling.BILINEAR     ,					__UpperCamelCase			:       bool = True     ,					__UpperCamelCase			:       Dict[str, int] = None     ,					__UpperCamelCase			:       bool = True     ,					__UpperCamelCase			:       Union[int, float] = 1 / 2_55     ,					__UpperCamelCase			:       bool = True     ,					__UpperCamelCase			:       Optional[Union[float, List[float]]] = None     ,					__UpperCamelCase			:       Optional[Union[float, List[float]]] = None     ,					**__UpperCamelCase			:       Optional[int]     ,					)		->None:






        '''simple docstring'''






        super().__init__(**__UpperCamelCase     )
        _UpperCAmelCase          =   size if size is not None else {"""shortest_edge""": 2_24}
        _UpperCAmelCase          =   get_size_dict(__UpperCamelCase     ,					default_to_square=__UpperCamelCase     )
        _UpperCAmelCase          =   crop_size if crop_size is not None else {"""height""": 2_24, """width""": 2_24}
        _UpperCAmelCase          =   get_size_dict(__UpperCamelCase     ,					param_name="""crop_size"""     )

        _UpperCAmelCase          =   do_resize
        _UpperCAmelCase          =   size
        _UpperCAmelCase          =   do_center_crop
        _UpperCAmelCase          =   crop_size
        _UpperCAmelCase          =   resample
        _UpperCAmelCase          =   do_rescale
        _UpperCAmelCase          =   rescale_factor
        _UpperCAmelCase          =   do_normalize
        _UpperCAmelCase          =   image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
        _UpperCAmelCase          =   image_std if image_std is not None else IMAGENET_STANDARD_STD







    def      _snake_case					(			self			:       Dict     ,					__UpperCamelCase			:       np.ndarray     ,					__UpperCamelCase			:       Dict[str, int]     ,					__UpperCamelCase			:       PILImageResampling = PILImageResampling.BILINEAR     ,					__UpperCamelCase			:       Optional[Union[str, ChannelDimension]] = None     ,					**__UpperCamelCase			:       List[Any]     ,					)		->np.ndarray:






        '''simple docstring'''






        _UpperCAmelCase          =   get_size_dict(__UpperCamelCase     ,					default_to_square=__UpperCamelCase     )
        if "shortest_edge" in size:
            _UpperCAmelCase          =   get_resize_output_image_size(__UpperCamelCase     ,					size["""shortest_edge"""]     ,					default_to_square=__UpperCamelCase     )
        elif "height" in size and "width" in size:
            _UpperCAmelCase          =   (size["""height"""], size["""width"""])
        else:
            raise ValueError(f"""Size must have 'height' and 'width' or 'shortest_edge' as keys. Got {size.keys()}"""     )
        return resize(__UpperCamelCase     ,					size=__UpperCamelCase     ,					resample=__UpperCamelCase     ,					data_format=__UpperCamelCase     ,					**__UpperCamelCase     )







    def      _snake_case					(			self			:       List[str]     ,					__UpperCamelCase			:       np.ndarray     ,					__UpperCamelCase			:       Dict[str, int]     ,					__UpperCamelCase			:       Optional[Union[str, ChannelDimension]] = None     ,					**__UpperCamelCase			:       List[str]     ,					)		->np.ndarray:






        '''simple docstring'''






        _UpperCAmelCase          =   get_size_dict(__UpperCamelCase     )
        if "height" not in size or "width" not in size:
            raise ValueError(f"""Size must have 'height' and 'width' as keys. Got {size.keys()}"""     )
        return center_crop(__UpperCamelCase     ,					size=(size["""height"""], size["""width"""])     ,					data_format=__UpperCamelCase     ,					**__UpperCamelCase     )







    def      _snake_case					(			self			:       Optional[Any]     ,					__UpperCamelCase			:       np.ndarray     ,					__UpperCamelCase			:       Union[int, float]     ,					__UpperCamelCase			:       Optional[Union[str, ChannelDimension]] = None     ,					**__UpperCamelCase			:       Any     ,					)		->int:






        '''simple docstring'''






        return rescale(__UpperCamelCase     ,					scale=__UpperCamelCase     ,					data_format=__UpperCamelCase     ,					**__UpperCamelCase     )







    def      _snake_case					(			self			:       Dict     ,					__UpperCamelCase			:       np.ndarray     ,					__UpperCamelCase			:       Union[float, List[float]]     ,					__UpperCamelCase			:       Union[float, List[float]]     ,					__UpperCamelCase			:       Optional[Union[str, ChannelDimension]] = None     ,					**__UpperCamelCase			:       List[Any]     ,					)		->np.ndarray:






        '''simple docstring'''






        return normalize(__UpperCamelCase     ,					mean=__UpperCamelCase     ,					std=__UpperCamelCase     ,					data_format=__UpperCamelCase     ,					**__UpperCamelCase     )







    def      _snake_case					(			self			:       Any     ,					__UpperCamelCase			:       ImageInput     ,					__UpperCamelCase			:       bool = None     ,					__UpperCamelCase			:       Dict[str, int] = None     ,					__UpperCamelCase			:       PILImageResampling = None     ,					__UpperCamelCase			:       bool = None     ,					__UpperCamelCase			:       Dict[str, int] = None     ,					__UpperCamelCase			:       bool = None     ,					__UpperCamelCase			:       float = None     ,					__UpperCamelCase			:       bool = None     ,					__UpperCamelCase			:       Optional[Union[float, List[float]]] = None     ,					__UpperCamelCase			:       Optional[Union[float, List[float]]] = None     ,					__UpperCamelCase			:       Optional[ChannelDimension] = ChannelDimension.FIRST     ,					)		->np.ndarray:






        '''simple docstring'''






        if do_resize and size is None or resample is None:
            raise ValueError("""Size and resample must be specified if do_resize is True."""     )

        if do_center_crop and crop_size is None:
            raise ValueError("""Crop size must be specified if do_center_crop is True."""     )

        if do_rescale and rescale_factor is None:
            raise ValueError("""Rescale factor must be specified if do_rescale is True."""     )

        if do_normalize and (image_mean is None or image_std is None):
            raise ValueError("""Image mean and std must be specified if do_normalize is True."""     )

        # All transformations expect numpy arrays.
        _UpperCAmelCase          =   to_numpy_array(__UpperCamelCase     )

        if do_resize:
            _UpperCAmelCase          =   self.resize(image=__UpperCamelCase     ,					size=__UpperCamelCase     ,					resample=__UpperCamelCase     )

        if do_center_crop:
            _UpperCAmelCase          =   self.center_crop(__UpperCamelCase     ,					size=__UpperCamelCase     )

        if do_rescale:
            _UpperCAmelCase          =   self.rescale(image=__UpperCamelCase     ,					scale=__UpperCamelCase     )

        if do_normalize:
            _UpperCAmelCase          =   self.normalize(image=__UpperCamelCase     ,					mean=__UpperCamelCase     ,					std=__UpperCamelCase     )

        _UpperCAmelCase          =   to_channel_dimension_format(__UpperCamelCase     ,					__UpperCamelCase     )
        return image







    def      _snake_case					(			self			:       Optional[int]     ,					__UpperCamelCase			:       ImageInput     ,					__UpperCamelCase			:       bool = None     ,					__UpperCamelCase			:       Dict[str, int] = None     ,					__UpperCamelCase			:       PILImageResampling = None     ,					__UpperCamelCase			:       bool = None     ,					__UpperCamelCase			:       Dict[str, int] = None     ,					__UpperCamelCase			:       bool = None     ,					__UpperCamelCase			:       float = None     ,					__UpperCamelCase			:       bool = None     ,					__UpperCamelCase			:       Optional[Union[float, List[float]]] = None     ,					__UpperCamelCase			:       Optional[Union[float, List[float]]] = None     ,					__UpperCamelCase			:       Optional[Union[str, TensorType]] = None     ,					__UpperCamelCase			:       ChannelDimension = ChannelDimension.FIRST     ,					**__UpperCamelCase			:       Optional[Any]     ,					)		->PIL.Image.Image:






        '''simple docstring'''






        _UpperCAmelCase          =   do_resize if do_resize is not None else self.do_resize
        _UpperCAmelCase          =   resample if resample is not None else self.resample
        _UpperCAmelCase          =   do_center_crop if do_center_crop is not None else self.do_center_crop
        _UpperCAmelCase          =   do_rescale if do_rescale is not None else self.do_rescale
        _UpperCAmelCase          =   rescale_factor if rescale_factor is not None else self.rescale_factor
        _UpperCAmelCase          =   do_normalize if do_normalize is not None else self.do_normalize
        _UpperCAmelCase          =   image_mean if image_mean is not None else self.image_mean
        _UpperCAmelCase          =   image_std if image_std is not None else self.image_std

        _UpperCAmelCase          =   size if size is not None else self.size
        _UpperCAmelCase          =   get_size_dict(__UpperCamelCase     ,					default_to_square=__UpperCamelCase     )
        _UpperCAmelCase          =   crop_size if crop_size is not None else self.crop_size
        _UpperCAmelCase          =   get_size_dict(__UpperCamelCase     ,					param_name="""crop_size"""     )

        if not valid_images(__UpperCamelCase     ):
            raise ValueError(
                """Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, """
                """torch.Tensor, tf.Tensor or jax.ndarray."""     )

        _UpperCAmelCase          =   make_batched(__UpperCamelCase     )

        _UpperCAmelCase          =   [
            [
                self._preprocess_image(
                    image=__UpperCamelCase     ,					do_resize=__UpperCamelCase     ,					size=__UpperCamelCase     ,					resample=__UpperCamelCase     ,					do_center_crop=__UpperCamelCase     ,					crop_size=__UpperCamelCase     ,					do_rescale=__UpperCamelCase     ,					rescale_factor=__UpperCamelCase     ,					do_normalize=__UpperCamelCase     ,					image_mean=__UpperCamelCase     ,					image_std=__UpperCamelCase     ,					data_format=__UpperCamelCase     ,					)
                for img in video
            ]
            for video in videos
        ]

        _UpperCAmelCase          =   {"""pixel_values""": videos}
        return BatchFeature(data=__UpperCamelCase     ,					tensor_type=__UpperCamelCase     )

"""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

a					:	List[Any]							=		get_logger()

a					:	Optional[dict]							=		None




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







    def __init__(			self			:       int     ,					__UpperCamelCase			:       List[str]=None     ,					__UpperCamelCase			:       Optional[int]=None     ,					**__UpperCamelCase			:       int     )		->Tuple:






        '''simple docstring'''






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

        if isinstance(__UpperCamelCase     ,					__UpperCamelCase     ):
            raise ValueError(
                f"""Expected {device} to be a `str` not {type(__UpperCamelCase     )}, 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          =   device if isinstance(__UpperCamelCase     ,					__UpperCamelCase     ) 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          =   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          =   str(jax.devices()[0]     )
        _UpperCAmelCase          =   jnp_array_kwargs







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






        '''simple docstring'''






        import jax

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







    def      _snake_case					(			self			:       Dict     ,					__UpperCamelCase			:       Any     )		->Union[str, Any]:






        '''simple docstring'''






        import jax
        import jax.numpy as jnp

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







    def      _snake_case					(			self			:       List[str]     ,					__UpperCamelCase			:       Any     )		->Optional[int]:






        '''simple docstring'''






        import jax
        import jax.numpy as jnp

        if isinstance(__UpperCamelCase     ,					(str, bytes, type(__UpperCamelCase     ))     ):
            return value
        elif isinstance(__UpperCamelCase     ,					(np.character, np.ndarray)     ) and np.issubdtype(value.dtype     ,					np.character     ):
            return value.tolist()

        _UpperCAmelCase          =   {}

        if isinstance(__UpperCamelCase     ,					(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          =   {"""dtype""": jnp.intaa}
            else:
                _UpperCAmelCase          =   {"""dtype""": jnp.intaa}
        elif isinstance(__UpperCamelCase     ,					(np.number, np.ndarray)     ) and np.issubdtype(value.dtype     ,					np.floating     ):
            _UpperCAmelCase          =   {"""dtype""": jnp.floataa}
        elif config.PIL_AVAILABLE and "PIL" in sys.modules:
            import PIL.Image

            if isinstance(__UpperCamelCase     ,					PIL.Image.Image     ):
                _UpperCAmelCase          =   np.asarray(__UpperCamelCase     )

        # 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          =   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(__UpperCamelCase     ,					**{**default_dtype, **self.jnp_array_kwargs}     )







    def      _snake_case					(			self			:       Union[str, Any]     ,					__UpperCamelCase			:       List[str]     )		->Any:






        '''simple docstring'''






        import jax

        # support for torch, tf, jax etc.
        if config.TORCH_AVAILABLE and "torch" in sys.modules:
            import torch

            if isinstance(__UpperCamelCase     ,					torch.Tensor     ):
                return self._tensorize(data_struct.detach().cpu().numpy()[()]     )
        if hasattr(__UpperCamelCase     ,					"""__array__"""     ) and not isinstance(__UpperCamelCase     ,					jax.Array     ):
            _UpperCAmelCase          =   data_struct.__array__()
        # support for nested types like struct of list of struct
        if isinstance(__UpperCamelCase     ,					np.ndarray     ):
            if data_struct.dtype == object:  # jax arrays cannot be instantied from an array of objects
                return self._consolidate([self.recursive_tensorize(__UpperCamelCase     ) for substruct in data_struct]     )
        elif isinstance(__UpperCamelCase     ,					(list, tuple)     ):
            return self._consolidate([self.recursive_tensorize(__UpperCamelCase     ) for substruct in data_struct]     )
        return self._tensorize(__UpperCamelCase     )







    def      _snake_case					(			self			:       List[str]     ,					__UpperCamelCase			:       dict     )		->int:






        '''simple docstring'''






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







    def      _snake_case					(			self			:       Dict     ,					__UpperCamelCase			:       pa.Table     )		->Mapping:






        '''simple docstring'''






        _UpperCAmelCase          =   self.numpy_arrow_extractor().extract_row(__UpperCamelCase     )
        _UpperCAmelCase          =   self.python_features_decoder.decode_row(__UpperCamelCase     )
        return self.recursive_tensorize(__UpperCamelCase     )







    def      _snake_case					(			self			:       Optional[int]     ,					__UpperCamelCase			:       pa.Table     )		->"jax.Array":






        '''simple docstring'''






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







    def      _snake_case					(			self			:       Optional[Any]     ,					__UpperCamelCase			:       pa.Table     )		->Mapping:






        '''simple docstring'''






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