

import os
import random
import sys

from . import cryptomath_module as cryptomath
from . import rabin_miller

A__						=							3




def 					_lowercase     (				a_				:					int				)				->	int:




					'''simple docstring'''







					print('Generating primitive root of p'				)
					while True:
										__magic_name__							=    random.randrange(3					,a_				)
										if pow(a_					,2					,a_				) == 1:
															continue
										if pow(a_					,a_					,a_				) == 1:
															continue
										return g




def 					_lowercase     (				a_				:					int				)				->	tuple[tuple[int, int, int, int], tuple[int, int]]:




					'''simple docstring'''







					print('Generating prime p...'				)
					__magic_name__							=    rabin_miller.generate_large_prime(a_				)  # select large prime number.
					__magic_name__							=    primitive_root(a_				)  # one primitive root on modulo p.
					__magic_name__							=    random.randrange(3					,a_				)  # private_key -> have to be greater than 2 for safety.
					__magic_name__							=    cryptomath.find_mod_inverse(pow(a_					,a_					,a_				)					,a_				)

					__magic_name__							=    (key_size, e_a, e_a, p)
					__magic_name__							=    (key_size, d)

					return public_key, private_key




def 					_lowercase     (				a_				:					str					,a_				:					int				)				->	None:




					'''simple docstring'''







					if os.path.exists(F'{name}_pubkey.txt'				) or os.path.exists(F'{name}_privkey.txt'				):
										print('\nWARNING:'				)
										print(
										    F'"{name}_pubkey.txt" or "{name}_privkey.txt" already exists. \n'
										    'Use a different name or delete these files and re-run this program.'				)
										sys.exit()

					__magic_name__,	__magic_name__							=    generate_key(a_				)
					print(F'\nWriting public key to file {name}_pubkey.txt...'				)
					with open(F'{name}_pubkey.txt'					,'w'				) as fo:
										fo.write(F'{public_key[0]},{public_key[1]},{public_key[2]},{public_key[3]}'				)

					print(F'Writing private key to file {name}_privkey.txt...'				)
					with open(F'{name}_privkey.txt'					,'w'				) as fo:
										fo.write(F'{private_key[0]},{private_key[1]}'				)




def 					_lowercase     (				)				->	None:




					'''simple docstring'''







					print('Making key files...'				)
					make_key_files('elgamal'					,2_0_4_8				)
					print('Key files generation successful'				)


if __name__ == "__main__":
						main()







import torch
from torch import nn

from ...configuration_utils import ConfigMixin, register_to_config
from ...models import ModelMixin

class 				__UpperCamelCase				(					SCREAMING_SNAKE_CASE  ,						SCREAMING_SNAKE_CASE			):







	@register_to_config
	def __init__(   self: Optional[Any]  , *,
	    __UpperCamelCase: int = 4  , __UpperCamelCase: int = 7_68  , __UpperCamelCase: int  , __UpperCamelCase: Any  , ):

						'''simple docstring'''





						super().__init__()

						__magic_name__							=    nn.Parameter(torch.zeros(__UpperCamelCase      )      )

						# parameters for additional clip time embeddings
						__magic_name__							=    nn.Linear(__UpperCamelCase  , __UpperCamelCase      )
						__magic_name__							=    nn.Linear(__UpperCamelCase  , __UpperCamelCase      )

						# parameters for encoder hidden states
						__magic_name__							=    clip_extra_context_tokens
						__magic_name__							=    nn.Linear(
						    __UpperCamelCase  , self.clip_extra_context_tokens * cross_attention_dim      )
						__magic_name__							=    nn.Linear(__UpperCamelCase  , __UpperCamelCase      )
						__magic_name__							=    nn.LayerNorm(__UpperCamelCase      )







	def 	_SCREAMING_SNAKE_CASE							(   self: List[str]  , *, __UpperCamelCase: Union[str, Any]  , __UpperCamelCase: str  , __UpperCamelCase: Optional[Any]  , __UpperCamelCase: Any      ):

						'''simple docstring'''





						if do_classifier_free_guidance:
											# Add the classifier free guidance embeddings to the image embeddings
											__magic_name__							=    image_embeddings.shape[0]
											__magic_name__							=    self.learned_classifier_free_guidance_embeddings.unsqueeze(0      )
											__magic_name__							=    classifier_free_guidance_embeddings.expand(
											    __UpperCamelCase  , -1      )
											__magic_name__							=    torch.cat([classifier_free_guidance_embeddings, image_embeddings]  , dim=0      )

						# The image embeddings batch size and the text embeddings batch size are equal
						assert image_embeddings.shape[0] == prompt_embeds.shape[0]

						__magic_name__							=    prompt_embeds.shape[0]

						# "Specifically, we modify the architecture described in Nichol et al. (2021) by projecting and
						# adding CLIP embeddings to the existing timestep embedding, ...
						__magic_name__							=    self.embedding_proj(__UpperCamelCase      )
						__magic_name__							=    self.clip_image_embeddings_project_to_time_embeddings(__UpperCamelCase      )
						__magic_name__							=    time_projected_image_embeddings + time_projected_prompt_embeds

						# ... and by projecting CLIP embeddings into four
						# extra tokens of context that are concatenated to the sequence of outputs from the GLIDE text encoder"
						__magic_name__							=    self.clip_extra_context_tokens_proj(__UpperCamelCase      )
						__magic_name__							=    clip_extra_context_tokens.reshape(__UpperCamelCase  , -1  , self.clip_extra_context_tokens      )
						__magic_name__							=    clip_extra_context_tokens.permute(0  , 2  , 1      )

						__magic_name__							=    self.encoder_hidden_states_proj(__UpperCamelCase      )
						__magic_name__							=    self.text_encoder_hidden_states_norm(__UpperCamelCase      )
						__magic_name__							=    torch.cat([clip_extra_context_tokens, text_encoder_hidden_states]  , dim=1      )

						return text_encoder_hidden_states, additive_clip_time_embeddings




