


'''simple docstring'''






import argparse
import struct
import unittest




class 	a__       :





							'''simple docstring'''






							def __init__(	self      ,					lowerCamelCase_     ) ->							None:
														lowerCAmelCase__      =			data

														# Initialize hash values
														lowerCAmelCase__      =			[
														    0X6A09E667,
														    0XBB67AE85,
														    0X3C6EF372,
														    0XA54FF53A,
														    0X510E527F,
														    0X9B05688C,
														    0X1F83D9AB,
														    0X5BE0CD19,
														]

														# Initialize round constants
														lowerCAmelCase__      =			[
														    0X428A2F98,
														    0X71374491,
														    0XB5C0FBCF,
														    0XE9B5DBA5,
														    0X3956C25B,
														    0X59F111F1,
														    0X923F82A4,
														    0XAB1C5ED5,
														    0XD807AA98,
														    0X12835B01,
														    0X243185BE,
														    0X550C7DC3,
														    0X72BE5D74,
														    0X80DEB1FE,
														    0X9BDC06A7,
														    0XC19BF174,
														    0XE49B69C1,
														    0XEFBE4786,
														    0X0FC19DC6,
														    0X240CA1CC,
														    0X2DE92C6F,
														    0X4A7484AA,
														    0X5CB0A9DC,
														    0X76F988DA,
														    0X983E5152,
														    0XA831C66D,
														    0XB00327C8,
														    0XBF597FC7,
														    0XC6E00BF3,
														    0XD5A79147,
														    0X06CA6351,
														    0X14292967,
														    0X27B70A85,
														    0X2E1B2138,
														    0X4D2C6DFC,
														    0X53380D13,
														    0X650A7354,
														    0X766A0ABB,
														    0X81C2C92E,
														    0X92722C85,
														    0XA2BFE8A1,
														    0XA81A664B,
														    0XC24B8B70,
														    0XC76C51A3,
														    0XD192E819,
														    0XD6990624,
														    0XF40E3585,
														    0X106AA070,
														    0X19A4C116,
														    0X1E376C08,
														    0X2748774C,
														    0X34B0BCB5,
														    0X391C0CB3,
														    0X4ED8AA4A,
														    0X5B9CCA4F,
														    0X682E6FF3,
														    0X748F82EE,
														    0X78A5636F,
														    0X84C87814,
														    0X8CC70208,
														    0X90BEFFFA,
														    0XA4506CEB,
														    0XBEF9A3F7,
														    0XC67178F2,
														]

														lowerCAmelCase__      =			self.preprocessing(self.data     )
														self.final_hash()







							@staticmethod
							def 						__SCREAMING_SNAKE_CASE							(	lowerCamelCase_     ) ->							bytes:
														lowerCAmelCase__      =			b'''\x80''' + (b'''\x00''' * (63 - (len(lowerCamelCase_     ) + 8) % 64))
														lowerCAmelCase__      =			struct.pack('''>Q'''      ,					(len(lowerCamelCase_     ) * 8)     )
														return data + padding + big_endian_integer







							def 						__SCREAMING_SNAKE_CASE							(	self     ) ->							None:
														# Convert into blocks of 64 bytes
														lowerCAmelCase__      =			[
														    self.preprocessed_data[x : x + 64]
														    for x in range(0      ,					len(self.preprocessed_data     )      ,					64     )
														]

														for block in self.blocks:
																					# Convert the given block into a list of 4 byte integers
																					lowerCAmelCase__      =			list(struct.unpack('''>16L'''      ,					lowerCamelCase_     )     )
																					# add 48 0-ed integers
																					words += [0] * 48

																					lowerCAmelCase__     ,      lowerCAmelCase__     ,      lowerCAmelCase__     ,      lowerCAmelCase__     ,      lowerCAmelCase__     ,      lowerCAmelCase__     ,      lowerCAmelCase__     ,      lowerCAmelCase__      =			self.hashes

																					for index in range(0      ,					64     ):
																												if index > 15:
																																			# modify the zero-ed indexes at the end of the array
																																			lowerCAmelCase__      =			(
																																			    self.ror(words[index - 15]      ,					7     )
																																			    ^ self.ror(words[index - 15]      ,					18     )
																																			    ^ (words[index - 15] >> 3)
																																			)
																																			lowerCAmelCase__      =			(
																																			    self.ror(words[index - 2]      ,					17     )
																																			    ^ self.ror(words[index - 2]      ,					19     )
																																			    ^ (words[index - 2] >> 10)
																																			)

																																			lowerCAmelCase__      =			(
																																			    words[index - 16] + sa + words[index - 7] + sa
																																			) % 0X100000000

																												# Compression
																												lowerCAmelCase__      =			self.ror(lowerCamelCase_      ,					6     ) ^ self.ror(lowerCamelCase_      ,					11     ) ^ self.ror(lowerCamelCase_      ,					25     )
																												lowerCAmelCase__      =			(e & f) ^ ((~e & 0XFFFFFFFF) & g)
																												lowerCAmelCase__      =			(
																												    h + sa + ch + self.round_constants[index] + words[index]
																												) % 0X100000000
																												lowerCAmelCase__      =			self.ror(lowerCamelCase_      ,					2     ) ^ self.ror(lowerCamelCase_      ,					13     ) ^ self.ror(lowerCamelCase_      ,					22     )
																												lowerCAmelCase__      =			(a & b) ^ (a & c) ^ (b & c)
																												lowerCAmelCase__      =			(sa + maj) % 0X100000000

																												lowerCAmelCase__     ,      lowerCAmelCase__     ,      lowerCAmelCase__     ,      lowerCAmelCase__     ,      lowerCAmelCase__     ,      lowerCAmelCase__     ,      lowerCAmelCase__     ,      lowerCAmelCase__      =			(
																												    g,
																												    f,
																												    e,
																												    ((d + tempa) % 0X100000000),
																												    c,
																												    b,
																												    a,
																												    ((tempa + tempa) % 0X100000000),
																												)

																					lowerCAmelCase__      =			[a, b, c, d, e, f, g, h]

																					# Modify final values
																					lowerCAmelCase__      =			[
																					    ((element + mutated_hash_values[index]) % 0X100000000)
																					    for index, element in enumerate(self.hashes     )
																					]

														lowerCAmelCase__      =			''''''.join([hex(lowerCamelCase_     )[2:].zfill(8     ) for value in self.hashes]     )







							def 						__SCREAMING_SNAKE_CASE							(	self      ,					lowerCamelCase_      ,					lowerCamelCase_     ) ->							int:
														return 0XFFFFFFFF & (value << (32 - rotations)) | (value >> rotations)




