






from collections.abc import Generator
from math import sin


def __A    (      __lowerCAmelCase	)->  bytes:





						"""simple docstring"""



						if len(__lowerCAmelCase	) != 32:
												raise ValueError('Input must be of length 32'	)

						_UpperCAmelCase									=			b''
						for i in [3, 2, 1, 0]:
												little_endian += string_aa[8 * i : 8 * i + 8]
						return little_endian


def __A    (      __lowerCAmelCase	)->  bytes:





						"""simple docstring"""



						if i < 0:
												raise ValueError('Input must be non-negative'	)

						_UpperCAmelCase									=			format(__lowerCAmelCase ,		'08x'	)[-8:]
						_UpperCAmelCase									=			b''
						for i in [3, 2, 1, 0]:
												little_endian_hex += hex_rep[2 * i : 2 * i + 2].encode('utf-8'	)
						return little_endian_hex


def __A    (      __lowerCAmelCase	)->  bytes:





						"""simple docstring"""



						_UpperCAmelCase									=			b''
						for char in message:
												bit_string += format(__lowerCAmelCase ,		'08b'	).encode('utf-8'	)
						_UpperCAmelCase									=			format(len(__lowerCAmelCase	) ,		'064b'	).encode('utf-8'	)

						# Pad bit_string to a multiple of 512 chars
						bit_string += b"1"
						while len(__lowerCAmelCase	) % 512 != 448:
												bit_string += b"0"
						bit_string += to_little_endian(start_len[32:]	) + to_little_endian(start_len[:32]	)

						return bit_string


def __A    (      __lowerCAmelCase	)->  Generator[list[int], None, None]:





						"""simple docstring"""



						if len(__lowerCAmelCase	) % 512 != 0:
												raise ValueError('Input must have length that\'s a multiple of 512'	)

						for pos in range(0 ,		len(__lowerCAmelCase	) ,		512	):
												_UpperCAmelCase									=			bit_string[pos : pos + 512]
												_UpperCAmelCase									=			[]
												for i in range(0 ,		512 ,		32	):
																		block_words.append(int(to_little_endian(block[i : i + 32]	) ,		2	)	)
												yield block_words


def __A    (      __lowerCAmelCase	)->  int:





						"""simple docstring"""



						if i < 0:
												raise ValueError('Input must be non-negative'	)

						_UpperCAmelCase									=			format(__lowerCAmelCase ,		'032b'	)
						_UpperCAmelCase									=			''
						for c in i_str:
												new_str += "1" if c == "0" else "0"
						return int(__lowerCAmelCase ,		2	)


def __A    (      __lowerCAmelCase ,		__lowerCAmelCase	)->  int:





						"""simple docstring"""



						return (a + b) % 2**32


def __A    (      __lowerCAmelCase ,		__lowerCAmelCase	)->  int:





						"""simple docstring"""



						if i < 0:
												raise ValueError('Input must be non-negative'	)
						if shift < 0:
												raise ValueError('Shift must be non-negative'	)
						return ((i << shift) ^ (i >> (32 - shift))) % 2**32


