




'''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__  ):







						"""simple docstring"""


						_lowerCAmelCase         =       ['image_processor', 'tokenizer']
						_lowerCAmelCase         =       'LayoutLMv2ImageProcessor'
						_lowerCAmelCase         =       ('LayoutLMv2Tokenizer', 'LayoutLMv2TokenizerFast')







						def __init__(  self   :							Union[str, Any]				,			_lowerCamelCase   :							Optional[Any]=None				,			_lowerCamelCase   :							Union[str, Any]=None				,			**_lowerCamelCase   :							Tuple     ):





											"""simple docstring"""







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

											A_			:  Dict			=				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   :							Optional[int]				,			_lowerCamelCase   :							Optional[int]				,			_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] = False				,			_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   :							Optional[Any]				,			):





											"""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_			:  Tuple			=				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     ):
																					A_			:  List[str]			=				[text]  # add batch dimension (as the image processor always adds a batch dimension)
																A_			:  Any			=				features['''words''']

											A_			:  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=_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
											A_			:  List[Any]			=				features.pop('''pixel_values'''     )
											if return_overflowing_tokens is True:
																A_			:  Dict			=				self.get_overflowing_images(_lowerCamelCase				,			encoded_inputs['''overflow_to_sample_mapping''']     )
											A_			:  Union[str, Any]			=				images

											return encoded_inputs







						def    _a     (  self   :							str				,			_lowerCamelCase   :							Any				,			_lowerCamelCase   :							int     ):





											"""simple docstring"""







											A_			:  Union[str, 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    _a     (  self   :							Union[str, Any]				,			*_lowerCamelCase   :							List[Any]				,			**_lowerCamelCase   :							List[Any]     ):





											"""simple docstring"""







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







						def    _a     (  self   :							Optional[int]				,			*_lowerCamelCase   :							Optional[int]				,			**_lowerCamelCase   :							Dict     ):





											"""simple docstring"""







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







						@property
						def    _a     (  self   :							Optional[Any]     ):





											"""simple docstring"""







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







						@property
						def    _a     (  self   :							Union[str, Any]     ):





											"""simple docstring"""







											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    _a     (  self   :							Optional[Any]     ):





											"""simple docstring"""







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









'''simple docstring'''




from typing import TYPE_CHECKING

from ..utils import OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_tf_available, is_torch_available


snake_case__ 							=    {
    """configuration_utils""": ["""GenerationConfig"""],
    """streamers""": ["""TextIteratorStreamer""", """TextStreamer"""],
}

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							snake_case__ 							=    [
							    """Constraint""",
							    """ConstraintListState""",
							    """DisjunctiveConstraint""",
							    """PhrasalConstraint""",
							]
							snake_case__ 							=    [
							    """BeamHypotheses""",
							    """BeamScorer""",
							    """BeamSearchScorer""",
							    """ConstrainedBeamSearchScorer""",
							]
							snake_case__ 							=    [
							    """EpsilonLogitsWarper""",
							    """EtaLogitsWarper""",
							    """ForcedBOSTokenLogitsProcessor""",
							    """ForcedEOSTokenLogitsProcessor""",
							    """HammingDiversityLogitsProcessor""",
							    """InfNanRemoveLogitsProcessor""",
							    """LogitsProcessor""",
							    """LogitsProcessorList""",
							    """LogitsWarper""",
							    """MinLengthLogitsProcessor""",
							    """MinNewTokensLengthLogitsProcessor""",
							    """NoBadWordsLogitsProcessor""",
							    """NoRepeatNGramLogitsProcessor""",
							    """PrefixConstrainedLogitsProcessor""",
							    """RepetitionPenaltyLogitsProcessor""",
							    """SequenceBiasLogitsProcessor""",
							    """EncoderRepetitionPenaltyLogitsProcessor""",
							    """TemperatureLogitsWarper""",
							    """TopKLogitsWarper""",
							    """TopPLogitsWarper""",
							    """TypicalLogitsWarper""",
							    """EncoderNoRepeatNGramLogitsProcessor""",
							    """ExponentialDecayLengthPenalty""",
							    """LogitNormalization""",
							]
							snake_case__ 							=    [
							    """MaxNewTokensCriteria""",
							    """MaxLengthCriteria""",
							    """MaxTimeCriteria""",
							    """StoppingCriteria""",
							    """StoppingCriteriaList""",
							    """validate_stopping_criteria""",
							]
							snake_case__ 							=    [
							    """GenerationMixin""",
							    """top_k_top_p_filtering""",
							    """GreedySearchEncoderDecoderOutput""",
							    """GreedySearchDecoderOnlyOutput""",
							    """SampleEncoderDecoderOutput""",
							    """SampleDecoderOnlyOutput""",
							    """BeamSearchEncoderDecoderOutput""",
							    """BeamSearchDecoderOnlyOutput""",
							    """BeamSampleEncoderDecoderOutput""",
							    """BeamSampleDecoderOnlyOutput""",
							    """ContrastiveSearchEncoderDecoderOutput""",
							    """ContrastiveSearchDecoderOnlyOutput""",
							]

try:
							if not is_tf_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							snake_case__ 							=    [
							    """TFForcedBOSTokenLogitsProcessor""",
							    """TFForcedEOSTokenLogitsProcessor""",
							    """TFLogitsProcessor""",
							    """TFLogitsProcessorList""",
							    """TFLogitsWarper""",
							    """TFMinLengthLogitsProcessor""",
							    """TFNoBadWordsLogitsProcessor""",
							    """TFNoRepeatNGramLogitsProcessor""",
							    """TFRepetitionPenaltyLogitsProcessor""",
							    """TFTemperatureLogitsWarper""",
							    """TFTopKLogitsWarper""",
							    """TFTopPLogitsWarper""",
							    """TFForceTokensLogitsProcessor""",
							    """TFSuppressTokensAtBeginLogitsProcessor""",
							    """TFSuppressTokensLogitsProcessor""",
							]
							snake_case__ 							=    [
							    """TFGenerationMixin""",
							    """tf_top_k_top_p_filtering""",
							    """TFGreedySearchDecoderOnlyOutput""",
							    """TFGreedySearchEncoderDecoderOutput""",
							    """TFSampleEncoderDecoderOutput""",
							    """TFSampleDecoderOnlyOutput""",
							    """TFBeamSearchEncoderDecoderOutput""",
							    """TFBeamSearchDecoderOnlyOutput""",
							    """TFBeamSampleEncoderDecoderOutput""",
							    """TFBeamSampleDecoderOnlyOutput""",
							    """TFContrastiveSearchEncoderDecoderOutput""",
							    """TFContrastiveSearchDecoderOnlyOutput""",
							]

try:
							if not is_flax_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							snake_case__ 							=    [
							    """FlaxForcedBOSTokenLogitsProcessor""",
							    """FlaxForcedEOSTokenLogitsProcessor""",
							    """FlaxLogitsProcessor""",
							    """FlaxLogitsProcessorList""",
							    """FlaxLogitsWarper""",
							    """FlaxMinLengthLogitsProcessor""",
							    """FlaxTemperatureLogitsWarper""",
							    """FlaxTopKLogitsWarper""",
							    """FlaxTopPLogitsWarper""",
							]
							snake_case__ 							=    [
							    """FlaxGenerationMixin""",
							    """FlaxGreedySearchOutput""",
							    """FlaxSampleOutput""",
							    """FlaxBeamSearchOutput""",
							]

if TYPE_CHECKING:
							from .configuration_utils import GenerationConfig
							from .streamers import TextIteratorStreamer, TextStreamer

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .beam_constraints import Constraint, ConstraintListState, DisjunctiveConstraint, PhrasalConstraint
														from .beam_search import BeamHypotheses, BeamScorer, BeamSearchScorer, ConstrainedBeamSearchScorer
														from .logits_process import (
														    EncoderNoRepeatNGramLogitsProcessor,
														    EncoderRepetitionPenaltyLogitsProcessor,
														    EpsilonLogitsWarper,
														    EtaLogitsWarper,
														    ExponentialDecayLengthPenalty,
														    ForcedBOSTokenLogitsProcessor,
														    ForcedEOSTokenLogitsProcessor,
														    HammingDiversityLogitsProcessor,
														    InfNanRemoveLogitsProcessor,
														    LogitNormalization,
														    LogitsProcessor,
														    LogitsProcessorList,
														    LogitsWarper,
														    MinLengthLogitsProcessor,
														    MinNewTokensLengthLogitsProcessor,
														    NoBadWordsLogitsProcessor,
														    NoRepeatNGramLogitsProcessor,
														    PrefixConstrainedLogitsProcessor,
														    RepetitionPenaltyLogitsProcessor,
														    SequenceBiasLogitsProcessor,
														    TemperatureLogitsWarper,
														    TopKLogitsWarper,
														    TopPLogitsWarper,
														    TypicalLogitsWarper,
														)
														from .stopping_criteria import (
														    MaxLengthCriteria,
														    MaxNewTokensCriteria,
														    MaxTimeCriteria,
														    StoppingCriteria,
														    StoppingCriteriaList,
														    validate_stopping_criteria,
														)
														from .utils import (
														    BeamSampleDecoderOnlyOutput,
														    BeamSampleEncoderDecoderOutput,
														    BeamSearchDecoderOnlyOutput,
														    BeamSearchEncoderDecoderOutput,
														    ContrastiveSearchDecoderOnlyOutput,
														    ContrastiveSearchEncoderDecoderOutput,
														    GenerationMixin,
														    GreedySearchDecoderOnlyOutput,
														    GreedySearchEncoderDecoderOutput,
														    SampleDecoderOnlyOutput,
														    SampleEncoderDecoderOutput,
														    top_k_top_p_filtering,
														)

							try:
														if not is_tf_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .tf_logits_process import (
														    TFForcedBOSTokenLogitsProcessor,
														    TFForcedEOSTokenLogitsProcessor,
														    TFForceTokensLogitsProcessor,
														    TFLogitsProcessor,
														    TFLogitsProcessorList,
														    TFLogitsWarper,
														    TFMinLengthLogitsProcessor,
														    TFNoBadWordsLogitsProcessor,
														    TFNoRepeatNGramLogitsProcessor,
														    TFRepetitionPenaltyLogitsProcessor,
														    TFSuppressTokensAtBeginLogitsProcessor,
														    TFSuppressTokensLogitsProcessor,
														    TFTemperatureLogitsWarper,
														    TFTopKLogitsWarper,
														    TFTopPLogitsWarper,
														)
														from .tf_utils import (
														    TFBeamSampleDecoderOnlyOutput,
														    TFBeamSampleEncoderDecoderOutput,
														    TFBeamSearchDecoderOnlyOutput,
														    TFBeamSearchEncoderDecoderOutput,
														    TFContrastiveSearchDecoderOnlyOutput,
														    TFContrastiveSearchEncoderDecoderOutput,
														    TFGenerationMixin,
														    TFGreedySearchDecoderOnlyOutput,
														    TFGreedySearchEncoderDecoderOutput,
														    TFSampleDecoderOnlyOutput,
														    TFSampleEncoderDecoderOutput,
														    tf_top_k_top_p_filtering,
														)

							try:
														if not is_flax_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .flax_logits_process import (
														    FlaxForcedBOSTokenLogitsProcessor,
														    FlaxForcedEOSTokenLogitsProcessor,
														    FlaxLogitsProcessor,
														    FlaxLogitsProcessorList,
														    FlaxLogitsWarper,
														    FlaxMinLengthLogitsProcessor,
														    FlaxTemperatureLogitsWarper,
														    FlaxTopKLogitsWarper,
														    FlaxTopPLogitsWarper,
														)
														from .flax_utils import FlaxBeamSearchOutput, FlaxGenerationMixin, FlaxGreedySearchOutput, FlaxSampleOutput
else:
							import sys

							snake_case__ 							=    _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)



