

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 					_a		(__magic_name__	,     __magic_name__	,     __magic_name__	,     unittest.TestCase       ):


					'''simple docstring'''






					UpperCAmelCase__:     Dict													= StableUnCLIPPipeline
					UpperCAmelCase__:     Any													= TEXT_TO_IMAGE_PARAMS
					UpperCAmelCase__:     List[str]													= TEXT_TO_IMAGE_BATCH_PARAMS
					UpperCAmelCase__:     Dict													= TEXT_TO_IMAGE_IMAGE_PARAMS
					UpperCAmelCase__:     str													= TEXT_TO_IMAGE_IMAGE_PARAMS

					# TODO(will) Expected attn_bias.stride(1) == 0 to be true, but got false
					UpperCAmelCase__:     Union[str, Any]													= False






					def 						__A    (				self    ):
						A__							:					Dict       =	32
						A__							:					Any       =	embedder_hidden_size

						# prior components

						torch.manual_seed(0    )
						A__							:					str       =	CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""    )

						torch.manual_seed(0    )
						A__							:					int       =	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    )
						A__							:					List[Any]       =	PriorTransformer(
						    num_attention_heads=2					, attention_head_dim=12					, embedding_dim=A__					, num_layers=1					, )

						torch.manual_seed(0    )
						A__							:					Optional[int]       =	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    )
						A__							:					Dict       =	StableUnCLIPImageNormalizer(embedding_dim=A__    )
						A__							:					int       =	DDPMScheduler(beta_schedule="""squaredcos_cap_v2"""    )

						torch.manual_seed(0    )
						A__							:					str       =	CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""    )

						torch.manual_seed(0    )
						A__							:					List[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    )
						A__							:					Union[str, Any]       =	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    )
						A__							:					Union[str, 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    )
						A__							:					List[Any]       =	AutoencoderKL()

						A__							:					Union[str, Any]       =	{
						    # 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 						__A    (				self					, A__					, A__=0    ):
						if str(A__    ).startswith("""mps"""    ):
							A__							:					Optional[int]       =	torch.manual_seed(A__    )
						else:
							A__							:					int       =	torch.Generator(device=A__    ).manual_seed(A__    )
						A__							:					Dict       =	{
						    """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 						__A    (				self    ):
						A__							:					int       =	torch_device == """cpu"""

						self._test_attention_slicing_forward_pass(test_max_difference=A__    )






					def 						__A    (				self    ):
						A__							:					str       =	torch_device in ["""cpu""", """mps"""]

						self._test_inference_batch_single_identical(test_max_difference=A__    )



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


					'''simple docstring'''






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






					def 						__A    (				self    ):
						A__							:					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"""    )

						A__							:					Optional[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()

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

						A__							:					Tuple       =	output.images[0]

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

						assert_mean_pixel_difference(A__					, A__    )






					def 						__A    (				self    ):
						torch.cuda.empty_cache()
						torch.cuda.reset_max_memory_allocated()
						torch.cuda.reset_peak_memory_stats()

						A__							:					Optional[int]       =	StableUnCLIPPipeline.from_pretrained("""fusing/stable-unclip-2-1-l"""					, torch_dtype=torch.floataa    )
						A__							:					List[Any]       =	pipe.to(A__    )
						pipe.set_progress_bar_config(disable=A__    )
						pipe.enable_attention_slicing()
						pipe.enable_sequential_cpu_offload()

						A__							:					Any       =	pipe(
						    """anime turtle"""					, prior_num_inference_steps=2					, num_inference_steps=2					, output_type="""np"""					, )

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






from functools import lru_cache

@lru_cache
def 		UpperCamelCase      (lowercase_:				int      )  ->   int:
	if num < 0:
		raise ValueError("""Number should not be negative."""      )

	return 1 if num in (0, 1) else num * factorial(num - 1      )


if __name__ == "__main__":
	import doctest

	doctest.testmod()



