"""simple docstring"""






import unittest

from huggingface_hub import hf_hub_download

from transformers import MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING, VideoMAEFeatureExtractor
from transformers.pipelines import VideoClassificationPipeline, pipeline
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_decord,
    require_tf,
    require_torch,
    require_torch_or_tf,
    require_vision,
)

from .test_pipelines_common import ANY




@is_pipeline_test
@require_torch_or_tf
@require_vision
@require_decord
class 				__lowercase			(			unittest.TestCase							):







					'''simple docstring'''




					__lowerCAmelCase  =  MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING







					def  _lowerCamelCase		(						self	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase     ):
									__a :						Any			       =  hf_hub_download(
									    repo_id='''nateraw/video-demo'''	,			filename='''archery.mp4'''	,			repo_type='''dataset'''     )
									__a :						str			       =  VideoClassificationPipeline(model=_UpperCAmelCase	,			image_processor=_UpperCAmelCase	,			top_k=2     )
									__a :						Optional[int]			       =  [
									    example_video_filepath,
									    '''https://huggingface.co/datasets/nateraw/video-demo/resolve/main/archery.mp4''',
									]
									return video_classifier, examples







					def  _lowerCamelCase		(						self	,			_UpperCAmelCase	,			_UpperCAmelCase     ):
									for example in examples:
													__a :						List[Any]			       =  video_classifier(_UpperCAmelCase     )

													self.assertEqual(
													    _UpperCAmelCase	,			[
													        {'''score''': ANY(_UpperCAmelCase     ), '''label''': ANY(_UpperCAmelCase     )},
													        {'''score''': ANY(_UpperCAmelCase     ), '''label''': ANY(_UpperCAmelCase     )},
													    ]	,			)







					@require_torch
					def  _lowerCamelCase		(						self     ):
									__a :						Tuple			       =  '''hf-internal-testing/tiny-random-VideoMAEForVideoClassification'''
									__a :						Dict			       =  VideoMAEFeatureExtractor(
									    size={'''shortest_edge''': 10}	,			crop_size={'''height''': 10, '''width''': 10}     )
									__a :						Union[str, Any]			       =  pipeline(
									    '''video-classification'''	,			model=_UpperCAmelCase	,			feature_extractor=_UpperCAmelCase	,			frame_sampling_rate=4     )

									__a :						str			       =  hf_hub_download(repo_id='''nateraw/video-demo'''	,			filename='''archery.mp4'''	,			repo_type='''dataset'''     )
									__a :						Dict			       =  video_classifier(_UpperCAmelCase	,			top_k=2     )
									self.assertEqual(
									    nested_simplify(_UpperCAmelCase	,			decimals=4     )	,			[{'''score''': 0.5_1_9_9, '''label''': '''LABEL_0'''}, {'''score''': 0.4_8_0_1, '''label''': '''LABEL_1'''}]	,			)

									__a :						str			       =  video_classifier(
									    [
									        video_file_path,
									        video_file_path,
									    ]	,			top_k=2	,			)
									self.assertEqual(
									    nested_simplify(_UpperCAmelCase	,			decimals=4     )	,			[
									        [{'''score''': 0.5_1_9_9, '''label''': '''LABEL_0'''}, {'''score''': 0.4_8_0_1, '''label''': '''LABEL_1'''}],
									        [{'''score''': 0.5_1_9_9, '''label''': '''LABEL_0'''}, {'''score''': 0.4_8_0_1, '''label''': '''LABEL_1'''}],
									    ]	,			)







					@require_tf
					def  _lowerCamelCase		(						self     ):
									pass






