
"""simple docstring"""




import copy
import os
from typing import Union

from ...configuration_utils import PretrainedConfig
from ...utils import logging


UpperCAmelCase__      :    Dict    							= logging.get_logger(__name__)

UpperCAmelCase__      :    Optional[int]    							= {
    "BAAI/AltCLIP": "https://huggingface.co/BAAI/AltCLIP/resolve/main/config.json",
    # See all AltCLIP models at https://huggingface.co/models?filter=altclip
}



class 	lowerCAmelCase_						(SCREAMING_SNAKE_CASE__  ):


				"""simple docstring"""



				__UpperCamelCase      :						Any					       =   '''altclip_text_model'''



				def __init__(self   ,       SCREAMING_SNAKE_CASE__=25_00_02   ,       SCREAMING_SNAKE_CASE__=10_24   ,       SCREAMING_SNAKE_CASE__=24   ,       SCREAMING_SNAKE_CASE__=16   ,       SCREAMING_SNAKE_CASE__=40_96   ,       SCREAMING_SNAKE_CASE__="gelu"   ,       SCREAMING_SNAKE_CASE__=0.1   ,       SCREAMING_SNAKE_CASE__=0.1   ,       SCREAMING_SNAKE_CASE__=5_14   ,       SCREAMING_SNAKE_CASE__=1   ,       SCREAMING_SNAKE_CASE__=0.02   ,       SCREAMING_SNAKE_CASE__=0.02   ,       SCREAMING_SNAKE_CASE__=1E-05   ,       SCREAMING_SNAKE_CASE__=1   ,       SCREAMING_SNAKE_CASE__=0   ,       SCREAMING_SNAKE_CASE__=2   ,       SCREAMING_SNAKE_CASE__="absolute"   ,       SCREAMING_SNAKE_CASE__=True   ,       SCREAMING_SNAKE_CASE__=7_68   ,       **SCREAMING_SNAKE_CASE__   ,       )					->		str:



											"""simple docstring"""




											super().__init__(pad_token_id=A__   ,       bos_token_id=A__   ,       eos_token_id=A__   ,       **A__    )

											SCREAMING_SNAKE_CASE__						:       List[str]           =   vocab_size
											SCREAMING_SNAKE_CASE__						:       Optional[int]           =   hidden_size
											SCREAMING_SNAKE_CASE__						:       str           =   num_hidden_layers
											SCREAMING_SNAKE_CASE__						:       Tuple           =   num_attention_heads
											SCREAMING_SNAKE_CASE__						:       List[Any]           =   hidden_act
											SCREAMING_SNAKE_CASE__						:       str           =   intermediate_size
											SCREAMING_SNAKE_CASE__						:       Union[str, Any]           =   hidden_dropout_prob
											SCREAMING_SNAKE_CASE__						:       Optional[Any]           =   attention_probs_dropout_prob
											SCREAMING_SNAKE_CASE__						:       str           =   max_position_embeddings
											SCREAMING_SNAKE_CASE__						:       str           =   type_vocab_size
											SCREAMING_SNAKE_CASE__						:       List[Any]           =   initializer_range
											SCREAMING_SNAKE_CASE__						:       List[Any]           =   initializer_factor
											SCREAMING_SNAKE_CASE__						:       List[Any]           =   layer_norm_eps
											SCREAMING_SNAKE_CASE__						:       List[Any]           =   position_embedding_type
											SCREAMING_SNAKE_CASE__						:       Dict           =   use_cache
											SCREAMING_SNAKE_CASE__						:       Optional[int]           =   project_dim






