
"""simple docstring"""







import sys
from dataclasses import dataclass
from typing import TYPE_CHECKING, Dict, List, Optional, Tuple, Union

import pandas as pd
import pyarrow as pa

import datasets
import datasets.config
from datasets.features.features import require_storage_cast
from datasets.table import table_cast


if TYPE_CHECKING:
							import sqlitea

							import sqlalchemy


lowerCamelCase__     =						datasets.utils.logging.get_logger(__name__)




@dataclass
class 					A__			(      datasets.BuilderConfig):
		A_		:			Union[str, "sqlalchemy.sql.Selectable"]							  =      None
		A_		:			Union[str, "sqlalchemy.engine.Connection", "sqlalchemy.engine.Engine", "sqlite3.Connection"]							  =      None
		A_		:			Optional[Union[str, List[str]]]							  =      None
		A_		:			bool							  =      True
		A_		:			Optional[Union[List, Tuple, Dict]]							  =      None
		A_		:			Optional[Union[List, Dict]]							  =      None
		A_		:			Optional[List[str]]							  =      None
		A_		:			Optional[int]							  =      1_0_0_0_0
		A_		:			Optional[datasets.Features]							  =      None

		def 				__lowerCamelCase				( self					):
			if self.sql is None:
				raise ValueError('sql must be specified'					)
			if self.con is None:
				raise ValueError('con must be specified'					)

		def 				__lowerCamelCase				( self			,						_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE = None			,						):
			__lowerCAmelCase     :		List[Any]		     = config_kwargs.copy()
			# We need to stringify the Selectable object to make its hash deterministic

			# The process of stringifying is explained here: http://docs.sqlalchemy.org/en/latest/faq/sqlexpressions.html
			__lowerCAmelCase     :		int		     = config_kwargs['sql']
			if not isinstance(_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE					):
				if datasets.config.SQLALCHEMY_AVAILABLE and "sqlalchemy" in sys.modules:
					import sqlalchemy

					if isinstance(_SCREAMING_SNAKE_CASE			,						sqlalchemy.sql.Selectable					):
						__lowerCAmelCase     :		str		     = sqlalchemy.create_engine(config_kwargs['con'].split('://'					)[0] + '://'					)
						__lowerCAmelCase     :		Tuple		     = str(sql.compile(dialect=engine.dialect					)					)
						__lowerCAmelCase     :		Dict		     = sql_str
					else:
						raise TypeError(
						    f"Supported types for 'sql' are string and sqlalchemy.sql.Selectable but got {type(_SCREAMING_SNAKE_CASE					)}: {sql}"					)
				else:
					raise TypeError(
					    f"Supported types for 'sql' are string and sqlalchemy.sql.Selectable but got {type(_SCREAMING_SNAKE_CASE					)}: {sql}"					)
			__lowerCAmelCase     :		Any		     = config_kwargs['con']
			if not isinstance(_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE					):
				__lowerCAmelCase     :		Dict		     = id(_SCREAMING_SNAKE_CASE					)
				logger.info(
				    f"SQL connection 'con' of type {type(_SCREAMING_SNAKE_CASE					)} couldn't be hashed properly. To enable hashing, specify 'con' as URI string instead."					)

			return super().create_config_id(_SCREAMING_SNAKE_CASE			,						custom_features=_SCREAMING_SNAKE_CASE					)







		@property
		def 				__lowerCamelCase				( self					):
			__lowerCAmelCase     :		Optional[Any]		     = {
			    'index_col': self.index_col,
			    'columns': self.columns,
			    'params': self.params,
			    'coerce_float': self.coerce_float,
			    'parse_dates': self.parse_dates,
			}
			return pd_read_sql_kwargs




class 					A__			(      datasets.ArrowBasedBuilder):
		A_		:			str							  =      SqlConfig

		def 				__lowerCamelCase				( self					):
			return datasets.DatasetInfo(features=self.config.features					)

		def 				__lowerCamelCase				( self			,						_SCREAMING_SNAKE_CASE					):
			return [datasets.SplitGenerator(name=datasets.Split.TRAIN			,						gen_kwargs={}					)]

		def 				__lowerCamelCase				( self			,						_SCREAMING_SNAKE_CASE					):
			if self.config.features is not None:
				__lowerCAmelCase     :		int		     = self.config.features.arrow_schema
				if all(not require_storage_cast(_SCREAMING_SNAKE_CASE					) for feature in self.config.features.values()					):
					# cheaper cast
					__lowerCAmelCase     :		List[str]		     = pa.Table.from_arrays([pa_table[field.name] for field in schema]			,						schema=_SCREAMING_SNAKE_CASE					)
				else:
					# more expensive cast; allows str <-> int/float or str to Audio for example
					__lowerCAmelCase     :		List[str]		     = table_cast(_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE					)
			return pa_table







		def 				__lowerCamelCase				( self					):
			__lowerCAmelCase     :		Dict		     = self.config.chunksize
			__lowerCAmelCase     :		Optional[Any]		     = pd.read_sql(
			    self.config.sql			,						self.config.con			,						chunksize=_SCREAMING_SNAKE_CASE			,						**self.config.pd_read_sql_kwargs					)
			__lowerCAmelCase     :		str		     = [sql_reader] if chunksize is None else sql_reader
			for chunk_idx, df in enumerate(_SCREAMING_SNAKE_CASE					):
				__lowerCAmelCase     :		Optional[int]		     = pa.Table.from_pandas(_SCREAMING_SNAKE_CASE					)
				yield chunk_idx, self._cast_table(_SCREAMING_SNAKE_CASE					)

