import functools

import glob

import importlib

import importlib.metadata

import inspect

import io

import logging

import multiprocessing

import os

import random

import re

import struct

import sys

import tempfile

import time

import urllib.parse

from collections import UserDict

from contextlib import contextmanager

from io import BytesIO, StringIO

from pathlib import Path

from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Set, Tuple, Union

import numpy as np

import PIL.Image

import PIL.ImageOps

import pytest

import requests

from numpy.linalg import norm

from packaging import version

from diffusers.utils.constants import DIFFUSERS_REQUEST_TIMEOUT

from diffusers.utils.import_utils import (

BACKENDS_MAPPING,

is_accelerate_available,

is_bitsandbytes_available,

is_compel_available,

is_flax_available,

is_gguf_available,

is_kernels_available,

is_note_seq_available,

is_nvidia_modelopt_version,

is_onnx_available,

is_opencv_available,

is_optimum_quanto_available,

is_peft_available,

is_timm_available,

is_torch_available,

is_torch_version,

is_torchao_available,

is_torchsde_available,

is_transformers_available,

)

from diffusers.utils.logging import get_logger

if is_torch_available():

import torch

IS_ROCM_SYSTEM = torch.version.hip is not None

IS_CUDA_SYSTEM = torch.version.cuda is not None

IS_XPU_SYSTEM = getattr(torch.version, "xpu", None) is not None

else:

IS_ROCM_SYSTEM = False

IS_CUDA_SYSTEM = False

IS_XPU_SYSTEM = False

IS_GITHUB_ACTIONS = os.getenv("GITHUB_ACTIONS") == "true" and os.getenv("DIFFUSERS_IS_CI") == "yes"

global_rng = random.Random()

logger = get_logger(__name__)

_required_peft_version = is_peft_available() and version.parse(

version.parse(importlib.metadata.version("peft")).base_version

) > version.parse("0.5")

_required_transformers_version = is_transformers_available() and version.parse(

version.parse(importlib.metadata.version("transformers")).base_version

) > version.parse("4.33")

USE_PEFT_BACKEND = _required_peft_version and _required_transformers_version

BIG_GPU_MEMORY = int(os.getenv("BIG_GPU_MEMORY", 40))

if is_torch_available():

import torch

# Set a backend environment variable for any extra module import required for a custom accelerator

if "DIFFUSERS_TEST_BACKEND" in os.environ:

backend = os.environ["DIFFUSERS_TEST_BACKEND"]

try:

_ = importlib.import_module(backend)

except ModuleNotFoundError as e:

raise ModuleNotFoundError(

f"Failed to import `DIFFUSERS_TEST_BACKEND` '{backend}'! This should be the name of an installed module \

to enable a specified backend.):\n{e}"

) from e

if "DIFFUSERS_TEST_DEVICE" in os.environ:

torch_device = os.environ["DIFFUSERS_TEST_DEVICE"]

try:

# try creating device to see if provided device is valid

_ = torch.device(torch_device)

except RuntimeError as e:

raise RuntimeError(

f"Unknown testing device specified by environment variable `DIFFUSERS_TEST_DEVICE`: {torch_device}"

) from e

logger.info(f"torch_device overrode to {torch_device}")

else:

if torch.cuda.is_available():

torch_device = "cuda"

elif torch.xpu.is_available():

torch_device = "xpu"

else:

torch_device = "cpu"

is_torch_higher_equal_than_1_12 = version.parse(

version.parse(torch.__version__).base_version

) >= version.parse("1.12")

if is_torch_higher_equal_than_1_12:

# Some builds of torch 1.12 don't have the mps backend registered. See #892 for more details

mps_backend_registered = hasattr(torch.backends, "mps")

torch_device = "mps" if (mps_backend_registered and torch.backends.mps.is_available()) else torch_device

from diffusers.utils.torch_utils import get_torch_cuda_device_capability

def torch_all_close(a, b, *args, **kwargs):

if not is_torch_available():

