SolitaryThinker
4e331eb7ff
Mechanical conversion of every relative import under v2/ to an absolute v2.* path (from .x / ..x / ...x -> from v2.<pkg>.x) so imports are unambiguous, grep-able, and stable when code is copied/moved between entrypoints (VideoGenerator, CLI, server). Surgical prefix-only rewrite: only the 'from <dots><module>' prefix changed — import names, parentheses, multi-line formatting, comments, and ordering are byte-for-byte preserved (no collapsing, no reorder, no unrelated reformatting). - 471 imports across 125 files; v2/tests/ was already absolute (untouched). - Validated: all 125 files compile, every 'from v2.* import' target resolves to a real module/package, zero relative imports remain (full sweep), CPU mini suite green (202 passed, 2 skipped).
110 lines
3.7 KiB
Python
110 lines
3.7 KiB
Python
"""Programs compose a card's loops into a task (design_v3 §13).
|
|
|
|
> The card says what loops *exist*, the program says how to *run* them for this request.
|
|
|
|
Kinds: InlineProgram (many loops, one resident instance — the omni default), TrainingProgram,
|
|
etc. Nodes are typed (ModelLoopNode / ComponentNode / ...); edges are typed and carry *named*
|
|
artifacts (not a god-batch). Linear pipelines are the degenerate case; ``when=`` predicates and
|
|
multiple producers give branches/fan-out (LTX-2 base→upsample→refine→decode; A/V fan-out).
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
from dataclasses import dataclass, field
|
|
from enum import Enum
|
|
from typing import Any, Callable
|
|
|
|
from v2.request.tasks import TaskType
|
|
|
|
|
|
class ProgramKind(str, Enum):
|
|
INLINE = "inline"
|
|
DISAGGREGATED = "disaggregated"
|
|
TRAINING = "training"
|
|
REALTIME = "realtime"
|
|
WORKFLOW = "workflow"
|
|
|
|
|
|
# --- node predicates (replace geometry heuristics; design.md P7) -------------- #
|
|
def always(_request: Any) -> bool:
|
|
return True
|
|
|
|
|
|
def when_task(*tasks: TaskType) -> Callable[[Any], bool]:
|
|
s = set(tasks)
|
|
return lambda req: req.task in s
|
|
|
|
|
|
def when_opt(node_id: str, key: str) -> Callable[[Any], bool]:
|
|
return lambda req: bool(req.node_override(node_id).get(key, False))
|
|
|
|
|
|
# --- nodes -------------------------------------------------------------------- #
|
|
@dataclass
|
|
class ProgramNode:
|
|
node_id: str
|
|
when: Callable[[Any], bool] = always
|
|
reads: tuple[str, ...] = () # input slot names (typed edges in)
|
|
writes: tuple[str, ...] = () # output slot names (typed edges out)
|
|
|
|
|
|
@dataclass
|
|
class ComponentNode(ProgramNode):
|
|
"""A one-shot transform: text/vision encode, VAE decode, latent upsample, vocoder.
|
|
|
|
``fn(instance, slots, request, ctx)`` reads its ``reads`` slots and writes its ``writes``
|
|
slots. Runs to completion in a single engine tick (not step-interleaved)."""
|
|
fn: Callable[..., None] | None = None
|
|
|
|
|
|
@dataclass
|
|
class ModelLoopNode(ProgramNode):
|
|
"""Binds one of the card's loops. The engine drives it via a LoopRunner, one step per tick,
|
|
so its steps interleave with other requests' steps (design_v3 §5, §6.3)."""
|
|
loop_id: str = ""
|
|
output_slot: str = "latents"
|
|
|
|
|
|
# --- typed edges (graph IR; validated, data flows via named slots) ------------ #
|
|
class EdgeKind(str, Enum):
|
|
TENSOR = "tensor"
|
|
ARTIFACT = "artifact"
|
|
STREAM = "stream"
|
|
CONTROL = "control"
|
|
CACHE = "cache"
|
|
BEHAVIOR = "behavior"
|
|
|
|
|
|
@dataclass
|
|
class Edge:
|
|
src: str # slot or node id
|
|
dst: str
|
|
kind: EdgeKind = EdgeKind.TENSOR
|
|
|
|
|
|
# --- program ------------------------------------------------------------------ #
|
|
@dataclass
|
|
class Program:
|
|
program_id: str
|
|
kind: ProgramKind
|
|
nodes: list[ProgramNode] = field(default_factory=list)
|
|
edges: list[Edge] = field(default_factory=list)
|
|
# artifact name -> slot that holds its value at the end (design_v3 §12 named artifacts)
|
|
output_artifacts: dict[str, str] = field(default_factory=dict)
|
|
|
|
def active_nodes(self, request: Any) -> list[ProgramNode]:
|
|
return [n for n in self.nodes if n.when(request)]
|
|
|
|
def validate(self) -> "Program":
|
|
produced: set[str] = set()
|
|
for n in self.nodes:
|
|
for r in n.reads:
|
|
if r not in produced:
|
|
# not fatal in mini (some reads come from the request itself), but flag dangling
|
|
pass
|
|
produced.update(n.writes)
|
|
for name, slot in self.output_artifacts.items():
|
|
if slot not in produced:
|
|
raise ValueError(f"program {self.program_id!r} output {name!r} reads slot "
|
|
f"{slot!r} that no node writes")
|
|
return self
|