

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  lowercase				(       unittest.TestCase			):




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




				@property
				def     a							(					self       ):
											snake_case_							=    1
											snake_case_							=    3
											snake_case_							=    (32, 32)

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




				@property
				def     a							(					self       ):
											torch.manual_seed(0       )
											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       ):
											torch.manual_seed(0       )
											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       ):
											torch.manual_seed(0       )
											snake_case_							=    RobertaSeriesConfig(
											    hidden_size=32      ,   project_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=5006      ,   )
											return RobertaSeriesModelWithTransformation(__UpperCAmelCase       )




				@property
				def     a							(					self       ):
											def extract(*snake_case      ,   **snake_case       ):







																		class  lowercase				:




																						def __init__(					self       ):
																													snake_case_							=    torch.ones([0]       )




																						def     a							(					self      ,   snake_case       ):
																													self.pixel_values.to(__UpperCAmelCase       )
																													return self



																		return Out()

											return extract




				def     a							(					self       ):
											snake_case_							=    """cpu"""  # ensure determinism for the device-dependent torch.Generator
											snake_case_							=    self.dummy_cond_unet
											snake_case_							=    PNDMScheduler(skip_prk_steps=__UpperCAmelCase       )
											snake_case_							=    self.dummy_vae
											snake_case_							=    self.dummy_text_encoder
											snake_case_							=    XLMRobertaTokenizer.from_pretrained('hf-internal-testing/tiny-xlm-roberta'       )
											snake_case_							=    77

											snake_case_							=    self.dummy_image.to(__UpperCAmelCase       )
											snake_case_							=    init_image / 2 + 0.5

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

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

											snake_case_							=    output.images

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

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

											assert image.shape == (1, 32, 32, 3)
											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       ):
											snake_case_							=    self.dummy_cond_unet
											snake_case_							=    PNDMScheduler(skip_prk_steps=__UpperCAmelCase       )
											snake_case_							=    self.dummy_vae
											snake_case_							=    self.dummy_text_encoder
											snake_case_							=    XLMRobertaTokenizer.from_pretrained('hf-internal-testing/tiny-xlm-roberta'       )
											snake_case_							=    77

											snake_case_							=    self.dummy_image.to(__UpperCAmelCase       )

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

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

											snake_case_							=    """A painting of a squirrel eating a burger"""
											snake_case_							=    torch.manual_seed(0       )
											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       ):
											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
											snake_case_							=    init_image.resize((760, 504)       )

											snake_case_							=    """BAAI/AltDiffusion"""
											snake_case_							=    AltDiffusionImgaImgPipeline.from_pretrained(
											    __UpperCAmelCase      ,   safety_checker=__UpperCAmelCase      ,   )
											pipe.to(__UpperCAmelCase       )
											pipe.set_progress_bar_config(disable=__UpperCAmelCase       )
											pipe.enable_attention_slicing()

											snake_case_							=    """A fantasy landscape, trending on artstation"""

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

											snake_case_							=    image[255:258, 383:386, -1]

											assert image.shape == (504, 760, 3)
											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  lowercase				(       unittest.TestCase			):




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




				def     a							(					self       ):
											snake_case_							=    load_image(
											    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
											    '/img2img/sketch-mountains-input.jpg'       )
											snake_case_							=    init_image.resize((768, 512)       )
											snake_case_							=    load_numpy(
											    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/img2img/fantasy_landscape_alt.npy'       )

											snake_case_							=    """BAAI/AltDiffusion"""
											snake_case_							=    AltDiffusionImgaImgPipeline.from_pretrained(
											    __UpperCAmelCase      ,   safety_checker=__UpperCAmelCase      ,   )
											pipe.to(__UpperCAmelCase       )
											pipe.set_progress_bar_config(disable=__UpperCAmelCase       )
											pipe.enable_attention_slicing()

											snake_case_							=    """A fantasy landscape, trending on artstation"""

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

											assert image.shape == (512, 768, 3)
											# img2img is flaky across GPUs even in fp32, so using MAE here
											assert np.abs(expected_image - image       ).max() < 1e-2









'''simple docstring'''





def    _SCREAMING_SNAKE_CASE  (       UpperCamelCase = "The quick brown fox jumps over the lazy dog"							,    ):



    """simple docstring"""





    lowerCAmelCase__ :  str							      =					set()

    # Replace all the whitespace in our sentence
    lowerCAmelCase__ :  Tuple							      =					input_str.replace(""" """							,    """"""			)
    for alpha in input_str:
        if "a" <= alpha.lower() <= "z":
            frequency.add(alpha.lower()			)
    return len(UpperCamelCase			) == 26
def    _SCREAMING_SNAKE_CASE  (       UpperCamelCase = "The quick brown fox jumps over the lazy dog"							,    ):



    """simple docstring"""





    lowerCAmelCase__ :  Any							      =					[False] * 26
    for char in input_str:
        if char.islower():
            lowerCAmelCase__ :  Optional[Any]							      =					True
        elif char.isupper():
            lowerCAmelCase__ :  Any							      =					True
    return all(UpperCamelCase			)
def    _SCREAMING_SNAKE_CASE  (       UpperCamelCase = "The quick brown fox jumps over the lazy dog"							,    ):



    """simple docstring"""





    return len({char for char in input_str.lower() if char.isalpha()}			) == 26
def    _SCREAMING_SNAKE_CASE  (       ):



    """simple docstring"""





    from timeit import timeit

    lowerCAmelCase__ :  Union[str, Any]							      =					"""from __main__ import is_pangram, is_pangram_faster, is_pangram_fastest"""
    print(timeit("""is_pangram()"""							,    setup=UpperCamelCase			)			)
    print(timeit("""is_pangram_faster()"""							,    setup=UpperCamelCase			)			)
    print(timeit("""is_pangram_fastest()"""							,    setup=UpperCamelCase			)			)
    # 5.348480500048026, 2.6477354579837993, 1.8470395830227062
    # 5.036091582966037, 2.644472333951853,  1.8869528750656173


if __name__ == "__main__":
 import doctest

 doctest.testmod()
 benchmark()


