

import inspect
import unittest

from transformers import YolosConfig
from transformers.testing_utils import require_torch, require_vision, 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
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
	import torch
	from torch import nn

	from transformers import YolosForObjectDetection, YolosModel
	from transformers.models.yolos.modeling_yolos import YOLOS_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
	from PIL import Image

	from transformers import AutoImageProcessor



class     _a						:


					'''simple docstring'''






					def __init__( self    ,       A__    ,       A__=13    ,       A__=[30, 30]    ,       A__=2    ,       A__=3    ,       A__=True    ,       A__=True    ,       A__=32    ,       A__=5    ,       A__=4    ,       A__=37    ,       A__="gelu"    ,       A__=0.1    ,       A__=0.1    ,       A__=10    ,       A__=0.0_2    ,       A__=3    ,       A__=None    ,       A__=8    ,       A__=10    ,       ):
						A__							:    str        =		parent
						A__							:    Union[str, Any]        =		batch_size
						A__							:    List[str]        =		image_size
						A__							:    Union[str, Any]        =		patch_size
						A__							:    Dict        =		num_channels
						A__							:    List[Any]        =		is_training
						A__							:    Optional[int]        =		use_labels
						A__							:    str        =		hidden_size
						A__							:    List[Any]        =		num_hidden_layers
						A__							:    Optional[Any]        =		num_attention_heads
						A__							:    Any        =		intermediate_size
						A__							:    List[Any]        =		hidden_act
						A__							:    Tuple        =		hidden_dropout_prob
						A__							:    int        =		attention_probs_dropout_prob
						A__							:    List[str]        =		type_sequence_label_size
						A__							:    List[Any]        =		initializer_range
						A__							:    int        =		num_labels
						A__							:    Union[str, Any]        =		scope
						A__							:    Dict        =		n_targets
						A__							:    Any        =		num_detection_tokens
						# we set the expected sequence length (which is used in several tests)
						# expected sequence length = num_patches + 1 (we add 1 for the [CLS] token) + num_detection_tokens
						A__							:    Tuple        =		(image_size[1] // patch_size) * (image_size[0] // patch_size)
						A__							:    Union[str, Any]        =		num_patches + 1 + self.num_detection_tokens






					def   __A			( self			):
						A__							:    str        =		floats_tensor([self.batch_size, self.num_channels, self.image_size[0], self.image_size[1]]			)

						A__							:    Any        =		None
						if self.use_labels:
							# labels is a list of Dict (each Dict being the labels for a given example in the batch)
							A__							:    Any        =		[]
							for i in range(self.batch_size			):
								A__							:    Tuple        =		{}
								A__							:    Any        =		torch.randint(
								    high=self.num_labels    ,       size=(self.n_targets,)    ,       device=A__			)
								A__							:    Any        =		torch.rand(self.n_targets    ,       4    ,       device=A__			)
								labels.append(A__			)

						A__							:    Tuple        =		self.get_config()

						return config, pixel_values, labels






					def   __A			( self			):
						return YolosConfig(
						    image_size=self.image_size    ,       patch_size=self.patch_size    ,       num_channels=self.num_channels    ,       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    ,       is_decoder=A__    ,       initializer_range=self.initializer_range    ,       num_detection_tokens=self.num_detection_tokens    ,       num_labels=self.num_labels    ,       )






					def   __A			( self    ,       A__    ,       A__    ,       A__			):
						A__							:    List[Any]        =		YolosModel(config=A__			)
						model.to(A__			)
						model.eval()
						A__							:    List[Any]        =		model(A__			)
						self.parent.assertEqual(
						    result.last_hidden_state.shape    ,       (self.batch_size, self.expected_seq_len, self.hidden_size)			)






					def   __A			( self    ,       A__    ,       A__    ,       A__			):
						A__							:    Optional[Any]        =		YolosForObjectDetection(A__			)
						model.to(A__			)
						model.eval()

						A__							:    str        =		model(pixel_values=A__			)
						A__							:    List[str]        =		model(A__			)

						self.parent.assertEqual(result.logits.shape    ,       (self.batch_size, self.num_detection_tokens, self.num_labels + 1)			)
						self.parent.assertEqual(result.pred_boxes.shape    ,       (self.batch_size, self.num_detection_tokens, 4)			)

						A__							:    str        =		model(pixel_values=A__    ,       labels=A__			)

						self.parent.assertEqual(result.loss.shape    ,       ()			)
						self.parent.assertEqual(result.logits.shape    ,       (self.batch_size, self.num_detection_tokens, self.num_labels + 1)			)
						self.parent.assertEqual(result.pred_boxes.shape    ,       (self.batch_size, self.num_detection_tokens, 4)			)






					def   __A			( self			):
						A__							:    List[Any]        =		self.prepare_config_and_inputs()
						A__   ,   A__   ,   A__							:    Union[str, Any]        =		config_and_inputs
						A__							:    Union[str, Any]        =		{"""pixel_values""": pixel_values}
						return config, inputs_dict



@require_torch
class     _a						(__magic_name__		,   __magic_name__		,   unittest.TestCase				):


					'''simple docstring'''






					UpperCAmelCase__:   Tuple  							=       (YolosModel, YolosForObjectDetection) if is_torch_available() else ()
					UpperCAmelCase__:   List[str]  							=       (
					    {'''feature-extraction''': YolosModel, '''object-detection''': YolosForObjectDetection} if is_torch_available() else {}
					)

					UpperCAmelCase__:   str  							=       False
					UpperCAmelCase__:   Optional[Any]  							=       False
					UpperCAmelCase__:   str  							=       False
					UpperCAmelCase__:   Any  							=       False






					def   __A			( self    ,       A__    ,       A__    ,       A__=False			):
						A__							:    Dict        =		super()._prepare_for_class(A__    ,       A__    ,       return_labels=A__			)

						if return_labels:
							if model_class.__name__ == "YolosForObjectDetection":
								A__							:    Dict        =		[]
								for i in range(self.model_tester.batch_size			):
									A__							:    str        =		{}
									A__							:    Union[str, Any]        =		torch.ones(
									    size=(self.model_tester.n_targets,)    ,       device=A__    ,       dtype=torch.long			)
									A__							:    str        =		torch.ones(
									    self.model_tester.n_targets    ,       4    ,       device=A__    ,       dtype=torch.float			)
									labels.append(A__			)
								A__							:    Optional[int]        =		labels

						return inputs_dict






					def   __A			( self			):
						A__							:    Dict        =		YolosModelTester(self			)
						A__							:    List[str]        =		ConfigTester(self    ,       config_class=A__    ,       has_text_modality=A__    ,       hidden_size=37			)






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






					def   __A			( self			):
						# YOLOS does not use inputs_embeds
						pass






					def   __A			( self			):
						A__   ,   A__							:    List[str]        =		self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes:
							A__							:    str        =		model_class(A__			)
							self.assertIsInstance(model.get_input_embeddings()    ,       (nn.Module)			)
							A__							:    Dict        =		model.get_output_embeddings()
							self.assertTrue(x is None or isinstance(A__    ,       nn.Linear			)			)






					def   __A			( self			):
						A__   ,   A__							:    Dict        =		self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes:
							A__							:    List[Any]        =		model_class(A__			)
							A__							:    List[str]        =		inspect.signature(model.forward			)
							# signature.parameters is an OrderedDict => so arg_names order is deterministic
							A__							:    List[str]        =		[*signature.parameters.keys()]

							A__							:    int        =		["""pixel_values"""]
							self.assertListEqual(arg_names[:1]    ,       A__			)






					def   __A			( self			):
						A__							:    Union[str, Any]        =		self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*A__			)






					def   __A			( self			):
						A__   ,   A__							:    List[str]        =		self.model_tester.prepare_config_and_inputs_for_common()
						A__							:    Optional[Any]        =		True

						# in YOLOS, the seq_len is different
						A__							:    List[str]        =		self.model_tester.expected_seq_len
						for model_class in self.all_model_classes:
							A__							:    Tuple        =		True
							A__							:    List[str]        =		False
							A__							:    str        =		True
							A__							:    Any        =		model_class(A__			)
							model.to(A__			)
							model.eval()
							with torch.no_grad():
								A__							:    str        =		model(**self._prepare_for_class(A__    ,       A__			)			)
							A__							:    Dict        =		outputs.attentions
							self.assertEqual(len(A__			)    ,       self.model_tester.num_hidden_layers			)

							# check that output_attentions also work using config
							del inputs_dict["output_attentions"]
							A__							:    Dict        =		True
							A__							:    int        =		model_class(A__			)
							model.to(A__			)
							model.eval()
							with torch.no_grad():
								A__							:    int        =		model(**self._prepare_for_class(A__    ,       A__			)			)
							A__							:    Optional[Any]        =		outputs.attentions
							self.assertEqual(len(A__			)    ,       self.model_tester.num_hidden_layers			)

							self.assertListEqual(
							    list(attentions[0].shape[-3:]			)    ,       [self.model_tester.num_attention_heads, seq_len, seq_len]    ,       )
							A__							:    Optional[Any]        =		len(A__			)

							# Check attention is always last and order is fine
							A__							:    Any        =		True
							A__							:    Any        =		True
							A__							:    List[Any]        =		model_class(A__			)
							model.to(A__			)
							model.eval()
							with torch.no_grad():
								A__							:    Optional[Any]        =		model(**self._prepare_for_class(A__    ,       A__			)			)

							A__							:    Union[str, Any]        =		1
							self.assertEqual(out_len + added_hidden_states    ,       len(A__			)			)

							A__							:    Any        =		outputs.attentions

							self.assertEqual(len(A__			)    ,       self.model_tester.num_hidden_layers			)
							self.assertListEqual(
							    list(self_attentions[0].shape[-3:]			)    ,       [self.model_tester.num_attention_heads, seq_len, seq_len]    ,       )






					def   __A			( self			):
						def check_hidden_states_output(A__    ,       A__    ,       A__			):
							A__							:    Any        =		model_class(A__			)
							model.to(A__			)
							model.eval()

							with torch.no_grad():
								A__							:    Tuple        =		model(**self._prepare_for_class(A__    ,       A__			)			)

							A__							:    int        =		outputs.hidden_states

							A__							:    int        =		getattr(
							    self.model_tester    ,       """expected_num_hidden_layers"""    ,       self.model_tester.num_hidden_layers + 1			)
							self.assertEqual(len(A__			)    ,       A__			)

							# YOLOS has a different seq_length
							A__							:    Dict        =		self.model_tester.expected_seq_len

							self.assertListEqual(
							    list(hidden_states[0].shape[-2:]			)    ,       [seq_length, self.model_tester.hidden_size]    ,       )

						A__   ,   A__							:    str        =		self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes:
							A__							:    Union[str, Any]        =		True
							check_hidden_states_output(A__    ,       A__    ,       A__			)

							# check that output_hidden_states also work using config
							del inputs_dict["output_hidden_states"]
							A__							:    Optional[Any]        =		True

							check_hidden_states_output(A__    ,       A__    ,       A__			)






					def   __A			( self			):
						A__							:    List[str]        =		self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_object_detection(*A__			)






					@slow
					def   __A			( self			):
						for model_name in YOLOS_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
							A__							:    Any        =		YolosModel.from_pretrained(A__			)
							self.assertIsNotNone(A__			)



