

'''simple docstring'''

import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image
from transformers import CLIPImageProcessor, CLIPVisionConfig, CLIPVisionModelWithProjection

from diffusers import (
    AutoencoderKL,
    DPMSolverMultistepScheduler,
    PNDMScheduler,
    StableDiffusionImageVariationPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import floats_tensor, load_image, load_numpy, nightly, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import IMAGE_VARIATION_BATCH_PARAMS, IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()


class   lowerCAmelCase     (      A   ,			A   ,			A   ,			unittest.TestCase   ):
       lowerCAmelCase_		= StableDiffusionImageVariationPipeline
       lowerCAmelCase_		= IMAGE_VARIATION_PARAMS
       lowerCAmelCase_		= IMAGE_VARIATION_BATCH_PARAMS
       lowerCAmelCase_		= frozenset([]   )
       # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
       lowerCAmelCase_		= frozenset([]   )







       def 			snake_case   (							self			: List[Any]      ):







            """simple docstring"""







            torch.manual_seed(0      )
            __lowercase					=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						,      )
            __lowercase					=PNDMScheduler(skip_prk_steps=__lowercase      )
            torch.manual_seed(0      )
            __lowercase					=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						,      )
            torch.manual_seed(0      )
            __lowercase					=CLIPVisionConfig(
                hidden_size=32						,      projection_dim=32						,      intermediate_size=37						,      layer_norm_eps=1E-05						,      num_attention_heads=4						,      num_hidden_layers=5						,      image_size=32						,      patch_size=4						,      )
            __lowercase					=CLIPVisionModelWithProjection(__lowercase      )
            __lowercase					=CLIPImageProcessor(crop_size=32						,      size=32      )

            __lowercase					={
                'unet': unet,
                'scheduler': scheduler,
                'vae': vae,
                'image_encoder': image_encoder,
                'feature_extractor': feature_extractor,
                'safety_checker': None,
            }
            return components







       def 			snake_case   (							self			: List[str]						,      __lowercase			: List[Any]						,      __lowercase			: Tuple=0      ):







            """simple docstring"""







            __lowercase					=floats_tensor((1, 3, 32, 32)						,      rng=random.Random(__lowercase      )      )
            __lowercase					=image.cpu().permute(0						,      2						,      3						,      1      )[0]
            __lowercase					=Image.fromarray(np.uinta(__lowercase      )      ).convert('RGB'      ).resize((32, 32)      )
            if str(__lowercase      ).startswith('mps'      ):
                 __lowercase					=torch.manual_seed(__lowercase      )
            else:
                 __lowercase					=torch.Generator(device=__lowercase      ).manual_seed(__lowercase      )
            __lowercase					={
                'image': image,
                'generator': generator,
                'num_inference_steps': 2,
                'guidance_scale': 6.0,
                'output_type': 'numpy',
            }
            return inputs







       def 			snake_case   (							self			: Optional[Any]      ):







            """simple docstring"""







            __lowercase					='cpu'  # ensure determinism for the device-dependent torch.Generator
            __lowercase					=self.get_dummy_components()
            __lowercase					=StableDiffusionImageVariationPipeline(**__lowercase      )
            __lowercase					=sd_pipe.to(__lowercase      )
            sd_pipe.set_progress_bar_config(disable=__lowercase      )

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

            assert image.shape == (1, 64, 64, 3)
            __lowercase					=np.array([0.5_2_3_9, 0.5_7_2_3, 0.4_7_9_6, 0.5_0_4_9, 0.5_5_5_0, 0.4_6_8_5, 0.5_3_2_9, 0.4_8_9_1, 0.4_9_2_1]      )

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







       def 			snake_case   (							self			: int      ):







            """simple docstring"""







            __lowercase					='cpu'  # ensure determinism for the device-dependent torch.Generator
            __lowercase					=self.get_dummy_components()
            __lowercase					=StableDiffusionImageVariationPipeline(**__lowercase      )
            __lowercase					=sd_pipe.to(__lowercase      )
            sd_pipe.set_progress_bar_config(disable=__lowercase      )

            __lowercase					=self.get_dummy_inputs(__lowercase      )
            __lowercase					=2 * [inputs['image']]
            __lowercase					=sd_pipe(**__lowercase      )

            __lowercase					=output.images

            __lowercase					=image[-1, -3:, -3:, -1]

            assert image.shape == (2, 64, 64, 3)
            __lowercase					=np.array([0.6_8_9_2, 0.5_6_3_7, 0.5_8_3_6, 0.5_7_7_1, 0.6_2_5_4, 0.6_4_0_9, 0.5_5_8_0, 0.5_5_6_9, 0.5_2_8_9]      )

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







       def 			snake_case   (							self			: Any      ):







            """simple docstring"""







            super().test_inference_batch_single_identical(expected_max_diff=3E-3      )






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







       def 			snake_case   (							self			: Dict      ):







            """simple docstring"""







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







       def 			snake_case   (							self			: Dict						,      __lowercase			: Any						,      __lowercase			: List[Any]="cpu"						,      __lowercase			: List[Any]=torch.floataa						,      __lowercase			: List[str]=0      ):







            """simple docstring"""







            __lowercase					=torch.Generator(device=__lowercase      ).manual_seed(__lowercase      )
            __lowercase					=load_image(
                'https://huggingface.co/datasets/diffusers/test-arrays/resolve/main'
                '/stable_diffusion_imgvar/input_image_vermeer.png'      )
            __lowercase					=np.random.RandomState(__lowercase      ).standard_normal((1, 4, 64, 64)      )
            __lowercase					=torch.from_numpy(__lowercase      ).to(device=__lowercase						,      dtype=__lowercase      )
            __lowercase					={
                'image': init_image,
                'latents': latents,
                'generator': generator,
                'num_inference_steps': 3,
                'guidance_scale': 7.5,
                'output_type': 'numpy',
            }
            return inputs







       def 			snake_case   (							self			: str      ):







            """simple docstring"""







            __lowercase					=StableDiffusionImageVariationPipeline.from_pretrained(
                'lambdalabs/sd-image-variations-diffusers'						,      safety_checker=__lowercase      )
            __lowercase					=sd_pipe.to(__lowercase      )
            sd_pipe.set_progress_bar_config(disable=__lowercase      )

            __lowercase					=self.get_inputs(__lowercase      )
            __lowercase					=sd_pipe(**__lowercase      ).images
            __lowercase					=image[0, -3:, -3:, -1].flatten()

            assert image.shape == (1, 512, 512, 3)
            __lowercase					=np.array([0.8_4_4_9_1, 0.9_0_7_8_9, 0.7_5_7_0_8, 0.7_8_7_3_4, 0.8_3_4_8_5, 0.7_0_0_9_9, 0.6_6_9_3_8, 0.6_8_7_2_7, 0.6_1_3_7_9]      )
            assert np.abs(image_slice - expected_slice      ).max() < 6E-3







       def 			snake_case   (							self			: Union[str, Any]      ):







            """simple docstring"""







            __lowercase					=0

            def callback_fn(__lowercase			: int						,      __lowercase			: int						,      __lowercase			: torch.FloatTensor      ) -> None:
                 __lowercase					=True
                 nonlocal number_of_steps
                 number_of_steps += 1
                 if step == 1:
                      __lowercase					=latents.detach().cpu().numpy()
                      assert latents.shape == (1, 4, 64, 64)
                      __lowercase					=latents[0, -3:, -3:, -1]
                      __lowercase					=np.array(
                          [-0.1_6_2_1, 0.2_8_3_7, -0.7_9_7_9, -0.1_2_2_1, -1.3_0_5_7, 0.7_6_8_1, -2.1_1_9_1, 0.0_4_6_4, 1.6_3_0_9]      )

                      assert np.abs(latents_slice.flatten() - expected_slice      ).max() < 5E-2
                 elif step == 2:
                      __lowercase					=latents.detach().cpu().numpy()
                      assert latents.shape == (1, 4, 64, 64)
                      __lowercase					=latents[0, -3:, -3:, -1]
                      __lowercase					=np.array([0.6_2_9_9, 1.7_5_0_0, 1.1_9_9_2, -2.1_5_8_2, -1.8_9_9_4, 0.7_3_3_4, -0.7_0_9_0, 1.0_1_3_7, 1.5_2_7_3]      )

                      assert np.abs(latents_slice.flatten() - expected_slice      ).max() < 5E-2

            __lowercase					=False

            __lowercase					=StableDiffusionImageVariationPipeline.from_pretrained(
                'fusing/sd-image-variations-diffusers'						,      safety_checker=__lowercase						,      torch_dtype=torch.floataa						,      )
            pipe.to(__lowercase      )
            pipe.set_progress_bar_config(disable=__lowercase      )
            pipe.enable_attention_slicing()

            __lowercase					=self.get_inputs(__lowercase						,      dtype=torch.floataa      )
            pipe(**__lowercase						,      callback=__lowercase						,      callback_steps=1      )
            assert callback_fn.has_been_called
            assert number_of_steps == inputs["num_inference_steps"]







       def 			snake_case   (							self			: List[str]      ):







            """simple docstring"""







            torch.cuda.empty_cache()
            torch.cuda.reset_max_memory_allocated()
            torch.cuda.reset_peak_memory_stats()

            __lowercase					='fusing/sd-image-variations-diffusers'
            __lowercase					=StableDiffusionImageVariationPipeline.from_pretrained(
                __lowercase						,      safety_checker=__lowercase						,      torch_dtype=torch.floataa      )
            __lowercase					=pipe.to(__lowercase      )
            pipe.set_progress_bar_config(disable=__lowercase      )
            pipe.enable_attention_slicing(1      )
            pipe.enable_sequential_cpu_offload()

            __lowercase					=self.get_inputs(__lowercase						,      dtype=torch.floataa      )
            __lowercase					=pipe(**__lowercase      )

            __lowercase					=torch.cuda.max_memory_allocated()
            # make sure that less than 2.6 GB is allocated
            assert mem_bytes < 2.6 * 10**9