raise ValueError("PyTorch needs to be installed to use this function.")

if not torch.allclose(a, b, *args, **kwargs):

assert False, f"Max diff is absolute {(a - b).abs().max()}. Diff tensor is {(a - b).abs()}."

return True

def assert_tensors_close(

actual: "torch.Tensor",

expected: "torch.Tensor",

atol: float = 1e-5,

rtol: float = 1e-5,

msg: str = "",

) -> None:

"""

Assert that two tensors are close within tolerance.

Uses the same formula as torch.allclose: |actual - expected| <= atol + rtol * |expected|

Provides concise, actionable error messages without dumping full tensors.

Args:

actual: The actual tensor from the computation.

expected: The expected tensor to compare against.

atol: Absolute tolerance.

rtol: Relative tolerance.

msg: Optional message prefix for the assertion error.

Raises:

AssertionError: If tensors have different shapes or values exceed tolerance.

Example:

>>> assert_tensors_close(output, expected_output, atol=1e-5, rtol=1e-5, msg="Forward pass")

"""

if not is_torch_available():

raise ValueError("PyTorch needs to be installed to use this function.")

if actual.shape != expected.shape:

raise AssertionError(f"{msg} Shape mismatch: actual {actual.shape} vs expected {expected.shape}")

if not torch.allclose(actual, expected, atol=atol, rtol=rtol):

abs_diff = (actual - expected).abs()

max_diff = abs_diff.max().item()

flat_idx = abs_diff.argmax().item()

max_idx = tuple(torch.unravel_index(torch.tensor(flat_idx), actual.shape).tolist())

threshold = atol + rtol * expected.abs()

mismatched = (abs_diff > threshold).sum().item()

total = actual.numel()

raise AssertionError(

f"{msg}\n"

f"Tensors not close! Mismatched elements: {mismatched}/{total} ({100 * mismatched / total:.1f}%)\n"

f" Max diff: {max_diff:.6e} at index {max_idx}\n"

f" Actual: {actual.flatten()[flat_idx].item():.6e}\n"

f" Expected: {expected.flatten()[flat_idx].item():.6e}\n"

f" atol: {atol:.6e}, rtol: {rtol:.6e}"

)

def numpy_cosine_similarity_distance(a, b):

similarity = np.dot(a, b) / (norm(a) * norm(b))

distance = 1.0 - similarity.mean()

return distance

def check_if_dicts_are_equal(dict1, dict2):

dict1, dict2 = dict1.copy(), dict2.copy()

for key, value in dict1.items():

if isinstance(value, set):

dict1[key] = sorted(value)

for key, value in dict2.items():

if isinstance(value, set):

dict2[key] = sorted(value)

for key in dict1:

if key not in dict2:

return False

if dict1[key] != dict2[key]:

return False

for key in dict2:

if key not in dict1:

return False

return True

def print_tensor_test(

tensor,

limit_to_slices=None,

max_torch_print=None,

filename="test_corrections.txt",

expected_tensor_name="expected_slice",

):

if max_torch_print:

torch.set_printoptions(threshold=10_000)

test_name = os.environ.get("PYTEST_CURRENT_TEST")

if not torch.is_tensor(tensor):

tensor = torch.from_numpy(tensor)

if limit_to_slices:

tensor = tensor[0, -3:, -3:, -1]

tensor_str = str(tensor.detach().cpu().flatten().to(torch.float32)).replace("\n", "")

# format is usually:

# expected_slice = np.array([-0.5713, -0.3018, -0.9814, 0.04663, -0.879, 0.76, -1.734, 0.1044, 1.161])

output_str = tensor_str.replace("tensor", f"{expected_tensor_name} = np.array")

test_file, test_class, test_fn = test_name.split("::")

test_fn = test_fn.split()[0]

with open(filename, "a") as f:

print("::".join([test_file, test_class, test_fn, output_str]), file=f)

def get_tests_dir(append_path=None):

