





import gc
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    StableDiffusionSAGPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()

class 							__SCREAMING_SNAKE_CASE       (  _a ,		_a ,		unittest.TestCase							):
							snake_case  :   Any      =							StableDiffusionSAGPipeline
							snake_case  :   List[Any]      =							TEXT_TO_IMAGE_PARAMS
							snake_case  :   Optional[Any]      =							TEXT_TO_IMAGE_BATCH_PARAMS
							snake_case  :   Tuple      =							TEXT_TO_IMAGE_IMAGE_PARAMS
							snake_case  :   str      =							TEXT_TO_IMAGE_IMAGE_PARAMS
							snake_case  :   List[str]      =							False






							def 					_lowerCamelCase		(    self	):
														torch.manual_seed(0	)
														UpperCamelCase__					  =      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	,			)
														UpperCamelCase__					  =      DDIMScheduler(
														    beta_start=0.0_0085	,			beta_end=0.012	,			beta_schedule="""scaled_linear"""	,			clip_sample=__lowerCAmelCase	,			set_alpha_to_one=__lowerCAmelCase	,			)
														torch.manual_seed(0	)
														UpperCamelCase__					  =      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	)
														UpperCamelCase__					  =      CLIPTextConfig(
														    bos_token_id=0	,			eos_token_id=2	,			hidden_size=32	,			intermediate_size=37	,			layer_norm_eps=1E-05	,			num_attention_heads=4	,			num_hidden_layers=5	,			pad_token_id=1	,			vocab_size=1000	,			)
														UpperCamelCase__					  =      CLIPTextModel(__lowerCAmelCase	)
														UpperCamelCase__					  =      CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""	)

														UpperCamelCase__					  =      {
														    """unet""": unet,
														    """scheduler""": scheduler,
														    """vae""": vae,
														    """text_encoder""": text_encoder,
														    """tokenizer""": tokenizer,
														    """safety_checker""": None,
														    """feature_extractor""": None,
														}
														return components






							def 					_lowerCamelCase		(    self	,			__lowerCAmelCase	,			__lowerCAmelCase=0	):
														if str(__lowerCAmelCase	).startswith("""mps"""	):
																					UpperCamelCase__					  =      torch.manual_seed(__lowerCAmelCase	)
														else:
																					UpperCamelCase__					  =      torch.Generator(device=__lowerCAmelCase	).manual_seed(__lowerCAmelCase	)
														UpperCamelCase__					  =      {
														    """prompt""": """.""",
														    """generator""": generator,
														    """num_inference_steps""": 2,
														    """guidance_scale""": 1.0,
														    """sag_scale""": 1.0,
														    """output_type""": """numpy""",
														}
														return inputs







							def 					_lowerCamelCase		(    self	):
														super().test_inference_batch_single_identical(expected_max_diff=3E-3	)






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






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






							def 					_lowerCamelCase		(    self	):
														UpperCamelCase__					  =      StableDiffusionSAGPipeline.from_pretrained("""CompVis/stable-diffusion-v1-4"""	)
														UpperCamelCase__					  =      sag_pipe.to(__lowerCAmelCase	)
														sag_pipe.set_progress_bar_config(disable=__lowerCAmelCase	)

														UpperCamelCase__					  =      """."""
														UpperCamelCase__					  =      torch.manual_seed(0	)
														UpperCamelCase__					  =      sag_pipe(
														    [prompt]	,			generator=__lowerCAmelCase	,			guidance_scale=7.5	,			sag_scale=1.0	,			num_inference_steps=20	,			output_type="""np"""	)

														UpperCamelCase__					  =      output.images

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

														assert image.shape == (1, 512, 512, 3)
														UpperCamelCase__					  =      np.array([0.1568, 0.1738, 0.1695, 0.1693, 0.1507, 0.1705, 0.1547, 0.1751, 0.1949]	)

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






							def 					_lowerCamelCase		(    self	):
														UpperCamelCase__					  =      StableDiffusionSAGPipeline.from_pretrained("""stabilityai/stable-diffusion-2-1-base"""	)
														UpperCamelCase__					  =      sag_pipe.to(__lowerCAmelCase	)
														sag_pipe.set_progress_bar_config(disable=__lowerCAmelCase	)

														UpperCamelCase__					  =      """."""
														UpperCamelCase__					  =      torch.manual_seed(0	)
														UpperCamelCase__					  =      sag_pipe(
														    [prompt]	,			generator=__lowerCAmelCase	,			guidance_scale=7.5	,			sag_scale=1.0	,			num_inference_steps=20	,			output_type="""np"""	)

														UpperCamelCase__					  =      output.images

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

														assert image.shape == (1, 512, 512, 3)
														UpperCamelCase__					  =      np.array([0.3459, 0.2876, 0.2537, 0.3002, 0.2671, 0.2160, 0.3026, 0.2262, 0.2371]	)

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







							def 					_lowerCamelCase		(    self	):
														UpperCamelCase__					  =      StableDiffusionSAGPipeline.from_pretrained("""stabilityai/stable-diffusion-2-1-base"""	)
														UpperCamelCase__					  =      sag_pipe.to(__lowerCAmelCase	)
														sag_pipe.set_progress_bar_config(disable=__lowerCAmelCase	)

														UpperCamelCase__					  =      """."""
														UpperCamelCase__					  =      torch.manual_seed(0	)
														UpperCamelCase__					  =      sag_pipe(
														    [prompt]	,			width=768	,			height=512	,			generator=__lowerCAmelCase	,			guidance_scale=7.5	,			sag_scale=1.0	,			num_inference_steps=20	,			output_type="""np"""	,			)

														UpperCamelCase__					  =      output.images

														assert image.shape == (1, 512, 768, 3)











