



import copy
import tempfile
import unittest

from huggingface_hub import HfFolder, delete_repo
from parameterized import parameterized
from requests.exceptions import HTTPError

from transformers import AutoConfig, GenerationConfig
from transformers.testing_utils import TOKEN, USER, is_staging_test


class       a							(			unittest.TestCase				):



		@parameterized.expand([(None,), ('''foo.json''',)]  )
		def 	__lowerCamelCase			(     self     :List[str]   ,__lowercase     :Tuple  ):
						snake_case__	:      List[Any]     		=	GenerationConfig(
						    do_sample=__lowercase   ,temperature=0.7   ,length_penalty=1.0   ,bad_words_ids=[[1, 2, 3], [4, 5]]   ,)
						with tempfile.TemporaryDirectory() as tmp_dir:
										config.save_pretrained(__lowercase   ,config_name=__lowercase  )
										snake_case__	:      Dict     		=	GenerationConfig.from_pretrained(__lowercase   ,config_name=__lowercase  )

						# Checks parameters that were specified
						self.assertEqual(loaded_config.do_sample   ,__lowercase  )
						self.assertEqual(loaded_config.temperature   ,0.7  )
						self.assertEqual(loaded_config.length_penalty   ,1.0  )
						self.assertEqual(loaded_config.bad_words_ids   ,[[1, 2, 3], [4, 5]]  )

						# Checks parameters that were not specified (defaults)
						self.assertEqual(loaded_config.top_k   ,5_0  )
						self.assertEqual(loaded_config.max_length   ,2_0  )
						self.assertEqual(loaded_config.max_time   ,__lowercase  )



		def 	__lowerCamelCase			(     self     :Any  ):
						snake_case__	:      List[Any]     		=	AutoConfig.from_pretrained('''gpt2'''  )
						snake_case__	:      Dict     		=	GenerationConfig.from_model_config(__lowercase  )
						snake_case__	:      str     		=	GenerationConfig()

						# The generation config has loaded a few non-default parameters from the model config
						self.assertNotEqual(__lowercase   ,__lowercase  )

						# One of those parameters is eos_token_id -- check if it matches
						self.assertNotEqual(generation_config_from_model.eos_token_id   ,default_generation_config.eos_token_id  )
						self.assertEqual(generation_config_from_model.eos_token_id   ,model_config.eos_token_id  )



		def 	__lowerCamelCase			(     self     :List[str]  ):
						snake_case__	:      List[str]     		=	GenerationConfig()
						snake_case__	:      List[Any]     		=	{
						    '''max_new_tokens''': 1_0_2_4,
						    '''foo''': '''bar''',
						}
						snake_case__	:      Union[str, Any]     		=	copy.deepcopy(__lowercase  )
						snake_case__	:      Any     		=	generation_config.update(**__lowercase  )

						# update_kwargs was not modified (no side effects)
						self.assertEqual(__lowercase   ,__lowercase  )

						# update_kwargs was used to update the config on valid attributes
						self.assertEqual(generation_config.max_new_tokens   ,1_0_2_4  )

						# `.update()` returns a dictionary of unused kwargs
						self.assertEqual(__lowercase   ,{'''foo''': '''bar'''}  )



		def 	__lowerCamelCase			(     self     :int  ):
						snake_case__	:      Dict     		=	GenerationConfig()
						snake_case__	:      Optional[int]     		=	'''bar'''

						with tempfile.TemporaryDirectory('''test-generation-config'''  ) as tmp_dir:
										generation_config.save_pretrained(__lowercase  )

										snake_case__	:      Optional[Any]     		=	GenerationConfig.from_pretrained(__lowercase  )
						# update_kwargs was used to update the config on valid attributes
						self.assertEqual(new_config.foo   ,'''bar'''  )

						snake_case__	:      Tuple     		=	GenerationConfig.from_model_config(__lowercase  )
						assert not hasattr(__lowercase   ,'''foo'''  )  # no new kwargs should be initialized if from config






		def 	__lowerCamelCase			(     self     :Any  ):
						snake_case__	:      List[str]     		=	GenerationConfig()
						self.assertEqual(default_config.temperature   ,1.0  )
						self.assertEqual(default_config.do_sample   ,__lowercase  )
						self.assertEqual(default_config.num_beams   ,1  )

						snake_case__	:      int     		=	GenerationConfig(
						    do_sample=__lowercase   ,temperature=0.7   ,length_penalty=1.0   ,bad_words_ids=[[1, 2, 3], [4, 5]]   ,)
						self.assertEqual(config.temperature   ,0.7  )
						self.assertEqual(config.do_sample   ,__lowercase  )
						self.assertEqual(config.num_beams   ,1  )

						with tempfile.TemporaryDirectory() as tmp_dir:
										config.save_pretrained(__lowercase  )
										snake_case__	:      Optional[int]     		=	GenerationConfig.from_pretrained(__lowercase   ,temperature=1.0  )

						self.assertEqual(loaded_config.temperature   ,1.0  )
						self.assertEqual(loaded_config.do_sample   ,__lowercase  )
						self.assertEqual(loaded_config.num_beams   ,1  )  # default value


