



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

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


    """simple docstring"""






    a							=		parent
    a							=		batch_size
    a							=		image_size
    a							=		patch_size
    a							=		num_channels
    a							=		is_training
    a							=		use_labels
    a							=		hidden_size
    a							=		num_hidden_layers
    a							=		backbone_out_indices
    a							=		num_attention_heads
    a							=		intermediate_size
    a							=		hidden_act
    a							=		hidden_dropout_prob
    a							=		attention_probs_dropout_prob
    a							=		initializer_range
    a							=		num_labels
    a							=		scope
    a							=		is_hybrid
    # sequence length of DPT = num_patches + 1 (we add 1 for the [CLS] token)
    a							=		(image_size // patch_size) ** 2
    a							=		num_patches + 1

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


    """simple docstring"""






    a							=		floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]				)

    a							=		None
    if self.use_labels:
     a							=		ids_tensor([self.batch_size, self.image_size, self.image_size]				, self.num_labels				)

    a							=		self.get_config()

    return config, pixel_values, labels

   def 		A				(   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 		A				(   self      :							List[Any]				, __lowerCAmelCase      :							Dict				, __lowerCAmelCase      :							str				, __lowerCAmelCase      :							Tuple				)							->					int:


    """simple docstring"""






    a							=		DPTModel(config=_A				)
    model.to(_A				)
    model.eval()
    a							=		model(_A				)
    self.parent.assertEqual(result.last_hidden_state.shape				, (self.batch_size, self.seq_length, self.hidden_size)				)

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


    """simple docstring"""






    a							=		self.num_labels
    a							=		DPTForDepthEstimation(_A				)
    model.to(_A				)
    model.eval()
    a							=		model(_A				)
    self.parent.assertEqual(result.predicted_depth.shape				, (self.batch_size, self.image_size, self.image_size)				)

   def 		A				(   self      :							List[Any]				, __lowerCAmelCase      :							Tuple				, __lowerCAmelCase      :							Tuple				, __lowerCAmelCase      :							Optional[Any]				)							->					List[Any]:


    """simple docstring"""






    a							=		self.num_labels
    a							=		DPTForSemanticSegmentation(_A				)
    model.to(_A				)
    model.eval()
    a							=		model(_A				, labels=_A				)
    self.parent.assertEqual(
        result.logits.shape				, (self.batch_size, self.num_labels, self.image_size, self.image_size)				)




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


    """simple docstring"""






    a							=		self.prepare_config_and_inputs()
    a							=		config_and_inputs
    a							=		{'pixel_values': pixel_values}
    return config, inputs_dict



@require_torch
class 		_lowercase		(							snake_case_, snake_case_, unittest.TestCase						):
   _UpperCAmelCase  						=      (DPTModel, DPTForDepthEstimation, DPTForSemanticSegmentation) if is_torch_available() else ()
   _UpperCAmelCase  						=      (
       {
           "depth-estimation": DPTForDepthEstimation,
           "feature-extraction": DPTModel,
           "image-segmentation": DPTForSemanticSegmentation,
       }
       if is_torch_available()
       else {}
   )

   _UpperCAmelCase  						=      False
   _UpperCAmelCase  						=      False
   _UpperCAmelCase  						=      False

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


    """simple docstring"""






    a							=		DPTModelTester(self				)
    a							=		ConfigTester(self				, config_class=_A				, has_text_modality=_A				, hidden_size=37				)

   def 		A				(   self      :							str				)							->					Any:


    """simple docstring"""






    self.config_tester.run_common_tests()

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


    """simple docstring"""






    pass

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


    """simple docstring"""






    a							=		self.model_tester.prepare_config_and_inputs_for_common()

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

   def 		A				(   self      :							Tuple				)							->					str:


    """simple docstring"""






    a							=		self.model_tester.prepare_config_and_inputs_for_common()

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

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

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


    """simple docstring"""






    a							=		self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_model(*_A				)

   def 		A				(   self      :							Any				)							->					Tuple:


    """simple docstring"""






    a							=		self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_depth_estimation(*_A				)

   def 		A				(   self      :							str				)							->					int:


    """simple docstring"""






    a							=		self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_semantic_segmentation(*_A				)

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


    """simple docstring"""






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

     a							=		self.model_tester.prepare_config_and_inputs_for_common()
     a							=		True

     if model_class in get_values(_A				):
      continue

     a							=		model_class(_A				)
     model.to(_A				)
     model.train()
     a							=		self._prepare_for_class(_A				, _A				, return_labels=_A				)
     a							=		model(**_A				).loss
     loss.backward()

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


    """simple docstring"""






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

     a							=		self.model_tester.prepare_config_and_inputs_for_common()
     a							=		False
     a							=		True

     if model_class in get_values(_A				) or not model_class.supports_gradient_checkpointing:
      continue
     a							=		model_class(_A				)
     model.to(_A				)
     model.gradient_checkpointing_enable()
     model.train()
     a							=		self._prepare_for_class(_A				, _A				, return_labels=_A				)
     a							=		model(**_A				).loss
     loss.backward()

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


    """simple docstring"""






    a							=		self.model_tester.prepare_config_and_inputs_for_common()

    a							=		_config_zero_init(_A				)
    for model_class in self.all_model_classes:
     a							=		model_class(config=_A				)
     # Skip the check for the backbone
     a							=		[]
     for name, module in model.named_modules():
      if module.__class__.__name__ == "DPTViTHybridEmbeddings":
       a							=		[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 		A				(   self      :							List[str]				)							->					Tuple:


    """simple docstring"""






    pass




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


    """simple docstring"""






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


def 						UpperCAmelCase__   (   ):






 '''simple docstring'''

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




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

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


    """simple docstring"""






    a							=		DPTImageProcessor.from_pretrained("Intel/dpt-large"				)
    a							=		DPTForDepthEstimation.from_pretrained("Intel/dpt-large"				).to(_A				)

    a							=		prepare_img()
    a							=		image_processor(images=_A				, return_tensors="pt"				).to(_A				)

    # forward pass
    with torch.no_grad():
     a							=		model(**_A				)
     a							=		outputs.predicted_depth

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

    a							=		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 		A				(   self      :							Union[str, Any]				)							->					Union[str, Any]:


    """simple docstring"""






    a							=		DPTImageProcessor.from_pretrained("Intel/dpt-large-ade"				)
    a							=		DPTForSemanticSegmentation.from_pretrained("Intel/dpt-large-ade"				).to(_A				)

    a							=		prepare_img()
    a							=		image_processor(images=_A				, return_tensors="pt"				).to(_A				)

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

    # verify the logits
    a							=		torch.Size((1, 150, 480, 480)				)
    self.assertEqual(outputs.logits.shape				, _A				)

    a							=		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 		A				(   self      :							List[str]				)							->					Any:


    """simple docstring"""






    a							=		DPTImageProcessor.from_pretrained("Intel/dpt-large-ade"				)
    a							=		DPTForSemanticSegmentation.from_pretrained("Intel/dpt-large-ade"				).to(_A				)

    a							=		prepare_img()
    a							=		image_processor(images=_A				, return_tensors="pt"				).to(_A				)

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

    a							=		outputs.logits.detach().cpu()

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

    a							=		image_processor.post_process_semantic_segmentation(outputs=_A				)
    a							=		torch.Size((480, 480)				)
    self.assertEqual(segmentation[0].shape				, _A				)








import unittest
from pathlib import Path
from tempfile import TemporaryDirectory
from unittest.mock import Mock, patch

import diffusers.utils.hub_utils
class SCREAMING_SNAKE_CASE_    (       unittest.TestCase       ):






						@patch('diffusers.utils.hub_utils.get_full_repo_name'						)
						def UpperCAmelCase_					(   self   :   Optional[int]		, _A   :   Mock						)				->     None:







							"""simple docstring"""


							snake_case_		:      Optional[Any]           =						'full_repo_name'
							with TemporaryDirectory() as tmpdir:
								# Dummy args values
								snake_case_		:      Optional[int]           =						Mock()
								snake_case_		:      Union[str, Any]           =						tmpdir
								snake_case_		:      Optional[Any]           =						0
								snake_case_		:      Union[str, Any]           =						'hub_token'
								snake_case_		:      Any           =						'dataset_name'
								snake_case_		:      Tuple           =						0.0_1
								snake_case_		:      Dict           =						100000
								snake_case_		:      Any           =						10000
								snake_case_		:      str           =						0.0_1
								snake_case_		:      Any           =						0.0_2
								snake_case_		:      Optional[Any]           =						0.0_3
								snake_case_		:      Tuple           =						0.0_0_0_5
								snake_case_		:      Tuple           =						0.0_0_0_0_0_1
								snake_case_		:      str           =						1
								snake_case_		:      Optional[int]           =						10
								snake_case_		:      List[str]           =						0.0_0_1
								snake_case_		:      Any           =						0.1
								snake_case_		:      List[str]           =						0.2
								snake_case_		:      Dict           =						True

								# Model card mush be rendered and saved
								diffusers.utils.hub_utils.create_model_card(_A		, model_name='model_name'						)
								self.assertTrue((Path(_A						) / 'README.md').is_file()						)

