


'''simple docstring'''







import unittest

import numpy as np

from transformers.testing_utils import require_flax, require_tf, require_torch
from transformers.utils import (
    expand_dims,
    flatten_dict,
    is_flax_available,
    is_tf_available,
    is_torch_available,
    reshape,
    squeeze,
    transpose,
)


if is_flax_available():
  import jax.numpy as jnp

if is_tf_available():
  import tensorflow as tf

if is_torch_available():
  import torch
class 					lowercase_     (    unittest.TestCase   ):


    def    __a							(     self    ):
          UpperCamelCase__										=				{
              "task_specific_params": {
                  "summarization": {"length_penalty": 1.0, "max_length": 1_28, "min_length": 12, "num_beams": 4},
                  "summarization_cnn": {"length_penalty": 2.0, "max_length": 1_42, "min_length": 56, "num_beams": 4},
                  "summarization_xsum": {"length_penalty": 1.0, "max_length": 62, "min_length": 11, "num_beams": 6},
              }
          }
          UpperCamelCase__										=				{
              "task_specific_params.summarization.length_penalty": 1.0,
              "task_specific_params.summarization.max_length": 1_28,
              "task_specific_params.summarization.min_length": 12,
              "task_specific_params.summarization.num_beams": 4,
              "task_specific_params.summarization_cnn.length_penalty": 2.0,
              "task_specific_params.summarization_cnn.max_length": 1_42,
              "task_specific_params.summarization_cnn.min_length": 56,
              "task_specific_params.summarization_cnn.num_beams": 4,
              "task_specific_params.summarization_xsum.length_penalty": 1.0,
              "task_specific_params.summarization_xsum.max_length": 62,
              "task_specific_params.summarization_xsum.min_length": 11,
              "task_specific_params.summarization_xsum.num_beams": 6,
          }

          self.assertEqual(flatten_dict(a    )  ,					a    )


    def    __a							(     self    ):
          UpperCamelCase__										=				np.random.randn(3  ,					4    )
          self.assertTrue(np.allclose(transpose(a    )  ,					x.transpose()    )    )

          UpperCamelCase__										=				np.random.randn(3  ,					4  ,					5    )
          self.assertTrue(np.allclose(transpose(a  ,					axes=(1, 2, 0)    )  ,					x.transpose((1, 2, 0)    )    )    )


    @require_torch
    def    __a							(     self    ):
          UpperCamelCase__										=				np.random.randn(3  ,					4    )
          UpperCamelCase__										=				torch.tensor(a    )
          self.assertTrue(np.allclose(transpose(a    )  ,					transpose(a    ).numpy()    )    )

          UpperCamelCase__										=				np.random.randn(3  ,					4  ,					5    )
          UpperCamelCase__										=				torch.tensor(a    )
          self.assertTrue(np.allclose(transpose(a  ,					axes=(1, 2, 0)    )  ,					transpose(a  ,					axes=(1, 2, 0)    ).numpy()    )    )


    @require_tf
    def    __a							(     self    ):
          UpperCamelCase__										=				np.random.randn(3  ,					4    )
          UpperCamelCase__										=				tf.constant(a    )
          self.assertTrue(np.allclose(transpose(a    )  ,					transpose(a    ).numpy()    )    )

          UpperCamelCase__										=				np.random.randn(3  ,					4  ,					5    )
          UpperCamelCase__										=				tf.constant(a    )
          self.assertTrue(np.allclose(transpose(a  ,					axes=(1, 2, 0)    )  ,					transpose(a  ,					axes=(1, 2, 0)    ).numpy()    )    )


    @require_flax
    def    __a							(     self    ):
          UpperCamelCase__										=				np.random.randn(3  ,					4    )
          UpperCamelCase__										=				jnp.array(a    )
          self.assertTrue(np.allclose(transpose(a    )  ,					np.asarray(transpose(a    )    )    )    )

          UpperCamelCase__										=				np.random.randn(3  ,					4  ,					5    )
          UpperCamelCase__										=				jnp.array(a    )
          self.assertTrue(np.allclose(transpose(a  ,					axes=(1, 2, 0)    )  ,					np.asarray(transpose(a  ,					axes=(1, 2, 0)    )    )    )    )


    def    __a							(     self    ):
          UpperCamelCase__										=				np.random.randn(3  ,					4    )
          self.assertTrue(np.allclose(reshape(a  ,					(4, 3)    )  ,					np.reshape(a  ,					(4, 3)    )    )    )

          UpperCamelCase__										=				np.random.randn(3  ,					4  ,					5    )
          self.assertTrue(np.allclose(reshape(a  ,					(12, 5)    )  ,					np.reshape(a  ,					(12, 5)    )    )    )


    @require_torch
    def    __a							(     self    ):
          UpperCamelCase__										=				np.random.randn(3  ,					4    )
          UpperCamelCase__										=				torch.tensor(a    )
          self.assertTrue(np.allclose(reshape(a  ,					(4, 3)    )  ,					reshape(a  ,					(4, 3)    ).numpy()    )    )

          UpperCamelCase__										=				np.random.randn(3  ,					4  ,					5    )
          UpperCamelCase__										=				torch.tensor(a    )
          self.assertTrue(np.allclose(reshape(a  ,					(12, 5)    )  ,					reshape(a  ,					(12, 5)    ).numpy()    )    )


    @require_tf
    def    __a							(     self    ):
          UpperCamelCase__										=				np.random.randn(3  ,					4    )
          UpperCamelCase__										=				tf.constant(a    )
          self.assertTrue(np.allclose(reshape(a  ,					(4, 3)    )  ,					reshape(a  ,					(4, 3)    ).numpy()    )    )

          UpperCamelCase__										=				np.random.randn(3  ,					4  ,					5    )
          UpperCamelCase__										=				tf.constant(a    )
          self.assertTrue(np.allclose(reshape(a  ,					(12, 5)    )  ,					reshape(a  ,					(12, 5)    ).numpy()    )    )


    @require_flax
    def    __a							(     self    ):
          UpperCamelCase__										=				np.random.randn(3  ,					4    )
          UpperCamelCase__										=				jnp.array(a    )
          self.assertTrue(np.allclose(reshape(a  ,					(4, 3)    )  ,					np.asarray(reshape(a  ,					(4, 3)    )    )    )    )

          UpperCamelCase__										=				np.random.randn(3  ,					4  ,					5    )
          UpperCamelCase__										=				jnp.array(a    )
          self.assertTrue(np.allclose(reshape(a  ,					(12, 5)    )  ,					np.asarray(reshape(a  ,					(12, 5)    )    )    )    )


    def    __a							(     self    ):
          UpperCamelCase__										=				np.random.randn(1  ,					3  ,					4    )
          self.assertTrue(np.allclose(squeeze(a    )  ,					np.squeeze(a    )    )    )

          UpperCamelCase__										=				np.random.randn(1  ,					4  ,					1  ,					5    )
          self.assertTrue(np.allclose(squeeze(a  ,					axis=2    )  ,					np.squeeze(a  ,					axis=2    )    )    )


    @require_torch
    def    __a							(     self    ):
          UpperCamelCase__										=				np.random.randn(1  ,					3  ,					4    )
          UpperCamelCase__										=				torch.tensor(a    )
          self.assertTrue(np.allclose(squeeze(a    )  ,					squeeze(a    ).numpy()    )    )

          UpperCamelCase__										=				np.random.randn(1  ,					4  ,					1  ,					5    )
          UpperCamelCase__										=				torch.tensor(a    )
          self.assertTrue(np.allclose(squeeze(a  ,					axis=2    )  ,					squeeze(a  ,					axis=2    ).numpy()    )    )


    @require_tf
    def    __a							(     self    ):
          UpperCamelCase__										=				np.random.randn(1  ,					3  ,					4    )
          UpperCamelCase__										=				tf.constant(a    )
          self.assertTrue(np.allclose(squeeze(a    )  ,					squeeze(a    ).numpy()    )    )

          UpperCamelCase__										=				np.random.randn(1  ,					4  ,					1  ,					5    )
          UpperCamelCase__										=				tf.constant(a    )
          self.assertTrue(np.allclose(squeeze(a  ,					axis=2    )  ,					squeeze(a  ,					axis=2    ).numpy()    )    )


    @require_flax
    def    __a							(     self    ):
          UpperCamelCase__										=				np.random.randn(1  ,					3  ,					4    )
          UpperCamelCase__										=				jnp.array(a    )
          self.assertTrue(np.allclose(squeeze(a    )  ,					np.asarray(squeeze(a    )    )    )    )

          UpperCamelCase__										=				np.random.randn(1  ,					4  ,					1  ,					5    )
          UpperCamelCase__										=				jnp.array(a    )
          self.assertTrue(np.allclose(squeeze(a  ,					axis=2    )  ,					np.asarray(squeeze(a  ,					axis=2    )    )    )    )


    def    __a							(     self    ):
          UpperCamelCase__										=				np.random.randn(3  ,					4    )
          self.assertTrue(np.allclose(expand_dims(a  ,					axis=1    )  ,					np.expand_dims(a  ,					axis=1    )    )    )


    @require_torch
    def    __a							(     self    ):
          UpperCamelCase__										=				np.random.randn(3  ,					4    )
          UpperCamelCase__										=				torch.tensor(a    )
          self.assertTrue(np.allclose(expand_dims(a  ,					axis=1    )  ,					expand_dims(a  ,					axis=1    ).numpy()    )    )


    @require_tf
    def    __a							(     self    ):
          UpperCamelCase__										=				np.random.randn(3  ,					4    )
          UpperCamelCase__										=				tf.constant(a    )
          self.assertTrue(np.allclose(expand_dims(a  ,					axis=1    )  ,					expand_dims(a  ,					axis=1    ).numpy()    )    )


    @require_flax
    def    __a							(     self    ):
          UpperCamelCase__										=				np.random.randn(3  ,					4    )
          UpperCamelCase__										=				jnp.array(a    )
          self.assertTrue(np.allclose(expand_dims(a  ,					axis=1    )  ,					np.asarray(expand_dims(a  ,					axis=1    )    )    )    )







