diffusers-workflow 0.4.0__py3-none-any.whl

dw/settings.py

@@ -0,0 +1,98 @@
+import json
+import os
+from pathlib import Path
+
+
+class Settings:
+    log_level: str = "WARNING"
+    log_filename: str = "log/dw.log"
+    log_to_console: bool = False
+
+    # Device to run on - None detects the best one available. Set to pick a specific
+    # accelerator ('cuda:1') or force a backend ('cpu', 'mps'). The DW_DEVICE
+    # environment variable overrides this for a single run.
+    device: str = None
+
+    # Directory holding this user's workflows, prompts, assets and outputs.
+    # None resolves it - see dw/workspace.py for the order, which ends at the
+    # working directory when it looks like a workspace, then ~/diffusers-workspace
+    workspace: str = None
+
+    # How generated files are laid out under the output directory: "run"
+    # gives each execution its own directory, "flat" keeps the pre-workspace
+    # layout. See dw/runs.py
+    output_layout: str = "run"
+
+    # PyTorch optimization settings
+    enable_tf32: bool = True  # TensorFloat-32 for faster matmul on Ampere+ GPUs
+    cudnn_benchmark: bool = True  # cuDNN autotuner (faster for fixed sizes)
+    cudnn_deterministic: bool = False  # Set True for reproducibility
+
+    # This server's public origin (e.g. "https://dw.example.com"), for a
+    # client that can't otherwise turn a served path into a URL it can open
+    # itself. None (the default) means no such origin is configured, so
+    # nothing composes one - see dw/server/app.py's `_served_url`. The
+    # DW_PUBLIC_URL environment variable overrides this for a single run.
+    public_url: str = None
+
+
+def load_settings():
+    settings = Settings()
+    try:
+        with open(get_settings_full_path(), "r") as file:
+            settings_dict = json.load(file)
+    except FileNotFoundError:
+        settings_dict = {}
+    except json.JSONDecodeError:
+        print("invalid settings file")
+        settings_dict = {}
+
+    settings.log_level = settings_dict.get("log_level", "WARNING")
+    settings.log_filename = settings_dict.get("log_filename", "log/dw.log")
+    settings.log_to_console = settings_dict.get("log_to_console", False)
+
+    settings.device = settings_dict.get("device", None)
+    settings.workspace = settings_dict.get("workspace", None)
+    settings.output_layout = settings_dict.get("output_layout", "run")
+
+    # PyTorch optimization settings
+    settings.enable_tf32 = settings_dict.get("enable_tf32", True)
+    settings.cudnn_benchmark = settings_dict.get("cudnn_benchmark", True)
+    settings.cudnn_deterministic = settings_dict.get("cudnn_deterministic", False)
+
+    settings.public_url = settings_dict.get("public_url", None)
+
+    return settings
+
+
+def save_settings(settings):
+    settings_dict = settings.__dict__
+    with open(get_settings_full_path(), "w") as file:
+        json.dump(settings_dict, file, indent=2)
+
+
+def settings_exist():
+    return get_settings_full_path().is_file()
+
+
+def resolve_path(path):
+    full_path = get_settings_dir().joinpath(path)
+    # make the directory if it doesn't exist
+    full_path.parent.mkdir(parents=True, exist_ok=True)
+
+    return full_path
+
+
+def get_settings_dir():
+    dir_path = os.environ.get("DIFFUSERS_HELPER_ROOT") or "~/.diffusers_helper/"
+
+    return Path(dir_path).expanduser()
+
+
+def save_file(data, filename):
+    with open(resolve_path(filename), "w") as file:
+        json.dump(data, file, indent=2)
+
+
+def get_settings_full_path():
+    return resolve_path("settings.json")

dw/shot_span_preflight.py

