




'''simple docstring'''





import gc
import random
import unittest

import numpy as np
import torch
from transformers import XLMRobertaTokenizer

from diffusers import (
    AltDiffusionImgaImgPipeline,
    AutoencoderKL,
    PNDMScheduler,
    UNetaDConditionModel,
)
from diffusers.image_processor import VaeImageProcessor
from diffusers.pipelines.alt_diffusion.modeling_roberta_series import (
    RobertaSeriesConfig,
    RobertaSeriesModelWithTransformation,
)
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu


enable_full_determinism()






class  __magic_name__						(  unittest.TestCase):
				'''simple docstring'''







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


				@property
				def     _A							(							self:   Any		):
											SCREAMING_SNAKE_CASE_   	=    1
											SCREAMING_SNAKE_CASE_   	=    3
											SCREAMING_SNAKE_CASE_   	=    (32, 32)

											SCREAMING_SNAKE_CASE_   	=    floats_tensor((batch_size, num_channels) + sizes		,					rng=random.Random(0		)		).to(__UpperCamelCase		)
											return image


				@property
				def     _A							(							self:   Optional[Any]		):
											torch.manual_seed(0		)
											SCREAMING_SNAKE_CASE_   	=    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''')		,					cross_attention_dim=32		,					)
											return model


				@property
				def     _A							(							self:   Optional[Any]		):
											torch.manual_seed(0		)
											SCREAMING_SNAKE_CASE_   	=    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		,					)
											return model


				@property
				def     _A							(							self:   List[Any]		):
											torch.manual_seed(0		)
											SCREAMING_SNAKE_CASE_   	=    RobertaSeriesConfig(
											    hidden_size=32		,					project_dim=32		,					intermediate_size=37		,					layer_norm_eps=1E-05		,					num_attention_heads=4		,					num_hidden_layers=5		,					pad_token_id=1		,					vocab_size=50_06		,					)
											return RobertaSeriesModelWithTransformation(__UpperCamelCase		)


				@property
				def     _A							(							self:   Tuple		):


											def extract(*_lowerCamelCase:   str		,					**_lowerCamelCase:   Optional[Any]		):






																		class  __magic_name__						:
																						'''simple docstring'''







																						def __init__(							self:   List[str]		):
																													SCREAMING_SNAKE_CASE_   	=    torch.ones([0]		)





																						def     _A							(							self:   Optional[Any]		,					_lowerCamelCase:   Tuple		):
																													self.pixel_values.to(__UpperCamelCase		)
																													return self






																		return Out()

											return extract


				def     _A							(							self:   Optional[Any]		):
											SCREAMING_SNAKE_CASE_   	=    '''cpu'''  # ensure determinism for the device-dependent torch.Generator
											SCREAMING_SNAKE_CASE_   	=    self.dummy_cond_unet
											SCREAMING_SNAKE_CASE_   	=    PNDMScheduler(skip_prk_steps=__UpperCamelCase		)
											SCREAMING_SNAKE_CASE_   	=    self.dummy_vae
											SCREAMING_SNAKE_CASE_   	=    self.dummy_text_encoder
											SCREAMING_SNAKE_CASE_   	=    XLMRobertaTokenizer.from_pretrained('''hf-internal-testing/tiny-xlm-roberta'''		)
											SCREAMING_SNAKE_CASE_   	=    77

											SCREAMING_SNAKE_CASE_   	=    self.dummy_image.to(__UpperCamelCase		)
											SCREAMING_SNAKE_CASE_   	=    init_image / 2 + 0.5

											# make sure here that pndm scheduler skips prk
											SCREAMING_SNAKE_CASE_   	=    AltDiffusionImgaImgPipeline(
											    unet=__UpperCamelCase		,					scheduler=__UpperCamelCase		,					vae=__UpperCamelCase		,					text_encoder=__UpperCamelCase		,					tokenizer=__UpperCamelCase		,					safety_checker=__UpperCamelCase		,					feature_extractor=self.dummy_extractor		,					)
											SCREAMING_SNAKE_CASE_   	=    VaeImageProcessor(vae_scale_factor=alt_pipe.vae_scale_factor		,					do_normalize=__UpperCamelCase		)
											SCREAMING_SNAKE_CASE_   	=    alt_pipe.to(__UpperCamelCase		)
											alt_pipe.set_progress_bar_config(disable=__UpperCamelCase		)

											SCREAMING_SNAKE_CASE_   	=    '''A painting of a squirrel eating a burger'''
											SCREAMING_SNAKE_CASE_   	=    torch.Generator(device=__UpperCamelCase		).manual_seed(0		)
											SCREAMING_SNAKE_CASE_   	=    alt_pipe(
											    [prompt]		,					generator=__UpperCamelCase		,					guidance_scale=6.0		,					num_inference_steps=2		,					output_type='''np'''		,					image=__UpperCamelCase		,					)

											SCREAMING_SNAKE_CASE_   	=    output.images

											SCREAMING_SNAKE_CASE_   	=    torch.Generator(device=__UpperCamelCase		).manual_seed(0		)
											SCREAMING_SNAKE_CASE_   	=    alt_pipe(
											    [prompt]		,					generator=__UpperCamelCase		,					guidance_scale=6.0		,					num_inference_steps=2		,					output_type='''np'''		,					image=__UpperCamelCase		,					return_dict=__UpperCamelCase		,					)[0]

											SCREAMING_SNAKE_CASE_   	=    image[0, -3:, -3:, -1]
											SCREAMING_SNAKE_CASE_   	=    image_from_tuple[0, -3:, -3:, -1]

											assert image.shape == (1, 32, 32, 3)
											SCREAMING_SNAKE_CASE_   	=    np.array([0.44_27, 0.37_31, 0.42_49, 0.49_41, 0.45_46, 0.41_48, 0.41_93, 0.46_66, 0.44_99]		)

											assert np.abs(image_slice.flatten() - expected_slice		).max() < 5E-3
											assert np.abs(image_from_tuple_slice.flatten() - expected_slice		).max() < 5E-3


				@unittest.skipIf(torch_device != '''cuda'''		,					'''This test requires a GPU'''		)
				def     _A							(							self:   List[str]		):
											SCREAMING_SNAKE_CASE_   	=    self.dummy_cond_unet
											SCREAMING_SNAKE_CASE_   	=    PNDMScheduler(skip_prk_steps=__UpperCamelCase		)
											SCREAMING_SNAKE_CASE_   	=    self.dummy_vae
											SCREAMING_SNAKE_CASE_   	=    self.dummy_text_encoder
											SCREAMING_SNAKE_CASE_   	=    XLMRobertaTokenizer.from_pretrained('''hf-internal-testing/tiny-xlm-roberta'''		)
											SCREAMING_SNAKE_CASE_   	=    77

											SCREAMING_SNAKE_CASE_   	=    self.dummy_image.to(__UpperCamelCase		)

											# put models in fp16
											SCREAMING_SNAKE_CASE_   	=    unet.half()
											SCREAMING_SNAKE_CASE_   	=    vae.half()
											SCREAMING_SNAKE_CASE_   	=    bert.half()

											# make sure here that pndm scheduler skips prk
											SCREAMING_SNAKE_CASE_   	=    AltDiffusionImgaImgPipeline(
											    unet=__UpperCamelCase		,					scheduler=__UpperCamelCase		,					vae=__UpperCamelCase		,					text_encoder=__UpperCamelCase		,					tokenizer=__UpperCamelCase		,					safety_checker=__UpperCamelCase		,					feature_extractor=self.dummy_extractor		,					)
											SCREAMING_SNAKE_CASE_   	=    VaeImageProcessor(vae_scale_factor=alt_pipe.vae_scale_factor		,					do_normalize=__UpperCamelCase		)
											SCREAMING_SNAKE_CASE_   	=    alt_pipe.to(__UpperCamelCase		)
											alt_pipe.set_progress_bar_config(disable=__UpperCamelCase		)

											SCREAMING_SNAKE_CASE_   	=    '''A painting of a squirrel eating a burger'''
											SCREAMING_SNAKE_CASE_   	=    torch.manual_seed(0		)
											SCREAMING_SNAKE_CASE_   	=    alt_pipe(
											    [prompt]		,					generator=__UpperCamelCase		,					num_inference_steps=2		,					output_type='''np'''		,					image=__UpperCamelCase		,					).images

											assert image.shape == (1, 32, 32, 3)





				@unittest.skipIf(torch_device != '''cuda'''		,					'''This test requires a GPU'''		)
				def     _A							(							self:   int		):
											SCREAMING_SNAKE_CASE_   	=    load_image(
											    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
											    '''/img2img/sketch-mountains-input.jpg'''		)
											# resize to resolution that is divisible by 8 but not 16 or 32
											SCREAMING_SNAKE_CASE_   	=    init_image.resize((7_60, 5_04)		)

											SCREAMING_SNAKE_CASE_   	=    '''BAAI/AltDiffusion'''
											SCREAMING_SNAKE_CASE_   	=    AltDiffusionImgaImgPipeline.from_pretrained(
											    __UpperCamelCase		,					safety_checker=__UpperCamelCase		,					)
											pipe.to(__UpperCamelCase		)
											pipe.set_progress_bar_config(disable=__UpperCamelCase		)
											pipe.enable_attention_slicing()

											SCREAMING_SNAKE_CASE_   	=    '''A fantasy landscape, trending on artstation'''

											SCREAMING_SNAKE_CASE_   	=    torch.manual_seed(0		)
											SCREAMING_SNAKE_CASE_   	=    pipe(
											    prompt=__UpperCamelCase		,					image=__UpperCamelCase		,					strength=0.75		,					guidance_scale=7.5		,					generator=__UpperCamelCase		,					output_type='''np'''		,					)
											SCREAMING_SNAKE_CASE_   	=    output.images[0]

											SCREAMING_SNAKE_CASE_   	=    image[2_55:2_58, 3_83:3_86, -1]

											assert image.shape == (5_04, 7_60, 3)
											SCREAMING_SNAKE_CASE_   	=    np.array([0.93_58, 0.93_97, 0.95_99, 0.99_01, 1.00_00, 1.00_00, 0.98_82, 1.00_00, 1.00_00]		)

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






@slow
@require_torch_gpu
class  __magic_name__						(  unittest.TestCase):
				'''simple docstring'''







				def     _A							(							self:   List[str]		):
											super().tearDown()
											gc.collect()
											torch.cuda.empty_cache()





				def     _A							(							self:   Optional[int]		):
											SCREAMING_SNAKE_CASE_   	=    load_image(
											    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
											    '''/img2img/sketch-mountains-input.jpg'''		)
											SCREAMING_SNAKE_CASE_   	=    init_image.resize((7_68, 5_12)		)
											SCREAMING_SNAKE_CASE_   	=    load_numpy(
											    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/img2img/fantasy_landscape_alt.npy'''		)

											SCREAMING_SNAKE_CASE_   	=    '''BAAI/AltDiffusion'''
											SCREAMING_SNAKE_CASE_   	=    AltDiffusionImgaImgPipeline.from_pretrained(
											    __UpperCamelCase		,					safety_checker=__UpperCamelCase		,					)
											pipe.to(__UpperCamelCase		)
											pipe.set_progress_bar_config(disable=__UpperCamelCase		)
											pipe.enable_attention_slicing()

											SCREAMING_SNAKE_CASE_   	=    '''A fantasy landscape, trending on artstation'''

											SCREAMING_SNAKE_CASE_   	=    torch.manual_seed(0		)
											SCREAMING_SNAKE_CASE_   	=    pipe(
											    prompt=__UpperCamelCase		,					image=__UpperCamelCase		,					strength=0.75		,					guidance_scale=7.5		,					generator=__UpperCamelCase		,					output_type='''np'''		,					)
											SCREAMING_SNAKE_CASE_   	=    output.images[0]

											assert image.shape == (5_12, 7_68, 3)
											# img2img is flaky across GPUs even in fp32, so using MAE here
											assert np.abs(expected_image - image		).max() < 1E-2








import requests

def 			a   (_lowerCAmelCase  ,    _lowerCAmelCase     ):
							SCREAMING_SNAKE_CASE_   	=    {'''Content-Type''': '''application/json'''}
							SCREAMING_SNAKE_CASE_   	=    requests.post(_lowerCAmelCase  ,    json={'''text''': message_body}  ,    headers=_lowerCAmelCase     )
							if response.status_code != 2_0_0:
														SCREAMING_SNAKE_CASE_   	=    (
														    '''Request to slack returned an error '''
														    F"{response.status_code}, the response is:\n{response.text}"
														)
														raise ValueError(_lowerCAmelCase     )


if __name__ == "__main__":
			# Set the slack url to the one provided by Slack when you create the webhook at
			# https://my.slack.com/services/new/incoming-webhook/
			send_slack_message("""<YOUR MESSAGE BODY>""", """<SLACK CHANNEL URL>""")


