



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 __lowerCAmelCase (     SCREAMING_SNAKE_CASE_  ):
			lowercase__					  =				[]
			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 __lowerCAmelCase (     SCREAMING_SNAKE_CASE_						,  SCREAMING_SNAKE_CASE_  ):
			lowercase__					  =				[]
			for d in reversed(SCREAMING_SNAKE_CASE_  ):
						idx.append(flat_idx % d  )
						lowercase__					  =				flat_idx // d

			return tuple(reversed(SCREAMING_SNAKE_CASE_  )  )



@torch.jit.ignore
def __lowerCAmelCase (     SCREAMING_SNAKE_CASE_						,  SCREAMING_SNAKE_CASE_						,  SCREAMING_SNAKE_CASE_						,  SCREAMING_SNAKE_CASE_ = None						,  SCREAMING_SNAKE_CASE_ = None						,  ):

			# start_edges and end_edges both indicate whether, starting from any given
			# dimension, the start/end index is at the top/bottom edge of the
			# corresponding tensor, modeled as a tree
			def reduce_edge_list(SCREAMING_SNAKE_CASE_  ) -> None:
						lowercase__					  =				True
						for i in range(len(SCREAMING_SNAKE_CASE_  )  ):
									lowercase__					  =				-1 * (i + 1)
									l[reversed_idx] &= tally
									lowercase__					  =				l[reversed_idx]

			if start_edges is None:
						lowercase__					  =				[s == 0 for s in start]
						reduce_edge_list(SCREAMING_SNAKE_CASE_  )
			if end_edges is None:
						lowercase__					  =				[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  ),)]

			lowercase__					  =				[]
			lowercase__					  =				[]

			# 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

			lowercase__					  =				tuple(SCREAMING_SNAKE_CASE_  )
			lowercase__					  =				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

						lowercase__					  =				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

						lowercase__					  =				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()  )
						lowercase__					  =				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 __lowerCAmelCase (     SCREAMING_SNAKE_CASE_						,  SCREAMING_SNAKE_CASE_						,  SCREAMING_SNAKE_CASE_						,  SCREAMING_SNAKE_CASE_  ):
			lowercase__					  =				t.shape[:no_batch_dims]
			lowercase__					  =				list(_flat_idx_to_idx(SCREAMING_SNAKE_CASE_						,  SCREAMING_SNAKE_CASE_  )  )
			# _get_minimal_slice_set is inclusive
			lowercase__					  =				list(_flat_idx_to_idx(flat_end - 1						,  SCREAMING_SNAKE_CASE_  )  )

			# Get an ordered list of slices to perform
			lowercase__					  =				_get_minimal_slice_set(
			    SCREAMING_SNAKE_CASE_						,  SCREAMING_SNAKE_CASE_						,  SCREAMING_SNAKE_CASE_						,  )

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

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



def __lowerCAmelCase (     SCREAMING_SNAKE_CASE_						,  SCREAMING_SNAKE_CASE_						,  SCREAMING_SNAKE_CASE_						,  SCREAMING_SNAKE_CASE_						,  SCREAMING_SNAKE_CASE_ = False						,  SCREAMING_SNAKE_CASE_ = None						,  SCREAMING_SNAKE_CASE_ = False						,  ):
			if not (len(SCREAMING_SNAKE_CASE_  ) > 0):
						raise ValueError("Must provide at least one input"  )

			lowercase__					  =				[shape[:no_batch_dims] for shape in _fetch_dims(SCREAMING_SNAKE_CASE_  )]
			lowercase__					  =				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:
												lowercase__					  =				t.expand(orig_batch_dims + t.shape[no_batch_dims:]  )
									lowercase__					  =				t.reshape(-1						,  *t.shape[no_batch_dims:]  )
						else:
									lowercase__					  =				t.expand(orig_batch_dims + t.shape[no_batch_dims:]  )
						return t

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

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

			lowercase__					  =				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

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

						lowercase__					  =				tensor_tree_map(SCREAMING_SNAKE_CASE_						,  SCREAMING_SNAKE_CASE_  )

						# Run the layer on the chunk
						lowercase__					  =				layer(**SCREAMING_SNAKE_CASE_  )

						# Allocate space for the output
						if out is None:
									lowercase__					  =				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:
																					lowercase__					  =				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:
															lowercase__					  =				xa
						elif isinstance(SCREAMING_SNAKE_CASE_						,  torch.Tensor  ):
									if _add_into_out:
												out[i : i + chunk_size] += output_chunk
									else:
												lowercase__					  =				output_chunk
						else:
									raise ValueError("Not supported"  )

						i += chunk_size

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

			return out




