Skip to content

Generate clean 2D game sprites & animation atlases — component-row pipeline: state rows, alpha cleanup, frame extraction, runtime atlases. Codex/Claude skill.

fix(out-dir): a verb never writes over, moves or deletes what it reads — runio.refuse_overlap follows each input, and what a verb finds in one, the way the system opens it and refuses, --force or not and before anything is made, one that is, lies inside or goes through what the run replaces; working folders are new ones of the run's own (runio.new_stage); the scattered same-file and inside-folder checks call runio.same_folder and runio.inside_folder

Soohong Kim67b92111b10e
diff --git a/sprite_gen/background/tile.py b/sprite_gen/background/tile.py
index a6b45b0..c493537 100644
--- a/sprite_gen/background/tile.py
+++ b/sprite_gen/background/tile.py
@@ -28,7 +28,7 @@ from typing import Any
from PIL import Image
from sprite_gen._deps import np
-from sprite_gen.spec.runio import acquire_run_dir_lock, atomic_write_set, release_run_dir_lock
+from sprite_gen.spec.runio import acquire_run_dir_lock, atomic_write_set, release_run_dir_lock, same_folder
from sprite_gen.util.console import utf8_streams
@@ -348,7 +348,8 @@ def inspect_tile_xy(image: Image.Image) -> dict[str, Any]:
def _same_file(a: Path, b: Path) -> bool:
- return a == b or (a.exists() and b.exists() and a.samefile(b))
+ """One path, or one file by identity (`runio.same_folder`): the PNG and its report may both be new paths."""
+ return a == b or same_folder(a, b)
def _validate_paths(source: Path, out: Path, report: Path) -> None:
diff --git a/sprite_gen/compose/game_pack.py b/sprite_gen/compose/game_pack.py
index bf8d97a..4b1c5ce 100644
--- a/sprite_gen/compose/game_pack.py
+++ b/sprite_gen/compose/game_pack.py
@@ -25,6 +25,7 @@ from sprite_gen.frames.ui_kit import (REPORT_KIND as UI_KIT_KIND, STRETCHES, con
measure_insets)
from sprite_gen._deps import np
from sprite_gen.spec.assets import finite, load_asset, load_asset_states
+from sprite_gen.spec.runio import inside_folder, same_folder
from sprite_gen.util.resample import resize_cell
from sprite_gen.util.console import utf8_streams
@@ -525,7 +526,7 @@ def pack(request: Path, out_dir: Path, *, page_size=MAX_PAGE_SIZE, max_bytes=MAX
sources.update(paths)
if not frames and not tile_files and not audio:
raise ValueError("game pack request declares nothing to pack: give it an asset, a scene entry or a sound")
- if any(path == out_dir or out_dir in path.parents for path in sources | {request}):
+ if any(same_folder(path, out_dir) or inside_folder(path, out_dir) for path in sources | {request}):
raise ValueError("output directory must not contain any source file")
result, payloads = _encode(_layout(frames, page_size) if frames else [], animations, max_bytes, sections, tile_files)
if audio:
diff --git a/sprite_gen/frames/ui_kit.py b/sprite_gen/frames/ui_kit.py
index 1433d22..0909aeb 100644
--- a/sprite_gen/frames/ui_kit.py
+++ b/sprite_gen/frames/ui_kit.py
@@ -42,6 +42,7 @@ from PIL import Image, ImageDraw
from sprite_gen._deps import np
from sprite_gen.frames.alpha_floor import clear_haze
+from sprite_gen.spec.runio import inside_folder, same_folder
from sprite_gen.util.console import utf8_streams
REFERENCE = 1024
@@ -1270,7 +1271,7 @@ def _publish(*, sheet: Path, out_dir: Path, alpha_floor: int = 64, alpha_edge: i
report_path = Path(report).expanduser().resolve() if report is not None else out_dir / "ui-kit.json"
if not sheet.is_file():
raise ValueError(f"sheet is not a file: {sheet}")
- if out_dir == sheet.parent or out_dir in sheet.parents or report_path == sheet:
+ if inside_folder(sheet, out_dir) or same_folder(report_path, sheet):
raise ValueError("the output directory must not hold the sheet; choose a new directory")
if report_path.suffix.lower() != ".json":
raise ValueError("--report must be a .json path")
diff --git a/sprite_gen/frames/unpack_atlas.py b/sprite_gen/frames/unpack_atlas.py
index 375d912..df5c29a 100644
--- a/sprite_gen/frames/unpack_atlas.py
+++ b/sprite_gen/frames/unpack_atlas.py
@@ -41,12 +41,11 @@ from sprite_gen.spec.runio import (
acquire_run_dir_lock,
atomic_save_image,
atomic_write_text,
- follow_path,
- inside_folder,
+ follow_input,
new_stage,
publish_guard,
+ refuse_overlap,
relative_posix,
- same_folder,
)
from sprite_gen.frames.segment import mask_components
from sprite_gen.util.console import utf8_streams
@@ -374,15 +373,6 @@ def import_png_groups(out_dir: Path, groups: list[dict[str, Any]], iso: dict[str
"base_source": base_out_name, "imported_refs": imported_refs_manifest}
-def _follow(flag: str, given: Path) -> tuple[list[Path], Path]:
- """`runio.follow_path` of an input: every entry its path looks up and the real path it reaches. A path that
- cannot be followed (a link loop) is refused by name before anything is made."""
- try:
- return follow_path(given)
- except OSError as exc:
- raise SystemExit(f"{flag} cannot be followed: {exc.filename}: {exc.strerror}") from None
-
-
def _refuse_overlap(inputs: dict[str, Path | None], out_dir: Path) -> None:
"""An input is never written, moved or deleted. Refused before anything is made: an input that is
the run dir (the run would replace it), lies inside it or goes through anything inside it (a --force
@@ -390,26 +380,9 @@ def _refuse_overlap(inputs: dict[str, Path | None], out_dir: Path) -> None:
path through it breaks), or holds it (the run would be written into the input). An input is followed
the way the system opens it (`runio.follow_path`): every link and folder its path looks up, a folder a
later `..` leaves again included. Read by real path and file identity, so a link, or a second spelling
- on a case-insensitive volume, is the same folder."""
- looked_at: set[Path] = set()
- for flag, given in inputs.items():
- if given is None:
- continue
- looked, path = _follow(flag, Path(given).expanduser())
- if same_folder(path, out_dir):
- kind = "folder" if path.is_dir() else "file"
- raise SystemExit(f"{flag} and --out-dir are the same {kind}: {path} (an input is never overwritten)")
- if inside_folder(path, out_dir):
- raise SystemExit(f"{flag} lies inside --out-dir: {path} "
- "(--force replaces the run dir's content, never an input)")
- fresh = [entry for entry in looked if entry not in looked_at]
- looked_at.update(fresh)
- through = next((entry for entry in fresh if inside_folder(entry, out_dir)), None)
- if through is not None:
- raise SystemExit(f"{flag} goes through {through}, inside --out-dir "
- "(--force replaces the run dir's content, never an input)")
- if inside_folder(out_dir, path):
- raise SystemExit(f"--out-dir lies inside {flag}: {out_dir} (a run is never written into its input)")
+ on a case-insensitive volume, is the same folder (`runio.refuse_overlap`, the judgment every writer calls)."""
+ refuse_overlap(inputs, {"--out-dir": out_dir}, holds=("--out-dir",),
+ replaces="--force replaces the run dir's content")
def _found_inputs(src: Path, groups: list[dict[str, Any]], *files: Path | None) -> dict[str, Path]:
@@ -514,13 +487,13 @@ def _run(args: argparse.Namespace):
out_dir = args.out_dir.expanduser().resolve()
else:
if args.pngs_dir:
- _, base = _follow("--pngs-dir", args.pngs_dir.expanduser())
+ _, base = follow_input("--pngs-dir", args.pngs_dir.expanduser())
out_dir = base.parent / f"{base.name}-curator"
elif args.atlas:
- _, base = _follow("--atlas", args.atlas.expanduser())
+ _, base = follow_input("--atlas", args.atlas.expanduser())
out_dir = base.parent / f"{base.stem}-curator"
elif args.manifest:
- _, base = _follow("--manifest", args.manifest.expanduser())
+ _, base = follow_input("--manifest", args.manifest.expanduser())
out_dir = base.parent / f"{base.stem}-curator"
else:
raise SystemExit("need one of --pngs-dir / --atlas / --manifest (or pass --out-dir)")
diff --git a/sprite_gen/gen/logo.py b/sprite_gen/gen/logo.py
index 22cde45..43a4d19 100644
--- a/sprite_gen/gen/logo.py
+++ b/sprite_gen/gen/logo.py
@@ -40,7 +40,7 @@ from PIL import Image
import sprite_gen.gen as gen_pkg
from sprite_gen.frames import logo_matte
-from sprite_gen.spec.runio import atomic_save_image, atomic_write_text
+from sprite_gen.spec.runio import atomic_save_image, atomic_write_text, new_stage, refuse_overlap, same_folder
from sprite_gen.util.cli_kwargs import namespace_from_kwargs
from . import chroma as chroma_mod
@@ -306,6 +306,20 @@ def _publish(image: Image.Image, path: Path) -> None:
atomic_save_image(image, path)
+def _refuse_overlap(files: dict[str, Path], report: Path, report_given: bool, *, mood: Path | None,
+ lettering: Path | None) -> None:
+ """A run never writes over or deletes the pictures it is given: `--mood` and `--lettering`, each with every link or
+ folder its path looks up, against every file the run removes or writes in `--out-dir` and its report
+ (`runio.refuse_overlap`) — but for the file each is copied to, `mood.png` and `lettering.png`, where a picture the
+ run made is given back to cut it again (its own pixels are written back). Refused before anything is made."""
+ written = {f"{name} in --out-dir": path for name, path in files.items()
+ if name != "mood.png" or lettering is None or mood is not None} # a given lettering alone writes no mood
+ written["--report" if report_given else "logo.report.json in --out-dir"] = report
+ for flag, given, own in (("--mood", mood, "mood.png"), ("--lettering", lettering, "lettering.png")):
+ refuse_overlap({flag: given}, {name: path for name, path in written.items() if name != f"{own} in --out-dir"},
+ verb="logo")
+
+
class _Refusal(Exception):
def __init__(self, stage: str, message: str) -> None:
super().__init__(message)
@@ -332,17 +346,16 @@ def make_logo(provider: str, *, text: str, out_dir: Path, subtitle: str | None =
if given is not None and not Path(given).expanduser().is_file():
raise SystemExit(f"logo: {flag} image not found: {given}")
out_dir = Path(out_dir).expanduser().resolve()
- out_dir.mkdir(parents=True, exist_ok=True)
+ report_given = report_path is not None
report_path = Path(report_path).expanduser().resolve() if report_path else out_dir / "logo.report.json"
ratio = aspect_ratio or COMPOSITIONS[composition]["aspect_ratio"]
- work = out_dir / ".logo-work"
- shutil.rmtree(work, ignore_errors=True)
- work.mkdir()
files = {name: out_dir / name for name in ("mood.png", "lettering.png", "logo.png", "logo.rejected.png",
"logo.preview.png")}
- inputs = {Path(given).expanduser().resolve() for given in (mood, lettering) if given is not None}
+ _refuse_overlap(files, report_path, report_given, mood=mood, lettering=lettering)
+ out_dir.mkdir(parents=True, exist_ok=True)
for name in ("lettering.png", "logo.png", "logo.rejected.png", "logo.preview.png"):
- if files[name] not in inputs: # a run never leaves an earlier run's result looking like its own
+ # a run never leaves an earlier run's result looking like its own; a --lettering given as its lettering.png is kept
+ if lettering is None or not same_folder(files[name], Path(lettering).expanduser()):
files[name].unlink(missing_ok=True)
report: dict[str, Any] = {
"kind": REPORT_KIND, "status": "running", "text": text, "subtitle": subtitle, "language": language,
@@ -360,6 +373,7 @@ def make_logo(provider: str, *, text: str, out_dir: Path, subtitle: str | None =
print(f"[logo] warning: {message}", file=sys.stderr)
backend = gen_pkg._make_provider(provider, keep_session=False)
+ work = new_stage(out_dir / "logo-work", "") # `.logo-work.<pid>-<random>`: the run's own, removed below
try:
if lettering is not None:
key = _given_lettering(Path(lettering).expanduser(), mood, files, report, chroma_key)
diff --git a/sprite_gen/gen/video.py b/sprite_gen/gen/video.py
index 8551eab..6b501fd 100644
--- a/sprite_gen/gen/video.py
+++ b/sprite_gen/gen/video.py
@@ -58,7 +58,7 @@ from dataclasses import dataclass, field, replace
from pathlib import Path
from typing import Any, Callable
-from sprite_gen.spec.runio import atomic_write_text
+from sprite_gen.spec.runio import atomic_write_text, refuse_overlap
from sprite_gen.util.cli_kwargs import namespace_from_kwargs
from . import prompt_parts, refusal, retry
from .base import announce_api_billing, print_json
@@ -817,6 +817,8 @@ def _validate_extend(request: ExtendRequest, *, probe: Callable[[Path], float])
)
clip = request.video.expanduser().resolve()
_require_mp4_clip(clip, verb="video-extend")
+ # The result is published over `--out`: the clip it continues is never that file (it would be replaced).
+ refuse_overlap({"--video": request.video}, {"--out": request.out.expanduser().resolve()}, verb="video-extend")
seconds = probe(clip)
low, high = EXTEND_INPUT_SECONDS
if not (low <= seconds <= high + EXTEND_INPUT_SLACK_SECONDS):
@@ -886,6 +888,8 @@ def _validate_edit(request: EditRequest, *, probe: Callable[[Path], float]) -> f
raise SystemExit(f"video-edit: only the classic {CLASSIC_MODEL} supports editing (the API answers 400 for {request.model})")
clip = request.video.expanduser().resolve()
_require_mp4_clip(clip, verb="video-edit")
+ # The result is published over `--out`: the clip it edits is never that file (it would be replaced).
+ refuse_overlap({"--video": request.video}, {"--out": request.out.expanduser().resolve()}, verb="video-edit")
seconds = probe(clip)
if seconds > EDIT_INPUT_MAX_SECONDS:
raise SystemExit(
diff --git a/sprite_gen/qa/correction_loop.py b/sprite_gen/qa/correction_loop.py
index 26a8fd7..d683f26 100644
--- a/sprite_gen/qa/correction_loop.py
+++ b/sprite_gen/qa/correction_loop.py
@@ -5,16 +5,18 @@ from __future__ import annotations
import argparse
import json
+import os
import shlex
import shutil
import subprocess
+from collections.abc import Callable
from pathlib import Path
from typing import Any
from sprite_gen.util.cli_kwargs import namespace_from_kwargs
from sprite_gen.qa import inspect as inspect_mod
from sprite_gen.qa import score as score_mod
-from sprite_gen.spec.runio import atomic_write_text
+from sprite_gen.spec.runio import LOCK_FILENAME, atomic_write_text, refuse_overlap, relative_posix, same_folder
from sprite_gen.util.console import utf8_streams
@@ -32,12 +34,41 @@ def _build_parser() -> argparse.ArgumentParser:
return parser
-def _copy_run_dir(source: Path, target: Path) -> None:
+def _skipped_by_copy(out_dir: Path) -> Callable[[Path], bool]:
+ """What the best candidate's copy of a run dir leaves out: its lock, `__pycache__`, and the loop's out dir where
+ it lies in the run dir, as the default one does (the copy would copy itself into itself). A link to the out dir
+ is not left out: it is an input that reaches the loop's own output, refused before the loop starts."""
+ return lambda path: (path.name in (LOCK_FILENAME, "__pycache__")
+ or (not path.is_symlink() and same_folder(path, out_dir)))
+
+
+def _links_copied(source: Path, skipped: Callable[[Path], bool]) -> list[Path]:
+ """Every link in `source` the copy follows (`shutil.copytree` reads a linked file's bytes and a linked folder's
+ content), the linked folders walked too, as found there: what the copy reads beside the run dir's own entries."""
+ links: list[Path] = []
+ todo, walked = [source], set()
+ while todo:
+ with os.scandir(todo.pop()) as entries:
+ for entry in entries:
+ path = Path(entry.path)
+ if skipped(path):
+ continue
+ if entry.is_symlink():
+ links.append(path)
+ if entry.is_dir():
+ folder = entry.stat()
+ if (folder.st_dev, folder.st_ino) not in walked: # a folder linked twice, or a link loop, once
+ walked.add((folder.st_dev, folder.st_ino))
+ todo.append(path)
+ return links
+
+
+def _copy_run_dir(source: Path, target: Path, skipped: Callable[[Path], bool]) -> None:
if target.exists():
shutil.rmtree(target)
- def ignore(_dir: str, names: list[str]) -> set[str]:
- return {name for name in names if name == ".sprite-gen.lock" or name == "__pycache__"}
+ def ignore(folder: str, names: list[str]) -> set[str]:
+ return {name for name in names if skipped(Path(folder) / name)}
shutil.copytree(source, target, ignore=ignore)
@@ -63,8 +94,16 @@ def run_loop(
raise SystemExit("--max-passes must be at least 1")
if min_attempts < 1 or min_attempts > max_passes:
raise SystemExit("--min-attempts must be between 1 and --max-passes")
+ given = run_dir
run_dir = run_dir.expanduser().resolve()
out_dir = (out_dir or (run_dir / "correction-loop")).expanduser().resolve()
+ # The loop never writes over, moves or deletes the run it reads: the run dir, and every link its copy follows
+ # (each with every link or folder its path looks up), is never the out dir or inside it. The out dir may lie in
+ # the run dir (the default does): it is added to it, and the copy leaves it out.
+ skipped = _skipped_by_copy(out_dir)
+ found = _links_copied(run_dir, skipped) if run_dir.is_dir() else []
+ refuse_overlap({"--run-dir": given, **{f"{relative_posix(p, run_dir)} in --run-dir": p for p in found}},
+ {"--out-dir": out_dir}, replaces="the loop writes its attempts and best candidate there")
out_dir.mkdir(parents=True, exist_ok=True)
attempts: list[dict[str, Any]] = []
best: dict[str, Any] | None = None
@@ -125,7 +164,7 @@ def run_loop(
preserved_best = None
if preserve_best:
preserved = out_dir / "best-candidate"
- _copy_run_dir(Path(best["run_dir"]), preserved)
+ _copy_run_dir(Path(best["run_dir"]), preserved, skipped)
preserved_best = str(preserved)
result = {
"ok": bool(attempts and attempts[-1]["ok"] and float(attempts[-1]["overall_score"]) >= pass_score),
diff --git a/sprite_gen/qa/motion.py b/sprite_gen/qa/motion.py
index 92fd156..580b693 100644
--- a/sprite_gen/qa/motion.py
+++ b/sprite_gen/qa/motion.py
@@ -29,7 +29,7 @@ from sprite_gen._deps import np
from PIL import Image
from sprite_gen.spec.assets import sequence_identity
-from sprite_gen.spec.runio import acquire_run_dir_lock, atomic_write_set, release_run_dir_lock
+from sprite_gen.spec.runio import acquire_run_dir_lock, atomic_write_set, release_run_dir_lock, same_folder
from sprite_gen.util.cli_kwargs import namespace_from_kwargs
from sprite_gen.util.console import utf8_streams
@@ -414,7 +414,7 @@ def add_arguments(parser):
def _output_path(out, source, sequence):
path = Path(out).expanduser().resolve()
protected = {Path(source).expanduser().resolve(), *(Path(p).resolve() for p in sequence.source_files)}
- if path in protected or (path.exists() and any(p.exists() and path.samefile(p) for p in protected)):
+ if path in protected or any(same_folder(path, p) for p in protected):
raise ValueError("motion report must not overwrite an asset source file")
if path.name == ".sprite-gen.lock" or path.name.endswith(".sg-rwlock"):
raise ValueError("motion report must not overwrite an output lock")
diff --git a/sprite_gen/scene/inspect_scene.py b/sprite_gen/scene/inspect_scene.py
index 4c33ffe..16e83a1 100644
--- a/sprite_gen/scene/inspect_scene.py
+++ b/sprite_gen/scene/inspect_scene.py
@@ -9,7 +9,8 @@ from pathlib import Path
from sprite_gen._deps import np
from sprite_gen.scene.model import Scene, load_scene
-from sprite_gen.spec.runio import LOCK_FILENAME, RWLOCK_SUFFIX, acquire_run_dir_lock, atomic_write_set, release_run_dir_lock
+from sprite_gen.spec.runio import (LOCK_FILENAME, RWLOCK_SUFFIX, acquire_run_dir_lock, atomic_write_set, release_run_dir_lock,
+ same_folder)
from sprite_gen.util.console import utf8_streams
@@ -110,7 +111,7 @@ def output_path(out, scene: Scene) -> Path:
if path.name == LOCK_FILENAME or path.name.endswith(RWLOCK_SUFFIX):
raise ValueError("inspection output must not use a reserved lock name")
protected = [Path(p) for p in scene.source_fingerprints]
- if path in protected or (path.exists() and any(p.exists() and path.samefile(p) for p in protected)):
+ if path in protected or any(same_folder(path, p) for p in protected):
raise ValueError("inspection output cannot overwrite scene inputs")
if path.exists() and not path.is_file():
raise ValueError("inspection output must be a file")
diff --git a/sprite_gen/scene/render.py b/sprite_gen/scene/render.py
index 83a04c1..e7506a5 100644
--- a/sprite_gen/scene/render.py
+++ b/sprite_gen/scene/render.py
@@ -22,7 +22,8 @@ from PIL import Image
from sprite_gen.scene.model import Scene, load_scene
from sprite_gen.spec.assets import finite
-from sprite_gen.spec.runio import LOCK_FILENAME, acquire_run_dir_lock, atomic_write_set, relative_posix, release_run_dir_lock
+from sprite_gen.spec.runio import (LOCK_FILENAME, acquire_run_dir_lock, atomic_write_set, inside_folder, relative_posix,
+ release_run_dir_lock, same_folder)
from sprite_gen.util.resample import resize_cell
from sprite_gen.util.console import utf8_streams
@@ -209,7 +210,7 @@ def encode_frames(work: Path, scene: Scene, formats: set, settings: dict):
def _validate_output(output: Path, scene: Scene):
# A scene output directory is dedicated; never overwrite source assets or scene specs.
- if any(p == output or output in p.parents for p in map(Path, scene.source_fingerprints)):
+ if any(same_folder(p, output) or inside_folder(p, output) for p in map(Path, scene.source_fingerprints)):
raise ValueError("output directory contains scene inputs; choose a separate output directory")
if output.exists() and not output.is_dir():
raise ValueError("scene output must be a directory")
diff --git a/sprite_gen/spec/runio.py b/sprite_gen/spec/runio.py
index 23c96a3..2ba9c81 100644
--- a/sprite_gen/spec/runio.py
+++ b/sprite_gen/spec/runio.py
@@ -23,11 +23,12 @@ example Claude Code and the Codex app driving the skill in parallel):
atlas/manifest/frame. `atomic_write_set()` extends the same mechanism to a
set of files that only makes sense published together (a sheet, its manifest,
and the report naming it).
-- `same_folder()` / `inside_folder()` / `follow_path()` / `new_stage()` — a writer
- never writes into, moves or deletes its inputs: inputs and outputs are compared
- by real path and file identity before anything is made — an input by every
- entry its path looks up, not only by where it ends — and a staging folder is a
- new one of the run's own, the only thing beside the output a run deletes.
+- `same_folder()` / `inside_folder()` / `follow_path()` / `refuse_overlap()` /
+ `new_stage()` — a writer never writes into, moves or deletes its inputs: inputs
+ and outputs are compared by real path and file identity before anything is
+ made — an input by every entry its path looks up, not only by where it ends —
+ and a staging or working folder is a new one of the run's own, the only thing
+ beside the output a run deletes.
`curation.json` is intentionally NOT under this pipeline write lock: the curation
surface writes it with the same atomic replace, and the compose scripts read one
@@ -53,7 +54,7 @@ import sys
import tempfile
import threading
import time
-from collections.abc import Callable
+from collections.abc import Callable, Collection, Mapping
from pathlib import Path, PurePath
from typing import NamedTuple
@@ -318,6 +319,45 @@ def follow_path(path: Path) -> tuple[list[Path], Path]:
return looked, reached
+def follow_input(flag: str, given: Path, *, verb: str | None = None) -> tuple[list[Path], Path]:
+ """`follow_path` of an input named `flag`: a path that cannot be followed (a link loop) is refused by name
+ (SystemExit, prefixed with `verb`) before anything is made."""
+ try:
+ return follow_path(given)
+ except OSError as exc:
+ raise SystemExit(f"{verb + ': ' if verb else ''}{flag} cannot be followed: {exc.filename}: {exc.strerror}") from None
+
+
+def refuse_overlap(inputs: Mapping[str, Path | None], outputs: Mapping[str, Path], *, holds: Collection[str] = (),
+ replaces: str = "the run replaces it", verb: str | None = None) -> None:
+ """입력을 쓰거나 옮기거나 지울 배치를 만들기 전에 거절한다(SystemExit, 문구 앞에 `verb`). `inputs` 는 이름 → 받은
+ 경로(None 은 건너뜀), `outputs` 는 이름 → 이 실행이 갈아 끼우거나 지우는 항목(파일이나 폴더 — 출력이 더해지기만
+ 하는 폴더는 넣지 않는다). 입력마다 `follow_path` 로 따라가, 닿은 실경로가 출력과 같거나(덮어씀), 출력 안에
+ 들거나(지움), 찾아본 항목 가운데 하나가 출력 안에 들면(그 항목이 지워져 길이 끊기거나 링크 너머가 지워짐)
+ 거절한다. `holds` 에 이름이 든 출력은 입력 안에 들어도 거절한다(입력 안에 씀). 실경로와 장치·inode 로 보므로
+ 링크와 대소문자를 가리지 않는 볼륨의 다른 철자도 같은 항목이다. 한 번의 호출 안에서 이미 본 항목은 다시 재지
+ 않는다(찾은 입력이 많아도 공통 조상은 한 번). 따라갈 수 없는 입력(링크 고리)은 이름을 대며 거절한다."""
+ say = f"{verb}: " if verb else ""
+ looked_at: set[Path] = set()
+ for flag, given in inputs.items():
+ if given is None:
+ continue
+ looked, path = follow_input(flag, Path(given).expanduser(), verb=verb)
+ fresh = [entry for entry in looked if entry not in looked_at]
+ looked_at.update(fresh)
+ for out, place in outputs.items():
+ if same_folder(path, place):
+ kind = "folder" if path.is_dir() else "file"
+ raise SystemExit(f"{say}{flag} and {out} are the same {kind}: {path} (an input is never overwritten)")
+ if inside_folder(path, place):
+ raise SystemExit(f"{say}{flag} lies inside {out}: {path} ({replaces}, never an input)")
+ through = next((entry for entry in fresh if inside_folder(entry, place)), None)
+ if through is not None:
+ raise SystemExit(f"{say}{flag} goes through {through}, inside {out} ({replaces}, never an input)")
+ if out in holds and inside_folder(place, path):
+ raise SystemExit(f"{say}{out} lies inside {flag}: {place} (a run is never written into its input)")
+
+
def new_stage(out: Path, suffix: str) -> Path:
"""`out` 옆에 이 실행만의 빈 임시 폴더 `.<out>.<pid>-<random><suffix>` — 같은 볼륨이라 다 쓴 뒤 rename 으로
내놓는다. 이름이 이미 있으면(입력이든 다른 실행의 것이든) 그 폴더는 건드리지 않고 다른 이름을 고른다.
diff --git a/sprite_gen/video/align.py b/sprite_gen/video/align.py
index b44213c..ea1f707 100644
--- a/sprite_gen/video/align.py
+++ b/sprite_gen/video/align.py
@@ -715,8 +715,7 @@ def _rebuild(loop_dir: Path, meta_path: Path, meta: dict[str, Any], frames: list
delay_ms = max(20, round(1000 * cycle_seconds / len(cells)))
gif_path, webp_path = loop_dir / f"{name}.gif", loop_dir / f"{name}.webp"
save_clean_gif(cells, gif_path, duration_ms=delay_ms, loop=0, alpha_threshold=128)
- loop_mod.write_webp(cells, webp_path, delay_ms=delay_ms, workdir=loop_dir / ".webp-frames")
- shutil.rmtree(loop_dir / ".webp-frames", ignore_errors=True)
+ loop_mod.write_webp(cells, webp_path, delay_ms=delay_ms)
# a GIF or WebP holds a frame shown twice in a row (`--between nearest` stretching a loop) as one
# frame of twice the delay, so each is checked for one frame per run of identical cells
runs = loop_mod.shown_runs(cells)
diff --git a/sprite_gen/video/frames.py b/sprite_gen/video/frames.py
index d06e076..01dbc73 100644
--- a/sprite_gen/video/frames.py
+++ b/sprite_gen/video/frames.py
@@ -72,7 +72,7 @@ from sprite_gen.frames.decontam import palette_from_stats
from sprite_gen.frames.extract import _border_key_candidate_field, _key_channel_split, _painted_key_leans
from sprite_gen.frames.extract import _SPILL_FULL_MIN_TINT, DEFAULT_UNMIX_REACH
from sprite_gen.frames.extract import BORDER_MIN_FRACTION, FRAME_SIDES, own_border
-from sprite_gen.spec.runio import atomic_write_text
+from sprite_gen.spec.runio import atomic_write_text, new_stage, refuse_overlap
from sprite_gen.util.console import utf8_streams
EDGE_ROWS = 4 # rows/cols inspected at each edge
@@ -433,13 +433,25 @@ def refused_dir(keyed_dir: Path) -> Path:
def _withdraw(keyed_dir: Path) -> Path:
- """Take back what an earlier run handed over, and give this run an empty working folder (returned): until this
- run passes, `keyed_dir` holds nothing."""
- work = keyed_dir.with_name(f".{keyed_dir.name}.work")
+ """Take back what an earlier run handed over, and give this run an empty working folder of its own beside it
+ (`runio.new_stage`: `.keyed.<pid>-<random>.work`, returned; a folder already there, an input's or another
+ run's, is never touched): until this run passes, `keyed_dir` holds nothing."""
shutil.rmtree(keyed_dir, ignore_errors=True)
- shutil.rmtree(work, ignore_errors=True)
- work.mkdir(parents=True)
- return work
+ keyed_dir.parent.mkdir(parents=True, exist_ok=True)
+ return new_stage(keyed_dir, ".work")
+
+
+def _refuse_overlap(clip: Path, reference: Path | None, out_dir: Path, target: Path, report_given: bool,
+ receipt: Path | None) -> None:
+ """A run never writes over, moves or deletes what it reads: `--clip` and `--reference`, each with every link or
+ folder its path looks up, against what it replaces in `--out-dir` (`raw/`'s frames, `keyed/`, `keyed.refused/`),
+ its report and its source manifest (`runio.refuse_overlap`). Refused before anything is made."""
+ out = out_dir.expanduser().resolve()
+ outputs = {f"{n.name} in --out-dir": n for n in (out / "raw", out / "keyed", refused_dir(out / "keyed"))}
+ outputs["--report" if report_given else f"{target.name} in --out-dir"] = target
+ if receipt is not None:
+ outputs["--source-manifest"] = Path(receipt).expanduser().resolve()
+ refuse_overlap({"--clip": clip, "--reference": reference}, outputs, verb="video-frames")
def key_frames(
@@ -681,11 +693,11 @@ def run_frames(clip: Path, out_dir: Path, *, key: str, allow_edge_contact: bool,
raise SystemExit("video-frames: brightness alpha does not use --decontam")
if source_manifest is not None and reference is None:
raise SystemExit("video-frames: --source-manifest needs --reference (the source canvas)")
+ target = (report_path or (out_dir / "frames.report.json")).expanduser().resolve()
if source_manifest is not None:
- target = (report_path or out_dir / "frames.report.json").expanduser().resolve()
+ # Two of the run's own outputs, new paths both: what an input may be is `_refuse_overlap`'s.
receipt = Path(source_manifest).expanduser().resolve()
- if (receipt in (target, clip.expanduser().resolve(), Path(reference).expanduser().resolve())
- or receipt.is_relative_to((out_dir / "keyed").expanduser().resolve())
+ if (receipt == target or receipt.is_relative_to((out_dir / "keyed").expanduser().resolve())
or receipt.is_relative_to((out_dir / "raw").expanduser().resolve())):
raise SystemExit("video-frames: source manifest cannot overwrite source files or report")
if spill not in SPILL_MODES:
@@ -694,13 +706,14 @@ def run_frames(clip: Path, out_dir: Path, *, key: str, allow_edge_contact: bool,
raise SystemExit("video-frames: --spill auto needs --reference (the still the clip was made from)")
if decontam not in DECONTAM_MODES:
raise SystemExit(f"video-frames: unknown --decontam {decontam!r}; expected one of {', '.join(DECONTAM_MODES)}")
+ given = clip
clip = clip.expanduser().resolve()
if not clip.is_file():
raise SystemExit(f"video-frames: clip not found: {clip}")
+ _refuse_overlap(given, reference, out_dir, target, report_path is not None, source_manifest)
out_dir = out_dir.expanduser().resolve()
raw_dir = out_dir / "raw"
keyed_dir = out_dir / "keyed"
- target = (report_path or (out_dir / "frames.report.json")).expanduser().resolve()
# From here the run reads the clip: an earlier run's keyed frames are no longer handed over (`key_frames`).
shutil.rmtree(keyed_dir, ignore_errors=True)
meta = probe(clip)
diff --git a/sprite_gen/video/gait_fallback.py b/sprite_gen/video/gait_fallback.py
index 61a5031..1b7154c 100644
--- a/sprite_gen/video/gait_fallback.py
+++ b/sprite_gen/video/gait_fallback.py
@@ -312,9 +312,7 @@ def long_window(lo: int, n: int, fps: float) -> int:
def write_frames(frames: list[Image.Image], names: list[str], work_dir: Path) -> list[Path]:
- work_dir.mkdir(parents=True, exist_ok=True)
- for old in work_dir.glob("*.png"):
- old.unlink()
+ """`frames` saved under `names` into `work_dir`, a new empty folder of the run's own (video-loop's `_Scratch`)."""
paths = []
for name, frame in zip(names, frames):
path = work_dir / name
diff --git a/sprite_gen/video/loop.py b/sprite_gen/video/loop.py
index 50c6ffc..27c9a14 100644
--- a/sprite_gen/video/loop.py
+++ b/sprite_gen/video/loop.py
@@ -45,7 +45,7 @@ from typing import Any
from PIL import Image
from sprite_gen._deps import np
-from sprite_gen.spec.runio import atomic_write_text
+from sprite_gen.spec.runio import atomic_write_text, new_stage, refuse_overlap
from sprite_gen.util.gif_utils import save_clean_gif
from sprite_gen.util.resample import resize_cell
from sprite_gen.video import motion_anchor, auto_motion, local_cycle, gait_fallback, nonloop, effect
@@ -79,8 +79,9 @@ STEP_RATIO_MAX = 2.5
# frame moved 2 px reads 0.057 drawn in colour and 0.021 drawn black.
STEP_JITTER_PX = 1.5
PERIODICITY_MIN = 0.15 # the period must dip at least 15% below the profile mean (flat profile = no repeat)
-# Where the gait fallback writes the frames it scaled back (removed once the strip is built).
-FALLBACK_FRAMES_DIR = ".gait-fallback-frames"
+# Where a size hold or the gait fallback writes the frames it scaled back: a folder of the run's own in the out dir,
+# `.gait-fallback-frames.<pid>-<random>` (`_Scratch`), removed however the run ends.
+FALLBACK_FRAMES = "gait-fallback-frames"
GIF_FPS_DEFAULT = 24.0 # GIF/WebP playback density = the source rate: every cycle frame is kept, a fast action never looks slow (12 made a jump read sluggish, 2026-09-09)
GIF_FRAMES_MIN = 4
ONE_SHOT_MIN_CONTRAST = 3.0 # one-shot: the excursion peak must stand this far above the rest-pose noise (in MADs)
@@ -856,9 +857,11 @@ def img2webp_supports_exact(binary: str | None = None) -> bool:
return "-exact" in (proc.stdout + proc.stderr)
-def write_webp(frames: list[Image.Image], out: Path, *, delay_ms: int, workdir: Path, loop: int = 0) -> None:
+def write_webp(frames: list[Image.Image], out: Path, *, delay_ms: int, loop: int = 0) -> None:
"""Animated WebP through libwebp's img2webp with -exact (Pillow's animated writer drops `exact`
- and rewrites RGB under alpha 0 to white; measured 2026-09-08)."""
+ and rewrites RGB under alpha 0 to white; measured 2026-09-08). The frames reach img2webp as PNGs in a
+ folder of this call's own beside `out` (`runio.new_stage`: `.<out>.<pid>-<random>.frames`), removed once
+ it has run: a folder already there, an input's or another run's, is never written into or removed."""
img2webp = shutil.which("img2webp")
if not img2webp:
raise SystemExit("video-loop: `img2webp` not found on PATH — install libwebp (brew install webp) for exact-alpha WebP")
@@ -867,13 +870,16 @@ def write_webp(frames: list[Image.Image], out: Path, *, delay_ms: int, workdir:
"video-loop: this img2webp has no `-exact` option (libwebp < 1.5; Ubuntu 24.04 ships 1.3.x) — "
"install libwebp >= 1.5 (brew install webp, or the official binaries from storage.googleapis.com/downloads.webmproject.org)"
)
- workdir.mkdir(parents=True, exist_ok=True)
- paths = []
- for k, im in enumerate(frames):
- p = workdir / f"webp-{k:03d}.png"
- im.save(p)
- paths.append(str(p))
- proc = subprocess.run([img2webp, "-loop", str(loop), "-lossless", "-exact", "-d", str(delay_ms), *paths, "-o", str(out)], capture_output=True, text=True)
+ workdir = new_stage(out, ".frames")
+ try:
+ paths = []
+ for k, im in enumerate(frames):
+ p = workdir / f"webp-{k:03d}.png"
+ im.save(p)
+ paths.append(str(p))
+ proc = subprocess.run([img2webp, "-loop", str(loop), "-lossless", "-exact", "-d", str(delay_ms), *paths, "-o", str(out)], capture_output=True, text=True)
+ finally:
+ shutil.rmtree(workdir, ignore_errors=True)
if proc.returncode != 0 or not out.is_file():
raise SystemExit(f"video-loop: img2webp failed: {proc.stderr.strip()[:300]}")
@@ -933,7 +939,6 @@ def refuse(target: Path, out_dir: Path, name: str, report: dict[str, Any], *, cu
read the exit code finds nothing to pass on, and write the report (`status: failed`). A cut this run wrote stays as
`cycle.refused/`, in place of an earlier one."""
out_dir = out_dir.expanduser().resolve()
- shutil.rmtree(out_dir / FALLBACK_FRAMES_DIR, ignore_errors=True)
shutil.rmtree(out_dir / CYCLE_REFUSED_DIR, ignore_errors=True)
if cut_written:
(out_dir / "cycle").rename(out_dir / CYCLE_REFUSED_DIR)
@@ -1636,10 +1641,52 @@ def _blend_wrap(frames: list[Image.Image], pin_file: Path, *, mode: str, anchor:
return wrap_blend_mod.apply(frames, pin, fps=fps, seam_max=seam_max)
-def run_loop(
+class _Scratch:
+ """The folders a run writes the frames a size hold or the gait fallback scaled back into: each a new one of the
+ run's own in the out dir (`runio.new_stage`: `.gait-fallback-frames.<pid>-<random>`), so a folder already there —
+ an input's, or another run's — is never written into or removed; `run_loop` removes them however the run ends."""
+
+ def __init__(self, out_dir: Path) -> None:
+ self.out_dir = out_dir
+ self.made: list[Path] = []
+
+ def new(self) -> Path:
+ out = self.out_dir.expanduser().resolve()
+ out.mkdir(parents=True, exist_ok=True)
+ self.made.append(new_stage(out / FALLBACK_FRAMES, ""))
+ return self.made[-1]
+
+ def remove(self) -> None:
+ for folder in self.made:
+ shutil.rmtree(folder, ignore_errors=True)
+
+
+def _refuse_overlap(frames_dir: Path, files: list[Path], out_dir: Path, name: str, target: Path, report_given: bool) -> None:
+ """A cut never writes over, moves or deletes the frames it reads: `--frames-dir`, every frame found in it and every
+ link or folder their paths look up, against what the cut replaces in `--out-dir` (`handed_over`, `cycle.refused/`)
+ and its report (`runio.refuse_overlap`). Refused before a frame is read or anything is made. `--out-dir` itself is
+ not compared: a cut adds to it, and the clip's frames are often inside it (`video-frames`' `keyed/`)."""
+ out = out_dir.expanduser().resolve()
+ outputs = {f"{path.name} in --out-dir": path for path in (*handed_over(out, name), out / CYCLE_REFUSED_DIR)}
+ outputs["--report" if report_given else f"{target.name} in --out-dir"] = target
+ refuse_overlap({"--frames-dir": frames_dir, **{f"{f.name} in --frames-dir": f for f in files}}, outputs, verb="video-loop")
+
+
+def run_loop(frames_dir: Path, out_dir: Path, **options: Any) -> dict[str, Any]:
+ """Cut the loop (`_cut_loop`, which takes the options). The frames a size hold or the gait fallback scales back
+ are written in folders of the run's own (`_Scratch`), removed however the run ends."""
+ scratch = _Scratch(out_dir)
+ try:
+ return _cut_loop(frames_dir, out_dir, scratch=scratch, **options)
+ finally:
+ scratch.remove()
+
+
+def _cut_loop(
frames_dir: Path,
out_dir: Path,
*,
+ scratch: _Scratch,
fps: float,
state: str | None,
min_len: int | None,
@@ -1717,10 +1764,13 @@ def run_loop(
raise SystemExit("video-loop: --steps counts the steps in the cut --anchor motion-auto takes; pass --anchor motion-auto")
if cycle_mode not in CYCLE_MODES:
raise SystemExit(f"video-loop: unknown --cycle {cycle_mode!r}; expected one of {', '.join(CYCLE_MODES)}")
+ given = frames_dir
frames_dir = frames_dir.expanduser().resolve()
files = sorted(frames_dir.glob("*.png"))
if len(files) < 6:
raise SystemExit(f"video-loop: need at least 6 keyed frames in {frames_dir}, found {len(files)}")
+ target = (report_path or (out_dir / f"{name}.loop.report.json")).expanduser().resolve()
+ _refuse_overlap(given, files, out_dir, name, target, report_path is not None)
prof = profile_for(state)
n = len(files)
# A walk or run may open on a lead-in (gait_fallback.lead_in): the video model reframing a small
@@ -1742,7 +1792,6 @@ def run_loop(
clip_steps = [float(D[k, k + 1]) for k in range(n - 1)]
masses = effect.frame_masses(files) if cycle_mode == "lifetime" else frame_masses(files)
periodic_attempt: dict[str, Any] | None = None
- target = (report_path or (out_dir / f"{name}.loop.report.json")).expanduser().resolve()
report_base = {
"kind": "sprite-gen-video-loop-report", "frames_dir": str(frames_dir),
"source": evidence_mod.source_identity(files, fps),
@@ -1781,7 +1830,7 @@ def run_loop(
if abs(measured["drift"]) >= gait_fallback.SIZE_HOLD_MIN:
pad = gait_fallback.undo_padding(source_frames, measured)
source_frames = gait_fallback.undo_scale(source_frames, measured, pad=pad)
- files = gait_fallback.write_frames(source_frames, [f.name for f in files], out_dir.expanduser().resolve() / FALLBACK_FRAMES_DIR)
+ files = gait_fallback.write_frames(source_frames, [f.name for f in files], scratch.new())
hold.update(applied=True, padding_ltrb=list(pad))
report_base["size_hold"] = hold
else:
@@ -1805,7 +1854,7 @@ def run_loop(
if abs(drift["drift"]) >= gait_fallback.SCALE_DRIFT_MIN:
fallback["padding_ltrb"] = list(gait_fallback.undo_padding(source_frames, drift))
source_frames = gait_fallback.undo_scale(source_frames, drift, pad=tuple(fallback["padding_ltrb"]))
- files = gait_fallback.write_frames(source_frames, [f.name for f in files], out_dir.expanduser().resolve() / FALLBACK_FRAMES_DIR)
+ files = gait_fallback.write_frames(source_frames, [f.name for f in files], scratch.new())
D, trajectory, analysis = auto_motion.analyse(source_frames, fps=fps)
report_base["automatic_motion_analysis"] = analysis
fallback["scale_undone"] = True
@@ -2152,8 +2201,6 @@ def run_loop(
"samples": [i + k for k in strip_meta["sample_indices"]]}
if cycle["kind"] in nonloop.KINDS:
strip_meta.update(nonloop.metadata(cycle, strip_meta["sample_indices"]))
- # The scaled-back frames are read for the last time above; the cycle cells keep them.
- shutil.rmtree(out_dir / FALLBACK_FRAMES_DIR, ignore_errors=True)
if state:
# `video-cycle-align` reads the gait floor of this state when it screens a loop for two cycles.
strip_meta["state"] = str(state).strip().lower()
@@ -2312,8 +2359,7 @@ def run_loop(
try:
save_clean_gif(gif_pick, gif_path, duration_ms=delay_ms, loop=None if single_play else 0,
alpha_threshold=128, opaque=gif_background is not None)
- write_webp(pick, webp_path, delay_ms=delay_ms, workdir=out_dir / ".webp-frames", **({"loop": 1} if single_play else {}))
- shutil.rmtree(out_dir / ".webp-frames", ignore_errors=True)
+ write_webp(pick, webp_path, delay_ms=delay_ms, **({"loop": 1} if single_play else {}))
# A filmed ghost given way to the frame beside it is that frame shown twice in a row: one frame of the GIF or WebP
shown = shown_runs(pick)
gif_report = verify_animation(gif_path, expect_frames=shown_runs(gif_pick), check_stale=False,
@@ -2322,7 +2368,6 @@ def run_loop(
webp_report = verify_animation(webp_path, expect_frames=shown, check_stale=True, **({"expected_loop": 1} if single_play else {}))
except SystemExit as exc:
# The GIF or WebP could not be written (no img2webp) or failed its verification: nothing of the cut is handed over.
- shutil.rmtree(out_dir / ".webp-frames", ignore_errors=True)
refuse(target, out_dir, name, {**report_base, "status": "failed", "error": str(exc), "cycle": cycle}, cut_written=True)
raise
diff --git a/sprite_gen/video/restoration.py b/sprite_gen/video/restoration.py
index 797dffc..9c2572d 100644
--- a/sprite_gen/video/restoration.py
+++ b/sprite_gen/video/restoration.py
@@ -537,8 +537,7 @@ def _write_candidate(paths: dict[str, Path], out: Path, name: str, baseline: Loo
indices, delay = playback.mapping(baseline)
selected = [frames[k] for k in indices]
save_clean_gif(selected, stage / names["gif"], duration_ms=delay, alpha_threshold=128)
- write_webp(selected, stage / names["webp"], delay_ms=delay, workdir=stage / ".webp")
- shutil.rmtree(stage / ".webp")
+ write_webp(selected, stage / names["webp"], delay_ms=delay)
stage.rename(out)
finally:
if stage.exists():
diff --git a/sprite_gen/video/stop.py b/sprite_gen/video/stop.py
index 4f1af04..9029105 100644
--- a/sprite_gen/video/stop.py
+++ b/sprite_gen/video/stop.py
@@ -56,7 +56,6 @@ import argparse
import hashlib
import json
import math
-import shutil
import sys
from pathlib import Path
from typing import Any
@@ -64,7 +63,7 @@ from typing import Any
from PIL import Image
from sprite_gen._deps import np
-from sprite_gen.spec.runio import atomic_write_text
+from sprite_gen.spec.runio import atomic_write_text, refuse_overlap
from sprite_gen.util.gif_utils import save_clean_gif
from sprite_gen.util.resample import resize_cell
from sprite_gen.video import evidence as evidence_mod
@@ -101,13 +100,31 @@ class StopRefused(ValueError):
self.record = record
+def _strip_beside(meta_path: Path) -> Path:
+ """The strip a loop's sidecar `<name>.strip.json` names: `<name>.strip.png` beside it."""
+ return meta_path.with_name(meta_path.name[: -len(".json")] + ".png")
+
+
+def _refuse_overlap(frames_dir: Path, files: list[Path], loop_meta: Path, out_dir: Path, name: str, target: Path,
+ report_given: bool) -> None:
+ """A stop never writes over, moves or deletes what it reads: `--frames-dir` and every frame found in it, `--loop`
+ and the strip beside it, each with every link or folder its path looks up, against the files it writes in
+ `--out-dir` and its report (`runio.refuse_overlap`). Refused before anything is made."""
+ meta = Path(loop_meta).expanduser()
+ inputs = {"--frames-dir": Path(frames_dir), **{f"{f.name} in --frames-dir": f for f in files},
+ "--loop": meta, f"{_strip_beside(meta).name} beside --loop": _strip_beside(meta)}
+ outputs = {f"{n} in --out-dir": out_dir / n for n in (f"{name}.strip.png", f"{name}.strip.json", f"{name}.gif", f"{name}.webp")}
+ outputs["--report" if report_given else f"{target.name} in --out-dir"] = target
+ refuse_overlap(inputs, outputs, verb=PROG)
+
+
def read_loop(meta_path: Path) -> tuple[dict[str, Any], list[Image.Image], str]:
"""The loop's sidecar, its cells and its strip's sha256. A loop the stop cannot leave from is refused."""
meta_path = Path(meta_path).expanduser()
if not meta_path.name.endswith(".strip.json"):
raise SystemExit(f"{PROG}: --loop {meta_path}: a loop strip's sidecar, <name>.strip.json")
meta = json.loads(meta_path.read_text(encoding="utf-8"))
- strip_path = meta_path.with_name(meta_path.name[: -len(".json")] + ".png")
+ strip_path = _strip_beside(meta_path)
data = strip_path.read_bytes()
strip = Image.open(strip_path).convert("RGBA")
n, w, h = int(meta["frames"]), int(meta["w"]), int(meta["h"])
@@ -360,6 +377,7 @@ def make_stop(frames_dir: Path, loop_meta: Path, out_dir: Path, *, name: str = "
if len(files) < start + length:
raise SystemExit(f"{PROG}: {frames_dir} holds {len(files)} frames; the loop was cut from frames {start} to "
f"{start + length - 1} of its clip — give the clip's keyed frames (video-frames …/keyed)")
+ _refuse_overlap(frames_dir, files, loop_meta, out_dir, name, target, report_path is not None)
identity = evidence_mod.source_identity(files, fps)
same_source = identity["sha256"] == cut["source"].get("sha256")
base: dict[str, Any] = {
@@ -429,8 +447,7 @@ def make_stop(frames_dir: Path, loop_meta: Path, out_dir: Path, *, name: str = "
gif_path, webp_path = out_dir / f"{name}.gif", out_dir / f"{name}.webp"
ms = max(20, round(1000 / fps))
save_clean_gif(stop_cells, gif_path, duration_ms=ms, loop=None, alpha_threshold=128)
- loop_mod.write_webp(stop_cells, webp_path, delay_ms=ms, workdir=out_dir / ".webp-frames", loop=1)
- shutil.rmtree(out_dir / ".webp-frames", ignore_errors=True)
+ loop_mod.write_webp(stop_cells, webp_path, delay_ms=ms, loop=1)
shown_runs = loop_mod.shown_runs(stop_cells)
gif = loop_mod.verify_animation(gif_path, expect_frames=shown_runs, check_stale=False, expected_loop=None)
webp = loop_mod.verify_animation(webp_path, expect_frames=shown_runs, check_stale=True, expected_loop=1)
diff --git a/sprite_gen/video/sway.py b/sprite_gen/video/sway.py
index 35d786f..dc7d809 100644
--- a/sprite_gen/video/sway.py
+++ b/sprite_gen/video/sway.py
@@ -1003,7 +1003,7 @@ def sway_loop(loop_dir: Path, regions: list[tuple[float, ...]], *, gain: float |
staged = {path: stage / path.name for path in (strip_path, gif_path, webp_path, meta_path)}
joined.save(staged[strip_path])
save_clean_gif(out, staged[gif_path], duration_ms=delay_ms, loop=0, alpha_threshold=128)
- loop_mod.write_webp(out, staged[webp_path], delay_ms=delay_ms, workdir=stage / ".webp-frames")
+ loop_mod.write_webp(out, staged[webp_path], delay_ms=delay_ms)
# a cell left as it was beside its twin (a filmed ghost given way to the frame beside it) is one frame of both
shown = loop_mod.shown_runs(out)
record = {
diff --git a/sprite_gen/video/sway_inspect.py b/sprite_gen/video/sway_inspect.py
index 2976c55..e029b31 100644
--- a/sprite_gen/video/sway_inspect.py
+++ b/sprite_gen/video/sway_inspect.py
@@ -60,7 +60,7 @@ from PIL import Image
from sprite_gen._deps import np
from sprite_gen.effects import breathe as breathe_mod
-from sprite_gen.spec.runio import atomic_write_set
+from sprite_gen.spec.runio import atomic_write_set, inside_folder, same_folder
from sprite_gen.video import loop as loop_mod
from sprite_gen.video import sway
from sprite_gen.util.console import utf8_streams
@@ -286,7 +286,7 @@ def inspect_loop(loop_dir: Path, regions: list[tuple[float, ...]], out_dir: Path
gain_across=gain_across)
ask = request.ask
out_dir = out_dir.expanduser().resolve()
- if out_dir == request.loop_dir or request.loop_dir in out_dir.parents:
+ if same_folder(out_dir, request.loop_dir) or inside_folder(out_dir, request.loop_dir):
raise SystemExit(f"{verb}: --out-dir {out_dir} is in the loop directory; an inspection writes nothing there")
scale, columns = int(scale), int(columns)
if scale < 1 or columns < 1:
diff --git a/tests/video/test_gait_fallback.py b/tests/video/test_gait_fallback.py
index 24ac3bc..586ff15 100644
--- a/tests/video/test_gait_fallback.py
+++ b/tests/video/test_gait_fallback.py
@@ -146,7 +146,7 @@ def test_a_clip_the_first_search_cuts_is_cut_without_the_fallback(tmp_path):
assert code == 0
assert report['cycle']['length'] == 24
assert 'gait_fallback' not in report
- assert not (output/loop.FALLBACK_FRAMES_DIR).exists()
+ assert not list(output.glob(f'.{loop.FALLBACK_FRAMES}*'))
# A clip that keeps its size is not held.
assert report['size_hold']['applied'] is False
assert abs(report['size_hold']['drift']) < gait_fallback.SIZE_HOLD_MIN
@@ -163,7 +163,7 @@ def test_a_cycle_longer_than_half_the_clip_is_found_by_the_fallback(tmp_path):
assert 'no periodic cycle found' in fallback['reason']
assert fallback['scale_undone'] is False
assert fallback['window'] == [12, gait_fallback.long_window(12, 73, 24.0)]
- assert not (output/loop.FALLBACK_FRAMES_DIR).exists()
+ assert not list(output.glob(f'.{loop.FALLBACK_FRAMES}*'))
@pytest.mark.slow
@@ -179,7 +179,7 @@ def test_a_walk_toward_the_camera_is_held_at_its_size_before_the_first_search(tm
cells = sorted((output/'cycle').glob('frame-*.png'))
heights = gait_fallback.subject_boxes([Image.open(p).convert('RGBA') for p in cells])
assert np.ptp(heights[:, 3]-heights[:, 1]) <= 6
- assert not (output/loop.FALLBACK_FRAMES_DIR).exists()
+ assert not list(output.glob(f'.{loop.FALLBACK_FRAMES}*'))
@pytest.mark.slow
@@ -315,7 +315,7 @@ def test_a_walk_toward_the_camera_is_scaled_back_before_the_second_search(tmp_pa
heights = heights[:, 3]-heights[:, 1]
# Filmed, the cycle grows by about 6 %; scaled back, it keeps the walker's own bob only.
assert np.ptp(heights) <= 6
- assert not (output/loop.FALLBACK_FRAMES_DIR).exists()
+ assert not list(output.glob(f'.{loop.FALLBACK_FRAMES}*'))
@pytest.mark.slow
@@ -325,7 +325,7 @@ def test_no_cycle_in_either_search_says_so_and_keeps_the_gate_line(tmp_path):
assert str(code).startswith('video-loop: no periodic cycle found')
assert 'also with the gait fallback' in str(code)
assert report['status'] == 'failed' and report['gait_fallback']['scale_undone'] is False
- assert not (output/loop.FALLBACK_FRAMES_DIR).exists()
+ assert not list(output.glob(f'.{loop.FALLBACK_FRAMES}*'))
@pytest.mark.parametrize('n, fps, expected', [(73, 24.0, 43), (145, 24.0, 48), (37, 24.0, 22)])
diff --git a/tests/video/test_source_restoration.py b/tests/video/test_source_restoration.py
index 540870f..a76e2d5 100644
--- a/tests/video/test_source_restoration.py
+++ b/tests/video/test_source_restoration.py
@@ -56,7 +56,7 @@ def damage(im, zoom=1):
def exports(paths, fs, delay=42):
save_clean_gif(fs, paths['gif'], duration_ms=delay, alpha_threshold=128)
- loop.write_webp(fs, paths['webp'], delay_ms=delay, workdir=paths['webp'].parent/'webp-temp')
+ loop.write_webp(fs, paths['webp'], delay_ms=delay)
def cleaned(frame):
@@ -276,7 +276,7 @@ def test_actual_playback_mismatch_and_byte_hashes(case,tmp_path):
paths=outputs(r)
# Same strip, differently timed WebP: even a rewritten receipt is rejected.
c,_=restoration.read_loop(paths)
- loop.write_webp(c.frames,paths['webp'],delay_ms=60,workdir=tmp_path/'bad-webp')
+ loop.write_webp(c.frames,paths['webp'],delay_ms=60)
c,_=restoration.read_loop(paths); r['candidate_artifacts']=c.artifacts
assert compare_result(case,r)['verdict']=='unknown'
for key,p in paths.items(): assert c.artifacts[key]['sha256']==evidence.digest(p.read_bytes())