






'''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_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


if is_vision_available():
     import PIL


lowerCamelCase_				: Optional[Any]    	=							logging.get_logger(__name__)
class    _SCREAMING_SNAKE_CASE							(		SCREAMING_SNAKE_CASE	):


   '''simple docstring'''





   __a							:							Optional[Any]					     =					["pixel_values"]






   def __init__(   self							:						List[str] ,      lowercase							:						bool = True ,      lowercase							:						Dict[str, int] = None ,      lowercase							:						PILImageResampling = PIL.Image.BICUBIC ,      lowercase							:						bool = True ,      lowercase							:						Dict[str, int] = None ,      lowercase							:						Union[int, float] = 1 / 2_5_5 ,      lowercase							:						bool = True ,      lowercase							:						bool = True ,      lowercase							:						Optional[Union[float, List[float]]] = None ,      lowercase							:						Optional[Union[float, List[float]]] = None ,      **lowercase							:						Optional[Any] ,      )							->    None:

         '''simple docstring'''







         super().__init__(**lowercase			)
         UpperCamelCase__         = size if size is not None else {"""height""": 2_5_6, """width""": 2_5_6}
         UpperCamelCase__         = get_size_dict(lowercase			)
         UpperCamelCase__         = crop_size if crop_size is not None else {"""height""": 2_2_4, """width""": 2_2_4}
         UpperCamelCase__         = get_size_dict(lowercase ,      param_name="""crop_size"""			)

         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 if image_mean is not None else IMAGENET_STANDARD_MEAN
         UpperCamelCase__         = image_std if image_std is not None else IMAGENET_STANDARD_STD






   def 				A      (   self							:						Union[str, Any] ,      lowercase							:						np.ndarray ,      lowercase							:						Dict[str, int] ,      lowercase							:						PILImageResampling = PIL.Image.BICUBIC ,      lowercase							:						Optional[Union[str, ChannelDimension]] = None ,      **lowercase							:						Dict ,      )							->    np.ndarray:

         '''simple docstring'''







         UpperCamelCase__         = get_size_dict(lowercase			)
         if "height" not in size or "width" not in size:
               raise ValueError(f"The size dictionary must have keys 'height' and 'width'. Got {size.keys()}"			)
         return resize(
             lowercase ,      size=(size["""height"""], size["""width"""]) ,      resample=lowercase ,      data_format=lowercase ,      **lowercase			)






   def 				A      (   self							:						str ,      lowercase							:						np.ndarray ,      lowercase							:						Dict[str, int] ,      lowercase							:						Optional[Union[str, ChannelDimension]] = None ,      **lowercase							:						Tuple ,      )							->    np.ndarray:

         '''simple docstring'''







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






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

         '''simple docstring'''







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






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

         '''simple docstring'''







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







   def 				A      (   self							:						Optional[Any] ,      lowercase							:						ImageInput ,      lowercase							:						bool = None ,      lowercase							:						Dict[str, int] = None ,      lowercase							:						Optional[Any]=None ,      lowercase							:						bool = None ,      lowercase							:						Dict[str, int] = None ,      lowercase							:						bool = None ,      lowercase							:						float = None ,      lowercase							:						bool = None ,      lowercase							:						Optional[Union[float, List[float]]] = None ,      lowercase							:						Optional[Union[float, List[float]]] = None ,      lowercase							:						Optional[Union[str, TensorType]] = None ,      lowercase							:						ChannelDimension = ChannelDimension.FIRST ,      **lowercase							:						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(lowercase			)
         UpperCamelCase__         = crop_size if crop_size is not None else self.crop_size
         UpperCamelCase__         = get_size_dict(lowercase ,      param_name="""crop_size"""			)

         UpperCamelCase__         = make_list_of_images(lowercase			)

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

         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(lowercase			) for image in images]

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

         if do_center_crop:
               UpperCamelCase__         = [self.center_crop(image=lowercase ,      size=lowercase			) for image in images]

         if do_rescale:
               UpperCamelCase__         = [self.rescale(image=lowercase ,      scale=lowercase			) for image in images]

         if do_normalize:
               UpperCamelCase__         = [self.normalize(image=lowercase ,      mean=lowercase ,      std=lowercase			) for image in images]

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

         UpperCamelCase__         = {"""pixel_values""": images}
         return BatchFeature(data=lowercase ,      tensor_type=lowercase			)








'''simple docstring'''


import enum
import os
from hashlib import shaaaa
from typing import Optional

from .. import config
from .logging import get_logger


lowerCamelCase_				: Any    	=							get_logger(__name__)
class    _SCREAMING_SNAKE_CASE							(		enum.Enum	):


			'''simple docstring'''





			__a							:							Tuple					     =					"all_checks"
			__a							:							List[Any]					     =					"basic_checks"
			__a							:							Dict					     =					"no_checks"
class    _SCREAMING_SNAKE_CASE							(		SCREAMING_SNAKE_CASE	):


			'''simple docstring'''





class    _SCREAMING_SNAKE_CASE							(		SCREAMING_SNAKE_CASE	):


			'''simple docstring'''





class    _SCREAMING_SNAKE_CASE							(		SCREAMING_SNAKE_CASE	):


			'''simple docstring'''





class    _SCREAMING_SNAKE_CASE							(		SCREAMING_SNAKE_CASE	):


			'''simple docstring'''












def 	__magic_name__( _A						,      _A						,      _A=None					):
						'''simple docstring'''





						if expected_checksums is None:
												logger.info("""Unable to verify checksums."""					)
												return
						if len(set(_A					) - set(_A					)					) > 0:
												raise ExpectedMoreDownloadedFiles(str(set(_A					) - set(_A					)					)					)
						if len(set(_A					) - set(_A					)					) > 0:
												raise UnexpectedDownloadedFile(str(set(_A					) - set(_A					)					)					)
						UpperCamelCase__         = [url for url in expected_checksums if expected_checksums[url] != recorded_checksums[url]]
						UpperCamelCase__         = """ for """ + verification_name if verification_name is not None else """"""
						if len(_A					) > 0:
												raise NonMatchingChecksumError(
												    f"Checksums didn't match{for_verification_name}:\n"
												    f"{bad_urls}\n"
												    """Set `verification_mode='no_checks'` to skip checksums verification and ignore this error"""					)
						logger.info("""All the checksums matched successfully""" + for_verification_name					)
class    _SCREAMING_SNAKE_CASE							(		SCREAMING_SNAKE_CASE	):


			'''simple docstring'''





class    _SCREAMING_SNAKE_CASE							(		SCREAMING_SNAKE_CASE	):


			'''simple docstring'''





class    _SCREAMING_SNAKE_CASE							(		SCREAMING_SNAKE_CASE	):


			'''simple docstring'''





class    _SCREAMING_SNAKE_CASE							(		SCREAMING_SNAKE_CASE	):


			'''simple docstring'''












def 	__magic_name__( _A						,      _A					):
						'''simple docstring'''





						if expected_splits is None:
												logger.info("""Unable to verify splits sizes."""					)
												return
						if len(set(_A					) - set(_A					)					) > 0:
												raise ExpectedMoreSplits(str(set(_A					) - set(_A					)					)					)
						if len(set(_A					) - set(_A					)					) > 0:
												raise UnexpectedSplits(str(set(_A					) - set(_A					)					)					)
						UpperCamelCase__         = [
						    {"""expected""": expected_splits[name], """recorded""": recorded_splits[name]}
						    for name in expected_splits
						    if expected_splits[name].num_examples != recorded_splits[name].num_examples
						]
						if len(_A					) > 0:
												raise NonMatchingSplitsSizesError(str(_A					)					)
						logger.info("""All the splits matched successfully."""					)







def 	__magic_name__( _A						,      _A = True					):
						'''simple docstring'''





						if record_checksum:
												UpperCamelCase__         = shaaaa()
												with open(_A						,      """rb"""					) as f:
																		for chunk in iter(lambda: f.read(1 << 20					)						,      B""""""					):
																								m.update(_A					)
																		UpperCamelCase__         = m.hexdigest()
						else:
												UpperCamelCase__         = None
						return {"num_bytes": os.path.getsize(_A					), "checksum": checksum}







def 	__magic_name__( _A					):
						'''simple docstring'''





						if dataset_size and config.IN_MEMORY_MAX_SIZE:
												return dataset_size < config.IN_MEMORY_MAX_SIZE
						else:
												return False