import os

import pytest

from transformers.dynamic_module_utils import get_imports


UpperCamelCase__           =			"\nimport os\n"

UpperCamelCase__           =			"\ndef foo():\n    import os\n    return False\n"

UpperCamelCase__           =			"\ndef foo():\n    def bar():\n        if True:\n            import os\n        return False\n    return bar()\n"

UpperCamelCase__           =			"\nimport os\n\ntry:\n    import bar\nexcept ImportError:\n    raise ValueError()\n"

UpperCamelCase__           =			"\nimport os\n\ndef foo():\n    try:\n        import bar\n    except ImportError:\n        raise ValueError()\n"

UpperCamelCase__           =			"\nimport os\n\ntry:\n    import bar\nexcept (ImportError, AttributeError):\n    raise ValueError()\n"

UpperCamelCase__           =			"\nimport os\n\ntry:\n    import bar\nexcept ImportError as e:\n    raise ValueError()\n"

UpperCamelCase__           =			"\nimport os\n\ntry:\n    import bar\nexcept:\n    raise ValueError()\n"

UpperCamelCase__           =			"\nimport os\n\ntry:\n    import bar\n    import baz\nexcept ImportError:\n    raise ValueError()\n"

UpperCamelCase__           =			"\nimport os\n\ntry:\n    import bar\n    import baz\nexcept ImportError:\n    x = 1\n    raise ValueError()\n"

UpperCamelCase__           =			[
    TOP_LEVEL_IMPORT,
    IMPORT_IN_FUNCTION,
    DEEPLY_NESTED_IMPORT,
    TOP_LEVEL_TRY_IMPORT,
    GENERIC_EXCEPT_IMPORT,
    MULTILINE_TRY_IMPORT,
    MULTILINE_BOTH_IMPORT,
    MULTIPLE_EXCEPTS_IMPORT,
    EXCEPT_AS_IMPORT,
    TRY_IMPORT_IN_FUNCTION,
]





@pytest.mark.parametrize("""case""" ,      a__							)
def      _UpperCamelCase  (a__ :Any ,      a__ :Optional[Any]							):






							"""simple docstring"""





							UpperCamelCase__					  =      os.path.join(a__ ,      """test_file.py"""							)
							with open(a__ ,      """w"""							) as _tmp_file:
														_tmp_file.write(a__							)

							UpperCamelCase__					  =      get_imports(a__							)
							assert parsed_imports == ["os"]




