


'''simple docstring'''

import copy
import unittest

from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
     import torch

     from transformers import (
         MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
         MODEL_FOR_QUESTION_ANSWERING_MAPPING,
         MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
         MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
         LayoutLMvaConfig,
         LayoutLMvaForQuestionAnswering,
         LayoutLMvaForSequenceClassification,
         LayoutLMvaForTokenClassification,
         LayoutLMvaModel,
     )
     from transformers.models.layoutlmva.modeling_layoutlmva import LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
     from PIL import Image

     from transformers import LayoutLMvaImageProcessor





class      snake_case    :





  """simple docstring"""




  def __init__(    self			,  UpperCamelCase			,  UpperCamelCase=2			,  UpperCamelCase=3			,  UpperCamelCase=4			,  UpperCamelCase=2			,  UpperCamelCase=7			,  UpperCamelCase=True			,  UpperCamelCase=True			,  UpperCamelCase=True			,  UpperCamelCase=True			,  UpperCamelCase=99			,  UpperCamelCase=36			,  UpperCamelCase=3			,  UpperCamelCase=4			,  UpperCamelCase=37			,  UpperCamelCase="gelu"			,  UpperCamelCase=0.1			,  UpperCamelCase=0.1			,  UpperCamelCase=512			,  UpperCamelCase=16			,  UpperCamelCase=2			,  UpperCamelCase=0.02			,  UpperCamelCase=6			,  UpperCamelCase=6			,  UpperCamelCase=3			,  UpperCamelCase=4			,  UpperCamelCase=None			,  UpperCamelCase=1000			,  ):







   """simple docstring"""
   lowerCamelCase_      =  parent
   lowerCamelCase_      =  batch_size
   lowerCamelCase_      =  num_channels
   lowerCamelCase_      =  image_size
   lowerCamelCase_      =  patch_size
   lowerCamelCase_      =  text_seq_length
   lowerCamelCase_      =  is_training
   lowerCamelCase_      =  use_input_mask
   lowerCamelCase_      =  use_token_type_ids
   lowerCamelCase_      =  use_labels
   lowerCamelCase_      =  vocab_size
   lowerCamelCase_      =  hidden_size
   lowerCamelCase_      =  num_hidden_layers
   lowerCamelCase_      =  num_attention_heads
   lowerCamelCase_      =  intermediate_size
   lowerCamelCase_      =  hidden_act
   lowerCamelCase_      =  hidden_dropout_prob
   lowerCamelCase_      =  attention_probs_dropout_prob
   lowerCamelCase_      =  max_position_embeddings
   lowerCamelCase_      =  type_vocab_size
   lowerCamelCase_      =  type_sequence_label_size
   lowerCamelCase_      =  initializer_range
   lowerCamelCase_      =  coordinate_size
   lowerCamelCase_      =  shape_size
   lowerCamelCase_      =  num_labels
   lowerCamelCase_      =  num_choices
   lowerCamelCase_      =  scope
   lowerCamelCase_      =  range_bbox

   # LayoutLMv3's sequence length equals the number of text tokens + number of patches + 1 (we add 1 for the CLS token)
   lowerCamelCase_      =  text_seq_length
   lowerCamelCase_      =  (image_size // patch_size) ** 2 + 1
   lowerCamelCase_      =  self.text_seq_length + self.image_seq_length






  def   snake_case		(    self     ):







   """simple docstring"""
   lowerCamelCase_      =  ids_tensor([self.batch_size, self.text_seq_length]			,  self.vocab_size     )

   lowerCamelCase_      =  ids_tensor([self.batch_size, self.text_seq_length, 4]			,  self.range_bbox     )
   # Ensure that bbox is legal
   for i in range(bbox.shape[0]     ):
    for j in range(bbox.shape[1]     ):
     if bbox[i, j, 3] < bbox[i, j, 1]:
      lowerCamelCase_      =  bbox[i, j, 3]
      lowerCamelCase_      =  bbox[i, j, 1]
      lowerCamelCase_      =  t
     if bbox[i, j, 2] < bbox[i, j, 0]:
      lowerCamelCase_      =  bbox[i, j, 2]
      lowerCamelCase_      =  bbox[i, j, 0]
      lowerCamelCase_      =  t

   lowerCamelCase_      =  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]     )

   lowerCamelCase_      =  None
   if self.use_input_mask:
    lowerCamelCase_      =  random_attention_mask([self.batch_size, self.text_seq_length]     )

   lowerCamelCase_      =  None
   if self.use_token_type_ids:
    lowerCamelCase_      =  ids_tensor([self.batch_size, self.text_seq_length]			,  self.type_vocab_size     )

   lowerCamelCase_      =  None
   lowerCamelCase_      =  None
   if self.use_labels:
    lowerCamelCase_      =  ids_tensor([self.batch_size]			,  self.type_sequence_label_size     )
    lowerCamelCase_      =  ids_tensor([self.batch_size, self.text_seq_length]			,  self.num_labels     )

   lowerCamelCase_      =  LayoutLMvaConfig(
       vocab_size=self.vocab_size			,  hidden_size=self.hidden_size			,  num_hidden_layers=self.num_hidden_layers			,  num_attention_heads=self.num_attention_heads			,  intermediate_size=self.intermediate_size			,  hidden_act=self.hidden_act			,  hidden_dropout_prob=self.hidden_dropout_prob			,  attention_probs_dropout_prob=self.attention_probs_dropout_prob			,  max_position_embeddings=self.max_position_embeddings			,  type_vocab_size=self.type_vocab_size			,  initializer_range=self.initializer_range			,  coordinate_size=self.coordinate_size			,  shape_size=self.shape_size			,  input_size=self.image_size			,  patch_size=self.patch_size			,  )

   return config, input_ids, bbox, pixel_values, token_type_ids, input_mask, sequence_labels, token_labels






  def   snake_case		(    self			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase     ):







   """simple docstring"""
   lowerCamelCase_      =  LayoutLMvaModel(config=UpperCamelCase     )
   model.to(UpperCamelCase     )
   model.eval()

   # text + image
   lowerCamelCase_      =  model(UpperCamelCase			,  pixel_values=UpperCamelCase     )
   lowerCamelCase_      =  model(
       UpperCamelCase			,  bbox=UpperCamelCase			,  pixel_values=UpperCamelCase			,  attention_mask=UpperCamelCase			,  token_type_ids=UpperCamelCase     )
   lowerCamelCase_      =  model(UpperCamelCase			,  bbox=UpperCamelCase			,  pixel_values=UpperCamelCase			,  token_type_ids=UpperCamelCase     )
   lowerCamelCase_      =  model(UpperCamelCase			,  bbox=UpperCamelCase			,  pixel_values=UpperCamelCase     )

   self.parent.assertEqual(result.last_hidden_state.shape			,  (self.batch_size, self.seq_length, self.hidden_size)     )

   # text only
   lowerCamelCase_      =  model(UpperCamelCase     )
   self.parent.assertEqual(
       result.last_hidden_state.shape			,  (self.batch_size, self.text_seq_length, self.hidden_size)     )

   # image only
   lowerCamelCase_      =  model(pixel_values=UpperCamelCase     )
   self.parent.assertEqual(
       result.last_hidden_state.shape			,  (self.batch_size, self.image_seq_length, self.hidden_size)     )






  def   snake_case		(    self			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase     ):







   """simple docstring"""
   lowerCamelCase_      =  self.num_labels
   lowerCamelCase_      =  LayoutLMvaForSequenceClassification(UpperCamelCase     )
   model.to(UpperCamelCase     )
   model.eval()
   lowerCamelCase_      =  model(
       UpperCamelCase			,  bbox=UpperCamelCase			,  pixel_values=UpperCamelCase			,  attention_mask=UpperCamelCase			,  token_type_ids=UpperCamelCase			,  labels=UpperCamelCase			,  )
   self.parent.assertEqual(result.logits.shape			,  (self.batch_size, self.num_labels)     )






  def   snake_case		(    self			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase     ):







   """simple docstring"""
   lowerCamelCase_      =  self.num_labels
   lowerCamelCase_      =  LayoutLMvaForTokenClassification(config=UpperCamelCase     )
   model.to(UpperCamelCase     )
   model.eval()
   lowerCamelCase_      =  model(
       UpperCamelCase			,  bbox=UpperCamelCase			,  pixel_values=UpperCamelCase			,  attention_mask=UpperCamelCase			,  token_type_ids=UpperCamelCase			,  labels=UpperCamelCase			,  )
   self.parent.assertEqual(result.logits.shape			,  (self.batch_size, self.text_seq_length, self.num_labels)     )






  def   snake_case		(    self			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase     ):







   """simple docstring"""
   lowerCamelCase_      =  LayoutLMvaForQuestionAnswering(config=UpperCamelCase     )
   model.to(UpperCamelCase     )
   model.eval()
   lowerCamelCase_      =  model(
       UpperCamelCase			,  bbox=UpperCamelCase			,  pixel_values=UpperCamelCase			,  attention_mask=UpperCamelCase			,  token_type_ids=UpperCamelCase			,  start_positions=UpperCamelCase			,  end_positions=UpperCamelCase			,  )
   self.parent.assertEqual(result.start_logits.shape			,  (self.batch_size, self.seq_length)     )
   self.parent.assertEqual(result.end_logits.shape			,  (self.batch_size, self.seq_length)     )







  def   snake_case		(    self     ):







   """simple docstring"""
   lowerCamelCase_      =  self.prepare_config_and_inputs()
   (
       (
       lowerCamelCase_
   ) ,(
       lowerCamelCase_
   ) ,(
       lowerCamelCase_
   ) ,(
       lowerCamelCase_
   ) ,(
       lowerCamelCase_
   ) ,(
       lowerCamelCase_
   ) ,(
       lowerCamelCase_
   ) ,(
       lowerCamelCase_
   ) ,
   )      =  config_and_inputs
   lowerCamelCase_      =  {
       "input_ids": input_ids,
       "bbox": bbox,
       "pixel_values": pixel_values,
       "token_type_ids": token_type_ids,
       "attention_mask": input_mask,
   }
   return config, inputs_dict





