






"""simple docstring"""







import gc
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTextModelWithProjection, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DiffusionPipeline,
    EulerDiscreteScheduler,
    StableDiffusionXLPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()







class 					lowerCamelCase__					(       snake_case    ,     snake_case    ,     unittest.TestCase ):
    SCREAMING_SNAKE_CASE		=			StableDiffusionXLPipeline
    SCREAMING_SNAKE_CASE		=			TEXT_TO_IMAGE_PARAMS
    SCREAMING_SNAKE_CASE		=			TEXT_TO_IMAGE_BATCH_PARAMS
    SCREAMING_SNAKE_CASE		=			TEXT_TO_IMAGE_IMAGE_PARAMS
    SCREAMING_SNAKE_CASE		=			TEXT_TO_IMAGE_IMAGE_PARAMS






    def 				_UpperCamelCase							( self					):
          torch.manual_seed(0					)
          UpperCAmelCase							=       UNetaDConditionModel(
              block_out_channels=(32, 64)	,layers_per_block=2	,sample_size=32	,in_channels=4	,out_channels=4	,down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")	,up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""")	,attention_head_dim=(2, 4)	,use_linear_projection=lowercase__	,addition_embed_type="""text_time"""	,addition_time_embed_dim=8	,transformer_layers_per_block=(1, 2)	,projection_class_embeddings_input_dim=80	,cross_attention_dim=64	,)
          UpperCAmelCase							=       EulerDiscreteScheduler(
              beta_start=0.00085	,beta_end=0.012	,steps_offset=1	,beta_schedule="""scaled_linear"""	,timestep_spacing="""leading"""	,)
          torch.manual_seed(0					)
          UpperCAmelCase							=       AutoencoderKL(
              block_out_channels=[32, 64]	,in_channels=3	,out_channels=3	,down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""]	,up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""]	,latent_channels=4	,sample_size=128	,)
          torch.manual_seed(0					)
          UpperCAmelCase							=       CLIPTextConfig(
              bos_token_id=0	,eos_token_id=2	,hidden_size=32	,intermediate_size=37	,layer_norm_eps=1e-0_5	,num_attention_heads=4	,num_hidden_layers=5	,pad_token_id=1	,vocab_size=1_000	,hidden_act="""gelu"""	,projection_dim=32	,)
          UpperCAmelCase							=       CLIPTextModel(lowercase__					)
          UpperCAmelCase							=       CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""	,local_files_only=lowercase__					)

          UpperCAmelCase							=       CLIPTextModelWithProjection(lowercase__					)
          UpperCAmelCase							=       CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""	,local_files_only=lowercase__					)

          UpperCAmelCase							=       {
              """unet""": unet,
              """scheduler""": scheduler,
              """vae""": vae,
              """text_encoder""": text_encoder,
              """tokenizer""": tokenizer,
              """text_encoder_2""": text_encoder_a,
              """tokenizer_2""": tokenizer_a,
              # "safety_checker": None,
              # "feature_extractor": None,
          }
          return components






    def 				_UpperCamelCase							( self	,A	,A=0					):







          if str(lowercase__					).startswith("""mps"""					):
                UpperCAmelCase							=       torch.manual_seed(lowercase__					)
          else:
                UpperCAmelCase							=       torch.Generator(device=lowercase__					).manual_seed(lowercase__					)
          UpperCAmelCase							=       {
              """prompt""": """A painting of a squirrel eating a burger""",
              """generator""": generator,
              """num_inference_steps""": 2,
              """guidance_scale""": 5.0,
              """output_type""": """numpy""",
          }
          return inputs






    def 				_UpperCamelCase							( self					):
          UpperCAmelCase							=       """cpu"""  # ensure determinism for the device-dependent torch.Generator
          UpperCAmelCase							=       self.get_dummy_components()
          UpperCAmelCase							=       StableDiffusionXLPipeline(**lowercase__					)
          UpperCAmelCase							=       sd_pipe.to(lowercase__					)
          sd_pipe.set_progress_bar_config(disable=lowercase__					)

          UpperCAmelCase							=       self.get_dummy_inputs(lowercase__					)
          UpperCAmelCase							=       sd_pipe(**lowercase__					).images
          UpperCAmelCase							=       image[0, -3:, -3:, -1]

          assert image.shape == (1, 64, 64, 3)
          UpperCAmelCase							=       np.array([0.5873, 0.6128, 0.4797, 0.5122, 0.5674, 0.4639, 0.5227, 0.5149, 0.4747]					)

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






    def 				_UpperCamelCase							( self					):
          UpperCAmelCase							=       self.get_dummy_components()
          UpperCAmelCase							=       StableDiffusionXLPipeline(**lowercase__					)
          UpperCAmelCase							=       sd_pipe.to(lowercase__					)
          UpperCAmelCase							=       sd_pipe.to(lowercase__					)
          sd_pipe.set_progress_bar_config(disable=lowercase__					)

          # forward without prompt embeds
          UpperCAmelCase							=       self.get_dummy_inputs(lowercase__					)
          UpperCAmelCase							=       3 * ["""this is a negative prompt"""]
          UpperCAmelCase							=       negative_prompt
          UpperCAmelCase							=       3 * [inputs["""prompt"""]]

          UpperCAmelCase							=       sd_pipe(**lowercase__					)
          UpperCAmelCase							=       output.images[0, -3:, -3:, -1]

          # forward with prompt embeds
          UpperCAmelCase							=       self.get_dummy_inputs(lowercase__					)
          UpperCAmelCase							=       3 * ["""this is a negative prompt"""]
          UpperCAmelCase							=       3 * [inputs.pop("""prompt"""					)]

          (
              (
              UpperCAmelCase    
          )			,					(
              UpperCAmelCase    
          )			,					(
              UpperCAmelCase    
          )			,					(
              UpperCAmelCase    
          )			,					    
          )							=       sd_pipe.encode_prompt(lowercase__	,negative_prompt=lowercase__					)

          UpperCAmelCase							=       sd_pipe(
              **lowercase__	,prompt_embeds=lowercase__	,negative_prompt_embeds=lowercase__	,pooled_prompt_embeds=lowercase__	,negative_pooled_prompt_embeds=lowercase__	,)
          UpperCAmelCase							=       output.images[0, -3:, -3:, -1]

          # make sure that it's equal
          assert np.abs(image_slice_a.flatten() - image_slice_a.flatten()					).max() < 1e-4






    def 				_UpperCamelCase							( self					):
          super().test_attention_slicing_forward_pass(expected_max_diff=3e-3					)






    def 				_UpperCamelCase							( self					):
          super().test_inference_batch_single_identical(expected_max_diff=3e-3					)







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






    def 				_UpperCamelCase							( self					):
          super().tearDown()
          gc.collect()
          torch.cuda.empty_cache()






    def 				_UpperCamelCase							( self	,A	,A="cpu"	,A=torch.floataa	,A=0					):
          UpperCAmelCase							=       torch.Generator(device=lowercase__					).manual_seed(lowercase__					)
          UpperCAmelCase							=       np.random.RandomState(lowercase__					).standard_normal((1, 4, 64, 64)					)
          UpperCAmelCase							=       torch.from_numpy(lowercase__					).to(device=lowercase__	,dtype=lowercase__					)
          UpperCAmelCase							=       {
              """prompt""": """a photograph of an astronaut riding a horse""",
              """latents""": latents,
              """generator""": generator,
              """num_inference_steps""": 3,
              """guidance_scale""": 7.5,
              """output_type""": """numpy""",
          }
          return inputs






    def 				_UpperCamelCase							( self					):
          UpperCAmelCase							=       DiffusionPipeline.from_pretrained("""stabilityai/stable-diffusion-2-base"""					)
          pipe.to(lowercase__					)
          pipe.set_progress_bar_config(disable=lowercase__					)

          UpperCAmelCase							=       self.get_inputs(lowercase__					)
          UpperCAmelCase							=       pipe(**lowercase__					).images
          UpperCAmelCase							=       image[0, -3:, -3:, -1].flatten()

          assert image.shape == (1, 512, 512, 3)
          UpperCAmelCase							=       np.array([0.49493, 0.47896, 0.40798, 0.54214, 0.53212, 0.48202, 0.47656, 0.46329, 0.48506]					)
          assert np.abs(image_slice - expected_slice					).max() < 7e-3





