






"""simple docstring"""
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      UpperCamelCase_			(__A	):
	__magic_name__       =							['''image_processor''', '''tokenizer''']
	__magic_name__       =							'''LayoutLMv2ImageProcessor'''
	__magic_name__       =							('''LayoutXLMTokenizer''', '''LayoutXLMTokenizerFast''')





	def __init__( self   :					Union[str, Any]      ,      lowerCAmelCase_   :					Any=None      ,      lowerCAmelCase_   :					Dict=None      ,      **lowerCAmelCase_   :					Dict		)		->     Dict:
				if "feature_extractor" in kwargs:
							warnings.warn(
							    "The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`"
							    " instead."      ,      lowerCAmelCase_      ,      )
							UpperCAmelCase_	:					List[Any]     	=   kwargs.pop("feature_extractor"		)

				UpperCAmelCase_	:					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__(lowerCAmelCase_      ,      lowerCAmelCase_		)





	def __call__( self   :					List[Any]      ,      lowerCAmelCase_   :					Dict      ,      lowerCAmelCase_   :					Union[TextInput, PreTokenizedInput, List[TextInput], List[PreTokenizedInput]] = None      ,      lowerCAmelCase_   :					Optional[Union[PreTokenizedInput, List[PreTokenizedInput]]] = None      ,      lowerCAmelCase_   :					Union[List[List[int]], List[List[List[int]]]] = None      ,      lowerCAmelCase_   :					Optional[Union[List[int], List[List[int]]]] = None      ,      lowerCAmelCase_   :					bool = True      ,      lowerCAmelCase_   :					Union[bool, str, PaddingStrategy] = False      ,      lowerCAmelCase_   :					Union[bool, str, TruncationStrategy] = None      ,      lowerCAmelCase_   :					Optional[int] = None      ,      lowerCAmelCase_   :					int = 0      ,      lowerCAmelCase_   :					Optional[int] = None      ,      lowerCAmelCase_   :					Optional[bool] = None      ,      lowerCAmelCase_   :					Optional[bool] = None      ,      lowerCAmelCase_   :					bool = False      ,      lowerCAmelCase_   :					bool = False      ,      lowerCAmelCase_   :					bool = False      ,      lowerCAmelCase_   :					bool = False      ,      lowerCAmelCase_   :					bool = True      ,      lowerCAmelCase_   :					Optional[Union[str, TensorType]] = None      ,      **lowerCAmelCase_   :					List[str]      ,      )		->     BatchEncoding:
				# verify input
				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
				UpperCAmelCase_	:					Optional[Any]     	=   self.image_processor(images=lowerCAmelCase_      ,      return_tensors=lowerCAmelCase_		)

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

				UpperCAmelCase_	:					Tuple     	=   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=lowerCAmelCase_      ,      add_special_tokens=lowerCAmelCase_      ,      padding=lowerCAmelCase_      ,      truncation=lowerCAmelCase_      ,      max_length=lowerCAmelCase_      ,      stride=lowerCAmelCase_      ,      pad_to_multiple_of=lowerCAmelCase_      ,      return_token_type_ids=lowerCAmelCase_      ,      return_attention_mask=lowerCAmelCase_      ,      return_overflowing_tokens=lowerCAmelCase_      ,      return_special_tokens_mask=lowerCAmelCase_      ,      return_offsets_mapping=lowerCAmelCase_      ,      return_length=lowerCAmelCase_      ,      verbose=lowerCAmelCase_      ,      return_tensors=lowerCAmelCase_      ,      **lowerCAmelCase_      ,      )

				# add pixel values
				UpperCAmelCase_	:					int     	=   features.pop("pixel_values"		)
				if return_overflowing_tokens is True:
							UpperCAmelCase_	:					Union[str, Any]     	=   self.get_overflowing_images(lowerCAmelCase_      ,      encoded_inputs["overflow_to_sample_mapping"]		)
				UpperCAmelCase_	:					Optional[Any]     	=   images

				return encoded_inputs





	def 	_SCREAMING_SNAKE_CASE ( self   :					Dict      ,      lowerCAmelCase_   :					List[str]      ,      lowerCAmelCase_   :					Optional[Any]		)		->     Any:
				# in case there's an overflow, ensure each `input_ids` sample is mapped to its corresponding image
				UpperCAmelCase_	:					List[Any]     	=   []
				for sample_idx in overflow_to_sample_mapping:
							images_with_overflow.append(images[sample_idx]		)

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

				return images_with_overflow





	def 	_SCREAMING_SNAKE_CASE ( self   :					str      ,      *lowerCAmelCase_   :					Tuple      ,      **lowerCAmelCase_   :					Dict		)		->     Optional[int]:
				return self.tokenizer.batch_decode(*lowerCAmelCase_      ,      **lowerCAmelCase_		)





	def 	_SCREAMING_SNAKE_CASE ( self   :					Union[str, Any]      ,      *lowerCAmelCase_   :					Union[str, Any]      ,      **lowerCAmelCase_   :					Union[str, Any]		)		->     Union[str, Any]:
				return self.tokenizer.decode(*lowerCAmelCase_      ,      **lowerCAmelCase_		)





	@property
	def 	_SCREAMING_SNAKE_CASE ( self   :					Optional[int]		)		->     Optional[Any]:
				return ["input_ids", "bbox", "attention_mask", "image"]





	@property
	def 	_SCREAMING_SNAKE_CASE ( self   :					Tuple		)		->     Any:
				warnings.warn(
				    "`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead."      ,      lowerCAmelCase_      ,      )
				return self.image_processor_class





	@property
	def 	_SCREAMING_SNAKE_CASE ( self   :					Any		)		->     Optional[Any]:
				warnings.warn(
				    "`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead."      ,      lowerCAmelCase_      ,      )
				return self.image_processor











