




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 				__UpperCamelCase      (			__UpperCAmelCase	):





				'''simple docstring'''



				__a				:			torch.FloatTensor




class 				__UpperCamelCase      (			__UpperCAmelCase  ,       __UpperCAmelCase	):





				'''simple docstring'''



				@register_to_config
				def __init__(			self							,			UpperCAmelCase_ = 16							,			UpperCAmelCase_ = 88							,			UpperCAmelCase_ = None							,			UpperCAmelCase_ = None							,			UpperCAmelCase_ = 1							,			UpperCAmelCase_ = 0.0							,			UpperCAmelCase_ = 32							,			UpperCAmelCase_ = None							,			UpperCAmelCase_ = False							,			UpperCAmelCase_ = None							,			UpperCAmelCase_ = None							,			UpperCAmelCase_ = None							,			UpperCAmelCase_ = "geglu"							,			UpperCAmelCase_ = None							,			UpperCAmelCase_ = False							,			UpperCAmelCase_ = False							,			UpperCAmelCase_ = False							,			UpperCAmelCase_ = "layer_norm"							,			UpperCAmelCase_ = True							,			):
											super().__init__()
											lowerCAmelCase =		use_linear_projection
											lowerCAmelCase =		num_attention_heads
											lowerCAmelCase =		attention_head_dim
											lowerCAmelCase =		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
											lowerCAmelCase =		(in_channels is not None) and (patch_size is None)
											lowerCAmelCase =		num_vector_embeds is not None
											lowerCAmelCase =		in_channels is not None and patch_size is not None

											if norm_type == "layer_norm" and num_embeds_ada_norm is not None:
																		lowerCAmelCase =		(
																		    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_    )
																		lowerCAmelCase =		'''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:
																		lowerCAmelCase =		in_channels

																		lowerCAmelCase =		torch.nn.GroupNorm(num_groups=UpperCAmelCase_							,			num_channels=UpperCAmelCase_							,			eps=1E-6							,			affine=UpperCAmelCase_    )
																		if use_linear_projection:
																									lowerCAmelCase =		nn.Linear(UpperCAmelCase_							,			UpperCAmelCase_    )
																		else:
																									lowerCAmelCase =		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"

																		lowerCAmelCase =		sample_size
																		lowerCAmelCase =		sample_size
																		lowerCAmelCase =		num_vector_embeds
																		lowerCAmelCase =		self.height * self.width

																		lowerCAmelCase =		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"

																		lowerCAmelCase =		sample_size
																		lowerCAmelCase =		sample_size

																		lowerCAmelCase =		patch_size
																		lowerCAmelCase =		PatchEmbed(
																		    height=UpperCAmelCase_							,			width=UpperCAmelCase_							,			patch_size=UpperCAmelCase_							,			in_channels=UpperCAmelCase_							,			embed_dim=UpperCAmelCase_							,			)

											# 3. Define transformers blocks
											lowerCAmelCase =		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
											lowerCAmelCase =		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:
																									lowerCAmelCase =		nn.Linear(UpperCAmelCase_							,			UpperCAmelCase_    )
																		else:
																									lowerCAmelCase =		nn.Convad(UpperCAmelCase_							,			UpperCAmelCase_							,			kernel_size=1							,			stride=1							,			padding=0    )
											elif self.is_input_vectorized:
																		lowerCAmelCase =		nn.LayerNorm(UpperCAmelCase_    )
																		lowerCAmelCase =		nn.Linear(UpperCAmelCase_							,			self.num_vector_embeds - 1    )
											elif self.is_input_patches:
																		lowerCAmelCase =		nn.LayerNorm(UpperCAmelCase_							,			elementwise_affine=UpperCAmelCase_							,			eps=1E-6    )
																		lowerCAmelCase =		nn.Linear(UpperCAmelCase_							,			2 * inner_dim    )
																		lowerCAmelCase =		nn.Linear(UpperCAmelCase_							,			patch_size * patch_size * self.out_channels    )






				def    __snake_case		(			self							,			UpperCAmelCase_							,			UpperCAmelCase_ = None							,			UpperCAmelCase_ = None							,			UpperCAmelCase_ = None							,			UpperCAmelCase_ = None							,			UpperCAmelCase_ = None							,			UpperCAmelCase_ = None							,			UpperCAmelCase_ = 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)
																		lowerCAmelCase =		(1 - attention_mask.to(hidden_states.dtype    )) * -10000.0
																		lowerCAmelCase =		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:
																		lowerCAmelCase =		(1 - encoder_attention_mask.to(hidden_states.dtype    )) * -10000.0
																		lowerCAmelCase =		encoder_attention_mask.unsqueeze(1    )

											# 1. Input
											if self.is_input_continuous:
																		lowerCAmelCase ,  lowerCAmelCase ,  lowerCAmelCase ,  lowerCAmelCase =		hidden_states.shape
																		lowerCAmelCase =		hidden_states

																		lowerCAmelCase =		self.norm(UpperCAmelCase_    )
																		if not self.use_linear_projection:
																									lowerCAmelCase =		self.proj_in(UpperCAmelCase_    )
																									lowerCAmelCase =		hidden_states.shape[1]
																									lowerCAmelCase =		hidden_states.permute(0							,			2							,			3							,			1    ).reshape(UpperCAmelCase_							,			height * width							,			UpperCAmelCase_    )
																		else:
																									lowerCAmelCase =		hidden_states.shape[1]
																									lowerCAmelCase =		hidden_states.permute(0							,			2							,			3							,			1    ).reshape(UpperCAmelCase_							,			height * width							,			UpperCAmelCase_    )
																									lowerCAmelCase =		self.proj_in(UpperCAmelCase_    )
											elif self.is_input_vectorized:
																		lowerCAmelCase =		self.latent_image_embedding(UpperCAmelCase_    )
											elif self.is_input_patches:
																		lowerCAmelCase =		self.pos_embed(UpperCAmelCase_    )

											# 2. Blocks
											for block in self.transformer_blocks:
																		lowerCAmelCase =		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:
																									lowerCAmelCase =		hidden_states.reshape(UpperCAmelCase_							,			UpperCAmelCase_							,			UpperCAmelCase_							,			UpperCAmelCase_    ).permute(0							,			3							,			1							,			2    ).contiguous()
																									lowerCAmelCase =		self.proj_out(UpperCAmelCase_    )
																		else:
																									lowerCAmelCase =		self.proj_out(UpperCAmelCase_    )
																									lowerCAmelCase =		hidden_states.reshape(UpperCAmelCase_							,			UpperCAmelCase_							,			UpperCAmelCase_							,			UpperCAmelCase_    ).permute(0							,			3							,			1							,			2    ).contiguous()

																		lowerCAmelCase =		hidden_states + residual
											elif self.is_input_vectorized:
																		lowerCAmelCase =		self.norm_out(UpperCAmelCase_    )
																		lowerCAmelCase =		self.out(UpperCAmelCase_    )
																		# (batch, self.num_vector_embeds - 1, self.num_latent_pixels)
																		lowerCAmelCase =		logits.permute(0							,			2							,			1    )

																		# log(p(x_0))
																		lowerCAmelCase =		F.log_softmax(logits.double()							,			dim=1    ).float()
											elif self.is_input_patches:
																		# TODO: cleanup!
																		lowerCAmelCase =		self.transformer_blocks[0].norma.emb(
																		    UpperCAmelCase_							,			UpperCAmelCase_							,			hidden_dtype=hidden_states.dtype    )
																		lowerCAmelCase ,  lowerCAmelCase =		self.proj_out_a(F.silu(UpperCAmelCase_    )    ).chunk(2							,			dim=1    )
																		lowerCAmelCase =		self.norm_out(UpperCAmelCase_    ) * (1 + scale[:, None]) + shift[:, None]
																		lowerCAmelCase =		self.proj_out_a(UpperCAmelCase_    )

																		# unpatchify
																		lowerCAmelCase =		lowerCAmelCase =		int(hidden_states.shape[1] ** 0.5    )
																		lowerCAmelCase =		hidden_states.reshape(
																		    shape=(-1, height, width, self.patch_size, self.patch_size, self.out_channels)    )
																		lowerCAmelCase =		torch.einsum('''nhwpqc->nchpwq'''							,			UpperCAmelCase_    )
																		lowerCAmelCase =		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_    )









import os
import sys

from . import rsa_key_generator as rkg

UpperCAmelCase_    =128
UpperCAmelCase_    =256



def    UpperCAmelCase							(  _snake_case    ,			_snake_case = DEFAULT_BLOCK_SIZE				):
							lowerCAmelCase =		message.encode('''ascii'''				)

							lowerCAmelCase =		[]
							for block_start in range(0    ,			len(_snake_case				)    ,			_snake_case				):
														lowerCAmelCase =		0
														for i in range(_snake_case    ,			min(block_start + block_size    ,			len(_snake_case				)				)				):
																					block_int += message_bytes[i] * (BYTE_SIZE ** (i % block_size))
														block_ints.append(_snake_case				)
							return block_ints



def    UpperCAmelCase							(  _snake_case    ,			_snake_case    ,			_snake_case = DEFAULT_BLOCK_SIZE				):
							lowerCAmelCase =		[]
							for block_int in block_ints:
														lowerCAmelCase =		[]
														for i in range(block_size - 1    ,			-1    ,			-1				):
																					if len(_snake_case				) + i < message_length:
																												lowerCAmelCase =		block_int // (BYTE_SIZE**i)
																												lowerCAmelCase =		block_int % (BYTE_SIZE**i)
																												block_message.insert(0    ,			chr(_snake_case				)				)
														message.extend(_snake_case				)
							return "".join(_snake_case				)



def    UpperCAmelCase							(  _snake_case    ,			_snake_case    ,			_snake_case = DEFAULT_BLOCK_SIZE				):
							lowerCAmelCase =		[]
							lowerCAmelCase ,  lowerCAmelCase =		key

							for block in get_blocks_from_text(_snake_case    ,			_snake_case				):
														encrypted_blocks.append(pow(_snake_case    ,			_snake_case    ,			_snake_case				)				)
							return encrypted_blocks



def    UpperCAmelCase							(  _snake_case    ,			_snake_case    ,			_snake_case    ,			_snake_case = DEFAULT_BLOCK_SIZE    ,			):
							lowerCAmelCase =		[]
							lowerCAmelCase ,  lowerCAmelCase =		key
							for block in encrypted_blocks:
														decrypted_blocks.append(pow(_snake_case    ,			_snake_case    ,			_snake_case				)				)
							return get_text_from_blocks(_snake_case    ,			_snake_case    ,			_snake_case				)



def    UpperCAmelCase							(  _snake_case				):
							with open(_snake_case				) as fo:
														lowerCAmelCase =		fo.read()
							lowerCAmelCase ,  lowerCAmelCase ,  lowerCAmelCase =		content.split(''','''				)
							return (int(_snake_case				), int(_snake_case				), int(_snake_case				))



def    UpperCAmelCase							(  _snake_case    ,			_snake_case    ,			_snake_case    ,			_snake_case = DEFAULT_BLOCK_SIZE    ,			):
							lowerCAmelCase ,  lowerCAmelCase ,  lowerCAmelCase =		read_key_file(_snake_case				)
							if key_size < block_size * 8:
														sys.exit(
														    '''ERROR: Block size is {} bits and key size is {} bits. The RSA cipher '''
														    '''requires the block size to be equal to or greater than the key size. '''
														    '''Either decrease the block size or use different keys.'''.format(
														        block_size * 8    ,			_snake_case				)				)

							lowerCAmelCase =		[str(_snake_case				) for i in encrypt_message(_snake_case    ,			(n, e)    ,			_snake_case				)]

							lowerCAmelCase =		''','''.join(_snake_case				)
							lowerCAmelCase =		F"""{len(_snake_case				)}_{block_size}_{encrypted_content}"""
							with open(_snake_case    ,			'''w'''				) as fo:
														fo.write(_snake_case				)
							return encrypted_content



def    UpperCAmelCase							(  _snake_case    ,			_snake_case				):
							lowerCAmelCase ,  lowerCAmelCase ,  lowerCAmelCase =		read_key_file(_snake_case				)
							with open(_snake_case				) as fo:
														lowerCAmelCase =		fo.read()
							lowerCAmelCase ,  lowerCAmelCase ,  lowerCAmelCase =		content.split('''_'''				)
							lowerCAmelCase =		int(_snake_case				)
							lowerCAmelCase =		int(_snake_case				)

							if key_size < block_size * 8:
														sys.exit(
														    '''ERROR: Block size is {} bits and key size is {} bits. The RSA cipher '''
														    '''requires the block size to be equal to or greater than the key size. '''
														    '''Did you specify the correct key file and encrypted file?'''.format(
														        block_size * 8    ,			_snake_case				)				)

							lowerCAmelCase =		[]
							for block in encrypted_message.split(''','''				):
														encrypted_blocks.append(int(_snake_case				)				)

							return decrypt_message(_snake_case    ,			_snake_case    ,			(n, d)    ,			_snake_case				)



def    UpperCAmelCase							(  ):
							lowerCAmelCase =		'''encrypted_file.txt'''
							lowerCAmelCase =		input(R'''Encrypt\Decrypt [e\d]: '''				)

							if response.lower().startswith('''e'''				):
														lowerCAmelCase =		'''encrypt'''
							elif response.lower().startswith('''d'''				):
														lowerCAmelCase =		'''decrypt'''

							if mode == "encrypt":
														if not os.path.exists('''rsa_pubkey.txt'''				):
																					rkg.make_key_files('''rsa'''    ,			1024				)

														lowerCAmelCase =		input('''\nEnter message: '''				)
														lowerCAmelCase =		'''rsa_pubkey.txt'''
														print(F"""Encrypting and writing to {filename}..."""				)
														lowerCAmelCase =		encrypt_and_write_to_file(_snake_case    ,			_snake_case    ,			_snake_case				)

														print('''\nEncrypted text:'''				)
														print(_snake_case				)

							elif mode == "decrypt":
														lowerCAmelCase =		'''rsa_privkey.txt'''
														print(F"""Reading from {filename} and decrypting..."""				)
														lowerCAmelCase =		read_from_file_and_decrypt(_snake_case    ,			_snake_case				)
														print('''writing decryption to rsa_decryption.txt...'''				)
														with open('''rsa_decryption.txt'''    ,			'''w'''				) as dec:
																					dec.write(_snake_case				)

														print('''\nDecryption:'''				)
														print(_snake_case				)


if __name__ == "__main__":
		main()



