

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     UpperCamelCase					(				self	:    int       ) ->			Tuple:
         """simple docstring"""





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

   @property
   def     UpperCamelCase					(				self	:    Optional[int]       ) ->			Optional[int]:
         """simple docstring"""





         A_							       =		1
         A_							       =		3
         A_							       =		(3_2, 3_2)

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

   @property
   def     UpperCamelCase					(				self	:    Union[str, Any]       ) ->			List[str]:
         """simple docstring"""





         torch.manual_seed(0       )
         A_							       =		UNetaDConditionModel(
             block_out_channels=(3_2, 6_4)			,						layers_per_block=2			,						sample_size=3_2			,						in_channels=4			,						out_channels=4			,						down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')			,						up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')			,						cross_attention_dim=3_2			,						)
         return model

   @property
   def     UpperCamelCase					(				self	:    Union[str, Any]       ) ->			Optional[int]:
         """simple docstring"""





         torch.manual_seed(0       )
         A_							       =		AutoencoderKL(
             block_out_channels=[3_2, 6_4]			,						in_channels=3			,						out_channels=3			,						down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''']			,						up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''']			,						latent_channels=4			,						)
         return model

   @property
   def     UpperCamelCase					(				self	:    Union[str, Any]       ) ->			int:
         """simple docstring"""





         torch.manual_seed(0       )
         A_							       =		RobertaSeriesConfig(
             hidden_size=3_2			,						project_dim=3_2			,						intermediate_size=3_7			,						layer_norm_eps=1e-05			,						num_attention_heads=4			,						num_hidden_layers=5			,						pad_token_id=1			,						vocab_size=5_0_0_6			,						)
         return RobertaSeriesModelWithTransformation(lowerCamelCase__       )

   @property
   def     UpperCamelCase					(				self	:    Any       ) ->			str:
         """simple docstring"""





         def extract(*lowerCamelCase__	:    Dict			,						**lowerCamelCase__	:    Any       ):

               class    _lowercase				:

                  def __init__(				self	:    int       ) ->			Union[str, Any]:
                        """simple docstring"""





                        A_							       =		torch.ones([0]       )





                  def     UpperCamelCase					(				self	:    Any			,						lowerCamelCase__	:    List[str]       ) ->			Any:
                        """simple docstring"""





                        self.pixel_values.to(lowerCamelCase__       )
                        return self



               return Out()

         return extract

   def     UpperCamelCase					(				self	:    List[str]       ) ->			str:
         """simple docstring"""





         A_							       =		'''cpu'''  # ensure determinism for the device-dependent torch.Generator
         A_							       =		self.dummy_cond_unet
         A_							       =		PNDMScheduler(skip_prk_steps=lowerCamelCase__       )
         A_							       =		self.dummy_vae
         A_							       =		self.dummy_text_encoder
         A_							       =		XLMRobertaTokenizer.from_pretrained('''hf-internal-testing/tiny-xlm-roberta'''       )
         A_							       =		7_7

         A_							       =		self.dummy_image.to(lowerCamelCase__       )
         A_							       =		init_image / 2 + 0.5

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

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

         A_							       =		output.images

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

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

         assert image.shape == (1, 3_2, 3_2, 3)
         A_							       =		np.array([0.4427, 0.3731, 0.4249, 0.4941, 0.4546, 0.4148, 0.4193, 0.4666, 0.4499]       )

         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     UpperCamelCase					(				self	:    Dict       ) ->			Any:
         """simple docstring"""





         A_							       =		self.dummy_cond_unet
         A_							       =		PNDMScheduler(skip_prk_steps=lowerCamelCase__       )
         A_							       =		self.dummy_vae
         A_							       =		self.dummy_text_encoder
         A_							       =		XLMRobertaTokenizer.from_pretrained('''hf-internal-testing/tiny-xlm-roberta'''       )
         A_							       =		7_7

         A_							       =		self.dummy_image.to(lowerCamelCase__       )

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

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

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

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





   @unittest.skipIf(torch_device != '''cuda'''			,						'''This test requires a GPU'''       )
   def     UpperCamelCase					(				self	:    int       ) ->			Optional[Any]:
         """simple docstring"""





         A_							       =		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
         A_							       =		init_image.resize((7_6_0, 5_0_4)       )

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

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

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

         A_							       =		image[2_5_5:2_5_8, 3_8_3:3_8_6, -1]

         assert image.shape == (5_0_4, 7_6_0, 3)
         A_							       =		np.array([0.9358, 0.9397, 0.9599, 0.9901, 1.0000, 1.0000, 0.9882, 1.0000, 1.0000]       )

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



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

   def     UpperCamelCase					(				self	:    List[str]       ) ->			Optional[Any]:
         """simple docstring"""





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





   def     UpperCamelCase					(				self	:    Optional[Any]       ) ->			Tuple:
         """simple docstring"""





         A_							       =		load_image(
             '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
             '''/img2img/sketch-mountains-input.jpg'''       )
         A_							       =		init_image.resize((7_6_8, 5_1_2)       )
         A_							       =		load_numpy(
             '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/img2img/fantasy_landscape_alt.npy'''       )

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

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

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

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








from __future__ import annotations







def 							_lowerCamelCase   (			SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE = None		,				SCREAMING_SNAKE_CASE = None   ):
      '''simple docstring'''







      if start is None:
            A_							       =		0

      if end is None:
            A_							       =		len(SCREAMING_SNAKE_CASE   ) - 1

      if start >= end:
            return

      A_							       =		(start + end) // 2

      slowsort(SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE   )
      slowsort(SCREAMING_SNAKE_CASE		,				mid + 1		,				SCREAMING_SNAKE_CASE   )

      if sequence[end] < sequence[mid]:
            A_       ,A_							       =		sequence[mid], sequence[end]

      slowsort(SCREAMING_SNAKE_CASE		,				SCREAMING_SNAKE_CASE		,				end - 1   )


if __name__ == "__main__":
      from doctest import testmod

      testmod()