"""simple docstring"""
import copy
from typing import TYPE_CHECKING, Any, Mapping, Optional, OrderedDict

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging
from ..auto.configuration_auto import AutoConfig


if TYPE_CHECKING:
			from ... import PreTrainedTokenizerBase, TensorType

lowerCamelCase_							      = logging.get_logger(__name__)







class      UpperCamelCase_			(__A	):
	__magic_name__       =							'''vision-encoder-decoder'''
	__magic_name__       =							True





	def __init__( self   :					Union[str, Any]      ,      **lowerCAmelCase_   :					List[Any]		)		->     Union[str, Any]:
				super().__init__(**lowerCAmelCase_		)
				if "encoder" not in kwargs or "decoder" not in kwargs:
							raise ValueError(
							    f"""A configuraton of type {self.model_type} cannot be instantiated because """
							    f"""not both `encoder` and `decoder` sub-configurations are passed, but only {kwargs}"""		)

				UpperCAmelCase_	:					str     	=   kwargs.pop("encoder"		)
				UpperCAmelCase_	:					Dict     	=   encoder_config.pop("model_type"		)
				UpperCAmelCase_	:					List[Any]     	=   kwargs.pop("decoder"		)
				UpperCAmelCase_	:					Dict     	=   decoder_config.pop("model_type"		)

				UpperCAmelCase_	:					Union[str, Any]     	=   AutoConfig.for_model(lowerCAmelCase_      ,      **lowerCAmelCase_		)
				UpperCAmelCase_	:					List[str]     	=   AutoConfig.for_model(lowerCAmelCase_      ,      **lowerCAmelCase_		)
				UpperCAmelCase_	:					Tuple     	=   True





	@classmethod
	def 	_SCREAMING_SNAKE_CASE ( cls   :					List[str]      ,      lowerCAmelCase_   :					PretrainedConfig      ,      lowerCAmelCase_   :					PretrainedConfig      ,      **lowerCAmelCase_   :					Dict		)		->     PretrainedConfig:
				logger.info("Setting `config.is_decoder=True` and `config.add_cross_attention=True` for decoder_config"		)
				UpperCAmelCase_	:					Tuple     	=   True
				UpperCAmelCase_	:					str     	=   True

				return cls(encoder=encoder_config.to_dict()      ,      decoder=decoder_config.to_dict()      ,      **lowerCAmelCase_		)





	def 	_SCREAMING_SNAKE_CASE ( self   :					Optional[int]		)		->     List[Any]:
				UpperCAmelCase_	:					Union[str, Any]     	=   copy.deepcopy(self.__dict__		)
				UpperCAmelCase_	:					List[str]     	=   self.encoder.to_dict()
				UpperCAmelCase_	:					List[Any]     	=   self.decoder.to_dict()
				UpperCAmelCase_	:					Any     	=   self.__class__.model_type
				return output







