
"""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							(SCREAMING_SNAKE_CASE__):






     '''simple docstring'''
     _SCREAMING_SNAKE_CASE						:Tuple       = 42





class      __a							(SCREAMING_SNAKE_CASE__   ,	SCREAMING_SNAKE_CASE__):






     '''simple docstring'''

     @register_to_config
     def __init__(						self	,    _a = 32	,    _a = 64	,    _a = 20	,    _a = 768	,    _a=77	,    _a=4	,    _a = 0.0	,    _a = "silu"	,    _a = None	,    _a = None	,    _a = "linear"	,    _a = "prd"	,    _a = None	,    _a = None	,    _a = None	,    )  ->      Dict:


           """simple docstring"""


           super().__init__()
           SCREAMING_SNAKE_CASE__   :      Tuple      		=	num_attention_heads
           SCREAMING_SNAKE_CASE__   :      str      		=	attention_head_dim
           SCREAMING_SNAKE_CASE__   :      Optional[Any]      		=	num_attention_heads * attention_head_dim
           SCREAMING_SNAKE_CASE__   :      List[str]      		=	additional_embeddings

           SCREAMING_SNAKE_CASE__   :      Any      		=	time_embed_dim or inner_dim
           SCREAMING_SNAKE_CASE__   :      Any      		=	embedding_proj_dim or embedding_dim
           SCREAMING_SNAKE_CASE__   :      List[str]      		=	clip_embed_dim or embedding_dim

           SCREAMING_SNAKE_CASE__   :      int      		=	Timesteps(_lowercase	,    _lowercase	,    0  )
           SCREAMING_SNAKE_CASE__   :      Dict      		=	TimestepEmbedding(_lowercase	,    _lowercase	,    out_dim=_lowercase	,    act_fn=_lowercase  )

           SCREAMING_SNAKE_CASE__   :      Union[str, Any]      		=	nn.Linear(_lowercase	,    _lowercase  )

           if embedding_proj_norm_type is None:
                 SCREAMING_SNAKE_CASE__   :      List[str]      		=	None
           elif embedding_proj_norm_type == "layer":
                 SCREAMING_SNAKE_CASE__   :      Dict      		=	nn.LayerNorm(_lowercase  )
           else:
                 raise ValueError(f'''unsupported embedding_proj_norm_type: {embedding_proj_norm_type}'''  )

           SCREAMING_SNAKE_CASE__   :      Any      		=	nn.Linear(_lowercase	,    _lowercase  )

           if encoder_hid_proj_type is None:
                 SCREAMING_SNAKE_CASE__   :      str      		=	None
           elif encoder_hid_proj_type == "linear":
                 SCREAMING_SNAKE_CASE__   :      List[str]      		=	nn.Linear(_lowercase	,    _lowercase  )
           else:
                 raise ValueError(f'''unsupported encoder_hid_proj_type: {encoder_hid_proj_type}'''  )

           SCREAMING_SNAKE_CASE__   :      Any      		=	nn.Parameter(torch.zeros(1	,    num_embeddings + additional_embeddings	,    _lowercase  )  )

           if added_emb_type == "prd":
                 SCREAMING_SNAKE_CASE__   :      Dict      		=	nn.Parameter(torch.zeros(1	,    1	,    _lowercase  )  )
           elif added_emb_type is None:
                 SCREAMING_SNAKE_CASE__   :      int      		=	None
           else:
                 raise ValueError(
                     f'''`added_emb_type`: {added_emb_type} is not supported. Make sure to choose one of `\'prd\'` or `None`.'''  )

           SCREAMING_SNAKE_CASE__   :      Tuple      		=	nn.ModuleList(
               [
                   BasicTransformerBlock(
                       _lowercase	,    _lowercase	,    _lowercase	,    dropout=_lowercase	,    activation_fn="""gelu"""	,    attention_bias=_lowercase	,    )
                   for d in range(_lowercase  )
               ]  )

           if norm_in_type == "layer":
                 SCREAMING_SNAKE_CASE__   :      Optional[Any]      		=	nn.LayerNorm(_lowercase  )
           elif norm_in_type is None:
                 SCREAMING_SNAKE_CASE__   :      List[str]      		=	None
           else:
                 raise ValueError(f'''Unsupported norm_in_type: {norm_in_type}.'''  )

           SCREAMING_SNAKE_CASE__   :      int      		=	nn.LayerNorm(_lowercase  )

           SCREAMING_SNAKE_CASE__   :      str      		=	nn.Linear(_lowercase	,    _lowercase  )

           SCREAMING_SNAKE_CASE__   :      Optional[Any]      		=	torch.full(
               [num_embeddings + additional_embeddings, num_embeddings + additional_embeddings]	,    -10_000.0  )
           causal_attention_mask.triu_(1  )
           SCREAMING_SNAKE_CASE__   :      Optional[int]      		=	causal_attention_mask[None, ...]
           self.register_buffer("""causal_attention_mask"""	,    _lowercase	,    persistent=_lowercase  )

           SCREAMING_SNAKE_CASE__   :      Any      		=	nn.Parameter(torch.zeros(1	,    _lowercase  )  )
           SCREAMING_SNAKE_CASE__   :      Dict      		=	nn.Parameter(torch.zeros(1	,    _lowercase  )  )

     @property
     # Copied from diffusers.models.unet_2d_condition.UNet2DConditionModel.attn_processors
     def 					_a			(						self  )  ->      Dict[str, AttentionProcessor]:


           """simple docstring"""


           SCREAMING_SNAKE_CASE__   :      Optional[Any]      		=	{}

           def fn_recursive_add_processors(_a	,    _a	,    _a  ):
                 if hasattr(_lowercase	,    """set_processor"""  ):
                       SCREAMING_SNAKE_CASE__   :      str      		=	module.processor

                 for sub_name, child in module.named_children():
                       fn_recursive_add_processors(f'''{name}.{sub_name}'''	,    _lowercase	,    _lowercase  )

                 return processors

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

           return processors

     def 					_a			(						self	,    _a  )  ->      Union[str, Any]:


           """simple docstring"""


           SCREAMING_SNAKE_CASE__   :      Optional[int]      		=	len(self.attn_processors.keys()  )

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

           def fn_recursive_attn_processor(_a	,    _a	,    _a  ):
                 if hasattr(_lowercase	,    """set_processor"""  ):
                       if not isinstance(_lowercase	,    _lowercase  ):
                             module.set_processor(_lowercase  )
                       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}'''	,    _lowercase	,    _lowercase  )

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

     def 					_a			(						self  )  ->      int:


           """simple docstring"""


           self.set_attn_processor(AttnProcessor()  )

     def 					_a			(						self	,    _a	,    _a	,    _a	,    _a = None	,    _a = None	,    _a = True	,    )  ->      Any:


           """simple docstring"""


           SCREAMING_SNAKE_CASE__   :      Tuple      		=	hidden_states.shape[0]

           SCREAMING_SNAKE_CASE__   :      List[Any]      		=	timestep
           if not torch.is_tensor(_lowercase  ):
                 SCREAMING_SNAKE_CASE__   :      Optional[Any]      		=	torch.tensor([timesteps]	,    dtype=torch.long	,    device=hidden_states.device  )
           elif torch.is_tensor(_lowercase  ) and len(timesteps.shape  ) == 0:
                 SCREAMING_SNAKE_CASE__   :      str      		=	timesteps[None].to(hidden_states.device  )

           # broadcast to batch dimension in a way that's compatible with ONNX/Core ML
           SCREAMING_SNAKE_CASE__   :      Optional[Any]      		=	timesteps * torch.ones(_lowercase	,    dtype=timesteps.dtype	,    device=timesteps.device  )

           SCREAMING_SNAKE_CASE__   :      Tuple      		=	self.time_proj(_lowercase  )

           # timesteps does not contain any weights and will always return f32 tensors
           # but time_embedding might be fp16, so we need to cast here.
           SCREAMING_SNAKE_CASE__   :      List[Any]      		=	timesteps_projected.to(dtype=self.dtype  )
           SCREAMING_SNAKE_CASE__   :      Optional[Any]      		=	self.time_embedding(_lowercase  )

           if self.embedding_proj_norm is not None:
                 SCREAMING_SNAKE_CASE__   :      Optional[Any]      		=	self.embedding_proj_norm(_lowercase  )

           SCREAMING_SNAKE_CASE__   :      List[Any]      		=	self.embedding_proj(_lowercase  )
           if self.encoder_hidden_states_proj is not None and encoder_hidden_states is not None:
                 SCREAMING_SNAKE_CASE__   :      List[Any]      		=	self.encoder_hidden_states_proj(_lowercase  )
           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"""  )

           SCREAMING_SNAKE_CASE__   :      Dict      		=	self.proj_in(_lowercase  )

           SCREAMING_SNAKE_CASE__   :      str      		=	self.positional_embedding.to(hidden_states.dtype  )

           SCREAMING_SNAKE_CASE__   :      Any      		=	[]
           SCREAMING_SNAKE_CASE__   :      Optional[Any]      		=	0

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

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

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

           SCREAMING_SNAKE_CASE__   :      List[str]      		=	additional_embeds + [
               proj_embeddings,
               time_embeddings[:, None, :],
               hidden_states,
           ]

           if self.prd_embedding is not None:
                 SCREAMING_SNAKE_CASE__   :      Optional[int]      		=	self.prd_embedding.to(hidden_states.dtype  ).expand(_lowercase	,    -1	,    -1  )
                 additional_embeds.append(_lowercase  )

           SCREAMING_SNAKE_CASE__   :      List[Any]      		=	torch.cat(
               _lowercase	,    dim=1	,    )

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

           SCREAMING_SNAKE_CASE__   :      int      		=	hidden_states + positional_embeddings

           if attention_mask is not None:
                 SCREAMING_SNAKE_CASE__   :      Union[str, Any]      		=	(1 - attention_mask.to(hidden_states.dtype  )) * -10_000.0
                 SCREAMING_SNAKE_CASE__   :      Dict      		=	F.pad(_lowercase	,    (0, self.additional_embeddings)	,    value=0.0  )
                 SCREAMING_SNAKE_CASE__   :      List[Any]      		=	(attention_mask[:, None, :] + self.causal_attention_mask).to(hidden_states.dtype  )
                 SCREAMING_SNAKE_CASE__   :      int      		=	attention_mask.repeat_interleave(self.config.num_attention_heads	,    dim=0  )

           if self.norm_in is not None:
                 SCREAMING_SNAKE_CASE__   :      List[str]      		=	self.norm_in(_lowercase  )

           for block in self.transformer_blocks:
                 SCREAMING_SNAKE_CASE__   :      Optional[Any]      		=	block(_lowercase	,    attention_mask=_lowercase  )

           SCREAMING_SNAKE_CASE__   :      int      		=	self.norm_out(_lowercase  )

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

           SCREAMING_SNAKE_CASE__   :      List[Any]      		=	self.proj_to_clip_embeddings(_lowercase  )

           if not return_dict:
                 return (predicted_image_embedding,)

           return PriorTransformerOutput(predicted_image_embedding=_lowercase  )





     def 					_a			(						self	,    _a  )  ->      Union[str, Any]:


           """simple docstring"""


           SCREAMING_SNAKE_CASE__   :      List[Any]      		=	(prior_latents * self.clip_std) + self.clip_mean
           return prior_latents







"""simple docstring"""


def  _lowercase					(    __lowerCAmelCase							)       ->				int:
      if divisor % 5 == 0 or divisor % 2 == 0:
            return 0
      SCREAMING_SNAKE_CASE__   :      List[Any]      		=	1
      SCREAMING_SNAKE_CASE__   :      int      		=	1
      while repunit:
            SCREAMING_SNAKE_CASE__   :      str      		=	(10 * repunit + 1) % divisor
            repunit_index += 1
      return repunit_index




def  _lowercase					(    __lowerCAmelCase = 100_0000							)       ->				int:
      SCREAMING_SNAKE_CASE__   :      Dict      		=	limit - 1
      if divisor % 2 == 0:
            divisor += 1
      while least_divisible_repunit(__lowerCAmelCase							) <= limit:
            divisor += 2
      return divisor


if __name__ == "__main__":
  print(f'{solution() = }')




