
from typing import List, Optional, Union

import numpy as np
import PIL.Image

from ...image_processing_utils import BaseImageProcessor, BatchFeature
from ...image_transforms import rescale, resize, to_channel_dimension_format
from ...image_utils import (
    ChannelDimension,
    PILImageResampling,
    get_image_size,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, logging


lowercase__		:List[str]   =    logging.get_logger(__name__)







class 				lowercase		(					SCREAMING_SNAKE_CASE__		):
							lowercase_       :       Optional[Any]       					=['''pixel_values''']




							def __init__(				self   ,A__ = True   ,A__ = 3_2   ,A__=PILImageResampling.BILINEAR   ,A__ = True   ,**A__   ,):
												lowercase							=						do_resize
												lowercase							=						do_rescale
												lowercase							=						size_divisor
												lowercase							=						resample
												super().__init__(**A__)




							def  A__      (				self   ,A__   ,A__   ,A__   ,A__ = None   ,**A__):
												lowercase	,						lowercase							=						get_image_size(A__)
												# Rounds the height and width down to the closest multiple of size_divisor
												lowercase							=						height // size_divisor * size_divisor
												lowercase							=						width // size_divisor * size_divisor
												lowercase							=						resize(A__   ,(new_h, new_w)   ,resample=A__   ,data_format=A__   ,**A__)
												return image




							def  A__      (				self   ,A__   ,A__   ,A__ = None   ,**A__):
												return rescale(image=A__   ,scale=A__   ,data_format=A__   ,**A__)





							def  A__      (				self   ,A__   ,A__ = None   ,A__ = None   ,A__=None   ,A__ = None   ,A__ = None   ,A__ = ChannelDimension.FIRST   ,**A__   ,):
												lowercase							=						do_resize if do_resize is not None else self.do_resize
												lowercase							=						do_rescale if do_rescale is not None else self.do_rescale
												lowercase							=						size_divisor if size_divisor is not None else self.size_divisor
												lowercase							=						resample if resample is not None else self.resample

												if do_resize and size_divisor is None:
																	raise ValueError('''size_divisor is required for resizing''')

												lowercase							=						make_list_of_images(A__)

												if not valid_images(A__):
																	raise ValueError('''Invalid image(s)''')

												# All transformations expect numpy arrays.
												lowercase							=						[to_numpy_array(A__) for img in images]

												if do_resize:
																	lowercase							=						[self.resize(A__   ,size_divisor=A__   ,resample=A__) for image in images]

												if do_rescale:
																	lowercase							=						[self.rescale(A__   ,scale=1 / 2_5_5) for image in images]

												lowercase							=						[to_channel_dimension_format(A__   ,A__) for image in images]

												lowercase							=						{'''pixel_values''': images}
												return BatchFeature(data=A__   ,tensor_type=A__)






# Lint as: python3
# pylint: enable=line-too-long
# pylint: disable=g-import-not-at-top,g-bad-import-order,wrong-import-position

__A				='''2.13.1'''

import platform

import pyarrow
from packaging import version


if version.parse(platform.python_version()) < version.parse('''3.7'''):
			raise ImportWarning(
			    '''To use `datasets`, Python>=3.7 is required, and the current version of Python doesn\'t match this condition.'''
			)

if version.parse(pyarrow.__version__).major < 8:
			raise ImportWarning(
			    '''To use `datasets`, the module `pyarrow>=8.0.0` is required, and the current version of `pyarrow` doesn\'t match this condition.\n'''
			    '''If you are running this in a Google Colab, you should probably just restart the runtime to use the right version of `pyarrow`.'''
			)

del platform
del pyarrow
del version

from .arrow_dataset import Dataset
from .arrow_reader import ReadInstruction
from .builder import ArrowBasedBuilder, BeamBasedBuilder, BuilderConfig, DatasetBuilder, GeneratorBasedBuilder
from .combine import concatenate_datasets, interleave_datasets
from .dataset_dict import DatasetDict, IterableDatasetDict
from .download import *
from .features import *
from .fingerprint import disable_caching, enable_caching, is_caching_enabled, set_caching_enabled
from .info import DatasetInfo, MetricInfo
from .inspect import (
    get_dataset_config_info,
    get_dataset_config_names,
    get_dataset_infos,
    get_dataset_split_names,
    inspect_dataset,
    inspect_metric,
    list_datasets,
    list_metrics,
)
from .iterable_dataset import IterableDataset
from .load import load_dataset, load_dataset_builder, load_from_disk, load_metric
from .metric import Metric
from .splits import (
    NamedSplit,
    NamedSplitAll,
    Split,
    SplitBase,
    SplitDict,
    SplitGenerator,
    SplitInfo,
    SubSplitInfo,
    percent,
)
from .tasks import *
from .utils import *
from .utils import logging


# deprecated modules
from datasets import arrow_dataset as _arrow_dataset  # isort:skip
from datasets import utils as _utils  # isort:skip
from datasets.utils import download_manager as _deprecated_download_manager  # isort:skip

__A				=concatenate_datasets
__A				=DownloadConfig
__A				=DownloadManager
__A				=DownloadMode
__A				=DownloadConfig
__A				=DownloadMode
__A				=DownloadManager

del _arrow_dataset, _utils, _deprecated_download_manager


