


'''simple docstring'''
import gc
import unittest

import numpy as np
import torch

from diffusers import StableDiffusionKDiffusionPipeline
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu


enable_full_determinism()






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






       def   UpperCamelCase						( self   )->      Optional[int]:
            # clean up the VRAM after each test
            super().tearDown()
            gc.collect()
            torch.cuda.empty_cache()






       def   UpperCamelCase						( self   )->      Union[str, Any]:
            _A				=							StableDiffusionKDiffusionPipeline.from_pretrained('CompVis/stable-diffusion-v1-4'   )
            _A				=							sd_pipe.to(_UpperCamelCase   )
            sd_pipe.set_progress_bar_config(disable=_UpperCamelCase   )

            sd_pipe.set_scheduler('sample_euler'   )

            _A				=							'A painting of a squirrel eating a burger'
            _A				=							torch.manual_seed(0   )
            _A				=							sd_pipe([prompt]			,     generator=_UpperCamelCase			,     guidance_scale=9.0			,     num_inference_steps=20			,     output_type='np'   )

            _A				=							output.images

            _A				=							image[0, -3:, -3:, -1]

            assert image.shape == (1, 512, 512, 3)
            _A				=							np.array([0.0447, 0.0492, 0.0468, 0.0408, 0.0383, 0.0408, 0.0354, 0.0380, 0.0339]   )

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






       def   UpperCamelCase						( self   )->      Optional[Any]:
            _A				=							StableDiffusionKDiffusionPipeline.from_pretrained('stabilityai/stable-diffusion-2-1-base'   )
            _A				=							sd_pipe.to(_UpperCamelCase   )
            sd_pipe.set_progress_bar_config(disable=_UpperCamelCase   )

            sd_pipe.set_scheduler('sample_euler'   )

            _A				=							'A painting of a squirrel eating a burger'
            _A				=							torch.manual_seed(0   )
            _A				=							sd_pipe([prompt]			,     generator=_UpperCamelCase			,     guidance_scale=9.0			,     num_inference_steps=20			,     output_type='np'   )

            _A				=							output.images

            _A				=							image[0, -3:, -3:, -1]

            assert image.shape == (1, 512, 512, 3)
            _A				=							np.array([0.1237, 0.1320, 0.1438, 0.1359, 0.1390, 0.1132, 0.1277, 0.1175, 0.1112]   )

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






       def   UpperCamelCase						( self   )->      Optional[int]:
            _A				=							StableDiffusionKDiffusionPipeline.from_pretrained('stabilityai/stable-diffusion-2-1-base'   )
            _A				=							sd_pipe.to(_UpperCamelCase   )
            sd_pipe.set_progress_bar_config(disable=_UpperCamelCase   )

            sd_pipe.set_scheduler('sample_dpmpp_2m'   )

            _A				=							'A painting of a squirrel eating a burger'
            _A				=							torch.manual_seed(0   )
            _A				=							sd_pipe(
                [prompt]			,     generator=_UpperCamelCase			,     guidance_scale=7.5			,     num_inference_steps=15			,     output_type='np'			,     use_karras_sigmas=_UpperCamelCase			,     )

            _A				=							output.images

            _A				=							image[0, -3:, -3:, -1]

            assert image.shape == (1, 512, 512, 3)
            _A				=							np.array(
                [0.1138_1689, 0.1211_2921, 0.138_9457, 0.1254_9606, 0.124_4964, 0.1083_1517, 0.1156_2866, 0.1086_7816, 0.1049_9048]   )

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









'''simple docstring'''
import colorsys

from PIL import Image  # type: ignore

def 					lowerCamelCase_ ( __UpperCamelCase					:       float							,    __UpperCamelCase					:       float							,    __UpperCamelCase					:       int		)					->	float:







     """simple docstring"""
     _A				=							x
     _A				=							y
     for step in range(__UpperCamelCase		):  # noqa: B007
          _A				=							a * a - b * b + x
          _A				=							2 * a * b + y
          _A				=							a_new

          # divergence happens for all complex number with an absolute value
          # greater than 4
          if a * a + b * b > 4:
               break
     return step / (max_step - 1)

def 					lowerCamelCase_ ( __UpperCamelCase					:       float		)					->	tuple:







     """simple docstring"""
     if distance == 1:
          return (0, 0, 0)
     else:
          return (2_5_5, 2_5_5, 2_5_5)

def 					lowerCamelCase_ ( __UpperCamelCase					:       float		)					->	tuple:







     """simple docstring"""
     if distance == 1:
          return (0, 0, 0)
     else:
          return tuple(round(i * 2_5_5		) for i in colorsys.hsv_to_rgb(__UpperCamelCase							,    1							,    1		)		)

def 					lowerCamelCase_ ( __UpperCamelCase					:       int = 8_0_0							,    __UpperCamelCase					:       int = 6_0_0							,    __UpperCamelCase					:       float = -0.6							,    __UpperCamelCase					:       float = 0							,    __UpperCamelCase					:       float = 3.2							,    __UpperCamelCase					:       int = 5_0							,    __UpperCamelCase					:       bool = True							,    )					->	Image.Image:







     """simple docstring"""
     _A				=							Image.new('RGB'							,    (image_width, image_height)		)
     _A				=							img.load()

     # loop through the image-coordinates
     for image_x in range(__UpperCamelCase		):
          for image_y in range(__UpperCamelCase		):
               # determine the figure-coordinates based on the image-coordinates
               _A				=							figure_width / image_width * image_height
               _A				=							figure_center_x + (image_x / image_width - 0.5) * figure_width
               _A				=							figure_center_y + (image_y / image_height - 0.5) * figure_height

               _A				=							get_distance(__UpperCamelCase							,    __UpperCamelCase							,    __UpperCamelCase		)

               # color the corresponding pixel based on the selected coloring-function
               if use_distance_color_coding:
                    _A				=							get_color_coded_rgb(__UpperCamelCase		)
               else:
                    _A				=							get_black_and_white_rgb(__UpperCamelCase		)

     return img


if __name__ == "__main__":
    import doctest

    doctest.testmod()

    # colored version, full figure
    lowerCAmelCase						=					get_image()

    # uncomment for colored version, different section, zoomed in
    # img = get_image(figure_center_x = -0.6, figure_center_y = -0.4,
    # figure_width = 0.8)

    # uncomment for black and white version, full figure
    # img = get_image(use_distance_color_coding = False)

    # uncomment to save the image
    # img.save("mandelbrot.png")

    img.show()