def __A    (      __lowerCAmelCase	)->  bytes:





						"""simple docstring"""



						_UpperCAmelCase									=			preprocess(__lowerCAmelCase	)

						_UpperCAmelCase									=			[int(2**32 * abs(sin(i + 1	)	)	) for i in range(64	)]

						# Starting states
						_UpperCAmelCase									=			0X6_7_4_5_2_3_0_1
						_UpperCAmelCase									=			0XE_F_C_D_A_B_8_9
						_UpperCAmelCase									=			0X9_8_B_A_D_C_F_E
						_UpperCAmelCase									=			0X1_0_3_2_5_4_7_6

						_UpperCAmelCase									=			[
						    7,
						    12,
						    17,
						    22,
						    7,
						    12,
						    17,
						    22,
						    7,
						    12,
						    17,
						    22,
						    7,
						    12,
						    17,
						    22,
						    5,
						    9,
						    14,
						    20,
						    5,
						    9,
						    14,
						    20,
						    5,
						    9,
						    14,
						    20,
						    5,
						    9,
						    14,
						    20,
						    4,
						    11,
						    16,
						    23,
						    4,
						    11,
						    16,
						    23,
						    4,
						    11,
						    16,
						    23,
						    4,
						    11,
						    16,
						    23,
						    6,
						    10,
						    15,
						    21,
						    6,
						    10,
						    15,
						    21,
						    6,
						    10,
						    15,
						    21,
						    6,
						    10,
						    15,
						    21,
						]

						# Process bit string in chunks, each with 16 32-char words
						for block_words in get_block_words(__lowerCAmelCase	):
												_UpperCAmelCase									=			aa
												_UpperCAmelCase									=			ba
												_UpperCAmelCase									=			ca
												_UpperCAmelCase									=			da

												# Hash current chunk
												for i in range(64	):
																		if i <= 15:
																								# f = (b & c) | (not_32(b) & d)     # Alternate definition for f
																								_UpperCAmelCase									=			d ^ (b & (c ^ d))
																								_UpperCAmelCase									=			i
																		elif i <= 31:
																								# f = (d & b) | (not_32(d) & c)     # Alternate definition for f
																								_UpperCAmelCase									=			c ^ (d & (b ^ c))
																								_UpperCAmelCase									=			(5 * i + 1) % 16
																		elif i <= 47:
																								_UpperCAmelCase									=			b ^ c ^ d
																								_UpperCAmelCase									=			(3 * i + 5) % 16
																		else:
																								_UpperCAmelCase									=			c ^ (b | not_aa(__lowerCAmelCase	))
																								_UpperCAmelCase									=			(7 * i) % 16
																		_UpperCAmelCase									=			(f + a + added_consts[i] + block_words[g]) % 2**32
																		_UpperCAmelCase									=			d
																		_UpperCAmelCase									=			c
																		_UpperCAmelCase									=			b
																		_UpperCAmelCase									=			sum_aa(__lowerCAmelCase ,		left_rotate_aa(__lowerCAmelCase ,		shift_amounts[i]	)	)

												# Add hashed chunk to running total
												_UpperCAmelCase									=			sum_aa(__lowerCAmelCase ,		__lowerCAmelCase	)
												_UpperCAmelCase									=			sum_aa(__lowerCAmelCase ,		__lowerCAmelCase	)
												_UpperCAmelCase									=			sum_aa(__lowerCAmelCase ,		__lowerCAmelCase	)
												_UpperCAmelCase									=			sum_aa(__lowerCAmelCase ,		__lowerCAmelCase	)

						_UpperCAmelCase									=			reformat_hex(__lowerCAmelCase	) + reformat_hex(__lowerCAmelCase	) + reformat_hex(__lowerCAmelCase	) + reformat_hex(__lowerCAmelCase	)
						return digest


if __name__ == "__main__":
		import doctest

		doctest.testmod()








import gc
import random
import unittest

import numpy as np
import torch
from transformers import CLIPImageProcessor, CLIPVisionConfig, CLIPVisionModel

from diffusers import HeunDiscreteScheduler, PriorTransformer, ShapEImgaImgPipeline
from diffusers.pipelines.shap_e import ShapERenderer
from diffusers.utils import floats_tensor, load_image, load_numpy, slow
from diffusers.utils.testing_utils import require_torch_gpu, torch_device

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference

