



from typing import Optional, Tuple, Union

import flax
import flax.linen as nn
import jax
import jax.numpy as jnp
from flax.core.frozen_dict import FrozenDict

from ..configuration_utils import ConfigMixin, flax_register_to_config
from ..utils import BaseOutput
from .embeddings_flax import FlaxTimestepEmbedding, FlaxTimesteps
from .modeling_flax_utils import FlaxModelMixin
from .unet_ad_blocks_flax import (
    FlaxCrossAttnDownBlockaD,
    FlaxDownBlockaD,
    FlaxUNetMidBlockaDCrossAttn,
)



@flax.struct.dataclass
class 						UpperCAmelCase_					( a):
       lowerCamelCase__         =	42
       lowerCamelCase__         =	42



class 						UpperCAmelCase_					( nn.Module):
       lowerCamelCase__         =	42
       lowerCamelCase__         =	(16, 32, 96, 256)
       lowerCamelCase__         =	jnp.floataa







       def      snake_case__   (     self):

              '''simple docstring'''

              _lowerCAmelCase  :							Optional[Any]				     =					nn.Conv(
                  self.block_out_channels[0],    kernel_size=(3, 3),    padding=((1, 1), (1, 1)),    dtype=self.dtype,    )

              _lowerCAmelCase  :							List[Any]				     =					[]
              for i in range(len(self.block_out_channels) - 1):
                     _lowerCAmelCase  :							List[Any]				     =					self.block_out_channels[i]
                     _lowerCAmelCase  :							Dict				     =					self.block_out_channels[i + 1]
                     _lowerCAmelCase  :							Any				     =					nn.Conv(
                         __a,    kernel_size=(3, 3),    padding=((1, 1), (1, 1)),    dtype=self.dtype,    )
                     blocks.append(__a)
                     _lowerCAmelCase  :							Any				     =					nn.Conv(
                         __a,    kernel_size=(3, 3),    strides=(2, 2),    padding=((1, 1), (1, 1)),    dtype=self.dtype,    )
                     blocks.append(__a)
              _lowerCAmelCase  :							Tuple				     =					blocks

              _lowerCAmelCase  :							Union[str, Any]				     =					nn.Conv(
                  self.conditioning_embedding_channels,    kernel_size=(3, 3),    padding=((1, 1), (1, 1)),    kernel_init=nn.initializers.zeros_init(),    bias_init=nn.initializers.zeros_init(),    dtype=self.dtype,    )







       def __call__(     self,    __a):

              '''simple docstring'''

              _lowerCAmelCase  :							Optional[Any]				     =					self.conv_in(__a)
              _lowerCAmelCase  :							str				     =					nn.silu(__a)

              for block in self.blocks:
                     _lowerCAmelCase  :							str				     =					block(__a)
                     _lowerCAmelCase  :							Dict				     =					nn.silu(__a)

              _lowerCAmelCase  :							str				     =					self.conv_out(__a)

              return embedding



