Skip to content

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): extract video metadata into system_metadata on ingest and scan (#15180)

Terry Jia73c4868d3032
diff --git a/app/assets/scanner.py b/app/assets/scanner.py
index b8cfeb048..8c441c044 100644
--- a/app/assets/scanner.py
+++ b/app/assets/scanner.py
@@ -67,7 +67,7 @@ from app.assets.services.file_utils import (
walk_listings,
)
from app.assets.services.gil import yield_gil
-from app.assets.services.image_dimensions import extract_image_dimensions
+from app.assets.services.media_metadata import extract_media_metadata
from app.assets.services.metadata_extract import ExtractedMetadata, extract_file_metadata
from app.assets.services.path_utils import (
compute_loader_path,
@@ -1041,10 +1041,9 @@ def enrich_asset(
if extract_metadata and metadata:
system_metadata = metadata.to_user_metadata()
- if mime_type and mime_type.startswith("image/"):
- dims = extract_image_dimensions(file_path, mime_type=mime_type)
- if dims:
- system_metadata.update(dims)
+ dims = extract_media_metadata(file_path, mime_type=mime_type)
+ if dims:
+ system_metadata.update(dims)
record.system_metadata = {**(record.system_metadata or {}), **system_metadata}
if stored_hash:
diff --git a/app/assets/services/ingest.py b/app/assets/services/ingest.py
index bbc5665b3..01d58c9f5 100644
--- a/app/assets/services/ingest.py
+++ b/app/assets/services/ingest.py
@@ -28,13 +28,13 @@ from app.assets.database.queries.records import (
)
from app.assets.helpers import normalize_tags, to_stored_hash
from app.assets.services.file_utils import get_mtime_ns, get_size_and_mtime_ns
-from app.assets.services.image_dimensions import extract_image_dimensions
from app.assets.services.lookup import (
claim_qualified_content,
lookup_for_from_hash,
lookup_for_view,
refresh_qualified_content,
)
+from app.assets.services.media_metadata import extract_media_metadata
from app.assets.services.metadata_extract import extract_file_metadata
from app.assets.services.path_utils import (
compute_loader_path,
@@ -68,8 +68,8 @@ def _extract_system_metadata_sync(
) -> dict[str, Any]:
"""Extract ``system_metadata`` at registration time (S29/D8).
- Mirrors the ``scanner.enrich`` pass: tier-1/tier-2 file metadata plus image
- dimensions for image MIME types, so records carry metadata at creation
+ Mirrors the ``scanner.enrich`` pass: tier-1/tier-2 file metadata plus media
+ metadata for image and video MIME types, so records carry metadata at creation
instead of waiting for the background enrich pass to fill it.
"""
metadata = extract_file_metadata(
@@ -78,10 +78,9 @@ def _extract_system_metadata_sync(
relative_filename=compute_loader_path(locator),
)
system_metadata = metadata.to_user_metadata()
- if mime_type and mime_type.startswith("image/"):
- dims = extract_image_dimensions(locator, mime_type=mime_type)
- if dims:
- system_metadata.update(dims)
+ dims = extract_media_metadata(locator, mime_type=mime_type)
+ if dims:
+ system_metadata.update(dims)
return system_metadata
diff --git a/app/assets/services/media_metadata.py b/app/assets/services/media_metadata.py
new file mode 100644
index 000000000..17d4ae2fa
--- /dev/null
+++ b/app/assets/services/media_metadata.py
@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from typing import Any
+
+from app.assets.services.image_dimensions import extract_image_dimensions
+from app.assets.services.video_metadata import extract_video_metadata
+
+
+def extract_media_metadata(
+ file_path: str, mime_type: str | None = None
+) -> dict[str, Any] | None:
+ """Extract media metadata for the file, dispatched on the MIME prefix.
+
+ Returns ``None`` for non-media MIME types or unreadable files.
+ """
+ if not mime_type:
+ return None
+ if mime_type.startswith("image/"):
+ return extract_image_dimensions(file_path, mime_type=mime_type)
+ if mime_type.startswith("video/"):
+ return extract_video_metadata(file_path, mime_type=mime_type)
+ return None
diff --git a/app/assets/services/video_metadata.py b/app/assets/services/video_metadata.py
new file mode 100644
index 000000000..31c1ffe1e
--- /dev/null
+++ b/app/assets/services/video_metadata.py
@@ -0,0 +1,79 @@
+"""Video metadata extraction for asset ingest.
+
+Reads only the container/stream headers via PyAV to capture dimensions,
+duration, fps and frame count cheaply, without decoding frames. Returns a
+metadata dict suitable for merging into ``AssetReference.system_metadata``.
+"""
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+def extract_video_metadata(
+ file_path: str, mime_type: str | None = None
+) -> dict[str, Any] | None:
+ """Extract video stream metadata for the file at ``file_path``.
+
+ Args:
+ file_path: Absolute path to a file on disk.
+ mime_type: Optional MIME type hint. When provided and not prefixed
+ with ``video/``, extraction is skipped without touching the file.
+
+ Returns:
+ ``{"kind": "video", "width": W, "height": H, ...}`` with optional
+ ``duration`` (seconds), ``fps`` and ``frame_count`` keys when the
+ file has a recognizable video stream, otherwise ``None``.
+ """
+ if mime_type is not None and not mime_type.startswith("video/"):
+ return None
+
+ try:
+ import av
+ except ImportError:
+ logger.debug(
+ "PyAV not available; skipping video metadata extraction for %s",
+ file_path,
+ )
+ return None
+
+ try:
+ with av.open(file_path) as container:
+ stream = next(
+ (s for s in container.streams if s.type == "video"), None
+ )
+ if stream is None:
+ return None
+
+ fps = float(stream.average_rate) if stream.average_rate else None
+ duration = None
+ if stream.duration is not None and stream.time_base is not None:
+ duration = float(stream.duration * stream.time_base)
+ elif container.duration is not None:
+ duration = float(container.duration / av.time_base)
+ frame_count = stream.frames or None
+
+ width = stream.codec_context.width
+ height = stream.codec_context.height
+ except (OSError, ValueError, av.error.FFmpegError) as exc:
+ logger.debug("Failed to read video metadata from %s: %s", file_path, exc)
+ return None
+
+ if (
+ not isinstance(width, int)
+ or not isinstance(height, int)
+ or width <= 0
+ or height <= 0
+ ):
+ return None
+
+ metadata: dict[str, Any] = {"kind": "video", "width": width, "height": height}
+ if duration is not None:
+ metadata["duration"] = duration
+ if fps is not None:
+ metadata["fps"] = fps
+ if frame_count is not None:
+ metadata["frame_count"] = frame_count
+ return metadata
diff --git a/comfy_execution/media_enrichment.py b/comfy_execution/media_enrichment.py
new file mode 100644
index 000000000..36412a034
--- /dev/null
+++ b/comfy_execution/media_enrichment.py
@@ -0,0 +1,94 @@
+"""Enrich executed-node output entries with media metadata.
+
+Attaches a ``metadata`` object (``kind``/``width``/``height``, plus
+``duration``/``fps``/``frame_count`` for videos) to each file-type output
+entry at output-processing time, so consumers of the ``executed`` message
+and ``/history`` can read media properties without probing the files
+themselves. Unlike asset enrichment this is NOT gated on ``--enable-assets``:
+the properties serve history/websocket consumers that don't run the assets
+system at all.
+"""
+import logging
+import mimetypes
+import os
+
+import folder_paths
+
+
+def resolve_output_entry_path(entry) -> str | None:
+ """Resolve a file-type output entry to an absolute path inside its base dir.
+
+ Returns ``None`` for non-file entries (no ``filename``/``type``, or
+ non-string fields), unknown folder types, paths that escape the
+ folder-type base directory (symlinks are resolved before the containment
+ check), and paths with no file on disk.
+ """
+ if not isinstance(entry, dict) or "filename" not in entry or "type" not in entry:
+ return None
+ filename = entry["filename"]
+ subfolder = entry.get("subfolder", "")
+ if not isinstance(filename, str) or not isinstance(subfolder, str) or not isinstance(entry["type"], str):
+ return None
+ base = folder_paths.get_directory_by_type(entry["type"])
+ if base is None:
+ return None
+ # realpath (not abspath) so a symlink planted inside the base directory
+ # can't smuggle an outside target past the containment check; the base is
+ # resolved too since output/temp dirs are themselves commonly symlinks.
+ base_real = os.path.realpath(base)
+ real_path = os.path.realpath(os.path.join(base_real, subfolder, filename))
+ try:
+ if os.path.commonpath([base_real, real_path]) != base_real:
+ logging.warning("Output entry path escapes base directory: %s", filename)
+ return None
+ except ValueError:
+ logging.warning("Output entry path escapes base directory: %s", filename)
+ return None
+ if not os.path.isfile(real_path):
+ return None
+ return real_path
+
+
+def enrich_output_with_media_metadata(output_ui: dict) -> dict:
+ """Attach a ``metadata`` media-properties object to file output entries.
+
+ Runs once per produced output at output-processing time. Returns a new
+ dict; entries are copied before modification, and an entry that already
+ carries a ``metadata`` key is left untouched. Best-effort: unreadable
+ files, non-media types, and per-entry errors leave that entry unchanged
+ and never block execution.
+ """
+ try:
+ from app.assets.services.media_metadata import extract_media_metadata
+ except Exception:
+ # Broad on purpose: this enrichment is best-effort and is called
+ # unguarded from the output-processing path, so a dependency failing
+ # to import for any reason must degrade to a no-op, not block outputs.
+ logging.warning("Media metadata extraction unavailable; skipping enrichment", exc_info=True)
+ return output_ui
+
+ enriched = {}
+ for key, entries in output_ui.items():
+ if not isinstance(entries, list):
+ enriched[key] = entries
+ continue
+ new_entries = []
+ for entry in entries:
+ try:
+ if isinstance(entry, dict) and "metadata" not in entry:
+ abs_path = resolve_output_entry_path(entry)
+ if abs_path is not None:
+ mime_type = mimetypes.guess_type(entry["filename"], strict=False)[0]
+ media = extract_media_metadata(abs_path, mime_type=mime_type)
+ if media:
+ entry = dict(entry)
+ entry["metadata"] = media
+ except Exception:
+ filename = entry.get("filename") if isinstance(entry, dict) else None
+ logging.warning(
+ "Failed to enrich output entry with media metadata: %s",
+ filename, exc_info=True,
+ )
+ new_entries.append(entry)
+ enriched[key] = new_entries
+ return enriched
diff --git a/execution.py b/execution.py
index 448e3d294..888eb302d 100644
--- a/execution.py
+++ b/execution.py
@@ -44,6 +44,7 @@ from comfy_execution.validation import LoopValidationError, validate_loops, vali
from comfy_execution.progress import get_progress_state, reset_progress_state, add_progress_handler, WebUIProgressHandler
from comfy_execution.utils import CurrentNodeContext
from comfy_execution.asset_enrichment import register_executed_outputs, emit_cached_output
+from comfy_execution.media_enrichment import enrich_output_with_media_metadata
from comfy_api.internal import _ComfyNodeInternal, _NodeOutputInternal, first_real_override, is_class, make_locked_method_func
from comfy_api.latest import io, _io
from comfy_execution.cache_provider import _has_cache_providers, _get_cache_providers, _logger as _cache_logger
@@ -564,6 +565,7 @@ async def execute(server: "ExecutionServer", dynprompt, caches, current_item, ex
return (ExecutionResult.PENDING, None, None)
cache_ui_value = ui_outputs.get(unique_id)
if len(output_ui) > 0:
+ output_ui = enrich_output_with_media_metadata(output_ui)
meta = {
"node_id": unique_id,
"display_node": display_node_id,
diff --git a/tests-unit/assets_test/services/test_scanner_b.py b/tests-unit/assets_test/services/test_scanner_b.py
index 729d6d41a..b32491dc6 100644
--- a/tests-unit/assets_test/services/test_scanner_b.py
+++ b/tests-unit/assets_test/services/test_scanner_b.py
@@ -94,7 +94,7 @@ def test_enrichment_retains_dimensions_when_image_extraction_degrades(
"app.assets.scanner.extract_file_metadata",
return_value=_ExtractedMetadata("image/png", {"filename": "image.png"}),
),
- patch("app.assets.scanner.extract_image_dimensions", return_value=None),
+ patch("app.assets.scanner.extract_media_metadata", return_value=None),
):
enrich_asset(session, str(path), content.id, record.id)
diff --git a/tests-unit/assets_test/services/test_video_metadata.py b/tests-unit/assets_test/services/test_video_metadata.py
new file mode 100644
index 000000000..7ca1faadc
--- /dev/null
+++ b/tests-unit/assets_test/services/test_video_metadata.py
@@ -0,0 +1,173 @@
+"""Tests for the video_metadata service."""
+from __future__ import annotations
+
+from pathlib import Path
+
+import numpy as np
+import pytest
+
+from app.assets.services.media_metadata import extract_media_metadata
+from app.assets.services.video_metadata import extract_video_metadata
+
+
+def _make_video(
+ path: Path,
+ width: int = 64,
+ height: int = 48,
+ frames: int = 12,
+ fps: int = 8,
+ codec: str = "libx264",
+) -> Path:
+ av = pytest.importorskip("av")
+ with av.open(str(path), "w") as container:
+ stream = container.add_stream(codec, rate=fps)
+ stream.width = width
+ stream.height = height
+ stream.pix_fmt = "yuv420p"
+ for _ in range(frames):
+ frame = av.VideoFrame.from_ndarray(
+ np.zeros((height, width, 3), dtype=np.uint8), format="rgb24"
+ )
+ for packet in stream.encode(frame):
+ container.mux(packet)
+ for packet in stream.encode():
+ container.mux(packet)
+ return path
+
+
+def _make_mp4(
+ path: Path, width: int = 64, height: int = 48, frames: int = 12, fps: int = 8
+) -> Path:
+ return _make_video(path, width=width, height=height, frames=frames, fps=fps)
+
+
+class TestExtractVideoMetadata:
+ def test_extracts_stream_metadata(self, tmp_path: Path):
+ f = _make_mp4(tmp_path / "clip.mp4", width=64, height=48, frames=12, fps=8)
+
+ result = extract_video_metadata(str(f), mime_type="video/mp4")
+
+ assert result is not None
+ assert result["kind"] == "video"
+ assert result["width"] == 64
+ assert result["height"] == 48
+ assert result["frame_count"] == 12
+ assert result["fps"] == pytest.approx(8.0)
+ assert result["duration"] == pytest.approx(12 / 8, abs=0.1)
+
+ def test_works_when_mime_type_is_none(self, tmp_path: Path):
+ f = _make_mp4(tmp_path / "no_mime.mp4")
+
+ result = extract_video_metadata(str(f), mime_type=None)
+
+ assert result is not None
+ assert result["kind"] == "video"
+
+ @pytest.mark.parametrize(
+ "mime",
+ ["application/json", "text/plain", "image/png", "audio/mpeg"],
+ )
+ def test_skips_non_video_mime_types(self, tmp_path: Path, mime: str):
+ result = extract_video_metadata(
+ str(tmp_path / "untouched.mp4"), mime_type=mime
+ )
+
+ assert result is None
+
+ def test_returns_none_for_missing_file(self, tmp_path: Path):
+ result = extract_video_metadata(
+ str(tmp_path / "does_not_exist.mp4"), mime_type="video/mp4"
+ )
+
+ assert result is None
+
+ def test_returns_none_for_corrupt_video(self, tmp_path: Path):
+ f = tmp_path / "corrupt.mp4"
+ f.write_bytes(b"not actually an mp4 file")
+
+ result = extract_video_metadata(str(f), mime_type="video/mp4")
+
+ assert result is None
+
+ def test_webm_duration_from_container_without_frame_count(self, tmp_path: Path):
+ f = _make_video(tmp_path / "clip.webm", frames=12, fps=8, codec="libvpx-vp9")
+
+ result = extract_video_metadata(str(f), mime_type="video/webm")
+
+ assert result is not None
+ assert result["duration"] == pytest.approx(12 / 8, abs=0.2)
+ assert "frame_count" not in result
+
+
+class TestExtractMediaMetadata:
+ def test_dispatches_video_mime_to_video_extractor(self, tmp_path: Path):
+ f = _make_mp4(tmp_path / "clip.mp4")
+
+ result = extract_media_metadata(str(f), mime_type="video/mp4")
+
+ assert result is not None
+ assert result["kind"] == "video"
+
+ def test_dispatches_image_mime_to_image_extractor(self, tmp_path: Path):
+ Image = pytest.importorskip("PIL.Image")
+
+ f = tmp_path / "img.png"
+ Image.new("RGB", (32, 16)).save(f, format="PNG")
+
+ result = extract_media_metadata(str(f), mime_type="image/png")
+
+ assert result == {"kind": "image", "width": 32, "height": 16}
+
+ def test_returns_none_without_mime_type(self, tmp_path: Path):
+ f = _make_mp4(tmp_path / "clip.mp4")
+
+ assert extract_media_metadata(str(f), mime_type=None) is None
+
+ def test_returns_none_for_non_media_mime(self, tmp_path: Path):
+ f = tmp_path / "file.bin"
+ f.write_bytes(b"\x00")
+
+ assert extract_media_metadata(str(f), mime_type="text/plain") is None
+
+
+class TestIngestStoresVideoMetadata:
+ @staticmethod
+ def _assert_video_metadata(meta: dict) -> None:
+ assert meta["kind"] == "video"
+ assert meta["width"] == 64
+ assert meta["height"] == 48
+ assert meta["frame_count"] == 12
+ assert meta["fps"] == pytest.approx(8.0)
+ assert "duration" in meta
+
+ def test_register_file_in_place_stores_video_metadata(
+ self, mock_create_session, temp_dir: Path
+ ):
+ from app.assets.services.ingest import register_file_in_place
+
+ f = _make_mp4(temp_dir / "clip.mp4", width=64, height=48)
+
+ result = register_file_in_place(
+ abs_path=str(f), name="clip.mp4", tags=["output"], mime_type="video/mp4"
+ )
+
+ self._assert_video_metadata(result.ref.system_metadata or {})
+
+ def test_create_from_hash_stores_video_metadata(
+ self, mock_create_session, monkeypatch, temp_dir: Path
+ ):
+ from app.assets.database.queries.records import create_content
+ from app.assets.helpers import to_stored_hash
+ from app.assets.services.ingest import create_from_hash
+
+ monkeypatch.setattr("app.assets.mode.hashing_enabled", lambda: True)
+ digest = "c" * 64
+ f = _make_mp4(temp_dir / "clip.mp4", width=64, height=48)
+ with mock_create_session() as session:
+ create_content(session, str(f), to_stored_hash(digest), f.stat().st_size)
+ session.commit()
+
+ result = create_from_hash(digest, "copy.mp4", mime_type="video/mp4")
+
+ assert result is not None
+ self._assert_video_metadata(result.ref.system_metadata or {})
diff --git a/tests-unit/execution_test/test_media_enrichment.py b/tests-unit/execution_test/test_media_enrichment.py
new file mode 100644
index 000000000..3c99cd0d8
--- /dev/null
+++ b/tests-unit/execution_test/test_media_enrichment.py
@@ -0,0 +1,233 @@
+"""Tests for enrich_output_with_media_metadata in comfy_execution/media_enrichment.py."""
+import os
+import shutil
+import tempfile
+import unittest
+from unittest.mock import MagicMock, patch
+
+from utils.mime_types import init_mime_types
+
+# Initialize the mimetypes registry before any test patches os.path.isfile —
+# its lazy init consults os.path.isfile to pick candidate files, and a
+# patched-True isfile makes it try to open files that don't exist. Use the
+# project initializer, not mimetypes.init(), which would wipe the custom
+# registrations other test modules rely on.
+init_mime_types()
+
+# Platform-appropriate absolute base. tempfile.gettempdir() returns C:\... on
+# Windows and /tmp on POSIX, so containment via commonpath behaves naturally.
+_DEFAULT_BASE = os.path.join(tempfile.gettempdir(), "media-enrichment-test-base")
+
+_VIDEO_META = {
+ "kind": "video",
+ "width": 1280,
+ "height": 720,
+ "duration": 4.0,
+ "fps": 24.0,
+ "frame_count": 96,
+}
+
+
+import comfy_execution.media_enrichment as media_enrichment
+
+
+def _folder_paths_mock(directory=_DEFAULT_BASE):
+ return MagicMock(get_directory_by_type=MagicMock(return_value=directory))
+
+
+def _call(output_ui, *, extract=None, file_exists=True, directory=_DEFAULT_BASE):
+ extract_mock = extract or MagicMock(return_value=dict(_VIDEO_META))
+ extractor_module = MagicMock(extract_media_metadata=extract_mock)
+
+ # folder_paths is bound at media_enrichment module scope, so it is patched
+ # as an attribute; the extractor is looked up lazily via sys.modules. Only
+ # os.path.isfile is patched — abspath/join must run natively so the
+ # containment check sees real platform paths.
+ with patch.object(media_enrichment, "folder_paths", _folder_paths_mock(directory)), \
+ patch.dict("sys.modules", {"app.assets.services.media_metadata": extractor_module}), \
+ patch("os.path.isfile", return_value=file_exists):
+ return media_enrichment.enrich_output_with_media_metadata(output_ui), extract_mock
+
+
+class TestEnrichOutputWithMediaMetadata(unittest.TestCase):
+
+ def test_attaches_metadata_object(self):
+ output = {"images": [{"filename": "clip.mp4", "subfolder": "", "type": "output"}]}
+ result, _ = _call(output)
+ self.assertEqual(result["images"][0]["metadata"], _VIDEO_META)
+
+ def test_passes_guessed_mime_type(self):
+ output = {"images": [{"filename": "clip.mp4", "subfolder": "", "type": "output"}]}
+ _, extract_mock = _call(output)
+ _, kwargs = extract_mock.call_args
+ self.assertEqual(kwargs["mime_type"], "video/mp4")
+
+ def test_original_entry_not_mutated(self):
+ orig = {"filename": "clip.mp4", "subfolder": "", "type": "output"}
+ _call({"images": [orig]})
+ self.assertNotIn("metadata", orig)
+
+ def test_non_media_extractor_none_leaves_entry_unchanged(self):
+ extract = MagicMock(return_value=None)
+ output = {"latent": [{"filename": "a.latent", "subfolder": "", "type": "output"}]}
+ result, _ = _call(output, extract=extract)
+ self.assertNotIn("metadata", result["latent"][0])
+
+ def test_existing_metadata_key_untouched(self):
+ entry = {"filename": "clip.mp4", "subfolder": "", "type": "output", "metadata": {"kind": "other"}}
+ result, extract_mock = _call({"images": [entry]})
+ self.assertEqual(result["images"][0]["metadata"], {"kind": "other"})
+ extract_mock.assert_not_called()
+
+ def test_non_list_value_passed_through(self):
+ result, _ = _call({"text": "hello"})
+ self.assertEqual(result["text"], "hello")
+
+ def test_none_entry_in_list_unchanged(self):
+ output = {"images": [None, {"filename": "a.mp4", "subfolder": "", "type": "output"}]}
+ result, _ = _call(output)
+ self.assertIsNone(result["images"][0])
+ self.assertIn("metadata", result["images"][1])
+
+ def test_entry_without_filename_unchanged(self):
+ output = {"latent": [{"subfolder": "", "type": "output"}]}
+ result, extract_mock = _call(output)
+ self.assertNotIn("metadata", result["latent"][0])
+ extract_mock.assert_not_called()
+
+ def test_file_not_on_disk_unchanged(self):
+ output = {"images": [{"filename": "missing.mp4", "subfolder": "", "type": "output"}]}
+ result, extract_mock = _call(output, file_exists=False)
+ self.assertNotIn("metadata", result["images"][0])
+ extract_mock.assert_not_called()
+
+ def test_unknown_type_directory_unchanged(self):
+ output = {"images": [{"filename": "a.mp4", "subfolder": "", "type": "unknown"}]}
+ result, extract_mock = _call(output, directory=None)
+ self.assertNotIn("metadata", result["images"][0])
+ extract_mock.assert_not_called()
+
+ def test_path_traversal_subfolder_skipped(self):
+ output = {"images": [{"filename": "passwd", "subfolder": "../../etc", "type": "output"}]}
+ result, extract_mock = _call(output)
+ self.assertNotIn("metadata", result["images"][0])
+ extract_mock.assert_not_called()
+
+ def test_absolute_filename_skipped(self):
+ absolute_filename = os.path.abspath(os.sep + "etc" + os.sep + "passwd")
+ output = {"images": [{"filename": absolute_filename, "subfolder": "", "type": "output"}]}
+ result, extract_mock = _call(output)
+ self.assertNotIn("metadata", result["images"][0])
+ extract_mock.assert_not_called()
+
+ def test_extractor_unavailable_returns_unchanged(self):
+ output = {"images": [{"filename": "a.mp4", "subfolder": "", "type": "output"}]}
+ # A None sys.modules entry makes the lazy import raise ImportError.
+ with patch.object(media_enrichment, "folder_paths", _folder_paths_mock()), \
+ patch.dict("sys.modules", {"app.assets.services.media_metadata": None}), \
+ patch("os.path.isfile", return_value=True):
+ result = media_enrichment.enrich_output_with_media_metadata(output)
+ self.assertNotIn("metadata", result["images"][0])
+
+ def test_extractor_import_failure_beyond_importerror_degrades(self):
+ class ExplodingModule:
+ def __getattr__(self, name):
+ raise RuntimeError("dependency init failed")
+
+ output = {"images": [{"filename": "a.mp4", "subfolder": "", "type": "output"}]}
+ with patch.object(media_enrichment, "folder_paths", _folder_paths_mock()), \
+ patch.dict("sys.modules", {"app.assets.services.media_metadata": ExplodingModule()}), \
+ patch("os.path.isfile", return_value=True):
+ result = media_enrichment.enrich_output_with_media_metadata(output)
+ self.assertNotIn("metadata", result["images"][0])
+
+ def test_missing_subfolder_key_defaults_to_base_dir(self):
+ output = {"images": [{"filename": "clip.mp4", "type": "output"}]}
+ result, _ = _call(output)
+ self.assertIn("metadata", result["images"][0])
+
+ def test_falsy_non_string_subfolder_skipped(self):
+ output = {
+ "images": [
+ {"filename": "a.mp4", "subfolder": None, "type": "output"},
+ {"filename": "b.mp4", "subfolder": False, "type": "output"},
+ {"filename": "c.mp4", "subfolder": 0, "type": "output"},
+ ]
+ }
+ result, extract_mock = _call(output)
+ for entry in result["images"]:
+ self.assertNotIn("metadata", entry)
+ extract_mock.assert_not_called()
+
+ def test_non_string_fields_skipped(self):
+ output = {
+ "images": [
+ {"filename": 42, "subfolder": "", "type": "output"},
+ {"filename": "a.mp4", "subfolder": ["nested"], "type": "output"},
+ {"filename": "b.mp4", "subfolder": "", "type": 7},
+ ]
+ }
+ result, extract_mock = _call(output)
+ for entry in result["images"]:
+ self.assertNotIn("metadata", entry)
+ extract_mock.assert_not_called()
+
+ def test_symlink_escape_rejected_real_fs(self):
+ root = tempfile.mkdtemp(prefix="media-enrichment-symlink-")
+ try:
+ base = os.path.join(root, "output")
+ os.makedirs(base)
+ secret = os.path.join(root, "secret.txt")
+ with open(secret, "w") as f:
+ f.write("outside")
+ try:
+ os.symlink(secret, os.path.join(base, "clip.mp4"))
+ except OSError as e:
+ self.skipTest(f"cannot create symlinks on this platform: {e}")
+ inside = os.path.join(base, "real.mp4")
+ with open(inside, "w") as f:
+ f.write("inside")
+
+ # No isfile patching — this test runs against the real filesystem.
+ with patch.object(media_enrichment, "folder_paths", _folder_paths_mock(base)):
+ escaped = media_enrichment.resolve_output_entry_path(
+ {"filename": "clip.mp4", "subfolder": "", "type": "output"})
+ contained = media_enrichment.resolve_output_entry_path(
+ {"filename": "real.mp4", "subfolder": "", "type": "output"})
+ self.assertIsNone(escaped, "symlink pointing outside the base must be rejected")
+ self.assertEqual(contained, os.path.realpath(inside))
+ finally:
+ shutil.rmtree(root, ignore_errors=True)
+
+ def test_extractor_error_does_not_block_sibling_entries(self):
+ call_count = [0]
+
+ def extract_side_effect(abs_path, mime_type=None):
+ call_count[0] += 1
+ if call_count[0] == 1:
+ raise RuntimeError("boom")
+ return dict(_VIDEO_META)
+
+ extract = MagicMock(side_effect=extract_side_effect)
+ output = {
+ "images": [
+ {"filename": "bad.mp4", "subfolder": "", "type": "output"},
+ {"filename": "good.mp4", "subfolder": "", "type": "output"},
+ ]
+ }
+ result, _ = _call(output, extract=extract)
+ self.assertNotIn("metadata", result["images"][0])
+ self.assertEqual(result["images"][1]["metadata"], _VIDEO_META)
+
+ def test_multiple_output_keys_all_enriched(self):
+ output = {
+ "images": [{"filename": "a.png", "subfolder": "", "type": "output"}],
+ "videos": [{"filename": "b.mp4", "subfolder": "", "type": "output"}],
+ }
+ result, _ = _call(output)
+ self.assertIn("metadata", result["images"][0])
+ self.assertIn("metadata", result["videos"][0])
+
+
+if __name__ == "__main__":
+ unittest.main()