@@ -0,0 +1,116 @@
+"""A `shots` argument to an assessment probe (`analyze_shots`,
+`analyze_seams`, `analyze_sync_drift`) whose frame span already runs past a
+statically-knowable video's real length, warned about before the run (#425).
+
+The probes silently clip an overrunning shot record to the file (`_clip` in
+`dw/tasks/assess.py`) and only say so at run time
+(`_shot_span_findings`, same module) - a message correct but late once the
+run has already spent the decode. Mirrors `slice_preflight.py` (#402): walk
+the expanded definition, `resolve_path_references` an `asset:`/`output:`
+video into a real path, and `probe_media` it - the same resolution and
+decode the run itself would do, just ahead of the queue.
+
+Deliberately narrower than the run-time check, same as #402's: a
+`previous_result:` video (nothing written yet), a remote URL, a literal path
+outside the directories the run may read, or a source `probe_media` cannot
+read, all answer "unknown" rather than guessing - silence here is correct,
+not a gap, since the run-time warning still fires once the file exists. Only
+the `shots` argument's `start_frame`/`num_frames` are checked; a `shots`
+argument sourced from a `variable:`/`previous_result:`/`gather:` reference
+names no records yet and is left to the run-time check.
+"""
+
+from .for_each import MEMBER_SEPARATOR, render_path
+from .media_info import probe_media
+from .probe_paths import resolve_probe_path
+
+PROBE_COMMANDS = ("analyze_shots", "analyze_seams", "analyze_sync_drift")
+
+
+def _frame_count(path):
+    """The frame count a probe would see for this file, or None when it
+    cannot be probed or carries no video stream."""
+    info = probe_media(path)
+    if info is None or info.get("kind") != "video":
+        return None
+    return info.get("frame_count")
+
+
+def _as_number(value):
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        return None
+    return value
+
+
+def shot_span_warnings(workflow_definition, source_indices=None, base_dir=None):
+    """Every assessment-probe step whose `shots` argument already reaches
+    past a statically-resolvable video's real frame count, as messages.
+
+    Walks the substituted, expanded definition, the same convention
+    `slice_past_end_warnings` follows: `source_indices` maps an expanded step
+    back to the one the author wrote, and a path inside a `for_each` member
+    names the member.
+    """
+    steps = workflow_definition.get("steps")
+    if not isinstance(steps, list):
+        return []
+
+    warnings = []
+    for index, step in enumerate(steps):
+        if not isinstance(step, dict):
+            continue
+        task = step.get("task")
+        if not isinstance(task, dict) or task.get("command") not in PROBE_COMMANDS:
+            continue
+        task_args = task.get("arguments")
+        if not isinstance(task_args, dict):
+            continue
+        shots = task_args.get("shots")
+        if not isinstance(shots, list) or not shots:
+            continue
+
+        path = resolve_probe_path(task_args.get("video"), base_dir, "a video argument")
+        if path is None:
+            continue
+        frame_count = _frame_count(path)
+        if frame_count is None:
+            continue
+
+        problems = []
+        for shot in shots:
+            if not isinstance(shot, dict):
+                continue
+            start_frame = _as_number(shot.get("start_frame", 0))
+            num_frames = _as_number(shot.get("num_frames"))
+            if start_frame is None or num_frames is None:
+                continue
+            end = start_frame + num_frames
+            if end > frame_count:
+                problems.append(
+                    f"shot {shot.get('name')!r} reaches frame {int(end)}, "
+                    f"{int(end - frame_count)} past the file's {frame_count} frames"
+                )
+        if not problems:
+            continue
+
+        source = (
+            source_indices[index]
+            if source_indices is not None and index < len(source_indices)
+            else index
+        )
+        name = step.get("name")
+        where = (
+            f" in member '{name}'"
+            if isinstance(name, str) and MEMBER_SEPARATOR in name
+            else ""
+        )
+        path_str = render_path(("steps", source, "task", "arguments", "shots"))
+        warnings.append(
+            f"{path_str}: {task['command']} will clip {'; '.join(problems)}{where} "
+            "- the probe measures a shorter window than the record asks for, "
+            "silently, unless the record is corrected"
+        )
+    return warnings
+
+
+__all__ = ["shot_span_warnings"]

dw/shots.py

