






'''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 _lowercase     (    __lowerCamelCase    ,				__lowerCamelCase    ,				__lowerCamelCase    ,				unittest.TestCase		):
							a    				=	StableUnCLIPPipeline
							a    				=	TEXT_TO_IMAGE_PARAMS
							a    				=	TEXT_TO_IMAGE_BATCH_PARAMS
							a    				=	TEXT_TO_IMAGE_IMAGE_PARAMS
							a    				=	TEXT_TO_IMAGE_IMAGE_PARAMS

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




							def 		lowerCamelCase_    (							self:    Optional[int]					):
														lowerCamelCase__ :     Tuple	  =	32
														lowerCamelCase__ :     int	  =	embedder_hidden_size

														# prior components

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

														torch.manual_seed(0					)
														lowerCamelCase__ :     Union[str, Any]	  =	CLIPTextModelWithProjection(
														    CLIPTextConfig(
														        bos_token_id=0      ,							eos_token_id=2      ,							hidden_size=__lowercase      ,							projection_dim=__lowercase      ,							intermediate_size=37      ,							layer_norm_eps=1e-05      ,							num_attention_heads=4      ,							num_hidden_layers=5      ,							pad_token_id=1      ,							vocab_size=1_000      ,							)					)

														torch.manual_seed(0					)
														lowerCamelCase__ :     Any	  =	PriorTransformer(
														    num_attention_heads=2      ,							attention_head_dim=12      ,							embedding_dim=__lowercase      ,							num_layers=1      ,							)

														torch.manual_seed(0					)
														lowerCamelCase__ :     Any	  =	DDPMScheduler(
														    variance_type="""fixed_small_log"""      ,							prediction_type="""sample"""      ,							num_train_timesteps=1_000      ,							clip_sample=__lowercase      ,							clip_sample_range=5.0      ,							beta_schedule="""squaredcos_cap_v2"""      ,							)

														# regular denoising components

														torch.manual_seed(0					)
														lowerCamelCase__ :     List[Any]	  =	StableUnCLIPImageNormalizer(embedding_dim=__lowercase					)
														lowerCamelCase__ :     int	  =	DDPMScheduler(beta_schedule="""squaredcos_cap_v2"""					)

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

														torch.manual_seed(0					)
														lowerCamelCase__ :     int	  =	CLIPTextModel(
														    CLIPTextConfig(
														        bos_token_id=0      ,							eos_token_id=2      ,							hidden_size=__lowercase      ,							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=1_000      ,							)					)

														torch.manual_seed(0					)
														lowerCamelCase__ :     Optional[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=__lowercase      ,							layers_per_block=1      ,							upcast_attention=__lowercase      ,							use_linear_projection=__lowercase      ,							)

														torch.manual_seed(0					)
														lowerCamelCase__ :     Dict	  =	DDIMScheduler(
														    beta_schedule="""scaled_linear"""      ,							beta_start=0.00_085      ,							beta_end=0.012      ,							prediction_type="""v_prediction"""      ,							set_alpha_to_one=__lowercase      ,							steps_offset=1      ,							)

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

														lowerCamelCase__ :     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 		lowerCamelCase_    (							self:    Union[str, Any]      ,							UpperCamelCase__:    Union[str, Any]      ,							UpperCamelCase__:    Dict=0					):
														if str(__lowercase					).startswith("""mps"""					):
																					lowerCamelCase__ :     List[Any]	  =	torch.manual_seed(__lowercase					)
														else:
																					lowerCamelCase__ :     List[Any]	  =	torch.Generator(device=__lowercase					).manual_seed(__lowercase					)
														lowerCamelCase__ :     List[Any]	  =	{
														    '''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 		lowerCamelCase_    (							self:    Any					):
														lowerCamelCase__ :     List[str]	  =	torch_device == '''cpu'''

														self._test_attention_slicing_forward_pass(test_max_difference=__lowercase					)




							def 		lowerCamelCase_    (							self:    Union[str, Any]					):
														lowerCamelCase__ :     str	  =	torch_device in ['''cpu''', '''mps''']

														self._test_inference_batch_single_identical(test_max_difference=__lowercase					)



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




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




							def 		lowerCamelCase_    (							self:    Optional[int]					):
														lowerCamelCase__ :     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"""					)

														lowerCamelCase__ :     Tuple	  =	StableUnCLIPPipeline.from_pretrained("""fusing/stable-unclip-2-1-l"""      ,							torch_dtype=torch.floataa					)
														pipe.to(__lowercase					)
														pipe.set_progress_bar_config(disable=__lowercase					)
														# 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()

														lowerCamelCase__ :     Dict	  =	torch.Generator(device="""cpu"""					).manual_seed(0					)
														lowerCamelCase__ :     Optional[Any]	  =	pipe("""anime turle"""      ,							generator=__lowercase      ,							output_type="""np"""					)

														lowerCamelCase__ :     Union[str, Any]	  =	output.images[0]

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

														assert_mean_pixel_difference(__lowercase      ,							__lowercase					)




							def 		lowerCamelCase_    (							self:    Optional[Any]					):
														torch.cuda.empty_cache()
														torch.cuda.reset_max_memory_allocated()
														torch.cuda.reset_peak_memory_stats()

														lowerCamelCase__ :     List[str]	  =	StableUnCLIPPipeline.from_pretrained("""fusing/stable-unclip-2-1-l"""      ,							torch_dtype=torch.floataa					)
														lowerCamelCase__ :     Dict	  =	pipe.to(__lowercase					)
														pipe.set_progress_bar_config(disable=__lowercase					)
														pipe.enable_attention_slicing()
														pipe.enable_sequential_cpu_offload()

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

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









'''simple docstring'''







def 			SCREAMING_SNAKE_CASE_	(UpperCamelCase				)				->	list:

							# bit count represents no. of bits in the gray code
							if bit_count < 0:
														raise ValueError("""The given input must be positive"""				)

							# get the generated string sequence
							lowerCamelCase__ :     List[str]	  =	gray_code_sequence_string(UpperCamelCase				)
							#
							# convert them to integers
							for i in range(len(UpperCamelCase				)				):
														lowerCamelCase__ :     int	  =	int(sequence[i]    ,      2				)

							return sequence





def 			SCREAMING_SNAKE_CASE_	(UpperCamelCase				)				->	list:

							# The approach is a recursive one
							# Base case achieved when either n = 0 or n=1
							if bit_count == 0:
														return ["0"]

							if bit_count == 1:
														return ["0", "1"]

							lowerCamelCase__ :     Optional[Any]	  =	1 << bit_count  # defines the length of the sequence
							# 1<< n is equivalent to 2^n

							# recursive answer will generate answer for n-1 bits
							lowerCamelCase__ :     Any	  =	gray_code_sequence_string(bit_count - 1				)

							lowerCamelCase__ :     Union[str, Any]	  =	[]

							# append 0 to first half of the smaller sequence generated
							for i in range(seq_len // 2				):
														lowerCamelCase__ :     Optional[int]	  =	"""0""" + smaller_sequence[i]
														sequence.append(UpperCamelCase				)

							# append 1 to second half ... start from the end of the list
							for i in reversed(range(seq_len // 2				)				):
														lowerCamelCase__ :     int	  =	"""1""" + smaller_sequence[i]
														sequence.append(UpperCamelCase				)

							return sequence


if __name__ == "__main__":
			import doctest

			doctest.testmod()

