






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 convert_to_rgb, normalize, rescale, resize, to_channel_dimension_format
from ...image_utils import (
    OPENAI_CLIP_MEAN,
    OPENAI_CLIP_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


__A					=	logging.get_logger(__name__)



class 				_A			(     UpperCamelCase				):
    """simple docstring"""

    lowerCamelCase	:							Union[str, Any]				= ['pixel_values']



    def __init__(				self      :     str ,     __SCREAMING_SNAKE_CASE      :     bool = True ,     __SCREAMING_SNAKE_CASE      :     Dict[str, int] = None ,     __SCREAMING_SNAKE_CASE      :     PILImageResampling = PILImageResampling.BICUBIC ,     __SCREAMING_SNAKE_CASE      :     bool = True ,     __SCREAMING_SNAKE_CASE      :     Union[int, float] = 1 / 255 ,     __SCREAMING_SNAKE_CASE      :     bool = True ,     __SCREAMING_SNAKE_CASE      :     Optional[Union[float, List[float]]] = None ,     __SCREAMING_SNAKE_CASE      :     Optional[Union[float, List[float]]] = None ,     __SCREAMING_SNAKE_CASE      :     bool = True ,     **__SCREAMING_SNAKE_CASE      :     Tuple ,     )      ->							None:
           super().__init__(**__SCREAMING_SNAKE_CASE      )
           __UpperCAmelCase     				=size if size is not None else {"""height""": 384, """width""": 384}
           __UpperCAmelCase     				=get_size_dict(__SCREAMING_SNAKE_CASE ,     default_to_square=__SCREAMING_SNAKE_CASE      )

           __UpperCAmelCase     				=do_resize
           __UpperCAmelCase     				=size
           __UpperCAmelCase     				=resample
           __UpperCAmelCase     				=do_rescale
           __UpperCAmelCase     				=rescale_factor
           __UpperCAmelCase     				=do_normalize
           __UpperCAmelCase     				=image_mean if image_mean is not None else OPENAI_CLIP_MEAN
           __UpperCAmelCase     				=image_std if image_std is not None else OPENAI_CLIP_STD
           __UpperCAmelCase     				=do_convert_rgb



    def _a							(				self      :     List[str] ,     __SCREAMING_SNAKE_CASE      :     np.ndarray ,     __SCREAMING_SNAKE_CASE      :     Dict[str, int] ,     __SCREAMING_SNAKE_CASE      :     PILImageResampling = PILImageResampling.BICUBIC ,     __SCREAMING_SNAKE_CASE      :     Optional[Union[str, ChannelDimension]] = None ,     **__SCREAMING_SNAKE_CASE      :     Dict ,     )      ->							np.ndarray:
           __UpperCAmelCase     				=get_size_dict(__SCREAMING_SNAKE_CASE ,     default_to_square=__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()}'''      )
           __UpperCAmelCase     				=(size["""height"""], size["""width"""])
           return resize(__SCREAMING_SNAKE_CASE ,     size=__SCREAMING_SNAKE_CASE ,     resample=__SCREAMING_SNAKE_CASE ,     data_format=__SCREAMING_SNAKE_CASE ,     **__SCREAMING_SNAKE_CASE      )



    def _a							(				self      :     Any ,     __SCREAMING_SNAKE_CASE      :     np.ndarray ,     __SCREAMING_SNAKE_CASE      :     Union[int, float] ,     __SCREAMING_SNAKE_CASE      :     Optional[Union[str, ChannelDimension]] = None ,     **__SCREAMING_SNAKE_CASE      :     Any ,     )      ->							Dict:
           return rescale(__SCREAMING_SNAKE_CASE ,     scale=__SCREAMING_SNAKE_CASE ,     data_format=__SCREAMING_SNAKE_CASE ,     **__SCREAMING_SNAKE_CASE      )



    def _a							(				self      :     Any ,     __SCREAMING_SNAKE_CASE      :     np.ndarray ,     __SCREAMING_SNAKE_CASE      :     Union[float, List[float]] ,     __SCREAMING_SNAKE_CASE      :     Union[float, List[float]] ,     __SCREAMING_SNAKE_CASE      :     Optional[Union[str, ChannelDimension]] = None ,     **__SCREAMING_SNAKE_CASE      :     Any ,     )      ->							np.ndarray:
           return normalize(__SCREAMING_SNAKE_CASE ,     mean=__SCREAMING_SNAKE_CASE ,     std=__SCREAMING_SNAKE_CASE ,     data_format=__SCREAMING_SNAKE_CASE ,     **__SCREAMING_SNAKE_CASE      )



    def _a							(				self      :     int ,     __SCREAMING_SNAKE_CASE      :     ImageInput ,     __SCREAMING_SNAKE_CASE      :     Optional[bool] = None ,     __SCREAMING_SNAKE_CASE      :     Optional[Dict[str, int]] = None ,     __SCREAMING_SNAKE_CASE      :     PILImageResampling = None ,     __SCREAMING_SNAKE_CASE      :     Optional[bool] = None ,     __SCREAMING_SNAKE_CASE      :     Optional[float] = None ,     __SCREAMING_SNAKE_CASE      :     Optional[bool] = None ,     __SCREAMING_SNAKE_CASE      :     Optional[Union[float, List[float]]] = None ,     __SCREAMING_SNAKE_CASE      :     Optional[Union[float, List[float]]] = None ,     __SCREAMING_SNAKE_CASE      :     Optional[Union[str, TensorType]] = None ,     __SCREAMING_SNAKE_CASE      :     bool = None ,     __SCREAMING_SNAKE_CASE      :     ChannelDimension = ChannelDimension.FIRST ,     **__SCREAMING_SNAKE_CASE      :     List[str] ,     )      ->							PIL.Image.Image:
           __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_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     				=do_convert_rgb if do_convert_rgb is not None else self.do_convert_rgb

           __UpperCAmelCase     				=size if size is not None else self.size
           __UpperCAmelCase     				=get_size_dict(__SCREAMING_SNAKE_CASE ,     default_to_square=__SCREAMING_SNAKE_CASE      )

           __UpperCAmelCase     				=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_resize and size is None or resample is None:
                  raise ValueError("""Size and resample 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 std must be specified if do_normalize is True."""      )

           # PIL RGBA images are converted to RGB
           if do_convert_rgb:
                  __UpperCAmelCase     				=[convert_to_rgb(__SCREAMING_SNAKE_CASE      ) for image in images]

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

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

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

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

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

           __UpperCAmelCase     				=BatchFeature(data={"""pixel_values""": images} ,     tensor_type=__SCREAMING_SNAKE_CASE      )

           return encoded_outputs











'''simple docstring'''


from ...configuration_utils import PretrainedConfig
from ...utils import logging


_SCREAMING_SNAKE_CASE									=				logging.get_logger(__name__)

_SCREAMING_SNAKE_CASE									=				{
    "naver-clova-ix/donut-base": "https://huggingface.co/naver-clova-ix/donut-base/resolve/main/config.json",
    # See all Donut models at https://huggingface.co/models?filter=donut-swin
}

class  lowerCAmelCase_		(		__magic_name__		):
 __lowerCamelCase    :				Union[str, Any]								=       "donut-swin"

 __lowerCamelCase    :				int								=       {
     "num_attention_heads": "num_heads",
     "num_hidden_layers": "num_layers",
 }




 def __init__(						self      ,  _lowerCAmelCase=224      ,  _lowerCAmelCase=4      ,  _lowerCAmelCase=3      ,  _lowerCAmelCase=96      ,  _lowerCAmelCase=[2, 2, 6, 2]      ,  _lowerCAmelCase=[3, 6, 12, 24]      ,  _lowerCAmelCase=7      ,  _lowerCAmelCase=4.0      ,  _lowerCAmelCase=True      ,  _lowerCAmelCase=0.0      ,  _lowerCAmelCase=0.0      ,  _lowerCAmelCase=0.1      ,  _lowerCAmelCase="gelu"      ,  _lowerCAmelCase=False      ,  _lowerCAmelCase=0.02      ,  _lowerCAmelCase=1E-5      ,  **_lowerCAmelCase      ,  )     ->				Optional[Any]:
     super().__init__(**_lowerCAmelCase		)

     _lowerCAmelCase						      =   image_size
     _lowerCAmelCase						      =   patch_size
     _lowerCAmelCase						      =   num_channels
     _lowerCAmelCase						      =   embed_dim
     _lowerCAmelCase						      =   depths
     _lowerCAmelCase						      =   len(_lowerCAmelCase		)
     _lowerCAmelCase						      =   num_heads
     _lowerCAmelCase						      =   window_size
     _lowerCAmelCase						      =   mlp_ratio
     _lowerCAmelCase						      =   qkv_bias
     _lowerCAmelCase						      =   hidden_dropout_prob
     _lowerCAmelCase						      =   attention_probs_dropout_prob
     _lowerCAmelCase						      =   drop_path_rate
     _lowerCAmelCase						      =   hidden_act
     _lowerCAmelCase						      =   use_absolute_embeddings
     _lowerCAmelCase						      =   layer_norm_eps
     _lowerCAmelCase						      =   initializer_range
     # we set the hidden_size attribute in order to make Swin work with VisionEncoderDecoderModel
     # this indicates the channel dimension after the last stage of the model
     _lowerCAmelCase						      =   int(embed_dim * 2 ** (len(_lowerCAmelCase		) - 1)		)


