Skip to content

Image Pipeline Playground

5.1 KB
Raw Blame
"""Collect Save Image outputs into ZIP archives under the output folder."""

from __future__ import annotations

import io
import uuid
import zipfile
from contextvars import ContextVar
from dataclasses import dataclass, field
from datetime import datetime
from pathlib import Path

import cv2
import numpy as np

from app.paths import output_dir

OUTPUT_DIR = output_dir()


def _unique_name(existing: dict[str, bytes], name: str) -> str:
    safe = Path(name).name or "image.png"
    suffix = Path(safe).suffix.lower()
    if suffix not in {".png", ".jpg", ".jpeg", ".bmp", ".webp"}:
        safe = f"{Path(safe).stem}.png"
    final_name = safe
    stem = Path(safe).stem
    file_suffix = Path(safe).suffix
    index = 2
    while final_name in existing:
        final_name = f"{stem}_{index}{file_suffix}"
        index += 1
    return final_name


@dataclass
class SaveBundle:
    """In-memory image files grouped by destination directory for ZIP writes."""

    files_by_dest: dict[str, dict[str, bytes]] = field(default_factory=dict)

    @property
    def files(self) -> dict[str, bytes]:
        """Flattened view of all pending ZIP entries (tests / legacy checks)."""
        merged: dict[str, bytes] = {}
        for bucket in self.files_by_dest.values():
            merged.update(bucket)
        return merged

    def add_image(
        self,
        name: str,
        image: np.ndarray,
        destination: Path | None = None,
    ) -> str:
        dest_key = str((destination or OUTPUT_DIR).resolve())
        bucket = self.files_by_dest.setdefault(dest_key, {})
        final_name = _unique_name(bucket, name)
        suffix = Path(final_name).suffix.lower()
        encode_ext = ".jpg" if suffix in {".jpg", ".jpeg"} else suffix
        success, buffer = cv2.imencode(encode_ext, image)
        if not success:
            success, buffer = cv2.imencode(".png", image)
            final_name = f"{Path(final_name).stem}.png"
        if not success:
            raise RuntimeError(f"Failed to encode image for '{final_name}'")
        bucket[final_name] = buffer.tobytes()
        return final_name

    def write_zips(self) -> list[Path]:
        """Write one ZIP per destination directory; return written paths."""
        if not self.files_by_dest:
            raise ValueError("No images were saved")
        written: list[Path] = []
        stamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        for dest_key, files in self.files_by_dest.items():
            if not files:
                continue
            dest = Path(dest_key)
            dest.mkdir(parents=True, exist_ok=True)
            out = dest / f"results_{stamp}_{uuid.uuid4().hex[:8]}.zip"
            with zipfile.ZipFile(out, "w", compression=zipfile.ZIP_DEFLATED) as archive:
                for name, payload in files.items():
                    archive.writestr(name, payload)
            written.append(out.resolve())
        if not written:
            raise ValueError("No images were saved")
        return written

    def write_zip(self, destination: Path | None = None) -> Path:
        """Write a single ZIP (tests / helpers). Uses destination or first bucket."""
        if destination is not None:
            dest_key = str(destination.resolve())
            files = self.files_by_dest.get(dest_key) or self.files
            if not files:
                raise ValueError("No images were saved")
            destination.mkdir(parents=True, exist_ok=True)
            stamp = datetime.now().strftime("%Y%m%d_%H%M%S")
            out = destination / f"results_{stamp}_{uuid.uuid4().hex[:8]}.zip"
            with zipfile.ZipFile(out, "w", compression=zipfile.ZIP_DEFLATED) as archive:
                for name, payload in files.items():
                    archive.writestr(name, payload)
            return out.resolve()
        paths = self.write_zips()
        return paths[0]


@dataclass
class FolderSaveTracker:
    """Tracks directories written by Save Image when writing bare files."""

    directories: set[str] = field(default_factory=set)
    files: list[str] = field(default_factory=list)

    def record(self, path: Path) -> None:
        resolved = path.resolve()
        self.files.append(str(resolved))
        self.directories.add(str(resolved.parent))


current_save_bundle: ContextVar[SaveBundle | None] = ContextVar(
    "current_save_bundle",
    default=None,
)

current_folder_saves: ContextVar[FolderSaveTracker | None] = ContextVar(
    "current_folder_saves",
    default=None,
)


def get_save_bundle() -> SaveBundle:
    bundle = current_save_bundle.get()
    if bundle is None:
        raise RuntimeError("Save bundle is not available for this run")
    return bundle


def get_folder_saves() -> FolderSaveTracker:
    tracker = current_folder_saves.get()
    if tracker is None:
        raise RuntimeError("Folder save tracker is not available for this run")
    return tracker


def zip_bytes(bundle: SaveBundle) -> bytes:
    """Return ZIP contents without writing to disk (tests / helpers)."""
    buffer = io.BytesIO()
    with zipfile.ZipFile(buffer, "w", compression=zipfile.ZIP_DEFLATED) as archive:
        for name, payload in bundle.files.items():
            archive.writestr(name, payload)
    return buffer.getvalue()