"""

Args:

append_path: optional path to append to the tests dir path

Return:

The full path to the `tests` dir, so that the tests can be invoked from anywhere. Optionally `append_path` is

joined after the `tests` dir the former is provided.

"""

# this function caller's __file__

caller__file__ = inspect.stack()[1][1]

tests_dir = os.path.abspath(os.path.dirname(caller__file__))

while not tests_dir.endswith("tests"):

tests_dir = os.path.dirname(tests_dir)

if append_path:

return Path(tests_dir, append_path).as_posix()

else:

return tests_dir

# Taken from the following PR:

# https://github.com/huggingface/accelerate/pull/1964

def str_to_bool(value) -> int:

"""

Converts a string representation of truth to `True` (1) or `False` (0). True values are `y`, `yes`, `t`, `true`,

`on`, and `1`; False value are `n`, `no`, `f`, `false`, `off`, and `0`;

"""

value = value.lower()

if value in ("y", "yes", "t", "true", "on", "1"):

return 1

elif value in ("n", "no", "f", "false", "off", "0"):

return 0

else:

raise ValueError(f"invalid truth value {value}")

def parse_flag_from_env(key, default=False):

try:

value = os.environ[key]

except KeyError:

# KEY isn't set, default to `default`.

_value = default

else:

# KEY is set, convert it to True or False.

try:

_value = str_to_bool(value)

except ValueError:

# More values are supported, but let's keep the message simple.

raise ValueError(f"If set, {key} must be yes or no.")

return _value

_run_slow_tests = parse_flag_from_env("RUN_SLOW", default=False)

_run_nightly_tests = parse_flag_from_env("RUN_NIGHTLY", default=False)

def floats_tensor(shape, scale=1.0, rng=None, name=None):

"""Creates a random float32 tensor"""

if rng is None:

rng = global_rng

total_dims = 1

for dim in shape:

total_dims *= dim

values = []

for _ in range(total_dims):

values.append(rng.random() * scale)

return torch.tensor(data=values, dtype=torch.float).view(shape).contiguous()

def slow(test_case):

"""

Decorator marking a test as slow.

Slow tests are skipped by default. Set the RUN_SLOW environment variable to a truthy value to run them.

"""

return pytest.mark.skipif(not _run_slow_tests, reason="test is slow")(test_case)

def nightly(test_case):

"""

Decorator marking a test that runs nightly in the diffusers CI.

Slow tests are skipped by default. Set the RUN_NIGHTLY environment variable to a truthy value to run them.

"""

return pytest.mark.skipif(not _run_nightly_tests, reason="test is nightly")(test_case)

def is_torch_compile(test_case):

"""

Decorator marking a test as a torch.compile test. These tests can be filtered using:

pytest -m "not compile" to skip

pytest -m compile to run only these tests

"""

return pytest.mark.compile(test_case)

def is_single_file(test_case):

"""

Decorator marking a test as a single file loading test. These tests can be filtered using:

pytest -m "not single_file" to skip

pytest -m single_file to run only these tests

"""

return pytest.mark.single_file(test_case)

def is_lora(test_case):

"""

Decorator marking a test as a LoRA test. These tests can be filtered using:

pytest -m "not lora" to skip

pytest -m lora to run only these tests

"""

return pytest.mark.lora(test_case)

def is_ip_adapter(test_case):

"""

Decorator marking a test as an IP Adapter test. These tests can be filtered using:

pytest -m "not ip_adapter" to skip

pytest -m ip_adapter to run only these tests

"""

return pytest.mark.ip_adapter(test_case)

def is_training(test_case):

"""

Decorator marking a test as a training test. These tests can be filtered using:

pytest -m "not training" to skip

pytest -m training to run only these tests

"""

return pytest.mark.training(test_case)

def is_attention(test_case):

"""

Decorator marking a test as an attention test. These tests can be filtered using:

pytest -m "not attention" to skip

pytest -m attention to run only these tests

"""

return pytest.mark.attention(test_case)

def is_memory(test_case):