@require_torch
class      snake_case    (    lowercase			,						lowercase			,						unittest.TestCase			):





  """simple docstring"""




  _lowerCamelCase		    =  False
  _lowerCamelCase		    =  False
  _lowerCamelCase		    =  False

  _lowerCamelCase		    =  (
      (
          LayoutLMvaModel,
          LayoutLMvaForSequenceClassification,
          LayoutLMvaForTokenClassification,
          LayoutLMvaForQuestionAnswering,
      )
      if is_torch_available()
      else ()
  )
  _lowerCamelCase		    =  (
      {"document-question-answering": LayoutLMvaForQuestionAnswering, "feature-extraction": LayoutLMvaModel}
      if is_torch_available()
      else {}
  )






  def   snake_case		(    self			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase     ):







   """simple docstring"""
   # `DocumentQuestionAnsweringPipeline` is expected to work with this model, but it combines the text and visual
   # embedding along the sequence dimension (dim 1), which causes an error during post-processing as `p_mask` has
   # the sequence dimension of the text embedding only.
   # (see the line `embedding_output = torch.cat([embedding_output, visual_embeddings], dim=1)`)
   return True






  def   snake_case		(    self     ):







   """simple docstring"""
   lowerCamelCase_      =  LayoutLMvaModelTester(self     )
   lowerCamelCase_      =  ConfigTester(self			,  config_class=UpperCamelCase			,  hidden_size=37     )






  def   snake_case		(    self			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase=False     ):







   """simple docstring"""
   lowerCamelCase_      =  copy.deepcopy(UpperCamelCase     )
   if model_class in get_values(UpperCamelCase     ):
    lowerCamelCase_      =  {
        k: v.unsqueeze(1     ).expand(-1			,  self.model_tester.num_choices			,  -1     ).contiguous()
        if isinstance(UpperCamelCase			,  torch.Tensor     ) and v.ndim > 1
        else v
        for k, v in inputs_dict.items()
    }
   if return_labels:
    if model_class in get_values(UpperCamelCase     ):
     lowerCamelCase_      =  torch.ones(self.model_tester.batch_size			,  dtype=torch.long			,  device=UpperCamelCase     )
    elif model_class in get_values(UpperCamelCase     ):
     lowerCamelCase_      =  torch.zeros(
         self.model_tester.batch_size			,  dtype=torch.long			,  device=UpperCamelCase     )
     lowerCamelCase_      =  torch.zeros(
         self.model_tester.batch_size			,  dtype=torch.long			,  device=UpperCamelCase     )
    elif model_class in [
        *get_values(UpperCamelCase     ),
    ]:
     lowerCamelCase_      =  torch.zeros(
         self.model_tester.batch_size			,  dtype=torch.long			,  device=UpperCamelCase     )
    elif model_class in [
        *get_values(UpperCamelCase     ),
    ]:
     lowerCamelCase_      =  torch.zeros(
         (self.model_tester.batch_size, self.model_tester.text_seq_length)			,  dtype=torch.long			,  device=UpperCamelCase			,  )

   return inputs_dict






  def   snake_case		(    self     ):







   """simple docstring"""
   self.config_tester.run_common_tests()






  def   snake_case		(    self     ):







   """simple docstring"""
   lowerCamelCase_      =  self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_model(*UpperCamelCase     )






  def   snake_case		(    self     ):







   """simple docstring"""
   lowerCamelCase_      =  self.model_tester.prepare_config_and_inputs()
   for type in ["absolute", "relative_key", "relative_key_query"]:
    lowerCamelCase_      =  type
    self.model_tester.create_and_check_model(*UpperCamelCase     )






  def   snake_case		(    self     ):







   """simple docstring"""
   lowerCamelCase_      =  self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_sequence_classification(*UpperCamelCase     )






  def   snake_case		(    self     ):







   """simple docstring"""
   lowerCamelCase_      =  self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_token_classification(*UpperCamelCase     )






  def   snake_case		(    self     ):







   """simple docstring"""
   lowerCamelCase_      =  self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_question_answering(*UpperCamelCase     )







  @slow
  def   snake_case		(    self     ):







   """simple docstring"""
   for model_name in LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
    lowerCamelCase_      =  LayoutLMvaModel.from_pretrained(UpperCamelCase     )
    self.assertIsNotNone(UpperCamelCase     )





