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()}."

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

distance = 1.0 - similarity.mean()

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

if not torch.is_tensor(tensor):

tensor = torch.from_numpy(tensor)

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:

"""

# 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 os.path.join(tests_dir, append_path)

else:

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 = strtobool(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.")

"""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 unittest.skipUnless(is_torch_available() and is_torch_version(">=", "2.0.0"), "test requires PyTorch 2")(

test_case

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

return unittest.skipUnless(is_torch_available() and torch_device == "cuda", "test requires PyTorch+CUDA")(

test_case

"""

"""

"""

"""

"""

"""

"""

def python39_available():

sys_info = sys.version_info

major, minor = sys_info.major, sys_info.minor

return major == 3 and minor >= 9

if isinstance(arry, str):

# local_path = "/home/patrick_huggingface_co/"

if local_path is not None:

# local_path can be passed to correct images of tests

return os.path.join(local_path, "/".join([arry.split("/")[-5], arry.split("/")[-2], arry.split("/")[-1]]))

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

response = requests.get(arry)

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."

)

response = requests.get(url)

response.raise_for_status()

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

"""

if isinstance(image, str):

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

image = PIL.Image.open(requests.get(image, stream=True).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")

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)

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,

)

"""

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(),

rgb.tolist(),

)

]

format = struct.Struct("<3f3B")

for item in vertices:

f.write(format.pack(*item))

else:

format = struct.Struct("<3f")

for vertex in coords.tolist():

f.write(format.pack(*vertex))

if faces is not None:

format = struct.Struct("<B3I")

for tri in faces.tolist():

f.write(format.pack(len(tri), *tri))

if output_obj_path is None:

output_obj_path = tempfile.NamedTemporaryFile(suffix=".obj").name

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

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

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

vertices = [

"{} {} {} {} {} {}".format(*coord, *color) for coord, color in zip(verts.tolist(), vertex_colors.tolist())

]

faces = ["f {} {} {}".format(str(tri[0] + 1), str(tri[1] + 1), str(tri[2] + 1)) for tri in faces.tolist()]

combined_data = ["v " + vertex for vertex in vertices] + faces

with open(output_obj_path, "w") as f:

if is_opencv_available():

import cv2

else:

raise ImportError(BACKENDS_MAPPING["opencv"][1].format("export_to_video"))

if output_video_path is None:

output_video_path = tempfile.NamedTemporaryFile(suffix=".mp4").name

fourcc = cv2.VideoWriter_fourcc(*"mp4v")

h, w, c = video_frames[0].shape

video_writer = cv2.VideoWriter(output_video_path, fourcc, fps=8, frameSize=(w, h))

for i in range(len(video_frames)):

img = cv2.cvtColor(video_frames[i], cv2.COLOR_RGB2BGR)

video_writer.write(img)

if not path.startswith("http://") or path.startswith("https://"):

path = os.path.join(

"https://huggingface.co/datasets/fusing/diffusers-testing/resolve/main", urllib.parse.quote(path)

)

"""

option = "--make-reports"

if option not in pytest_opt_registered:

parser.addoption(

option,

action="store",

default=False,

help="generate report files. The value of this option is used as a prefix to report names",

)

"""

from _pytest.config import create_terminal_writer

if not len(id):

id = "tests"

config = tr.config

orig_writer = config.get_terminal_writer()

orig_tbstyle = config.option.tbstyle

orig_reportchars = tr.reportchars

dir = "reports"

Path(dir).mkdir(parents=True, exist_ok=True)

report_files = {

k: f"{dir}/{id}_{k}.txt"

for k in [

"durations",

"errors",

"failures_long",

"failures_short",

"failures_line",

"passes",

"stats",

"summary_short",

"warnings",

]

}

# custom durations report

# note: there is no need to call pytest --durations=XX to get this separate report

# adapted from https://github.com/pytest-dev/pytest/blob/897f151e/src/_pytest/runner.py#L66

dlist = []

for replist in tr.stats.values():

for rep in replist:

if hasattr(rep, "duration"):

dlist.append(rep)

if dlist:

dlist.sort(key=lambda x: x.duration, reverse=True)

with open(report_files["durations"], "w") as f:

durations_min = 0.05 # sec

f.write("slowest durations\n")

for i, rep in enumerate(dlist):

if rep.duration < durations_min:

f.write(f"{len(dlist)-i} durations < {durations_min} secs were omitted")

break

f.write(f"{rep.duration:02.2f}s {rep.when:<8} {rep.nodeid}\n")

def summary_failures_short(tr):

# expecting that the reports were --tb=long (default) so we chop them off here to the last frame

reports = tr.getreports("failed")

if not reports:

return

tr.write_sep("=", "FAILURES SHORT STACK")

for rep in reports:

msg = tr._getfailureheadline(rep)

tr.write_sep("_", msg, red=True, bold=True)

# chop off the optional leading extra frames, leaving only the last one

longrepr = re.sub(r".*_ _ _ (_ ){10,}_ _ ", "", rep.longreprtext, 0, re.M | re.S)

tr._tw.line(longrepr)

# note: not printing out any rep.sections to keep the report short

# use ready-made report funcs, we are just hijacking the filehandle to log to a dedicated file each

# adapted from https://github.com/pytest-dev/pytest/blob/897f151e/src/_pytest/terminal.py#L814

# note: some pytest plugins may interfere by hijacking the default `terminalreporter` (e.g.

# pytest-instafail does that)

# report failures with line/short/long styles

config.option.tbstyle = "auto" # full tb

with open(report_files["failures_long"], "w") as f:

tr._tw = create_terminal_writer(config, f)

tr.summary_failures()

# config.option.tbstyle = "short" # short tb

with open(report_files["failures_short"], "w") as f:

tr._tw = create_terminal_writer(config, f)

summary_failures_short(tr)

config.option.tbstyle = "line" # one line per error

with open(report_files["failures_line"], "w") as f:

tr._tw = create_terminal_writer(config, f)

tr.summary_failures()

with open(report_files["errors"], "w") as f:

tr._tw = create_terminal_writer(config, f)

tr.summary_errors()

with open(report_files["warnings"], "w") as f:

tr._tw = create_terminal_writer(config, f)

tr.summary_warnings() # normal warnings

tr.summary_warnings() # final warnings

tr.reportchars = "wPpsxXEf" # emulate -rA (used in summary_passes() and short_test_summary())

with open(report_files["passes"], "w") as f:

tr._tw = create_terminal_writer(config, f)

tr.summary_passes()

with open(report_files["summary_short"], "w") as f:

tr._tw = create_terminal_writer(config, f)

tr.short_test_summary()

with open(report_files["stats"], "w") as f:

tr._tw = create_terminal_writer(config, f)

tr.summary_stats()

# restore:

tr._tw = orig_writer

tr.reportchars = orig_reportchars

"""

def decorator(test_func_ref):

@functools.wraps(test_func_ref)

def wrapper(*args, **kwargs):

retry_count = 1

while retry_count < max_attempts:

try:

return test_func_ref(*args, **kwargs)

except Exception as err:

print(f"Test failed with {err} at try {retry_count}/{max_attempts}.", file=sys.stderr)

if wait_before_retry is not None:

time.sleep(wait_before_retry)

retry_count += 1

return test_func_ref(*args, **kwargs)

return wrapper

"""

if timeout is None:

timeout = int(os.environ.get("PYTEST_TIMEOUT", 600))

start_methohd = "spawn"

ctx = multiprocessing.get_context(start_methohd)

input_queue = ctx.Queue(1)

output_queue = ctx.JoinableQueue(1)

# We can't send `unittest.TestCase` to the child, otherwise we get issues regarding pickle.

input_queue.put(inputs, timeout=timeout)

process = ctx.Process(target=target_func, args=(input_queue, output_queue, timeout))

process.start()

# Kill the child process if we can't get outputs from it in time: otherwise, the hanging subprocess prevents

# the test to exit properly.

try:

results = output_queue.get(timeout=timeout)

output_queue.task_done()

except Exception as e:

process.terminate()

test_case.fail(e)

process.join(timeout=timeout)

if results["error"] is not None:

"""

def __init__(self, logger):

self.logger = logger

self.io = StringIO()

self.sh = logging.StreamHandler(self.io)

self.out = ""

def __enter__(self):

self.logger.addHandler(self.sh)

return self

def __exit__(self, *exc):

self.logger.removeHandler(self.sh)

self.out = self.io.getvalue()

def __repr__(self):

"""

# Enable PyTorch deterministic mode. This potentially requires either the environment

# variable 'CUDA_LAUNCH_BLOCKING' or 'CUBLAS_WORKSPACE_CONFIG' to be set,

# depending on the CUDA version, so we set them both here

os.environ["CUDA_LAUNCH_BLOCKING"] = "1"

os.environ["CUBLAS_WORKSPACE_CONFIG"] = ":16:8"

torch.use_deterministic_algorithms(True)

# Enable CUDNN deterministic mode

torch.backends.cudnn.deterministic = True

torch.backends.cudnn.benchmark = False