class     _SCREAMING_SNAKE_CASE       (			_a		,   unittest.TestCase      ):
	snake_case__							:     Tuple     	=  ShapEImgaImgPipeline
	snake_case__							:     Optional[Any]     	=  ["""image"""]
	snake_case__							:     Union[str, Any]     	=  ["""image"""]
	snake_case__							:     Optional[Any]     	=  [
	    """num_images_per_prompt""",
	    """num_inference_steps""",
	    """generator""",
	    """latents""",
	    """guidance_scale""",
	    """frame_size""",
	    """output_type""",
	    """return_dict""",
	]
	snake_case__							:     List[str]     	=  False





	@property
	def 						_A (		self				:					Any	):
		return 32





	@property
	def 						_A (		self				:					Any	):
		return 32





	@property
	def 						_A (		self				:					Optional[Any]	):
		return self.time_input_dim * 4





	@property
	def 						_A (		self				:					Union[str, Any]	):
		return 8





	@property
	def 						_A (		self				:					int	):
		torch.manual_seed(0	)
		UpperCamelCase     :Union[str, Any]          =	CLIPVisionConfig(
		    hidden_size=self.text_embedder_hidden_size ,  image_size=64 ,  projection_dim=self.text_embedder_hidden_size ,  intermediate_size=37 ,  num_attention_heads=4 ,  num_channels=3 ,  num_hidden_layers=5 ,  patch_size=1 ,  )

		UpperCamelCase     :Optional[int]          =	CLIPVisionModel(__lowerCamelCase	)
		return model





	@property
	def 						_A (		self				:					str	):
		UpperCamelCase     :Optional[int]          =	CLIPImageProcessor(
		    crop_size=224 ,  do_center_crop=__lowerCamelCase ,  do_normalize=__lowerCamelCase ,  do_resize=__lowerCamelCase ,  image_mean=[0.48145466, 0.4578275, 0.40821073] ,  image_std=[0.26862954, 0.26130258, 0.27577711] ,  resample=3 ,  size=224 ,  )

		return image_processor





	@property
	def 						_A (		self				:					Tuple	):
		torch.manual_seed(0	)

		UpperCamelCase     :Dict          =	{
		    """num_attention_heads""": 2,
		    """attention_head_dim""": 16,
		    """embedding_dim""": self.time_input_dim,
		    """num_embeddings""": 32,
		    """embedding_proj_dim""": self.text_embedder_hidden_size,
		    """time_embed_dim""": self.time_embed_dim,
		    """num_layers""": 1,
		    """clip_embed_dim""": self.time_input_dim * 2,
		    """additional_embeddings""": 0,
		    """time_embed_act_fn""": """gelu""",
		    """norm_in_type""": """layer""",
		    """embedding_proj_norm_type""": """layer""",
		    """encoder_hid_proj_type""": None,
		    """added_emb_type""": None,
		}

		UpperCamelCase     :int          =	PriorTransformer(**__lowerCamelCase	)
		return model





	@property
	def 						_A (		self				:					Optional[int]	):
		torch.manual_seed(0	)

		UpperCamelCase     :str          =	{
		    """param_shapes""": (
		        (self.renderer_dim, 93),
		        (self.renderer_dim, 8),
		        (self.renderer_dim, 8),
		        (self.renderer_dim, 8),
		    ),
		    """d_latent""": self.time_input_dim,
		    """d_hidden""": self.renderer_dim,
		    """n_output""": 12,
		    """background""": (
		        0.1,
		        0.1,
		        0.1,
		    ),
		}
		UpperCamelCase     :List[str]          =	ShapERenderer(**__lowerCamelCase	)
		return model





	def 						_A (		self				:					str	):
		UpperCamelCase     :int          =	self.dummy_prior
		UpperCamelCase     :Any          =	self.dummy_image_encoder
		UpperCamelCase     :Dict          =	self.dummy_image_processor
		UpperCamelCase     :List[Any]          =	self.dummy_renderer

		UpperCamelCase     :int          =	HeunDiscreteScheduler(
		    beta_schedule="""exp""" ,  num_train_timesteps=1_024 ,  prediction_type="""sample""" ,  use_karras_sigmas=__lowerCamelCase ,  clip_sample=__lowerCamelCase ,  clip_sample_range=1.0 ,  )
		UpperCamelCase     :Optional[Any]          =	{
		    """prior""": prior,
		    """image_encoder""": image_encoder,
		    """image_processor""": image_processor,
		    """renderer""": renderer,
		    """scheduler""": scheduler,
		}

		return components





	def 						_A (		self				:					int ,  __lowerCamelCase				:					int ,  __lowerCamelCase				:					Any=0	):
		UpperCamelCase     :Any          =	floats_tensor((1, 3, 64, 64) ,  rng=random.Random(__lowerCamelCase	)	).to(__lowerCamelCase	)

		if str(__lowerCamelCase	).startswith("""mps"""	):
			UpperCamelCase     :List[Any]          =	torch.manual_seed(__lowerCamelCase	)
		else:
			UpperCamelCase     :Optional[int]          =	torch.Generator(device=__lowerCamelCase	).manual_seed(__lowerCamelCase	)
		UpperCamelCase     :Optional[Any]          =	{
		    """image""": input_image,
		    """generator""": generator,
		    """num_inference_steps""": 1,
		    """frame_size""": 32,
		    """output_type""": """np""",
		}
		return inputs





	def 						_A (		self				:					List[str]	):
		UpperCamelCase     :Dict          =	"""cpu"""

		UpperCamelCase     :List[Any]          =	self.get_dummy_components()

		UpperCamelCase     :Optional[int]          =	self.pipeline_class(**__lowerCamelCase	)
		UpperCamelCase     :int          =	pipe.to(__lowerCamelCase	)

		pipe.set_progress_bar_config(disable=__lowerCamelCase	)

		UpperCamelCase     :Optional[Any]          =	pipe(**self.get_dummy_inputs(__lowerCamelCase	)	)
		UpperCamelCase     :Dict          =	output.images[0]
		UpperCamelCase     :List[Any]          =	image[0, -3:, -3:, -1]

		assert image.shape == (20, 32, 32, 3)

		UpperCamelCase     :Dict          =	np.array(
		    [
		        0.00039216,
		        0.00039216,
		        0.00039216,
		        0.00039216,
		        0.00039216,
		        0.00039216,
		        0.00039216,
		        0.00039216,
		        0.00039216,
		    ]	)

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





	def 						_A (		self				:					List[Any]	):
		# NOTE: Larger batch sizes cause this test to timeout, only test on smaller batches
		self._test_inference_batch_consistent(batch_sizes=[1, 2]	)





	def 						_A (		self				:					List[Any]	):
		UpperCamelCase     :str          =	torch_device == """cpu"""
		UpperCamelCase     :int          =	True
		self._test_inference_batch_single_identical(
		    batch_size=2 ,  test_max_difference=__lowerCamelCase ,  relax_max_difference=__lowerCamelCase ,  )





	def 						_A (		self				:					List[Any]	):
		UpperCamelCase     :List[Any]          =	self.get_dummy_components()
		UpperCamelCase     :Optional[int]          =	self.pipeline_class(**__lowerCamelCase	)
		UpperCamelCase     :List[Any]          =	pipe.to(__lowerCamelCase	)
		pipe.set_progress_bar_config(disable=__lowerCamelCase	)

		UpperCamelCase     :Any          =	1
		UpperCamelCase     :int          =	2

		UpperCamelCase     :Union[str, Any]          =	self.get_dummy_inputs(__lowerCamelCase	)

		for key in inputs.keys():
			if key in self.batch_params:
				UpperCamelCase     :str          =	batch_size * [inputs[key]]

		UpperCamelCase     :Optional[int]          =	pipe(**__lowerCamelCase ,  num_images_per_prompt=__lowerCamelCase	)[0]

		assert images.shape[0] == batch_size * num_images_per_prompt