"""

Decorator marking a test as a memory optimization test. These tests can be filtered using:

pytest -m "not memory" to skip

pytest -m memory to run only these tests

"""

return pytest.mark.memory(test_case)

def is_cpu_offload(test_case):

"""

Decorator marking a test as a CPU offload test. These tests can be filtered using:

pytest -m "not cpu_offload" to skip

pytest -m cpu_offload to run only these tests

"""

return pytest.mark.cpu_offload(test_case)

def is_group_offload(test_case):

"""

Decorator marking a test as a group offload test. These tests can be filtered using:

pytest -m "not group_offload" to skip

pytest -m group_offload to run only these tests

"""

return pytest.mark.group_offload(test_case)

def is_quantization(test_case):

"""

Decorator marking a test as a quantization test. These tests can be filtered using:

pytest -m "not quantization" to skip

pytest -m quantization to run only these tests

"""

return pytest.mark.quantization(test_case)

def is_bitsandbytes(test_case):

"""

Decorator marking a test as a BitsAndBytes quantization test. These tests can be filtered using:

pytest -m "not bitsandbytes" to skip

pytest -m bitsandbytes to run only these tests

"""

return pytest.mark.bitsandbytes(test_case)

def is_quanto(test_case):

"""

Decorator marking a test as a Quanto quantization test. These tests can be filtered using:

pytest -m "not quanto" to skip

pytest -m quanto to run only these tests

"""

return pytest.mark.quanto(test_case)

def is_torchao(test_case):

"""

Decorator marking a test as a TorchAO quantization test. These tests can be filtered using:

pytest -m "not torchao" to skip

pytest -m torchao to run only these tests

"""

return pytest.mark.torchao(test_case)

def is_gguf(test_case):

"""

Decorator marking a test as a GGUF quantization test. These tests can be filtered using:

pytest -m "not gguf" to skip

pytest -m gguf to run only these tests

"""

return pytest.mark.gguf(test_case)

def is_modelopt(test_case):

"""

Decorator marking a test as a NVIDIA ModelOpt quantization test. These tests can be filtered using:

pytest -m "not modelopt" to skip

pytest -m modelopt to run only these tests

"""

return pytest.mark.modelopt(test_case)

def is_context_parallel(test_case):

"""

Decorator marking a test as a context parallel inference test. These tests can be filtered using:

pytest -m "not context_parallel" to skip

pytest -m context_parallel to run only these tests

"""

return pytest.mark.context_parallel(test_case)

def is_cache(test_case):

"""

Decorator marking a test as a cache test. These tests can be filtered using:

pytest -m "not cache" to skip

pytest -m cache to run only these tests

"""

return pytest.mark.cache(test_case)

def require_torch(test_case):

"""

Decorator marking a test that requires PyTorch. These tests are skipped when PyTorch isn't installed.

"""

return pytest.mark.skipif(not is_torch_available(), reason="test requires PyTorch")(test_case)

def require_torch_2(test_case):

"""

Decorator marking a test that requires PyTorch 2. These tests are skipped when it isn't installed.

"""

return pytest.mark.skipif(

not (is_torch_available() and is_torch_version(">=", "2.0.0")), reason="test requires PyTorch 2"

)(test_case)

def require_torch_version_greater_equal(torch_version):

"""Decorator marking a test that requires torch with a specific version or greater."""

def decorator(test_case):

correct_torch_version = is_torch_available() and is_torch_version(">=", torch_version)

return pytest.mark.skipif(

not correct_torch_version,

reason=f"test requires torch with the version greater than or equal to {torch_version}",

)(test_case)

return decorator

def require_torch_version_greater(torch_version):

"""Decorator marking a test that requires torch with a specific version greater."""

def decorator(test_case):

correct_torch_version = is_torch_available() and is_torch_version(">", torch_version)

return pytest.mark.skipif(

not correct_torch_version, reason=f"test requires torch with the version greater than {torch_version}"

)(test_case)

return decorator

def require_torch_gpu(test_case):

