


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






			"""simple docstring"""






			def __init__(				self   ,    snake_case   ,    snake_case=2   ,    snake_case=32   ,    snake_case=16   ,    snake_case=3   ,    snake_case=True   ,    snake_case=True   ,    snake_case=32   ,    snake_case=4   ,    snake_case=[0, 1, 2, 3]   ,    snake_case=4   ,    snake_case=37   ,    snake_case="gelu"   ,    snake_case=0.1   ,    snake_case=0.1   ,    snake_case=0.02   ,    snake_case=3   ,    snake_case=[1, 384, 24, 24]   ,    snake_case=True   ,    snake_case=None   ,    ):

						'''simple docstring'''


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




			def 					snake_case__					(				self  ):

						'''simple docstring'''


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

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

						UpperCamelCase__       =							self.get_config()

						return config, pixel_values, labels




			def 					snake_case__					(				self  ):

						'''simple docstring'''


						UpperCamelCase__       =							{
						    "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=snake_case   ,    initializer_range=self.initializer_range   ,    is_hybrid=self.is_hybrid   ,    backbone_config=snake_case   ,    backbone_featmap_shape=self.backbone_featmap_shape   ,    )




			def 					snake_case__					(				self   ,    snake_case   ,    snake_case   ,    snake_case  ):

						'''simple docstring'''


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




			def 					snake_case__					(				self   ,    snake_case   ,    snake_case   ,    snake_case  ):

						'''simple docstring'''


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




			def 					snake_case__					(				self   ,    snake_case   ,    snake_case   ,    snake_case  ):

						'''simple docstring'''


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







			def 					snake_case__					(				self  ):

						'''simple docstring'''


						UpperCamelCase__       =							self.prepare_config_and_inputs()
						UpperCamelCase__,   UpperCamelCase__,   UpperCamelCase__       =							config_and_inputs
						UpperCamelCase__       =							{"pixel_values": pixel_values}
						return config, inputs_dict







@require_torch
class 							lowerCamelCase__						(				UpperCAmelCase       ,						UpperCAmelCase       ,						unittest.TestCase   ):






			"""simple docstring"""






			_UpperCamelCase		:       Optional[Any] 			=		(DPTModel, DPTForDepthEstimation, DPTForSemanticSegmentation) if is_torch_available() else ()
			_UpperCamelCase		:       Tuple 			=		(
			    {
			        'depth-estimation': DPTForDepthEstimation,
			        'feature-extraction': DPTModel,
			        'image-segmentation': DPTForSemanticSegmentation,
			    }
			    if is_torch_available()
			    else {}
			)

			_UpperCamelCase		:       List[str] 			=		False
			_UpperCamelCase		:       Optional[Any] 			=		False
			_UpperCamelCase		:       Dict 			=		False




			def 					snake_case__					(				self  ):

						'''simple docstring'''


						UpperCamelCase__       =							DPTModelTester(self  )
						UpperCamelCase__       =							ConfigTester(self   ,    config_class=snake_case   ,    has_text_modality=snake_case   ,    hidden_size=37  )




			def 					snake_case__					(				self  ):

						'''simple docstring'''


						self.config_tester.run_common_tests()




			@unittest.skip(reason="DPT does not use inputs_embeds"  )
			def 					snake_case__					(				self  ):

						'''simple docstring'''


						pass




			def 					snake_case__					(				self  ):

						'''simple docstring'''


						UpperCamelCase__,   UpperCamelCase__       =							self.model_tester.prepare_config_and_inputs_for_common()

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




			def 					snake_case__					(				self  ):

						'''simple docstring'''


						UpperCamelCase__,   UpperCamelCase__       =							self.model_tester.prepare_config_and_inputs_for_common()

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

									UpperCamelCase__       =							["pixel_values"]
									self.assertListEqual(arg_names[:1]   ,    snake_case  )




			def 					snake_case__					(				self  ):

						'''simple docstring'''


						UpperCamelCase__       =							self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*snake_case  )




			def 					snake_case__					(				self  ):

						'''simple docstring'''


						UpperCamelCase__       =							self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_depth_estimation(*snake_case  )




			def 					snake_case__					(				self  ):

						'''simple docstring'''


						UpperCamelCase__       =							self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_semantic_segmentation(*snake_case  )




			def 					snake_case__					(				self  ):

						'''simple docstring'''


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

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

									if model_class in get_values(snake_case  ):
												continue

									UpperCamelCase__       =							model_class(snake_case  )
									model.to(snake_case  )
									model.train()
									UpperCamelCase__       =							self._prepare_for_class(snake_case   ,    snake_case   ,    return_labels=snake_case  )
									UpperCamelCase__       =							model(**snake_case  ).loss
									loss.backward()




			def 					snake_case__					(				self  ):

						'''simple docstring'''


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

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

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




			def 					snake_case__					(				self  ):

						'''simple docstring'''


						UpperCamelCase__,   UpperCamelCase__       =							self.model_tester.prepare_config_and_inputs_for_common()

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

						'''simple docstring'''


						pass




			@slow
			def 					snake_case__					(				self  ):

						'''simple docstring'''


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







			def 					snake_case__					(				self  ):

						'''simple docstring'''


						UpperCamelCase__,   UpperCamelCase__       =							self.model_tester.prepare_config_and_inputs_for_common()
						UpperCamelCase__       =							"add"
						with self.assertRaises(snake_case  ):
									UpperCamelCase__       =							DPTForDepthEstimation(snake_case  )



def 							UpperCamelCase_(					)->		Tuple:
			UpperCamelCase__       =							Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"	)
			return image







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






			"""simple docstring"""






			def 					snake_case__					(				self  ):

						'''simple docstring'''


						UpperCamelCase__       =							DPTImageProcessor.from_pretrained("Intel/dpt-hybrid-midas"  )
						UpperCamelCase__       =							DPTForDepthEstimation.from_pretrained("Intel/dpt-hybrid-midas"  ).to(snake_case  )

						UpperCamelCase__       =							prepare_img()
						UpperCamelCase__       =							image_processor(images=snake_case   ,    return_tensors="pt"  ).to(snake_case  )

						# forward pass
						with torch.no_grad():
									UpperCamelCase__       =							model(**snake_case  )
									UpperCamelCase__       =							outputs.predicted_depth

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

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

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






import requests
from bsa import BeautifulSoup
def 							UpperCamelCase_(					_A :str = "AAPL"	)->		str:
			UpperCamelCase__       =							F'''https://in.finance.yahoo.com/quote/{symbol}?s={symbol}'''
			UpperCamelCase__       =							BeautifulSoup(requests.get(_A	).text					,  "html.parser"	)
			UpperCamelCase__       =							"My(6px) Pos(r) smartphone_Mt(6px)"
			return soup.find("div"					,  class_=class_	).find("span"	).text


if __name__ == "__main__":
						for symbol in "AAPL AMZN IBM GOOG MSFT ORCL".split():
												print(f'''Current {symbol:<4} stock price is {stock_price(symbol):>8}''')