def 						UpperCamelCase					()     ->      Optional[int]:
	A__							:    Union[str, Any]        =		Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""					)
	return image



@require_torch
@require_vision
class     _a						(unittest.TestCase				):


					'''simple docstring'''






					@cached_property
					def   __A			( self			):
						return AutoImageProcessor.from_pretrained("""hustvl/yolos-small"""			) if is_vision_available() else None






					@slow
					def   __A			( self			):
						A__							:    Optional[Any]        =		YolosForObjectDetection.from_pretrained("""hustvl/yolos-small"""			).to(A__			)

						A__							:    List[str]        =		self.default_image_processor
						A__							:    Tuple        =		prepare_img()
						A__							:    Any        =		image_processor(images=A__    ,       return_tensors="""pt"""			).to(A__			)

						# forward pass
						with torch.no_grad():
							A__							:    Any        =		model(inputs.pixel_values			)

						# verify outputs
						A__							:    List[Any]        =		torch.Size((1, 100, 92)			)
						self.assertEqual(outputs.logits.shape    ,       A__			)

						A__							:    Optional[Any]        =		torch.tensor(
						    [[-2_4.0_2_4_8, -1_0.3_0_2_4, -1_4.8_2_9_0], [-4_2.0_3_9_2, -1_6.8_2_0_0, -2_7.4_3_3_4], [-2_7.2_7_4_3, -1_1.8_1_5_4, -1_8.7_1_4_8]]    ,       device=A__    ,       )
						A__							:    Tuple        =		torch.tensor(
						    [[0.2_5_5_9, 0.5_4_5_5, 0.4_7_0_6], [0.2_9_8_9, 0.7_2_7_9, 0.1_8_7_5], [0.7_7_3_2, 0.4_0_1_7, 0.4_4_6_2]]    ,       device=A__			)
						self.assertTrue(torch.allclose(outputs.logits[0, :3, :3]    ,       A__    ,       atol=1e-4			)			)
						self.assertTrue(torch.allclose(outputs.pred_boxes[0, :3, :3]    ,       A__    ,       atol=1e-4			)			)

						# verify postprocessing
						A__							:    Union[str, Any]        =		image_processor.post_process_object_detection(
						    A__    ,       threshold=0.3    ,       target_sizes=[image.size[::-1]]			)[0]
						A__							:    Optional[Any]        =		torch.tensor([0.9_9_9_4, 0.9_7_9_0, 0.9_9_6_4, 0.9_9_7_2, 0.9_8_6_1]			).to(A__			)
						A__							:    Optional[Any]        =		[75, 75, 17, 63, 17]
						A__							:    List[str]        =		torch.tensor([3_3_5.0_6_0_9, 7_9.3_8_4_8, 3_7_5.4_2_1_6, 1_8_7.2_4_9_5]			).to(A__			)

						self.assertEqual(len(results["""scores"""]			)    ,       5			)
						self.assertTrue(torch.allclose(results["""scores"""]    ,       A__    ,       atol=1e-4			)			)
						self.assertSequenceEqual(results["""labels"""].tolist()    ,       A__			)
						self.assertTrue(torch.allclose(results["""boxes"""][0, :]    ,       A__			)			)






import warnings

from ...utils import logging
from .image_processing_donut import DonutImageProcessor


A_       : Union[str, Any]         =			logging.get_logger(__name__)



class     _a						(__magic_name__				):


					'''simple docstring'''






					def __init__( self    ,       *A__    ,       **A__			):
						warnings.warn(
						    """The class DonutFeatureExtractor is deprecated and will be removed in version 5 of Transformers. Please"""
						    """ use DonutImageProcessor instead."""    ,       A__    ,       )
						super().__init__(*A__    ,       **A__			)



