



'''simple docstring'''
import unittest

import torch
from torch import nn

from diffusers.models.activations import get_activation






class 							lowercase__	(							unittest.TestCase   ):





	def 	UpperCamelCase_  ( self					:				Dict ):







							'''simple docstring'''
							_UpperCamelCase					:		Union[str, Any] 				=   get_activation('swish' )

							self.assertIsInstance(lowerCamelCase__ ,nn.SiLU )

							self.assertEqual(act(torch.tensor(-100 ,dtype=torch.floataa ) ).item() ,0 )
							self.assertNotEqual(act(torch.tensor(-1 ,dtype=torch.floataa ) ).item() ,0 )
							self.assertEqual(act(torch.tensor(0 ,dtype=torch.floataa ) ).item() ,0 )
							self.assertEqual(act(torch.tensor(20 ,dtype=torch.floataa ) ).item() ,20 )





	def 	UpperCamelCase_  ( self					:				Optional[int] ):







							'''simple docstring'''
							_UpperCamelCase					:		List[str] 				=   get_activation('silu' )

							self.assertIsInstance(lowerCamelCase__ ,nn.SiLU )

							self.assertEqual(act(torch.tensor(-100 ,dtype=torch.floataa ) ).item() ,0 )
							self.assertNotEqual(act(torch.tensor(-1 ,dtype=torch.floataa ) ).item() ,0 )
							self.assertEqual(act(torch.tensor(0 ,dtype=torch.floataa ) ).item() ,0 )
							self.assertEqual(act(torch.tensor(20 ,dtype=torch.floataa ) ).item() ,20 )





	def 	UpperCamelCase_  ( self					:				Optional[Any] ):







							'''simple docstring'''
							_UpperCamelCase					:		Dict 				=   get_activation('mish' )

							self.assertIsInstance(lowerCamelCase__ ,nn.Mish )

							self.assertEqual(act(torch.tensor(-200 ,dtype=torch.floataa ) ).item() ,0 )
							self.assertNotEqual(act(torch.tensor(-1 ,dtype=torch.floataa ) ).item() ,0 )
							self.assertEqual(act(torch.tensor(0 ,dtype=torch.floataa ) ).item() ,0 )
							self.assertEqual(act(torch.tensor(20 ,dtype=torch.floataa ) ).item() ,20 )





	def 	UpperCamelCase_  ( self					:				int ):







							'''simple docstring'''
							_UpperCamelCase					:		Dict 				=   get_activation('gelu' )

							self.assertIsInstance(lowerCamelCase__ ,nn.GELU )

							self.assertEqual(act(torch.tensor(-100 ,dtype=torch.floataa ) ).item() ,0 )
							self.assertNotEqual(act(torch.tensor(-1 ,dtype=torch.floataa ) ).item() ,0 )
							self.assertEqual(act(torch.tensor(0 ,dtype=torch.floataa ) ).item() ,0 )
							self.assertEqual(act(torch.tensor(20 ,dtype=torch.floataa ) ).item() ,20 )










"""simple docstring"""






from typing import Dict, List, Optional, Union

import numpy as np

from transformers.utils import is_vision_available
from transformers.utils.generic import TensorType

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


if is_vision_available():
  import PIL

UpperCAmelCase_   : int   			= logging.get_logger(__name__)



def 					_A			(__a							) ->       List[List[ImageInput]]:
    """simple docstring"""






    if isinstance(__a    ,				(list, tuple)							) and isinstance(videos[0]    ,				(list, tuple)							) and is_valid_image(videos[0][0]							):
        return videos

    elif isinstance(__a    ,				(list, tuple)							) and is_valid_image(videos[0]							):
        return [videos]

    elif is_valid_image(__a							):
        return [[videos]]

    raise ValueError(f'Could not make batched video from {videos}'							)





