



import warnings
from typing import List, Optional, Union

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding, PaddingStrategy, PreTokenizedInput, TextInput, TruncationStrategy
from ...utils import TensorType


class 				_a						(       SCREAMING_SNAKE_CASE			):





							'''simple docstring'''

							A				:Union[str, Any] =       ["image_processor", "tokenizer"]
							A				:Optional[Any] =       "LayoutLMv2ImageProcessor"
							A				:Optional[int] =       ("LayoutXLMTokenizer", "LayoutXLMTokenizerFast")



							def __init__(							self ,					__UpperCAmelCase=None ,					__UpperCAmelCase=None ,					**__UpperCAmelCase				):







											"""simple docstring"""



											if "feature_extractor" in kwargs:
															warnings.warn(
															    "The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`"
															    " instead." ,					__UpperCAmelCase ,					)
															a__	:							str      						= kwargs.pop("feature_extractor"				)

											a__	:							Optional[Any]      						= image_processor if image_processor is not None else feature_extractor
											if image_processor is None:
															raise ValueError("You need to specify an `image_processor`."				)
											if tokenizer is None:
															raise ValueError("You need to specify a `tokenizer`."				)

											super().__init__(__UpperCAmelCase ,					__UpperCAmelCase				)



							def __call__(							self ,					__UpperCAmelCase ,					__UpperCAmelCase = None ,					__UpperCAmelCase = None ,					__UpperCAmelCase = None ,					__UpperCAmelCase = None ,					__UpperCAmelCase = True ,					__UpperCAmelCase = False ,					__UpperCAmelCase = None ,					__UpperCAmelCase = None ,					__UpperCAmelCase = 0 ,					__UpperCAmelCase = None ,					__UpperCAmelCase = None ,					__UpperCAmelCase = None ,					__UpperCAmelCase = False ,					__UpperCAmelCase = False ,					__UpperCAmelCase = False ,					__UpperCAmelCase = False ,					__UpperCAmelCase = True ,					__UpperCAmelCase = None ,					**__UpperCAmelCase ,					):







											"""simple docstring"""



											if self.image_processor.apply_ocr and (boxes is not None):
															raise ValueError(
															    "You cannot provide bounding boxes "
															    "if you initialized the image processor with apply_ocr set to True."				)

											if self.image_processor.apply_ocr and (word_labels is not None):
															raise ValueError(
															    "You cannot provide word labels if you initialized the image processor with apply_ocr set to True."				)

											if return_overflowing_tokens is True and return_offsets_mapping is False:
															raise ValueError("You cannot return overflowing tokens without returning the offsets mapping."				)

											# first, apply the image processor
											a__	:							Optional[Any]      						= self.image_processor(images=__UpperCAmelCase ,					return_tensors=__UpperCAmelCase				)

											# second, apply the tokenizer
											if text is not None and self.image_processor.apply_ocr and text_pair is None:
															if isinstance(__UpperCAmelCase ,					__UpperCAmelCase				):
																			a__	:							Optional[Any]      						= [text]  # add batch dimension (as the image processor always adds a batch dimension)
															a__	:							Optional[Any]      						= features["words"]

											a__	:							List[str]      						= self.tokenizer(
											    text=text if text is not None else features["words"] ,					text_pair=text_pair if text_pair is not None else None ,					boxes=boxes if boxes is not None else features["boxes"] ,					word_labels=__UpperCAmelCase ,					add_special_tokens=__UpperCAmelCase ,					padding=__UpperCAmelCase ,					truncation=__UpperCAmelCase ,					max_length=__UpperCAmelCase ,					stride=__UpperCAmelCase ,					pad_to_multiple_of=__UpperCAmelCase ,					return_token_type_ids=__UpperCAmelCase ,					return_attention_mask=__UpperCAmelCase ,					return_overflowing_tokens=__UpperCAmelCase ,					return_special_tokens_mask=__UpperCAmelCase ,					return_offsets_mapping=__UpperCAmelCase ,					return_length=__UpperCAmelCase ,					verbose=__UpperCAmelCase ,					return_tensors=__UpperCAmelCase ,					**__UpperCAmelCase ,					)

											# add pixel values
											a__	:							Tuple      						= features.pop("pixel_values"				)
											if return_overflowing_tokens is True:
															a__	:							List[Any]      						= self.get_overflowing_images(__UpperCAmelCase ,					encoded_inputs["overflow_to_sample_mapping"]				)
											a__	:							Optional[int]      						= images

											return encoded_inputs



							def 		_A	(							self ,					__UpperCAmelCase ,					__UpperCAmelCase				):







											"""simple docstring"""



											a__	:							Union[str, Any]      						= []
											for sample_idx in overflow_to_sample_mapping:
															images_with_overflow.append(images[sample_idx]				)

											if len(__UpperCAmelCase				) != len(__UpperCAmelCase				):
															raise ValueError(
															    "Expected length of images to be the same as the length of `overflow_to_sample_mapping`, but got"
															    f' {len(__UpperCAmelCase				)} and {len(__UpperCAmelCase				)}'				)

											return images_with_overflow



							def 		_A	(							self ,					*__UpperCAmelCase ,					**__UpperCAmelCase				):







											"""simple docstring"""



											return self.tokenizer.batch_decode(*__UpperCAmelCase ,					**__UpperCAmelCase				)



							def 		_A	(							self ,					*__UpperCAmelCase ,					**__UpperCAmelCase				):







											"""simple docstring"""



											return self.tokenizer.decode(*__UpperCAmelCase ,					**__UpperCAmelCase				)



							@property
							def 		_A	(							self				):







											"""simple docstring"""



											return ["input_ids", "bbox", "attention_mask", "image"]



							@property
							def 		_A	(							self				):







											"""simple docstring"""



											warnings.warn(
											    "`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead." ,					__UpperCAmelCase ,					)
											return self.image_processor_class




							@property
							def 		_A	(							self				):







											"""simple docstring"""



											warnings.warn(
											    "`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead." ,					__UpperCAmelCase ,					)
											return self.image_processor







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:
						lowerCamelCase		       =      False