class 	lowerCAmelCase_						(SCREAMING_SNAKE_CASE__  ):


				"""simple docstring"""



				__UpperCamelCase      :						Optional[int]					       =   '''altclip_vision_model'''



				def __init__(self   ,       SCREAMING_SNAKE_CASE__=7_68   ,       SCREAMING_SNAKE_CASE__=30_72   ,       SCREAMING_SNAKE_CASE__=5_12   ,       SCREAMING_SNAKE_CASE__=12   ,       SCREAMING_SNAKE_CASE__=12   ,       SCREAMING_SNAKE_CASE__=3   ,       SCREAMING_SNAKE_CASE__=2_24   ,       SCREAMING_SNAKE_CASE__=32   ,       SCREAMING_SNAKE_CASE__="quick_gelu"   ,       SCREAMING_SNAKE_CASE__=1E-5   ,       SCREAMING_SNAKE_CASE__=0.0   ,       SCREAMING_SNAKE_CASE__=0.02   ,       SCREAMING_SNAKE_CASE__=1.0   ,       **SCREAMING_SNAKE_CASE__   ,       )					->		List[str]:



											"""simple docstring"""




											super().__init__(**A__    )

											SCREAMING_SNAKE_CASE__						:       List[Any]           =   hidden_size
											SCREAMING_SNAKE_CASE__						:       str           =   intermediate_size
											SCREAMING_SNAKE_CASE__						:       List[Any]           =   projection_dim
											SCREAMING_SNAKE_CASE__						:       Any           =   num_hidden_layers
											SCREAMING_SNAKE_CASE__						:       Any           =   num_attention_heads
											SCREAMING_SNAKE_CASE__						:       Optional[Any]           =   num_channels
											SCREAMING_SNAKE_CASE__						:       Dict           =   patch_size
											SCREAMING_SNAKE_CASE__						:       Dict           =   image_size
											SCREAMING_SNAKE_CASE__						:       str           =   initializer_range
											SCREAMING_SNAKE_CASE__						:       Dict           =   initializer_factor
											SCREAMING_SNAKE_CASE__						:       Tuple           =   attention_dropout
											SCREAMING_SNAKE_CASE__						:       List[str]           =   layer_norm_eps
											SCREAMING_SNAKE_CASE__						:       Optional[int]           =   hidden_act



				@classmethod
				def 	__magic_name__    (cls   ,       SCREAMING_SNAKE_CASE__   ,       **SCREAMING_SNAKE_CASE__    )					->		Any:



											"""simple docstring"""




											cls._set_token_in_kwargs(A__    )

											SCREAMING_SNAKE_CASE__      ,      SCREAMING_SNAKE_CASE__						:       Dict           =   cls.get_config_dict(A__   ,       **A__    )

											# get the vision config dict if we are loading from AltCLIPConfig
											if config_dict.get("""model_type"""    ) == "altclip":
																		SCREAMING_SNAKE_CASE__						:       Any           =   config_dict["""vision_config"""]

											if "model_type" in config_dict and hasattr(cls   ,       """model_type"""    ) and config_dict["model_type"] != cls.model_type:
																		logger.warning(
																		    F'''You are using a model of type {config_dict['model_type']} to instantiate a model of type '''
																		    F'''{cls.model_type}. This is not supported for all configurations of models and can yield errors.'''    )

											return cls.from_dict(A__   ,       **A__    )