@is_staging_test
class       a							(			unittest.TestCase				):



		@classmethod
		def 	__lowerCamelCase			(     cls     :Any  ):
						snake_case__	:      str     		=	TOKEN
						HfFolder.save_token(__lowercase  )



		@classmethod
		def 	__lowerCamelCase			(     cls     :Union[str, Any]  ):
						try:
										delete_repo(token=cls._token   ,repo_id='''test-generation-config'''  )
						except HTTPError:
										pass

						try:
										delete_repo(token=cls._token   ,repo_id='''valid_org/test-generation-config-org'''  )
						except HTTPError:
										pass



		def 	__lowerCamelCase			(     self     :Dict  ):
						snake_case__	:      List[str]     		=	GenerationConfig(
						    do_sample=__lowercase   ,temperature=0.7   ,length_penalty=1.0   ,)
						config.push_to_hub('''test-generation-config'''   ,use_auth_token=self._token  )

						snake_case__	:      Union[str, Any]     		=	GenerationConfig.from_pretrained(F"""{USER}/test-generation-config"""  )
						for k, v in config.to_dict().items():
										if k != "transformers_version":
														self.assertEqual(__lowercase   ,getattr(__lowercase   ,__lowercase  )  )

        # Reset repo
						delete_repo(token=self._token   ,repo_id='''test-generation-config'''  )

						# Push to hub via save_pretrained
						with tempfile.TemporaryDirectory() as tmp_dir:
										config.save_pretrained(
										    __lowercase   ,repo_id='''test-generation-config'''   ,push_to_hub=__lowercase   ,use_auth_token=self._token  )

						snake_case__	:      Tuple     		=	GenerationConfig.from_pretrained(F"""{USER}/test-generation-config"""  )
						for k, v in config.to_dict().items():
										if k != "transformers_version":
														self.assertEqual(__lowercase   ,getattr(__lowercase   ,__lowercase  )  )






		def 	__lowerCamelCase			(     self     :Optional[int]  ):
						snake_case__	:      Tuple     		=	GenerationConfig(
						    do_sample=__lowercase   ,temperature=0.7   ,length_penalty=1.0   ,)
						config.push_to_hub('''valid_org/test-generation-config-org'''   ,use_auth_token=self._token  )

						snake_case__	:      Any     		=	GenerationConfig.from_pretrained('''valid_org/test-generation-config-org'''  )
						for k, v in config.to_dict().items():
										if k != "transformers_version":
														self.assertEqual(__lowercase   ,getattr(__lowercase   ,__lowercase  )  )

        # Reset repo
						delete_repo(token=self._token   ,repo_id='''valid_org/test-generation-config-org'''  )

						# Push to hub via save_pretrained
						with tempfile.TemporaryDirectory() as tmp_dir:
										config.save_pretrained(
										    __lowercase   ,repo_id='''valid_org/test-generation-config-org'''   ,push_to_hub=__lowercase   ,use_auth_token=self._token  )

						snake_case__	:      List[str]     		=	GenerationConfig.from_pretrained('''valid_org/test-generation-config-org'''  )
						for k, v in config.to_dict().items():
										if k != "transformers_version":
														self.assertEqual(__lowercase   ,getattr(__lowercase   ,__lowercase  )  )









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

				"""simple docstring"""




				def __init__(     self						:    str,  lowerCamelCase						:    Dict,  lowerCamelCase						:    List[str]=2,  lowerCamelCase						:    List[str]=32,  lowerCamelCase						:    Tuple=16,  lowerCamelCase						:    List[Any]=3,  lowerCamelCase						:    List[Any]=True,  lowerCamelCase						:    str=True,  lowerCamelCase						:    Tuple=32,  lowerCamelCase						:    Dict=4,  lowerCamelCase						:    Dict=[0, 1, 2, 3],  lowerCamelCase						:    Union[str, Any]=4,  lowerCamelCase						:    Optional[int]=37,  lowerCamelCase						:    Optional[Any]="gelu",  lowerCamelCase						:    List[Any]=0.1,  lowerCamelCase						:    Optional[Any]=0.1,  lowerCamelCase						:    Optional[int]=0.02,  lowerCamelCase						:    str=3,  lowerCamelCase						:    str=[1, 384, 24, 24],  lowerCamelCase						:    Optional[int]=True,  lowerCamelCase						:    List[str]=None,  ):

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




				def 				lowercase__   (     self						:    Tuple  ):

								'''simple docstring'''
								lowercase__    =			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]  )

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

								lowercase__    =			self.get_config()

								return config, pixel_values, labels




				def 				lowercase__   (     self						:    List[str]  ):

								'''simple docstring'''
								lowercase__    =			{
								    '''global_padding''': '''same''',
								    '''layer_type''': '''bottleneck''',
								    '''depths''': [3, 4, 9],
								    '''out_features''': ['''stage1''', '''stage2''', '''stage3'''],
								    '''embedding_dynamic_padding''': True,
								    '''hidden_sizes''': [96, 192, 384, 768],
								    '''num_groups''': 2,
								}

								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=lowerCamelCase,  initializer_range=self.initializer_range,  is_hybrid=self.is_hybrid,  backbone_config=lowerCamelCase,  backbone_featmap_shape=self.backbone_featmap_shape,  )




				def 				lowercase__   (     self						:    str,  lowerCamelCase						:    Optional[Any],  lowerCamelCase						:    Optional[int],  lowerCamelCase						:    Union[str, Any]  ):

								'''simple docstring'''
								lowercase__    =			DPTModel(config=lowerCamelCase  )
								model.to(lowerCamelCase  )
								model.eval()
								lowercase__    =			model(lowerCamelCase  )
								self.parent.assertEqual(result.last_hidden_state.shape,  (self.batch_size, self.seq_length, self.hidden_size)  )




				def 				lowercase__   (     self						:    List[Any],  lowerCamelCase						:    Union[str, Any],  lowerCamelCase						:    List[str],  lowerCamelCase						:    int  ):

								'''simple docstring'''
								lowercase__    =			self.num_labels
								lowercase__    =			DPTForDepthEstimation(lowerCamelCase  )
								model.to(lowerCamelCase  )
								model.eval()
								lowercase__    =			model(lowerCamelCase  )
								self.parent.assertEqual(result.predicted_depth.shape,  (self.batch_size, self.image_size, self.image_size)  )




				def 				lowercase__   (     self						:    int,  lowerCamelCase						:    Any,  lowerCamelCase						:    Optional[int],  lowerCamelCase						:    int  ):

								'''simple docstring'''
								lowercase__    =			self.num_labels
								lowercase__    =			DPTForSemanticSegmentation(lowerCamelCase  )
								model.to(lowerCamelCase  )
								model.eval()
								lowercase__    =			model(lowerCamelCase,  labels=lowerCamelCase  )
								self.parent.assertEqual(
								    result.logits.shape,  (self.batch_size, self.num_labels, self.image_size, self.image_size)  )




				def 				lowercase__   (     self						:    Dict  ):

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