class 	a__       (							unittest.TestCase						):





							'''simple docstring'''






							def 						__SCREAMING_SNAKE_CASE							(	self     ) ->							None:
														import hashlib

														lowerCAmelCase__      =			bytes('''Test String'''      ,					'''utf-8'''     )
														self.assertEqual(SHAaaa(lowerCamelCase_     ).hash      ,					hashlib.shaaaa(lowerCamelCase_     ).hexdigest()     )


def       _snake_case     (  )		->					None:
							import doctest

							doctest.testmod()

							lowerCAmelCase__      =			argparse.ArgumentParser()
							parser.add_argument(
							    '''-s'''				,					'''--string'''				,					dest='''input_string'''				,					default='''Hello World!! Welcome to Cryptography'''				,					help='''Hash the string'''				,					)
							parser.add_argument(
							    '''-f'''				,					'''--file'''				,					dest='''input_file'''				,					help='''Hash contents of a file''' )

							lowerCAmelCase__      =			parser.parse_args()

							lowerCAmelCase__      =			args.input_string

							# hash input should be a bytestring
							if args.input_file:
														with open(args.input_file				,					'''rb''' ) as f:
																					lowerCAmelCase__      =			f.read()
							else:
														lowerCAmelCase__      =			bytes(A				,					'''utf-8''' )

							print(SHAaaa(A ).hash )


if __name__ == "__main__":
		main()



'''simple docstring'''






import inspect
from typing import Callable, List, Optional, Union

import torch
from transformers import CLIPImageProcessor, CLIPTextModel, CLIPTokenizer

from diffusers import DiffusionPipeline
from diffusers.models import AutoencoderKL, UNetaDConditionModel
from diffusers.pipelines.stable_diffusion import StableDiffusionPipelineOutput
from diffusers.pipelines.stable_diffusion.safety_checker import StableDiffusionSafetyChecker
from diffusers.schedulers import DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler
from diffusers.utils import logging


__UpperCAmelCase					       =							logging.get_logger(__name__)  # pylint: disable=invalid-name