"""Decorator marking a test that requires CUDA and PyTorch."""

return pytest.mark.skipif(torch_device != "cuda", reason="test requires PyTorch+CUDA")(test_case)

def require_torch_cuda_compatibility(expected_compute_capability):

def decorator(test_case):

if torch.cuda.is_available():

current_compute_capability = get_torch_cuda_device_capability()

return pytest.mark.skipif(

float(current_compute_capability) != float(expected_compute_capability),

reason="Test not supported for this compute capability.",

)(test_case)

return test_case

return decorator

# These decorators are for accelerator-specific behaviours that are not GPU-specific

def require_torch_accelerator(test_case):

"""Decorator marking a test that requires an accelerator backend and PyTorch."""

return pytest.mark.skipif(torch_device == "cpu", reason="test requires accelerator+PyTorch")(test_case)

def require_torch_multi_gpu(test_case):

"""

Decorator marking a test that requires a multi-GPU setup (in PyTorch). These tests are skipped on a machine without

multiple GPUs. To run *only* the multi_gpu tests, assuming all test names contain multi_gpu: $ pytest -sv ./tests

-k "multi_gpu"

"""

if not is_torch_available():

return pytest.mark.skip(reason="test requires PyTorch")(test_case)

import torch

return pytest.mark.skipif(torch.cuda.device_count() <= 1, reason="test requires multiple GPUs")(test_case)

def require_torch_multi_accelerator(test_case):

"""

Decorator marking a test that requires a multi-accelerator setup (in PyTorch). These tests are skipped on a machine

without multiple hardware accelerators.

"""

if not is_torch_available():

return pytest.mark.skip(reason="test requires PyTorch")(test_case)

import torch

return pytest.mark.skipif(

not (torch.cuda.device_count() > 1 or torch.xpu.device_count() > 1),

reason="test requires multiple hardware accelerators",

)(test_case)

def require_torch_accelerator_with_fp16(test_case):

"""Decorator marking a test that requires an accelerator with support for the FP16 data type."""

return pytest.mark.skipif(

not _is_torch_fp16_available(torch_device), reason="test requires accelerator with fp16 support"

)(test_case)

def require_torch_accelerator_with_fp64(test_case):

"""Decorator marking a test that requires an accelerator with support for the FP64 data type."""

return pytest.mark.skipif(

not _is_torch_fp64_available(torch_device), reason="test requires accelerator with fp64 support"

)(test_case)

def require_big_gpu_with_torch_cuda(test_case):

"""

Decorator marking a test that requires a bigger GPU (24GB) for execution. Some example pipelines: Flux, SD3, Cog,

etc.

"""

if not is_torch_available():

return pytest.mark.skip(reason="test requires PyTorch")(test_case)

import torch

if not torch.cuda.is_available():

return pytest.mark.skip(reason="test requires PyTorch CUDA")(test_case)

device_properties = torch.cuda.get_device_properties(0)

total_memory = device_properties.total_memory / (1024**3)

return pytest.mark.skipif(

total_memory < BIG_GPU_MEMORY, reason=f"test requires a GPU with at least {BIG_GPU_MEMORY} GB memory"

)(test_case)

def require_big_accelerator(test_case):

"""

Decorator marking a test that requires a bigger hardware accelerator (24GB) for execution. Some example pipelines:

Flux, SD3, Cog, etc.

"""

import pytest

test_case = pytest.mark.big_accelerator(test_case)

if not is_torch_available():

return pytest.mark.skip(reason="test requires PyTorch")(test_case)

import torch

if not (torch.cuda.is_available() or torch.xpu.is_available()):

return pytest.mark.skip(reason="test requires PyTorch CUDA")(test_case)

if torch.xpu.is_available():

device_properties = torch.xpu.get_device_properties(0)

else:

device_properties = torch.cuda.get_device_properties(0)

total_memory = device_properties.total_memory / (1024**3)