def __snake_case					(      ):
 lowerCamelCase_      =  Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"		)
 return image







@require_torch
class      snake_case    (    unittest.TestCase			):





  """simple docstring"""




  @cached_property
  def   snake_case		(    self     ):







   """simple docstring"""
   return LayoutLMvaImageProcessor(apply_ocr=UpperCamelCase     ) if is_vision_available() else None







  @slow
  def   snake_case		(    self     ):







   """simple docstring"""
   lowerCamelCase_      =  LayoutLMvaModel.from_pretrained("microsoft/layoutlmv3-base"     ).to(UpperCamelCase     )

   lowerCamelCase_      =  self.default_image_processor
   lowerCamelCase_      =  prepare_img()
   lowerCamelCase_      =  image_processor(images=UpperCamelCase			,  return_tensors="pt"     ).pixel_values.to(UpperCamelCase     )

   lowerCamelCase_      =  torch.tensor([[1, 2]]     )
   lowerCamelCase_      =  torch.tensor([[1, 2, 3, 4], [5, 6, 7, 8]]     ).unsqueeze(0     )

   # forward pass
   lowerCamelCase_      =  model(
       input_ids=input_ids.to(UpperCamelCase     )			,  bbox=bbox.to(UpperCamelCase     )			,  pixel_values=pixel_values.to(UpperCamelCase     )			,  )

   # verify the logits
   lowerCamelCase_      =  torch.Size((1, 199, 768)     )
   self.assertEqual(outputs.last_hidden_state.shape			,  UpperCamelCase     )

   lowerCamelCase_      =  torch.tensor(
       [[-0.0_529, 0.3_618, 0.1_632], [-0.1_587, -0.1_667, -0.0_400], [-0.1_557, -0.1_671, -0.0_505]]     ).to(UpperCamelCase     )

   self.assertTrue(torch.allclose(outputs.last_hidden_state[0, :3, :3]			,  UpperCamelCase			,  atol=1e-4     )     )






"""simple docstring"""


from __future__ import annotations






def     a__    (    __SCREAMING_SNAKE_CASE )	->	bool:
		__lowerCAmelCase:       Tuple          =			str(__SCREAMING_SNAKE_CASE )
		return len(__SCREAMING_SNAKE_CASE ) == 9 and set(__SCREAMING_SNAKE_CASE ) == set("123456789" )






def     a__    (    )	->	int | None:
		for base_num in range(9_9_9_9					, 4_9_9_9					, -1 ):
				__lowerCAmelCase:       Tuple          =			1_0_0_0_0_2 * base_num
				if is_9_pandigital(__SCREAMING_SNAKE_CASE ):
						return candidate

		for base_num in range(3_3_3					, 9_9					, -1 ):
				__lowerCAmelCase:       int          =			1_0_0_2_0_0_3 * base_num
				if is_9_pandigital(__SCREAMING_SNAKE_CASE ):
						return candidate

		return None


if __name__ == "__main__":
			print(F'''{solution() = }''')


