





import logging
import math
from functools import partial
from typing import Any, Callable, Dict, Iterable, List, Optional, Sequence, Tuple, Union

import torch

from .tensor_utils import tensor_tree_map, tree_map



def        __lowercase       (				_SCREAMING_SNAKE_CASE     )			->       List[Tuple[int, ...]]:


      '''simple docstring'''


      SCREAMING_SNAKE_CASE		=						[]
      if isinstance(_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE     ):
            for v in tree.values():
                  shapes.extend(_fetch_dims(_SCREAMING_SNAKE_CASE     )     )
      elif isinstance(_SCREAMING_SNAKE_CASE			,						(list, tuple)     ):
            for t in tree:
                  shapes.extend(_fetch_dims(_SCREAMING_SNAKE_CASE     )     )
      elif isinstance(_SCREAMING_SNAKE_CASE			,						torch.Tensor     ):
            shapes.append(tree.shape     )
      else:
            raise ValueError("""Not supported"""     )

      return shapes



@torch.jit.ignore
def        __lowercase       (				_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE     )			->       Tuple[int, ...]:


      '''simple docstring'''


      SCREAMING_SNAKE_CASE		=						[]
      for d in reversed(_SCREAMING_SNAKE_CASE     ):
            idx.append(flat_idx % d     )
            SCREAMING_SNAKE_CASE		=						flat_idx // d

      return tuple(reversed(_SCREAMING_SNAKE_CASE     )     )



@torch.jit.ignore
def        __lowercase       (				_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE = None			,						_SCREAMING_SNAKE_CASE = None			,						)			->       List[Tuple[slice, ...]]:


      '''simple docstring'''


      def reduce_edge_list(_SCREAMING_SNAKE_CASE     ) -> None:
            SCREAMING_SNAKE_CASE		=						True
            for i in range(len(_SCREAMING_SNAKE_CASE     )     ):
                  SCREAMING_SNAKE_CASE		=						-1 * (i + 1)
                  l[reversed_idx] &= tally
                  SCREAMING_SNAKE_CASE		=						l[reversed_idx]

      if start_edges is None:
            SCREAMING_SNAKE_CASE		=						[s == 0 for s in start]
            reduce_edge_list(_SCREAMING_SNAKE_CASE     )
      if end_edges is None:
            SCREAMING_SNAKE_CASE		=						[e == (d - 1) for e, d in zip(_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE     )]
            reduce_edge_list(_SCREAMING_SNAKE_CASE     )

      # Base cases. Either start/end are empty and we're done, or the final,
      # one-dimensional tensor can be simply sliced
      if len(_SCREAMING_SNAKE_CASE     ) == 0:
            return [()]
      elif len(_SCREAMING_SNAKE_CASE     ) == 1:
            return [(slice(start[0]			,						end[0] + 1     ),)]

      SCREAMING_SNAKE_CASE		=						[]
      SCREAMING_SNAKE_CASE		=						[]

      # Dimensions common to start and end can be selected directly
      for s, e in zip(_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE     ):
            if s == e:
                  path_list.append(slice(_SCREAMING_SNAKE_CASE			,						s + 1     )     )
            else:
                  break

      SCREAMING_SNAKE_CASE		=						tuple(_SCREAMING_SNAKE_CASE     )
      SCREAMING_SNAKE_CASE		=						len(_SCREAMING_SNAKE_CASE     )

      # start == end, and we're done
      if divergence_idx == len(_SCREAMING_SNAKE_CASE     ):
            return [path]

      def upper() -> Tuple[Tuple[slice, ...], ...]:
            assert start_edges is not None
            assert end_edges is not None

            SCREAMING_SNAKE_CASE		=						start[divergence_idx]
            return tuple(
                path + (slice(_SCREAMING_SNAKE_CASE			,						sdi + 1     ),) + s
                for s in _get_minimal_slice_set(
                    start[divergence_idx + 1 :]			,						[d - 1 for d in dims[divergence_idx + 1 :]]			,						dims[divergence_idx + 1 :]			,						start_edges=start_edges[divergence_idx + 1 :]			,						end_edges=[True for _ in end_edges[divergence_idx + 1 :]]			,						)     )

      def lower() -> Tuple[Tuple[slice, ...], ...]:
            assert start_edges is not None
            assert end_edges is not None

            SCREAMING_SNAKE_CASE		=						end[divergence_idx]
            return tuple(
                path + (slice(_SCREAMING_SNAKE_CASE			,						edi + 1     ),) + s
                for s in _get_minimal_slice_set(
                    [0 for _ in start[divergence_idx + 1 :]]			,						end[divergence_idx + 1 :]			,						dims[divergence_idx + 1 :]			,						start_edges=[True for _ in start_edges[divergence_idx + 1 :]]			,						end_edges=end_edges[divergence_idx + 1 :]			,						)     )

      # If both start and end are at the edges of the subtree rooted at
      # divergence_idx, we can just select the whole subtree at once
      if start_edges[divergence_idx] and end_edges[divergence_idx]:
            slices.append(path + (slice(start[divergence_idx]			,						end[divergence_idx] + 1     ),)     )
      # If just start is at the edge, we can grab almost all of the subtree,
      # treating only the ragged bottom edge as an edge case
      elif start_edges[divergence_idx]:
            slices.append(path + (slice(start[divergence_idx]			,						end[divergence_idx]     ),)     )
            slices.extend(lower()     )
      # Analogous to the previous case, but the top is ragged this time
      elif end_edges[divergence_idx]:
            slices.extend(upper()     )
            slices.append(path + (slice(start[divergence_idx] + 1			,						end[divergence_idx] + 1     ),)     )
      # If both sides of the range are ragged, we need to handle both sides
      # separately. If there's contiguous meat in between them, we can index it
      # in one big chunk
      else:
            slices.extend(upper()     )
            SCREAMING_SNAKE_CASE		=						end[divergence_idx] - start[divergence_idx]
            if middle_ground > 1:
                  slices.append(path + (slice(start[divergence_idx] + 1			,						end[divergence_idx]     ),)     )
            slices.extend(lower()     )

      return slices



