




"""simple docstring"""

import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image

from diffusers import (
    DDIMScheduler,
    KandinskyVaaControlnetImgaImgPipeline,
    KandinskyVaaPriorEmbaEmbPipeline,
    UNetaDConditionModel,
    VQModel,
)
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()

class        lowercase      (    _UpperCAmelCase     ,	unittest.TestCase):
				__lowerCAmelCase    :    List[str]         =   KandinskyVaaControlnetImgaImgPipeline
				__lowerCAmelCase    :    List[str]         =   ['''image_embeds''', '''negative_image_embeds''', '''image''', '''hint''']
				__lowerCAmelCase    :    Optional[Any]         =   ['''image_embeds''', '''negative_image_embeds''', '''image''', '''hint''']
				__lowerCAmelCase    :    Tuple         =   [
				    '''generator''',
				    '''height''',
				    '''width''',
				    '''strength''',
				    '''guidance_scale''',
				    '''num_inference_steps''',
				    '''return_dict''',
				    '''guidance_scale''',
				    '''num_images_per_prompt''',
				    '''output_type''',
				    '''return_dict''',
				]
				__lowerCAmelCase    :    Dict         =   False







				@property
				def 					a_  (							self   :					List[str]       ):



					"""simple docstring"""

					return 32







				@property
				def 					a_  (							self   :					Tuple       ):



					"""simple docstring"""

					return 32







				@property
				def 					a_  (							self   :					List[str]       ):



					"""simple docstring"""

					return self.time_input_dim







				@property
				def 					a_  (							self   :					Dict       ):



					"""simple docstring"""

					return self.time_input_dim * 4







				@property
				def 					a_  (							self   :					Tuple       ):



					"""simple docstring"""

					return 1_00







				@property
				def 					a_  (							self   :					List[Any]       ):



					"""simple docstring"""

					torch.manual_seed(0       )

					A_  :				Tuple	   =		{
					    '''in_channels''': 8,
					    # Out channels is double in channels because predicts mean and variance
					    '''out_channels''': 8,
					    '''addition_embed_type''': '''image_hint''',
					    '''down_block_types''': ('''ResnetDownsampleBlock2D''', '''SimpleCrossAttnDownBlock2D'''),
					    '''up_block_types''': ('''SimpleCrossAttnUpBlock2D''', '''ResnetUpsampleBlock2D'''),
					    '''mid_block_type''': '''UNetMidBlock2DSimpleCrossAttn''',
					    '''block_out_channels''': (self.block_out_channels_a, self.block_out_channels_a * 2),
					    '''layers_per_block''': 1,
					    '''encoder_hid_dim''': self.text_embedder_hidden_size,
					    '''encoder_hid_dim_type''': '''image_proj''',
					    '''cross_attention_dim''': self.cross_attention_dim,
					    '''attention_head_dim''': 4,
					    '''resnet_time_scale_shift''': '''scale_shift''',
					    '''class_embed_type''': None,
					}

					A_  :				Tuple	   =		UNetaDConditionModel(**A_       )
					return model







				@property
				def 					a_  (							self   :					int       ):



					"""simple docstring"""

					return {
					    "block_out_channels": [32, 32, 64, 64],
					    "down_block_types": [
					        "DownEncoderBlock2D",
					        "DownEncoderBlock2D",
					        "DownEncoderBlock2D",
					        "AttnDownEncoderBlock2D",
					    ],
					    "in_channels": 3,
					    "latent_channels": 4,
					    "layers_per_block": 1,
					    "norm_num_groups": 8,
					    "norm_type": "spatial",
					    "num_vq_embeddings": 12,
					    "out_channels": 3,
					    "up_block_types": ["AttnUpDecoderBlock2D", "UpDecoderBlock2D", "UpDecoderBlock2D", "UpDecoderBlock2D"],
					    "vq_embed_dim": 4,
					}







				@property
				def 					a_  (							self   :					Optional[Any]       ):



					"""simple docstring"""

					torch.manual_seed(0       )
					A_  :				str	   =		VQModel(**self.dummy_movq_kwargs       )
					return model







				def 					a_  (							self   :					int       ):



					"""simple docstring"""

					A_  :				str	   =		self.dummy_unet
					A_  :				Optional[Any]	   =		self.dummy_movq

					A_  :				int	   =		{
					    '''num_train_timesteps''': 10_00,
					    '''beta_schedule''': '''linear''',
					    '''beta_start''': 0.00085,
					    '''beta_end''': 0.012,
					    '''clip_sample''': False,
					    '''set_alpha_to_one''': False,
					    '''steps_offset''': 0,
					    '''prediction_type''': '''epsilon''',
					    '''thresholding''': False,
					}

					A_  :				Optional[int]	   =		DDIMScheduler(**A_       )

					A_  :				Tuple	   =		{
					    '''unet''': unet,
					    '''scheduler''': scheduler,
					    '''movq''': movq,
					}

					return components







				def 					a_  (							self   :					List[Any]      ,     _lowerCamelCase   :					Tuple      ,     _lowerCamelCase   :					List[Any]=0       ):



					"""simple docstring"""

					A_  :				Any	   =		floats_tensor((1, self.text_embedder_hidden_size)      ,     rng=random.Random(A_       )       ).to(A_       )
					A_  :				str	   =		floats_tensor((1, self.text_embedder_hidden_size)      ,     rng=random.Random(seed + 1       )       ).to(
					    A_       )
					# create init_image
					A_  :				Union[str, Any]	   =		floats_tensor((1, 3, 64, 64)      ,     rng=random.Random(A_       )       ).to(A_       )
					A_  :				List[Any]	   =		image.cpu().permute(0      ,     2      ,     3      ,     1       )[0]
					A_  :				List[str]	   =		Image.fromarray(np.uinta(A_       )       ).convert('''RGB'''       ).resize((2_56, 2_56)       )
					# create hint
					A_  :				Union[str, Any]	   =		floats_tensor((1, 3, 64, 64)      ,     rng=random.Random(A_       )       ).to(A_       )

					if str(A_       ).startswith('''mps'''       ):
						A_  :				Tuple	   =		torch.manual_seed(A_       )
					else:
						A_  :				Tuple	   =		torch.Generator(device=A_       ).manual_seed(A_       )
					A_  :				Union[str, Any]	   =		{
					    '''image''': init_image,
					    '''image_embeds''': image_embeds,
					    '''negative_image_embeds''': negative_image_embeds,
					    '''hint''': hint,
					    '''generator''': generator,
					    '''height''': 64,
					    '''width''': 64,
					    '''num_inference_steps''': 10,
					    '''guidance_scale''': 7.0,
					    '''strength''': 0.2,
					    '''output_type''': '''np''',
					}
					return inputs







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



					"""simple docstring"""

					A_  :				Dict	   =		'''cpu'''

					A_  :				List[Any]	   =		self.get_dummy_components()

					A_  :				int	   =		self.pipeline_class(**A_       )
					A_  :				List[str]	   =		pipe.to(A_       )

					pipe.set_progress_bar_config(disable=A_       )

					A_  :				List[Any]	   =		pipe(**self.get_dummy_inputs(A_       )       )
					A_  :				List[str]	   =		output.images

					A_  :				Dict	   =		pipe(
					    **self.get_dummy_inputs(A_       )      ,     return_dict=A_      ,     )[0]

					A_  :				List[str]	   =		image[0, -3:, -3:, -1]
					A_  :				Tuple	   =		image_from_tuple[0, -3:, -3:, -1]

					assert image.shape == (1, 64, 64, 3)

					A_  :				Optional[Any]	   =		np.array(
					    [0.54985034, 0.55509365, 0.52561504, 0.5570494, 0.5593818, 0.5263979, 0.50285643, 0.5069846, 0.51196736]       )
					assert (
					    np.abs(image_slice.flatten() - expected_slice       ).max() < 1E-2
					), F""" expected_slice {expected_slice}, but got {image_slice.flatten()}"""
					assert (
					    np.abs(image_from_tuple_slice.flatten() - expected_slice       ).max() < 1E-2
					), F""" expected_slice {expected_slice}, but got {image_from_tuple_slice.flatten()}"""

