The most powerful and modular diffusion model GUI, api and backend with a graph/nodes interface. The fastest local inference engine in the world.
feat(assets): previews for EXR assets, written by SaveImageAdvanced for outputs (#16898)
Simon Pinfold12081cf9b8cb
diff --git a/.gitignore b/.gitignoreindex fc426eda4..7af67dde6 100644--- a/.gitignore+++ b/.gitignore@@ -24,3 +24,4 @@ web_custom_versions/filtered-openapi.yamluv.lock.comfy_environment+/previews/diff --git a/app/assets/api/routes.py b/app/assets/api/routes.pyindex 52abca2dc..c32e65b71 100644--- a/app/assets/api/routes.py+++ b/app/assets/api/routes.py@@ -7,10 +7,10 @@ shaping only; the work itself belongs to the services layer."""import asyncio+import dataclassesimport functoolsimport jsonimport logging-import mimetypesimport osimport urllib.parseimport uuid@@ -61,6 +61,8 @@ from app.assets.services import (upload_from_temp_path,)from app.assets.services.path_utils import compute_asset_response_paths+from app.assets.previews import generate_upload_preview+from app.assets.services.preview_rules import preview_fieldsfrom app.assets.services.cursor import (InvalidCursorError,decode_cursor,@@ -75,7 +77,7 @@ from app.database.db import create_sessionROUTES = web.RouteTableDef()USER_MANAGER: user_manager.UserManager | None = None_ASSETS_ENABLED = False-SYSTEM_TAGS = frozenset({"missing"})+SYSTEM_TAGS = frozenset({"missing", "preview"})_CURSOR_SORT_FIELDS: tuple[RecordSortField, ...] = ("created_at","updated_at",@@ -155,6 +157,11 @@ class SystemTagForbiddenError(Exception):self.tag = tag+def _reserved_preview_tag() -> web.Response:+ # Core deletes a `preview`-tagged preview with its parent, so clients can't create one.+ return _build_error_response(400, "SYSTEM_TAG_FORBIDDEN", "Tag 'preview' is reserved", {"tag": "preview"})++def _reject_system_tags(tags: list[str]) -> None:for tag in tags:if tag in SYSTEM_TAGS:@@ -260,38 +267,11 @@ def _validate_sort_field(requested: str | None) -> RecordSortField:return "created_at"-# What a client can render from the bytes themselves; anything else needs a nominated preview.-PREVIEWABLE_MIME_PREFIXES = ("image/", "video/", "audio/", "text/")--# models is deliberately absent: /api/view has no directory type for it.-VIEWABLE_NAMESPACES = frozenset({"input", "output", "temp"})---def _has_previewable_content(asset: schemas.AssetData | None, file_path: str | None) -> bool:- if asset is None:- return False- # Resolved from the path, not the caller-editable name, so a rename cannot change what previews.- raw = asset.mime_type or mimetypes.guess_type(file_path or "")[0] or ""- return raw.split(";", 1)[0].strip().lower().startswith(PREVIEWABLE_MIME_PREFIXES)---def _build_view_url(file_path: str | None) -> str | None:- # /api/view is a FileResponse: byte-range seeking, no user header, no access write.- if not file_path:- return None- paths = compute_asset_response_paths(file_path)- if not paths:- return None- logical_path, relative_path = paths- namespace = logical_path.split("/", 1)[0]- if namespace not in VIEWABLE_NAMESPACES or not relative_path:- return None-- subfolder, _, filename = relative_path.rpartition("/")- url = f"/api/view?type={namespace}&filename={urllib.parse.quote(filename, safe='')}"- if subfolder:- url += f"&subfolder={urllib.parse.quote(subfolder, safe='')}"- return url+async def _with_upload_preview(result: schemas.UploadResult) -> schemas.UploadResult:+ preview_id = await generate_upload_preview(result.ref.id, result.ref.file_path, result.ref.preview_id)+ if preview_id == result.ref.preview_id:+ return result+ return dataclasses.replace(result, ref=dataclasses.replace(result.ref, preview_id=preview_id))def _resolve_preview_paths(@@ -306,15 +286,14 @@ def _build_asset_response(result: schemas.AssetDetailResult | schemas.UploadResult,preview_paths: dict[str, str],) -> schemas_out.Asset:- if result.ref.preview_id:- # A nominated preview is one whatever it holds, so no media check here.- preview_url = _build_view_url(preview_paths.get(result.ref.preview_id))- elif result.asset is not None and result.asset.is_missing:- preview_url = None- elif _has_previewable_content(result.asset, result.ref.file_path):- preview_url = _build_view_url(result.ref.file_path)- else:- preview_url = None+ preview_id, preview_url = preview_fields(+ result.ref.id,+ result.ref.preview_id,+ result.asset.mime_type if result.asset else None,+ result.ref.file_path if result.asset else None,+ result.asset is not None and result.asset.is_missing,+ preview_paths,+ )if result.ref.file_path:paths = compute_asset_response_paths(result.ref.file_path)display_name = paths[1] if paths else None@@ -334,7 +313,7 @@ def _build_asset_response(mime_type=result.asset.mime_type if result.asset else None,tags=result.tags,preview_url=preview_url,- preview_id=result.ref.preview_id,+ preview_id=preview_id,user_metadata=result.ref.user_metadata or {},metadata=result.ref.system_metadata,job_id=result.ref.job_id,@@ -353,18 +332,9 @@ def _build_record_response(content = record.contentpaths = compute_asset_response_paths(content.path)display_name = paths[1] if paths else None- if record.preview_id:- preview_url = _build_view_url(preview_paths.get(record.preview_id))- elif content.is_missing:- preview_url = None- else:- mime_type = record.mime_type or mimetypes.guess_type(content.path)[0] or ""- if mime_type.split(";", 1)[0].strip().lower().startswith(- PREVIEWABLE_MIME_PREFIXES- ):- preview_url = _build_view_url(content.path)- else:- preview_url = None+ preview_id, preview_url = preview_fields(+ record.id, record.preview_id, record.mime_type, content.path, content.is_missing, preview_paths+ )return schemas_out.Asset(id=record.id,@@ -376,7 +346,7 @@ def _build_record_response(mime_type=record.mime_type,tags=tags,preview_url=preview_url,- preview_id=record.preview_id,+ preview_id=preview_id,user_metadata=record.user_metadata or {},metadata=record.system_metadata,job_id=record.job_id,@@ -586,6 +556,8 @@ async def download_asset_content(request: web.Request) -> web.Response:try:result = resolve_asset_for_download(reference_id=str(uuid.UUID(request.match_info["id"])),+ # Showing a thumbnail or playing media isn't a read worth a database write per render.+ record_access=request.headers.get("Sec-Fetch-Dest") not in ("image", "video", "audio"),)abs_path = result.abs_pathcontent_type = result.content_type@@ -627,16 +599,10 @@ async def download_asset_content(request: web.Request) -> web.Response:encoded = urllib.parse.quote(safe_name)cd = f"{disposition}; filename*=UTF-8''{encoded}"+ # debug, not info: preview_url points here, so every thumbnail render is a fetch.+ logging.debug("download_asset_content: path=%s, type=%s, name=%s", abs_path, content_type, filename)+file_size = os.path.getsize(abs_path)- size_mb = file_size / (1024 * 1024)- logging.info(- "download_asset_content: path=%s, size=%d bytes (%.2f MB), type=%s, name=%s",- abs_path,- file_size,- size_mb,- content_type,- filename,- )async def stream_file_chunks():chunk_size = 64 * 1024@@ -672,6 +638,9 @@ async def create_asset_from_hash_route(request: web.Request) -> web.Response:400, "INVALID_JSON", "Request body must be valid JSON.")+ if "preview" in (body.tags or ()):+ return _reserved_preview_tag()+# Derive name from hash if not providedname = body.nameif name is None:@@ -698,6 +667,7 @@ async def create_asset_from_hash_route(request: web.Request) -> web.Response:404, "ASSET_NOT_FOUND", f"Asset content {body.hash} does not exist")+ result = await _with_upload_preview(result)asset = _build_asset_response(result, _resolve_preview_paths([result]))payload_out = schemas_out.AssetCreated(**asset.model_dump(),@@ -733,6 +703,9 @@ async def upload_asset(request: web.Request) -> web.Response:return _build_error_response(400, "INVALID_BODY", f"Validation failed: {ve.json()}")+ if "preview" in (spec.tags or ()):+ delete_temp_file_if_exists(parsed.tmp_path)+ return _reserved_preview_tag()try:if not parsed.file_present and spec.hash:@@ -789,6 +762,7 @@ async def upload_asset(request: web.Request) -> web.Response:logging.exception("upload_asset failed for tenant_id=%s", tenant_id)return _build_error_response(500, "INTERNAL", "Unexpected server error.")+ result = await _with_upload_preview(result)asset = _build_asset_response(result, _resolve_preview_paths([result]))payload_out = schemas_out.AssetCreated(**asset.model_dump(),@@ -811,6 +785,12 @@ async def update_asset_route(request: web.Request) -> web.Response:400, "INVALID_JSON", "Request body must be valid JSON.")+ if body.preview_id == reference_id:+ # A self-reference makes the record undeletable (an ORM delete cycle).+ return _build_error_response(+ 400, "INVALID_BODY", "An asset cannot be its own preview_id.", {"id": reference_id}+ )+try:result = update_asset_metadata(reference_id=reference_id,diff --git a/app/assets/docs/README.md b/app/assets/docs/README.mdindex 613c74c4b..2cc317a26 100644--- a/app/assets/docs/README.md+++ b/app/assets/docs/README.md@@ -137,7 +137,7 @@ Classification is fixed at record creation. A newly visible path receives the reDelete the target asset record. Leave its content row and file intact. Do not soft-delete the record or revive the deleted identity during later discovery. The retained content row is not a tombstone: it is ordinary live content describing bytes that are still there, and nothing records that a deletion happened.-Deleting a record never deletes any other record. A preview record the deleted asset nominated stays untouched; references to a preview clear only when the preview record itself is deleted. The preview reference points from the deleted record to its target, so deleting the pointer must not destroy the target.+Deleting a record deletes no other record, with one exception: a preview record tagged `preview` that no other record links goes with it, and so does its file when no record still uses that content and the file is under the previews directory (see Previews). The file is removed inside the same write transaction, so a registration linking the same preview can't interleave with it. Any other preview the deleted asset nominated, such as an `output` image, stays untouched; references to a preview clear only when the preview record itself is deleted.Content left behind after all its asset records are deleted can still be resolved by hash lookup, falling back to a generic name and a guessed content type when no record is left to supply one. There is currently no mechanism that reclaims or removes such orphaned content.@@ -161,7 +161,7 @@ Uploads hash in both hashing modes, so this content-level dedup applies regardleAn asset record's `updated_at` reflects only the last explicit user or API edit to that record: a rename, a user-metadata update, a MIME-type change, a preview nomination, or a manual tag add or remove.-It never advances for serving or downloading the asset (access time is a separate concern from edit time), for scanner enrichment filling in extracted metadata, for the automatic missing or recovered tag projection, for a content split or content retire, or for the preview-deleted foreign-key cascade that clears a `preview_id`. Reading or downloading an asset's content instead updates a separate last-access marker on the record or records involved; that marker only ever moves forward, never backward. Minting a new record, whether from an upload, a cached rerun, or a content split, does not touch any other record's `updated_at`. The new record carries its own fresh timestamp from creation, and every existing record's last-explicit-edit time stays untouched.+It never advances for serving or downloading the asset (access time is a separate concern from edit time), for scanner enrichment filling in extracted metadata, for the automatic missing or recovered tag projection, for a content split or content retire, or for the preview-deleted foreign-key cascade that clears a `preview_id`. Reading or downloading an asset's content instead updates a separate last-access marker on the record or records involved, except when a browser fetches it to display as an image, video or audio element (`Sec-Fetch-Dest`), which is how a generated preview renders; that marker only ever moves forward, never backward. Minting a new record, whether from an upload, a cached rerun, or a content split, does not touch any other record's `updated_at`. The new record carries its own fresh timestamp from creation, and every existing record's last-explicit-edit time stays untouched.### Upload the same bytes with a different name@@ -281,6 +281,18 @@ Create one asset record and one content row per location. Equal hashes may reveaThe local asset system has global records and no owner field. It does not isolate or duplicate records by user.+### Previews++An asset's response carries `preview_url` and, when it has a linked preview, `preview_id`. `preview_url` is the path-based `/api/view` URL when the preview's file is under input, output or temp; a generated preview in the previews directory, which `/api/view` doesn't serve, is `/api/assets/{id}/content` with no query string. `preview_id` is only ever sent together with a working `preview_url`. A linked preview wins; otherwise an image, video, audio or text file previews itself, except EXR and Radiance HDR, which browsers can't display and which are never their own preview, matched by extension as well as MIME type. A stored link from an asset to itself is ignored, and `PUT /api/assets/{id}` refuses a link to the asset itself.++An EXR output of `SaveImageAdvanced` gets its preview from the node itself, written from the image it saves: a JPEG, or a WebP with alpha when the image has an alpha channel, of at most one megapixel, named by the blake3 hash of its bytes and written once, so identical previews share one file. The node writes it only when assets are running. Execution registers the output's record already linked to it, in the same transaction, so a listing never shows that record waiting for its preview; an asset scan that runs while the node is still saving its batch can list the file first, without one. Outputs of other save nodes get no generated preview. A preview written for a frame whose output never registered (the run was stopped, or registration failed) stays in the previews directory with no record. An EXR saved from HDR (Rec.2020) input is previewed as if its primaries were Rec.709, so its preview looks desaturated and dark.++An uploaded EXR (`/upload/image`, multipart `POST /api/assets`, from-hash creation) gets a preview decoded from the file, with the same tonemap, only when the record has no preview yet; a record over content another record already has a live preview for reuses that preview instead. A cached rerun of an output only ever reuses. Upload previews are WebP of at most one megapixel, with alpha when the EXR has an alpha channel. Files over 17 megapixels get none, checked from the EXR header before decoding.++All previews are stored in the previews directory (`<base>/previews`, or `--previews-directory`), tagged `preview`, and never scanned; the directory is owned, so the startup prune keeps them. `preview` is a reserved tag the tag endpoints refuse. Previews are ordinary assets, so a listing with no tag filter includes them; filter by `input`, `output` or `models` to leave them out.++The upload decodes on a worker thread, so the server stays responsive, and responds once its preview is stored. A failed decode leaves the upload without a preview. Each outcome is a `previews.generated` or `previews.generation_failed` event; previews the save node writes are logged only when they fail.+### `/view` routes`/view` accepts two query forms: a path-based form (`type`, `filename`, `subfolder`) and a blake3-hash form (`filename=blake3:<hash>`). `/api/assets/{id}/content` accepts an asset id and serves that asset's content directly. The blake3 form resolves only to non-temp content whose file is currently present (see Lookup and dedup against missing content).diff --git a/app/assets/event_log.py b/app/assets/event_log.pyindex bc88278dc..ee47ff4ee 100644--- a/app/assets/event_log.py+++ b/app/assets/event_log.py@@ -62,7 +62,10 @@ ALLOWED_EVENTS = frozenset({"scanner.watch_stat_failed","scanner.watch_spec_failed","scanner.watch_seed_failed",+ "previews.generated",+ "previews.generation_failed",})+PREVIEW_FAILURE_REASONS = frozenset({"too_large", "decode_failed", "write_failed"})class EventLogError(ValueError):@@ -115,6 +118,7 @@ ALLOWED_FIELDS: dict[str, Callable[[Any], bool]] = {"error_kind": _one_of(ERROR_KINDS),"hashing_enabled": _is_flag,"site": _one_of(STAT_SITES),+ "reason": _one_of(PREVIEW_FAILURE_REASONS),}_warned_call_sites: set[tuple[str, int]] = set()diff --git a/app/assets/lifecycle.py b/app/assets/lifecycle.pyindex 02f86e7ab..f5f755a22 100644--- a/app/assets/lifecycle.py+++ b/app/assets/lifecycle.py@@ -24,6 +24,7 @@ if dependencies_available():from app.assets.database.models import Asset, AssetContentfrom app.assets.database.queries.records import delete_recordfrom app.assets.helpers import sql_path_under_prefix+ from app.assets.services.asset_management import reclaim_previewfrom app.assets.services.hash_mode_state import enqueue_transition_workfrom app.assets.services.hash_mode_state import record_transition_intent@@ -58,18 +59,19 @@ def wipe_temp_db_rows(session) -> tuple[int, int]:# case-different persistent directory destroys user assets.under_temp = sql_path_under_prefix(AssetContent.path, temp_root)- temp_record_ids = list(- session.scalars(- select(Asset.id)- .join(AssetContent, Asset.content_id == AssetContent.id)- .where(under_temp)- )- )+ temp_records = session.execute(+ select(Asset.id, Asset.preview_id)+ .join(AssetContent, Asset.content_id == AssetContent.id)+ .where(under_temp)+ ).all()records_deleted = 0- for record_id in temp_record_ids:+ for record_id, _ in temp_records:delete_record(session, record_id)records_deleted += 1+ # Their previews live in previews/, not temp/, so the path predicate never reaches them.+ for preview_id in {preview_id for _, preview_id in temp_records if preview_id}:+ reclaim_preview(session, preview_id)contents_deleted = 0for content in session.scalars(select(AssetContent).where(under_temp)).all():diff --git a/app/assets/manager.py b/app/assets/manager.pyindex 8b89a5a48..f9bbf17a3 100644--- a/app/assets/manager.py+++ b/app/assets/manager.py@@ -62,7 +62,7 @@ class AssetManager(Protocol):) -> UploadAssetView | None: ...def register_executed_output(- self, abs_path: str, job_id: str | None+ self, abs_path: str, job_id: str | None, preview_ref: dict | None = None) -> RegisteredAsset | None: ...def register_cached_output(@@ -130,7 +130,7 @@ class NoAssets:return Nonedef register_executed_output(- self, abs_path: str, job_id: str | None+ self, abs_path: str, job_id: str | None, preview_ref: dict | None = None) -> RegisteredAsset | None:return None@@ -205,6 +205,7 @@ class AssetsEnabled:content_id=result.content_id,job_id=result.ref.job_id,name=result.ref.name,+ preview_id=result.ref.preview_id,)return UploadAssetView(asset=asset,@@ -218,9 +219,9 @@ class AssetsEnabled:return Nonedef register_executed_output(- self, abs_path: str, job_id: str | None+ self, abs_path: str, job_id: str | None, preview_ref: dict | None = None) -> RegisteredAsset | None:- return ingest_register_executed_output(abs_path, job_id)+ return ingest_register_executed_output(abs_path, job_id, preview_ref)def register_cached_output(self, abs_path: str, job_id: str | Nonediff --git a/app/assets/previews.py b/app/assets/previews.pynew file mode 100644index 000000000..119dae0e8--- /dev/null+++ b/app/assets/previews.py@@ -0,0 +1,129 @@+"""Previews of uploaded EXRs: decoded, stored and linked on upload. Best-effort, since an+asset without a preview is a normal state."""++from __future__ import annotations++import asyncio+import io+import mimetypes+import os+import time+import uuid++import av+import numpy as np+import torch+from PIL import Image++import folder_paths+from app.assets.database.models import Asset+from app.assets.database.queries.records import create_content, create_record+from app.assets.event_log import emit, error_type+from app.assets.services.image_dimensions import read_exr_windows+from app.database.db import create_write_session+from comfy_execution.preview_tonemap import linear_to_preview++# A decode costs ~30 MB per MP, and running out of memory can't be caught.+PREVIEW_MAX_SOURCE_PIXELS = 17_000_000+_DECODE_SLOTS = asyncio.Semaphore(2)+++class PreviewSkipped(Exception):+ """A preview Core declines to make; the argument is the event's reason."""+++def _decode_for_preview(path: str) -> Image.Image:+ """An SDR image of an EXR's display window, at most one megapixel; RGBA if the EXR has alpha."""+ windows = read_exr_windows(path)+ if windows is None:+ raise PreviewSkipped("decode_failed")+ if max(w * h for w, h in windows) > PREVIEW_MAX_SOURCE_PIXELS:+ raise PreviewSkipped("too_large")+ # Name the demuxer: left to probe, FFmpeg picks one from the file's contents.+ with av.open(path, format="exr_pipe") as container:+ frame = next(container.decode(video=0))+ if frame.format.name.startswith("gray"):+ # Exact; converting half-float gray to gbrpf32le crushes the darks.+ pixels = np.repeat(frame.to_ndarray(format="grayf32le")[..., None], 3, axis=-1)+ else:+ pixels = frame.to_ndarray(format="gbrapf32le" if len(frame.format.components) == 4 else "gbrpf32le")+ return linear_to_preview(torch.from_numpy(pixels))+++def _make_preview(path: str) -> tuple[bytes, int, int]:+ image = _decode_for_preview(path)+ buffer = io.BytesIO()+ image.save(buffer, format="WEBP", quality=80)+ return buffer.getvalue(), image.width, image.height+++def _store_and_link(parent_id: str, webp: bytes, width: int, height: int) -> str | None:+ """Write the preview, register it and link it. None if the parent is gone or got a preview meanwhile."""+ preview_id = str(uuid.uuid4())+ directory = folder_paths.get_previews_directory()+ path = os.path.join(directory, f"{preview_id}.webp")+ linked = False+ try:+ os.makedirs(directory, exist_ok=True)+ with open(path, "wb") as f:+ f.write(webp)+ mtime_ns = os.stat(path).st_mtime_ns+ # A write session holds the lock from its first statement, so this check and the link are atomic.+ with create_write_session() as session:+ parent = session.get(Asset, parent_id)+ if parent is None or parent.preview_id is not None:+ return None+ content = create_content(session, path, size_bytes=len(webp), mtime_ns=mtime_ns)+ record = create_record(+ session,+ content.id,+ f"{preview_id}.webp",+ mime_type="image/webp",+ tags=["preview"],+ system_metadata={"kind": "image", "width": width, "height": height},+ )+ parent.preview_id = record.id+ record_id = record.id+ session.commit()+ linked = True+ return record_id+ finally:+ if not linked and os.path.exists(path):+ os.remove(path)+++def is_exr(path: str) -> bool:+ """From the path, never an uploader-supplied type."""+ return mimetypes.guess_type(path, strict=False)[0] == "image/x-exr"+++def _emit_failed(reason: str) -> None:+ emit("previews.generation_failed", reason=reason)+++def _emit_error(reason: str, exc: BaseException) -> None:+ emit("previews.generation_failed", reason=reason, error_type=error_type(exc))+++async def generate_upload_preview(asset_id: str, path: str | None, preview_id: str | None) -> str | None:+ """The preview_id an upload ends with: the one it has, else one made now for an EXR."""+ if preview_id is not None or not path or not is_exr(path):+ return preview_id+ started = time.monotonic()+ try:+ async with _DECODE_SLOTS:+ webp, width, height = await asyncio.to_thread(_make_preview, path)+ except PreviewSkipped as skipped:+ _emit_failed(skipped.args[0])+ return None+ except Exception as exc:+ _emit_error("decode_failed", exc)+ return None+ try:+ linked = await asyncio.to_thread(_store_and_link, asset_id, webp, width, height)+ except Exception as exc:+ _emit_error("write_failed", exc)+ return None+ if linked is not None:+ emit("previews.generated", elapsed_ms=int((time.monotonic() - started) * 1000))+ return linkeddiff --git a/app/assets/scanner.py b/app/assets/scanner.pyindex da7963efe..66245cf1e 100644--- a/app/assets/scanner.py+++ b/app/assets/scanner.py@@ -200,7 +200,8 @@ def get_owned_prefixes() -> list[str]:"""Every directory an asset may live in; references outside these are marked missing."""scan_roots: tuple[RootType, ...] = ("models", "input", "output")prefixes = [p for root in scan_roots for p in get_scan_prefixes_for_root(root)]- return prefixes + get_temp_prefixes()+ # Owned but never scanned: previews are only ever registered by Core or an upload.+ return prefixes + get_temp_prefixes() + [os.path.abspath(folder_paths.get_previews_directory())]def get_temp_prefixes() -> list[str]:diff --git a/app/assets/services/asset_management.py b/app/assets/services/asset_management.pyindex f06495c2d..7e0d560e8 100644--- a/app/assets/services/asset_management.py+++ b/app/assets/services/asset_management.py@@ -5,12 +5,16 @@ tag updates move ``updated_at`` only when the requested values differ. Othersupplied metadata fields record a write."""+import loggingimport mimetypesimport os+from pathlib import Pathfrom typing import Sequencefrom sqlalchemy import delete, select, update+import folder_paths+from app.assets.database.models import Asset, AssetContent, AssetTagfrom app.assets.database.queries import (delete_record,@@ -35,7 +39,7 @@ from app.assets.services.schemas import (ReferenceData,UserMetadata,)-from app.database.db import create_session+from app.database.db import create_session, create_write_sessiondef _record_to_detail_result(session, record) -> AssetDetailResult:@@ -94,10 +98,12 @@ def update_asset_metadata(mime_type: str | None = None,preview_id: str | None = None,) -> AssetDetailResult:- with create_session() as session:+ # A write session: reclaiming a replaced preview can't interleave with a registration linking it.+ with create_write_session() as session:record = get_record_by_id(session, reference_id)if record is None:raise ValueError(f"Asset {reference_id} not found")+ replaced_preview_id = record.preview_idif name is not None:rename_record(session, reference_id, name)@@ -132,6 +138,9 @@ def update_asset_metadata(.where(Asset.id == reference_id).values(preview_id=preview_id, updated_at=get_utc_now()))+ if replaced_preview_id and replaced_preview_id != preview_id:+ session.flush()+ reclaim_preview(session, replaced_preview_id)if tags is not None:for tag_name in normalize_tags(list(tags)):ensure_tag(session, tag_name)@@ -152,13 +161,56 @@ def update_asset_metadata(return detail+def _is_core_preview(session, record: Asset) -> bool:+ """A preview Core made: tagged ``preview`` and stored under previews/."""+ if "preview" not in fetch_record_tags(session, record.id):+ return False+ path = session.get(AssetContent, record.content_id).path+ return Path(os.path.realpath(path)).is_relative_to(os.path.realpath(folder_paths.get_previews_directory()))+++def _drop_unused_content(session, content_id: str) -> None:+ """Remove a preview's content row and file once no record uses them."""+ if session.scalar(select(Asset.id).where(Asset.content_id == content_id).limit(1)) is not None:+ return+ content = session.get(AssetContent, content_id)+ session.delete(content)+ session.flush()+ # A missing row's path may since belong to a live row: an identical preview saved again.+ if content.is_missing or session.scalar(select(AssetContent.id).where(AssetContent.path == content.path).limit(1)):+ return+ try:+ os.remove(content.path)+ except OSError:+ logging.warning("Could not remove preview file %s", content.path, exc_info=True)+++def reclaim_preview(session, preview_id: str) -> None:+ """Delete a Core preview, and its file, once no record links or uses them."""+ preview = session.get(Asset, preview_id)+ if preview is None or session.scalar(select(Asset.id).where(Asset.preview_id == preview_id).limit(1)) is not None:+ return+ if _is_core_preview(session, preview):+ content_id = preview.content_id+ delete_record(session, preview_id)+ _drop_unused_content(session, content_id)++def delete_asset_reference(reference_id: str,) -> bool:- with create_session() as session:- if get_record_by_id(session, reference_id) is None:+ # A write session: a registration linking the same preview file can't interleave.+ with create_write_session() as session:+ record = get_record_by_id(session, reference_id)+ if record is None:return False+ content_id, preview_id = record.content_id, record.preview_id+ is_core_preview = _is_core_preview(session, record)delete_record(session, reference_id)+ if is_core_preview:+ _drop_unused_content(session, content_id)+ if preview_id:+ reclaim_preview(session, preview_id)session.commit()return True@@ -236,6 +288,7 @@ def get_preview_file_paths(preview_ids: list[str]) -> dict[str, str]:def resolve_asset_for_download(reference_id: str,+ record_access: bool = True,) -> DownloadResolutionResult:with create_session() as session:record = get_record_by_id(session, reference_id)@@ -257,8 +310,9 @@ def resolve_asset_for_download(asset_mime = record.mime_typeabs_path = content.path- update_record_access_time(session, reference_id)- session.commit()+ if record_access:+ update_record_access_time(session, reference_id)+ session.commit()ctype = (asset_mimediff --git a/app/assets/services/image_dimensions.py b/app/assets/services/image_dimensions.pyindex ccd97399a..14f3361da 100644--- a/app/assets/services/image_dimensions.py+++ b/app/assets/services/image_dimensions.py@@ -7,10 +7,58 @@ into ``AssetReference.system_metadata``.from __future__ import annotationsimport logging+import structfrom typing import Anylogger = logging.getLogger(__name__)+_EXR_MAGIC = b"\x76\x2f\x31\x01"+_EXR_MAX_ATTRIBUTES = 1024+++def _read_cstring(f) -> bytes:+ out = bytearray()+ while len(out) <= 255:+ b = f.read(1)+ if not b or b == b"\0":+ return bytes(out)+ out += b+ raise ValueError("EXR header name too long")+++def read_exr_windows(file_path: str) -> tuple[tuple[int, int], tuple[int, int]] | None:+ """(display, data) window sizes as (width, height), read from the header alone.++ Pillow can't open EXR, and opening it with PyAV buffers the whole file.+ """+ windows: dict[bytes, tuple[int, int]] = {}+ try:+ with open(file_path, "rb") as f:+ if f.read(4) != _EXR_MAGIC:+ return None+ f.read(4) # version and flags+ for _ in range(_EXR_MAX_ATTRIBUTES):+ name = _read_cstring(f)+ if not name:+ break+ _read_cstring(f) # attribute type+ (size,) = struct.unpack("<i", f.read(4))+ if size < 0:+ return None+ if name in (b"displayWindow", b"dataWindow") and size == 16:+ if name in windows:+ return None # decoders differ on which copy applies+ x_min, y_min, x_max, y_max = struct.unpack("<4i", f.read(16))+ windows[name] = (x_max - x_min + 1, y_max - y_min + 1)+ else:+ f.seek(size, 1)+ except (OSError, ValueError, struct.error):+ return None+ display, data = windows.get(b"displayWindow"), windows.get(b"dataWindow")+ if display is None or data is None or min(*display, *data) <= 0:+ return None+ return display, data+def extract_image_dimensions(file_path: str, mime_type: str | None = None@@ -33,6 +81,12 @@ def extract_image_dimensions("""if mime_type is not None and not mime_type.startswith("image/"):return None+ if mime_type == "image/x-exr":+ windows = read_exr_windows(file_path)+ if windows is None:+ return None+ (width, height), _ = windows+ return {"kind": "image", "width": width, "height": height}try:from PIL import Image, UnidentifiedImageErrordiff --git a/app/assets/services/ingest.py b/app/assets/services/ingest.pyindex 01d58c9f5..d98eee529 100644--- a/app/assets/services/ingest.py+++ b/app/assets/services/ingest.py@@ -13,12 +13,14 @@ import errnoimport loggingimport mimetypesimport os+import reimport shutilfrom typing import Any, NamedTuple, Sequencefrom sqlalchemy import false, func, select-from sqlalchemy.orm import Session+from sqlalchemy.orm import Session, aliased+import folder_pathsfrom app.assets import modefrom app.assets.database.models import Asset, AssetContent, AssetTagfrom app.assets.database.queries.records import (@@ -84,6 +86,77 @@ def _extract_system_metadata_sync(return system_metadata+def _live_sibling_preview_id(session: Session, content_id: str) -> str | None:+ """A ``preview``-tagged preview another record of the same content has, if its file is still there.++ A preview tagged otherwise was nominated by hand for that record, not made for the bytes.+ """+ preview = aliased(Asset)+ preview_content = aliased(AssetContent)+ rows = session.execute(+ select(Asset.preview_id, preview_content.path)+ .join(preview, preview.id == Asset.preview_id)+ .join(preview_content, preview_content.id == preview.content_id)+ .join(AssetTag, (AssetTag.asset_id == preview.id) & (AssetTag.tag_name == "preview"))+ .where(+ Asset.content_id == content_id,+ preview_content.is_missing == false(),+ )+ .order_by(Asset.created_at.desc())+ )+ # previews/ is never scanned, so a file removed by hand still reads as live.+ return next((preview_id for preview_id, path in rows if os.path.isfile(path)), None)+++_PREVIEW_FILENAME = re.compile(r"[0-9a-f]{64}\.(jpg|webp)")+++def _probe_output_preview(preview_ref: dict | None) -> tuple[str, str, int, int, os.stat_result] | None:+ """The file a save node named as its output's preview: trusted by name, so stat only."""+ if preview_ref is None:+ return None+ try:+ filename = preview_ref["filename"]+ if not isinstance(filename, str) or not _PREVIEW_FILENAME.fullmatch(filename):+ raise ValueError(f"not a preview file name: {filename!r}")+ path = os.path.join(folder_paths.get_previews_directory(), filename)+ return path, filename, int(preview_ref["width"]), int(preview_ref["height"]), os.stat(path)+ except Exception:+ logging.warning("Ignoring the preview named for an output: %r", preview_ref, exc_info=True)+ return None+++def _link_output_preview(session: Session, record: Asset, preview: tuple[str, str, int, int, os.stat_result]) -> None:+ """Link the output to its preview's record, creating it on first use; never fails the output."""+ path, filename, width, height, stat_result = preview+ try:+ with session.begin_nested():+ if not os.path.isfile(path):+ return # deleted with its last user since the probe; the write lock rules out a later delete+ content, _ = create_content_reporting_insert(+ session, path, f"blake3:{filename.partition('.')[0]}", stat_result.st_size, get_mtime_ns(stat_result)+ )+ preview_id = session.scalar(+ select(Asset.id)+ .join(AssetTag, (AssetTag.asset_id == Asset.id) & (AssetTag.tag_name == "preview"))+ .where(Asset.content_id == content.id)+ .limit(1)+ )+ if preview_id is None:+ preview_id = create_record(+ session,+ content.id,+ filename,+ mime_type="image/webp" if filename.endswith(".webp") else "image/jpeg",+ tags=["preview"],+ system_metadata={"kind": "image", "width": width, "height": height},+ ).id+ record.preview_id = preview_id+ session.flush()+ except Exception:+ logging.warning("Could not link the preview %s", filename, exc_info=True)++def _discard_unreferenced_content(session: Session, content_id: str) -> None:"""Remove a content row left orphaned by a failed registration.@@ -212,6 +285,9 @@ def _create_upload_record() -> Asset:if preview_id is not None and session.get(Asset, preview_id) is None:raise ValueError(f"preview_id {preview_id!r} does not reference an existing asset")+ if preview_id is None:+ # Same bytes, same picture: reuse the preview instead of generating another.+ preview_id = _live_sibling_preview_id(session, content_id)record = create_record(session,content_id,@@ -710,6 +786,9 @@ def register_cached_output(tags=path_tags,system_metadata=system_metadata,)+ sibling_preview_id = _live_sibling_preview_id(session, existing.id)+ if sibling_preview_id is not None:+ record.preview_id = sibling_preview_idsession.commit()except Exception:session.rollback()@@ -718,6 +797,7 @@ def register_cached_output(record_content_id = record.content_idrecord_job_id = record.job_idrecord_name = record.name+ record_preview_id = record.preview_idexcept Exception:logging.exception("Failed to register cached output: %s", locator)return None@@ -727,13 +807,15 @@ def register_cached_output(content_id=record_content_id,job_id=record_job_id,name=record_name,+ preview_id=record_preview_id,)def register_executed_output(- abs_path: str, job_id: str | None = None+ abs_path: str, job_id: str | None = None, preview_ref: dict | None = None) -> RegisteredAsset | None:locator = os.path.abspath(abs_path)+ preview = _probe_output_preview(preview_ref)try:stat_result = os.stat(locator, follow_symlinks=True)size_bytes = stat_result.st_size@@ -769,11 +851,14 @@ def register_executed_output(tags=path_tags,system_metadata=system_metadata,)+ if preview is not None:+ _link_output_preview(session, record, preview)# Read before commit: expiry would reload them in a second write transaction.record_id = record.idrecord_content_id = record.content_idrecord_job_id = record.job_idrecord_name = record.name+ record_preview_id = record.preview_idsession.commit()except Exception:session.rollback()@@ -789,4 +874,5 @@ def register_executed_output(content_id=record_content_id,job_id=record_job_id,name=record_name,+ preview_id=record_preview_id,)diff --git a/app/assets/services/preview_rules.py b/app/assets/services/preview_rules.pynew file mode 100644index 000000000..6ec44cf4a--- /dev/null+++ b/app/assets/services/preview_rules.py@@ -0,0 +1,77 @@+"""How an asset's preview is reported: a linked preview, the asset itself, or none."""+import mimetypes+import os+import urllib.parse++from app.assets.services.path_utils import compute_asset_response_paths+++# What a client can render from the bytes themselves; anything else needs a nominated preview.+PREVIEWABLE_MIME_PREFIXES = ("image/", "video/", "audio/", "text/")++# Images browsers can't display. Matched by extension too, since hosts differ on .hdr.+_NEVER_SELF_EXTENSIONS = frozenset({".exr", ".hdr"})+_NEVER_SELF_MIME_TYPES = frozenset({"image/x-exr", "image/vnd.radiance"})+++def previews_itself(mime_type: str | None, path: str | None) -> bool:+ """Whether a client can render the file itself as its preview.++ ``path`` is the on-disk path, not the caller-editable name, so a rename cannot+ change what previews.+ """+ mime = (mime_type or mimetypes.guess_type(path or "")[0] or "").split(";", 1)[0].strip().lower()+ if not mime.startswith(PREVIEWABLE_MIME_PREFIXES):+ return False+ return mime not in _NEVER_SELF_MIME_TYPES and os.path.splitext(path or "")[1].lower() not in _NEVER_SELF_EXTENSIONS+++# models is deliberately absent: /api/view has no directory type for it.+VIEWABLE_NAMESPACES = frozenset({"input", "output", "temp"})+++def view_url(file_path: str | None) -> str | None:+ # /api/view is a FileResponse: byte-range seeking, no user header, no access write.+ if not file_path:+ return None+ paths = compute_asset_response_paths(file_path)+ if not paths:+ return None+ logical_path, relative_path = paths+ namespace = logical_path.split("/", 1)[0]+ if namespace not in VIEWABLE_NAMESPACES or not relative_path:+ return None++ subfolder, _, filename = relative_path.rpartition("/")+ url = f"/api/view?type={namespace}&filename={urllib.parse.quote(filename, safe='')}"+ if subfolder:+ url += f"&subfolder={urllib.parse.quote(subfolder, safe='')}"+ return url+++def content_url(asset_id: str) -> str:+ # No query string: clients tell this form apart from /api/view?type=... by that.+ return f"/api/assets/{asset_id}/content"+++def preview_fields(+ asset_id: str,+ preview_id: str | None,+ mime_type: str | None,+ file_path: str | None,+ is_missing: bool,+ preview_paths: dict[str, str],+) -> tuple[str | None, str | None]:+ """(preview_id, preview_url); preview_id is only ever sent with a URL."""+ # A self-nomination is ignored: whether a file is its own preview is decided below.+ if preview_id and preview_id != asset_id:+ # A nominated preview is one whatever it holds, so no media check here.+ if preview_id in preview_paths:+ # By id only where /api/view can't serve the file, such as previews/.+ return preview_id, view_url(preview_paths[preview_id]) or content_url(preview_id)+ return None, None+ if is_missing or not file_path:+ return None, None+ if not previews_itself(mime_type, file_path):+ return None, None+ return None, view_url(file_path)diff --git a/app/assets/services/schemas.py b/app/assets/services/schemas.pyindex 8f3efa6cb..0b77daf40 100644--- a/app/assets/services/schemas.py+++ b/app/assets/services/schemas.py@@ -102,6 +102,7 @@ class RegisteredAsset:content_id: strjob_id: str | Nonename: str+ preview_id: str | None = None@dataclass(frozen=True)diff --git a/comfy/cli_args.py b/comfy/cli_args.pyindex 8b0a42c7f..f42dfbb4d 100644--- a/comfy/cli_args.py+++ b/comfy/cli_args.py@@ -72,6 +72,7 @@ parser.add_argument("--extra-model-paths-config", type=str, default=None, metavaparser.add_argument("--output-directory", type=str, default=None, help="Set the ComfyUI output directory. Overrides --base-directory.")parser.add_argument("--temp-directory", type=str, default=None, help="Set the ComfyUI temp directory (default is in the ComfyUI directory). Overrides --base-directory.")parser.add_argument("--input-directory", type=str, default=None, help="Set the ComfyUI input directory. Overrides --base-directory.")+parser.add_argument("--previews-directory", type=str, default=None, help="Set the directory for generated asset previews. Overrides --base-directory.")parser.add_argument("--auto-launch", action="store_true", help="Automatically launch ComfyUI in the default browser.")parser.add_argument("--disable-auto-launch", action="store_true", help="Disable auto launching the browser.")parser.add_argument("--cuda-device", type=str, default=None, metavar="DEVICE_ID", help="Set the ids of cuda devices this instance will use, as a comma-separated list (e.g. '0' or '0,1'), or 'all' to leave all currently visible devices available. All other devices will not be visible.")diff --git a/comfy_execution/asset_enrichment.py b/comfy_execution/asset_enrichment.pyindex 328f38298..cd1eb0f6b 100644--- a/comfy_execution/asset_enrichment.py+++ b/comfy_execution/asset_enrichment.py@@ -60,10 +60,31 @@ def _enrich_in_place(result = register(abs_path, job_id)if result is not None:entry["id"] = result.id+ if result.preview_id:+ entry["preview_id"] = result.preview_idexcept Exception:logging.warning("Asset registration failed for output: %s", entry.get("filename"), exc_info=True)+def take_asset_previews(output_ui: dict) -> dict[str, dict]:+ """Pop the previews save nodes named for their outputs, by output path, so none reaches clients or the cache."""+ previews: dict[str, dict] = {}+ for entries in output_ui.values():+ if not isinstance(entries, list):+ continue+ for entry in entries:+ if not isinstance(entry, dict) or "asset_preview" not in entry:+ continue+ preview = entry.pop("asset_preview")+ try:+ abs_path = _resolve_output_path(entry)+ except Exception:+ continue+ if abs_path is not None:+ previews[abs_path] = preview+ return previews++def _strip_ids(output_ui: dict) -> None:for entries in output_ui.values():if not isinstance(entries, list):@@ -71,14 +92,20 @@ def _strip_ids(output_ui: dict) -> None:for entry in entries:if isinstance(entry, dict):entry.pop("id", None)+ entry.pop("preview_id", None)-def register_executed_outputs(output_ui: dict, job_id: str, asset_manager: "AssetManager") -> dict:+def register_executed_outputs(output_ui: dict, job_id: str, asset_manager: "AssetManager", asset_previews: dict[str, dict] | None = None) -> dict:enriched = copy.deepcopy(output_ui)if not asset_manager.enabled:return enriched- _enrich_in_place(enriched, job_id, asset_manager.register_executed_output)+ previews = asset_previews or {}+ _enrich_in_place(+ enriched,+ job_id,+ lambda path, job: asset_manager.register_executed_output(path, job, preview_ref=previews.get(path)),+ )return enricheddiff --git a/comfy_execution/preview_tonemap.py b/comfy_execution/preview_tonemap.pynew file mode 100644index 000000000..a8d5f050e--- /dev/null+++ b/comfy_execution/preview_tonemap.py@@ -0,0 +1,38 @@+"""The tonemap Core's previews share: the save node's and the upload decoder's."""++import torch+import torch.nn.functional as F+from PIL import Image++PREVIEW_MAX_PIXELS = 1_000_000+++def linear_to_preview(image: torch.Tensor, max_pixels: int = PREVIEW_MAX_PIXELS) -> Image.Image:+ """An 8-bit sRGB image of a scene-linear (H, W, C) image, at most ``max_pixels``; RGBA if C is 4.++ Clamps to [0, 1]. RGBA is straight alpha, averaged weighted by alpha so colour under+ transparent pixels doesn't bleed into the edges.+ """+ if image.ndim == 2:+ image = image.unsqueeze(-1)+ x = torch.nan_to_num(image.float(), nan=0.0, posinf=1.0, neginf=0.0)+ if x.shape[-1] == 1:+ x = x.expand(-1, -1, 3)+ height, width = x.shape[:2]+ x = x.movedim(-1, 0).unsqueeze(0)+ has_alpha = x.shape[1] == 4+ if has_alpha:+ alpha = x[:, 3:].clamp(0.0, 1.0)+ x = torch.cat([x[:, :3] * alpha, alpha], dim=1)+ # WebP's side limit is 16383 px.+ scale = min(1.0, (max_pixels / (width * height)) ** 0.5, 16383 / max(width, height))+ if scale < 1.0:+ x = F.interpolate(x, size=(max(1, int(height * scale)), max(1, int(width * scale))), mode="area")+ if has_alpha:+ alpha = x[:, 3:]+ x = torch.cat([torch.where(alpha > 0, x[:, :3] / alpha.clamp_min(1e-12), 0.0), alpha], dim=1)+ linear = x[0].movedim(0, -1).clamp(0.0, 1.0)+ rgb = linear[..., :3]+ linear[..., :3] = torch.where(rgb <= 0.0031308, rgb * 12.92, 1.055 * rgb.pow(1 / 2.4) - 0.055)+ pixels = (linear * 255 + 0.5).to(torch.uint8).cpu().numpy()+ return Image.fromarray(pixels, "RGBA" if has_alpha else "RGB")diff --git a/comfy_extras/nodes_images.py b/comfy_extras/nodes_images.pyindex 4628d6609..a2491148a 100644--- a/comfy_extras/nodes_images.py+++ b/comfy_extras/nodes_images.py@@ -2,6 +2,7 @@ import nodesimport folder_pathsimport av+import ioimport jsonimport os@@ -12,6 +13,7 @@ import structimport torchimport loggingimport tempfile+import uuidimport zlibimport comfy.utils@@ -21,6 +23,7 @@ from PIL.Image import Exiffrom server import PromptServerfrom comfy_api.latest import ComfyExtension, IO, UI+from comfy_execution.preview_tonemap import linear_to_previewfrom comfy.cli_args import argsfrom typing_extensions import override@@ -1639,6 +1642,48 @@ def inject_avif_metadata(path: str, metadata: dict) -> None:# Encoding# ---------------------------------------------------------------------------+def _to_scene_linear(img_tensor: torch.Tensor, colorspace: str) -> torch.Tensor:+ if colorspace == "sRGB":+ return srgb_to_linear(img_tensor)+ if colorspace == "HDR":+ return hlg_to_linear(img_tensor)+ return img_tensor+++def _write_asset_preview(linear: torch.Tensor) -> dict | None:+ """Write a preview of a scene-linear image to previews/, named by its blake3 hash."""+ try:+ from blake3 import blake3 # an optional assets dependency; ComfyUI starts without it++ image = linear_to_preview(linear)+ buffer = io.BytesIO()+ if image.mode == "RGBA":+ image.save(buffer, format="WEBP", quality=80)+ ext = "webp"+ else:+ image.save(buffer, format="JPEG", quality=85)+ ext = "jpg"+ data = buffer.getvalue()+ filename = f"{blake3(data).hexdigest()}.{ext}"+ directory = folder_paths.get_previews_directory()+ path = os.path.join(directory, filename)+ if not os.path.exists(path):+ os.makedirs(directory, exist_ok=True)+ # Publish atomically, so a truncated file never sits under a trusted name.+ temp_path = f"{path}.{uuid.uuid4().hex}.tmp"+ try:+ with open(temp_path, "wb") as f:+ f.write(data)+ os.replace(temp_path, path)+ finally:+ if os.path.exists(temp_path):+ os.remove(temp_path)+ return {"filename": filename, "width": image.width, "height": image.height}+ except Exception:+ logging.warning("Could not write a preview for an EXR output", exc_info=True)+ return None++def _encode_image(img_tensor: torch.Tensor,file_format: str,@@ -1673,10 +1718,7 @@ def _encode_image(if spec["dtype"] == np.float32:# EXR path: preserve full range, no clamp.- if colorspace == "sRGB":- img_tensor = srgb_to_linear(img_tensor)- elif colorspace == "HDR":- img_tensor = hlg_to_linear(img_tensor)+ img_tensor = _to_scene_linear(img_tensor, colorspace)if bit_depth == "16-bit float":# Round to half precision before FFmpeg's truncating float-to-half conversion.img_tensor = img_tensor.to(torch.float16)@@ -1913,8 +1955,13 @@ class SaveImageAdvanced(IO.ComfyNode):ui["animated"] = (True,)return IO.NodeOutput(images, ui=ui)+ write_previews = file_format == "exr" and PromptServer.instance.asset_manager.enabledfor batch_number, image in enumerate(images):- encoded = _encode_image(image, file_format, bit_depth, colorspace)+ if file_format == "exr":+ if image.ndim == 2:+ image = image.unsqueeze(-1) # before conversion, which reads a 4-wide last dim as RGBA+ image = _to_scene_linear(image, colorspace)+ encoded = _encode_image(image, file_format, bit_depth, "linear" if file_format == "exr" else colorspace)if write_metadata:if file_format == "png":@@ -1927,7 +1974,12 @@ class SaveImageAdvanced(IO.ComfyNode):with open(os.path.join(full_output_folder, file), "wb") as f:f.write(encoded)- results.append({"filename": file, "subfolder": subfolder, "type": "output"})+ entry = {"filename": file, "subfolder": subfolder, "type": "output"}+ if write_previews:+ asset_preview = _write_asset_preview(image)+ if asset_preview is not None:+ entry["asset_preview"] = asset_preview+ results.append(entry)counter += 1return IO.NodeOutput(images, ui={"images": results})diff --git a/execution.py b/execution.pyindex d4a68b32a..305f1dbb7 100644--- a/execution.py+++ b/execution.py@@ -43,7 +43,7 @@ from comfy_execution.graph_utils import GraphBuilder, is_linkfrom comfy_execution.validation import LoopValidationError, validate_loops, validate_node_inputfrom comfy_execution.progress import get_progress_state, reset_progress_state, add_progress_handler, WebUIProgressHandlerfrom comfy_execution.utils import CurrentNodeContext-from comfy_execution.asset_enrichment import register_executed_outputs, emit_cached_output+from comfy_execution.asset_enrichment import register_executed_outputs, emit_cached_output, take_asset_previewsfrom comfy_execution.media_enrichment import enrich_output_with_media_metadatafrom comfy_api.internal import _ComfyNodeInternal, _NodeOutputInternal, first_real_override, is_class, make_locked_method_funcfrom comfy_api.latest import io, _io@@ -565,6 +565,7 @@ async def execute(server: "ExecutionServer", dynprompt, caches, current_item, exreturn (ExecutionResult.PENDING, None, None)cache_ui_value = ui_outputs.get(unique_id)if len(output_ui) > 0:+ asset_previews = take_asset_previews(output_ui)output_ui = enrich_output_with_media_metadata(output_ui)meta = {"node_id": unique_id,@@ -572,7 +573,7 @@ async def execute(server: "ExecutionServer", dynprompt, caches, current_item, ex"parent_node": parent_node_id,"real_node_id": real_node_id,}- enriched_output_ui = register_executed_outputs(output_ui, prompt_id, asset_manager)+ enriched_output_ui = register_executed_outputs(output_ui, prompt_id, asset_manager, asset_previews)ui_outputs[unique_id] = {"meta": meta, "output": enriched_output_ui}cache_ui_value = {"meta": meta, "output": output_ui}if server.client_id is not None:diff --git a/folder_paths.py b/folder_paths.pyindex 6723e52c8..0673f6c95 100644--- a/folder_paths.py+++ b/folder_paths.py@@ -68,6 +68,7 @@ folder_names_and_paths["detection"] = ([os.path.join(models_dir, "detection")],output_directory = os.path.join(base_path, "output")temp_directory = os.path.join(base_path, "temp")+previews_directory = os.path.join(base_path, "previews")input_directory = os.path.join(base_path, "input")user_directory = os.path.join(base_path, "user")@@ -131,6 +132,10 @@ def set_input_directory(input_dir: str) -> None:global input_directoryinput_directory = input_dir+def set_previews_directory(previews_dir: str) -> None:+ global previews_directory+ previews_directory = previews_dir+def get_output_directory() -> str:global output_directoryreturn output_directory@@ -143,6 +148,10 @@ def get_input_directory() -> str:global input_directoryreturn input_directory+def get_previews_directory() -> str:+ """Where generated asset previews are stored. Not served by type through /view."""+ return previews_directory+def get_user_directory() -> str:return user_directorydiff --git a/main.py b/main.pyindex b93c2a81c..25dd02fc5 100644--- a/main.py+++ b/main.py@@ -27,7 +27,6 @@ from app.database.db import dependencies_available, get_database_url, get_db_patfrom app.assets.event_log import error_kindfrom utils.install_util import get_missing_requirements_messagefrom app.assets.lifecycle import cleanup_temp_filesystem-from app.assets.manager import AssetManager, default_asset_managerimport itertoolsimport utils.extra_configfrom utils.mime_types import init_mime_types@@ -165,6 +164,11 @@ def apply_custom_paths():logging.info(f"Setting input directory to: {input_dir}")folder_paths.set_input_directory(input_dir)+ if args.previews_directory:+ previews_dir = os.path.abspath(args.previews_directory)+ logging.info(f"Setting previews directory to: {previews_dir}")+ folder_paths.set_previews_directory(previews_dir)+if args.user_directory:user_dir = os.path.abspath(args.user_directory)logging.info(f"Setting user directory to: {user_dir}")@@ -256,6 +260,7 @@ import comfy.utilsimport executionimport server+from app.assets.manager import AssetManager, default_asset_manager # imports torch, so not before the check abovefrom protocol import BinaryEventTypesimport nodesimport comfy.model_managementdiff --git a/server.py b/server.pyindex ca0399df2..7e7236e0f 100644--- a/server.py+++ b/server.py@@ -49,11 +49,14 @@ from app.assets.event_log import emitfrom app.database.db import dependencies_availableif dependencies_available():+ from app.assets.previews import generate_upload_previewfrom app.assets.services.asset_management import (get_export_file,+ get_preview_file_paths,list_job_export_files,resolve_hash_to_path,)+ from app.assets.services.preview_rules import preview_fieldsfrom app.asset_export import AssetExportManagerfrom app.user_manager import UserManager@@ -456,6 +459,11 @@ class PromptServer():return Falsedef image_upload(post, image_save_function=None):+ resp, _, _ = store_image_upload(post, image_save_function)+ return resp if isinstance(resp, web.Response) else web.json_response(resp)++ def store_image_upload(post, image_save_function=None):+ """(response dict or error Response, registered asset view or None, file path)."""image = post.get("image")overwrite = post.get("overwrite")image_is_duplicate = False@@ -466,14 +474,14 @@ class PromptServer():if image and image.file:filename = image.filenameif not filename:- return web.Response(status=400)+ return web.Response(status=400), None, Nonesubfolder = post.get("subfolder", "")full_output_folder = os.path.join(upload_dir, os.path.normpath(subfolder))filepath = os.path.abspath(os.path.join(full_output_folder, filename))if os.path.commonpath((upload_dir, filepath)) != upload_dir:- return web.Response(status=400)+ return web.Response(status=400), None, Noneif not os.path.exists(full_output_folder):os.makedirs(full_output_folder)@@ -518,14 +526,25 @@ class PromptServer():"tags": view.tags,}- return web.json_response(resp)+ return resp, view, filepathelse:- return web.Response(status=400)+ return web.Response(status=400), None, None@routes.post("/upload/image")async def upload_image(request):post = await request.post()- return image_upload(post)+ resp, view, filepath = store_image_upload(post)+ if view is not None:+ preview_id = await generate_upload_preview(view.asset.id, filepath, view.asset.preview_id)+ live_previews = get_preview_file_paths([preview_id]) if preview_id else {}+ preview_id, preview_url = preview_fields(+ view.asset.id, preview_id, view.mime_type, filepath, False, live_previews+ )+ if preview_url is not None:+ resp["asset"]["preview_url"] = preview_url+ if preview_id is not None:+ resp["asset"]["preview_id"] = preview_id+ return resp if isinstance(resp, web.Response) else web.json_response(resp)@routes.post("/upload/mask")diff --git a/tests-unit/assets_test/services/conftest.py b/tests-unit/assets_test/services/conftest.pyindex 3d9bf8c66..9cb734901 100644--- a/tests-unit/assets_test/services/conftest.py+++ b/tests-unit/assets_test/services/conftest.py@@ -5,12 +5,19 @@ from unittest.mock import patchimport pytestfrom sqlalchemy import create_engine, event+from sqlalchemy.pool import StaticPoolfrom sqlalchemy.orm import Session, Session as SASession, sessionmaker+import folder_pathsfrom app.assets import modefrom app.assets.database.models import Base+def _memory_engine():+ # One shared connection: upload previews are stored from a worker thread.+ return create_engine("sqlite:///:memory:", poolclass=StaticPool, connect_args={"check_same_thread": False})++@pytest.fixture(autouse=True)def autoclean_unit_test_assets():"""Override parent autouse fixture - service unit tests don't need server cleanup."""@@ -30,7 +37,7 @@ def initialised_hash_mode():@pytest.fixturedef db_engine():"""In-memory SQLite engine for fast unit tests."""- engine = create_engine("sqlite:///:memory:")+ engine = _memory_engine()Base.metadata.create_all(engine)return engine@@ -38,7 +45,7 @@ def db_engine():@pytest.fixturedef db_engine_fk():"""In-memory SQLite engine with foreign key enforcement enabled."""- engine = create_engine("sqlite:///:memory:")+ engine = _memory_engine()@event.listens_for(engine, "connect")def _set_pragma(dbapi_connection, connection_record):@@ -77,3 +84,18 @@ def temp_dir():"""Temporary directory for file operations."""with tempfile.TemporaryDirectory() as tmpdir:yield Path(tmpdir)+++def roots(tmp_path: Path):+ """input/, output/ and previews/ in tmp_path, as Core's roots."""+ saved = (folder_paths.get_output_directory(), folder_paths.get_input_directory(), folder_paths.get_previews_directory())+ folder_paths.set_output_directory(str(tmp_path / "output"))+ folder_paths.set_input_directory(str(tmp_path / "input"))+ folder_paths.set_previews_directory(str(tmp_path / "previews"))+ for name in ("output", "input", "previews"):+ (tmp_path / name).mkdir()+ yield tmp_path+ folder_paths.set_output_directory(saved[0])+ folder_paths.set_input_directory(saved[1])+ folder_paths.set_previews_directory(saved[2])diff --git a/tests-unit/assets_test/services/preview_helpers.py b/tests-unit/assets_test/services/preview_helpers.pynew file mode 100644index 000000000..41e365b92--- /dev/null+++ b/tests-unit/assets_test/services/preview_helpers.py@@ -0,0 +1,55 @@+"""An EXR writer shared by the preview tests."""++import struct+from fractions import Fraction+from pathlib import Path++import av+import numpy as np+++def write_exr(path: Path, width: int, height: int, value=(1.0, 0.5, 0.25), display_window=None) -> Path:+ """An EXR the way SaveImageAdvanced writes one (PyAV, uncompressed half); RGBA given 4 values."""+ fmt = "gbrapf32le" if len(value) == 4 else "gbrpf32le"+ pixels = np.empty((height, width, len(value)), np.float32)+ pixels[...] = value+ codec = av.CodecContext.create("exr", "w")+ codec.width, codec.height, codec.pix_fmt = width, height, fmt+ codec.time_base = Fraction(1, 1)+ codec.options = {"format": "half"}+ frame = av.VideoFrame.from_ndarray(pixels, format=fmt)+ frame.pts = 0+ frame.time_base = codec.time_base+ data = bytearray(b"".join(bytes(p) for p in list(codec.encode(frame)) + list(codec.encode(None))))+ if display_window is not None:+ key = b"displayWindow\x00box2i\x00"+ at = data.find(key) + len(key) + 4+ struct.pack_into("<4i", data, at, *display_window)+ path.write_bytes(bytes(data))+ return path+++def write_preview(roots: Path, size=(4, 3), color=(200, 100, 50), alpha=False) -> dict:+ """A preview the way SaveImageAdvanced names one: previews/<blake3>.jpg (.webp with alpha), and its entry ref."""+ import io++ from blake3 import blake3+ from PIL import Image++ buffer = io.BytesIO()+ if alpha:+ Image.new("RGBA", size, (*color, 128)).save(buffer, format="WEBP", quality=80)+ else:+ Image.new("RGB", size, color).save(buffer, format="JPEG", quality=85)+ data = buffer.getvalue()+ filename = f"{blake3(data).hexdigest()}.{'webp' if alpha else 'jpg'}"+ (roots / "previews" / filename).write_bytes(data)+ return {"filename": filename, "width": size[0], "height": size[1]}+++def duplicate_data_window(data: bytes) -> bytes:+ """An EXR header with its dataWindow attribute repeated."""+ key = b"dataWindow\x00box2i\x00"+ at = data.find(key)+ end = at + len(key) + 4 + 16+ return data[:end] + data[at:end] + data[end:]diff --git a/tests-unit/assets_test/services/test_asset_response_preview_url.py b/tests-unit/assets_test/services/test_asset_response_preview_url.pyindex e0a3d3115..307f79538 100644--- a/tests-unit/assets_test/services/test_asset_response_preview_url.py+++ b/tests-unit/assets_test/services/test_asset_response_preview_url.py@@ -383,3 +383,43 @@ def test_record_response_has_no_self_preview_url_when_content_is_missing(assert resp.preview_url is None, ("the list surface must also withhold a missing record's self-preview URL")+++ ("name", "mime_type"),+ [+ ("frame.exr", "image/x-exr"),+ ("frame.exr", None),+ ("frame.exr", "image/png"), # a client-supplied type+ ("sky.hdr", "image/vnd.radiance"),+ ("sky.hdr", None),+ ("sky.HDR", "image/x-whatever-this-host-says"),+ ("blake3-named-upload", "image/x-exr"),+ ],+)+def test_exr_and_hdr_are_never_their_own_preview(+ sandboxed_comfy_roots: Path, name: str, mime_type: str | None+):+ resp = _build_asset_response(+ _make_result(name=name, file_path=str(sandboxed_comfy_roots / "output" / name), mime_type=mime_type),+ {},+ )++ assert (resp.preview_id, resp.preview_url) == (None, None), (+ "browsers can't display these, so the bytes must never be offered as a preview"+ )+++def test_an_exr_with_a_generated_preview_shows_it(sandboxed_comfy_roots: Path):+ result = _make_result(+ name="frame.exr",+ file_path=str(sandboxed_comfy_roots / "output" / "frame.exr"),+ mime_type="image/x-exr",+ preview_id="preview-ref",+ )++ resp = _build_asset_response(result, {"preview-ref": str(sandboxed_comfy_roots / "previews" / "p.webp")})++ assert (resp.preview_id, resp.preview_url) == ("preview-ref", "/api/assets/preview-ref/content"), (+ "/api/view can't serve previews/, so a generated preview is served by id"+ )diff --git a/tests-unit/assets_test/services/test_manager_isolated.py b/tests-unit/assets_test/services/test_manager_isolated.pyindex ef600f4e7..fbd21f608 100644--- a/tests-unit/assets_test/services/test_manager_isolated.py+++ b/tests-unit/assets_test/services/test_manager_isolated.py@@ -207,6 +207,7 @@ def test_executed_and_cached_outputs_share_unhashed_content("content_id","job_id","name",+ "preview_id",}with mock_create_session() as session:asset = session.get(Asset, executed.id)diff --git a/tests-unit/assets_test/services/test_metadata_update_b.py b/tests-unit/assets_test/services/test_metadata_update_b.pyindex 20ba1b3b1..f711f37df 100644--- a/tests-unit/assets_test/services/test_metadata_update_b.py+++ b/tests-unit/assets_test/services/test_metadata_update_b.py@@ -57,3 +57,27 @@ def test_update_asset_metadata_unknown_preview_id_raises(session, mock_create_sesession.expire_all()assert session.get(Asset, record.id).preview_id is None+++async def test_put_rejects_an_asset_as_its_own_preview(session, mock_create_session):+ from unittest.mock import AsyncMock, patch++ from aiohttp import web+ from aiohttp.test_utils import make_mocked_request++ from app.assets.api import routes++ record = _create_record(session, "/output/self.png")+ request = make_mocked_request("PUT", f"/api/assets/{record.id}", match_info={"id": record.id})++ with (+ patch.object(routes, "_ASSETS_ENABLED", True),+ patch.object(web.BaseRequest, "json", AsyncMock(return_value={"preview_id": record.id})),+ ):+ response = await routes.update_asset_route(request)++ assert response.status == 400, "a self-reference makes the record undeletable, so it is refused"+ assert b"INVALID_BODY" in response.body+ session.expire_all()+ assert session.get(Asset, record.id).preview_id is Nonediff --git a/tests-unit/assets_test/services/test_output_previews.py b/tests-unit/assets_test/services/test_output_previews.pynew file mode 100644index 000000000..74a626231--- /dev/null+++ b/tests-unit/assets_test/services/test_output_previews.py@@ -0,0 +1,33 @@+"""An output registers already linked to the preview its save node named."""++from sqlalchemy import event+from sqlalchemy.orm import Session++from app.assets.database.models import Asset, AssetContent+from app.assets.services.ingest import register_executed_output++from .preview_helpers import write_exr, write_preview+++def test_the_output_row_is_never_committed_without_its_preview(session, mock_create_session, roots):+ ref = write_preview(roots)+ committed: list = []++ def before_commit(s):+ if s.in_nested_transaction():+ return # a savepoint, not the commit that makes the row visible+ s.flush()+ committed.extend(a.preview_id for a in s.identity_map.values() if isinstance(a, Asset) and a.name == "frame.exr")++ event.listen(Session, "before_commit", before_commit)+ try:+ result = register_executed_output(str(write_exr(roots / "output" / "frame.exr", 8, 8)), "job", ref)+ finally:+ event.remove(Session, "before_commit", before_commit)++ assert committed and None not in committed+ preview = session.get(Asset, result.preview_id)+ assert preview.name == ref["filename"] and preview.mime_type == "image/jpeg"+ assert [t.name for t in preview.tags] == ["preview"]+ assert preview.system_metadata == {"kind": "image", "width": 4, "height": 3}+ assert session.get(AssetContent, preview.content_id).hash == f"blake3:{ref['filename'][:64]}"diff --git a/tests-unit/assets_test/services/test_preview_lifecycle.py b/tests-unit/assets_test/services/test_preview_lifecycle.pynew file mode 100644index 000000000..f16614bab--- /dev/null+++ b/tests-unit/assets_test/services/test_preview_lifecycle.py@@ -0,0 +1,81 @@+from pathlib import Path++import pytest++import folder_paths+from app.assets.database.models import Asset, AssetContent+from app.assets.database.queries.records import create_content, create_record, mark_content_missing+from app.assets.lifecycle import wipe_temp_db_rows+from app.assets.services.asset_management import delete_asset_reference, update_asset_metadata+++def db_engine(db_engine_fk):+ """Foreign keys on, as in production: deletes rely on RESTRICT, SET NULL and cascades."""+ return db_engine_fk+++def _record(session, path: Path, *, tags=(), preview_id=None) -> str:+ path.parent.mkdir(parents=True, exist_ok=True)+ if not path.exists():+ path.write_bytes(path.name.encode())+ content = session.query(AssetContent).filter_by(path=str(path), is_missing=False).one_or_none() or create_content(session, str(path))+ record = create_record(session, content.id, path.name, tags=list(tags))+ record.preview_id = preview_id+ session.commit()+ return record.id+++def test_previews_are_reclaimed_with_their_last_user_and_never_before(session, mock_create_session, roots, tmp_path):+ previews = roots / "previews"++ # Shared by two outputs: survives the first delete, goes with the second.+ shared = _record(session, previews / "shared.webp", tags=["preview"])+ first = _record(session, roots / "output" / "a.exr", preview_id=shared)+ second = _record(session, roots / "output" / "b.exr", preview_id=shared)+ delete_asset_reference(first)+ assert (previews / "shared.webp").exists() and session.get(Asset, shared) is not None+ delete_asset_reference(second)+ session.expire_all()+ assert not (previews / "shared.webp").exists() and session.get(Asset, shared) is None++ # A file another record also uses stays when one of them goes.+ twin_a = _record(session, previews / "twin.webp", tags=["preview"])+ _record(session, previews / "twin.webp", tags=["preview"])+ delete_asset_reference(_record(session, roots / "output" / "d.exr", preview_id=twin_a))+ assert (previews / "twin.webp").exists(), "the other record still uses the file"++ # Deleting a preview itself reclaims its file.+ direct = _record(session, previews / "direct.webp", tags=["preview"])+ _record(session, roots / "output" / "e.exr", preview_id=direct)+ delete_asset_reference(direct)+ assert not (previews / "direct.webp").exists()++ # A preview replaced through PUT goes once nothing links it.+ generated = _record(session, previews / "generated.webp", tags=["preview"])+ chosen = _record(session, roots / "output" / "chosen.png")+ update_asset_metadata(_record(session, roots / "output" / "f.exr", preview_id=generated), preview_id=chosen)+ session.expire_all()+ assert session.get(Asset, generated) is None and not (previews / "generated.webp").exists()++ # A missing row's path that a live preview now uses keeps its file.+ old = _record(session, previews / "again.webp", tags=["preview"])+ parent = _record(session, roots / "output" / "c.exr", preview_id=old)+ mark_content_missing(session, session.get(Asset, old).content_id)+ session.commit()+ _record(session, previews / "again.webp", tags=["preview"])+ delete_asset_reference(parent)+ assert (previews / "again.webp").exists(), "the newer preview still uses this file"++ # A temp upload's preview goes with the restart temp wipe.+ saved = folder_paths.get_temp_directory()+ folder_paths.set_temp_directory(str(tmp_path / "temp"))+ try:+ temp_preview = _record(session, previews / "temp.webp", tags=["preview"])+ _record(session, tmp_path / "temp" / "upload.exr", tags=["input"], preview_id=temp_preview)+ wipe_temp_db_rows(session)+ session.commit()+ finally:+ folder_paths.set_temp_directory(saved)+ session.expire_all()+ assert session.get(Asset, temp_preview) is None and not (previews / "temp.webp").exists()diff --git a/tests-unit/assets_test/services/test_previews.py b/tests-unit/assets_test/services/test_previews.pynew file mode 100644index 000000000..062778b29--- /dev/null+++ b/tests-unit/assets_test/services/test_previews.py@@ -0,0 +1,43 @@+import asyncio+import threading+import time+from unittest.mock import patch++import pytest++from app.assets import previews++[email protected](("height", "skipped"), [(4000, False), (4001, True)])+def test_upload_decodes_are_bounded(tmp_path, height, skipped):+ """A decode costs ~30 MB per megapixel, and running out of memory can't be caught."""+ # Over 17 megapixels is skipped from the header, before decoding.+ with (+ patch.object(previews, "read_exr_windows", return_value=[(4250, height)]),+ patch.object(previews.av, "open", side_effect=RuntimeError("decoded")) as decode,+ ):+ with pytest.raises(previews.PreviewSkipped if skipped else RuntimeError):+ previews._decode_for_preview("a.exr")+ assert decode.called is not skipped++ # At most two decode at once, and the rest still get their preview.+ running, peak, lock = 0, 0, threading.Lock()++ def make(path):+ nonlocal running, peak+ with lock:+ running += 1+ peak = max(peak, running)+ time.sleep(0.05)+ with lock:+ running -= 1+ return b"webp", 2, 2++ async def uploads():+ # A semaphore made inside this loop, at the module's limit, so the module's stays unbound.+ with patch.object(previews, "_DECODE_SLOTS", asyncio.Semaphore(previews._DECODE_SLOTS._value)):+ await asyncio.gather(*(previews.generate_upload_preview(f"id{i}", str(tmp_path / f"{i}.exr"), None) for i in range(6)))++ with patch.object(previews, "_make_preview", make), patch.object(previews, "_store_and_link", return_value="linked") as store:+ asyncio.run(uploads())+ assert peak == 2 and store.call_count == 6diff --git a/tests-unit/assets_test/services/test_startup_imports.py b/tests-unit/assets_test/services/test_startup_imports.pynew file mode 100644index 000000000..4e6007eb7--- /dev/null+++ b/tests-unit/assets_test/services/test_startup_imports.py@@ -0,0 +1,20 @@+import subprocess+import sys+from pathlib import Path++# Runs main.py's top-level imports up to its "Torch already imported" check, in a fresh process.+_REPLAY = """+import ast, sys+tree = ast.parse(open("main.py").read())+check = next(n.lineno for n in tree.body if isinstance(n, ast.If) and "torch" in ast.unparse(n.test))+sys.argv = ["main.py"]+for node in tree.body:+ if isinstance(node, (ast.Import, ast.ImportFrom)) and node.lineno < check:+ exec(compile(ast.Module([node], []), "main.py", "exec"), {})+assert "torch" not in sys.modules, "torch imported before main.py's check"+"""+++def test_nothing_main_imports_before_its_torch_check_loads_torch():+ """cuda_malloc, aimdo and prestartup scripts must all run before torch loads."""+ subprocess.run([sys.executable, "-c", _REPLAY], check=True, cwd=Path(__file__).resolve().parents[3])diff --git a/tests-unit/assets_test/services/test_upload_previews.py b/tests-unit/assets_test/services/test_upload_previews.pynew file mode 100644index 000000000..7ca25a86e--- /dev/null+++ b/tests-unit/assets_test/services/test_upload_previews.py@@ -0,0 +1,156 @@+import io+import json+from unittest.mock import MagicMock, patch++import pytest+from aiohttp import FormData+from aiohttp.test_utils import TestClient, TestServer+from PIL import Image++from app.assets.manager import AssetsEnabled++from .preview_helpers import duplicate_data_window, write_exr+++class _Args:+ enable_assets = True+ enable_asset_hashing = False+++def _png() -> bytes:+ buffer = io.BytesIO()+ Image.new("RGBA", (8, 8), (255, 0, 0, 255)).save(buffer, format="PNG")+ return buffer.getvalue()+++async def _client(asset_manager) -> TestClient:+ from comfy.cli_args import args+ from utils.mime_types import init_mime_types++ # Importing server initialises the device; these tests never touch a model.+ with patch.object(args, "cpu", True):+ import server+ init_mime_types()+ prompt_server = server.PromptServer(None, asset_manager)+ prompt_server.app.add_routes(prompt_server.routes)+ return TestClient(TestServer(prompt_server.app))+++def _form(name: str, data: bytes, **fields) -> FormData:+ form = FormData()+ form.add_field("image", data, filename=name)+ for key, value in fields.items():+ form.add_field(key, value)+ return form+++async def _assets_client():+ from aiohttp import web++ from app.assets.api import routes+ from utils.mime_types import init_mime_types++ init_mime_types()+ app = web.Application()+ app.add_routes(routes.ROUTES)+ return TestClient(TestServer(app))+++def assets_routes_on():+ from app.assets.api import routes++ with (+ patch.object(routes, "_ASSETS_ENABLED", True),+ patch.object(routes, "USER_MANAGER", MagicMock(get_request_user_id=MagicMock(return_value="default"))),+ ):+ yield+++async def _upload(route: str, exr: bytes, roots, session) -> dict:+ if route == "/upload/image":+ async with await _client(AssetsEnabled(_Args())) as client:+ asset = (await (await client.post(route, data=_form("frame.exr", exr))).json())["asset"]+ return asset | {"preview": await (await client.get(asset["preview_url"])).read()}+ async with await _assets_client() as client:+ if route == "multipart":+ form = FormData()+ form.add_field("file", exr, filename="frame.exr")+ form.add_field("tags", json.dumps(["input"]))+ resp = await client.post("/api/assets", data=form)+ else: # from-hash, over content a previous run already stored+ from app.assets import mode+ from app.assets.database.queries.records import create_content++ class _HashingOn:+ enable_asset_hashing = True++ mode.init(_HashingOn())+ path = roots / "input" / "frame.exr"+ path.write_bytes(exr)+ digest = "blake3:" + "ab" * 32+ create_content(session, str(path), hash=digest, size_bytes=len(exr), mtime_ns=path.stat().st_mtime_ns)+ session.commit()+ resp = await client.post("/api/assets/from-hash", json={"hash": digest, "name": "frame.exr", "tags": ["input"]})+ asset = await resp.json()+ assert resp.status == 201, asset+ return asset | {"preview": await (await client.get(asset["preview_url"])).read()}++[email protected]("route", ["/upload/image", "multipart", "from-hash"])[email protected](("value", "mode"), [((0.5, 0.5, 0.5), "RGB"), ((0.5, 0.5, 0.5, 0.25), "RGBA")])+async def test_an_uploaded_exr_comes_back_with_its_preview(mock_create_session, roots, tmp_path, assets_routes_on, session, route, value, mode):+ from app.assets import previews++ exr = write_exr(tmp_path / "src.exr", 64, 48, value=value).read_bytes()++ with patch.object(previews, "_make_preview", wraps=previews._make_preview) as make:+ asset = await _upload(route, exr, roots, session)+ if route == "/upload/image":+ again = await _upload(route, exr, roots, session)+ assert again["preview_id"] == asset["preview_id"], "the same bytes reuse their preview"+ assert make.call_count == 1, "and aren't decoded again"++ assert asset["preview_id"] not in (None, asset["id"])+ assert asset["preview_url"] == f"/api/assets/{asset['preview_id']}/content"+ preview = Image.open(io.BytesIO(asset["preview"]))+ assert (preview.format, preview.mode, preview.size) == ("WEBP", mode, (64, 48)), "alpha is kept"++[email protected]("bad", [b"not an exr", "duplicated window"])+async def test_an_exr_that_cant_be_previewed_still_uploads(mock_create_session, roots, tmp_path, bad):+ data = bad if isinstance(bad, bytes) else duplicate_data_window(write_exr(tmp_path / "a.exr", 64, 48).read_bytes())+ async with await _client(AssetsEnabled(_Args())) as client:+ resp = await client.post("/upload/image", data=_form("broken.exr", data))+ asset = (await resp.json())["asset"]++ assert resp.status == 200+ assert "preview_id" not in asset and "preview_url" not in asset+++async def test_mask_upload_still_answers_with_json(mock_create_session, roots):+ (roots / "input" / "base.png").write_bytes(_png())+ original_ref = json.dumps({"filename": "base.png", "type": "input", "subfolder": ""})+ async with await _client(AssetsEnabled(_Args())) as client:+ resp = await client.post("/upload/mask", data=_form("mask.png", _png(), original_ref=original_ref))+ body = await resp.json()++ assert resp.status == 200+ assert body["name"] == "mask.png"+++async def test_clients_cannot_create_a_preview_tagged_asset(mock_create_session, roots, tmp_path, assets_routes_on):+ form = FormData()+ form.add_field("file", b"png", filename="mine.png")+ form.add_field("tags", json.dumps(["input", "preview"]))+ async with await _assets_client() as client:+ upload = await client.post("/api/assets", data=form)+ from_hash = await client.post("/api/assets/from-hash", json={"hash": "blake3:" + "ab" * 32, "tags": ["input", "preview"]})+ bodies = [await upload.json(), await from_hash.json()]++ assert [upload.status, from_hash.status] == [400, 400]+ assert [body["error"]["code"] for body in bodies] == ["SYSTEM_TAG_FORBIDDEN"] * 2diff --git a/tests-unit/assets_test/test_event_log.py b/tests-unit/assets_test/test_event_log.pyindex dd946ccd9..ec5743001 100644--- a/tests-unit/assets_test/test_event_log.py+++ b/tests-unit/assets_test/test_event_log.py@@ -48,6 +48,7 @@ VALID_VALUES: dict[str, list[object]] = {"error_kind": sorted(ERROR_KINDS),"hashing_enabled": [True, False],"site": ["discovery", "enrich"],+ "reason": ["too_large", "decode_failed", "write_failed"],}diff --git a/tests-unit/comfy_extras_test/save_image_advanced_preview_test.py b/tests-unit/comfy_extras_test/save_image_advanced_preview_test.pynew file mode 100644index 000000000..4ca57dab1--- /dev/null+++ b/tests-unit/comfy_extras_test/save_image_advanced_preview_test.py@@ -0,0 +1,99 @@+"""SaveImageAdvanced writes a content-addressed preview next to each EXR when assets are on."""++import sys+from types import SimpleNamespace+from unittest.mock import MagicMock, patch++import numpy as np+import pytest+import torch+from PIL import Image++import folder_paths+from comfy.cli_args import args+from comfy_execution.preview_tonemap import linear_to_preview++previous_nodes = sys.modules.get("nodes")+previous_server = sys.modules.get("server")+sys.modules["nodes"] = MagicMock(MAX_RESOLUTION=16384)+sys.modules["server"] = MagicMock()+from comfy_extras import nodes_images # noqa: E402+from comfy_extras.nodes_images import SaveImageAdvanced # noqa: E402+for name, previous in (("nodes", previous_nodes), ("server", previous_server)):+ if previous is None:+ sys.modules.pop(name)+ else:+ sys.modules[name] = previous+++def dirs(tmp_path, monkeypatch):+ saved = (folder_paths.get_output_directory(), folder_paths.get_previews_directory())+ folder_paths.set_output_directory(str(tmp_path / "output"))+ folder_paths.set_previews_directory(str(tmp_path / "previews"))+ (tmp_path / "output").mkdir()+ monkeypatch.setattr(nodes_images.PromptServer, "instance", SimpleNamespace(asset_manager=SimpleNamespace(enabled=True)), raising=False)+ monkeypatch.setattr(args, "disable_metadata", True)+ monkeypatch.setattr(SaveImageAdvanced, "hidden", SimpleNamespace(prompt=None, extra_pnginfo=None), raising=False)+ yield tmp_path+ folder_paths.set_output_directory(saved[0])+ folder_paths.set_previews_directory(saved[1])+++def _save(images: torch.Tensor, colorspace: str = "linear", bit_depth: str = "32-bit float") -> list[dict]:+ fmt = {"format": "exr", "bit_depth": bit_depth, "input_color_space": colorspace}+ return SaveImageAdvanced.execute(images, "t", fmt).ui["images"]+++def test_an_rgba_exr_gets_a_webp_with_straight_alpha_within_one_megapixel(dirs):+ rgba = torch.empty((1, 1000, 1200, 4))+ rgba[..., :3] = 0.1+ rgba[..., 3] = 0.2++ ref = _save(rgba)[0]["asset_preview"]++ image = Image.open(dirs / "previews" / ref["filename"])+ assert ref["filename"].endswith(".webp") and image.mode == "RGBA"+ assert (ref["width"], ref["height"]) == image.size and image.width * image.height <= 1_000_000 < 1200 * 1000+ pixel = np.asarray(image)[image.height // 2, image.width // 2]+ assert abs(int(pixel[0]) - 89) <= 3, "sRGB(0.1), not brightened by un-premultiplying"+ assert abs(int(pixel[3]) - 51) <= 3+++def test_with_assets_off_no_preview_is_written(dirs, monkeypatch):+ monkeypatch.setattr(nodes_images.PromptServer.instance.asset_manager, "enabled", False)++ entry = _save(torch.full((1, 8, 8, 3), 0.5))[0]++ assert "asset_preview" not in entry+ assert not (dirs / "previews").exists()+++def test_a_failing_preview_never_fails_the_save(dirs):+ with patch.object(nodes_images, "linear_to_preview", side_effect=RuntimeError("boom")):+ entry = _save(torch.full((1, 8, 8, 3), 0.5))[0]++ assert "asset_preview" not in entry+ assert (dirs / "output" / entry["filename"]).is_file()+++ ("image", "colorspace", "expected"),+ [+ # Over-range clamps to white, linear 0.5 is sRGB 188 (not 128), black stays black.+ (torch.tensor([[[[4.0, 0.5, 0.0], [0.0, 0.0, 0.0]]]]), "linear", [[[255, 188, 0], [0, 0, 0]]]),+ # Channel-less gray 4 wide, sRGB in: every column converted, and half-float darks kept+ # (0.28 sRGB is linear ~0.064, sRGB 71; crushed darks were near 0).+ (torch.full((1, 2, 4), 0.28), "sRGB", [[[71, 71, 71]] * 4] * 2),+ ],+)+def test_the_preview_pixels_match_the_golden_for_outputs_and_uploads(dirs, image, colorspace, expected):+ from app.assets.previews import _decode_for_preview++ with patch.object(nodes_images, "linear_to_preview", wraps=linear_to_preview) as tonemap:+ entry = _save(image, colorspace, bit_depth="16-bit float")[0]++ written = np.asarray(linear_to_preview(tonemap.call_args.args[0]))+ uploaded = np.asarray(_decode_for_preview(str(dirs / "output" / entry["filename"])))+ assert written.tolist() == expected, "the save node's preview"+ assert uploaded.tolist() == expected, "the upload decoder's preview of the saved EXR"diff --git a/tests-unit/execution_test/test_inmemory_assets.py b/tests-unit/execution_test/test_inmemory_assets.pyindex c67861366..a3030474a 100644--- a/tests-unit/execution_test/test_inmemory_assets.py+++ b/tests-unit/execution_test/test_inmemory_assets.py@@ -77,7 +77,7 @@ class InMemoryAssets:return Nonedef register_executed_output(- self, abs_path: str, job_id: str | None+ self, abs_path: str, job_id: str | None, preview_ref: dict | None = None) -> RegisteredAsset | None:self._record("register_executed_output", abs_path, job_id)deliveries = self.deliveries_by_path.setdefault(abs_path, [])diff --git a/tests-unit/folder_paths_test/filter_by_content_types_test.py b/tests-unit/folder_paths_test/filter_by_content_types_test.pyindex d11f0159a..bcd21f607 100644--- a/tests-unit/folder_paths_test/filter_by_content_types_test.py+++ b/tests-unit/folder_paths_test/filter_by_content_types_test.py@@ -66,3 +66,13 @@ def test_handles_no_extension():def test_handles_no_files():files = []assert filter_files_content_types(files, ["image", "audio", "video"]) == []++++def test_exr_is_listed_as_an_image_once_registered():+ # LoadImage decodes EXR through PyAV, so registering .exr makes it selectable.+ from utils.mime_types import init_mime_types++ init_mime_types()+ with patch("folder_paths.extension_mimetypes_cache", extension_mimetypes_cache.copy()):+ assert filter_files_content_types(["a.exr", "b.png"], ["image"]) == ["a.exr", "b.png"]diff --git a/tests-unit/security_test/test_ghsa_779p_06_inline_svg_image_dest.py b/tests-unit/security_test/test_ghsa_779p_06_inline_svg_image_dest.pyindex 7afdc9a2c..8c7666498 100644--- a/tests-unit/security_test/test_ghsa_779p_06_inline_svg_image_dest.py+++ b/tests-unit/security_test/test_ghsa_779p_06_inline_svg_image_dest.py@@ -119,7 +119,7 @@ def asset_app(monkeypatch, tmp_path):monkeypatch.setattr(asset_routes,"resolve_asset_for_download",- lambda reference_id: DownloadResolutionResult(+ lambda reference_id, **_: DownloadResolutionResult(abs_path=str(svg),content_type=stored_mime_type,download_name="thumb.svg",diff --git a/tests-unit/test_assets_event_log_static.py b/tests-unit/test_assets_event_log_static.pyindex fd76692e2..4d7c90b34 100644--- a/tests-unit/test_assets_event_log_static.py+++ b/tests-unit/test_assets_event_log_static.py@@ -78,6 +78,10 @@ EXPECTED_CALL_SITES: frozenset[CallSite] = frozenset(CallSite("app/assets/scanner_admission.py", "tick_watch_list", "scanner.watch_seed_failed"),+ # preview generation outcomes, for rollout failure rates+ CallSite("app/assets/previews.py", "generate_upload_preview", "previews.generated"),+ CallSite("app/assets/previews.py", "_emit_failed", "previews.generation_failed"),+ CallSite("app/assets/previews.py", "_emit_error", "previews.generation_failed"),})diff --git a/tests/execution/test_exr_previews.py b/tests/execution/test_exr_previews.pynew file mode 100644index 000000000..2abfc1a26--- /dev/null+++ b/tests/execution/test_exr_previews.py@@ -0,0 +1,158 @@+"""EXR outputs register already linked to the preview their save node wrote: a real server with assets enabled."""++import io+import json+import socket+import subprocess+import threading+import time+import urllib.request+import uuid++import pytest+import websocket+from PIL import Image++from comfy_execution.graph_utils import GraphBuilder++[email protected](scope="module")+def server(args_pytest, tmp_path_factory):+ work = tmp_path_factory.mktemp("exr-previews")+ log = (work / "server.log").open("w")+ # Its own port: a server another module hasn't finished killing must not answer for this one.+ with socket.socket() as probe:+ probe.bind((args_pytest["listen"], 0))+ port = probe.getsockname()[1]+ process = subprocess.Popen([+ "python", "main.py",+ "--output-directory", args_pytest["output_dir"],+ "--listen", args_pytest["listen"],+ "--port", str(port),+ "--extra-model-paths-config", "tests/execution/extra_model_paths.yaml",+ "--cpu",+ "--enable-assets",+ "--database-url", f"sqlite:///{work / 'assets.db'}",+ "--previews-directory", str(work / "previews"),+ ], stdout=log, stderr=subprocess.STDOUT)+ base = f"http://{args_pytest['listen']}:{port}"+ try:+ for _ in range(120):+ if process.poll() is not None:+ pytest.fail(f"server exited with {process.returncode}:\n{(work / 'server.log').read_text()[-4000:]}")+ try:+ urllib.request.urlopen(f"{base}/system_stats", timeout=2)+ break+ except OSError:+ time.sleep(1)+ else:+ pytest.fail(f"server never answered:\n{(work / 'server.log').read_text()[-4000:]}")+ yield base, work / "previews"+ finally:+ process.kill()+ process.wait(timeout=10)+ log.close()+++def _run(base: str, prompt: dict) -> tuple[dict, str]:+ """Queue a prompt and return its executed messages by node id, and its prompt id."""+ client_id = str(uuid.uuid4())+ ws = websocket.WebSocket()+ ws.settimeout(120)+ ws.connect(f"ws://{base.removeprefix('http://')}/ws?clientId={client_id}")+ request = urllib.request.Request(f"{base}/prompt", data=json.dumps({"prompt": prompt, "client_id": client_id}).encode())+ prompt_id = json.loads(urllib.request.urlopen(request).read())["prompt_id"]+ executed = {}+ while True:+ message = ws.recv()+ if not isinstance(message, str):+ continue+ message = json.loads(message)+ data = message.get("data", {})+ if data.get("prompt_id") != prompt_id:+ continue+ if message["type"] == "execution_error":+ raise AssertionError(data)+ if message["type"] == "executed":+ executed[data["node"]] = data["output"]+ if message["type"] == "executing" and data["node"] is None:+ ws.close()+ return executed, prompt_id+++def _exr_save_graph(prefix: str, batch_size: int) -> tuple[dict, str]:+ g = GraphBuilder(prefix=prefix)+ # Small frames: decode speed is the unit tests' business, not this one's.+ image = g.node("StubImage", content="WHITE", height=60, width=200, batch_size=batch_size)+ save = g.node(+ "SaveImageAdvanced",+ images=image.out(0),+ filename_prefix=f"exr_previews/{prefix}",+ format="exr",+ **{"format.bit_depth": "16-bit float", "format.input_color_space": "sRGB"},+ )+ return g.finalize(), save.id+++def _get(base: str, path: str):+ with urllib.request.urlopen(f"{base}{path}") as response:+ return json.loads(response.read())+++def test_saved_exr_frames_carry_their_preview(server):+ base, previews_dir = server+ prefix = f"exr_{uuid.uuid4().hex[:8]}"+ prompt, save_id = _exr_save_graph(prefix, batch_size=3)+ unlinked, done = [], threading.Event()++ def poll_listing():+ # Every listing while the job runs: an output is never visible without its preview.+ while not done.is_set():+ for asset in _get(base, "/api/assets?include_tags=output&limit=500")["assets"]:+ if asset["name"].startswith(prefix) and not asset.get("preview_id"):+ unlinked.append(asset["name"])+ time.sleep(0.01)++ poller = threading.Thread(target=poll_listing)+ poller.start()+ try:+ executed, prompt_id = _run(base, prompt)+ finally:+ done.set()+ poller.join()+ entries = executed[save_id]["images"]+ assert unlinked == [], "an output was listed before its preview was linked"+ listed = [a for a in _get(base, "/api/assets?include_tags=output&limit=500")["assets"] if a["name"].startswith(prefix)]+ assert len(listed) == 3 and all(a.get("preview_id") for a in listed), "the poll's query finds these outputs"++ assert len(entries) == 3+ for entry in entries:+ assert entry["filename"].endswith(".exr")+ assert entry["preview_id"] != entry["id"], "an EXR is never its own preview"+ with urllib.request.urlopen(f"{base}/api/assets/{entry['preview_id']}/content") as response:+ preview = Image.open(io.BytesIO(response.read()))+ assert preview.format == "JPEG"+ assert preview.size == (200, 60)+ asset = _get(base, f"/api/assets/{entry['id']}")+ assert asset["preview_id"] == entry["preview_id"]+ assert asset["metadata"]["width"] == 200 and asset["metadata"]["height"] == 60+ assert len({entry["preview_id"] for entry in entries}) == 1, "identical frames share one preview"+ assert len(list(previews_dir.glob("*.jpg"))) >= 1+ for value in (executed, _get(base, f"/history/{prompt_id}"), _get(base, f"/api/jobs/{prompt_id}")):+ assert "asset_preview" not in json.dumps(value)+++def test_a_cached_rerun_keeps_the_preview(server):+ base, _ = server+ prompt, save_id = _exr_save_graph(f"exr_{uuid.uuid4().hex[:8]}", batch_size=1)++ first = _run(base, prompt)[0][save_id]["images"][0]+ replay, _ = _run(base, prompt)+ replay = replay[save_id]["images"][0]++ assert replay["filename"] == first["filename"], "served from cache, not saved again"+ assert replay["id"] != first["id"], "a replay registers its own record"+ assert replay["preview_id"] == first["preview_id"], "and reuses the preview of the same bytes"+ assert "asset_preview" not in replaydiff --git a/utils/mime_types.py b/utils/mime_types.pyindex a173ad109..333535499 100644--- a/utils/mime_types.py+++ b/utils/mime_types.py@@ -25,6 +25,7 @@ def init_mime_types():mimetypes.add_type('application/javascript; charset=utf-8', '.js')mimetypes.add_type('image/webp', '.webp')mimetypes.add_type('image/svg+xml', '.svg')+ mimetypes.add_type('image/x-exr', '.exr')# Model and data file types (used by asset scanning / metadata extraction)mimetypes.add_type("application/safetensors", ".safetensors")