@torch.jit.ignore
def        __lowercase       (				_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE     )			->       torch.Tensor:


      '''simple docstring'''


      SCREAMING_SNAKE_CASE		=						t.shape[:no_batch_dims]
      SCREAMING_SNAKE_CASE		=						list(_flat_idx_to_idx(_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE     )     )
      # _get_minimal_slice_set is inclusive
      SCREAMING_SNAKE_CASE		=						list(_flat_idx_to_idx(flat_end - 1			,						_SCREAMING_SNAKE_CASE     )     )

      # Get an ordered list of slices to perform
      SCREAMING_SNAKE_CASE		=						_get_minimal_slice_set(
          _SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE			,						)

      SCREAMING_SNAKE_CASE		=						[t[s] for s in slices]

      return torch.cat([s.view((-1,) + t.shape[no_batch_dims:]     ) for s in sliced_tensors]     )



def        __lowercase       (				_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE = False			,						_SCREAMING_SNAKE_CASE = None			,						_SCREAMING_SNAKE_CASE = False			,						)			->       Any:


      '''simple docstring'''


      if not (len(_SCREAMING_SNAKE_CASE     ) > 0):
            raise ValueError("""Must provide at least one input"""     )

      SCREAMING_SNAKE_CASE		=						[shape[:no_batch_dims] for shape in _fetch_dims(_SCREAMING_SNAKE_CASE     )]
      SCREAMING_SNAKE_CASE		=						tuple([max(_SCREAMING_SNAKE_CASE     ) for s in zip(*_SCREAMING_SNAKE_CASE     )]     )

      def _prep_inputs(_SCREAMING_SNAKE_CASE     ) -> torch.Tensor:
            if not low_mem:
                  if not sum(t.shape[:no_batch_dims]     ) == no_batch_dims:
                        SCREAMING_SNAKE_CASE		=						t.expand(orig_batch_dims + t.shape[no_batch_dims:]     )
                  SCREAMING_SNAKE_CASE		=						t.reshape(-1			,						*t.shape[no_batch_dims:]     )
            else:
                  SCREAMING_SNAKE_CASE		=						t.expand(orig_batch_dims + t.shape[no_batch_dims:]     )
            return t

      SCREAMING_SNAKE_CASE		=						tensor_tree_map(_prep_inputs			,						_SCREAMING_SNAKE_CASE     )
      SCREAMING_SNAKE_CASE		=						None
      if _out is not None:
            SCREAMING_SNAKE_CASE		=						tensor_tree_map(lambda _SCREAMING_SNAKE_CASE     : t.view([-1] + list(t.shape[no_batch_dims:]     )     )			,						_out     )

      SCREAMING_SNAKE_CASE		=						1
      for d in orig_batch_dims:
            flat_batch_dim *= d

      SCREAMING_SNAKE_CASE		=						flat_batch_dim // chunk_size + (flat_batch_dim % chunk_size != 0)

      def _select_chunk(_SCREAMING_SNAKE_CASE     ) -> torch.Tensor:
            return t[i : i + chunk_size] if t.shape[0] != 1 else t

      SCREAMING_SNAKE_CASE		=						0
      SCREAMING_SNAKE_CASE		=						prepped_outputs
      for _ in range(_SCREAMING_SNAKE_CASE     ):
            # Chunk the input
            if not low_mem:
                  SCREAMING_SNAKE_CASE		=						_select_chunk
            else:
                  SCREAMING_SNAKE_CASE		=						partial(
                      _chunk_slice			,						flat_start=_SCREAMING_SNAKE_CASE			,						flat_end=min(_SCREAMING_SNAKE_CASE			,						i + chunk_size     )			,						no_batch_dims=len(_SCREAMING_SNAKE_CASE     )			,						)

            SCREAMING_SNAKE_CASE		=						tensor_tree_map(_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE     )

            # Run the layer on the chunk
            SCREAMING_SNAKE_CASE		=						layer(**_SCREAMING_SNAKE_CASE     )

            # Allocate space for the output
            if out is None:
                  SCREAMING_SNAKE_CASE		=						tensor_tree_map(lambda _SCREAMING_SNAKE_CASE     : t.new_zeros((flat_batch_dim,) + t.shape[1:]     )			,						_SCREAMING_SNAKE_CASE     )

            # Put the chunk in its pre-allocated space
            if isinstance(_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE     ):

                  def assign(_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE     ) -> None:
                        for k, v in da.items():
                              if isinstance(_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE     ):
                                    assign(_SCREAMING_SNAKE_CASE			,						da[k]     )
                              else:
                                    if _add_into_out:
                                          v[i : i + chunk_size] += da[k]
                                    else:
                                          SCREAMING_SNAKE_CASE		=						da[k]

                  assign(_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE     )
            elif isinstance(_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE     ):
                  for xa, xa in zip(_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE     ):
                        if _add_into_out:
                              xa[i : i + chunk_size] += xa
                        else:
                              SCREAMING_SNAKE_CASE		=						xa
            elif isinstance(_SCREAMING_SNAKE_CASE			,						torch.Tensor     ):
                  if _add_into_out:
                        out[i : i + chunk_size] += output_chunk
                  else:
                        SCREAMING_SNAKE_CASE		=						output_chunk
            else:
                  raise ValueError("""Not supported"""     )

            i += chunk_size

      SCREAMING_SNAKE_CASE		=						tensor_tree_map(lambda _SCREAMING_SNAKE_CASE     : t.view(orig_batch_dims + t.shape[1:]     )			,						_SCREAMING_SNAKE_CASE     )

      return out