"""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, normalize, rescale, resize, to_channel_dimension_format
from ...image_utils import (
    IMAGENET_DEFAULT_MEAN,
    IMAGENET_DEFAULT_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    get_image_size,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


if is_vision_available():
							import PIL


lowerCamelCase__     =						logging.get_logger(__name__)




class 					A__			(      _lowerCamelCase):
		A_		:			List[str]							  =      ['pixel_values']

		def __init__( self			,						_SCREAMING_SNAKE_CASE = True			,						_SCREAMING_SNAKE_CASE = None			,						_SCREAMING_SNAKE_CASE = True			,						_SCREAMING_SNAKE_CASE = None			,						_SCREAMING_SNAKE_CASE = PILImageResampling.BICUBIC			,						_SCREAMING_SNAKE_CASE = True			,						_SCREAMING_SNAKE_CASE = 1 / 2_55			,						_SCREAMING_SNAKE_CASE = True			,						_SCREAMING_SNAKE_CASE = None			,						_SCREAMING_SNAKE_CASE = None			,						**_SCREAMING_SNAKE_CASE			,						):
			super().__init__(**_SCREAMING_SNAKE_CASE					)
			__lowerCAmelCase     :		List[str]		     = crop_size if crop_size is not None else {'height': 2_56, 'width': 2_56}
			__lowerCAmelCase     :		int		     = get_size_dict(_SCREAMING_SNAKE_CASE			,						param_name='crop_size'					)
			__lowerCAmelCase     :		List[str]		     = size if size is not None else {'height': 2_24, 'width': 2_24}
			__lowerCAmelCase     :		Optional[int]		     = get_size_dict(_SCREAMING_SNAKE_CASE					)

			__lowerCAmelCase     :		str		     = do_center_crop
			__lowerCAmelCase     :		Optional[int]		     = crop_size
			__lowerCAmelCase     :		Optional[Any]		     = do_resize
			__lowerCAmelCase     :		Optional[int]		     = size
			__lowerCAmelCase     :		List[Any]		     = resample
			__lowerCAmelCase     :		str		     = do_rescale
			__lowerCAmelCase     :		str		     = rescale_factor
			__lowerCAmelCase     :		Union[str, Any]		     = do_normalize
			__lowerCAmelCase     :		str		     = image_mean if image_mean is not None else IMAGENET_DEFAULT_MEAN
			__lowerCAmelCase     :		List[Any]		     = image_std if image_std is not None else IMAGENET_DEFAULT_STD

		def 				__lowerCamelCase				( self			,						_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE = None			,						_SCREAMING_SNAKE_CASE = None			,						**_SCREAMING_SNAKE_CASE			,						):
			__lowerCAmelCase     :		List[str]		     = self.size if size is None else size
			__lowerCAmelCase     :		List[str]		     = get_size_dict(_SCREAMING_SNAKE_CASE					)
			__lowerCAmelCase     :		Optional[Any]		     = get_size_dict(_SCREAMING_SNAKE_CASE			,						param_name='crop_size'					)

			__lowerCAmelCase     ,  __lowerCAmelCase     :		Optional[int]		     = get_image_size(_SCREAMING_SNAKE_CASE					)
			__lowerCAmelCase     :		Tuple		     = min(_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE					)
			__lowerCAmelCase     :		Optional[Any]		     = (size['height'] / crop_size['height']) * min_dim
			__lowerCAmelCase     :		Tuple		     = (size['width'] / crop_size['width']) * min_dim
			return center_crop(_SCREAMING_SNAKE_CASE			,						size=(cropped_height, cropped_width)			,						data_format=_SCREAMING_SNAKE_CASE			,						**_SCREAMING_SNAKE_CASE					)

		def 				__lowerCamelCase				( self			,						_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE = PIL.Image.BICUBIC			,						_SCREAMING_SNAKE_CASE = None			,						**_SCREAMING_SNAKE_CASE			,						):
			__lowerCAmelCase     :		Dict		     = get_size_dict(_SCREAMING_SNAKE_CASE					)
			if "height" not in size or "width" not in size:
				raise ValueError(f"The size dictionary must contain the keys 'height' and 'width'. Got {size.keys()}"					)
			return resize(
			    _SCREAMING_SNAKE_CASE			,						size=(size['height'], size['width'])			,						resample=_SCREAMING_SNAKE_CASE			,						data_format=_SCREAMING_SNAKE_CASE			,						**_SCREAMING_SNAKE_CASE					)

		def 				__lowerCamelCase				( self			,						_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE = None			,						**_SCREAMING_SNAKE_CASE			,						):
			return rescale(_SCREAMING_SNAKE_CASE			,						scale=_SCREAMING_SNAKE_CASE			,						data_format=_SCREAMING_SNAKE_CASE			,						**_SCREAMING_SNAKE_CASE					)

		def 				__lowerCamelCase				( self			,						_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE = None			,						**_SCREAMING_SNAKE_CASE			,						):
			return normalize(_SCREAMING_SNAKE_CASE			,						mean=_SCREAMING_SNAKE_CASE			,						std=_SCREAMING_SNAKE_CASE			,						data_format=_SCREAMING_SNAKE_CASE			,						**_SCREAMING_SNAKE_CASE					)







		def 				__lowerCamelCase				( self			,						_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE = None			,						_SCREAMING_SNAKE_CASE = None			,						_SCREAMING_SNAKE_CASE = None			,						_SCREAMING_SNAKE_CASE = None			,						_SCREAMING_SNAKE_CASE = None			,						_SCREAMING_SNAKE_CASE = None			,						_SCREAMING_SNAKE_CASE = None			,						_SCREAMING_SNAKE_CASE = None			,						_SCREAMING_SNAKE_CASE = None			,						_SCREAMING_SNAKE_CASE = None			,						_SCREAMING_SNAKE_CASE = None			,						_SCREAMING_SNAKE_CASE = ChannelDimension.FIRST			,						**_SCREAMING_SNAKE_CASE			,						):
			__lowerCAmelCase     :		Tuple		     = do_center_crop if do_center_crop is not None else self.do_center_crop
			__lowerCAmelCase     :		Optional[int]		     = crop_size if crop_size is not None else self.crop_size
			__lowerCAmelCase     :		int		     = get_size_dict(_SCREAMING_SNAKE_CASE			,						param_name='crop_size'					)
			__lowerCAmelCase     :		List[str]		     = do_resize if do_resize is not None else self.do_resize
			__lowerCAmelCase     :		Any		     = size if size is not None else self.size
			__lowerCAmelCase     :		Any		     = get_size_dict(_SCREAMING_SNAKE_CASE					)
			__lowerCAmelCase     :		Any		     = resample if resample is not None else self.resample
			__lowerCAmelCase     :		Union[str, Any]		     = do_rescale if do_rescale is not None else self.do_rescale
			__lowerCAmelCase     :		int		     = rescale_factor if rescale_factor is not None else self.rescale_factor
			__lowerCAmelCase     :		List[Any]		     = do_normalize if do_normalize is not None else self.do_normalize
			__lowerCAmelCase     :		Tuple		     = image_mean if image_mean is not None else self.image_mean
			__lowerCAmelCase     :		Union[str, Any]		     = image_std if image_std is not None else self.image_std

			__lowerCAmelCase     :		Tuple		     = make_list_of_images(_SCREAMING_SNAKE_CASE					)

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

			if do_center_crop and crop_size is None:
				raise ValueError('If `do_center_crop` is set to `True`, `crop_size` must be provided.'					)

			if do_resize and size is None:
				raise ValueError('Size must be specified if do_resize 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 image standard deviation must be specified if do_normalize is True.'					)

			# All transformations expect numpy arrays.
			__lowerCAmelCase     :		int		     = [to_numpy_array(_SCREAMING_SNAKE_CASE					) for image in images]

			if do_center_crop:
				__lowerCAmelCase     :		int		     = [self.center_crop(_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE			,						size=_SCREAMING_SNAKE_CASE					) for image in images]

			if do_resize:
				__lowerCAmelCase     :		Optional[Any]		     = [self.resize(image=_SCREAMING_SNAKE_CASE			,						size=_SCREAMING_SNAKE_CASE			,						resample=_SCREAMING_SNAKE_CASE					) for image in images]

			if do_rescale:
				__lowerCAmelCase     :		str		     = [self.rescale(image=_SCREAMING_SNAKE_CASE			,						scale=_SCREAMING_SNAKE_CASE					) for image in images]

			if do_normalize:
				__lowerCAmelCase     :		Optional[int]		     = [self.normalize(image=_SCREAMING_SNAKE_CASE			,						mean=_SCREAMING_SNAKE_CASE			,						std=_SCREAMING_SNAKE_CASE					) for image in images]

			__lowerCAmelCase     :		Tuple		     = [to_channel_dimension_format(_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE					) for image in images]

			__lowerCAmelCase     :		str		     = {'pixel_values': images}
			return BatchFeature(data=_SCREAMING_SNAKE_CASE			,						tensor_type=_SCREAMING_SNAKE_CASE					)