@slow
@require_torch_gpu
class        lowercase      (    unittest.TestCase):







				def 					a_  (							self   :					Any       ):



					"""simple docstring"""

					super().tearDown()
					gc.collect()
					torch.cuda.empty_cache()







				def 					a_  (							self   :					Optional[int]       ):



					"""simple docstring"""

					A_  :				List[Any]	   =		load_numpy(
					    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
					    '''/kandinskyv22/kandinskyv22_controlnet_img2img_robotcat_fp16.npy'''       )

					A_  :				Any	   =		load_image(
					    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main''' '''/kandinsky/cat.png'''       )
					A_  :				str	   =		init_image.resize((5_12, 5_12)       )

					A_  :				List[Any]	   =		load_image(
					    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
					    '''/kandinskyv22/hint_image_cat.png'''       )
					A_  :				int	   =		torch.from_numpy(np.array(A_       )       ).float() / 2_55.0
					A_  :				Dict	   =		hint.permute(2      ,     0      ,     1       ).unsqueeze(0       )

					A_  :				Optional[int]	   =		'''A robot, 4k photo'''

					A_  :				Dict	   =		KandinskyVaaPriorEmbaEmbPipeline.from_pretrained(
					    '''kandinsky-community/kandinsky-2-2-prior'''      ,     torch_dtype=torch.floataa       )
					pipe_prior.to(A_       )

					A_  :				Optional[Any]	   =		KandinskyVaaControlnetImgaImgPipeline.from_pretrained(
					    '''kandinsky-community/kandinsky-2-2-controlnet-depth'''      ,     torch_dtype=torch.floataa       )
					A_  :				str	   =		pipeline.to(A_       )

					pipeline.set_progress_bar_config(disable=A_       )

					A_  :				Optional[Any]	   =		torch.Generator(device='''cpu'''       ).manual_seed(0       )

					A_   , A_  :				Any	   =		pipe_prior(
					    A_      ,     image=A_      ,     strength=0.85      ,     generator=A_      ,     negative_prompt=''''''      ,     ).to_tuple()

					A_  :				str	   =		pipeline(
					    image=A_      ,     image_embeds=A_      ,     negative_image_embeds=A_      ,     hint=A_      ,     generator=A_      ,     num_inference_steps=1_00      ,     height=5_12      ,     width=5_12      ,     strength=0.5      ,     output_type='''np'''      ,     )

					A_  :				int	   =		output.images[0]

					assert image.shape == (5_12, 5_12, 3)

					assert_mean_pixel_difference(A_      ,     A_       )











"""simple docstring"""

import requests
from bsa import BeautifulSoup

def 		lowercase_      (		_UpperCAmelCase = "https://www.worldometers.info/coronavirus"	):




	"""simple docstring"""






	A_  :				str	   =		BeautifulSoup(requests.get(_UpperCAmelCase	).text  ,      '''html.parser'''	)
	A_  :				Union[str, Any]	   =		soup.findAll('''h1'''	)
	A_  :				Union[str, Any]	   =		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(_UpperCAmelCase  ,      _UpperCAmelCase	)}


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')