class 	lowerCAmelCase_						(SCREAMING_SNAKE_CASE__  ):


				"""simple docstring"""



				__UpperCamelCase      :						Any					       =   '''altclip'''
				__UpperCamelCase      :						List[Any]					       =   True



				def __init__(self   ,       SCREAMING_SNAKE_CASE__=None   ,       SCREAMING_SNAKE_CASE__=None   ,       SCREAMING_SNAKE_CASE__=7_68   ,       SCREAMING_SNAKE_CASE__=2.6592   ,       **SCREAMING_SNAKE_CASE__    )					->		Tuple:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:       Any           =   kwargs.pop("""text_config_dict"""   ,       A__    )
											SCREAMING_SNAKE_CASE__						:       str           =   kwargs.pop("""vision_config_dict"""   ,       A__    )

											super().__init__(**A__    )

											# Instead of simply assigning `[text|vision]_config_dict` to `[text|vision]_config`, we use the values in
											# `[text|vision]_config_dict` to update the values in `[text|vision]_config`. The values should be same in most
											# cases, but we don't want to break anything regarding `_config_dict` that existed before commit `8827e1b2`.
											if text_config_dict is not None:
																		if text_config is None:
																									SCREAMING_SNAKE_CASE__						:       List[str]           =   {}

																		# This is the complete result when using `text_config_dict`.
																		SCREAMING_SNAKE_CASE__						:       Optional[Any]           =   AltCLIPTextConfig(**A__    ).to_dict()

																		# Give a warning if the values exist in both `_text_config_dict` and `text_config` but being different.
																		for key, value in _text_config_dict.items():
																									if key in text_config and value != text_config[key] and key not in ["transformers_version"]:
																																# If specified in `text_config_dict`
																																if key in text_config_dict:
																																							SCREAMING_SNAKE_CASE__						:       Optional[int]           =   (
																																							    F'''`{key}` is found in both `text_config_dict` and `text_config` but with different values. '''
																																							    F'''The value `text_config_dict["{key}"]` will be used instead.'''
																																							)
																																# If inferred from default argument values (just to be super careful)
																																else:
																																							SCREAMING_SNAKE_CASE__						:       Any           =   (
																																							    F'''`text_config_dict` is provided which will be used to initialize `AltCLIPTextConfig`. The '''
																																							    F'''value `text_config["{key}"]` will be overriden.'''
																																							)
																																logger.warning(A__    )

            # Update all values in `text_config` with the ones in `_text_config_dict`.
																		text_config.update(_text_config_dict    )

											if vision_config_dict is not None:
																		if vision_config is None:
																									SCREAMING_SNAKE_CASE__						:       Any           =   {}

																		# This is the complete result when using `vision_config_dict`.
																		SCREAMING_SNAKE_CASE__						:       Union[str, Any]           =   AltCLIPVisionConfig(**A__    ).to_dict()
																		# convert keys to string instead of integer
																		if "id2label" in _vision_config_dict:
																									SCREAMING_SNAKE_CASE__						:       Dict           =   {
																									    str(A__    ): value for key, value in _vision_config_dict["""id2label"""].items()
																									}

																		# Give a warning if the values exist in both `_vision_config_dict` and `vision_config` but being different.
																		for key, value in _vision_config_dict.items():
																									if key in vision_config and value != vision_config[key] and key not in ["transformers_version"]:
																																# If specified in `vision_config_dict`
																																if key in vision_config_dict:
																																							SCREAMING_SNAKE_CASE__						:       Dict           =   (
																																							    F'''`{key}` is found in both `vision_config_dict` and `vision_config` but with different '''
																																							    F'''values. The value `vision_config_dict["{key}"]` will be used instead.'''
																																							)
																																# If inferred from default argument values (just to be super careful)
																																else:
																																							SCREAMING_SNAKE_CASE__						:       Optional[Any]           =   (
																																							    F'''`vision_config_dict` is provided which will be used to initialize `AltCLIPVisionConfig`. '''
																																							    F'''The value `vision_config["{key}"]` will be overriden.'''
																																							)
																																logger.warning(A__    )

            # Update all values in `vision_config` with the ones in `_vision_config_dict`.
																		vision_config.update(_vision_config_dict    )

											if text_config is None:
																		SCREAMING_SNAKE_CASE__						:       int           =   {}
																		logger.info("""`text_config` is `None`. Initializing the `AltCLIPTextConfig` with default values."""    )

											if vision_config is None:
																		SCREAMING_SNAKE_CASE__						:       Union[str, Any]           =   {}
																		logger.info("""`vision_config` is `None`. initializing the `AltCLIPVisionConfig` with default values."""    )

											SCREAMING_SNAKE_CASE__						:       Optional[int]           =   AltCLIPTextConfig(**A__    )
											SCREAMING_SNAKE_CASE__						:       str           =   AltCLIPVisionConfig(**A__    )

											SCREAMING_SNAKE_CASE__						:       str           =   projection_dim
											SCREAMING_SNAKE_CASE__						:       Optional[int]           =   logit_scale_init_value
											SCREAMING_SNAKE_CASE__						:       List[str]           =   1.0



				@classmethod
				def 	__magic_name__    (cls   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__   ,       **SCREAMING_SNAKE_CASE__    )					->		Tuple:



											"""simple docstring"""




											return cls(text_config=text_config.to_dict()   ,       vision_config=vision_config.to_dict()   ,       **A__    )



				def 	__magic_name__    (self    )					->		Dict:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:       int           =   copy.deepcopy(self.__dict__    )
											SCREAMING_SNAKE_CASE__						:       Dict           =   self.text_config.to_dict()
											SCREAMING_SNAKE_CASE__						:       str           =   self.vision_config.to_dict()
											SCREAMING_SNAKE_CASE__						:       Optional[Any]           =   self.__class__.model_type
											return output






import requests
from bsa import BeautifulSoup



def        UpperCamelCase    (							lowerCAmelCase__ = "https://www.worldometers.info/coronavirus"		):
					'''simple docstring'''
					lowercase							=						BeautifulSoup(requests.get(lowerCAmelCase__		).text ,			'''html.parser'''		)
					lowercase							=						soup.findAll('''h1'''		)
					lowercase							=						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')