class 				_snake_case			:




				def __init__(						self					:						Optional[Any],					__lowercase					:						int = 512,					):
							lowercase__					  =				max_chunk_size
							lowercase__					  =				None
							lowercase__					  =				None




				def 							A__      (						self					:						Dict,					__lowercase					:						Callable,					__lowercase					:						tuple,					__lowercase					:						int						):
							logging.info("Tuning chunk size..."						)

							if min_chunk_size >= self.max_chunk_size:
										return min_chunk_size

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

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

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

							return candidates[min_viable_chunk_size_index]




				def 							A__      (						self					:						Optional[int],					__lowercase					:						Iterable,					__lowercase					:						Iterable						):
							lowercase__					  =				True
							for aa, aa in zip(__lowercase,					__lowercase						):
										assert type(__lowercase						) == type(__lowercase						)
										if isinstance(__lowercase,					(list, tuple)						):
													consistent &= self._compare_arg_caches(__lowercase,					__lowercase						)
										elif isinstance(__lowercase,					__lowercase						):
													lowercase__					  =				[v for _, v in sorted(aa.items(),					key=lambda __lowercase						: x[0]						)]
													lowercase__					  =				[v for _, v in sorted(aa.items(),					key=lambda __lowercase						: x[0]						)]
													consistent &= self._compare_arg_caches(__lowercase,					__lowercase						)
										else:
													consistent &= aa == aa

							return consistent




				def 							A__      (						self					:						int,					__lowercase					:						Callable,					__lowercase					:						tuple,					__lowercase					:						int,					):
							lowercase__					  =				True
							lowercase__					  =				tree_map(lambda __lowercase						: a.shape if isinstance(__lowercase,					torch.Tensor						) else a,					__lowercase,					__lowercase						)
							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(__lowercase						)
										lowercase__					  =				self._compare_arg_caches(self.cached_arg_data,					__lowercase						)
							else:
										# Otherwise, we can reuse the precomputed value
										lowercase__					  =				False

							if not consistent:
										lowercase__					  =				self._determine_favorable_chunk_size(
										    __lowercase,					__lowercase,					__lowercase,					)
										lowercase__					  =				arg_data

							assert self.cached_chunk_size is not None

							return self.cached_chunk_size









import unittest

import numpy as np
import requests

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

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
							import torch

							from transformers.pytorch_utils import is_torch_greater_or_equal_than_1_11
else:
							lowercase_								=     False

if is_vision_available():
							from PIL import Image

							from transformers import PixaStructImageProcessor
class 				_snake_case			(					unittest.TestCase):




				def __init__(						self					:						List[Any],					__lowercase					:						int,					__lowercase					:						Optional[int]=7,					__lowercase					:						List[str]=3,					__lowercase					:						Tuple=18,					__lowercase					:						List[Any]=30,					__lowercase					:						Tuple=400,					__lowercase					:						Any=None,					__lowercase					:						Optional[int]=True,					__lowercase					:						List[str]=True,					__lowercase					:						Union[str, Any]=None,					):
							lowercase__					  =				size if size is not None else {"height": 20, "width": 20}
							lowercase__					  =				parent
							lowercase__					  =				batch_size
							lowercase__					  =				num_channels
							lowercase__					  =				image_size
							lowercase__					  =				min_resolution
							lowercase__					  =				max_resolution
							lowercase__					  =				size
							lowercase__					  =				do_normalize
							lowercase__					  =				do_convert_rgb
							lowercase__					  =				[512, 1024, 2048, 4096]
							lowercase__					  =				patch_size if patch_size is not None else {"height": 16, "width": 16}




				def 							A__      (						self					:						List[str]						):
							return {"do_normalize": self.do_normalize, "do_convert_rgb": self.do_convert_rgb}




				def 							A__      (						self					:						Any						):
							lowercase__					  =				"https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/australia.jpg"
							lowercase__					  =				Image.open(requests.get(__lowercase,					stream=__lowercase						).raw						).convert("RGB"						)
							return raw_image
@unittest.skipIf(
    not is_torch_greater_or_equal_than_1_11    ,	reason="""`Pix2StructImageProcessor` requires `torch>=1.11.0`."""    ,	)