if is_vision_available():
						from PIL import Image

						from transformers import PixaStructImageProcessor


class 				_a						(       unittest.TestCase			):





							'''simple docstring'''

							def __init__(							self ,					__UpperCAmelCase ,					__UpperCAmelCase=7 ,					__UpperCAmelCase=3 ,					__UpperCAmelCase=18 ,					__UpperCAmelCase=30 ,					__UpperCAmelCase=400 ,					__UpperCAmelCase=None ,					__UpperCAmelCase=True ,					__UpperCAmelCase=True ,					__UpperCAmelCase=None ,					):







											"""simple docstring"""



											a__	:							str      						= size if size is not None else {"height": 20, "width": 20}
											a__	:							Optional[int]      						= parent
											a__	:							Union[str, Any]      						= batch_size
											a__	:							List[Any]      						= num_channels
											a__	:							Union[str, Any]      						= image_size
											a__	:							List[str]      						= min_resolution
											a__	:							int      						= max_resolution
											a__	:							int      						= size
											a__	:							List[str]      						= do_normalize
											a__	:							Any      						= do_convert_rgb
											a__	:							Optional[Any]      						= [512, 1024, 2048, 4096]
											a__	:							Any      						= patch_size if patch_size is not None else {"height": 16, "width": 16}



							def 		_A	(							self				):







											"""simple docstring"""



											return {"do_normalize": self.do_normalize, "do_convert_rgb": self.do_convert_rgb}




							def 		_A	(							self				):







											"""simple docstring"""



											a__	:							str      						= "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/australia.jpg"
											a__	:							Union[str, Any]      						= Image.open(requests.get(__UpperCAmelCase ,					stream=__UpperCAmelCase				).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 				_a						(       SCREAMING_SNAKE_CASE       ,  unittest.TestCase			):





							'''simple docstring'''

							A				:List[str] =       PixaStructImageProcessor if is_vision_available() else None



							def 		_A	(							self				):







											"""simple docstring"""



											a__	:							Any      						= PixaStructImageProcessingTester(self				)



							@property
							def 		_A	(							self				):







											"""simple docstring"""



											return self.image_processor_tester.prepare_image_processor_dict()



							def 		_A	(							self				):







											"""simple docstring"""



											a__	:							Union[str, Any]      						= self.image_processing_class(**self.image_processor_dict				)
											self.assertTrue(hasattr(__UpperCAmelCase ,					"do_normalize"				)				)
											self.assertTrue(hasattr(__UpperCAmelCase ,					"do_convert_rgb"				)				)



							def 		_A	(							self				):







											"""simple docstring"""



											a__	:							Tuple      						= self.image_processor_tester.prepare_dummy_image()

											a__	:							Any      						= self.image_processing_class(**self.image_processor_dict				)
											a__	:							List[str]      						= 2048

											a__	:							Union[str, Any]      						= image_processor(__UpperCAmelCase ,					return_tensors="pt" ,					max_patches=__UpperCAmelCase				)
											self.assertTrue(torch.allclose(inputs.flattened_patches.mean() ,					torch.tensor(0.0_6_0_6				) ,					atol=1E-3 ,					rtol=1E-3				)				)



							def 		_A	(							self				):







											"""simple docstring"""



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

											# Test not batched input
											a__	:							List[Any]      						= (
											    (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
															a__	:							Optional[Any]      						= image_processor(
															    image_inputs[0] ,					return_tensors="pt" ,					max_patches=__UpperCAmelCase				).flattened_patches
															self.assertEqual(
															    encoded_images.shape ,					(1, max_patch, expected_hidden_dim) ,					)

															# Test batched
															a__	:							Optional[Any]      						= image_processor(
															    __UpperCAmelCase ,					return_tensors="pt" ,					max_patches=__UpperCAmelCase				).flattened_patches
															self.assertEqual(
															    encoded_images.shape ,					(self.image_processor_tester.batch_size, max_patch, expected_hidden_dim) ,					)



							def 		_A	(							self				):







											"""simple docstring"""



											a__	:							Union[str, Any]      						= self.image_processing_class(**self.image_processor_dict				)
											# create random PIL images
											a__	:							Any      						= prepare_image_inputs(self.image_processor_tester ,					equal_resolution=__UpperCAmelCase				)
											for image in image_inputs:
															self.assertIsInstance(__UpperCAmelCase ,					Image.Image				)

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

											a__	:							int      						= True

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

															a__	:							Tuple      						= "Hello"

															a__	:							Union[str, Any]      						= image_processor(
															    image_inputs[0] ,					return_tensors="pt" ,					max_patches=__UpperCAmelCase ,					header_text=__UpperCAmelCase				).flattened_patches
															self.assertEqual(
															    encoded_images.shape ,					(1, max_patch, expected_hidden_dim) ,					)

															# Test batched
															a__	:							Optional[int]      						= image_processor(
															    __UpperCAmelCase ,					return_tensors="pt" ,					max_patches=__UpperCAmelCase ,					header_text=__UpperCAmelCase				).flattened_patches
															self.assertEqual(
															    encoded_images.shape ,					(self.image_processor_tester.batch_size, max_patch, expected_hidden_dim) ,					)



							def 		_A	(							self				):







											"""simple docstring"""



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

											a__	:							List[str]      						= (
											    (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
															a__	:							Any      						= image_processor(
															    image_inputs[0] ,					return_tensors="pt" ,					max_patches=__UpperCAmelCase				).flattened_patches
															self.assertEqual(
															    encoded_images.shape ,					(1, max_patch, expected_hidden_dim) ,					)

															# Test batched
															a__	:							str      						= image_processor(
															    __UpperCAmelCase ,					return_tensors="pt" ,					max_patches=__UpperCAmelCase				).flattened_patches
															self.assertEqual(
															    encoded_images.shape ,					(self.image_processor_tester.batch_size, max_patch, expected_hidden_dim) ,					)




							def 		_A	(							self				):







											"""simple docstring"""



											a__	:							List[Any]      						= self.image_processing_class(**self.image_processor_dict				)
											# create random PyTorch tensors
											a__	:							Any      						= prepare_image_inputs(self.image_processor_tester ,					equal_resolution=__UpperCAmelCase ,					torchify=__UpperCAmelCase				)
											for image in image_inputs:
															self.assertIsInstance(__UpperCAmelCase ,					torch.Tensor				)

											# Test not batched input
											a__	:							Optional[Any]      						= (
											    (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
															a__	:							str      						= image_processor(
															    image_inputs[0] ,					return_tensors="pt" ,					max_patches=__UpperCAmelCase				).flattened_patches
															self.assertEqual(
															    encoded_images.shape ,					(1, max_patch, expected_hidden_dim) ,					)

															# Test batched
															a__	:							Optional[int]      						= image_processor(
															    __UpperCAmelCase ,					return_tensors="pt" ,					max_patches=__UpperCAmelCase				).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 				_a						(       SCREAMING_SNAKE_CASE       ,  unittest.TestCase			):





							'''simple docstring'''

							A				:List[str] =       PixaStructImageProcessor if is_vision_available() else None



							def 		_A	(							self				):







											"""simple docstring"""



											a__	:							Dict      						= PixaStructImageProcessingTester(self ,					num_channels=4				)
											a__	:							Tuple      						= 3



							@property
							def 		_A	(							self				):







											"""simple docstring"""



											return self.image_processor_tester.prepare_image_processor_dict()



							def 		_A	(							self				):







											"""simple docstring"""



											a__	:							Optional[int]      						= self.image_processing_class(**self.image_processor_dict				)
											self.assertTrue(hasattr(__UpperCAmelCase ,					"do_normalize"				)				)
											self.assertTrue(hasattr(__UpperCAmelCase ,					"do_convert_rgb"				)				)




							def 		_A	(							self				):







											"""simple docstring"""



											a__	:							Dict      						= self.image_processing_class(**self.image_processor_dict				)
											# create random PIL images
											a__	:							Union[str, Any]      						= prepare_image_inputs(self.image_processor_tester ,					equal_resolution=__UpperCAmelCase				)
											for image in image_inputs:
															self.assertIsInstance(__UpperCAmelCase ,					Image.Image				)

											# Test not batched input
											a__	:							str      						= (
											    (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
															a__	:							List[str]      						= image_processor(
															    image_inputs[0] ,					return_tensors="pt" ,					max_patches=__UpperCAmelCase				).flattened_patches
															self.assertEqual(
															    encoded_images.shape ,					(1, max_patch, expected_hidden_dim) ,					)

															# Test batched
															a__	:							int      						= image_processor(
															    __UpperCAmelCase ,					return_tensors="pt" ,					max_patches=__UpperCAmelCase				).flattened_patches
															self.assertEqual(
															    encoded_images.shape ,					(self.image_processor_tester.batch_size, max_patch, expected_hidden_dim) ,					)