@slow
@require_torch_gpu
class     _SCREAMING_SNAKE_CASE       (			unittest.TestCase      ):





	def 						_A (		self				:					Any	):
		# clean up the VRAM after each test
		super().tearDown()
		gc.collect()
		torch.cuda.empty_cache()





	def 						_A (		self				:					Any	):
		UpperCamelCase     :Optional[Any]          =	load_image(
		    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main""" """/shap_e/corgi.png"""	)
		UpperCamelCase     :Any          =	load_numpy(
		    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
		    """/shap_e/test_shap_e_img2img_out.npy"""	)
		UpperCamelCase     :Union[str, Any]          =	ShapEImgaImgPipeline.from_pretrained("""openai/shap-e-img2img"""	)
		UpperCamelCase     :List[str]          =	pipe.to(__lowerCamelCase	)
		pipe.set_progress_bar_config(disable=__lowerCamelCase	)

		UpperCamelCase     :Optional[Any]          =	torch.Generator(device=__lowerCamelCase	).manual_seed(0	)

		UpperCamelCase     :Optional[int]          =	pipe(
		    __lowerCamelCase ,  generator=__lowerCamelCase ,  guidance_scale=3.0 ,  num_inference_steps=64 ,  frame_size=64 ,  output_type="""np""" ,  ).images[0]

		assert images.shape == (20, 64, 64, 3)

		assert_mean_pixel_difference(__lowerCamelCase ,  __lowerCamelCase	)
