






'''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      ):



				"""simple docstring"""



				def 					__magic_name__							(      self    :    Tuple):






											'''simple docstring'''







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



				def 					__magic_name__							(      self    :    int):






											'''simple docstring'''







											snake_case__	  =       StableDiffusionKDiffusionPipeline.from_pretrained("""CompVis/stable-diffusion-v1-4""")
											snake_case__	  =       sd_pipe.to(A_)
											sd_pipe.set_progress_bar_config(disable=A_)

											sd_pipe.set_scheduler("""sample_euler""")

											snake_case__	  =       """A painting of a squirrel eating a burger"""
											snake_case__	  =       torch.manual_seed(0)
											snake_case__	  =       sd_pipe([prompt]			,		generator=A_			,		guidance_scale=9.0			,		num_inference_steps=2_0			,		output_type="""np""")

											snake_case__	  =       output.images

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

											assert image.shape == (1, 5_1_2, 5_1_2, 3)
											snake_case__	  =       np.array([0.04_47, 0.04_92, 0.04_68, 0.04_08, 0.03_83, 0.04_08, 0.03_54, 0.03_80, 0.03_39])

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



				def 					__magic_name__							(      self    :    Optional[Any]):






											'''simple docstring'''







											snake_case__	  =       StableDiffusionKDiffusionPipeline.from_pretrained("""stabilityai/stable-diffusion-2-1-base""")
											snake_case__	  =       sd_pipe.to(A_)
											sd_pipe.set_progress_bar_config(disable=A_)

											sd_pipe.set_scheduler("""sample_euler""")

											snake_case__	  =       """A painting of a squirrel eating a burger"""
											snake_case__	  =       torch.manual_seed(0)
											snake_case__	  =       sd_pipe([prompt]			,		generator=A_			,		guidance_scale=9.0			,		num_inference_steps=2_0			,		output_type="""np""")

											snake_case__	  =       output.images

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

											assert image.shape == (1, 5_1_2, 5_1_2, 3)
											snake_case__	  =       np.array([0.12_37, 0.13_20, 0.14_38, 0.13_59, 0.13_90, 0.11_32, 0.12_77, 0.11_75, 0.11_12])

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



				def 					__magic_name__							(      self    :    List[str]):






											'''simple docstring'''







											snake_case__	  =       StableDiffusionKDiffusionPipeline.from_pretrained("""stabilityai/stable-diffusion-2-1-base""")
											snake_case__	  =       sd_pipe.to(A_)
											sd_pipe.set_progress_bar_config(disable=A_)

											sd_pipe.set_scheduler("""sample_dpmpp_2m""")

											snake_case__	  =       """A painting of a squirrel eating a burger"""
											snake_case__	  =       torch.manual_seed(0)
											snake_case__	  =       sd_pipe(
											    [prompt]			,		generator=A_			,		guidance_scale=7.5			,		num_inference_steps=1_5			,		output_type="""np"""			,		use_karras_sigmas=A_			,		)

											snake_case__	  =       output.images

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

											assert image.shape == (1, 5_1_2, 5_1_2, 3)
											snake_case__	  =       np.array(
											    [0.11_38_16_89, 0.12_11_29_21, 0.1_38_94_57, 0.12_54_96_06, 0.1_24_49_64, 0.10_83_15_17, 0.11_56_28_66, 0.10_86_78_16, 0.10_49_90_48])

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








import os
import time

import pytest

from datasets.utils.filelock import FileLock, Timeout

def _UpperCAmelCase   (	a						:	List[Any] ):
							snake_case__	  =       FileLock(str(tmpdir / """foo.lock""" ) )
							snake_case__	  =       FileLock(str(tmpdir / """foo.lock""" ) )
							snake_case__	  =       0.01
							with locka.acquire():
														with pytest.raises(a ):
																					snake_case__	  =       time.time()
																					locka.acquire(a )
																					assert time.time() - _start > timeout



def _UpperCAmelCase   (	a						:	str ):
							snake_case__	  =       """a""" * 1000 + """.lock"""
							snake_case__	  =       FileLock(str(tmpdir / filename ) )
							assert locka._lock_file.endswith(""".lock""" )
							assert not locka._lock_file.endswith(a )
							assert len(os.path.basename(locka._lock_file ) ) <= 255
							snake_case__	  =       FileLock(tmpdir / filename )
							with locka.acquire():
														with pytest.raises(a ):
																					locka.acquire(0 )
