





import inspect
import unittest

from transformers import DPTConfig
from transformers.file_utils import is_torch_available, is_vision_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_vision, slow, torch_device

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


if is_torch_available():
						import torch
						from torch import nn

						from transformers import MODEL_MAPPING, DPTForDepthEstimation, DPTForSemanticSegmentation, DPTModel
						from transformers.models.dpt.modeling_dpt import DPT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
						from PIL import Image

						from transformers import DPTImageProcessor
class SCREAMING_SNAKE_CASE_    :






						def __init__(   self   :   List[str]		, _A   :   Optional[Any]		, _A   :   List[str]=2		, _A   :   Dict=32		, _A   :   str=16		, _A   :   Tuple=3		, _A   :   List[str]=True		, _A   :   str=True		, _A   :   str=32		, _A   :   List[Any]=4		, _A   :   Any=[0, 1, 2, 3]		, _A   :   Any=4		, _A   :   Tuple=37		, _A   :   List[Any]="gelu"		, _A   :   Dict=0.1		, _A   :   Tuple=0.1		, _A   :   str=0.0_2		, _A   :   Dict=3		, _A   :   Dict=False		, _A   :   Union[str, Any]=None		, )				->     Optional[int]:







							"""simple docstring"""


							snake_case_		:      Optional[int]           =						parent
							snake_case_		:      Any           =						batch_size
							snake_case_		:      List[str]           =						image_size
							snake_case_		:      Tuple           =						patch_size
							snake_case_		:      str           =						num_channels
							snake_case_		:      Any           =						is_training
							snake_case_		:      Dict           =						use_labels
							snake_case_		:      str           =						hidden_size
							snake_case_		:      Dict           =						num_hidden_layers
							snake_case_		:      Dict           =						backbone_out_indices
							snake_case_		:      Optional[int]           =						num_attention_heads
							snake_case_		:      str           =						intermediate_size
							snake_case_		:      int           =						hidden_act
							snake_case_		:      int           =						hidden_dropout_prob
							snake_case_		:      str           =						attention_probs_dropout_prob
							snake_case_		:      Optional[int]           =						initializer_range
							snake_case_		:      List[Any]           =						num_labels
							snake_case_		:      Dict           =						scope
							snake_case_		:      List[str]           =						is_hybrid
							# sequence length of DPT = num_patches + 1 (we add 1 for the [CLS] token)
							snake_case_		:      Union[str, Any]           =						(image_size // patch_size) ** 2
							snake_case_		:      Any           =						num_patches + 1






						def UpperCAmelCase_					(   self   :   Dict						)				->     Union[str, Any]:







							"""simple docstring"""


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

							snake_case_		:      Tuple           =						None
							if self.use_labels:
								snake_case_		:      Optional[int]           =						ids_tensor([self.batch_size, self.image_size, self.image_size]		, self.num_labels						)

							snake_case_		:      Optional[int]           =						self.get_config()

							return config, pixel_values, labels






						def UpperCAmelCase_					(   self   :   List[Any]						)				->     Any:







							"""simple docstring"""


							return DPTConfig(
							    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		, backbone_out_indices=self.backbone_out_indices		, 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		, is_hybrid=self.is_hybrid		, )






						def UpperCAmelCase_					(   self   :   List[Any]		, _A   :   Dict		, _A   :   str		, _A   :   Tuple						)				->     int:







							"""simple docstring"""


							snake_case_		:      List[Any]           =						DPTModel(config=_A						)
							model.to(_A						)
							model.eval()
							snake_case_		:      int           =						model(_A						)
							self.parent.assertEqual(result.last_hidden_state.shape		, (self.batch_size, self.seq_length, self.hidden_size)						)






						def UpperCAmelCase_					(   self   :   List[Any]		, _A   :   Optional[Any]		, _A   :   Optional[Any]		, _A   :   Union[str, Any]						)				->     Tuple:







							"""simple docstring"""


							snake_case_		:      Union[str, Any]           =						self.num_labels
							snake_case_		:      Any           =						DPTForDepthEstimation(_A						)
							model.to(_A						)
							model.eval()
							snake_case_		:      int           =						model(_A						)
							self.parent.assertEqual(result.predicted_depth.shape		, (self.batch_size, self.image_size, self.image_size)						)






						def UpperCAmelCase_					(   self   :   List[Any]		, _A   :   Tuple		, _A   :   Tuple		, _A   :   Optional[Any]						)				->     List[Any]:







							"""simple docstring"""


							snake_case_		:      str           =						self.num_labels
							snake_case_		:      Optional[Any]           =						DPTForSemanticSegmentation(_A						)
							model.to(_A						)
							model.eval()
							snake_case_		:      Any           =						model(_A		, labels=_A						)
							self.parent.assertEqual(
							    result.logits.shape		, (self.batch_size, self.num_labels, self.image_size, self.image_size)						)






						def UpperCAmelCase_					(   self   :   Union[str, Any]						)				->     List[Any]:







							"""simple docstring"""


							snake_case_		:      int           =						self.prepare_config_and_inputs()
							snake_case_    ,snake_case_    ,snake_case_		:      Any           =						config_and_inputs
							snake_case_		:      int           =						{'pixel_values': pixel_values}
							return config, inputs_dict
@require_torch
class SCREAMING_SNAKE_CASE_    (       snake_case_							,					snake_case_							,					unittest.TestCase       ):
						__magic_name__:      Optional[int]			   =							(DPTModel, DPTForDepthEstimation, DPTForSemanticSegmentation) if is_torch_available() else ()
						__magic_name__:      List[str]			   =							(
						    {
						        "depth-estimation": DPTForDepthEstimation,
						        "feature-extraction": DPTModel,
						        "image-segmentation": DPTForSemanticSegmentation,
						    }
						    if is_torch_available()
						    else {}
						)

						__magic_name__:      int			   =							False
						__magic_name__:      Optional[Any]			   =							False
						__magic_name__:      List[Any]			   =							False






						def UpperCAmelCase_					(   self   :   List[Any]						)				->     Any:







							"""simple docstring"""


							snake_case_		:      List[str]           =						DPTModelTester(self						)
							snake_case_		:      List[str]           =						ConfigTester(self		, config_class=_A		, has_text_modality=_A		, hidden_size=37						)






						def UpperCAmelCase_					(   self   :   str						)				->     Any:







							"""simple docstring"""


							self.config_tester.run_common_tests()






						@unittest.skip(reason='DPT does not use inputs_embeds'						)
						def UpperCAmelCase_					(   self   :   Dict						)				->     Tuple:







							"""simple docstring"""


							pass






						def UpperCAmelCase_					(   self   :   Union[str, Any]						)				->     Union[str, Any]:







							"""simple docstring"""


							snake_case_    ,snake_case_		:      Union[str, Any]           =						self.model_tester.prepare_config_and_inputs_for_common()

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






						def UpperCAmelCase_					(   self   :   Tuple						)				->     str:







							"""simple docstring"""


							snake_case_    ,snake_case_		:      Any           =						self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
								snake_case_		:      Optional[int]           =						model_class(_A						)
								snake_case_		:      Union[str, Any]           =						inspect.signature(model.forward						)
								# signature.parameters is an OrderedDict => so arg_names order is deterministic
								snake_case_		:      Dict           =						[*signature.parameters.keys()]

								snake_case_		:      Dict           =						['pixel_values']
								self.assertListEqual(arg_names[:1]		, _A						)






						def UpperCAmelCase_					(   self   :   List[str]						)				->     str:







							"""simple docstring"""


							snake_case_		:      Optional[int]           =						self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*_A						)






						def UpperCAmelCase_					(   self   :   Any						)				->     Tuple:







							"""simple docstring"""


							snake_case_		:      int           =						self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_depth_estimation(*_A						)






						def UpperCAmelCase_					(   self   :   str						)				->     int:







							"""simple docstring"""


							snake_case_		:      Tuple           =						self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_semantic_segmentation(*_A						)






						def UpperCAmelCase_					(   self   :   List[str]						)				->     Union[str, Any]:







							"""simple docstring"""


							for model_class in self.all_model_classes:
								if model_class.__name__ == "DPTForDepthEstimation":
									continue

								snake_case_    ,snake_case_		:      Optional[Any]           =						self.model_tester.prepare_config_and_inputs_for_common()
								snake_case_		:      Union[str, Any]           =						True

								if model_class in get_values(_A						):
									continue

								snake_case_		:      Tuple           =						model_class(_A						)
								model.to(_A						)
								model.train()
								snake_case_		:      Optional[Any]           =						self._prepare_for_class(_A		, _A		, return_labels=_A						)
								snake_case_		:      List[Any]           =						model(**_A						).loss
								loss.backward()






						def UpperCAmelCase_					(   self   :   Optional[Any]						)				->     List[Any]:







							"""simple docstring"""


							for model_class in self.all_model_classes:
								if model_class.__name__ == "DPTForDepthEstimation":
									continue

								snake_case_    ,snake_case_		:      Optional[Any]           =						self.model_tester.prepare_config_and_inputs_for_common()
								snake_case_		:      Any           =						False
								snake_case_		:      List[str]           =						True

								if model_class in get_values(_A						) or not model_class.supports_gradient_checkpointing:
									continue
								snake_case_		:      Union[str, Any]           =						model_class(_A						)
								model.to(_A						)
								model.gradient_checkpointing_enable()
								model.train()
								snake_case_		:      int           =						self._prepare_for_class(_A		, _A		, return_labels=_A						)
								snake_case_		:      Union[str, Any]           =						model(**_A						).loss
								loss.backward()






						def UpperCAmelCase_					(   self   :   Union[str, Any]						)				->     Tuple:







							"""simple docstring"""


							snake_case_    ,snake_case_		:      int           =						self.model_tester.prepare_config_and_inputs_for_common()

							snake_case_		:      str           =						_config_zero_init(_A						)
							for model_class in self.all_model_classes:
								snake_case_		:      Union[str, Any]           =						model_class(config=_A						)
								# Skip the check for the backbone
								snake_case_		:      int           =						[]
								for name, module in model.named_modules():
									if module.__class__.__name__ == "DPTViTHybridEmbeddings":
										snake_case_		:      Optional[Any]           =						[F"""{name}.{key}""" for key in module.state_dict().keys()]
										break

								for name, param in model.named_parameters():
									if param.requires_grad:
										if name in backbone_params:
											continue
										self.assertIn(
										    ((param.data.mean() * 1E9).round() / 1E9).item()		, [0.0, 1.0]		, msg=F"""Parameter {name} of model {model_class} seems not properly initialized"""		, )






						@unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.'						)
						def UpperCAmelCase_					(   self   :   List[str]						)				->     Tuple:







							"""simple docstring"""


							pass






						@slow
						def UpperCAmelCase_					(   self   :   Tuple						)				->     List[str]:







							"""simple docstring"""


							for model_name in DPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
								snake_case_		:      int           =						DPTModel.from_pretrained(_A						)
								self.assertIsNotNone(_A						)