"""simple docstring"""




def   UpperCamelCase_  (		SCREAMING_SNAKE_CASE_			):
					if not isinstance(SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_			):
										SCREAMING_SNAKE_CASE				=	(
										    'operation can not be conducted on a object of type '
										    f'''{type(SCREAMING_SNAKE_CASE_			).__name__}'''
										)
										raise TypeError(SCREAMING_SNAKE_CASE_			)
					SCREAMING_SNAKE_CASE				=	''
					for _ in range(0,     3_2			):
										bit_string += str(number % 2			)
										SCREAMING_SNAKE_CASE				=	number >> 1
					return bit_string

def   UpperCamelCase_  (		SCREAMING_SNAKE_CASE_			):
					if number < 0:
										raise ValueError('the value of input must be positive'			)
					elif isinstance(SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_			):
										raise TypeError('Input value must be a \'int\' type'			)
					elif isinstance(SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_			):
										raise TypeError('\'<\' not supported between instances of \'str\' and \'int\''			)
					SCREAMING_SNAKE_CASE				=	0
					# iterator over [1 to 32],since we are dealing with 32 bit integer
					for _ in range(1,     3_3			):
										# left shift the bits by unity
										SCREAMING_SNAKE_CASE				=	result << 1
										# get the end bit
										SCREAMING_SNAKE_CASE				=	number % 2
										# right shift the bits by unity
										SCREAMING_SNAKE_CASE				=	number >> 1
										# add that bit to our ans
										SCREAMING_SNAKE_CASE				=	result | end_bit
					return get_reverse_bit_string(SCREAMING_SNAKE_CASE_			)


if __name__ == "__main__":
	import doctest

	doctest.testmod()