@require_torch
class       _UpperCAmelCase					(       A__		,A__		,unittest.TestCase	):

				"""simple docstring"""




				lowercase__											=       (DPTModel, DPTForDepthEstimation, DPTForSemanticSegmentation) if is_torch_available() else ()
				lowercase__											=       (
				    {
				        """depth-estimation""": DPTForDepthEstimation,
				        """feature-extraction""": DPTModel,
				        """image-segmentation""": DPTForSemanticSegmentation,
				    }
				    if is_torch_available()
				    else {}
				)

				lowercase__											=       False
				lowercase__											=       False
				lowercase__											=       False




				def 				lowercase__   (     self						:    Union[str, Any]  ):

								'''simple docstring'''
								lowercase__    =			DPTModelTester(self  )
								lowercase__    =			ConfigTester(self,  config_class=lowerCamelCase,  has_text_modality=lowerCamelCase,  hidden_size=37  )




				def 				lowercase__   (     self						:    int  ):

								'''simple docstring'''
								self.config_tester.run_common_tests()




				@unittest.skip(reason='''DPT does not use inputs_embeds'''  )
				def 				lowercase__   (     self						:    Union[str, Any]  ):

								'''simple docstring'''
								pass




				def 				lowercase__   (     self						:    Dict  ):

								'''simple docstring'''
								lowercase__ ,						lowercase__    =			self.model_tester.prepare_config_and_inputs_for_common()

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




				def 				lowercase__   (     self						:    Optional[int]  ):

								'''simple docstring'''
								lowercase__ ,						lowercase__    =			self.model_tester.prepare_config_and_inputs_for_common()

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

												lowercase__    =			['''pixel_values''']
												self.assertListEqual(arg_names[:1],  lowerCamelCase  )




				def 				lowercase__   (     self						:    Tuple  ):

								'''simple docstring'''
								lowercase__    =			self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*lowerCamelCase  )




				def 				lowercase__   (     self						:    Tuple  ):

								'''simple docstring'''
								lowercase__    =			self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_depth_estimation(*lowerCamelCase  )




				def 				lowercase__   (     self						:    Union[str, Any]  ):

								'''simple docstring'''
								lowercase__    =			self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_semantic_segmentation(*lowerCamelCase  )




				def 				lowercase__   (     self						:    List[str]  ):

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

												lowercase__ ,						lowercase__    =			self.model_tester.prepare_config_and_inputs_for_common()
												lowercase__    =			True

												if model_class in get_values(lowerCamelCase  ):
																continue

												lowercase__    =			model_class(lowerCamelCase  )
												model.to(lowerCamelCase  )
												model.train()
												lowercase__    =			self._prepare_for_class(lowerCamelCase,  lowerCamelCase,  return_labels=lowerCamelCase  )
												lowercase__    =			model(**lowerCamelCase  ).loss
												loss.backward()




				def 				lowercase__   (     self						:    List[str]  ):

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

												lowercase__ ,						lowercase__    =			self.model_tester.prepare_config_and_inputs_for_common()
												lowercase__    =			False
												lowercase__    =			True

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




				def 				lowercase__   (     self						:    List[str]  ):

								'''simple docstring'''
								lowercase__ ,						lowercase__    =			self.model_tester.prepare_config_and_inputs_for_common()

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

								'''simple docstring'''
								pass




				@slow
				def 				lowercase__   (     self						:    Dict  ):

								'''simple docstring'''
								for model_name in DPT_PRETRAINED_MODEL_ARCHIVE_LIST[1:]:
												lowercase__    =			DPTModel.from_pretrained(lowerCamelCase  )
												self.assertIsNotNone(lowerCamelCase  )




				def 				lowercase__   (     self						:    Union[str, Any]  ):

								'''simple docstring'''
								# We do this test only for DPTForDepthEstimation since it is the only model that uses readout_type
								lowercase__ ,						lowercase__    =			self.model_tester.prepare_config_and_inputs_for_common()
								lowercase__    =			'''add'''
								with self.assertRaises(lowerCamelCase  ):
												lowercase__    =			DPTForDepthEstimation(lowerCamelCase  )






def   a			(						):






				'''simple docstring'''
				lowercase__    =			Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''				)
				return image




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

				"""simple docstring"""




				def 				lowercase__   (     self						:    Optional[Any]  ):

								'''simple docstring'''
								lowercase__    =			DPTImageProcessor.from_pretrained('''Intel/dpt-hybrid-midas'''  )
								lowercase__    =			DPTForDepthEstimation.from_pretrained('''Intel/dpt-hybrid-midas'''  ).to(lowerCamelCase  )

								lowercase__    =			prepare_img()
								lowercase__    =			image_processor(images=lowerCamelCase,  return_tensors='''pt'''  ).to(lowerCamelCase  )

								# forward pass
								with torch.no_grad():
												lowercase__    =			model(**lowerCamelCase  )
												lowercase__    =			outputs.predicted_depth

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

								lowercase__    =			torch.tensor(
								    [[[5.6437, 5.6146, 5.6511], [5.4371, 5.5649, 5.5958], [5.5215, 5.5184, 5.5293]]]  ).to(lowerCamelCase  )

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




