




import argparse
import struct
import unittest







class a :
						"""simple docstring"""

						def __init__( self :     str				,							lowerCamelCase__ :     bytes				)    ->						None:
													"""simple docstring"""


													__lowercase      =    data

													# Initialize hash values
													__lowercase      =    [
													    0x6_a_0_9_e_6_6_7,
													    0xb_b_6_7_a_e_8_5,
													    0x3_c_6_e_f_3_7_2,
													    0xa_5_4_f_f_5_3_a,
													    0x5_1_0_e_5_2_7_f,
													    0x9_b_0_5_6_8_8_c,
													    0x1_f_8_3_d_9_a_b,
													    0x5_b_e_0_c_d_1_9,
													]

													# Initialize round constants
													__lowercase      =    [
													    0x4_2_8_a_2_f_9_8,
													    0x7_1_3_7_4_4_9_1,
													    0xb_5_c_0_f_b_c_f,
													    0xe_9_b_5_d_b_a_5,
													    0x3_9_5_6_c_2_5_b,
													    0x5_9_f_1_1_1_f_1,
													    0x9_2_3_f_8_2_a_4,
													    0xa_b_1_c_5_e_d_5,
													    0xd_8_0_7_a_a_9_8,
													    0x1_2_8_3_5_b_0_1,
													    0x2_4_3_1_8_5_b_e,
													    0x5_5_0_c_7_d_c_3,
													    0x7_2_b_e_5_d_7_4,
													    0x8_0_d_e_b_1_f_e,
													    0x9_b_d_c_0_6_a_7,
													    0xc_1_9_b_f_1_7_4,
													    0xe_4_9_b_6_9_c_1,
													    0xe_f_b_e_4_7_8_6,
													    0x0_f_c_1_9_d_c_6,
													    0x2_4_0_c_a_1_c_c,
													    0x2_d_e_9_2_c_6_f,
													    0x4_a_7_4_8_4_a_a,
													    0x5_c_b_0_a_9_d_c,
													    0x7_6_f_9_8_8_d_a,
													    0x9_8_3_e_5_1_5_2,
													    0xa_8_3_1_c_6_6_d,
													    0xb_0_0_3_2_7_c_8,
													    0xb_f_5_9_7_f_c_7,
													    0xc_6_e_0_0_b_f_3,
													    0xd_5_a_7_9_1_4_7,
													    0x0_6_c_a_6_3_5_1,
													    0x1_4_2_9_2_9_6_7,
													    0x2_7_b_7_0_a_8_5,
													    0x2_e_1_b_2_1_3_8,
													    0x4_d_2_c_6_d_f_c,
													    0x5_3_3_8_0_d_1_3,
													    0x6_5_0_a_7_3_5_4,
													    0x7_6_6_a_0_a_b_b,
													    0x8_1_c_2_c_9_2_e,
													    0x9_2_7_2_2_c_8_5,
													    0xa_2_b_f_e_8_a_1,
													    0xa_8_1_a_6_6_4_b,
													    0xc_2_4_b_8_b_7_0,
													    0xc_7_6_c_5_1_a_3,
													    0xd_1_9_2_e_8_1_9,
													    0xd_6_9_9_0_6_2_4,
													    0xf_4_0_e_3_5_8_5,
													    0x1_0_6_a_a_0_7_0,
													    0x1_9_a_4_c_1_1_6,
													    0x1_e_3_7_6_c_0_8,
													    0x2_7_4_8_7_7_4_c,
													    0x3_4_b_0_b_c_b_5,
													    0x3_9_1_c_0_c_b_3,
													    0x4_e_d_8_a_a_4_a,
													    0x5_b_9_c_c_a_4_f,
													    0x6_8_2_e_6_f_f_3,
													    0x7_4_8_f_8_2_e_e,
													    0x7_8_a_5_6_3_6_f,
													    0x8_4_c_8_7_8_1_4,
													    0x8_c_c_7_0_2_0_8,
													    0x9_0_b_e_f_f_f_a,
													    0xa_4_5_0_6_c_e_b,
													    0xb_e_f_9_a_3_f_7,
													    0xc_6_7_1_7_8_f_2,
													]

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






						@staticmethod
						def     UpperCAmelCase_      ( lowerCamelCase__ :     bytes				)    ->						bytes:
													"""simple docstring"""


													__lowercase      =    b'''\x80''' + (b'''\x00''' * (63 - (len(lowerCamelCase__				) + 8) % 64))
													__lowercase      =    struct.pack('''>Q'''				,							(len(lowerCamelCase__				) * 8)				)
													return data + padding + big_endian_integer






						def     UpperCAmelCase_      ( self :     Dict				)    ->						None:
													"""simple docstring"""


													__lowercase      =    [
													    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
																				__lowercase      =    list(struct.unpack('''>16L'''				,							lowerCamelCase__				)				)
																				# add 48 0-ed integers
																				words += [0] * 48

																				__lowercase     ,     __lowercase     ,     __lowercase     ,     __lowercase     ,     __lowercase     ,     __lowercase     ,     __lowercase     ,     __lowercase      =    self.hashes

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

																																		__lowercase      =    (
																																		    words[index - 16] + sa + words[index - 7] + sa
																																		) % 0x1_0_0_0_0_0_0_0_0

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

																											__lowercase     ,     __lowercase     ,     __lowercase     ,     __lowercase     ,     __lowercase     ,     __lowercase     ,     __lowercase     ,     __lowercase      =    (
																											    g,
																											    f,
																											    e,
																											    ((d + tempa) % 0x1_0_0_0_0_0_0_0_0),
																											    c,
																											    b,
																											    a,
																											    ((tempa + tempa) % 0x1_0_0_0_0_0_0_0_0),
																											)

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

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

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






						def     UpperCAmelCase_      ( self :     Optional[Any]				,							lowerCamelCase__ :     int				,							lowerCamelCase__ :     int				)    ->						int:
													"""simple docstring"""


													return 0xf_f_f_f_f_f_f_f & (value << (32 - rotations)) | (value >> rotations)







class a (     unittest.TestCase  ):
						"""simple docstring"""

						def     UpperCAmelCase_      ( self :     str				)    ->						None:
													"""simple docstring"""


													import hashlib

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







def 		_A(       )    -> None:
							'''simple docstring'''


							import doctest

							doctest.testmod()

							__lowercase      =    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'''				)

							__lowercase      =    parser.parse_args()

							__lowercase      =    args.input_string

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

							print(SHAaaa(UpperCamelCase__				).hash				)


if __name__ == "__main__":
			main()












import gc
import random
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import AutoencoderKL, CycleDiffusionPipeline, DDIMScheduler, UNetaDConditionModel
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu, skip_mps

from ..pipeline_params import (
    IMAGE_TO_IMAGE_IMAGE_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_PARAMS,
)
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()







class a (     __SCREAMING_SNAKE_CASE       ,						__SCREAMING_SNAKE_CASE       ,						unittest.TestCase  ):
						"""simple docstring"""

						UpperCamelCase_	:       Any       	=		CycleDiffusionPipeline
						UpperCamelCase_	:       List[str]       	=		TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {
						    'negative_prompt',
						    'height',
						    'width',
						    'negative_prompt_embeds',
						}
						UpperCamelCase_	:       int       	=		PipelineTesterMixin.required_optional_params - {'latents'}
						UpperCamelCase_	:       Dict       	=		TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({'source_prompt'}  )
						UpperCamelCase_	:       Dict       	=		IMAGE_TO_IMAGE_IMAGE_PARAMS
						UpperCamelCase_	:       Optional[Any]       	=		IMAGE_TO_IMAGE_IMAGE_PARAMS






						def     UpperCAmelCase_      ( self :     int				)    ->						Dict:
													"""simple docstring"""


													torch.manual_seed(0				)
													__lowercase      =    UNetaDConditionModel(
													    block_out_channels=(32, 64)				,							layers_per_block=2				,							sample_size=32				,							in_channels=4				,							out_channels=4				,							down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')				,							up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')				,							cross_attention_dim=32				,							)
													__lowercase      =    DDIMScheduler(
													    beta_start=0.0_0_0_8_5				,							beta_end=0.0_1_2				,							beta_schedule='''scaled_linear'''				,							num_train_timesteps=1_000				,							clip_sample=lowerCamelCase__				,							set_alpha_to_one=lowerCamelCase__				,							)
													torch.manual_seed(0				)
													__lowercase      =    AutoencoderKL(
													    block_out_channels=[32, 64]				,							in_channels=3				,							out_channels=3				,							down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''']				,							up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''']				,							latent_channels=4				,							)
													torch.manual_seed(0				)
													__lowercase      =    CLIPTextConfig(
													    bos_token_id=0				,							eos_token_id=2				,							hidden_size=32				,							intermediate_size=37				,							layer_norm_eps=1e-0_5				,							num_attention_heads=4				,							num_hidden_layers=5				,							pad_token_id=1				,							vocab_size=1_000				,							)
													__lowercase      =    CLIPTextModel(lowerCamelCase__				)
													__lowercase      =    CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''				)

													__lowercase      =    {
													    '''unet''': unet,
													    '''scheduler''': scheduler,
													    '''vae''': vae,
													    '''text_encoder''': text_encoder,
													    '''tokenizer''': tokenizer,
													    '''safety_checker''': None,
													    '''feature_extractor''': None,
													}
													return components






						def     UpperCAmelCase_      ( self :     Any				,							lowerCamelCase__ :     int				,							lowerCamelCase__ :     List[str]=0				)    ->						Any:
													"""simple docstring"""


													__lowercase      =    floats_tensor((1, 3, 32, 32)				,							rng=random.Random(lowerCamelCase__				)				).to(lowerCamelCase__				)
													__lowercase      =    image / 2 + 0.5
													if str(lowerCamelCase__				).startswith('''mps'''				):
																				__lowercase      =    torch.manual_seed(lowerCamelCase__				)
													else:
																				__lowercase      =    torch.Generator(device=lowerCamelCase__				).manual_seed(lowerCamelCase__				)
													__lowercase      =    {
													    '''prompt''': '''An astronaut riding an elephant''',
													    '''source_prompt''': '''An astronaut riding a horse''',
													    '''image''': image,
													    '''generator''': generator,
													    '''num_inference_steps''': 2,
													    '''eta''': 0.1,
													    '''strength''': 0.8,
													    '''guidance_scale''': 3,
													    '''source_guidance_scale''': 1,
													    '''output_type''': '''numpy''',
													}
													return inputs






						def     UpperCAmelCase_      ( self :     List[Any]				)    ->						Optional[Any]:
													"""simple docstring"""


													__lowercase      =    '''cpu'''  # ensure determinism for the device-dependent torch.Generator

													__lowercase      =    self.get_dummy_components()
													__lowercase      =    CycleDiffusionPipeline(**lowerCamelCase__				)
													__lowercase      =    pipe.to(lowerCamelCase__				)
													pipe.set_progress_bar_config(disable=lowerCamelCase__				)

													__lowercase      =    self.get_dummy_inputs(lowerCamelCase__				)
													__lowercase      =    pipe(**lowerCamelCase__				)
													__lowercase      =    output.images

													__lowercase      =    images[0, -3:, -3:, -1]

													assert images.shape == (1, 32, 32, 3)
													__lowercase      =    np.array([0.4_4_5_9, 0.4_9_4_3, 0.4_5_4_4, 0.6_6_4_3, 0.5_4_7_4, 0.4_3_2_7, 0.5_7_0_1, 0.5_9_5_9, 0.5_1_7_9]				)

													assert np.abs(image_slice.flatten() - expected_slice				).max() < 1e-2






						@unittest.skipIf(torch_device != '''cuda'''				,							'''This test requires a GPU'''				)
						def     UpperCAmelCase_      ( self :     str				)    ->						Optional[Any]:
													"""simple docstring"""


													__lowercase      =    self.get_dummy_components()
													for name, module in components.items():
																				if hasattr(lowerCamelCase__				,							'''half'''				):
																											__lowercase      =    module.half()
													__lowercase      =    CycleDiffusionPipeline(**lowerCamelCase__				)
													__lowercase      =    pipe.to(lowerCamelCase__				)
													pipe.set_progress_bar_config(disable=lowerCamelCase__				)

													__lowercase      =    self.get_dummy_inputs(lowerCamelCase__				)
													__lowercase      =    pipe(**lowerCamelCase__				)
													__lowercase      =    output.images

													__lowercase      =    images[0, -3:, -3:, -1]

													assert images.shape == (1, 32, 32, 3)
													__lowercase      =    np.array([0.3_5_0_6, 0.4_5_4_3, 0.4_4_6, 0.4_5_7_5, 0.5_1_9_5, 0.4_1_5_5, 0.5_2_7_3, 0.5_1_8, 0.4_1_1_6]				)

													assert np.abs(image_slice.flatten() - expected_slice				).max() < 1e-2






						@skip_mps
						def     UpperCAmelCase_      ( self :     str				)    ->						int:
													"""simple docstring"""


													return super().test_save_load_local()






						@unittest.skip('''non-deterministic pipeline'''				)
						def     UpperCAmelCase_      ( self :     int				)    ->						Union[str, Any]:
													"""simple docstring"""


													return super().test_inference_batch_single_identical()






						@skip_mps
						def     UpperCAmelCase_      ( self :     int				)    ->						Optional[int]:
													"""simple docstring"""


													return super().test_dict_tuple_outputs_equivalent()






						@skip_mps
						def     UpperCAmelCase_      ( self :     List[Any]				)    ->						List[str]:
													"""simple docstring"""


													return super().test_save_load_optional_components()






						@skip_mps
						def     UpperCAmelCase_      ( self :     Union[str, Any]				)    ->						Tuple:
													"""simple docstring"""


													return super().test_attention_slicing_forward_pass()







@slow
@require_torch_gpu
class a (     unittest.TestCase  ):
						"""simple docstring"""

						def     UpperCAmelCase_      ( self :     Optional[Any]				)    ->						Union[str, Any]:
													"""simple docstring"""


													super().tearDown()
													gc.collect()
													torch.cuda.empty_cache()






						def     UpperCAmelCase_      ( self :     Optional[int]				)    ->						List[str]:
													"""simple docstring"""


													__lowercase      =    load_image(
													    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
													    '''/cycle-diffusion/black_colored_car.png'''				)
													__lowercase      =    load_numpy(
													    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/cycle-diffusion/blue_colored_car_fp16.npy'''				)
													__lowercase      =    init_image.resize((512, 512)				)

													__lowercase      =    '''CompVis/stable-diffusion-v1-4'''
													__lowercase      =    DDIMScheduler.from_pretrained(lowerCamelCase__				,							subfolder='''scheduler'''				)
													__lowercase      =    CycleDiffusionPipeline.from_pretrained(
													    lowerCamelCase__				,							scheduler=lowerCamelCase__				,							safety_checker=lowerCamelCase__				,							torch_dtype=torch.floataa				,							revision='''fp16'''				)

													pipe.to(lowerCamelCase__				)
													pipe.set_progress_bar_config(disable=lowerCamelCase__				)
													pipe.enable_attention_slicing()

													__lowercase      =    '''A black colored car'''
													__lowercase      =    '''A blue colored car'''

													__lowercase      =    torch.manual_seed(0				)
													__lowercase      =    pipe(
													    prompt=lowerCamelCase__				,							source_prompt=lowerCamelCase__				,							image=lowerCamelCase__				,							num_inference_steps=100				,							eta=0.1				,							strength=0.8_5				,							guidance_scale=3				,							source_guidance_scale=1				,							generator=lowerCamelCase__				,							output_type='''np'''				,							)
													__lowercase      =    output.images

													# the values aren't exactly equal, but the images look the same visually
													assert np.abs(image - expected_image				).max() < 5e-1






						def     UpperCAmelCase_      ( self :     Tuple				)    ->						List[str]:
													"""simple docstring"""


													__lowercase      =    load_image(
													    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
													    '''/cycle-diffusion/black_colored_car.png'''				)
													__lowercase      =    load_numpy(
													    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/cycle-diffusion/blue_colored_car.npy'''				)
													__lowercase      =    init_image.resize((512, 512)				)

													__lowercase      =    '''CompVis/stable-diffusion-v1-4'''
													__lowercase      =    DDIMScheduler.from_pretrained(lowerCamelCase__				,							subfolder='''scheduler'''				)
													__lowercase      =    CycleDiffusionPipeline.from_pretrained(lowerCamelCase__				,							scheduler=lowerCamelCase__				,							safety_checker=lowerCamelCase__				)

													pipe.to(lowerCamelCase__				)
													pipe.set_progress_bar_config(disable=lowerCamelCase__				)
													pipe.enable_attention_slicing()

													__lowercase      =    '''A black colored car'''
													__lowercase      =    '''A blue colored car'''

													__lowercase      =    torch.manual_seed(0				)
													__lowercase      =    pipe(
													    prompt=lowerCamelCase__				,							source_prompt=lowerCamelCase__				,							image=lowerCamelCase__				,							num_inference_steps=100				,							eta=0.1				,							strength=0.8_5				,							guidance_scale=3				,							source_guidance_scale=1				,							generator=lowerCamelCase__				,							output_type='''np'''				,							)
													__lowercase      =    output.images

													assert np.abs(image - expected_image				).max() < 2e-2