class 	a__       (							a__						):





							'''simple docstring'''






							def __init__(	self      ,					lowerCamelCase_      ,					lowerCamelCase_      ,					lowerCamelCase_      ,					lowerCamelCase_      ,					lowerCamelCase_      ,					lowerCamelCase_      ,					lowerCamelCase_      ,					) ->							Optional[Any]:
														super().__init__()
														self.register_modules(
														    vae=lowerCamelCase_      ,					text_encoder=lowerCamelCase_      ,					tokenizer=lowerCamelCase_      ,					unet=lowerCamelCase_      ,					scheduler=lowerCamelCase_      ,					safety_checker=lowerCamelCase_      ,					feature_extractor=lowerCamelCase_      ,					)







							def 						__SCREAMING_SNAKE_CASE							(	self      ,					lowerCamelCase_ = "auto"     ) ->							Any:
														if slice_size == "auto":
																					# half the attention head size is usually a good trade-off between
																					# speed and memory
																					lowerCAmelCase__      =			self.unet.config.attention_head_dim // 2
														self.unet.set_attention_slice(lowerCamelCase_     )







							def 						__SCREAMING_SNAKE_CASE							(	self     ) ->							Optional[Any]:
														self.enable_attention_slicing(lowerCamelCase_     )







							@torch.no_grad()
							def __call__(	self      ,					lowerCamelCase_      ,					lowerCamelCase_ = 5_12      ,					lowerCamelCase_ = 5_12      ,					lowerCamelCase_ = 50      ,					lowerCamelCase_ = 7.5      ,					lowerCamelCase_ = None      ,					lowerCamelCase_ = 1      ,					lowerCamelCase_ = 0.0      ,					lowerCamelCase_ = None      ,					lowerCamelCase_ = None      ,					lowerCamelCase_ = "pil"      ,					lowerCamelCase_ = True      ,					lowerCamelCase_ = None      ,					lowerCamelCase_ = 1      ,					lowerCamelCase_ = None      ,					**lowerCamelCase_      ,					) ->							Any:

														if isinstance(lowerCamelCase_      ,					lowerCamelCase_     ):
																					lowerCAmelCase__      =			1
														elif isinstance(lowerCamelCase_      ,					lowerCamelCase_     ):
																					lowerCAmelCase__      =			len(lowerCamelCase_     )
														else:
																					raise ValueError(F"""`prompt` has to be of type `str` or `list` but is {type(lowerCamelCase_     )}"""     )

														if height % 8 != 0 or width % 8 != 0:
																					raise ValueError(F"""`height` and `width` have to be divisible by 8 but are {height} and {width}."""     )

														if (callback_steps is None) or (
														    callback_steps is not None and (not isinstance(lowerCamelCase_      ,					lowerCamelCase_     ) or callback_steps <= 0)
														):
																					raise ValueError(
																					    F"""`callback_steps` has to be a positive integer but is {callback_steps} of type"""
																					    F""" {type(lowerCamelCase_     )}."""     )

														# get prompt text embeddings
														lowerCAmelCase__      =			self.tokenizer(
														    lowerCamelCase_      ,					padding='''max_length'''      ,					max_length=self.tokenizer.model_max_length      ,					return_tensors='''pt'''      ,					)
														lowerCAmelCase__      =			text_inputs.input_ids

														if text_input_ids.shape[-1] > self.tokenizer.model_max_length:
																					lowerCAmelCase__      =			self.tokenizer.batch_decode(text_input_ids[:, self.tokenizer.model_max_length :]     )
																					logger.warning(
																					    '''The following part of your input was truncated because CLIP can only handle sequences up to'''
																					    F""" {self.tokenizer.model_max_length} tokens: {removed_text}"""     )
																					lowerCAmelCase__      =			text_input_ids[:, : self.tokenizer.model_max_length]

														if text_embeddings is None:
																					lowerCAmelCase__      =			self.text_encoder(text_input_ids.to(self.device     )     )[0]

														# duplicate text embeddings for each generation per prompt, using mps friendly method
														lowerCAmelCase__     ,      lowerCAmelCase__     ,      lowerCAmelCase__      =			text_embeddings.shape
														lowerCAmelCase__      =			text_embeddings.repeat(1      ,					lowerCamelCase_      ,					1     )
														lowerCAmelCase__      =			text_embeddings.view(bs_embed * num_images_per_prompt      ,					lowerCamelCase_      ,					-1     )

														# here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)
														# of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`
														# corresponds to doing no classifier free guidance.
														lowerCAmelCase__      =			guidance_scale > 1.0
														# get unconditional embeddings for classifier free guidance
														if do_classifier_free_guidance:
																					lowerCAmelCase__      =			42
																					if negative_prompt is None:
																												lowerCAmelCase__      =			['''''']
																					elif type(lowerCamelCase_     ) is not type(lowerCamelCase_     ):
																												raise TypeError(
																												    F"""`negative_prompt` should be the same type to `prompt`, but got {type(lowerCamelCase_     )} !="""
																												    F""" {type(lowerCamelCase_     )}."""     )
																					elif isinstance(lowerCamelCase_      ,					lowerCamelCase_     ):
																												lowerCAmelCase__      =			[negative_prompt]
																					elif batch_size != len(lowerCamelCase_     ):
																												raise ValueError(
																												    F"""`negative_prompt`: {negative_prompt} has batch size {len(lowerCamelCase_     )}, but `prompt`:"""
																												    F""" {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches"""
																												    ''' the batch size of `prompt`.'''     )
																					else:
																												lowerCAmelCase__      =			negative_prompt

																					lowerCAmelCase__      =			text_input_ids.shape[-1]
																					lowerCAmelCase__      =			self.tokenizer(
																					    lowerCamelCase_      ,					padding='''max_length'''      ,					max_length=lowerCamelCase_      ,					truncation=lowerCamelCase_      ,					return_tensors='''pt'''      ,					)
																					lowerCAmelCase__      =			self.text_encoder(uncond_input.input_ids.to(self.device     )     )[0]

																					# duplicate unconditional embeddings for each generation per prompt, using mps friendly method
																					lowerCAmelCase__      =			uncond_embeddings.shape[1]
																					lowerCAmelCase__      =			uncond_embeddings.repeat(lowerCamelCase_      ,					lowerCamelCase_      ,					1     )
																					lowerCAmelCase__      =			uncond_embeddings.view(batch_size * num_images_per_prompt      ,					lowerCamelCase_      ,					-1     )

																					# For classifier free guidance, we need to do two forward passes.
																					# Here we concatenate the unconditional and text embeddings into a single batch
																					# to avoid doing two forward passes
																					lowerCAmelCase__      =			torch.cat([uncond_embeddings, text_embeddings]     )

														# get the initial random noise unless the user supplied it

														# Unlike in other pipelines, latents need to be generated in the target device
														# for 1-to-1 results reproducibility with the CompVis implementation.
														# However this currently doesn't work in `mps`.
														lowerCAmelCase__      =			(batch_size * num_images_per_prompt, self.unet.config.in_channels, height // 8, width // 8)
														lowerCAmelCase__      =			(batch_size * num_images_per_prompt, self.unet.config.in_channels, 64, 64)
														lowerCAmelCase__      =			text_embeddings.dtype
														if latents is None:
																					if self.device.type == "mps":
																												# randn does not exist on mps
																												lowerCAmelCase__      =			torch.randn(
																												    lowerCamelCase_      ,					generator=lowerCamelCase_      ,					device='''cpu'''      ,					dtype=lowerCamelCase_     ).to(self.device     )
																												lowerCAmelCase__      =			torch.randn(lowerCamelCase_      ,					generator=lowerCamelCase_      ,					device='''cpu'''      ,					dtype=lowerCamelCase_     ).to(
																												    self.device     )
																					else:
																												lowerCAmelCase__      =			torch.randn(
																												    lowerCamelCase_      ,					generator=lowerCamelCase_      ,					device=self.device      ,					dtype=lowerCamelCase_     )
																												lowerCAmelCase__      =			torch.randn(lowerCamelCase_      ,					generator=lowerCamelCase_      ,					device=self.device      ,					dtype=lowerCamelCase_     )
														else:
																					if latents_reference.shape != latents_shape:
																												raise ValueError(F"""Unexpected latents shape, got {latents.shape}, expected {latents_shape}"""     )
																					lowerCAmelCase__      =			latents_reference.to(self.device     )
																					lowerCAmelCase__      =			latents.to(self.device     )

														# This is the key part of the pipeline where we
														# try to ensure that the generated images w/ the same seed
														# but different sizes actually result in similar images
														lowerCAmelCase__      =			(latents_shape[3] - latents_shape_reference[3]) // 2
														lowerCAmelCase__      =			(latents_shape[2] - latents_shape_reference[2]) // 2
														lowerCAmelCase__      =			latents_shape_reference[3] if dx >= 0 else latents_shape_reference[3] + 2 * dx
														lowerCAmelCase__      =			latents_shape_reference[2] if dy >= 0 else latents_shape_reference[2] + 2 * dy
														lowerCAmelCase__      =			0 if dx < 0 else dx
														lowerCAmelCase__      =			0 if dy < 0 else dy
														lowerCAmelCase__      =			max(-dx      ,					0     )
														lowerCAmelCase__      =			max(-dy      ,					0     )
														# import pdb
														# pdb.set_trace()
														lowerCAmelCase__      =			latents_reference[:, :, dy : dy + h, dx : dx + w]

														# set timesteps
														self.scheduler.set_timesteps(lowerCamelCase_     )

														# Some schedulers like PNDM have timesteps as arrays
														# It's more optimized to move all timesteps to correct device beforehand
														lowerCAmelCase__      =			self.scheduler.timesteps.to(self.device     )

														# scale the initial noise by the standard deviation required by the scheduler
														lowerCAmelCase__      =			latents * self.scheduler.init_noise_sigma

														# prepare extra kwargs for the scheduler step, since not all schedulers have the same signature
														# eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers.
														# eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502
														# and should be between [0, 1]
														lowerCAmelCase__      =			'''eta''' in set(inspect.signature(self.scheduler.step     ).parameters.keys()     )
														lowerCAmelCase__      =			{}
														if accepts_eta:
																					lowerCAmelCase__      =			eta

														for i, t in enumerate(self.progress_bar(lowerCamelCase_     )     ):
																					# expand the latents if we are doing classifier free guidance
																					lowerCAmelCase__      =			torch.cat([latents] * 2     ) if do_classifier_free_guidance else latents
																					lowerCAmelCase__      =			self.scheduler.scale_model_input(lowerCamelCase_      ,					lowerCamelCase_     )

																					# predict the noise residual
																					lowerCAmelCase__      =			self.unet(lowerCamelCase_      ,					lowerCamelCase_      ,					encoder_hidden_states=lowerCamelCase_     ).sample

																					# perform guidance
																					if do_classifier_free_guidance:
																												lowerCAmelCase__     ,      lowerCAmelCase__      =			noise_pred.chunk(2     )
																												lowerCAmelCase__      =			noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)

																					# compute the previous noisy sample x_t -> x_t-1
																					lowerCAmelCase__      =			self.scheduler.step(lowerCamelCase_      ,					lowerCamelCase_      ,					lowerCamelCase_      ,					**lowerCamelCase_     ).prev_sample

																					# call the callback, if provided
																					if callback is not None and i % callback_steps == 0:
																												callback(lowerCamelCase_      ,					lowerCamelCase_      ,					lowerCamelCase_     )

														lowerCAmelCase__      =			1 / 0.18_215 * latents
														lowerCAmelCase__      =			self.vae.decode(lowerCamelCase_     ).sample

														lowerCAmelCase__      =			(image / 2 + 0.5).clamp(0      ,					1     )

														# we always cast to float32 as this does not cause significant overhead and is compatible with bfloat16
														lowerCAmelCase__      =			image.cpu().permute(0      ,					2      ,					3      ,					1     ).float().numpy()

														if self.safety_checker is not None:
																					lowerCAmelCase__      =			self.feature_extractor(self.numpy_to_pil(lowerCamelCase_     )      ,					return_tensors='''pt'''     ).to(
																					    self.device     )
																					lowerCAmelCase__     ,      lowerCAmelCase__      =			self.safety_checker(
																					    images=lowerCamelCase_      ,					clip_input=safety_checker_input.pixel_values.to(text_embeddings.dtype     )     )
														else:
																					lowerCAmelCase__      =			None

														if output_type == "pil":
																					lowerCAmelCase__      =			self.numpy_to_pil(lowerCamelCase_     )

														if not return_dict:
																					return (image, has_nsfw_concept)

														return StableDiffusionPipelineOutput(images=lowerCamelCase_      ,					nsfw_content_detected=lowerCamelCase_     )