@@ -0,0 +1,359 @@
+"""Shot boundaries a joined video carries: where each input landed in it.
+
+A step that joins shots - `concat_videos`, `dissolve_videos`, a chained
+pipeline - knows exactly where every seam fell, in frames and in samples, and
+used to throw that away: a consumer checking a cut had to re-derive the seams
+from arguments, and a shot whose track ran 267 samples long drifted the rest
+of the cut with nothing saying where (#378). The join now records one entry
+per shot on the `AudioVideo` it returns (`AudioVideo.shots`), the step's
+manifest entry carries them, and `get_gallery_metadata` reads them back.
+
+A shot is a dict:
+
+- `name` - which input it was: `shot@<key>` when the step named a `for_each`
+  member, else the path it was given, else `video N` / `segment N`
+- `start_frame`, `num_frames` - its place on the joined picture. The shots
+  partition the frames: the counts add up to the file's frame count
+- `start_sample`, `num_samples` - its place on the joined track, *measured*
+  from the waveform the join built rather than derived from the frame
+  numbers, so an overrun shows up as a count that disagrees with the frames'.
+  None when the video has no track, or when the track is one the join did
+  not build shot by shot (a chain's `match_audio`)
+- `overlap_frames` - a dissolve's head: the frames at its start that are
+  blended with the shot before it
+
+Every other `AudioVideo` constructor either carries the list (same frames),
+rescales it (`interpolate_frames`), re-measures the sample side for a new
+track (`pair_audio`), or builds a video with no shots at all.
+`tests/test_shots.py` fails on a constructor site nobody decided for.
+"""
+
+import copy
+
+from .arguments import PREVIOUS_RESULT_PREFIX
+
+# The step names a for_each member as `<group>@<entry>`; only a member of the
+# group conventionally called `shot` names a shot
+SHOT_REFERENCE_PREFIX = f"{PREVIOUS_RESULT_PREFIX}shot@"
+
+
+def shot_record(
+    name, start_frame, num_frames, start_sample=None, num_samples=None, **extra
+):
+    """One shot's entry, in the key order the manifest shows."""
+    record = {
+        "name": name,
+        "start_frame": int(start_frame),
+        "num_frames": int(num_frames),
+        "start_sample": None if start_sample is None else int(start_sample),
+        "num_samples": None if num_samples is None else int(num_samples),
+    }
+    record.update(extra)
+    return record
+
+
+def carried_shots(source):
+    """The shots of a video whose frames a step kept one for one, copied."""
+    shots = getattr(source, "shots", None)
+    return copy.deepcopy(shots) if shots else None
+
+
+def without_samples(shots):
+    """The shots with their sample side cleared - a track that is gone."""
+    return [{**shot, "start_sample": None, "num_samples": None} for shot in shots]
+
+
+def rescaled_shots(shots, multiplier):
+    """The shots of a video whose frames were multiplied by interpolation.
+
+    N frames become (N - 1) * multiplier + 1: every frame but the last gains
+    multiplier - 1 frames after it. A shot starting at frame s now starts at
+    s * multiplier, and the last shot keeps the one frame nothing follows.
+    Interpolation drops the track, so the sample side goes with it.
+    """
+    if not shots:
+        return None
+    total = sum(shot["num_frames"] for shot in shots)
+    rescaled = []
+    for shot in shots:
+        start = shot["start_frame"] * multiplier
+        end = shot["start_frame"] + shot["num_frames"]
+        new_end = (end - 1) * multiplier + 1 if end == total else end * multiplier
+        entry = {
+            **shot,
+            "start_frame": start,
+            "num_frames": new_end - start,
+            "start_sample": None,
+            "num_samples": None,
+        }
+        if shot.get("overlap_frames"):
+            entry["overlap_frames"] = shot["overlap_frames"] * multiplier
+        rescaled.append(entry)
+    return rescaled
+
+
+def remeasured_shots(shots, fps, sample_rate, total_samples):
+    """The shots of a video laid over a new track by pair_audio.
+
+    The frame side is unchanged. The new track was not built shot by shot, so
+    each shot's samples are the stretch of the track its frames play over: a
+    shot starts at start_frame / fps seconds, and the last one runs to the end
+    of the track as written - with `fit: "video"` that is the fitted length.
+    Without a frame rate there is no way to place a frame on the track, so the
+    sample side is cleared rather than guessed.
+
+    This deliberately makes the last shot the one place `num_samples` can
+    disagree with `round(num_frames * sample_rate / fps)` (#423): every other
+    boundary is a frame position rounded onto the new rate, but the last one
+    is the track's actual end, whatever the audio chain that built it (a
+    resample, a mix, a normalize) landed on - usually the same figure, but a
+    sample or two off is rounding slop, not a dropped or invented sample.
+    `pair_audio` already warns separately (`audio_video_length_mismatch`,
+    `audio_padded_to_video`, `audio_trimmed_to_video`) when a track disagrees
+    with its video by more than a frame's worth, so a real overrun is never
+    silent; this is only ever the sub-frame remainder landing on the last
+    shot instead of being unaccounted for.
+    """
+    if not shots:
+        return None
+    if not fps or not sample_rate or total_samples is None:
+        return without_samples(shots)
+    starts = [
+        min(int(round(shot["start_frame"] / fps * sample_rate)), total_samples)
+        for shot in shots
+    ]
+    ends = starts[1:] + [total_samples]
+    return [
+        {**shot, "start_sample": start, "num_samples": max(end - start, 0)}
+        for shot, start, end in zip(shots, starts, ends)
+    ]
+
+
+def trimmed_shots(shots, head_trim):
+    """The shots of a video after dropping `head_trim` frames off its start.
+
+    concat_videos trims the head of every video after the first before
+    joining it. A shot entirely inside the trim never reaches the joined
+    picture and is dropped; one straddling the cut survives, clipped to what
+    is left and re-based to start at 0, so a later frame offset places it
+    correctly. The crossfade drawn from the trimmed material makes the
+    surviving samples' position in the joined track unmeasurable, so the
+    sample side is cleared regardless of rate.
+    """
+    if not head_trim:
+        return shots
+    clipped = []
+    for shot in shots:
+        end = shot["start_frame"] + shot["num_frames"]
+        if end <= head_trim:
+            continue
+        start = max(shot["start_frame"], head_trim)
+        clipped.append(
+            {
+                **shot,
+                "start_frame": start - head_trim,
+                "num_frames": end - start,
+                "start_sample": None,
+                "num_samples": None,
+            }
+        )
+    return clipped
+
+
+def nested_shots(
+    shots, frame_offset, sample_offset, native_rate, target_rate, fps=None
+):
+    """An input's own shots, offset onto where the whole input landed in a join.
+
+    Frames are exact: a join only ever adds frames before an input, never
+    inside it, so `start_frame + frame_offset` is where each inner shot now
+    sits. Samples are only ever offset when the join measured where the
+    input's own track landed (`sample_offset`) and both rates are known -
+    resampling a partial waveform inside the crossfaded region is not a
+    measurement, so trimmed_shots already clears those before this runs.
+    Otherwise the sample side is cleared, same as without_samples.
+
+    A caller that knows the joined track's frame rate (`fps`) can have the
+    sample side *derived* from each shot's new frame position
+    (frames_to_samples) instead of rescaled from its own already-rounded
+    `start_sample` - the same choice #401 made for the top-level seam
+    position, because rescaling a stored value compounds whatever rounding
+    an earlier join already did, drifting a sample or two off what a later
+    pair_audio would measure for the same boundary (#405). concat_videos
+    does not pass `fps` here: its sample_offset is a measurement of the
+    real, unevenly-spaced crossfades it drew, not a multiple of a frame
+    rate, so deriving from frame position would disagree with the track it
+    actually built.
+    """
+    rescale = (
+        target_rate / native_rate
+        if sample_offset is not None and native_rate and target_rate
+        else None
+    )
+    derive = fps and target_rate and sample_offset is not None
+    offset = []
+    for shot in shots:
+        entry = {**shot, "start_frame": shot["start_frame"] + frame_offset}
+        start_sample = shot.get("start_sample")
+        if derive:
+            entry["start_sample"] = round(entry["start_frame"] / fps * target_rate)
+        elif rescale is not None and start_sample is not None:
+            entry["start_sample"] = sample_offset + round(start_sample * rescale)
+        else:
+            entry["start_sample"] = None
+            entry["num_samples"] = None
+        offset.append(entry)
+    return offset
+
+
+def measured_num_samples(shots, total_samples):
+    """Fill each shot's `num_samples` from where the next measured one starts.
+
+    A shot's track runs up to wherever the next shot with a known
+    `start_sample` begins, or to the end of the joined track for the last
+    one - shared by concat_videos and dissolve_videos so nesting an input's
+    shots (which can leave some entries with no `start_sample`) is handled
+    the same way in both.
+    """
+    for index, shot in enumerate(shots):
+        if total_samples is None or shot["start_sample"] is None:
+            shot["num_samples"] = None
+            if total_samples is None:
+                shot["start_sample"] = None
+            continue
+        end = total_samples
+        for following in shots[index + 1 :]:
+            if following["start_sample"] is not None:
+                end = following["start_sample"]
+                break
+        shot["num_samples"] = end - shot["start_sample"]
+    return shots
+
+
+def shot_reference_names(references):
+    """A name per entry of a step's list naming a shot, else None.
+
+    A step's `videos` argument is written as a list of `previous_result:`
+    references; by the time the task runs `gather:` has expanded into exactly
+    such a list, so the entry at position i names the video the join put at
+    position i. A reference to a `shot@` member keeps that name (the
+    for_each entry, not the field read off it); any other `previous_result:`
+    reference is named after the step it points at, so a shot generated by an
+    ordinary step (a `pair_audio`, a chain) is traceable in the manifest and
+    in a probe finding the same way (#396). Anything else (an `asset:` path,
+    a literal video) keeps the name the join gave it.
+    """
+    if not isinstance(references, list):
+        return None
+    names = []
+    for reference in references:
+        if isinstance(reference, str) and reference.startswith(SHOT_REFERENCE_PREFIX):
+            # `previous_result:shot@x.field` names the member, not the field
+            member = reference[len(PREVIOUS_RESULT_PREFIX) :]
+            names.append(member.split(".", 1)[0])
+        elif isinstance(reference, str) and reference.startswith(
+            PREVIOUS_RESULT_PREFIX
+        ):
+            # `previous_result:step.field` names the step, not the field
+            step = reference[len(PREVIOUS_RESULT_PREFIX) :]
+            names.append(step.split(".", 1)[0])
+        else:
+            names.append(None)
+    return names
+
+
+def named_shots(shots, names):
+    """The shots with each renamed where the step named its source input.
+
+    `names` is one name per input the join was given (`shot_reference_names`
+    over the step's `videos` argument); a flattened shot is matched to it by
+    the `source_index` the join stamped on it - not by position in `shots`,
+    which is a different length from `names` as soon as one input nests more
+    than one shot of its own (#432: the old positional zip then silently
+    skipped every rename past that input, since the length guard refused the
+    whole list rather than the one entry it could not place). Only an input
+    that contributed exactly one shot takes the override; one that nested
+    keeps the names its own inner shots already carry - renaming all of them
+    to the same one name would collide them. A shot with no `source_index` (a
+    flat list built by hand rather than by concat_videos/dissolve_videos, as
+    a for_each join's `gather:` result is) falls back to its position in
+    `shots`, which is exactly what `source_index` means for a list with no
+    nesting.
+    """
+    if not shots:
+        return shots
+    indices = [
+        shot["source_index"] if "source_index" in shot else position
+        for position, shot in enumerate(shots)
+    ]
+    counts = {}
+    for index in indices:
+        counts[index] = counts.get(index, 0) + 1
+    renamed = []
+    for shot, index in zip(shots, indices):
+        entry = {key: value for key, value in shot.items() if key != "source_index"}
+        name = names[index] if names and index < len(names) else None
+        if name and counts.get(index) == 1:
+            entry["name"] = name
+        renamed.append(entry)
+    return renamed
+
+
+def _rename_in_place(shots, names):
+    """Write the step-named `name`s back onto the shot dicts themselves, and
+    drop the transient `source_index` tag named_shots placed them by.
+
+    `Result.save` stores `saved_shots[path]` as the artifact's own `.shots`
+    list, not a copy (`self._artifacts_for` / `getattr(artifact, "shots")`),
+    and that same artifact is what a later `previous_result:` step reads
+    (`results[step.name]` holds it directly). Renaming only the manifest's
+    deep copy left that artifact carrying the join's `video N` fallback, so
+    a probe reading `previous_result:cut` still saw the unnamed shot even
+    after the manifest was fixed (#396 follow-up). Mutating here reaches
+    both.
+    """
+    for shot, named in zip(shots, named_shots(shots, names)):
+        shot["name"] = named["name"]
+        shot.pop("source_index", None)
+
+
+def step_shots(saved_shots, saved_files, references=None):
+    """The `shots` a step's manifest entry and step_end carry, or None.
+
+    `saved_shots` maps each file the step wrote to the shots its video
+    carried (`Result.saved_shots`). A step that wrote one file lists that
+    file's shots; one that wrote several marks each shot with the `file` it
+    belongs to, so no shot is ever read against the wrong file. `references`
+    is the step's `videos` argument as written, which names the shots.
+    """
+    if not saved_shots:
+        return None
+    names = shot_reference_names(references)
+    files = [path for path in saved_files or [] if path in saved_shots]
+    for path in files:
+        _rename_in_place(saved_shots[path], names)
+    if len(files) == 1 and len(saved_files) == 1:
+        return copy.deepcopy(saved_shots[files[0]])
+    return [
+        {**shot, "file": path}
+        for path in files
+        for shot in copy.deepcopy(saved_shots[path])
+    ]
+
+
+def shots_for_file(shots, path, step_files):
+    """The shots of one file out of a manifest entry's `shots`, or None.
+
+    `path` and `step_files` are as the manifest records them, so a
+    run-relative path matches a run-relative `file`.
+    """
+    if not shots:
+        return None
+    if any("file" in shot for shot in shots):
+        own = [
+            {key: value for key, value in shot.items() if key != "file"}
+            for shot in shots
+            if shot.get("file") == path
+        ]
+        return own or None
+    return shots if list(step_files or []) == [path] else None