@nightly
@require_torch_gpu
class   lowerCAmelCase     (      unittest.TestCase   ):







       def 			snake_case   (							self			: Union[str, Any]      ):







            """simple docstring"""







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







       def 			snake_case   (							self			: List[str]						,      __lowercase			: Union[str, Any]						,      __lowercase			: Optional[int]="cpu"						,      __lowercase			: Any=torch.floataa						,      __lowercase			: List[str]=0      ):







            """simple docstring"""







            __lowercase					=torch.Generator(device=__lowercase      ).manual_seed(__lowercase      )
            __lowercase					=load_image(
                'https://huggingface.co/datasets/diffusers/test-arrays/resolve/main'
                '/stable_diffusion_imgvar/input_image_vermeer.png'      )
            __lowercase					=np.random.RandomState(__lowercase      ).standard_normal((1, 4, 64, 64)      )
            __lowercase					=torch.from_numpy(__lowercase      ).to(device=__lowercase						,      dtype=__lowercase      )
            __lowercase					={
                'image': init_image,
                'latents': latents,
                'generator': generator,
                'num_inference_steps': 50,
                'guidance_scale': 7.5,
                'output_type': 'numpy',
            }
            return inputs







       def 			snake_case   (							self			: str      ):







            """simple docstring"""







            __lowercase					=StableDiffusionImageVariationPipeline.from_pretrained('fusing/sd-image-variations-diffusers'      )
            sd_pipe.to(__lowercase      )
            sd_pipe.set_progress_bar_config(disable=__lowercase      )

            __lowercase					=self.get_inputs(__lowercase      )
            __lowercase					=sd_pipe(**__lowercase      ).images[0]

            __lowercase					=load_numpy(
                'https://huggingface.co/datasets/diffusers/test-arrays/resolve/main'
                '/stable_diffusion_imgvar/lambdalabs_variations_pndm.npy'      )
            __lowercase					=np.abs(expected_image - image      ).max()
            assert max_diff < 1E-3







       def 			snake_case   (							self			: Any      ):







            """simple docstring"""







            __lowercase					=StableDiffusionImageVariationPipeline.from_pretrained('fusing/sd-image-variations-diffusers'      )
            __lowercase					=DPMSolverMultistepScheduler.from_config(sd_pipe.scheduler.config      )
            sd_pipe.to(__lowercase      )
            sd_pipe.set_progress_bar_config(disable=__lowercase      )

            __lowercase					=self.get_inputs(__lowercase      )
            __lowercase					=25
            __lowercase					=sd_pipe(**__lowercase      ).images[0]

            __lowercase					=load_numpy(
                'https://huggingface.co/datasets/diffusers/test-arrays/resolve/main'
                '/stable_diffusion_imgvar/lambdalabs_variations_dpm_multi.npy'      )
            __lowercase					=np.abs(expected_image - image      ).max()
            assert max_diff < 1E-3





'''simple docstring'''

from __future__ import annotations

def 				__UpperCamelCase							(	lowercase__						:  list[int | float],					lowercase__						:  int,					lowercase__						:  int ):






     '''simple docstring'''





     if len(lowercase__ ) == 0:
          raise ValueError('find_min() arg is an empty sequence' )
     if (
         left >= len(lowercase__ )
         or left < -len(lowercase__ )
         or right >= len(lowercase__ )
         or right < -len(lowercase__ )
     ):
          raise IndexError('list index out of range' )
     if left == right:
          return nums[left]
     __lowercase					=(left + right) >> 1  # the middle
     __lowercase					=find_min(lowercase__,					lowercase__,					lowercase__ )  # find min in range[left, mid]
     __lowercase					=find_min(lowercase__,					mid + 1,					lowercase__ )  # find min in range[mid + 1, right]

     return left_min if left_min <= right_min else right_min


if __name__ == "__main__":
       import doctest

       doctest.testmod(verbose=True)


