code: 
  
  
  
  
  
  
  """simple docstring"""
  
  
  
  
  
  
  from dataclasses import dataclass
  from typing import Any, Dict, Optional
  
  import torch
  import torch.nn.functional as F
  from torch import nn
  
  from ..configuration_utils import ConfigMixin, register_to_config
  from ..models.embeddings import ImagePositionalEmbeddings
  from ..utils import BaseOutput, deprecate
  from .attention import BasicTransformerBlock
  from .embeddings import PatchEmbed
  from .modeling_utils import ModelMixin
  @dataclass
  class 						__lowerCAmelCase   (			UpperCAmelCase       ):
  
  
  
  
  
  
  
    '''simple docstring'''
  
  
    __lowerCamelCase       :    torch.FloatTensor
  
  
  
  
  class 						__lowerCAmelCase   (			UpperCAmelCase       ,   UpperCAmelCase       ):
  
  
  
  
  
  
  
    '''simple docstring'''
  
  
    @register_to_config
    def __init__(      self:		Dict				,			UpperCamelCase_:		int = 16				,			UpperCamelCase_:		int = 88				,			UpperCamelCase_:		Optional[int] = None				,			UpperCamelCase_:		Optional[int] = None				,			UpperCamelCase_:		int = 1				,			UpperCamelCase_:		float = 0.0				,			UpperCamelCase_:		int = 32				,			UpperCamelCase_:		Optional[int] = None				,			UpperCamelCase_:		bool = False				,			UpperCamelCase_:		Optional[int] = None				,			UpperCamelCase_:		Optional[int] = None				,			UpperCamelCase_:		Optional[int] = None				,			UpperCamelCase_:		str = "geglu"				,			UpperCamelCase_:		Optional[int] = None				,			UpperCamelCase_:		bool = False				,			UpperCamelCase_:		bool = False				,			UpperCamelCase_:		bool = False				,			UpperCamelCase_:		str = "layer_norm"				,			UpperCamelCase_:		bool = True				,			):
       super().__init__()
       UpperCamelCase_     =use_linear_projection
       UpperCamelCase_     =num_attention_heads
       UpperCamelCase_     =attention_head_dim
       UpperCamelCase_     =num_attention_heads * attention_head_dim
  
       # 1. Transformer2DModel can process both standard continuous images of shape `(batch_size, num_channels, width, height)` as well as quantized image embeddings of shape `(batch_size, num_image_vectors)`
       # Define whether input is continuous or discrete depending on configuration
       UpperCamelCase_     =(in_channels is not None) and (patch_size is None)
       UpperCamelCase_     =num_vector_embeds is not None
       UpperCamelCase_     =in_channels is not None and patch_size is not None
  
       if norm_type == "layer_norm" and num_embeds_ada_norm is not None:
          UpperCamelCase_     =(
              f"""The configuration file of this model: {self.__class__} is outdated. `norm_type` is either not set or"""
              " incorrectly set to `'layer_norm'`.Make sure to set `norm_type` to `'ada_norm'` in the config."
              " Please make sure to update the config accordingly as leaving `norm_type` might led to incorrect"
              " results in future versions. If you have downloaded this checkpoint from the Hugging Face Hub, it"
              " would be very nice if you could open a Pull request for the `transformer/config.json` file"
          )
          deprecate("norm_type!=num_embeds_ada_norm"				,			"1.0.0"				,			UpperCamelCase_				,			standard_warn=UpperCamelCase_					)
          UpperCamelCase_     ="ada_norm"
  
       if self.is_input_continuous and self.is_input_vectorized:
          raise ValueError(
              f"""Cannot define both `in_channels`: {in_channels} and `num_vector_embeds`: {num_vector_embeds}. Make"""
              " sure that either `in_channels` or `num_vector_embeds` is None."					)
       elif self.is_input_vectorized and self.is_input_patches:
          raise ValueError(
              f"""Cannot define both `num_vector_embeds`: {num_vector_embeds} and `patch_size`: {patch_size}. Make"""
              " sure that either `num_vector_embeds` or `num_patches` is None."					)
       elif not self.is_input_continuous and not self.is_input_vectorized and not self.is_input_patches:
          raise ValueError(
              f"""Has to define `in_channels`: {in_channels}, `num_vector_embeds`: {num_vector_embeds}, or patch_size:"""
              f""" {patch_size}. Make sure that `in_channels`, `num_vector_embeds` or `num_patches` is not None."""					)
  
       # 2. Define input layers
       if self.is_input_continuous:
          UpperCamelCase_     =in_channels
  
          UpperCamelCase_     =torch.nn.GroupNorm(num_groups=UpperCamelCase_				,			num_channels=UpperCamelCase_				,			eps=1e-6				,			affine=UpperCamelCase_					)
          if use_linear_projection:
             UpperCamelCase_     =nn.Linear(UpperCamelCase_				,			UpperCamelCase_					)
          else:
             UpperCamelCase_     =nn.Convad(UpperCamelCase_				,			UpperCamelCase_				,			kernel_size=1				,			stride=1				,			padding=0					)
       elif self.is_input_vectorized:
          assert sample_size is not None, "Transformer2DModel over discrete input must provide sample_size"
          assert num_vector_embeds is not None, "Transformer2DModel over discrete input must provide num_embed"
  
          UpperCamelCase_     =sample_size
          UpperCamelCase_     =sample_size
          UpperCamelCase_     =num_vector_embeds
          UpperCamelCase_     =self.height * self.width
  
          UpperCamelCase_     =ImagePositionalEmbeddings(
              num_embed=UpperCamelCase_				,			embed_dim=UpperCamelCase_				,			height=self.height				,			width=self.width					)
       elif self.is_input_patches:
          assert sample_size is not None, "Transformer2DModel over patched input must provide sample_size"
  
          UpperCamelCase_     =sample_size
          UpperCamelCase_     =sample_size
  
          UpperCamelCase_     =patch_size
          UpperCamelCase_     =PatchEmbed(
              height=UpperCamelCase_				,			width=UpperCamelCase_				,			patch_size=UpperCamelCase_				,			in_channels=UpperCamelCase_				,			embed_dim=UpperCamelCase_				,			)
  
       # 3. Define transformers blocks
       UpperCamelCase_     =nn.ModuleList(
           [
               BasicTransformerBlock(
                   UpperCamelCase_				,			UpperCamelCase_				,			UpperCamelCase_				,			dropout=UpperCamelCase_				,			cross_attention_dim=UpperCamelCase_				,			activation_fn=UpperCamelCase_				,			num_embeds_ada_norm=UpperCamelCase_				,			attention_bias=UpperCamelCase_				,			only_cross_attention=UpperCamelCase_				,			upcast_attention=UpperCamelCase_				,			norm_type=UpperCamelCase_				,			norm_elementwise_affine=UpperCamelCase_				,			)
               for d in range(UpperCamelCase_					)
           ]					)
  
       # 4. Define output layers
       UpperCamelCase_     =in_channels if out_channels is None else out_channels
       if self.is_input_continuous:
          # TODO: should use out_channels for continuous projections
          if use_linear_projection:
             UpperCamelCase_     =nn.Linear(UpperCamelCase_				,			UpperCamelCase_					)
          else:
             UpperCamelCase_     =nn.Convad(UpperCamelCase_				,			UpperCamelCase_				,			kernel_size=1				,			stride=1				,			padding=0					)
       elif self.is_input_vectorized:
          UpperCamelCase_     =nn.LayerNorm(UpperCamelCase_					)
          UpperCamelCase_     =nn.Linear(UpperCamelCase_				,			self.num_vector_embeds - 1					)
       elif self.is_input_patches:
          UpperCamelCase_     =nn.LayerNorm(UpperCamelCase_				,			elementwise_affine=UpperCamelCase_				,			eps=1e-6					)
          UpperCamelCase_     =nn.Linear(UpperCamelCase_				,			2 * inner_dim					)
          UpperCamelCase_     =nn.Linear(UpperCamelCase_				,			patch_size * patch_size * self.out_channels					)
  
  
  
  
  
    def 					UpperCamelCase__   (      self:		Optional[int]				,			UpperCamelCase_:		torch.Tensor				,			UpperCamelCase_:		Optional[torch.Tensor] = None				,			UpperCamelCase_:		Optional[torch.LongTensor] = None				,			UpperCamelCase_:		Optional[torch.LongTensor] = None				,			UpperCamelCase_:		Dict[str, Any] = None				,			UpperCamelCase_:		Optional[torch.Tensor] = None				,			UpperCamelCase_:		Optional[torch.Tensor] = None				,			UpperCamelCase_:		bool = True				,			):
       # ensure attention_mask is a bias, and give it a singleton query_tokens dimension.
       #   we may have done this conversion already, e.g. if we came here via UNet2DConditionModel#forward.
       #   we can tell by counting dims; if ndim == 2: it's a mask rather than a bias.
       # expects mask of shape:
       #   [batch, key_tokens]
       # adds singleton query_tokens dimension:
       #   [batch,                    1, key_tokens]
       # this helps to broadcast it as a bias over attention scores, which will be in one of the following shapes:
       #   [batch,  heads, query_tokens, key_tokens] (e.g. torch sdp attn)
       #   [batch * heads, query_tokens, key_tokens] (e.g. xformers or classic attn)
       if attention_mask is not None and attention_mask.ndim == 2:
          # assume that mask is expressed as:
          #   (1 = keep,      0 = discard)
          # convert mask into a bias that can be added to attention scores:
          #       (keep = +0,     discard = -10000.0)
          UpperCamelCase_     =(1 - attention_mask.to(hidden_states.dtype					)) * -1_0000.0
          UpperCamelCase_     =attention_mask.unsqueeze(1					)
  
       # convert encoder_attention_mask to a bias the same way we do for attention_mask
       if encoder_attention_mask is not None and encoder_attention_mask.ndim == 2:
          UpperCamelCase_     =(1 - encoder_attention_mask.to(hidden_states.dtype					)) * -1_0000.0
          UpperCamelCase_     =encoder_attention_mask.unsqueeze(1					)
  
       # 1. Input
       if self.is_input_continuous:
          UpperCamelCase_    ,							UpperCamelCase_    ,							UpperCamelCase_    ,							UpperCamelCase_     =hidden_states.shape
          UpperCamelCase_     =hidden_states
  
          UpperCamelCase_     =self.norm(UpperCamelCase_					)
          if not self.use_linear_projection:
             UpperCamelCase_     =self.proj_in(UpperCamelCase_					)
             UpperCamelCase_     =hidden_states.shape[1]
             UpperCamelCase_     =hidden_states.permute(0				,			2				,			3				,			1					).reshape(UpperCamelCase_				,			height * width				,			UpperCamelCase_					)
          else:
             UpperCamelCase_     =hidden_states.shape[1]
             UpperCamelCase_     =hidden_states.permute(0				,			2				,			3				,			1					).reshape(UpperCamelCase_				,			height * width				,			UpperCamelCase_					)
             UpperCamelCase_     =self.proj_in(UpperCamelCase_					)
       elif self.is_input_vectorized:
          UpperCamelCase_     =self.latent_image_embedding(UpperCamelCase_					)
       elif self.is_input_patches:
          UpperCamelCase_     =self.pos_embed(UpperCamelCase_					)
  
       # 2. Blocks
       for block in self.transformer_blocks:
          UpperCamelCase_     =block(
              UpperCamelCase_				,			attention_mask=UpperCamelCase_				,			encoder_hidden_states=UpperCamelCase_				,			encoder_attention_mask=UpperCamelCase_				,			timestep=UpperCamelCase_				,			cross_attention_kwargs=UpperCamelCase_				,			class_labels=UpperCamelCase_				,			)
  
       # 3. Output
       if self.is_input_continuous:
          if not self.use_linear_projection:
             UpperCamelCase_     =hidden_states.reshape(UpperCamelCase_				,			UpperCamelCase_				,			UpperCamelCase_				,			UpperCamelCase_					).permute(0				,			3				,			1				,			2					).contiguous()
             UpperCamelCase_     =self.proj_out(UpperCamelCase_					)
          else:
             UpperCamelCase_     =self.proj_out(UpperCamelCase_					)
             UpperCamelCase_     =hidden_states.reshape(UpperCamelCase_				,			UpperCamelCase_				,			UpperCamelCase_				,			UpperCamelCase_					).permute(0				,			3				,			1				,			2					).contiguous()
  
          UpperCamelCase_     =hidden_states + residual
       elif self.is_input_vectorized:
          UpperCamelCase_     =self.norm_out(UpperCamelCase_					)
          UpperCamelCase_     =self.out(UpperCamelCase_					)
          # (batch, self.num_vector_embeds - 1, self.num_latent_pixels)
          UpperCamelCase_     =logits.permute(0				,			2				,			1					)
  
          # log(p(x_0))
          UpperCamelCase_     =F.log_softmax(logits.double()				,			dim=1					).float()
       elif self.is_input_patches:
          # TODO: cleanup!
          UpperCamelCase_     =self.transformer_blocks[0].norma.emb(
              UpperCamelCase_				,			UpperCamelCase_				,			hidden_dtype=hidden_states.dtype					)
          UpperCamelCase_    ,							UpperCamelCase_     =self.proj_out_a(F.silu(UpperCamelCase_					)					).chunk(2				,			dim=1					)
          UpperCamelCase_     =self.norm_out(UpperCamelCase_					) * (1 + scale[:, None]) + shift[:, None]
          UpperCamelCase_     =self.proj_out_a(UpperCamelCase_					)
  
          # unpatchify
          UpperCamelCase_     =UpperCamelCase_     =int(hidden_states.shape[1] ** 0.5					)
          UpperCamelCase_     =hidden_states.reshape(
              shape=(-1, height, width, self.patch_size, self.patch_size, self.out_channels)					)
          UpperCamelCase_     =torch.einsum("nhwpqc->nchpwq"				,			UpperCamelCase_					)
          UpperCamelCase_     =hidden_states.reshape(
              shape=(-1, self.out_channels, height * self.patch_size, width * self.patch_size)					)
  
       if not return_dict:
          return (output,)
  
       return TransformeraDModelOutput(sample=UpperCamelCase_					)
  
style_context: 
  
  
  
  
  
  
  """simple docstring"""
  
  
  
  
  
  
  from datetime import date
  
  import requests
  
  A_			  =    "https://api.carbonintensity.org.uk/intensity"
  
  
  
  
  def 						_UpperCamelCase			(  ):
     UpperCamelCase_     =requests.get(A			).json()["data"][0]
     return last_half_hour["intensity"]["actual"]
  
  
  
  
  def 						_UpperCamelCase			(  A    ,       A			):
     return requests.get(f"""{BASE_URL}/{start}/{end}"""			).json()["data"]
  
  
  if __name__ == "__main__":
      for entry in fetch_from_to(start=date(2020, 10, 1), end=date(2020, 10, 3)):
          print("from {from} to {to}: {intensity[actual]}".format(**entry))
      print(f'''{fetch_last_half_hour() = }''')
  