



'''simple docstring'''




import gc
import unittest

import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTextModelWithProjection, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DDPMScheduler,
    PriorTransformer,
    StableUnCLIPPipeline,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.stable_unclip_image_normalizer import StableUnCLIPImageNormalizer
from diffusers.utils.testing_utils import enable_full_determinism, load_numpy, require_torch_gpu, slow, torch_device

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import (
    PipelineKarrasSchedulerTesterMixin,
    PipelineLatentTesterMixin,
    PipelineTesterMixin,
    assert_mean_pixel_difference,
)


enable_full_determinism()

class     UpperCamelCase_				(							__magic_name__   ,  __magic_name__   ,  __magic_name__   ,  unittest.TestCase    ):
	lowercase    =				StableUnCLIPPipeline
	lowercase    =				TEXT_TO_IMAGE_PARAMS
	lowercase    =				TEXT_TO_IMAGE_BATCH_PARAMS
	lowercase    =				TEXT_TO_IMAGE_IMAGE_PARAMS
	lowercase    =				TEXT_TO_IMAGE_IMAGE_PARAMS

	# TODO(will) Expected attn_bias.stride(1) == 0 to be true, but got false
	lowercase    =				False





	def 				_lowercase(						self					)    ->    List[Any]:
								UpperCAmelCase  :	int							  =	32
								UpperCAmelCase  :	int							  =	embedder_hidden_size

								# prior components

								torch.manual_seed(0					)
								UpperCAmelCase  :	Union[str, Any]							  =	CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""					)

								torch.manual_seed(0					)
								UpperCAmelCase  :	Dict							  =	CLIPTextModelWithProjection(
								    CLIPTextConfig(
								        bos_token_id=0	,	eos_token_id=2	,	hidden_size=A	,	projection_dim=A	,	intermediate_size=37	,	layer_norm_eps=1e-05	,	num_attention_heads=4	,	num_hidden_layers=5	,	pad_token_id=1	,	vocab_size=1000	,	)					)

								torch.manual_seed(0					)
								UpperCAmelCase  :	int							  =	PriorTransformer(
								    num_attention_heads=2	,	attention_head_dim=12	,	embedding_dim=A	,	num_layers=1	,	)

								torch.manual_seed(0					)
								UpperCAmelCase  :	Union[str, Any]							  =	DDPMScheduler(
								    variance_type="""fixed_small_log"""	,	prediction_type="""sample"""	,	num_train_timesteps=1000	,	clip_sample=A	,	clip_sample_range=5.0	,	beta_schedule="""squaredcos_cap_v2"""	,	)

								# regular denoising components

								torch.manual_seed(0					)
								UpperCAmelCase  :	Any							  =	StableUnCLIPImageNormalizer(embedding_dim=A					)
								UpperCAmelCase  :	Any							  =	DDPMScheduler(beta_schedule="""squaredcos_cap_v2"""					)

								torch.manual_seed(0					)
								UpperCAmelCase  :	List[Any]							  =	CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""					)

								torch.manual_seed(0					)
								UpperCAmelCase  :	str							  =	CLIPTextModel(
								    CLIPTextConfig(
								        bos_token_id=0	,	eos_token_id=2	,	hidden_size=A	,	projection_dim=32	,	intermediate_size=37	,	layer_norm_eps=1e-05	,	num_attention_heads=4	,	num_hidden_layers=5	,	pad_token_id=1	,	vocab_size=1000	,	)					)

								torch.manual_seed(0					)
								UpperCAmelCase  :	int							  =	UNetaDConditionModel(
								    sample_size=32	,	in_channels=4	,	out_channels=4	,	down_block_types=("""CrossAttnDownBlock2D""", """DownBlock2D""")	,	up_block_types=("""UpBlock2D""", """CrossAttnUpBlock2D""")	,	block_out_channels=(32, 64)	,	attention_head_dim=(2, 4)	,	class_embed_type="""projection"""	,	projection_class_embeddings_input_dim=embedder_projection_dim * 2	,	cross_attention_dim=A	,	layers_per_block=1	,	upcast_attention=A	,	use_linear_projection=A	,	)

								torch.manual_seed(0					)
								UpperCAmelCase  :	Any							  =	DDIMScheduler(
								    beta_schedule="""scaled_linear"""	,	beta_start=0.0_0_0_8_5	,	beta_end=0.0_1_2	,	prediction_type="""v_prediction"""	,	set_alpha_to_one=A	,	steps_offset=1	,	)

								torch.manual_seed(0					)
								UpperCAmelCase  :	Optional[Any]							  =	AutoencoderKL()

								UpperCAmelCase  :	str							  =	{
								    # prior components
								    """prior_tokenizer""": prior_tokenizer,
								    """prior_text_encoder""": prior_text_encoder,
								    """prior""": prior,
								    """prior_scheduler""": prior_scheduler,
								    # image noising components
								    """image_normalizer""": image_normalizer,
								    """image_noising_scheduler""": image_noising_scheduler,
								    # regular denoising components
								    """tokenizer""": tokenizer,
								    """text_encoder""": text_encoder,
								    """unet""": unet,
								    """scheduler""": scheduler,
								    """vae""": vae,
								}

								return components





	def 				_lowercase(						self	,	A	,	A=0					)    ->    Optional[int]:
								if str(A					).startswith("""mps"""					):
															UpperCAmelCase  :	Union[str, Any]							  =	torch.manual_seed(A					)
								else:
															UpperCAmelCase  :	Dict							  =	torch.Generator(device=A					).manual_seed(A					)
								UpperCAmelCase  :	Tuple							  =	{
								    """prompt""": """A painting of a squirrel eating a burger""",
								    """generator""": generator,
								    """num_inference_steps""": 2,
								    """prior_num_inference_steps""": 2,
								    """output_type""": """numpy""",
								}
								return inputs





	def 				_lowercase(						self					)    ->    Dict:
								UpperCAmelCase  :	List[str]							  =	torch_device == """cpu"""

								self._test_attention_slicing_forward_pass(test_max_difference=A					)






	def 				_lowercase(						self					)    ->    Tuple:
								UpperCAmelCase  :	List[str]							  =	torch_device in ["""cpu""", """mps"""]

								self._test_inference_batch_single_identical(test_max_difference=A					)




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





	def 				_lowercase(						self					)    ->    Union[str, Any]:
								# clean up the VRAM after each test
								super().tearDown()
								gc.collect()
								torch.cuda.empty_cache()





	def 				_lowercase(						self					)    ->    List[Any]:
								UpperCAmelCase  :	Optional[Any]							  =	load_numpy(
								    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_l_anime_turtle_fp16.npy"""					)

								UpperCAmelCase  :	Union[str, Any]							  =	StableUnCLIPPipeline.from_pretrained("""fusing/stable-unclip-2-1-l"""	,	torch_dtype=torch.floataa					)
								pipe.to(A					)
								pipe.set_progress_bar_config(disable=A					)
								# stable unclip will oom when integration tests are run on a V100,
								# so turn on memory savings
								pipe.enable_attention_slicing()
								pipe.enable_sequential_cpu_offload()

								UpperCAmelCase  :	Optional[int]							  =	torch.Generator(device="""cpu"""					).manual_seed(0					)
								UpperCAmelCase  :	Union[str, Any]							  =	pipe("""anime turle"""	,	generator=A	,	output_type="""np"""					)

								UpperCAmelCase  :	List[Any]							  =	output.images[0]

								assert image.shape == (768, 768, 3)

								assert_mean_pixel_difference(A	,	A					)






	def 				_lowercase(						self					)    ->    List[str]:
								torch.cuda.empty_cache()
								torch.cuda.reset_max_memory_allocated()
								torch.cuda.reset_peak_memory_stats()

								UpperCAmelCase  :	Any							  =	StableUnCLIPPipeline.from_pretrained("""fusing/stable-unclip-2-1-l"""	,	torch_dtype=torch.floataa					)
								UpperCAmelCase  :	Any							  =	pipe.to(A					)
								pipe.set_progress_bar_config(disable=A					)
								pipe.enable_attention_slicing()
								pipe.enable_sequential_cpu_offload()

								UpperCAmelCase  :	Dict							  =	pipe(
								    """anime turtle"""	,	prior_num_inference_steps=2	,	num_inference_steps=2	,	output_type="""np"""	,	)

								UpperCAmelCase  :	Any							  =	torch.cuda.max_memory_allocated()
								# make sure that less than 7 GB is allocated
								assert mem_bytes < 7 * 10**9






'''simple docstring'''




a     :    Tuple      						=					[sum(int(c, 1_0) ** 2 for c in i.__str__()) for i in range(1_0_0_0_0_0)]



def    __lowerCamelCase						(      _lowercase	)   ->    int:
							UpperCAmelCase  :	str							  =	0
							while number:
														# Increased Speed Slightly by checking every 5 digits together.
														sum_of_digits_squared += DIGITS_SQUARED[number % 1_0_0_0_0_0]
														number //= 1_0_0_0_0_0

							return sum_of_digits_squared


# There are 2 Chains made,
# One ends with 89 with the chain member 58 being the one which when declared first,
# there will be the least number of iterations for all the members to be checked.

# The other one ends with 1 and has only one element 1.

# So 58 and 1 are chosen to be declared at the starting.

# Changed dictionary to an array to quicken the solution
a     :    list[bool | None]      						=					[None] * 1_0_0_0_0_0_0_0
a     :    Optional[Any]      						=					True
a     :    List[Any]      						=					False



def    __lowerCamelCase						(      _lowercase	)   ->    bool:

							if CHAINS[number - 1] is not None:
														return CHAINS[number - 1]  # type: ignore

							UpperCAmelCase  :	List[str]							  =	chain(next_number(_lowercase	)	)
							UpperCAmelCase  :	Tuple							  =	number_chain

							while number < 1_0_0_0_0_0_0_0:
														UpperCAmelCase  :	List[str]							  =	number_chain
														number *= 1_0

							return number_chain



def    __lowerCamelCase						(      _lowercase = 1_0_0_0_0_0_0_0	)   ->    int:
							for i in range(1			,       _lowercase	):
														if CHAINS[i] is None:
																					chain(i + 1	)

							return CHAINS[:number].count(_lowercase	)


if __name__ == "__main__":
							import doctest

							doctest.testmod()
							print(F'''{solution() = }''')