def 				SCREAMING_SNAKE_CASE__    (     ):
	snake_case_		:      List[str]           =						Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png' )
	return image


@require_torch
@require_vision
@slow
class SCREAMING_SNAKE_CASE_    (       unittest.TestCase       ):






						def UpperCAmelCase_					(   self   :   List[Any]						)				->     Optional[int]:







							"""simple docstring"""


							snake_case_		:      Tuple           =						DPTImageProcessor.from_pretrained('Intel/dpt-large'						)
							snake_case_		:      Optional[int]           =						DPTForDepthEstimation.from_pretrained('Intel/dpt-large'						).to(_A						)

							snake_case_		:      Optional[Any]           =						prepare_img()
							snake_case_		:      Optional[int]           =						image_processor(images=_A		, return_tensors='pt'						).to(_A						)

							# forward pass
							with torch.no_grad():
								snake_case_		:      Optional[Any]           =						model(**_A						)
								snake_case_		:      int           =						outputs.predicted_depth

							# verify the predicted depth
							snake_case_		:      Any           =						torch.Size((1, 384, 384)						)
							self.assertEqual(predicted_depth.shape		, _A						)

							snake_case_		:      Optional[Any]           =						torch.tensor(
							    [[6.3_1_9_9, 6.3_6_2_9, 6.4_1_4_8], [6.3_8_5_0, 6.3_6_1_5, 6.4_1_6_6], [6.3_5_1_9, 6.3_1_7_6, 6.3_5_7_5]]						).to(_A						)

							self.assertTrue(torch.allclose(outputs.predicted_depth[0, :3, :3]		, _A		, atol=1E-4						)						)






						def UpperCAmelCase_					(   self   :   Union[str, Any]						)				->     Union[str, Any]:







							"""simple docstring"""


							snake_case_		:      Optional[int]           =						DPTImageProcessor.from_pretrained('Intel/dpt-large-ade'						)
							snake_case_		:      Union[str, Any]           =						DPTForSemanticSegmentation.from_pretrained('Intel/dpt-large-ade'						).to(_A						)

							snake_case_		:      Union[str, Any]           =						prepare_img()
							snake_case_		:      str           =						image_processor(images=_A		, return_tensors='pt'						).to(_A						)

							# forward pass
							with torch.no_grad():
								snake_case_		:      Any           =						model(**_A						)

							# verify the logits
							snake_case_		:      List[str]           =						torch.Size((1, 150, 480, 480)						)
							self.assertEqual(outputs.logits.shape		, _A						)

							snake_case_		:      Optional[int]           =						torch.tensor(
							    [[4.0_4_8_0, 4.2_4_2_0, 4.4_3_6_0], [4.3_1_2_4, 4.5_6_9_3, 4.8_2_6_1], [4.5_7_6_8, 4.8_9_6_5, 5.2_1_6_3]]						).to(_A						)

							self.assertTrue(torch.allclose(outputs.logits[0, 0, :3, :3]		, _A		, atol=1E-4						)						)






						def UpperCAmelCase_					(   self   :   List[str]						)				->     Any:







							"""simple docstring"""


							snake_case_		:      int           =						DPTImageProcessor.from_pretrained('Intel/dpt-large-ade'						)
							snake_case_		:      Optional[int]           =						DPTForSemanticSegmentation.from_pretrained('Intel/dpt-large-ade'						).to(_A						)

							snake_case_		:      Dict           =						prepare_img()
							snake_case_		:      Union[str, Any]           =						image_processor(images=_A		, return_tensors='pt'						).to(_A						)

							# forward pass
							with torch.no_grad():
								snake_case_		:      Optional[Any]           =						model(**_A						)

							snake_case_		:      Any           =						outputs.logits.detach().cpu()

							snake_case_		:      Dict           =						image_processor.post_process_semantic_segmentation(outputs=_A		, target_sizes=[(500, 300)]						)
							snake_case_		:      Dict           =						torch.Size((500, 300)						)
							self.assertEqual(segmentation[0].shape		, _A						)

							snake_case_		:      Optional[int]           =						image_processor.post_process_semantic_segmentation(outputs=_A						)
							snake_case_		:      List[Any]           =						torch.Size((480, 480)						)
							self.assertEqual(segmentation[0].shape		, _A						)


'''simple docstring'''


from itertools import combinations, product


def    _lowerCamelCase       ( lowerCamelCase_   :				int      ,	lowerCamelCase_   :				int      ,	lowerCamelCase_   :				int      ,	lowerCamelCase_   :				int  ):



     """simple docstring"""





     if xa == ya == 0 or xa == ya == 0:
          return False
     UpperCAmelCase_				:  Union[str, Any]  = xa * xa + ya * ya
     UpperCAmelCase_				:  str  = xa * xa + ya * ya
     UpperCAmelCase_				:  str  = (xa - xa) * (xa - xa) + (ya - ya) * (ya - ya)
     return (
         a_square + b_square == c_square
         or a_square + c_square == b_square
         or b_square + c_square == a_square
     )


def    _lowerCamelCase       ( lowerCamelCase_   :				int = 50  ):



     """simple docstring"""





     return sum(
         1
         for pta, pta in combinations(product(range(limit + 1  )      ,	repeat=2  )      ,	2  )
         if is_right(*lowerCamelCase_      ,	*lowerCamelCase_  )  )


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