return pytest.mark.skipif(

total_memory < BIG_GPU_MEMORY,

reason=f"test requires a hardware accelerator with at least {BIG_GPU_MEMORY} GB memory",

)(test_case)

def require_torch_accelerator_with_training(test_case):

"""Decorator marking a test that requires an accelerator with support for training."""

return pytest.mark.skipif(

not (is_torch_available() and backend_supports_training(torch_device)),

reason="test requires accelerator with training support",

)(test_case)

def skip_mps(test_case):

"""Decorator marking a test to skip if torch_device is 'mps'"""

return pytest.mark.skipif(torch_device == "mps", reason="test requires non 'mps' device")(test_case)

def require_flax(test_case):

"""

Decorator marking a test that requires JAX & Flax. These tests are skipped when one / both are not installed

"""

return pytest.mark.skipif(not is_flax_available(), reason="test requires JAX & Flax")(test_case)

def require_compel(test_case):

"""

Decorator marking a test that requires compel: https://github.com/damian0815/compel. These tests are skipped when

the library is not installed.

"""

return pytest.mark.skipif(not is_compel_available(), reason="test requires compel")(test_case)

def require_onnxruntime(test_case):

"""

Decorator marking a test that requires onnxruntime. These tests are skipped when onnxruntime isn't installed.

"""

return pytest.mark.skipif(not is_onnx_available(), reason="test requires onnxruntime")(test_case)

def require_note_seq(test_case):

"""

Decorator marking a test that requires note_seq. These tests are skipped when note_seq isn't installed.

"""

return pytest.mark.skipif(not is_note_seq_available(), reason="test requires note_seq")(test_case)

def require_accelerator(test_case):

"""

Decorator marking a test that requires a hardware accelerator backend. These tests are skipped when there are no

hardware accelerator available.

"""

return pytest.mark.skipif(torch_device == "cpu", reason="test requires a hardware accelerator")(test_case)

def require_torchsde(test_case):

"""

Decorator marking a test that requires torchsde. These tests are skipped when torchsde isn't installed.

"""

return pytest.mark.skipif(not is_torchsde_available(), reason="test requires torchsde")(test_case)

def require_peft_backend(test_case):

"""

Decorator marking a test that requires PEFT backend, this would require some specific versions of PEFT and

transformers.

"""

return pytest.mark.skipif(not USE_PEFT_BACKEND, reason="test requires PEFT backend")(test_case)

def require_timm(test_case):

"""

Decorator marking a test that requires timm. These tests are skipped when timm isn't installed.

"""

return pytest.mark.skipif(not is_timm_available(), reason="test requires timm")(test_case)

def require_bitsandbytes(test_case):

"""

Decorator marking a test that requires bitsandbytes. These tests are skipped when bitsandbytes isn't installed.

"""

return pytest.mark.skipif(not is_bitsandbytes_available(), reason="test requires bitsandbytes")(test_case)

def require_quanto(test_case):

"""

Decorator marking a test that requires quanto. These tests are skipped when quanto isn't installed.

"""

return pytest.mark.skipif(not is_optimum_quanto_available(), reason="test requires quanto")(test_case)

def require_accelerate(test_case):

"""

Decorator marking a test that requires accelerate. These tests are skipped when accelerate isn't installed.

"""

return pytest.mark.skipif(not is_accelerate_available(), reason="test requires accelerate")(test_case)

def require_peft_version_greater(peft_version):

"""

Decorator marking a test that requires PEFT backend with a specific version, this would require some specific

versions of PEFT and transformers.

"""

def decorator(test_case):

correct_peft_version = is_peft_available() and version.parse(

version.parse(importlib.metadata.version("peft")).base_version

) > version.parse(peft_version)

return pytest.mark.skipif(

not correct_peft_version, reason=f"test requires PEFT backend with the version greater than {peft_version}"

)(test_case)

return decorator

def require_transformers_version_greater(transformers_version):

"""

Decorator marking a test that requires transformers with a specific version, this would require some specific

versions of PEFT and transformers.

"""

