import os
import unittest

from transformers import BertTokenizerFast
from transformers.models.bert.tokenization_bert import (
    VOCAB_FILES_NAMES,
    BasicTokenizer,
    BertTokenizer,
    WordpieceTokenizer,
    _is_control,
    _is_punctuation,
    _is_whitespace,
)
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin, filter_non_english



@require_tokenizers
class        lowerCamelCase__				(   UpperCAmelCase       ,unittest.TestCase				):
			UpperCamelCase__    							=BertTokenizer
			UpperCamelCase__    							=BertTokenizerFast
			UpperCamelCase__    							=True
			UpperCamelCase__    							=True
			UpperCamelCase__    							=filter_non_english





			def   SCREAMING_SNAKE_CASE__     (       self	:	List[Any]						):
										super().setUp()

										_lowerCAmelCase							=							[
										    '[UNK]',
										    '[CLS]',
										    '[SEP]',
										    '[PAD]',
										    '[MASK]',
										    'want',
										    '##want',
										    '##ed',
										    'wa',
										    'un',
										    'runn',
										    '##ing',
										    ',',
										    'low',
										    'lowest',
										]
										_lowerCAmelCase							=							os.path.join(self.tmpdirname  ,  VOCAB_FILES_NAMES['vocab_file']						)
										with open(self.vocab_file  ,  'w'  ,  encoding='utf-8'						) as vocab_writer:
																	vocab_writer.write(''.join([x + '\n' for x in vocab_tokens]						)						)





			def   SCREAMING_SNAKE_CASE__     (       self	:	Optional[int]  ,  lowercase__	:	List[Any]						):
										_lowerCAmelCase							=							'UNwant\u00E9d,running'
										_lowerCAmelCase							=							'unwanted, running'
										return input_text, output_text





			def   SCREAMING_SNAKE_CASE__     (       self	:	List[str]						):
										_lowerCAmelCase							=							self.tokenizer_class(self.vocab_file						)

										_lowerCAmelCase							=							tokenizer.tokenize('UNwant\u00E9d,running'						)
										self.assertListEqual(lowercase__  ,  ['un', '##want', '##ed', ',', 'runn', '##ing']						)
										self.assertListEqual(tokenizer.convert_tokens_to_ids(lowercase__						)  ,  [9, 6, 7, 12, 10, 11]						)





			def   SCREAMING_SNAKE_CASE__     (       self	:	Optional[int]						):
										if not self.test_rust_tokenizer:
																	return

										_lowerCAmelCase							=							self.get_tokenizer()
										_lowerCAmelCase							=							self.get_rust_tokenizer()

										_lowerCAmelCase							=							'UNwant\u00E9d,running'

										_lowerCAmelCase							=							tokenizer.tokenize(lowercase__						)
										_lowerCAmelCase							=							rust_tokenizer.tokenize(lowercase__						)
										self.assertListEqual(lowercase__  ,  lowercase__						)

										_lowerCAmelCase							=							tokenizer.encode(lowercase__  ,  add_special_tokens=lowercase__						)
										_lowerCAmelCase							=							rust_tokenizer.encode(lowercase__  ,  add_special_tokens=lowercase__						)
										self.assertListEqual(lowercase__  ,  lowercase__						)

										_lowerCAmelCase							=							self.get_rust_tokenizer()
										_lowerCAmelCase							=							tokenizer.encode(lowercase__						)
										_lowerCAmelCase							=							rust_tokenizer.encode(lowercase__						)
										self.assertListEqual(lowercase__  ,  lowercase__						)

										# With lower casing
										_lowerCAmelCase							=							self.get_tokenizer(do_lower_case=lowercase__						)
										_lowerCAmelCase							=							self.get_rust_tokenizer(do_lower_case=lowercase__						)

										_lowerCAmelCase							=							'UNwant\u00E9d,running'

										_lowerCAmelCase							=							tokenizer.tokenize(lowercase__						)
										_lowerCAmelCase							=							rust_tokenizer.tokenize(lowercase__						)
										self.assertListEqual(lowercase__  ,  lowercase__						)

										_lowerCAmelCase							=							tokenizer.encode(lowercase__  ,  add_special_tokens=lowercase__						)
										_lowerCAmelCase							=							rust_tokenizer.encode(lowercase__  ,  add_special_tokens=lowercase__						)
										self.assertListEqual(lowercase__  ,  lowercase__						)

										_lowerCAmelCase							=							self.get_rust_tokenizer()
										_lowerCAmelCase							=							tokenizer.encode(lowercase__						)
										_lowerCAmelCase							=							rust_tokenizer.encode(lowercase__						)
										self.assertListEqual(lowercase__  ,  lowercase__						)





			def   SCREAMING_SNAKE_CASE__     (       self	:	str						):
										_lowerCAmelCase							=							BasicTokenizer()

										self.assertListEqual(tokenizer.tokenize('ah\u535A\u63A8zz'						)  ,  ['ah', '\u535A', '\u63A8', 'zz']						)





			def   SCREAMING_SNAKE_CASE__     (       self	:	List[Any]						):
										_lowerCAmelCase							=							BasicTokenizer(do_lower_case=lowercase__						)

										self.assertListEqual(
										    tokenizer.tokenize(' \tHeLLo!how  \n Are yoU?  '						)  ,  ['hello', '!', 'how', 'are', 'you', '?']						)
										self.assertListEqual(tokenizer.tokenize('H\u00E9llo'						)  ,  ['hello']						)





			def   SCREAMING_SNAKE_CASE__     (       self	:	Dict						):
										_lowerCAmelCase							=							BasicTokenizer(do_lower_case=lowercase__  ,  strip_accents=lowercase__						)

										self.assertListEqual(
										    tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '						)  ,  ['hällo', '!', 'how', 'are', 'you', '?']						)
										self.assertListEqual(tokenizer.tokenize('H\u00E9llo'						)  ,  ['h\u00E9llo']						)





			def   SCREAMING_SNAKE_CASE__     (       self	:	Optional[int]						):
										_lowerCAmelCase							=							BasicTokenizer(do_lower_case=lowercase__  ,  strip_accents=lowercase__						)

										self.assertListEqual(
										    tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '						)  ,  ['hallo', '!', 'how', 'are', 'you', '?']						)
										self.assertListEqual(tokenizer.tokenize('H\u00E9llo'						)  ,  ['hello']						)





			def   SCREAMING_SNAKE_CASE__     (       self	:	Tuple						):
										_lowerCAmelCase							=							BasicTokenizer(do_lower_case=lowercase__						)

										self.assertListEqual(
										    tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '						)  ,  ['hallo', '!', 'how', 'are', 'you', '?']						)
										self.assertListEqual(tokenizer.tokenize('H\u00E9llo'						)  ,  ['hello']						)





			def   SCREAMING_SNAKE_CASE__     (       self	:	Union[str, Any]						):
										_lowerCAmelCase							=							BasicTokenizer(do_lower_case=lowercase__						)

										self.assertListEqual(
										    tokenizer.tokenize(' \tHeLLo!how  \n Are yoU?  '						)  ,  ['HeLLo', '!', 'how', 'Are', 'yoU', '?']						)





			def   SCREAMING_SNAKE_CASE__     (       self	:	Optional[Any]						):
										_lowerCAmelCase							=							BasicTokenizer(do_lower_case=lowercase__  ,  strip_accents=lowercase__						)

										self.assertListEqual(
										    tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '						)  ,  ['HäLLo', '!', 'how', 'Are', 'yoU', '?']						)





			def   SCREAMING_SNAKE_CASE__     (       self	:	Union[str, Any]						):
										_lowerCAmelCase							=							BasicTokenizer(do_lower_case=lowercase__  ,  strip_accents=lowercase__						)

										self.assertListEqual(
										    tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '						)  ,  ['HaLLo', '!', 'how', 'Are', 'yoU', '?']						)





			def   SCREAMING_SNAKE_CASE__     (       self	:	str						):
										_lowerCAmelCase							=							BasicTokenizer(do_lower_case=lowercase__  ,  never_split=['[UNK]']						)

										self.assertListEqual(
										    tokenizer.tokenize(' \tHeLLo!how  \n Are yoU? [UNK]'						)  ,  ['HeLLo', '!', 'how', 'Are', 'yoU', '?', '[UNK]']						)





			def   SCREAMING_SNAKE_CASE__     (       self	:	List[Any]						):
										_lowerCAmelCase							=							BasicTokenizer()
										_lowerCAmelCase							=							'a\n\'ll !!to?\'d of, can\'t.'
										_lowerCAmelCase							=							['a', '\'', 'll', '!', '!', 'to', '?', '\'', 'd', 'of', ',', 'can', '\'', 't', '.']
										self.assertListEqual(tokenizer.tokenize(lowercase__						)  ,  lowercase__						)





			def   SCREAMING_SNAKE_CASE__     (       self	:	Tuple						):
										_lowerCAmelCase							=							['[UNK]', '[CLS]', '[SEP]', 'want', '##want', '##ed', 'wa', 'un', 'runn', '##ing']

										_lowerCAmelCase							=							{}
										for i, token in enumerate(lowercase__						):
																	_lowerCAmelCase							=							i
										_lowerCAmelCase							=							WordpieceTokenizer(vocab=lowercase__  ,  unk_token='[UNK]'						)

										self.assertListEqual(tokenizer.tokenize(''						)  ,  []						)

										self.assertListEqual(tokenizer.tokenize('unwanted running'						)  ,  ['un', '##want', '##ed', 'runn', '##ing']						)

										self.assertListEqual(tokenizer.tokenize('unwantedX running'						)  ,  ['[UNK]', 'runn', '##ing']						)





			def   SCREAMING_SNAKE_CASE__     (       self	:	Tuple						):
										self.assertTrue(_is_whitespace(' '						)						)
										self.assertTrue(_is_whitespace('\t'						)						)
										self.assertTrue(_is_whitespace('\r'						)						)
										self.assertTrue(_is_whitespace('\n'						)						)
										self.assertTrue(_is_whitespace('\u00A0'						)						)

										self.assertFalse(_is_whitespace('A'						)						)
										self.assertFalse(_is_whitespace('-'						)						)





			def   SCREAMING_SNAKE_CASE__     (       self	:	Dict						):
										self.assertTrue(_is_control('\u0005'						)						)

										self.assertFalse(_is_control('A'						)						)
										self.assertFalse(_is_control(' '						)						)
										self.assertFalse(_is_control('\t'						)						)
										self.assertFalse(_is_control('\r'						)						)





			def   SCREAMING_SNAKE_CASE__     (       self	:	List[str]						):
										self.assertTrue(_is_punctuation('-'						)						)
										self.assertTrue(_is_punctuation('$'						)						)
										self.assertTrue(_is_punctuation('`'						)						)
										self.assertTrue(_is_punctuation('.'						)						)

										self.assertFalse(_is_punctuation('A'						)						)
										self.assertFalse(_is_punctuation(' '						)						)





			def   SCREAMING_SNAKE_CASE__     (       self	:	str						):
										_lowerCAmelCase							=							self.get_tokenizer()
										_lowerCAmelCase							=							self.get_rust_tokenizer()

										# Example taken from the issue https://github.com/huggingface/tokenizers/issues/340
										self.assertListEqual([tokenizer.tokenize(lowercase__						) for t in ['Test', '\xad', 'test']]  ,  [['[UNK]'], [], ['[UNK]']]						)

										self.assertListEqual(
										    [rust_tokenizer.tokenize(lowercase__						) for t in ['Test', '\xad', 'test']]  ,  [['[UNK]'], [], ['[UNK]']]						)





			@slow
			def   SCREAMING_SNAKE_CASE__     (       self	:	Optional[int]						):
										_lowerCAmelCase							=							self.tokenizer_class.from_pretrained('bert-base-uncased'						)

										_lowerCAmelCase							=							tokenizer.encode('sequence builders'  ,  add_special_tokens=lowercase__						)
										_lowerCAmelCase							=							tokenizer.encode('multi-sequence build'  ,  add_special_tokens=lowercase__						)

										_lowerCAmelCase							=							tokenizer.build_inputs_with_special_tokens(lowercase__						)
										_lowerCAmelCase							=							tokenizer.build_inputs_with_special_tokens(lowercase__  ,  lowercase__						)

										assert encoded_sentence == [1_01] + text + [1_02]
										assert encoded_pair == [1_01] + text + [1_02] + text_a + [1_02]





			def   SCREAMING_SNAKE_CASE__     (       self	:	Tuple						):
										for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
																	with self.subTest(f'{tokenizer.__class__.__name__} ({pretrained_name})'						):
																								_lowerCAmelCase							=							self.rust_tokenizer_class.from_pretrained(lowercase__  ,  **lowercase__						)

																								_lowerCAmelCase							=							f'A, naïve {tokenizer_r.mask_token} AllenNLP sentence.'
																								_lowerCAmelCase							=							tokenizer_r.encode_plus(
																								    lowercase__  ,  return_attention_mask=lowercase__  ,  return_token_type_ids=lowercase__  ,  return_offsets_mapping=lowercase__  ,  add_special_tokens=lowercase__  ,  )

																								_lowerCAmelCase							=							tokenizer_r.do_lower_case if hasattr(lowercase__  ,  'do_lower_case'						) else False
																								_lowerCAmelCase							=							(
																								    [
																								        ((0, 0), tokenizer_r.cls_token),
																								        ((0, 1), 'A'),
																								        ((1, 2), ','),
																								        ((3, 5), 'na'),
																								        ((5, 6), '##ï'),
																								        ((6, 8), '##ve'),
																								        ((9, 15), tokenizer_r.mask_token),
																								        ((16, 21), 'Allen'),
																								        ((21, 23), '##NL'),
																								        ((23, 24), '##P'),
																								        ((25, 33), 'sentence'),
																								        ((33, 34), '.'),
																								        ((0, 0), tokenizer_r.sep_token),
																								    ]
																								    if not do_lower_case
																								    else [
																								        ((0, 0), tokenizer_r.cls_token),
																								        ((0, 1), 'a'),
																								        ((1, 2), ','),
																								        ((3, 8), 'naive'),
																								        ((9, 15), tokenizer_r.mask_token),
																								        ((16, 21), 'allen'),
																								        ((21, 23), '##nl'),
																								        ((23, 24), '##p'),
																								        ((25, 33), 'sentence'),
																								        ((33, 34), '.'),
																								        ((0, 0), tokenizer_r.sep_token),
																								    ]
																								)

																								self.assertEqual(
																								    [e[1] for e in expected_results]  ,  tokenizer_r.convert_ids_to_tokens(tokens['input_ids']						)						)
																								self.assertEqual([e[0] for e in expected_results]  ,  tokens['offset_mapping']						)





			def   SCREAMING_SNAKE_CASE__     (       self	:	int						):
										_lowerCAmelCase							=							['的', '人', '有']
										_lowerCAmelCase							=							''.join(lowercase__						)
										for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
																	with self.subTest(f'{tokenizer.__class__.__name__} ({pretrained_name})'						):
																								_lowerCAmelCase							=							True
																								_lowerCAmelCase							=							self.tokenizer_class.from_pretrained(lowercase__  ,  **lowercase__						)
																								_lowerCAmelCase							=							self.rust_tokenizer_class.from_pretrained(lowercase__  ,  **lowercase__						)

																								_lowerCAmelCase							=							tokenizer_p.encode(lowercase__  ,  add_special_tokens=lowercase__						)
																								_lowerCAmelCase							=							tokenizer_r.encode(lowercase__  ,  add_special_tokens=lowercase__						)

																								_lowerCAmelCase							=							tokenizer_r.convert_ids_to_tokens(lowercase__						)
																								_lowerCAmelCase							=							tokenizer_p.convert_ids_to_tokens(lowercase__						)

																								# it is expected that each Chinese character is not preceded by "##"
																								self.assertListEqual(lowercase__  ,  lowercase__						)
																								self.assertListEqual(lowercase__  ,  lowercase__						)

																								_lowerCAmelCase							=							False
																								_lowerCAmelCase							=							self.rust_tokenizer_class.from_pretrained(lowercase__  ,  **lowercase__						)
																								_lowerCAmelCase							=							self.tokenizer_class.from_pretrained(lowercase__  ,  **lowercase__						)

																								_lowerCAmelCase							=							tokenizer_r.encode(lowercase__  ,  add_special_tokens=lowercase__						)
																								_lowerCAmelCase							=							tokenizer_p.encode(lowercase__  ,  add_special_tokens=lowercase__						)

																								_lowerCAmelCase							=							tokenizer_r.convert_ids_to_tokens(lowercase__						)
																								_lowerCAmelCase							=							tokenizer_p.convert_ids_to_tokens(lowercase__						)

																								# it is expected that only the first Chinese character is not preceded by "##".
																								_lowerCAmelCase							=							[
																								    f'##{token}' if idx != 0 else token for idx, token in enumerate(lowercase__						)
																								]
																								self.assertListEqual(lowercase__  ,  lowercase__						)
																								self.assertListEqual(lowercase__  ,  lowercase__						)







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        lowerCamelCase__				:





			def __init__(       self	:	str  ,  lowercase__	:	Optional[Any]  ,  lowercase__	:	str=2  ,  lowercase__	:	Union[str, Any]=3  ,  lowercase__	:	Dict=4  ,  lowercase__	:	Any=2  ,  lowercase__	:	Any=7  ,  lowercase__	:	Dict=True  ,  lowercase__	:	Any=True  ,  lowercase__	:	Optional[int]=True  ,  lowercase__	:	str=True  ,  lowercase__	:	Optional[Any]=99  ,  lowercase__	:	int=36  ,  lowercase__	:	Union[str, Any]=3  ,  lowercase__	:	List[Any]=4  ,  lowercase__	:	List[str]=37  ,  lowercase__	:	Optional[Any]="gelu"  ,  lowercase__	:	Optional[int]=0.1  ,  lowercase__	:	List[Any]=0.1  ,  lowercase__	:	Tuple=5_12  ,  lowercase__	:	Optional[Any]=16  ,  lowercase__	:	Tuple=2  ,  lowercase__	:	Optional[int]=0.0_2  ,  lowercase__	:	List[str]=6  ,  lowercase__	:	List[Any]=6  ,  lowercase__	:	Optional[int]=3  ,  lowercase__	:	Optional[Any]=4  ,  lowercase__	:	Optional[Any]=None  ,  lowercase__	:	Optional[Any]=10_00  ,  ):
										_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   SCREAMING_SNAKE_CASE__     (       self	:	int						):
										_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   SCREAMING_SNAKE_CASE__     (       self	:	Tuple  ,  lowercase__	:	Union[str, Any]  ,  lowercase__	:	Optional[int]  ,  lowercase__	:	Optional[int]  ,  lowercase__	:	Union[str, Any]  ,  lowercase__	:	str  ,  lowercase__	:	Tuple  ,  lowercase__	:	str  ,  lowercase__	:	Optional[Any]						):
										_lowerCAmelCase							=							LayoutLMvaModel(config=lowercase__						)
										model.to(lowercase__						)
										model.eval()

										# text + image
										_lowerCAmelCase							=							model(lowercase__  ,  pixel_values=lowercase__						)
										_lowerCAmelCase							=							model(
										    lowercase__  ,  bbox=lowercase__  ,  pixel_values=lowercase__  ,  attention_mask=lowercase__  ,  token_type_ids=lowercase__						)
										_lowerCAmelCase							=							model(lowercase__  ,  bbox=lowercase__  ,  pixel_values=lowercase__  ,  token_type_ids=lowercase__						)
										_lowerCAmelCase							=							model(lowercase__  ,  bbox=lowercase__  ,  pixel_values=lowercase__						)

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

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

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





			def   SCREAMING_SNAKE_CASE__     (       self	:	Optional[Any]  ,  lowercase__	:	List[str]  ,  lowercase__	:	Tuple  ,  lowercase__	:	Optional[Any]  ,  lowercase__	:	Tuple  ,  lowercase__	:	Union[str, Any]  ,  lowercase__	:	List[Any]  ,  lowercase__	:	List[Any]  ,  lowercase__	:	int						):
										_lowerCAmelCase							=							self.num_labels
										_lowerCAmelCase							=							LayoutLMvaForSequenceClassification(lowercase__						)
										model.to(lowercase__						)
										model.eval()
										_lowerCAmelCase							=							model(
										    lowercase__  ,  bbox=lowercase__  ,  pixel_values=lowercase__  ,  attention_mask=lowercase__  ,  token_type_ids=lowercase__  ,  labels=lowercase__  ,  )
										self.parent.assertEqual(result.logits.shape  ,  (self.batch_size, self.num_labels)						)





			def   SCREAMING_SNAKE_CASE__     (       self	:	int  ,  lowercase__	:	Optional[int]  ,  lowercase__	:	Dict  ,  lowercase__	:	List[Any]  ,  lowercase__	:	Optional[Any]  ,  lowercase__	:	Tuple  ,  lowercase__	:	Tuple  ,  lowercase__	:	Optional[Any]  ,  lowercase__	:	int						):
										_lowerCAmelCase							=							self.num_labels
										_lowerCAmelCase							=							LayoutLMvaForTokenClassification(config=lowercase__						)
										model.to(lowercase__						)
										model.eval()
										_lowerCAmelCase							=							model(
										    lowercase__  ,  bbox=lowercase__  ,  pixel_values=lowercase__  ,  attention_mask=lowercase__  ,  token_type_ids=lowercase__  ,  labels=lowercase__  ,  )
										self.parent.assertEqual(result.logits.shape  ,  (self.batch_size, self.text_seq_length, self.num_labels)						)





			def   SCREAMING_SNAKE_CASE__     (       self	:	Any  ,  lowercase__	:	Optional[int]  ,  lowercase__	:	List[Any]  ,  lowercase__	:	List[str]  ,  lowercase__	:	str  ,  lowercase__	:	Optional[Any]  ,  lowercase__	:	List[Any]  ,  lowercase__	:	List[str]  ,  lowercase__	:	Union[str, Any]						):
										_lowerCAmelCase							=							LayoutLMvaForQuestionAnswering(config=lowercase__						)
										model.to(lowercase__						)
										model.eval()
										_lowerCAmelCase							=							model(
										    lowercase__  ,  bbox=lowercase__  ,  pixel_values=lowercase__  ,  attention_mask=lowercase__  ,  token_type_ids=lowercase__  ,  start_positions=lowercase__  ,  end_positions=lowercase__  ,  )
										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   SCREAMING_SNAKE_CASE__     (       self	:	List[Any]						):
										_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        lowerCamelCase__				(   UpperCAmelCase       ,UpperCAmelCase       ,unittest.TestCase				):
			UpperCamelCase__    							=False
			UpperCamelCase__    							=False
			UpperCamelCase__    							=False

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





			def   SCREAMING_SNAKE_CASE__     (       self	:	List[Any]  ,  lowercase__	:	List[Any]  ,  lowercase__	:	Union[str, Any]  ,  lowercase__	:	Any  ,  lowercase__	:	Union[str, Any]  ,  lowercase__	:	Optional[Any]						):
										# `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   SCREAMING_SNAKE_CASE__     (       self	:	Dict						):
										_lowerCAmelCase							=							LayoutLMvaModelTester(self						)
										_lowerCAmelCase							=							ConfigTester(self  ,  config_class=lowercase__  ,  hidden_size=37						)





			def   SCREAMING_SNAKE_CASE__     (       self	:	Optional[int]  ,  lowercase__	:	Optional[Any]  ,  lowercase__	:	Optional[int]  ,  lowercase__	:	Any=False						):
										_lowerCAmelCase							=							copy.deepcopy(lowercase__						)
										if model_class in get_values(lowercase__						):
																	_lowerCAmelCase							=							{
																	    k: v.unsqueeze(1						).expand(-1  ,  self.model_tester.num_choices  ,  -1						).contiguous()
																	    if isinstance(lowercase__  ,  torch.Tensor						) and v.ndim > 1
																	    else v
																	    for k, v in inputs_dict.items()
																	}
										if return_labels:
																	if model_class in get_values(lowercase__						):
																								_lowerCAmelCase							=							torch.ones(self.model_tester.batch_size  ,  dtype=torch.long  ,  device=lowercase__						)
																	elif model_class in get_values(lowercase__						):
																								_lowerCAmelCase							=							torch.zeros(
																								    self.model_tester.batch_size  ,  dtype=torch.long  ,  device=lowercase__						)
																								_lowerCAmelCase							=							torch.zeros(
																								    self.model_tester.batch_size  ,  dtype=torch.long  ,  device=lowercase__						)
																	elif model_class in [
																	    *get_values(lowercase__						),
																	]:
																								_lowerCAmelCase							=							torch.zeros(
																								    self.model_tester.batch_size  ,  dtype=torch.long  ,  device=lowercase__						)
																	elif model_class in [
																	    *get_values(lowercase__						),
																	]:
																								_lowerCAmelCase							=							torch.zeros(
																								    (self.model_tester.batch_size, self.model_tester.text_seq_length)  ,  dtype=torch.long  ,  device=lowercase__  ,  )

										return inputs_dict





			def   SCREAMING_SNAKE_CASE__     (       self	:	List[str]						):
										self.config_tester.run_common_tests()





			def   SCREAMING_SNAKE_CASE__     (       self	:	Tuple						):
										_lowerCAmelCase							=							self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*lowercase__						)





			def   SCREAMING_SNAKE_CASE__     (       self	:	Optional[int]						):
										_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(*lowercase__						)





			def   SCREAMING_SNAKE_CASE__     (       self	:	str						):
										_lowerCAmelCase							=							self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_sequence_classification(*lowercase__						)





			def   SCREAMING_SNAKE_CASE__     (       self	:	Any						):
										_lowerCAmelCase							=							self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_token_classification(*lowercase__						)





			def   SCREAMING_SNAKE_CASE__     (       self	:	int						):
										_lowerCAmelCase							=							self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_question_answering(*lowercase__						)





			@slow
			def   SCREAMING_SNAKE_CASE__     (       self	:	Any						):
										for model_name in LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																	_lowerCAmelCase							=							LayoutLMvaModel.from_pretrained(lowercase__						)
																	self.assertIsNotNone(lowercase__						)







def _lowerCamelCase  (		):
							_lowerCAmelCase							=							Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'  )
							return image



@require_torch
class        lowerCamelCase__				(   unittest.TestCase				):





			@cached_property
			def   SCREAMING_SNAKE_CASE__     (       self	:	Optional[int]						):
										return LayoutLMvaImageProcessor(apply_ocr=lowercase__						) if is_vision_available() else None





			@slow
			def   SCREAMING_SNAKE_CASE__     (       self	:	Tuple						):
										_lowerCAmelCase							=							LayoutLMvaModel.from_pretrained('microsoft/layoutlmv3-base'						).to(lowercase__						)

										_lowerCAmelCase							=							self.default_image_processor
										_lowerCAmelCase							=							prepare_img()
										_lowerCAmelCase							=							image_processor(images=lowercase__  ,  return_tensors='pt'						).pixel_values.to(lowercase__						)

										_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(lowercase__						)  ,  bbox=bbox.to(lowercase__						)  ,  pixel_values=pixel_values.to(lowercase__						)  ,  )

										# verify the logits
										_lowerCAmelCase							=							torch.Size((1, 1_99, 7_68)						)
										self.assertEqual(outputs.last_hidden_state.shape  ,  lowercase__						)

										_lowerCAmelCase							=							torch.tensor(
										    [[-0.0_5_2_9, 0.3_6_1_8, 0.1_6_3_2], [-0.1_5_8_7, -0.1_6_6_7, -0.0_4_0_0], [-0.1_5_5_7, -0.1_6_7_1, -0.0_5_0_5]]						).to(lowercase__						)

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






