
def 						SCREAMING_SNAKE_CASE__     (   __lowerCAmelCase				):
    assert column_title.isupper()
    snake_case__    =					0
    snake_case__    =					len(__lowerCAmelCase				) - 1
    snake_case__    =					0

    while index >= 0:
        snake_case__    =					(ord(column_title[index]				) - 64) * pow(26     ,		__lowerCAmelCase				)
        answer += value
        power += 1
        index -= 1

    return answer


if __name__ == "__main__":
     from doctest import testmod

     testmod()





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			):
      _A    :		Optional[int]     						=  ['image_processor', 'tokenizer']
      _A    :		List[Any]     						=  'LayoutLMv2ImageProcessor'
      _A    :		Dict     						=  ('LayoutXLMTokenizer', 'LayoutXLMTokenizerFast')
      def __init__(      self		,						lowerCamelCase=None		,						lowerCamelCase=None		,						**lowerCamelCase			):
          if "feature_extractor" in kwargs:
              warnings.warn(
                  "The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`"
                  " instead."		,						lowerCamelCase		,						)
              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__(lowerCamelCase		,						lowerCamelCase			)
      def __call__(      self		,						lowerCamelCase		,						lowerCamelCase = None		,						lowerCamelCase = None		,						lowerCamelCase = None		,						lowerCamelCase = None		,						lowerCamelCase = True		,						lowerCamelCase = False		,						lowerCamelCase = None		,						lowerCamelCase = None		,						lowerCamelCase = 0		,						lowerCamelCase = None		,						lowerCamelCase = None		,						lowerCamelCase = None		,						lowerCamelCase = False		,						lowerCamelCase = False		,						lowerCamelCase = False		,						lowerCamelCase = False		,						lowerCamelCase = True		,						lowerCamelCase = None		,						**lowerCamelCase		,						):
          # 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
          snake_case__    =					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			):
                  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=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
          snake_case__    =					features.pop("pixel_values"			)
          if return_overflowing_tokens is True:
              snake_case__    =					self.get_overflowing_images(lowerCamelCase		,						encoded_inputs["overflow_to_sample_mapping"]			)
          snake_case__    =					images

          return encoded_inputs
      def A_      (      self		,						lowerCamelCase		,						lowerCamelCase			):
          # in case there's an overflow, ensure each `input_ids` sample is mapped to its corresponding image
          snake_case__    =					[]
          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		,						*lowerCamelCase		,						**lowerCamelCase			):
          return self.tokenizer.batch_decode(*lowerCamelCase		,						**lowerCamelCase			)
      def A_      (      self		,						*lowerCamelCase		,						**lowerCamelCase			):
          return self.tokenizer.decode(*lowerCamelCase		,						**lowerCamelCase			)
      @property
      def A_      (      self			):
          return ["input_ids", "bbox", "attention_mask", "image"]
      @property
      def A_      (      self			):
          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			):
          warnings.warn(
              "`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead."		,						lowerCamelCase		,						)
          return self.image_processor



