


'''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        lowerCamelCase__	(							UpperCAmelCase					,	UpperCAmelCase					,	UpperCAmelCase					,	unittest.TestCase      ):






			"""simple docstring"""






			_UpperCamelCase		:					Union[str, Any]    =		StableUnCLIPPipeline
			_UpperCamelCase		:					int    =		TEXT_TO_IMAGE_PARAMS
			_UpperCamelCase		:					str    =		TEXT_TO_IMAGE_BATCH_PARAMS
			_UpperCamelCase		:					Optional[Any]    =		TEXT_TO_IMAGE_IMAGE_PARAMS
			_UpperCamelCase		:					Dict    =		TEXT_TO_IMAGE_IMAGE_PARAMS

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




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       32
						UpperCamelCase__					=       embedder_hidden_size

						# prior components

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

						torch.manual_seed(0     )
						UpperCamelCase__					=       CLIPTextModelWithProjection(
						    CLIPTextConfig(
						        bos_token_id=0      ,						eos_token_id=2      ,						hidden_size=snake_case      ,						projection_dim=snake_case      ,						intermediate_size=37      ,						layer_norm_eps=1E-0_5      ,						num_attention_heads=4      ,						num_hidden_layers=5      ,						pad_token_id=1      ,						vocab_size=1000      ,						)     )

						torch.manual_seed(0     )
						UpperCamelCase__					=       PriorTransformer(
						    num_attention_heads=2      ,						attention_head_dim=12      ,						embedding_dim=snake_case      ,						num_layers=1      ,						)

						torch.manual_seed(0     )
						UpperCamelCase__					=       DDPMScheduler(
						    variance_type="fixed_small_log"      ,						prediction_type="sample"      ,						num_train_timesteps=1000      ,						clip_sample=snake_case      ,						clip_sample_range=5.0      ,						beta_schedule="squaredcos_cap_v2"      ,						)

						# regular denoising components

						torch.manual_seed(0     )
						UpperCamelCase__					=       StableUnCLIPImageNormalizer(embedding_dim=snake_case     )
						UpperCamelCase__					=       DDPMScheduler(beta_schedule="squaredcos_cap_v2"     )

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

						torch.manual_seed(0     )
						UpperCamelCase__					=       CLIPTextModel(
						    CLIPTextConfig(
						        bos_token_id=0      ,						eos_token_id=2      ,						hidden_size=snake_case      ,						projection_dim=32      ,						intermediate_size=37      ,						layer_norm_eps=1E-0_5      ,						num_attention_heads=4      ,						num_hidden_layers=5      ,						pad_token_id=1      ,						vocab_size=1000      ,						)     )

						torch.manual_seed(0     )
						UpperCamelCase__					=       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=snake_case      ,						layers_per_block=1      ,						upcast_attention=snake_case      ,						use_linear_projection=snake_case      ,						)

						torch.manual_seed(0     )
						UpperCamelCase__					=       DDIMScheduler(
						    beta_schedule="scaled_linear"      ,						beta_start=0.00085      ,						beta_end=0.012      ,						prediction_type="v_prediction"      ,						set_alpha_to_one=snake_case      ,						steps_offset=1      ,						)

						torch.manual_seed(0     )
						UpperCamelCase__					=       AutoencoderKL()

						UpperCamelCase__					=       {
						    # 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 				snake_case__				(							self      ,						snake_case      ,						snake_case=0     ):

						'''simple docstring'''


						if str(snake_case     ).startswith("mps"     ):
									UpperCamelCase__					=       torch.manual_seed(snake_case     )
						else:
									UpperCamelCase__					=       torch.Generator(device=snake_case     ).manual_seed(snake_case     )
						UpperCamelCase__					=       {
						    "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 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       torch_device == "cpu"

						self._test_attention_slicing_forward_pass(test_max_difference=snake_case     )







			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       torch_device in ["cpu", "mps"]

						self._test_inference_batch_single_identical(test_max_difference=snake_case     )







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






			"""simple docstring"""






			def 				snake_case__				(							self     ):

						'''simple docstring'''


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




			def 				snake_case__				(							self     ):

						'''simple docstring'''


						UpperCamelCase__					=       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__					=       StableUnCLIPPipeline.from_pretrained("fusing/stable-unclip-2-1-l"      ,						torch_dtype=torch.floataa     )
						pipe.to(snake_case     )
						pipe.set_progress_bar_config(disable=snake_case     )
						# 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__					=       torch.Generator(device="cpu"     ).manual_seed(0     )
						UpperCamelCase__					=       pipe("anime turle"      ,						generator=snake_case      ,						output_type="np"     )

						UpperCamelCase__					=       output.images[0]

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

						assert_mean_pixel_difference(snake_case      ,						snake_case     )







			def 				snake_case__				(							self     ):

						'''simple docstring'''


						torch.cuda.empty_cache()
						torch.cuda.reset_max_memory_allocated()
						torch.cuda.reset_peak_memory_stats()

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

						UpperCamelCase__					=       pipe(
						    "anime turtle"      ,						prior_num_inference_steps=2      ,						num_inference_steps=2      ,						output_type="np"      ,						)

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






def        UpperCamelCase_(				_A   :int				,     _A   :int  )->		str:
			if number < 0 or shift_amount < 0:
						raise ValueError("both inputs must be positive integers"  )

			UpperCamelCase__					=       str(bin(_A  )  )
			binary_number += "0" * shift_amount
			return binary_number
def        UpperCamelCase_(				_A   :int				,     _A   :int  )->		str:
			if number < 0 or shift_amount < 0:
						raise ValueError("both inputs must be positive integers"  )

			UpperCamelCase__					=       str(bin(_A  )  )[2:]
			if shift_amount >= len(_A  ):
						return "0b0"
			UpperCamelCase__					=       binary_number[: len(_A  ) - shift_amount]
			return "0b" + shifted_binary_number
def        UpperCamelCase_(				_A   :int				,     _A   :int  )->		str:
			if number >= 0:  # Get binary representation of positive number
						UpperCamelCase__					=       "0" + str(bin(_A  )  ).strip("-"  )[2:]
			else:  # Get binary (2's complement) representation of negative number
						UpperCamelCase__					=       len(bin(_A  )[3:]  )  # Find 2's complement of number
						UpperCamelCase__					=       bin(abs(_A  ) - (1 << binary_number_length)  )[3:]
						UpperCamelCase__					=       (
						    "1" + "0" * (binary_number_length - len(_A  )) + binary_number
						)

			if shift_amount >= len(_A  ):
						return "0b" + binary_number[0] * len(_A  )
			return (
			    "0b"
			    + binary_number[0] * shift_amount
			    + binary_number[: len(_A  ) - shift_amount]
			)


if __name__ == "__main__":
						import doctest

						doctest.testmod()