class 		UpperCamelCase__			:



     '''simple docstring'''

     def __init__(							self						:   Union[str, Any]						,lowerCamelCase__						:   int = 512						,)					->		str:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						max_chunk_size
           SCREAMING_SNAKE_CASE		=						None
           SCREAMING_SNAKE_CASE		=						None






     def     SCREAMING_SNAKE_CASE__  (							self						:   Tuple						,lowerCamelCase__						:   Callable						,lowerCamelCase__						:   tuple						,lowerCamelCase__						:   int	)					->		int:




           '''simple docstring'''


           logging.info("""Tuning chunk size..."""	)

           if min_chunk_size >= self.max_chunk_size:
                 return min_chunk_size

           SCREAMING_SNAKE_CASE		=						[2**l for l in range(int(math.log(self.max_chunk_size						,2	)	) + 1	)]
           SCREAMING_SNAKE_CASE		=						[c for c in candidates if c > min_chunk_size]
           SCREAMING_SNAKE_CASE		=						[min_chunk_size] + candidates
           candidates[-1] += 4

           def test_chunk_size(lowerCamelCase__						:   int	) -> bool:
                 try:
                       with torch.no_grad():
                             fn(*lowerCamelCase__						,chunk_size=lowerCamelCase__	)
                       return True
                 except RuntimeError:
                       return False

           SCREAMING_SNAKE_CASE		=						0
           SCREAMING_SNAKE_CASE		=						len(lowerCamelCase__	) - 1
           while i > min_viable_chunk_size_index:
                 SCREAMING_SNAKE_CASE		=						test_chunk_size(candidates[i]	)
                 if not viable:
                       SCREAMING_SNAKE_CASE		=						(min_viable_chunk_size_index + i) // 2
                 else:
                       SCREAMING_SNAKE_CASE		=						i
                       SCREAMING_SNAKE_CASE		=						(i + len(lowerCamelCase__	) - 1) // 2

           return candidates[min_viable_chunk_size_index]






     def     SCREAMING_SNAKE_CASE__  (							self						:   Optional[int]						,lowerCamelCase__						:   Iterable						,lowerCamelCase__						:   Iterable	)					->		bool:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						True
           for aa, aa in zip(lowerCamelCase__						,lowerCamelCase__	):
                 assert type(lowerCamelCase__	) == type(lowerCamelCase__	)
                 if isinstance(lowerCamelCase__						,(list, tuple)	):
                       consistent &= self._compare_arg_caches(lowerCamelCase__						,lowerCamelCase__	)
                 elif isinstance(lowerCamelCase__						,lowerCamelCase__	):
                       SCREAMING_SNAKE_CASE		=						[v for _, v in sorted(aa.items()						,key=lambda lowerCamelCase__	: x[0]	)]
                       SCREAMING_SNAKE_CASE		=						[v for _, v in sorted(aa.items()						,key=lambda lowerCamelCase__	: x[0]	)]
                       consistent &= self._compare_arg_caches(lowerCamelCase__						,lowerCamelCase__	)
                 else:
                       consistent &= aa == aa

           return consistent






     def     SCREAMING_SNAKE_CASE__  (							self						:   Any						,lowerCamelCase__						:   Callable						,lowerCamelCase__						:   tuple						,lowerCamelCase__						:   int						,)					->		int:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						True
           SCREAMING_SNAKE_CASE		=						tree_map(lambda lowerCamelCase__	: a.shape if isinstance(lowerCamelCase__						,torch.Tensor	) else a						,lowerCamelCase__						,lowerCamelCase__	)
           if self.cached_arg_data is not None:
                 # If args have changed shape/value, we need to re-tune
                 assert len(self.cached_arg_data	) == len(lowerCamelCase__	)
                 SCREAMING_SNAKE_CASE		=						self._compare_arg_caches(self.cached_arg_data						,lowerCamelCase__	)
           else:
                 # Otherwise, we can reuse the precomputed value
                 SCREAMING_SNAKE_CASE		=						False

           if not consistent:
                 SCREAMING_SNAKE_CASE		=						self._determine_favorable_chunk_size(
                     lowerCamelCase__						,lowerCamelCase__						,lowerCamelCase__						,)
                 SCREAMING_SNAKE_CASE		=						arg_data

           assert self.cached_chunk_size is not None

           return self.cached_chunk_size









