



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						,				_snake_case						,				_snake_case=2						,				_snake_case=3						,				_snake_case=4						,				_snake_case=2						,				_snake_case=7						,				_snake_case=True						,				_snake_case=True						,				_snake_case=True						,				_snake_case=True						,				_snake_case=99						,				_snake_case=36						,				_snake_case=3						,				_snake_case=4						,				_snake_case=37						,				_snake_case="gelu"						,				_snake_case=0.1						,				_snake_case=0.1						,				_snake_case=512						,				_snake_case=16						,				_snake_case=2						,				_snake_case=0.02						,				_snake_case=6						,				_snake_case=6						,				_snake_case=3						,				_snake_case=4						,				_snake_case=None						,				_snake_case=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						,				_snake_case						,				_snake_case						,				_snake_case						,				_snake_case						,				_snake_case						,				_snake_case						,				_snake_case						,				_snake_case		):



									"""simple docstring"""





									_lowerCAmelCase						=    LayoutLMvaModel(config=_snake_case		)
									model.to(_snake_case		)
									model.eval()

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

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

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

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




				def 							snake_case   (							self						,				_snake_case						,				_snake_case						,				_snake_case						,				_snake_case						,				_snake_case						,				_snake_case						,				_snake_case						,				_snake_case		):



									"""simple docstring"""





									_lowerCAmelCase						=    self.num_labels
									_lowerCAmelCase						=    LayoutLMvaForSequenceClassification(_snake_case		)
									model.to(_snake_case		)
									model.eval()
									_lowerCAmelCase						=    model(
									    _snake_case						,				bbox=_snake_case						,				pixel_values=_snake_case						,				attention_mask=_snake_case						,				token_type_ids=_snake_case						,				labels=_snake_case						,				)
									self.parent.assertEqual(result.logits.shape						,				(self.batch_size, self.num_labels)		)




				def 							snake_case   (							self						,				_snake_case						,				_snake_case						,				_snake_case						,				_snake_case						,				_snake_case						,				_snake_case						,				_snake_case						,				_snake_case		):



									"""simple docstring"""





									_lowerCAmelCase						=    self.num_labels
									_lowerCAmelCase						=    LayoutLMvaForTokenClassification(config=_snake_case		)
									model.to(_snake_case		)
									model.eval()
									_lowerCAmelCase						=    model(
									    _snake_case						,				bbox=_snake_case						,				pixel_values=_snake_case						,				attention_mask=_snake_case						,				token_type_ids=_snake_case						,				labels=_snake_case						,				)
									self.parent.assertEqual(result.logits.shape						,				(self.batch_size, self.text_seq_length, self.num_labels)		)




				def 							snake_case   (							self						,				_snake_case						,				_snake_case						,				_snake_case						,				_snake_case						,				_snake_case						,				_snake_case						,				_snake_case						,				_snake_case		):



									"""simple docstring"""





									_lowerCAmelCase						=    LayoutLMvaForQuestionAnswering(config=_snake_case		)
									model.to(_snake_case		)
									model.eval()
									_lowerCAmelCase						=    model(
									    _snake_case						,				bbox=_snake_case						,				pixel_values=_snake_case						,				attention_mask=_snake_case						,				token_type_ids=_snake_case						,				start_positions=_snake_case						,				end_positions=_snake_case						,				)
									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 					__lowerCAmelCase (     lowerCamelCase__       ,						lowerCamelCase__       ,						unittest.TestCase       ):
				__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						,				_snake_case						,				_snake_case						,				_snake_case						,				_snake_case						,				_snake_case		):



									"""simple docstring"""





									return True




				def 							snake_case   (							self		):



									"""simple docstring"""





									_lowerCAmelCase						=    LayoutLMvaModelTester(self		)
									_lowerCAmelCase						=    ConfigTester(self						,				config_class=_snake_case						,				hidden_size=37		)




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



									"""simple docstring"""





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

									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(*_snake_case		)




				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(*_snake_case		)




				def 							snake_case   (							self		):



									"""simple docstring"""





									_lowerCAmelCase						=    self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_sequence_classification(*_snake_case		)




				def 							snake_case   (							self		):



									"""simple docstring"""





									_lowerCAmelCase						=    self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_token_classification(*_snake_case		)




				def 							snake_case   (							self		):



									"""simple docstring"""





									_lowerCAmelCase						=    self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_question_answering(*_snake_case		)




				@slow
				def 							snake_case   (							self		):



									"""simple docstring"""





									for model_name in LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
														_lowerCAmelCase						=    LayoutLMvaModel.from_pretrained(_snake_case		)
														self.assertIsNotNone(_snake_case		)


def 		_UpperCAmelCase				(      ):





					"""simple docstring"""

					_lowerCAmelCase						=    Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""			)
					return image





@require_torch
class 					__lowerCAmelCase (     unittest.TestCase       ):




				@cached_property
				def 							snake_case   (							self		):



									"""simple docstring"""





									return LayoutLMvaImageProcessor(apply_ocr=_snake_case		) if is_vision_available() else None




				@slow
				def 							snake_case   (							self		):



									"""simple docstring"""





									_lowerCAmelCase						=    LayoutLMvaModel.from_pretrained("""microsoft/layoutlmv3-base"""		).to(_snake_case		)

									_lowerCAmelCase						=    self.default_image_processor
									_lowerCAmelCase						=    prepare_img()
									_lowerCAmelCase						=    image_processor(images=_snake_case						,				return_tensors="""pt"""		).pixel_values.to(_snake_case		)

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

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

									_lowerCAmelCase						=    torch.tensor(
									    [[-0.0529, 0.3618, 0.1632], [-0.1587, -0.1667, -0.0400], [-0.1557, -0.1671, -0.0505]]		).to(_snake_case		)

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







import argparse
import importlib
from pathlib import Path


# Test all the extensions added in the setup
lowerCAmelCase           =		[
    '''kernels/rwkv/wkv_cuda.cu''',
    '''kernels/rwkv/wkv_op.cpp''',
    '''kernels/deformable_detr/ms_deform_attn.h''',
    '''kernels/deformable_detr/cuda/ms_deform_im2col_cuda.cuh''',
    '''models/graphormer/algos_graphormer.pyx''',
]







def        _lowerCamelCase(	lowercase__	)						->	str:

		'''simple docstring'''







		for file in FILES_TO_FIND:
				if not (transformers_path / file).exists():
						return False
		return True


if __name__ == "__main__":
	lowerCAmelCase           =		argparse.ArgumentParser()
	parser.add_argument('''--check_lib''', action='''store_true''', help='''Whether to check the build or the actual package.''')
	lowerCAmelCase           =		parser.parse_args()
	if args.check_lib:
		lowerCAmelCase           =		importlib.import_module('''transformers''')
		lowerCAmelCase           =		Path(transformers_module.__file__).parent
	else:
		lowerCAmelCase           =		Path.cwd() / '''build/lib/transformers'''
	if not test_custom_files_are_present(transformers_path):
		raise ValueError('''The built release does not contain the custom files. Fix this before going further!''')