@require_torch
@require_vision
class 				_snake_case			(					lowercase__    ,	unittest.TestCase):
				UpperCamelCase__				:					Any     		=PixaStructImageProcessor if is_vision_available() else None




				def 							A__      (						self					:						Any						):
							lowercase__					  =				PixaStructImageProcessingTester(self						)




				@property
				def 							A__      (						self					:						Union[str, Any]						):
							return self.image_processor_tester.prepare_image_processor_dict()




				def 							A__      (						self					:						Optional[Any]						):
							lowercase__					  =				self.image_processing_class(**self.image_processor_dict						)
							self.assertTrue(hasattr(__lowercase,					"do_normalize"						)						)
							self.assertTrue(hasattr(__lowercase,					"do_convert_rgb"						)						)




				def 							A__      (						self					:						Optional[int]						):
							lowercase__					  =				self.image_processor_tester.prepare_dummy_image()

							lowercase__					  =				self.image_processing_class(**self.image_processor_dict						)
							lowercase__					  =				2048

							lowercase__					  =				image_processor(__lowercase,					return_tensors="pt",					max_patches=__lowercase						)
							self.assertTrue(torch.allclose(inputs.flattened_patches.mean(),					torch.tensor(0.0606						),					atol=1e-3,					rtol=1e-3						)						)




				def 							A__      (						self					:						Union[str, Any]						):
							# Initialize image_processor
							lowercase__					  =				self.image_processing_class(**self.image_processor_dict						)
							# create random PIL images
							lowercase__					  =				prepare_image_inputs(self.image_processor_tester,					equal_resolution=__lowercase						)
							for image in image_inputs:
										self.assertIsInstance(__lowercase,					Image.Image						)

							# Test not batched input
							lowercase__					  =				(
							    (self.image_processor_tester.patch_size["height"] * self.image_processor_tester.patch_size["width"])
							    * self.image_processor_tester.num_channels
							) + 2

							for max_patch in self.image_processor_tester.max_patches:
										# Test not batched input
										lowercase__					  =				image_processor(
										    image_inputs[0],					return_tensors="pt",					max_patches=__lowercase						).flattened_patches
										self.assertEqual(
										    encoded_images.shape,					(1, max_patch, expected_hidden_dim),					)

										# Test batched
										lowercase__					  =				image_processor(
										    __lowercase,					return_tensors="pt",					max_patches=__lowercase						).flattened_patches
										self.assertEqual(
										    encoded_images.shape,					(self.image_processor_tester.batch_size, max_patch, expected_hidden_dim),					)




				def 							A__      (						self					:						int						):
							# Initialize image_processor
							lowercase__					  =				self.image_processing_class(**self.image_processor_dict						)
							# create random PIL images
							lowercase__					  =				prepare_image_inputs(self.image_processor_tester,					equal_resolution=__lowercase						)
							for image in image_inputs:
										self.assertIsInstance(__lowercase,					Image.Image						)

							# Test not batched input
							lowercase__					  =				(
							    (self.image_processor_tester.patch_size["height"] * self.image_processor_tester.patch_size["width"])
							    * self.image_processor_tester.num_channels
							) + 2

							lowercase__					  =				True

							for max_patch in self.image_processor_tester.max_patches:
										# Test not batched input
										with self.assertRaises(__lowercase						):
													lowercase__					  =				image_processor(
													    image_inputs[0],					return_tensors="pt",					max_patches=__lowercase						).flattened_patches

										lowercase__					  =				"Hello"

										lowercase__					  =				image_processor(
										    image_inputs[0],					return_tensors="pt",					max_patches=__lowercase,					header_text=__lowercase						).flattened_patches
										self.assertEqual(
										    encoded_images.shape,					(1, max_patch, expected_hidden_dim),					)

										# Test batched
										lowercase__					  =				image_processor(
										    __lowercase,					return_tensors="pt",					max_patches=__lowercase,					header_text=__lowercase						).flattened_patches
										self.assertEqual(
										    encoded_images.shape,					(self.image_processor_tester.batch_size, max_patch, expected_hidden_dim),					)




				def 							A__      (						self					:						Tuple						):
							# Initialize image_processor
							lowercase__					  =				self.image_processing_class(**self.image_processor_dict						)
							# create random numpy tensors
							lowercase__					  =				prepare_image_inputs(self.image_processor_tester,					equal_resolution=__lowercase,					numpify=__lowercase						)
							for image in image_inputs:
										self.assertIsInstance(__lowercase,					np.ndarray						)

							lowercase__					  =				(
							    (self.image_processor_tester.patch_size["height"] * self.image_processor_tester.patch_size["width"])
							    * self.image_processor_tester.num_channels
							) + 2

							for max_patch in self.image_processor_tester.max_patches:
										# Test not batched input
										lowercase__					  =				image_processor(
										    image_inputs[0],					return_tensors="pt",					max_patches=__lowercase						).flattened_patches
										self.assertEqual(
										    encoded_images.shape,					(1, max_patch, expected_hidden_dim),					)

										# Test batched
										lowercase__					  =				image_processor(
										    __lowercase,					return_tensors="pt",					max_patches=__lowercase						).flattened_patches
										self.assertEqual(
										    encoded_images.shape,					(self.image_processor_tester.batch_size, max_patch, expected_hidden_dim),					)




				def 							A__      (						self					:						Any						):
							# Initialize image_processor
							lowercase__					  =				self.image_processing_class(**self.image_processor_dict						)
							# create random PyTorch tensors
							lowercase__					  =				prepare_image_inputs(self.image_processor_tester,					equal_resolution=__lowercase,					torchify=__lowercase						)
							for image in image_inputs:
										self.assertIsInstance(__lowercase,					torch.Tensor						)

							# Test not batched input
							lowercase__					  =				(
							    (self.image_processor_tester.patch_size["height"] * self.image_processor_tester.patch_size["width"])
							    * self.image_processor_tester.num_channels
							) + 2

							for max_patch in self.image_processor_tester.max_patches:
										# Test not batched input
										lowercase__					  =				image_processor(
										    image_inputs[0],					return_tensors="pt",					max_patches=__lowercase						).flattened_patches
										self.assertEqual(
										    encoded_images.shape,					(1, max_patch, expected_hidden_dim),					)

										# Test batched
										lowercase__					  =				image_processor(
										    __lowercase,					return_tensors="pt",					max_patches=__lowercase						).flattened_patches
										self.assertEqual(
										    encoded_images.shape,					(self.image_processor_tester.batch_size, max_patch, expected_hidden_dim),					)
