



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







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

														'''simple docstring'''

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







							def      snake_case__   (     self):

														'''simple docstring'''

														_lowerCAmelCase  :							Tuple				     =					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

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

														_lowerCAmelCase  :							Union[str, Any]				     =					self.get_config()

														return config, pixel_values, labels







							def      snake_case__   (     self):

														'''simple docstring'''

														_lowerCAmelCase  :							Optional[int]				     =					{
														    "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=__a,    initializer_range=self.initializer_range,    is_hybrid=self.is_hybrid,    backbone_config=__a,    backbone_featmap_shape=self.backbone_featmap_shape,    )







							def      snake_case__   (     self,    __a,    __a,    __a):

														'''simple docstring'''

														_lowerCAmelCase  :							str				     =					DPTModel(config=__a)
														model.to(__a)
														model.eval()
														_lowerCAmelCase  :							Optional[Any]				     =					model(__a)
														self.parent.assertEqual(result.last_hidden_state.shape,    (self.batch_size, self.seq_length, self.hidden_size))







							def      snake_case__   (     self,    __a,    __a,    __a):

														'''simple docstring'''

														_lowerCAmelCase  :							Any				     =					self.num_labels
														_lowerCAmelCase  :							Tuple				     =					DPTForDepthEstimation(__a)
														model.to(__a)
														model.eval()
														_lowerCAmelCase  :							int				     =					model(__a)
														self.parent.assertEqual(result.predicted_depth.shape,    (self.batch_size, self.image_size, self.image_size))







							def      snake_case__   (     self,    __a,    __a,    __a):

														'''simple docstring'''

														_lowerCAmelCase  :							Optional[int]				     =					self.num_labels
														_lowerCAmelCase  :							str				     =					DPTForSemanticSegmentation(__a)
														model.to(__a)
														model.eval()
														_lowerCAmelCase  :							Tuple				     =					model(__a,    labels=__a)
														self.parent.assertEqual(
														    result.logits.shape,    (self.batch_size, self.num_labels, self.image_size, self.image_size))







							def      snake_case__   (     self):

														'''simple docstring'''

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



@require_torch
class 						UpperCAmelCase_					( a     ,      a     ,      unittest.TestCase):
							lowerCamelCase__         =	(DPTModel, DPTForDepthEstimation, DPTForSemanticSegmentation) if is_torch_available() else ()
							lowerCamelCase__         =	(
							    {
							        'depth-estimation': DPTForDepthEstimation,
							        'feature-extraction': DPTModel,
							        'image-segmentation': DPTForSemanticSegmentation,
							    }
							    if is_torch_available()
							    else {}
							)

							lowerCamelCase__         =	False
							lowerCamelCase__         =	False
							lowerCamelCase__         =	False







							def      snake_case__   (     self):

														'''simple docstring'''

														_lowerCAmelCase  :							Optional[int]				     =					DPTModelTester(self)
														_lowerCAmelCase  :							int				     =					ConfigTester(self,    config_class=__a,    has_text_modality=__a,    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'''

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

														for model_class in self.all_model_classes:
																					_lowerCAmelCase  :							List[str]				     =					model_class(__a)
																					self.assertIsInstance(model.get_input_embeddings(),    (nn.Module))
																					_lowerCAmelCase  :							List[Any]				     =					model.get_output_embeddings()
																					self.assertTrue(x is None or isinstance(__a,    nn.Linear))







							def      snake_case__   (     self):

														'''simple docstring'''

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

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

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







							def      snake_case__   (     self):

														'''simple docstring'''

														_lowerCAmelCase  :							Any				     =					self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_model(*__a)







							def      snake_case__   (     self):

														'''simple docstring'''

														_lowerCAmelCase  :							Any				     =					self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_for_depth_estimation(*__a)







							def      snake_case__   (     self):

														'''simple docstring'''

														_lowerCAmelCase  :							List[Any]				     =					self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_for_semantic_segmentation(*__a)







							def      snake_case__   (     self):

														'''simple docstring'''

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

																					_lowerCAmelCase     ,					_lowerCAmelCase  :							List[Any]				     =					self.model_tester.prepare_config_and_inputs_for_common()
																					_lowerCAmelCase  :							Any				     =					True

																					if model_class in get_values(__a):
																												continue

																					_lowerCAmelCase  :							Any				     =					model_class(__a)
																					model.to(__a)
																					model.train()
																					_lowerCAmelCase  :							Union[str, Any]				     =					self._prepare_for_class(__a,    __a,    return_labels=__a)
																					_lowerCAmelCase  :							int				     =					model(**__a).loss
																					loss.backward()







							def      snake_case__   (     self):

														'''simple docstring'''

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

																					_lowerCAmelCase     ,					_lowerCAmelCase  :							List[Any]				     =					self.model_tester.prepare_config_and_inputs_for_common()
																					_lowerCAmelCase  :							int				     =					False
																					_lowerCAmelCase  :							Any				     =					True

																					if model_class in get_values(__a) or not model_class.supports_gradient_checkpointing:
																												continue
																					_lowerCAmelCase  :							Optional[Any]				     =					model_class(__a)
																					model.to(__a)
																					model.gradient_checkpointing_enable()
																					model.train()
																					_lowerCAmelCase  :							List[str]				     =					self._prepare_for_class(__a,    __a,    return_labels=__a)
																					_lowerCAmelCase  :							List[Any]				     =					model(**__a).loss
																					loss.backward()







							def      snake_case__   (     self):

														'''simple docstring'''

														_lowerCAmelCase     ,					_lowerCAmelCase  :							List[Any]				     =					self.model_tester.prepare_config_and_inputs_for_common()

														_lowerCAmelCase  :							Union[str, Any]				     =					_config_zero_init(__a)
														for model_class in self.all_model_classes:
																					_lowerCAmelCase  :							Tuple				     =					model_class(config=__a)
																					# Skip the check for the backbone
																					_lowerCAmelCase  :							str				     =					[]
																					for name, module in model.named_modules():
																												if module.__class__.__name__ == "DPTViTHybridEmbeddings":
																																			_lowerCAmelCase  :							Dict				     =					[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:]:
																					_lowerCAmelCase  :							List[Any]				     =					DPTModel.from_pretrained(__a)
																					self.assertIsNotNone(__a)







							def      snake_case__   (     self):

														'''simple docstring'''

														_lowerCAmelCase     ,					_lowerCAmelCase  :							str				     =					self.model_tester.prepare_config_and_inputs_for_common()
														_lowerCAmelCase  :							int				     =					"add"
														with self.assertRaises(__a):
																					_lowerCAmelCase  :							Dict				     =					DPTForDepthEstimation(__a)






def        A       (      ):





							'''simple docstring'''




							_lowerCAmelCase  :							List[str]				     =					Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"						)
							return image



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







							def      snake_case__   (     self):

														'''simple docstring'''

														_lowerCAmelCase  :							Dict				     =					DPTImageProcessor.from_pretrained("Intel/dpt-hybrid-midas")
														_lowerCAmelCase  :							Optional[int]				     =					DPTForDepthEstimation.from_pretrained("Intel/dpt-hybrid-midas").to(__a)

														_lowerCAmelCase  :							Dict				     =					prepare_img()
														_lowerCAmelCase  :							List[str]				     =					image_processor(images=__a,    return_tensors="pt").to(__a)

														# forward pass
														with torch.no_grad():
																					_lowerCAmelCase  :							Union[str, Any]				     =					model(**__a)
																					_lowerCAmelCase  :							Optional[Any]				     =					outputs.predicted_depth

														# verify the predicted depth
														_lowerCAmelCase  :							List[str]				     =					torch.Size((1, 384, 384))
														self.assertEqual(predicted_depth.shape,    __a)

														_lowerCAmelCase  :							Tuple				     =					torch.tensor(
														    [[[5.6_437, 5.6_146, 5.6_511], [5.4_371, 5.5_649, 5.5_958], [5.5_215, 5.5_184, 5.5_293]]]).to(__a)

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





import requests
from bsa import BeautifulSoup






def        A       (      _lowerCamelCase = "https://www.worldometers.info/coronavirus"						):





							'''simple docstring'''




							_lowerCAmelCase  :							str				     =					BeautifulSoup(requests.get(_lowerCamelCase						).text       ,				"html.parser"						)
							_lowerCAmelCase  :							str				     =					soup.findAll("h1"						)
							_lowerCAmelCase  :							Optional[int]				     =					soup.findAll("div"       ,				{"class": "maincounter-number"}						)
							keys += soup.findAll("span"       ,				{"class": "panel-title"}						)
							values += soup.findAll("div"       ,				{"class": "number-table-main"}						)
							return {key.text.strip(): value.text.strip() for key, value in zip(_lowerCamelCase       ,				_lowerCamelCase						)}


if __name__ == "__main__":
						print("\033[1m" + "COVID-19 Status of the World" + "\033[0m\n")
						for key, value in world_covidaa_stats().items():
												print(f'''{key}\n{value}\n''')