def decorator(test_case):

correct_transformers_version = is_transformers_available() and version.parse(

version.parse(importlib.metadata.version("transformers")).base_version

) > version.parse(transformers_version)

return pytest.mark.skipif(

not correct_transformers_version,

reason=f"test requires transformers with the version greater than {transformers_version}",

)(test_case)

return decorator

def require_accelerate_version_greater(accelerate_version):

def decorator(test_case):

correct_accelerate_version = is_accelerate_available() and version.parse(

version.parse(importlib.metadata.version("accelerate")).base_version

) > version.parse(accelerate_version)

return pytest.mark.skipif(

not correct_accelerate_version,

reason=f"Test requires accelerate with the version greater than {accelerate_version}.",

)(test_case)

return decorator

def require_bitsandbytes_version_greater(bnb_version):

def decorator(test_case):

correct_bnb_version = is_bitsandbytes_available() and version.parse(

version.parse(importlib.metadata.version("bitsandbytes")).base_version

) > version.parse(bnb_version)

return pytest.mark.skipif(

not correct_bnb_version, reason=f"Test requires bitsandbytes with the version greater than {bnb_version}."

)(test_case)

return decorator

def require_hf_hub_version_greater(hf_hub_version):

def decorator(test_case):

correct_hf_hub_version = version.parse(

version.parse(importlib.metadata.version("huggingface_hub")).base_version

) > version.parse(hf_hub_version)

return pytest.mark.skipif(

not correct_hf_hub_version,

reason=f"Test requires huggingface_hub with the version greater than {hf_hub_version}.",

)(test_case)

return decorator

def require_gguf_version_greater_or_equal(gguf_version):

def decorator(test_case):

correct_gguf_version = is_gguf_available() and version.parse(

version.parse(importlib.metadata.version("gguf")).base_version

) >= version.parse(gguf_version)

return pytest.mark.skipif(

not correct_gguf_version, reason=f"Test requires gguf with the version greater than {gguf_version}."

)(test_case)

return decorator

def require_torchao_version_greater_or_equal(torchao_version):

def decorator(test_case):

correct_torchao_version = is_torchao_available() and version.parse(

version.parse(importlib.metadata.version("torchao")).base_version

) >= version.parse(torchao_version)

return pytest.mark.skipif(

not correct_torchao_version, reason=f"Test requires torchao with version greater than {torchao_version}."

)(test_case)

return decorator

def require_kernels_version_greater_or_equal(kernels_version):

def decorator(test_case):

correct_kernels_version = is_kernels_available() and version.parse(

version.parse(importlib.metadata.version("kernels")).base_version

) >= version.parse(kernels_version)

return pytest.mark.skipif(

not correct_kernels_version, reason=f"Test requires kernels with version greater than {kernels_version}."

)(test_case)

return decorator

def require_modelopt_version_greater_or_equal(modelopt_version):

def decorator(test_case):

return pytest.mark.skipif(

not is_nvidia_modelopt_version(">=", modelopt_version),

reason=f"Test requires modelopt with version greater than {modelopt_version}.",

)(test_case)

return decorator

def deprecate_after_peft_backend(test_case):

"""

Decorator marking a test that will be skipped after PEFT backend

"""

return pytest.mark.skipif(USE_PEFT_BACKEND, reason="test skipped in favor of PEFT backend")(test_case)

def get_python_version():

sys_info = sys.version_info

major, minor = sys_info.major, sys_info.minor

return major, minor

def load_numpy(arry: Union[str, np.ndarray], local_path: Optional[str] = None) -> np.ndarray:

if isinstance(arry, str):

if local_path is not None:

# local_path can be passed to correct images of tests

return Path(local_path, arry.split("/")[-5], arry.split("/")[-2], arry.split("/")[-1]).as_posix()

elif arry.startswith("http://") or arry.startswith("https://"):

response = requests.get(arry, timeout=DIFFUSERS_REQUEST_TIMEOUT)

response.raise_for_status()