"""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 				__lowercase			:







					'''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.0_2	,			_UpperCAmelCase=6	,			_UpperCAmelCase=6	,			_UpperCAmelCase=3	,			_UpperCAmelCase=4	,			_UpperCAmelCase=None	,			_UpperCAmelCase=1000	,			):
									__a :						Dict			       =  parent
									__a :						Optional[int]			       =  batch_size
									__a :						Optional[int]			       =  num_channels
									__a :						List[Any]			       =  image_size
									__a :						int			       =  patch_size
									__a :						Tuple			       =  text_seq_length
									__a :						Dict			       =  is_training
									__a :						str			       =  use_input_mask
									__a :						Optional[int]			       =  use_token_type_ids
									__a :						List[Any]			       =  use_labels
									__a :						Tuple			       =  vocab_size
									__a :						str			       =  hidden_size
									__a :						Any			       =  num_hidden_layers
									__a :						List[str]			       =  num_attention_heads
									__a :						str			       =  intermediate_size
									__a :						int			       =  hidden_act
									__a :						List[Any]			       =  hidden_dropout_prob
									__a :						Tuple			       =  attention_probs_dropout_prob
									__a :						Tuple			       =  max_position_embeddings
									__a :						List[Any]			       =  type_vocab_size
									__a :						int			       =  type_sequence_label_size
									__a :						str			       =  initializer_range
									__a :						Dict			       =  coordinate_size
									__a :						int			       =  shape_size
									__a :						int			       =  num_labels
									__a :						Optional[int]			       =  num_choices
									__a :						Any			       =  scope
									__a :						Any			       =  range_bbox

									# LayoutLMv3's sequence length equals the number of text tokens + number of patches + 1 (we add 1 for the CLS token)
									__a :						Optional[int]			       =  text_seq_length
									__a :						str			       =  (image_size // patch_size) ** 2 + 1
									__a :						Tuple			       =  self.text_seq_length + self.image_seq_length







					def  _lowerCamelCase		(						self     ):
									__a :						List[Any]			       =  ids_tensor([self.batch_size, self.text_seq_length]	,			self.vocab_size     )

									__a :						Union[str, Any]			       =  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]:
																					__a :						Optional[Any]			       =  bbox[i, j, 3]
																					__a :						Union[str, Any]			       =  bbox[i, j, 1]
																					__a :						Tuple			       =  t
																	if bbox[i, j, 2] < bbox[i, j, 0]:
																					__a :						Optional[int]			       =  bbox[i, j, 2]
																					__a :						Optional[int]			       =  bbox[i, j, 0]
																					__a :						str			       =  t

									__a :						str			       =  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]     )

									__a :						Union[str, Any]			       =  None
									if self.use_input_mask:
													__a :						int			       =  random_attention_mask([self.batch_size, self.text_seq_length]     )

									__a :						int			       =  None
									if self.use_token_type_ids:
													__a :						Union[str, Any]			       =  ids_tensor([self.batch_size, self.text_seq_length]	,			self.type_vocab_size     )

									__a :						Optional[int]			       =  None
									__a :						Dict			       =  None
									if self.use_labels:
													__a :						Optional[Any]			       =  ids_tensor([self.batch_size]	,			self.type_sequence_label_size     )
													__a :						Optional[int]			       =  ids_tensor([self.batch_size, self.text_seq_length]	,			self.num_labels     )

									__a :						int			       =  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  _lowerCamelCase		(						self	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase     ):
									__a :						Union[str, Any]			       =  LayoutLMvaModel(config=_UpperCAmelCase     )
									model.to(_UpperCAmelCase     )
									model.eval()

									# text + image
									__a :						Union[str, Any]			       =  model(_UpperCAmelCase	,			pixel_values=_UpperCAmelCase     )
									__a :						List[Any]			       =  model(
									    _UpperCAmelCase	,			bbox=_UpperCAmelCase	,			pixel_values=_UpperCAmelCase	,			attention_mask=_UpperCAmelCase	,			token_type_ids=_UpperCAmelCase     )
									__a :						Optional[int]			       =  model(_UpperCAmelCase	,			bbox=_UpperCAmelCase	,			pixel_values=_UpperCAmelCase	,			token_type_ids=_UpperCAmelCase     )
									__a :						List[str]			       =  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
									__a :						int			       =  model(_UpperCAmelCase     )
									self.parent.assertEqual(
									    result.last_hidden_state.shape	,			(self.batch_size, self.text_seq_length, self.hidden_size)     )

									# image only
									__a :						Tuple			       =  model(pixel_values=_UpperCAmelCase     )
									self.parent.assertEqual(
									    result.last_hidden_state.shape	,			(self.batch_size, self.image_seq_length, self.hidden_size)     )







					def  _lowerCamelCase		(						self	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase     ):
									__a :						Optional[Any]			       =  self.num_labels
									__a :						Optional[Any]			       =  LayoutLMvaForSequenceClassification(_UpperCAmelCase     )
									model.to(_UpperCAmelCase     )
									model.eval()
									__a :						Union[str, Any]			       =  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  _lowerCamelCase		(						self	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase     ):
									__a :						List[str]			       =  self.num_labels
									__a :						int			       =  LayoutLMvaForTokenClassification(config=_UpperCAmelCase     )
									model.to(_UpperCAmelCase     )
									model.eval()
									__a :						List[str]			       =  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  _lowerCamelCase		(						self	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase     ):
									__a :						List[Any]			       =  LayoutLMvaForQuestionAnswering(config=_UpperCAmelCase     )
									model.to(_UpperCAmelCase     )
									model.eval()
									__a :						List[str]			       =  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  _lowerCamelCase		(						self     ):
									__a :						Optional[int]			       =  self.prepare_config_and_inputs()
									(
									    (
									    __a
									)       ,						(
									    __a
									)       ,						(
									    __a
									)       ,						(
									    __a
									)       ,						(
									    __a
									)       ,						(
									    __a
									)       ,						(
									    __a
									)       ,						(
									    __a
									)       ,						
									) :						List[Any]			       =  config_and_inputs
									__a :						Optional[int]			       =  {
									    '''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 				__lowercase			(			_UpperCamelCase   ,      _UpperCamelCase   ,      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  _lowerCamelCase		(						self	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase     ):
									# `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  _lowerCamelCase		(						self     ):
									__a :						str			       =  LayoutLMvaModelTester(self     )
									__a :						int			       =  ConfigTester(self	,			config_class=_UpperCAmelCase	,			hidden_size=37     )







					def  _lowerCamelCase		(						self	,			_UpperCAmelCase	,			_UpperCAmelCase	,			_UpperCAmelCase=False     ):
									__a :						int			       =  copy.deepcopy(_UpperCAmelCase     )
									if model_class in get_values(_UpperCAmelCase     ):
													__a :						List[str]			       =  {
													    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     ):
																	__a :						Dict			       =  torch.ones(self.model_tester.batch_size	,			dtype=torch.long	,			device=_UpperCAmelCase     )
													elif model_class in get_values(_UpperCAmelCase     ):
																	__a :						int			       =  torch.zeros(
																	    self.model_tester.batch_size	,			dtype=torch.long	,			device=_UpperCAmelCase     )
																	__a :						Any			       =  torch.zeros(
																	    self.model_tester.batch_size	,			dtype=torch.long	,			device=_UpperCAmelCase     )
													elif model_class in [
													    *get_values(_UpperCAmelCase     ),
													]:
																	__a :						Any			       =  torch.zeros(
																	    self.model_tester.batch_size	,			dtype=torch.long	,			device=_UpperCAmelCase     )
													elif model_class in [
													    *get_values(_UpperCAmelCase     ),
													]:
																	__a :						int			       =  torch.zeros(
																	    (self.model_tester.batch_size, self.model_tester.text_seq_length)	,			dtype=torch.long	,			device=_UpperCAmelCase	,			)

									return inputs_dict







					def  _lowerCamelCase		(						self     ):
									self.config_tester.run_common_tests()







					def  _lowerCamelCase		(						self     ):
									__a :						List[str]			       =  self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*_UpperCAmelCase     )







					def  _lowerCamelCase		(						self     ):
									__a :						Optional[int]			       =  self.model_tester.prepare_config_and_inputs()
									for type in ["absolute", "relative_key", "relative_key_query"]:
													__a :						Optional[Any]			       =  type
													self.model_tester.create_and_check_model(*_UpperCAmelCase     )







					def  _lowerCamelCase		(						self     ):
									__a :						Tuple			       =  self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_sequence_classification(*_UpperCAmelCase     )







					def  _lowerCamelCase		(						self     ):
									__a :						Tuple			       =  self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_token_classification(*_UpperCAmelCase     )







					def  _lowerCamelCase		(						self     ):
									__a :						int			       =  self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_question_answering(*_UpperCAmelCase     )







					@slow
					def  _lowerCamelCase		(						self     ):
									for model_name in LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													__a :						Tuple			       =  LayoutLMvaModel.from_pretrained(_UpperCAmelCase     )
													self.assertIsNotNone(_UpperCAmelCase     )






def     __A      (			)		->		Dict:
				__a :						Tuple			       =  Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''')
				return image






@require_torch
class 				__lowercase			(			unittest.TestCase							):







					'''simple docstring'''




					@cached_property
					def  _lowerCamelCase		(						self     ):
									return LayoutLMvaImageProcessor(apply_ocr=_UpperCAmelCase     ) if is_vision_available() else None







					@slow
					def  _lowerCamelCase		(						self     ):
									__a :						List[Any]			       =  LayoutLMvaModel.from_pretrained('''microsoft/layoutlmv3-base'''     ).to(_UpperCAmelCase     )

									__a :						Dict			       =  self.default_image_processor
									__a :						Tuple			       =  prepare_img()
									__a :						Optional[Any]			       =  image_processor(images=_UpperCAmelCase	,			return_tensors='''pt'''     ).pixel_values.to(_UpperCAmelCase     )

									__a :						Tuple			       =  torch.tensor([[1, 2]]     )
									__a :						Dict			       =  torch.tensor([[1, 2, 3, 4], [5, 6, 7, 8]]     ).unsqueeze(0     )

									# forward pass
									__a :						Tuple			       =  model(
									    input_ids=input_ids.to(_UpperCAmelCase     )	,			bbox=bbox.to(_UpperCAmelCase     )	,			pixel_values=pixel_values.to(_UpperCAmelCase     )	,			)

									# verify the logits
									__a :						Any			       =  torch.Size((1, 199, 768)     )
									self.assertEqual(outputs.last_hidden_state.shape	,			_UpperCAmelCase     )

									__a :						Union[str, Any]			       =  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(_UpperCAmelCase     )

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