




'''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_DEFAULT_MEAN,
    IMAGENET_DEFAULT_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    is_batched,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, logging


UpperCAmelCase_							:	Optional[Any]	     =		logging.get_logger(__name__)





class      lowerCAmelCase (			__lowerCAmelCase):
       __lowercase	:   Union[str, Any]										=      ['''pixel_values''']


       def __init__( self     ,	__SCREAMING_SNAKE_CASE = True     ,	__SCREAMING_SNAKE_CASE = None     ,	__SCREAMING_SNAKE_CASE = PILImageResampling.BICUBIC     ,	__SCREAMING_SNAKE_CASE = True     ,	__SCREAMING_SNAKE_CASE = True     ,	__SCREAMING_SNAKE_CASE = 1 / 255     ,	__SCREAMING_SNAKE_CASE = None     ,	__SCREAMING_SNAKE_CASE = True     ,	__SCREAMING_SNAKE_CASE = None     ,	__SCREAMING_SNAKE_CASE = None     ,	**__SCREAMING_SNAKE_CASE     ,	)   ->	None:



            '''simple docstring'''




            super().__init__(**__SCREAMING_SNAKE_CASE	)
            __snake_case            =	size if size is not None else {'''height''': 224, '''width''': 224}
            __snake_case            =	get_size_dict(__SCREAMING_SNAKE_CASE	)
            __snake_case            =	crop_size if crop_size is not None else {'''height''': 224, '''width''': 224}
            __snake_case            =	get_size_dict(__SCREAMING_SNAKE_CASE     ,	default_to_square=__SCREAMING_SNAKE_CASE     ,	param_name='''crop_size'''	)

            __snake_case            =	do_resize
            __snake_case            =	do_rescale
            __snake_case            =	do_normalize
            __snake_case            =	do_center_crop
            __snake_case            =	crop_size
            __snake_case            =	size
            __snake_case            =	resample
            __snake_case            =	rescale_factor
            __snake_case            =	image_mean if image_mean is not None else IMAGENET_DEFAULT_MEAN
            __snake_case            =	image_std if image_std is not None else IMAGENET_DEFAULT_STD


       def    lowerCAmelCase   ( self     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE = PILImageResampling.BILINEAR     ,	__SCREAMING_SNAKE_CASE = None     ,	**__SCREAMING_SNAKE_CASE     ,	)   ->	np.ndarray:



            '''simple docstring'''




            __snake_case            =	get_size_dict(__SCREAMING_SNAKE_CASE	)

            if "shortest_edge" in size:
                 __snake_case            =	get_resize_output_image_size(__SCREAMING_SNAKE_CASE     ,	size=size['''shortest_edge''']     ,	default_to_square=__SCREAMING_SNAKE_CASE	)
                 # size = get_resize_output_image_size(image, size["shortest_edge"], size["longest_edge"])
            elif "height" in size and "width" in size:
                 __snake_case            =	(size['''height'''], size['''width'''])
            else:
                 raise ValueError(F'''Size must contain \'height\' and \'width\' keys or \'shortest_edge\' key. Got {size.keys()}'''	)
            return resize(__SCREAMING_SNAKE_CASE     ,	size=__SCREAMING_SNAKE_CASE     ,	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     ,	)   ->	np.ndarray:



            '''simple docstring'''




            __snake_case            =	get_size_dict(__SCREAMING_SNAKE_CASE	)
            if "height" not in size or "width" not in size:
                 raise ValueError(F'''The `size` parameter must contain the keys (height, width). Got {size.keys()}'''	)
            return center_crop(__SCREAMING_SNAKE_CASE     ,	size=(size['''height'''], size['''width'''])     ,	data_format=__SCREAMING_SNAKE_CASE     ,	**__SCREAMING_SNAKE_CASE	)


       def    lowerCAmelCase   ( self     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE = None     ,	**__SCREAMING_SNAKE_CASE	)   ->	np.ndarray:



            '''simple docstring'''




            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     ,	)   ->	np.ndarray:



            '''simple docstring'''




            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     ,	)   ->	BatchFeature:



            '''simple docstring'''




            __snake_case            =	do_resize if do_resize is not None else self.do_resize
            __snake_case            =	do_rescale if do_rescale is not None else self.do_rescale
            __snake_case            =	do_normalize if do_normalize is not None else self.do_normalize
            __snake_case            =	do_center_crop if do_center_crop is not None else self.do_center_crop
            __snake_case            =	crop_size if crop_size is not None else self.crop_size
            __snake_case            =	get_size_dict(__SCREAMING_SNAKE_CASE     ,	param_name='''crop_size'''     ,	default_to_square=__SCREAMING_SNAKE_CASE	)
            __snake_case            =	resample if resample is not None else self.resample
            __snake_case            =	rescale_factor if rescale_factor is not None else self.rescale_factor
            __snake_case            =	image_mean if image_mean is not None else self.image_mean
            __snake_case            =	image_std if image_std is not None else self.image_std

            __snake_case            =	size if size is not None else self.size
            __snake_case            =	get_size_dict(__SCREAMING_SNAKE_CASE	)

            if not is_batched(__SCREAMING_SNAKE_CASE	):
                 __snake_case            =	[images]

            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_resize and size is None:
                 raise ValueError('''Size 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.'''	)

            # All transformations expect numpy arrays.
            __snake_case            =	[to_numpy_array(__SCREAMING_SNAKE_CASE	) for image in images]

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

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

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

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

            __snake_case            =	[to_channel_dimension_format(__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE	) for image in images]

            __snake_case            =	{'''pixel_values''': images}
            return BatchFeature(data=__SCREAMING_SNAKE_CASE     ,	tensor_type=__SCREAMING_SNAKE_CASE	)












'''simple docstring'''



def       _UpperCamelCase			(_lowerCamelCase				:  int						)-> int:




     '''simple docstring'''





     __snake_case            =	abs(_lowerCamelCase						)
     __snake_case            =	0
     while n > 0:
          res += n % 10
          n //= 10
     return res







def       _UpperCamelCase			(_lowerCamelCase				:  int						)-> int:




     '''simple docstring'''





     __snake_case            =	abs(_lowerCamelCase						)
     return n if n < 10 else n % 10 + sum_of_digits(n // 10						)







def       _UpperCamelCase			(_lowerCamelCase				:  int						)-> int:




     '''simple docstring'''





     return sum(int(_lowerCamelCase						) for c in str(abs(_lowerCamelCase						)						)						)







def       _UpperCamelCase			()-> None:




     '''simple docstring'''





     from collections.abc import Callable
     from timeit import timeit

     def benchmark_a_function(_lowerCamelCase				:  Callable ,						_lowerCamelCase				:  int						) -> None:
          __snake_case            =	f'''{func.__name__}({value})'''
          __snake_case            =	timeit(f'''__main__.{call}''' ,						setup='''import __main__'''						)
          print(f'''{call:56} = {func(_lowerCamelCase						)} -- {timing:.4f} seconds'''						)

     for value in (26_21_44, 11_25_89_99_06_84_26_24, 1_26_76_50_60_02_28_22_94_01_49_67_03_20_53_76):
          for func in (sum_of_digits, sum_of_digits_recursion, sum_of_digits_compact):
               benchmark_a_function(_lowerCamelCase ,						_lowerCamelCase						)
          print()


if __name__ == "__main__":
     import doctest

     doctest.testmod()
     benchmark()






