






'''simple docstring'''

from dataclasses import dataclass
from typing import Dict, Optional, Union

import torch
import torch.nn.functional as F
from torch import nn

from ..configuration_utils import ConfigMixin, register_to_config
from ..utils import BaseOutput
from .attention import BasicTransformerBlock
from .attention_processor import AttentionProcessor, AttnProcessor
from .embeddings import TimestepEmbedding, Timesteps
from .modeling_utils import ModelMixin






@dataclass
class 				a_						(			__a				):
  lowercase     		=      42






class 				a_						(			__a	,       __a				):

  @register_to_config
  def __init__(      self			,		_SCREAMING_SNAKE_CASE = 32			,		_SCREAMING_SNAKE_CASE = 64			,		_SCREAMING_SNAKE_CASE = 20			,		_SCREAMING_SNAKE_CASE = 768			,		_SCREAMING_SNAKE_CASE=77			,		_SCREAMING_SNAKE_CASE=4			,		_SCREAMING_SNAKE_CASE = 0.0			,		_SCREAMING_SNAKE_CASE = "silu"			,		_SCREAMING_SNAKE_CASE = None			,		_SCREAMING_SNAKE_CASE = None			,		_SCREAMING_SNAKE_CASE = "linear"			,		_SCREAMING_SNAKE_CASE = "prd"			,		_SCREAMING_SNAKE_CASE = None			,		_SCREAMING_SNAKE_CASE = None			,		_SCREAMING_SNAKE_CASE = None			,		)  ->      Optional[Any]:



        """simple docstring"""






        super().__init__()
        UpperCamelCase				  =					num_attention_heads
        UpperCamelCase				  =					attention_head_dim
        UpperCamelCase				  =					num_attention_heads * attention_head_dim
        UpperCamelCase				  =					additional_embeddings

        UpperCamelCase				  =					time_embed_dim or inner_dim
        UpperCamelCase				  =					embedding_proj_dim or embedding_dim
        UpperCamelCase				  =					clip_embed_dim or embedding_dim

        UpperCamelCase				  =					Timesteps(lowerCAmelCase__			,		lowerCAmelCase__			,		0      )
        UpperCamelCase				  =					TimestepEmbedding(lowerCAmelCase__			,		lowerCAmelCase__			,		out_dim=lowerCAmelCase__			,		act_fn=lowerCAmelCase__      )

        UpperCamelCase				  =					nn.Linear(lowerCAmelCase__			,		lowerCAmelCase__      )

        if embedding_proj_norm_type is None:
              UpperCamelCase				  =					None
        elif embedding_proj_norm_type == "layer":
              UpperCamelCase				  =					nn.LayerNorm(lowerCAmelCase__      )
        else:
              raise ValueError(F"unsupported embedding_proj_norm_type: {embedding_proj_norm_type}"      )

        UpperCamelCase				  =					nn.Linear(lowerCAmelCase__			,		lowerCAmelCase__      )

        if encoder_hid_proj_type is None:
              UpperCamelCase				  =					None
        elif encoder_hid_proj_type == "linear":
              UpperCamelCase				  =					nn.Linear(lowerCAmelCase__			,		lowerCAmelCase__      )
        else:
              raise ValueError(F"unsupported encoder_hid_proj_type: {encoder_hid_proj_type}"      )

        UpperCamelCase				  =					nn.Parameter(torch.zeros(1			,		num_embeddings + additional_embeddings			,		lowerCAmelCase__      )      )

        if added_emb_type == "prd":
              UpperCamelCase				  =					nn.Parameter(torch.zeros(1			,		1			,		lowerCAmelCase__      )      )
        elif added_emb_type is None:
              UpperCamelCase				  =					None
        else:
              raise ValueError(
                  F"`added_emb_type`: {added_emb_type} is not supported. Make sure to choose one of `'prd'` or `None`."      )

        UpperCamelCase				  =					nn.ModuleList(
            [
                BasicTransformerBlock(
                    lowerCAmelCase__			,		lowerCAmelCase__			,		lowerCAmelCase__			,		dropout=lowerCAmelCase__			,		activation_fn="""gelu"""			,		attention_bias=lowerCAmelCase__			,		)
                for d in range(lowerCAmelCase__      )
            ]      )

        if norm_in_type == "layer":
              UpperCamelCase				  =					nn.LayerNorm(lowerCAmelCase__      )
        elif norm_in_type is None:
              UpperCamelCase				  =					None
        else:
              raise ValueError(F"Unsupported norm_in_type: {norm_in_type}."      )

        UpperCamelCase				  =					nn.LayerNorm(lowerCAmelCase__      )

        UpperCamelCase				  =					nn.Linear(lowerCAmelCase__			,		lowerCAmelCase__      )

        UpperCamelCase				  =					torch.full(
            [num_embeddings + additional_embeddings, num_embeddings + additional_embeddings]			,		-10000.0      )
        causal_attention_mask.triu_(1      )
        UpperCamelCase				  =					causal_attention_mask[None, ...]
        self.register_buffer("""causal_attention_mask"""			,		lowerCAmelCase__			,		persistent=lowerCAmelCase__      )

        UpperCamelCase				  =					nn.Parameter(torch.zeros(1			,		lowerCAmelCase__      )      )
        UpperCamelCase				  =					nn.Parameter(torch.zeros(1			,		lowerCAmelCase__      )      )

  @property
  # Copied from diffusers.models.unet_2d_condition.UNet2DConditionModel.attn_processors
  def   A__						(      self      )  ->      int:



        """simple docstring"""






        UpperCamelCase				  =					{}

        def fn_recursive_add_processors(_SCREAMING_SNAKE_CASE			,		_SCREAMING_SNAKE_CASE			,		_SCREAMING_SNAKE_CASE      ):
              if hasattr(lowerCAmelCase__			,		"""set_processor"""      ):
                    UpperCamelCase				  =					module.processor

              for sub_name, child in module.named_children():
                    fn_recursive_add_processors(F"{name}.{sub_name}"			,		lowerCAmelCase__			,		lowerCAmelCase__      )

              return processors

        for name, module in self.named_children():
              fn_recursive_add_processors(lowerCAmelCase__			,		lowerCAmelCase__			,		lowerCAmelCase__      )

        return processors

  def   A__						(      self			,		_SCREAMING_SNAKE_CASE      )  ->      Tuple:



        """simple docstring"""






        UpperCamelCase				  =					len(self.attn_processors.keys()      )

        if isinstance(lowerCAmelCase__			,		lowerCAmelCase__      ) and len(lowerCAmelCase__      ) != count:
              raise ValueError(
                  F"A dict of processors was passed, but the number of processors {len(lowerCAmelCase__      )} does not match the"
                  F" number of attention layers: {count}. Please make sure to pass {count} processor classes."      )

        def fn_recursive_attn_processor(_SCREAMING_SNAKE_CASE			,		_SCREAMING_SNAKE_CASE			,		_SCREAMING_SNAKE_CASE      ):
              if hasattr(lowerCAmelCase__			,		"""set_processor"""      ):
                    if not isinstance(lowerCAmelCase__			,		lowerCAmelCase__      ):
                          module.set_processor(lowerCAmelCase__      )
                    else:
                          module.set_processor(processor.pop(F"{name}.processor"      )      )

              for sub_name, child in module.named_children():
                    fn_recursive_attn_processor(F"{name}.{sub_name}"			,		lowerCAmelCase__			,		lowerCAmelCase__      )

        for name, module in self.named_children():
              fn_recursive_attn_processor(lowerCAmelCase__			,		lowerCAmelCase__			,		lowerCAmelCase__      )

  def   A__						(      self      )  ->      Optional[Any]:



        """simple docstring"""






        self.set_attn_processor(AttnProcessor()      )

  def   A__						(      self			,		_SCREAMING_SNAKE_CASE			,		_SCREAMING_SNAKE_CASE			,		_SCREAMING_SNAKE_CASE			,		_SCREAMING_SNAKE_CASE = None			,		_SCREAMING_SNAKE_CASE = None			,		_SCREAMING_SNAKE_CASE = True			,		)  ->      List[Any]:



        """simple docstring"""






        UpperCamelCase				  =					hidden_states.shape[0]

        UpperCamelCase				  =					timestep
        if not torch.is_tensor(lowerCAmelCase__      ):
              UpperCamelCase				  =					torch.tensor([timesteps]			,		dtype=torch.long			,		device=hidden_states.device      )
        elif torch.is_tensor(lowerCAmelCase__      ) and len(timesteps.shape      ) == 0:
              UpperCamelCase				  =					timesteps[None].to(hidden_states.device      )

        # broadcast to batch dimension in a way that's compatible with ONNX/Core ML
        UpperCamelCase				  =					timesteps * torch.ones(lowerCAmelCase__			,		dtype=timesteps.dtype			,		device=timesteps.device      )

        UpperCamelCase				  =					self.time_proj(lowerCAmelCase__      )

        # timesteps does not contain any weights and will always return f32 tensors
        # but time_embedding might be fp16, so we need to cast here.
        UpperCamelCase				  =					timesteps_projected.to(dtype=self.dtype      )
        UpperCamelCase				  =					self.time_embedding(lowerCAmelCase__      )

        if self.embedding_proj_norm is not None:
              UpperCamelCase				  =					self.embedding_proj_norm(lowerCAmelCase__      )

        UpperCamelCase				  =					self.embedding_proj(lowerCAmelCase__      )
        if self.encoder_hidden_states_proj is not None and encoder_hidden_states is not None:
              UpperCamelCase				  =					self.encoder_hidden_states_proj(lowerCAmelCase__      )
        elif self.encoder_hidden_states_proj is not None and encoder_hidden_states is None:
              raise ValueError("""`encoder_hidden_states_proj` requires `encoder_hidden_states` to be set"""      )

        UpperCamelCase				  =					self.proj_in(lowerCAmelCase__      )

        UpperCamelCase				  =					self.positional_embedding.to(hidden_states.dtype      )

        UpperCamelCase				  =					[]
        UpperCamelCase				  =					0

        if encoder_hidden_states is not None:
              additional_embeds.append(lowerCAmelCase__      )
              additional_embeddings_len += encoder_hidden_states.shape[1]

        if len(proj_embeddings.shape      ) == 2:
              UpperCamelCase				  =					proj_embeddings[:, None, :]

        if len(hidden_states.shape      ) == 2:
              UpperCamelCase				  =					hidden_states[:, None, :]

        UpperCamelCase				  =					additional_embeds + [
            proj_embeddings,
            time_embeddings[:, None, :],
            hidden_states,
        ]

        if self.prd_embedding is not None:
              UpperCamelCase				  =					self.prd_embedding.to(hidden_states.dtype      ).expand(lowerCAmelCase__			,		-1			,		-1      )
              additional_embeds.append(lowerCAmelCase__      )

        UpperCamelCase				  =					torch.cat(
            lowerCAmelCase__			,		dim=1			,		)

        # Allow positional_embedding to not include the `addtional_embeddings` and instead pad it with zeros for these additional tokens
        UpperCamelCase				  =					additional_embeddings_len + proj_embeddings.shape[1] + 1
        if positional_embeddings.shape[1] < hidden_states.shape[1]:
              UpperCamelCase				  =					F.pad(
                  lowerCAmelCase__			,		(
                      0,
                      0,
                      additional_embeddings_len,
                      self.prd_embedding.shape[1] if self.prd_embedding is not None else 0,
                  )			,		value=0.0			,		)

        UpperCamelCase				  =					hidden_states + positional_embeddings

        if attention_mask is not None:
              UpperCamelCase				  =					(1 - attention_mask.to(hidden_states.dtype      )) * -10000.0
              UpperCamelCase				  =					F.pad(lowerCAmelCase__			,		(0, self.additional_embeddings)			,		value=0.0      )
              UpperCamelCase				  =					(attention_mask[:, None, :] + self.causal_attention_mask).to(hidden_states.dtype      )
              UpperCamelCase				  =					attention_mask.repeat_interleave(self.config.num_attention_heads			,		dim=0      )

        if self.norm_in is not None:
              UpperCamelCase				  =					self.norm_in(lowerCAmelCase__      )

        for block in self.transformer_blocks:
              UpperCamelCase				  =					block(lowerCAmelCase__			,		attention_mask=lowerCAmelCase__      )

        UpperCamelCase				  =					self.norm_out(lowerCAmelCase__      )

        if self.prd_embedding is not None:
              UpperCamelCase				  =					hidden_states[:, -1]
        else:
              UpperCamelCase				  =					hidden_states[:, additional_embeddings_len:]

        UpperCamelCase				  =					self.proj_to_clip_embeddings(lowerCAmelCase__      )

        if not return_dict:
              return (predicted_image_embedding,)

        return PriorTransformerOutput(predicted_image_embedding=lowerCAmelCase__      )


  def   A__						(      self			,		_SCREAMING_SNAKE_CASE      )  ->      Optional[int]:



        """simple docstring"""






        UpperCamelCase				  =					(prior_latents * self.clip_std) + self.clip_mean
        return prior_latents


"""simple docstring"""





import requests
from bsa import BeautifulSoup



def 						_lowerCAmelCase				(				UpperCamelCase_ = "AAPL"				):
		__SCREAMING_SNAKE_CASE            = f"https://in.finance.yahoo.com/quote/{symbol}?s={symbol}"
		__SCREAMING_SNAKE_CASE            = BeautifulSoup(requests.get(UpperCamelCase_				).text  ,				"""html.parser"""				)
		__SCREAMING_SNAKE_CASE            = """My(6px) Pos(r) smartphone_Mt(6px)"""
		return soup.find("""div"""  ,				class_=class_				).find("""span"""				).text


if __name__ == "__main__":
							for symbol in "AAPL AMZN IBM GOOG MSFT ORCL".split():
														print(F"""Current {symbol:<4} stock price is {stock_price(symbol):>8}""")