@flax_register_to_config
class 						UpperCAmelCase_					( nn.Module     ,      a     ,      a):
       lowerCamelCase__         =	32
       lowerCamelCase__         =	4
       lowerCamelCase__         =	(
           'CrossAttnDownBlock2D',
           'CrossAttnDownBlock2D',
           'CrossAttnDownBlock2D',
           'DownBlock2D',
       )
       lowerCamelCase__         =	False
       lowerCamelCase__         =	(320, 640, 1280, 1280)
       lowerCamelCase__         =	2
       lowerCamelCase__         =	8
       lowerCamelCase__         =	None
       lowerCamelCase__         =	1280
       lowerCamelCase__         =	0.0
       lowerCamelCase__         =	False
       lowerCamelCase__         =	jnp.floataa
       lowerCamelCase__         =	True
       lowerCamelCase__         =	0
       lowerCamelCase__         =	'rgb'
       lowerCamelCase__         =	(16, 32, 96, 256)







       def      snake_case__   (     self,    __a):

              '''simple docstring'''

              _lowerCAmelCase  :							List[str]				     =					(1, self.in_channels, self.sample_size, self.sample_size)
              _lowerCAmelCase  :							Dict				     =					jnp.zeros(__a,    dtype=jnp.floataa)
              _lowerCAmelCase  :							Any				     =					jnp.ones((1,),    dtype=jnp.intaa)
              _lowerCAmelCase  :							int				     =					jnp.zeros((1, 1, self.cross_attention_dim),    dtype=jnp.floataa)
              _lowerCAmelCase  :							List[Any]				     =					(1, 3, self.sample_size * 8, self.sample_size * 8)
              _lowerCAmelCase  :							List[str]				     =					jnp.zeros(__a,    dtype=jnp.floataa)

              _lowerCAmelCase  :							Union[str, Any]				     =					jax.random.split(__a)
              _lowerCAmelCase  :							List[str]				     =					{"params": params_rng, "dropout": dropout_rng}

              return self.init(__a,    __a,    __a,    __a,    __a)["params"]







       def      snake_case__   (     self):

              '''simple docstring'''

              _lowerCAmelCase  :							Any				     =					self.block_out_channels
              _lowerCAmelCase  :							Any				     =					block_out_channels[0] * 4

              # If `num_attention_heads` is not defined (which is the case for most models)
              # it will default to `attention_head_dim`. This looks weird upon first reading it and it is.
              # The reason for this behavior is to correct for incorrectly named variables that were introduced
              # when this library was created. The incorrect naming was only discovered much later in https://github.com/huggingface/diffusers/issues/2011#issuecomment-1547958131
              # Changing `attention_head_dim` to `num_attention_heads` for 40,000+ configurations is too backwards breaking
              # which is why we correct for the naming here.
              _lowerCAmelCase  :							Union[str, Any]				     =					self.num_attention_heads or self.attention_head_dim

              # input
              _lowerCAmelCase  :							Dict				     =					nn.Conv(
                  block_out_channels[0],    kernel_size=(3, 3),    strides=(1, 1),    padding=((1, 1), (1, 1)),    dtype=self.dtype,    )

              # time
              _lowerCAmelCase  :							List[str]				     =					FlaxTimesteps(
                  block_out_channels[0],    flip_sin_to_cos=self.flip_sin_to_cos,    freq_shift=self.config.freq_shift)
              _lowerCAmelCase  :							Tuple				     =					FlaxTimestepEmbedding(__a,    dtype=self.dtype)

              _lowerCAmelCase  :							List[Any]				     =					FlaxControlNetConditioningEmbedding(
                  conditioning_embedding_channels=block_out_channels[0],    block_out_channels=self.conditioning_embedding_out_channels,    )

              _lowerCAmelCase  :							List[str]				     =					self.only_cross_attention
              if isinstance(__a,    __a):
                     _lowerCAmelCase  :							List[str]				     =					(only_cross_attention,) * len(self.down_block_types)

              if isinstance(__a,    __a):
                     _lowerCAmelCase  :							Any				     =					(num_attention_heads,) * len(self.down_block_types)

              # down
              _lowerCAmelCase  :							Any				     =					[]
              _lowerCAmelCase  :							Optional[int]				     =					[]

              _lowerCAmelCase  :							Any				     =					block_out_channels[0]

              _lowerCAmelCase  :							Any				     =					nn.Conv(
                  __a,    kernel_size=(1, 1),    padding="VALID",    kernel_init=nn.initializers.zeros_init(),    bias_init=nn.initializers.zeros_init(),    dtype=self.dtype,    )
              controlnet_down_blocks.append(__a)

              for i, down_block_type in enumerate(self.down_block_types):
                     _lowerCAmelCase  :							Optional[Any]				     =					output_channel
                     _lowerCAmelCase  :							Optional[int]				     =					block_out_channels[i]
                     _lowerCAmelCase  :							List[Any]				     =					i == len(__a) - 1

                     if down_block_type == "CrossAttnDownBlock2D":
                            _lowerCAmelCase  :							Dict				     =					FlaxCrossAttnDownBlockaD(
                                in_channels=__a,    out_channels=__a,    dropout=self.dropout,    num_layers=self.layers_per_block,    num_attention_heads=num_attention_heads[i],    add_downsample=not is_final_block,    use_linear_projection=self.use_linear_projection,    only_cross_attention=only_cross_attention[i],    dtype=self.dtype,    )
                     else:
                            _lowerCAmelCase  :							Optional[Any]				     =					FlaxDownBlockaD(
                                in_channels=__a,    out_channels=__a,    dropout=self.dropout,    num_layers=self.layers_per_block,    add_downsample=not is_final_block,    dtype=self.dtype,    )

                     down_blocks.append(__a)

                     for _ in range(self.layers_per_block):
                            _lowerCAmelCase  :							str				     =					nn.Conv(
                                __a,    kernel_size=(1, 1),    padding="VALID",    kernel_init=nn.initializers.zeros_init(),    bias_init=nn.initializers.zeros_init(),    dtype=self.dtype,    )
                            controlnet_down_blocks.append(__a)

                     if not is_final_block:
                            _lowerCAmelCase  :							int				     =					nn.Conv(
                                __a,    kernel_size=(1, 1),    padding="VALID",    kernel_init=nn.initializers.zeros_init(),    bias_init=nn.initializers.zeros_init(),    dtype=self.dtype,    )
                            controlnet_down_blocks.append(__a)

              _lowerCAmelCase  :							Optional[int]				     =					down_blocks
              _lowerCAmelCase  :							int				     =					controlnet_down_blocks

              # mid
              _lowerCAmelCase  :							Dict				     =					block_out_channels[-1]
              _lowerCAmelCase  :							Dict				     =					FlaxUNetMidBlockaDCrossAttn(
                  in_channels=__a,    dropout=self.dropout,    num_attention_heads=num_attention_heads[-1],    use_linear_projection=self.use_linear_projection,    dtype=self.dtype,    )

              _lowerCAmelCase  :							str				     =					nn.Conv(
                  __a,    kernel_size=(1, 1),    padding="VALID",    kernel_init=nn.initializers.zeros_init(),    bias_init=nn.initializers.zeros_init(),    dtype=self.dtype,    )







       def __call__(     self,    __a,    __a,    __a,    __a,    __a = 1.0,    __a = True,    __a = False,    ):

              '''simple docstring'''

              _lowerCAmelCase  :							Optional[int]				     =					self.controlnet_conditioning_channel_order
              if channel_order == "bgr":
                     _lowerCAmelCase  :							List[str]				     =					jnp.flip(__a,    axis=1)

              # 1. time
              if not isinstance(__a,    jnp.ndarray):
                     _lowerCAmelCase  :							List[str]				     =					jnp.array([timesteps],    dtype=jnp.intaa)
              elif isinstance(__a,    jnp.ndarray) and len(timesteps.shape) == 0:
                     _lowerCAmelCase  :							Optional[int]				     =					timesteps.astype(dtype=jnp.floataa)
                     _lowerCAmelCase  :							int				     =					jnp.expand_dims(__a,    0)

              _lowerCAmelCase  :							Union[str, Any]				     =					self.time_proj(__a)
              _lowerCAmelCase  :							Optional[int]				     =					self.time_embedding(__a)

              # 2. pre-process
              _lowerCAmelCase  :							List[str]				     =					jnp.transpose(__a,    (0, 2, 3, 1))
              _lowerCAmelCase  :							int				     =					self.conv_in(__a)

              _lowerCAmelCase  :							Optional[Any]				     =					jnp.transpose(__a,    (0, 2, 3, 1))
              _lowerCAmelCase  :							Tuple				     =					self.controlnet_cond_embedding(__a)
              sample += controlnet_cond

              # 3. down
              _lowerCAmelCase  :							Any				     =					(sample,)
              for down_block in self.down_blocks:
                     if isinstance(__a,    __a):
                            _lowerCAmelCase  :							Tuple				     =					down_block(__a,    __a,    __a,    deterministic=not train)
                     else:
                            _lowerCAmelCase  :							Optional[int]				     =					down_block(__a,    __a,    deterministic=not train)
                     down_block_res_samples += res_samples

              # 4. mid
              _lowerCAmelCase  :							Any				     =					self.mid_block(__a,    __a,    __a,    deterministic=not train)

              # 5. contronet blocks
              _lowerCAmelCase  :							str				     =					()
              for down_block_res_sample, controlnet_block in zip(__a,    self.controlnet_down_blocks):
                     _lowerCAmelCase  :							str				     =					controlnet_block(__a)
                     controlnet_down_block_res_samples += (down_block_res_sample,)

              _lowerCAmelCase  :							int				     =					controlnet_down_block_res_samples

              _lowerCAmelCase  :							List[Any]				     =					self.controlnet_mid_block(__a)

              # 6. scaling
              _lowerCAmelCase  :							List[str]				     =					[sample * conditioning_scale for sample in down_block_res_samples]
              mid_block_res_sample *= conditioning_scale

              if not return_dict:
                     return (down_block_res_samples, mid_block_res_sample)

              return FlaxControlNetOutput(
                  down_block_res_samples=__a,    mid_block_res_sample=__a)





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