class 							lowerCAmelCase__				(			UpperCAmelCase__ ):






      '''simple docstring'''

      __UpperCamelCase	 =  ["pixel_values"]
      def __init__(						self     :  Dict						,	lowercase_     :  bool = True						,	lowercase_     :  Dict[str, int] = None						,	lowercase_     :  PILImageResampling = PILImageResampling.BILINEAR						,	lowercase_     :  bool = True						,	lowercase_     :  Dict[str, int] = None						,	lowercase_     :  bool = True						,	lowercase_     :  Union[int, float] = 1 / 255						,	lowercase_     :  bool = True						,	lowercase_     :  bool = True						,	lowercase_     :  Optional[Union[float, List[float]]] = None						,	lowercase_     :  Optional[Union[float, List[float]]] = None						,	**lowercase_     :  Dict						,	):




          '''simple docstring'''


          super().__init__(**lowercase_)
          SCREAMING_SNAKE_CASE_      :  str    						=		size if size is not None else {'''shortest_edge''': 256}
          SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		get_size_dict(lowercase_						,	default_to_square=lowercase_)
          SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		crop_size if crop_size is not None else {'''height''': 224, '''width''': 224}
          SCREAMING_SNAKE_CASE_      :  Dict    						=		get_size_dict(lowercase_						,	param_name='''crop_size''')

          SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		do_resize
          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		size
          SCREAMING_SNAKE_CASE_      :  Tuple    						=		do_center_crop
          SCREAMING_SNAKE_CASE_      :  Dict    						=		crop_size
          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		resample
          SCREAMING_SNAKE_CASE_      :  List[str]    						=		do_rescale
          SCREAMING_SNAKE_CASE_      :  List[str]    						=		rescale_factor
          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		offset
          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		do_normalize
          SCREAMING_SNAKE_CASE_      :  Tuple    						=		image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
          SCREAMING_SNAKE_CASE_      :  Optional[int]    						=		image_std if image_std is not None else IMAGENET_STANDARD_STD
      def _SCREAMING_SNAKE_CASE (						self     :  List[Any]						,	lowercase_     :  np.ndarray						,	lowercase_     :  Dict[str, int]						,	lowercase_     :  PILImageResampling = PILImageResampling.BILINEAR						,	lowercase_     :  Optional[Union[str, ChannelDimension]] = None						,	**lowercase_     :  Any						,	):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  Tuple    						=		get_size_dict(lowercase_						,	default_to_square=lowercase_)
          if "shortest_edge" in size:
              SCREAMING_SNAKE_CASE_      :  List[Any]    						=		get_resize_output_image_size(lowercase_						,	size['''shortest_edge''']						,	default_to_square=lowercase_)
          elif "height" in size and "width" in size:
              SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		(size['''height'''], size['''width'''])
          else:
              raise ValueError(F'Size must have \'height\' and \'width\' or \'shortest_edge\' as keys. Got {size.keys()}')
          return resize(lowercase_						,	size=lowercase_						,	resample=lowercase_						,	data_format=lowercase_						,	**lowercase_)
      def _SCREAMING_SNAKE_CASE (						self     :  Any						,	lowercase_     :  np.ndarray						,	lowercase_     :  Dict[str, int]						,	lowercase_     :  Optional[Union[str, ChannelDimension]] = None						,	**lowercase_     :  List[Any]						,	):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  List[str]    						=		get_size_dict(lowercase_)
          if "height" not in size or "width" not in size:
              raise ValueError(F'Size must have \'height\' and \'width\' as keys. Got {size.keys()}')
          return center_crop(lowercase_						,	size=(size['''height'''], size['''width'''])						,	data_format=lowercase_						,	**lowercase_)
      def _SCREAMING_SNAKE_CASE (						self     :  List[Any]						,	lowercase_     :  np.ndarray						,	lowercase_     :  Union[int, float]						,	lowercase_     :  bool = True						,	lowercase_     :  Optional[Union[str, ChannelDimension]] = None						,	**lowercase_     :  Optional[int]						,	):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		image.astype(np.floataa)
          if offset:
              SCREAMING_SNAKE_CASE_      :  Tuple    						=		image - (scale / 2)
          return rescale(lowercase_						,	scale=lowercase_						,	data_format=lowercase_						,	**lowercase_)
      def _SCREAMING_SNAKE_CASE (						self     :  List[str]						,	lowercase_     :  np.ndarray						,	lowercase_     :  Union[float, List[float]]						,	lowercase_     :  Union[float, List[float]]						,	lowercase_     :  Optional[Union[str, ChannelDimension]] = None						,	**lowercase_     :  List[str]						,	):




          '''simple docstring'''


          return normalize(lowercase_						,	mean=lowercase_						,	std=lowercase_						,	data_format=lowercase_						,	**lowercase_)
      def _SCREAMING_SNAKE_CASE (						self     :  List[str]						,	lowercase_     :  ImageInput						,	lowercase_     :  bool = None						,	lowercase_     :  Dict[str, int] = None						,	lowercase_     :  PILImageResampling = None						,	lowercase_     :  bool = None						,	lowercase_     :  Dict[str, int] = None						,	lowercase_     :  bool = None						,	lowercase_     :  float = None						,	lowercase_     :  bool = None						,	lowercase_     :  bool = None						,	lowercase_     :  Optional[Union[float, List[float]]] = None						,	lowercase_     :  Optional[Union[float, List[float]]] = None						,	lowercase_     :  Optional[ChannelDimension] = ChannelDimension.FIRST						,	):




          '''simple docstring'''


          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.''')

          if offset and not do_rescale:
              raise ValueError('''For offset, do_rescale must also be set to True.''')

          # All transformations expect numpy arrays.
          SCREAMING_SNAKE_CASE_      :  List[str]    						=		to_numpy_array(lowercase_)

          if do_resize:
              SCREAMING_SNAKE_CASE_      :  List[Any]    						=		self.resize(image=lowercase_						,	size=lowercase_						,	resample=lowercase_)

          if do_center_crop:
              SCREAMING_SNAKE_CASE_      :  Dict    						=		self.center_crop(lowercase_						,	size=lowercase_)

          if do_rescale:
              SCREAMING_SNAKE_CASE_      :  int    						=		self.rescale(image=lowercase_						,	scale=lowercase_						,	offset=lowercase_)

          if do_normalize:
              SCREAMING_SNAKE_CASE_      :  Dict    						=		self.normalize(image=lowercase_						,	mean=lowercase_						,	std=lowercase_)

          SCREAMING_SNAKE_CASE_      :  List[Any]    						=		to_channel_dimension_format(lowercase_						,	lowercase_)
          return image



      def _SCREAMING_SNAKE_CASE (						self     :  Dict						,	lowercase_     :  ImageInput						,	lowercase_     :  bool = None						,	lowercase_     :  Dict[str, int] = None						,	lowercase_     :  PILImageResampling = None						,	lowercase_     :  bool = None						,	lowercase_     :  Dict[str, int] = None						,	lowercase_     :  bool = None						,	lowercase_     :  float = None						,	lowercase_     :  bool = 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]						,	):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		do_resize if do_resize is not None else self.do_resize
          SCREAMING_SNAKE_CASE_      :  int    						=		resample if resample is not None else self.resample
          SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		do_center_crop if do_center_crop is not None else self.do_center_crop
          SCREAMING_SNAKE_CASE_      :  Dict    						=		do_rescale if do_rescale is not None else self.do_rescale
          SCREAMING_SNAKE_CASE_      :  Dict    						=		rescale_factor if rescale_factor is not None else self.rescale_factor
          SCREAMING_SNAKE_CASE_      :  Dict    						=		offset if offset is not None else self.offset
          SCREAMING_SNAKE_CASE_      :  str    						=		do_normalize if do_normalize is not None else self.do_normalize
          SCREAMING_SNAKE_CASE_      :  Dict    						=		image_mean if image_mean is not None else self.image_mean
          SCREAMING_SNAKE_CASE_      :  List[str]    						=		image_std if image_std is not None else self.image_std

          SCREAMING_SNAKE_CASE_      :  Union[str, Any]    						=		size if size is not None else self.size
          SCREAMING_SNAKE_CASE_      :  Tuple    						=		get_size_dict(lowercase_						,	default_to_square=lowercase_)
          SCREAMING_SNAKE_CASE_      :  Any    						=		crop_size if crop_size is not None else self.crop_size
          SCREAMING_SNAKE_CASE_      :  Dict    						=		get_size_dict(lowercase_						,	param_name='''crop_size''')

          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.''')

          SCREAMING_SNAKE_CASE_      :  Tuple    						=		make_batched(lowercase_)

          SCREAMING_SNAKE_CASE_      :  Optional[Any]    						=		[
              [
                  self._preprocess_image(
                      image=lowercase_						,	do_resize=lowercase_						,	size=lowercase_						,	resample=lowercase_						,	do_center_crop=lowercase_						,	crop_size=lowercase_						,	do_rescale=lowercase_						,	rescale_factor=lowercase_						,	offset=lowercase_						,	do_normalize=lowercase_						,	image_mean=lowercase_						,	image_std=lowercase_						,	data_format=lowercase_						,	)
                  for img in video
              ]
              for video in videos
          ]

          SCREAMING_SNAKE_CASE_      :  int    						=		{'''pixel_values''': videos}
          return BatchFeature(data=lowercase_						,	tensor_type=lowercase_)