from typing import List, Optional, Union

import numpy as np
import PIL.Image

from ...image_processing_utils import BaseImageProcessor, BatchFeature
from ...image_transforms import rescale, resize, to_channel_dimension_format
from ...image_utils import (
    ChannelDimension,
    PILImageResampling,
    get_image_size,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, logging


__snake_case								=  logging.get_logger(__name__)




class 						lowercase__  (						_UpperCAmelCase  ):
	A__    :   List[str]				       =["""pixel_values"""]
	def __init__(			self							:   Dict       ,   UpperCAmelCase_							:   bool = True       ,   UpperCAmelCase_							:   int = 32       ,   UpperCAmelCase_							:   int=PILImageResampling.BILINEAR       ,   UpperCAmelCase_							:   bool = True       ,   **UpperCAmelCase_							:   Any       ,   ):
						SCREAMING_SNAKE_CASE__													= do_resize
						SCREAMING_SNAKE_CASE__													= do_rescale
						SCREAMING_SNAKE_CASE__													= size_divisor
						SCREAMING_SNAKE_CASE__													= resample
						super().__init__(**UpperCAmelCase_							)
	def      A_				(			self							:   Optional[int]       ,   UpperCAmelCase_							:   np.ndarray       ,   UpperCAmelCase_							:   int       ,   UpperCAmelCase_							:   Dict       ,   UpperCAmelCase_							:   Optional[ChannelDimension] = None       ,   **UpperCAmelCase_							:   Dict							):
						SCREAMING_SNAKE_CASE__						, SCREAMING_SNAKE_CASE__													= get_image_size(UpperCAmelCase_							)
						# Rounds the height and width down to the closest multiple of size_divisor
						SCREAMING_SNAKE_CASE__													= height // size_divisor * size_divisor
						SCREAMING_SNAKE_CASE__													= width // size_divisor * size_divisor
						SCREAMING_SNAKE_CASE__													= resize(UpperCAmelCase_       ,   (new_h, new_w)       ,   resample=UpperCAmelCase_       ,   data_format=UpperCAmelCase_       ,   **UpperCAmelCase_							)
						return image
	def      A_				(			self							:   Any       ,   UpperCAmelCase_							:   np.ndarray       ,   UpperCAmelCase_							:   float       ,   UpperCAmelCase_							:   Optional[ChannelDimension] = None       ,   **UpperCAmelCase_							:   List[str]							):
						return rescale(image=UpperCAmelCase_       ,   scale=UpperCAmelCase_       ,   data_format=UpperCAmelCase_       ,   **UpperCAmelCase_							)





	def      A_				(			self							:   Dict       ,   UpperCAmelCase_							:   Union["PIL.Image.Image", TensorType, List["PIL.Image.Image"], List[TensorType]]       ,   UpperCAmelCase_							:   Optional[bool] = None       ,   UpperCAmelCase_							:   Optional[int] = None       ,   UpperCAmelCase_							:   List[str]=None       ,   UpperCAmelCase_							:   Optional[bool] = None       ,   UpperCAmelCase_							:   Optional[Union[TensorType, str]] = None       ,   UpperCAmelCase_							:   ChannelDimension = ChannelDimension.FIRST       ,   **UpperCAmelCase_							:   List[Any]       ,   ):
						SCREAMING_SNAKE_CASE__													= do_resize if do_resize is not None else self.do_resize
						SCREAMING_SNAKE_CASE__													= do_rescale if do_rescale is not None else self.do_rescale
						SCREAMING_SNAKE_CASE__													= size_divisor if size_divisor is not None else self.size_divisor
						SCREAMING_SNAKE_CASE__													= resample if resample is not None else self.resample

						if do_resize and size_divisor is None:
											raise ValueError('size_divisor is required for resizing'							)

						SCREAMING_SNAKE_CASE__													= make_list_of_images(UpperCAmelCase_							)

						if not valid_images(UpperCAmelCase_							):
											raise ValueError('Invalid image(s)'							)

						# All transformations expect numpy arrays.
						SCREAMING_SNAKE_CASE__													= [to_numpy_array(UpperCAmelCase_							) for img in images]

						if do_resize:
											SCREAMING_SNAKE_CASE__													= [self.resize(UpperCAmelCase_       ,   size_divisor=UpperCAmelCase_       ,   resample=UpperCAmelCase_							) for image in images]

						if do_rescale:
											SCREAMING_SNAKE_CASE__													= [self.rescale(UpperCAmelCase_       ,   scale=1 / 255							) for image in images]

						SCREAMING_SNAKE_CASE__													= [to_channel_dimension_format(UpperCAmelCase_       ,   UpperCAmelCase_							) for image in images]

						SCREAMING_SNAKE_CASE__													= {'pixel_values': images}
						return BatchFeature(data=UpperCAmelCase_       ,   tensor_type=UpperCAmelCase_							)