arry = np.load(BytesIO(response.content))

elif os.path.isfile(arry):

arry = np.load(arry)

else:

raise ValueError(

f"Incorrect path or url, URLs must start with `http://` or `https://`, and {arry} is not a valid path"

)

elif isinstance(arry, np.ndarray):

pass

else:

raise ValueError(

"Incorrect format used for numpy ndarray. Should be an url linking to an image, a local path, or a"

" ndarray."

)

return arry

def load_pt(url: str, map_location: Optional[str] = None, weights_only: Optional[bool] = True):

response = requests.get(url, timeout=DIFFUSERS_REQUEST_TIMEOUT)

response.raise_for_status()

arry = torch.load(BytesIO(response.content), map_location=map_location, weights_only=weights_only)

return arry

def load_image(image: Union[str, PIL.Image.Image]) -> PIL.Image.Image:

"""

Loads `image` to a PIL Image.

Args:

image (`str` or `PIL.Image.Image`):

The image to convert to the PIL Image format.

Returns:

`PIL.Image.Image`:

A PIL Image.

"""

if isinstance(image, str):

if image.startswith("http://") or image.startswith("https://"):

image = PIL.Image.open(requests.get(image, stream=True, timeout=DIFFUSERS_REQUEST_TIMEOUT).raw)

elif os.path.isfile(image):

image = PIL.Image.open(image)

else:

raise ValueError(

f"Incorrect path or url, URLs must start with `http://` or `https://`, and {image} is not a valid path"

)

elif isinstance(image, PIL.Image.Image):

image = image

else:

raise ValueError(

"Incorrect format used for image. Should be an url linking to an image, a local path, or a PIL image."

)

image = PIL.ImageOps.exif_transpose(image)

image = image.convert("RGB")

return image

def preprocess_image(image: PIL.Image, batch_size: int):

w, h = image.size

w, h = (x - x % 8 for x in (w, h)) # resize to integer multiple of 8

image = image.resize((w, h), resample=PIL.Image.LANCZOS)

image = np.array(image).astype(np.float32) / 255.0

image = np.vstack([image[None].transpose(0, 3, 1, 2)] * batch_size)

image = torch.from_numpy(image)

return 2.0 * image - 1.0

def export_to_gif(image: List[PIL.Image.Image], output_gif_path: str = None) -> str:

if output_gif_path is None:

output_gif_path = tempfile.NamedTemporaryFile(suffix=".gif").name

image[0].save(

output_gif_path,

save_all=True,

append_images=image[1:],

optimize=False,

duration=100,

loop=0,

)

return output_gif_path

@contextmanager

def buffered_writer(raw_f):

f = io.BufferedWriter(raw_f)

yield f

f.flush()

def export_to_ply(mesh, output_ply_path: str = None):

"""

Write a PLY file for a mesh.

"""

if output_ply_path is None:

output_ply_path = tempfile.NamedTemporaryFile(suffix=".ply").name

coords = mesh.verts.detach().cpu().numpy()

faces = mesh.faces.cpu().numpy()

rgb = np.stack([mesh.vertex_channels[x].detach().cpu().numpy() for x in "RGB"], axis=1)

with buffered_writer(open(output_ply_path, "wb")) as f:

f.write(b"ply\n")

f.write(b"format binary_little_endian 1.0\n")

f.write(bytes(f"element vertex {len(coords)}\n", "ascii"))

f.write(b"property float x\n")

f.write(b"property float y\n")

f.write(b"property float z\n")

if rgb is not None:

f.write(b"property uchar red\n")

f.write(b"property uchar green\n")

f.write(b"property uchar blue\n")

if faces is not None:

f.write(bytes(f"element face {len(faces)}\n", "ascii"))

f.write(b"property list uchar int vertex_index\n")

f.write(b"end_header\n")

if rgb is not None:

rgb = (rgb * 255.499).round().astype(int)

vertices = [

(*coord, *rgb)

for coord, rgb in zip(

coords.tolist(),