import unittest

import numpy as np

from transformers.file_utils import is_torch_available, is_vision_available
from transformers.testing_utils import require_torch, require_vision

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
      import torch

if is_vision_available():
      from PIL import Image

      from transformers import DPTImageProcessor

class 		UpperCamelCase__			(				unittest.TestCase       ):



     '''simple docstring'''

     def __init__(							self						:   Optional[Any]						,lowerCamelCase__						:   List[str]						,lowerCamelCase__						:   Optional[Any]=7						,lowerCamelCase__						:   Optional[Any]=3						,lowerCamelCase__						:   Union[str, Any]=18						,lowerCamelCase__						:   Optional[int]=30						,lowerCamelCase__						:   int=400						,lowerCamelCase__						:   List[str]=True						,lowerCamelCase__						:   Union[str, Any]=None						,lowerCamelCase__						:   Union[str, Any]=True						,lowerCamelCase__						:   Optional[int]=[0.5, 0.5, 0.5]						,lowerCamelCase__						:   Any=[0.5, 0.5, 0.5]						,)					->		List[str]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						size if size is not None else {"""height""": 18, """width""": 18}
           SCREAMING_SNAKE_CASE		=						parent
           SCREAMING_SNAKE_CASE		=						batch_size
           SCREAMING_SNAKE_CASE		=						num_channels
           SCREAMING_SNAKE_CASE		=						image_size
           SCREAMING_SNAKE_CASE		=						min_resolution
           SCREAMING_SNAKE_CASE		=						max_resolution
           SCREAMING_SNAKE_CASE		=						do_resize
           SCREAMING_SNAKE_CASE		=						size
           SCREAMING_SNAKE_CASE		=						do_normalize
           SCREAMING_SNAKE_CASE		=						image_mean
           SCREAMING_SNAKE_CASE		=						image_std






     def     SCREAMING_SNAKE_CASE__  (							self						:   Any	)					->		Union[str, Any]:




           '''simple docstring'''


           return {
               "image_mean": self.image_mean,
               "image_std": self.image_std,
               "do_normalize": self.do_normalize,
               "do_resize": self.do_resize,
               "size": self.size,
           }

