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.pyindex 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_metadatafrom app.assets.services.metadata_extract import ExtractedMetadata, extract_file_metadatafrom 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.pyindex 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_hashfrom app.assets.services.file_utils import get_mtime_ns, get_size_and_mtime_ns-from app.assets.services.image_dimensions import extract_image_dimensionsfrom 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_metadatafrom app.assets.services.metadata_extract import extract_file_metadatafrom 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 creationinstead 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_metadatadiff --git a/app/assets/services/media_metadata.py b/app/assets/services/media_metadata.pynew file mode 100644index 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 Nonediff --git a/app/assets/services/video_metadata.py b/app/assets/services/video_metadata.pynew file mode 100644index 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 metadatadiff --git a/comfy_execution/media_enrichment.py b/comfy_execution/media_enrichment.pynew file mode 100644index 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 enricheddiff --git a/execution.py b/execution.pyindex 448e3d294..888eb302d 100644--- a/execution.py+++ b/execution.py@@ -44,6 +44,7 @@ from comfy_execution.validation import LoopValidationError, validate_loops, valifrom comfy_execution.progress import get_progress_state, reset_progress_state, add_progress_handler, WebUIProgressHandlerfrom comfy_execution.utils import CurrentNodeContextfrom comfy_execution.asset_enrichment import register_executed_outputs, emit_cached_output+from 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, _iofrom 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, exreturn (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.pyindex 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.pynew file mode 100644index 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.pynew file mode 100644index 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()