@unittest.skipIf(
    not is_torch_greater_or_equal_than_1_11    ,	reason="""`Pix2StructImageProcessor` requires `torch>=1.11.0`."""    ,	)
@require_torch
@require_vision
class 				_snake_case			(					lowercase__    ,	unittest.TestCase):
				UpperCamelCase__				:					Optional[int]     		=PixaStructImageProcessor if is_vision_available() else None




				def 							A__      (						self					:						Optional[int]						):
							lowercase__					  =				PixaStructImageProcessingTester(self,					num_channels=4						)
							lowercase__					  =				3




				@property
				def 							A__      (						self					:						Union[str, Any]						):
							return self.image_processor_tester.prepare_image_processor_dict()




				def 							A__      (						self					:						Dict						):
							lowercase__					  =				self.image_processing_class(**self.image_processor_dict						)
							self.assertTrue(hasattr(__lowercase,					"do_normalize"						)						)
							self.assertTrue(hasattr(__lowercase,					"do_convert_rgb"						)						)




				def 							A__      (						self					:						Union[str, Any]						):
							# Initialize image_processor
							lowercase__					  =				self.image_processing_class(**self.image_processor_dict						)
							# create random PIL images
							lowercase__					  =				prepare_image_inputs(self.image_processor_tester,					equal_resolution=__lowercase						)
							for image in image_inputs:
										self.assertIsInstance(__lowercase,					Image.Image						)

							# Test not batched input
							lowercase__					  =				(
							    (self.image_processor_tester.patch_size["height"] * self.image_processor_tester.patch_size["width"])
							    * (self.image_processor_tester.num_channels - 1)
							) + 2

							for max_patch in self.image_processor_tester.max_patches:
										# Test not batched input
										lowercase__					  =				image_processor(
										    image_inputs[0],					return_tensors="pt",					max_patches=__lowercase						).flattened_patches
										self.assertEqual(
										    encoded_images.shape,					(1, max_patch, expected_hidden_dim),					)

										# Test batched
										lowercase__					  =				image_processor(
										    __lowercase,					return_tensors="pt",					max_patches=__lowercase						).flattened_patches
										self.assertEqual(
										    encoded_images.shape,					(self.image_processor_tester.batch_size, max_patch, expected_hidden_dim),					)