@require_torch
@require_vision
class 		UpperCamelCase__			(				lowerCAmelCase_							,				unittest.TestCase       ):



     '''simple docstring'''

     __snake_case   :     Tuple		     =      DPTImageProcessor if is_vision_available() else None






     def     SCREAMING_SNAKE_CASE__  (							self						:   Union[str, Any]	)					->		Optional[Any]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						DPTImageProcessingTester(self	)






     @property
     def     SCREAMING_SNAKE_CASE__  (							self						:   Union[str, Any]	)					->		int:




           '''simple docstring'''


           return self.image_processor_tester.prepare_image_processor_dict()






     def     SCREAMING_SNAKE_CASE__  (							self						:   Dict	)					->		List[Any]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						self.image_processing_class(**self.image_processor_dict	)
           self.assertTrue(hasattr(lowerCamelCase__						,"""image_mean"""	)	)
           self.assertTrue(hasattr(lowerCamelCase__						,"""image_std"""	)	)
           self.assertTrue(hasattr(lowerCamelCase__						,"""do_normalize"""	)	)
           self.assertTrue(hasattr(lowerCamelCase__						,"""do_resize"""	)	)
           self.assertTrue(hasattr(lowerCamelCase__						,"""size"""	)	)






     def     SCREAMING_SNAKE_CASE__  (							self						:   int	)					->		List[Any]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						self.image_processing_class.from_dict(self.image_processor_dict	)
           self.assertEqual(image_processor.size						,{"""height""": 18, """width""": 18}	)

           SCREAMING_SNAKE_CASE		=						self.image_processing_class.from_dict(self.image_processor_dict						,size=42	)
           self.assertEqual(image_processor.size						,{"""height""": 42, """width""": 42}	)






     def     SCREAMING_SNAKE_CASE__  (							self						:   Union[str, Any]	)					->		Optional[int]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						self.image_processing_class(**self.image_processor_dict	)
           # create random PIL images
           SCREAMING_SNAKE_CASE		=						prepare_image_inputs(self.image_processor_tester						,equal_resolution=lowerCamelCase__	)
           for image in image_inputs:
                 self.assertIsInstance(lowerCamelCase__						,Image.Image	)

           # Test not batched input
           SCREAMING_SNAKE_CASE		=						image_processing(image_inputs[0]						,return_tensors="""pt"""	).pixel_values
           self.assertEqual(
               encoded_images.shape						,(
                   1,
                   self.image_processor_tester.num_channels,
                   self.image_processor_tester.size["""height"""],
                   self.image_processor_tester.size["""width"""],
               )						,)

           # Test batched
           SCREAMING_SNAKE_CASE		=						image_processing(lowerCamelCase__						,return_tensors="""pt"""	).pixel_values
           self.assertEqual(
               encoded_images.shape						,(
                   self.image_processor_tester.batch_size,
                   self.image_processor_tester.num_channels,
                   self.image_processor_tester.size["""height"""],
                   self.image_processor_tester.size["""width"""],
               )						,)






     def     SCREAMING_SNAKE_CASE__  (							self						:   List[Any]	)					->		int:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						self.image_processing_class(**self.image_processor_dict	)
           # create random numpy tensors
           SCREAMING_SNAKE_CASE		=						prepare_image_inputs(self.image_processor_tester						,equal_resolution=lowerCamelCase__						,numpify=lowerCamelCase__	)
           for image in image_inputs:
                 self.assertIsInstance(lowerCamelCase__						,np.ndarray	)

           # Test not batched input
           SCREAMING_SNAKE_CASE		=						image_processing(image_inputs[0]						,return_tensors="""pt"""	).pixel_values
           self.assertEqual(
               encoded_images.shape						,(
                   1,
                   self.image_processor_tester.num_channels,
                   self.image_processor_tester.size["""height"""],
                   self.image_processor_tester.size["""width"""],
               )						,)

           # Test batched
           SCREAMING_SNAKE_CASE		=						image_processing(lowerCamelCase__						,return_tensors="""pt"""	).pixel_values
           self.assertEqual(
               encoded_images.shape						,(
                   self.image_processor_tester.batch_size,
                   self.image_processor_tester.num_channels,
                   self.image_processor_tester.size["""height"""],
                   self.image_processor_tester.size["""width"""],
               )						,)






     def     SCREAMING_SNAKE_CASE__  (							self						:   Tuple	)					->		Optional[int]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						self.image_processing_class(**self.image_processor_dict	)
           # create random PyTorch tensors
           SCREAMING_SNAKE_CASE		=						prepare_image_inputs(self.image_processor_tester						,equal_resolution=lowerCamelCase__						,torchify=lowerCamelCase__	)
           for image in image_inputs:
                 self.assertIsInstance(lowerCamelCase__						,torch.Tensor	)

           # Test not batched input
           SCREAMING_SNAKE_CASE		=						image_processing(image_inputs[0]						,return_tensors="""pt"""	).pixel_values
           self.assertEqual(
               encoded_images.shape						,(
                   1,
                   self.image_processor_tester.num_channels,
                   self.image_processor_tester.size["""height"""],
                   self.image_processor_tester.size["""width"""],
               )						,)

           # Test batched
           SCREAMING_SNAKE_CASE		=						image_processing(lowerCamelCase__						,return_tensors="""pt"""	).pixel_values
           self.assertEqual(
               encoded_images.shape						,(
                   self.image_processor_tester.batch_size,
                   self.image_processor_tester.num_channels,
                   self.image_processor_tester.size["""height"""],
                   self.image_processor_tester.size["""width"""],
               )						,)


