




'''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 		SCREAMING_SNAKE_CASE__  (			_UpperCamelCase	):
			__SCREAMING_SNAKE_CASE    =			["""image_processor""", """tokenizer"""]
			__SCREAMING_SNAKE_CASE    =			"""LayoutLMv3ImageProcessor"""
			__SCREAMING_SNAKE_CASE    =			("""LayoutLMv3Tokenizer""", """LayoutLMv3TokenizerFast""")





			def __init__(      self						:    int      ,		a_						:    Any=None      ,		a_						:    Union[str, Any]=None      ,		**a_						:    Any							):



						"""simple docstring"""




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

						__snake_case			=		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__(a_      ,		a_							)





			def __call__(      self						:    Union[str, Any]      ,		a_						:    int      ,		a_						:    Union[TextInput, PreTokenizedInput, List[TextInput], List[PreTokenizedInput]] = None      ,		a_						:    Optional[Union[PreTokenizedInput, List[PreTokenizedInput]]] = None      ,		a_						:    Union[List[List[int]], List[List[List[int]]]] = None      ,		a_						:    Optional[Union[List[int], List[List[int]]]] = None      ,		a_						:    bool = True      ,		a_						:    Union[bool, str, PaddingStrategy] = False      ,		a_						:    Union[bool, str, TruncationStrategy] = None      ,		a_						:    Optional[int] = None      ,		a_						:    int = 0      ,		a_						:    Optional[int] = None      ,		a_						:    Optional[bool] = None      ,		a_						:    Optional[bool] = None      ,		a_						:    bool = False      ,		a_						:    bool = False      ,		a_						:    bool = False      ,		a_						:    bool = False      ,		a_						:    bool = True      ,		a_						:    Optional[Union[str, TensorType]] = None      ,		**a_						:    int      ,		):



						"""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."							)

						# first, apply the image processor
						__snake_case			=		self.image_processor(images=a_      ,		return_tensors=a_							)

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

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

						# add pixel values
						__snake_case			=		features.pop("pixel_values"							)
						if return_overflowing_tokens is True:
									__snake_case			=		self.get_overflowing_images(a_      ,		encoded_inputs["overflow_to_sample_mapping"]							)
						__snake_case			=		images

						return encoded_inputs





			def 							A (      self						:    Union[str, Any]      ,		a_						:    str      ,		a_						:    Dict							):



						"""simple docstring"""




						__snake_case			=		[]
						for sample_idx in overflow_to_sample_mapping:
									images_with_overflow.append(images[sample_idx]							)

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

						return images_with_overflow





			def 							A (      self						:    Optional[int]      ,		*a_						:    List[Any]      ,		**a_						:    Dict							):



						"""simple docstring"""




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





			def 							A (      self						:    Any      ,		*a_						:    List[Any]      ,		**a_						:    Union[str, Any]							):



						"""simple docstring"""




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





			@property
			def 							A (      self						:    Dict							):



						"""simple docstring"""




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





			@property
			def 							A (      self						:    int							):



						"""simple docstring"""




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






			@property
			def 							A (      self						:    List[Any]							):



						"""simple docstring"""




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











import operator as op


__UpperCamelCase   :			Optional[Any]          = "scaler.pt"
__UpperCamelCase   :			Optional[Any]          = "pytorch_model"
__UpperCamelCase   :			str          = "random_states"
__UpperCamelCase   :			Optional[int]          = "optimizer"
__UpperCamelCase   :			Optional[int]          = "scheduler"
__UpperCamelCase   :			str          = "pytorch_model.bin"
__UpperCamelCase   :			List[str]          = "pytorch_model.bin.index.json"
__UpperCamelCase   :			List[str]          = "model.safetensors"
__UpperCamelCase   :			Optional[int]          = "model.safetensors.index.json"
__UpperCamelCase   :			List[str]          = "1.10.2"
__UpperCamelCase   :			Dict          = "py38"
__UpperCamelCase   :			List[str]          = "4.17.0"
__UpperCamelCase   :			Any          = ["ml.p3.16xlarge", "ml.p3dn.24xlarge", "ml.p4dn.24xlarge"]
__UpperCamelCase   :			Any          = ["FULL_SHARD", "SHARD_GRAD_OP", "NO_SHARD", "HYBRID_SHARD", "HYBRID_SHARD_ZERO2"]
__UpperCamelCase   :			int          = ["TRANSFORMER_BASED_WRAP", "SIZE_BASED_WRAP", "NO_WRAP"]
__UpperCamelCase   :			Dict          = ["BACKWARD_PRE", "BACKWARD_POST", "NO_PREFETCH"]
__UpperCamelCase   :			str          = ["FULL_STATE_DICT", "LOCAL_STATE_DICT", "SHARDED_STATE_DICT"]
__UpperCamelCase   :			List[Any]          = "2.0.1"
__UpperCamelCase   :			int          = ["pdsh", "standard", "openmpi", "mvapich"]
__UpperCamelCase   :			List[str]          = ["default", "reduce-overhead", "max-autotune"]

__UpperCamelCase   :			List[Any]          = {">": op.gt, ">=": op.ge, "==": op.eq, "!=": op.ne, "<=": op.le, "<": op.lt}

# These are the args for `torch.distributed.launch` for pytorch < 1.9
__UpperCamelCase   :			List[Any]          = [
    "nnodes",
    "nproc_per_node",
    "rdzv_backend",
    "rdzv_endpoint",
    "rdzv_id",
    "rdzv_conf",
    "standalone",
    "max_restarts",
    "monitor_interval",
    "start_method",
    "role",
    "module",
    "m",
    "no_python",
    "run_path",
    "log_dir",
    "r",
    "redirects",
    "t",
    "tee",
    "node_rank",
    "master_addr",
    "master_port",
]

__UpperCamelCase   :			List[str]          = ["DEEPSPEED", "MULTI_GPU", "FSDP", "MEGATRON_LM"]
__UpperCamelCase   :			int          = ["DEEPSPEED", "MULTI_XPU", "FSDP"]