class      UpperCamelCase_			(__A	):
	__magic_name__       =							version.parse('''1.11'''	)





	@property
	def 	_SCREAMING_SNAKE_CASE ( self   :					Union[str, Any]		)		->     Mapping[str, Mapping[int, str]]:
				return OrderedDict(
				    [
				        ("pixel_values", {0: "batch", 1: "num_channels", 2: "height", 3: "width"}),
				    ]		)





	@property
	def 	_SCREAMING_SNAKE_CASE ( self   :					Dict		)		->     float:
				return 1e-4





	@property
	def 	_SCREAMING_SNAKE_CASE ( self   :					Any		)		->     Mapping[str, Mapping[int, str]]:
				return OrderedDict({"last_hidden_state": {0: "batch", 1: "encoder_sequence"}}		)







class      UpperCamelCase_			(__A	):





	@property
	def 	_SCREAMING_SNAKE_CASE ( self   :					Dict		)		->     Mapping[str, Mapping[int, str]]:
				UpperCAmelCase_	:					List[Any]     	=   OrderedDict()
				UpperCAmelCase_	:					int     	=   {0: "batch", 1: "past_decoder_sequence + sequence"}
				UpperCAmelCase_	:					Dict     	=   {0: "batch", 1: "past_decoder_sequence + sequence"}
				UpperCAmelCase_	:					Union[str, Any]     	=   {0: "batch", 1: "encoder_sequence"}

				return common_inputs





	def 	_SCREAMING_SNAKE_CASE ( self   :					List[Any]      ,      lowerCAmelCase_   :					"PreTrainedTokenizerBase"      ,      lowerCAmelCase_   :					int = -1      ,      lowerCAmelCase_   :					int = -1      ,      lowerCAmelCase_   :					bool = False      ,      lowerCAmelCase_   :					Optional["TensorType"] = None      ,      )		->     Mapping[str, Any]:
				import torch

				UpperCAmelCase_	:					Optional[int]     	=   OrderedDict()

				UpperCAmelCase_	:					Any     	=   super().generate_dummy_inputs(
				    lowerCAmelCase_      ,      batch_size=lowerCAmelCase_      ,      seq_length=lowerCAmelCase_      ,      is_pair=lowerCAmelCase_      ,      framework=lowerCAmelCase_		)

				UpperCAmelCase_	,      UpperCAmelCase_	:					Optional[Any]     	=   dummy_input["input_ids"].shape
				UpperCAmelCase_	:					List[str]     	=   (batch, encoder_sequence, self._config.encoder_hidden_size)
				UpperCAmelCase_	:					List[str]     	=   dummy_input.pop("input_ids"		)
				UpperCAmelCase_	:					List[str]     	=   dummy_input.pop("attention_mask"		)
				UpperCAmelCase_	:					List[Any]     	=   torch.zeros(lowerCAmelCase_		)

				return common_inputs







class      UpperCamelCase_			(__A	):





	@property
	def 	_SCREAMING_SNAKE_CASE ( self   :					List[str]		)		->     None:
				pass





	def 	_SCREAMING_SNAKE_CASE ( self   :					Any      ,      lowerCAmelCase_   :					PretrainedConfig		)		->     OnnxConfig:
				return VisionEncoderDecoderEncoderOnnxConfig(lowerCAmelCase_		)





	def 	_SCREAMING_SNAKE_CASE ( self   :					Union[str, Any]      ,      lowerCAmelCase_   :					PretrainedConfig      ,      lowerCAmelCase_   :					PretrainedConfig      ,      lowerCAmelCase_   :					str = "default"		)		->     OnnxConfig:
				UpperCAmelCase_	:					Optional[int]     	=   encoder_config.hidden_size
				return VisionEncoderDecoderDecoderOnnxConfig(lowerCAmelCase_      ,      lowerCAmelCase_		)



