




'''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,
    convert_to_rgb,
    get_resize_output_image_size,
    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


a_ :						Union[str, Any]				 =			logging.get_logger(__name__)


if is_vision_available():
     import PIL


class     __UpperCamelCase			(					_UpperCamelCase							):
       lowercase      :       int 		=["pixel_values"]






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



              """simple docstring"""







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

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






       def 	lowercase__	(				self,						lowerCAmelCase,						lowerCAmelCase,						lowerCAmelCase = PILImageResampling.BICUBIC,						lowerCAmelCase = None,						**lowerCAmelCase,						):



              """simple docstring"""







              lowerCamelCase_				=get_size_dict(a_,						default_to_square=a_    )
              if "shortest_edge" not in size:
                     raise ValueError(f'''The `size` parameter must contain the key `shortest_edge`. Got {size.keys()}'''    )
              lowerCamelCase_				=get_resize_output_image_size(a_,						size=size['''shortest_edge'''],						default_to_square=a_    )
              return resize(a_,						size=a_,						resample=a_,						data_format=a_,						**a_    )






       def 	lowercase__	(				self,						lowerCAmelCase,						lowerCAmelCase,						lowerCAmelCase = None,						**lowerCAmelCase,						):



              """simple docstring"""







              lowerCamelCase_				=get_size_dict(a_    )
              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(a_,						size=(size['''height'''], size['''width''']),						data_format=a_,						**a_    )






       def 	lowercase__	(				self,						lowerCAmelCase,						lowerCAmelCase,						lowerCAmelCase = None,						**lowerCAmelCase,						):



              """simple docstring"""







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






       def 	lowercase__	(				self,						lowerCAmelCase,						lowerCAmelCase,						lowerCAmelCase,						lowerCAmelCase = None,						**lowerCAmelCase,						):



              """simple docstring"""







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






       def 	lowercase__	(				self,						lowerCAmelCase,						lowerCAmelCase = None,						lowerCAmelCase = None,						lowerCAmelCase = None,						lowerCAmelCase = None,						lowerCAmelCase = None,						lowerCAmelCase = None,						lowerCAmelCase = None,						lowerCAmelCase = None,						lowerCAmelCase = None,						lowerCAmelCase = None,						lowerCAmelCase = None,						lowerCAmelCase = None,						lowerCAmelCase = ChannelDimension.FIRST,						**lowerCAmelCase,						):



              """simple docstring"""







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

              lowerCamelCase_				=make_list_of_images(a_    )

              if not valid_images(a_    ):
                     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.'''    )

              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:
                     lowerCamelCase_				=[convert_to_rgb(a_    ) for image in images]

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

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

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

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

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

              lowerCamelCase_				=[to_channel_dimension_format(a_,						a_    ) for image in images]

              lowerCamelCase_				={"pixel_values": images}
              return BatchFeature(data=a_,						tensor_type=a_    )











"""simple docstring"""






from typing import TYPE_CHECKING

# rely on isort to merge the imports
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


__UpperCAmelCase						=			{
    '''configuration_informer''': [
        '''INFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''InformerConfig''',
    ],
}

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		__UpperCAmelCase						=			[
		    '''INFORMER_PRETRAINED_MODEL_ARCHIVE_LIST''',
		    '''InformerForPrediction''',
		    '''InformerModel''',
		    '''InformerPreTrainedModel''',
		]


if TYPE_CHECKING:
		from .configuration_informer import INFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, InformerConfig

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_informer import (
				    INFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
				    InformerForPrediction,
				    InformerModel,
				    InformerPreTrainedModel,
				)

else:
		import sys

		__UpperCAmelCase						=			_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)