inline-core 1.2.69__tar.gz → 1.2.70__tar.gz

{inline_core-1.2.69 → inline_core-1.2.70}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: inline-core
-Version: 1.2.69
+Version: 1.2.70
 Summary: The generation engine behind Inline Studio.
 License-Expression: GPL-3.0-or-later
 Requires-Python: >=3.11

{inline_core-1.2.69 → inline_core-1.2.70}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 # PyPI name; the import package is `inline_core` (src/inline_core).
 name = "inline-core"
-version = "1.2.69"
+version = "1.2.70"
 description = "The generation engine behind Inline Studio."
 readme = "README.md"
 license = "GPL-3.0-or-later"

{inline_core-1.2.69 → inline_core-1.2.70}/src/inline_core/graph/registry.py

@@ -10,7 +10,15 @@ from ..errors import UnknownNodeType
 from .descriptor import NodeDescriptor
 from .loader_runners import register_loaders
 from .primitives import register_primitives
-from .runners import IMAGE_INPUT, TEXT_INPUT, ImageInputRunner, NodeRunner, TextInputRunner
+from .runners import (
+    IMAGE_INPUT,
+    TEXT_INPUT,
+    VIDEO_INPUT,
+    ImageInputRunner,
+    NodeRunner,
+    TextInputRunner,
+    VideoInputRunner,
+)
 
 
 class Registry:
@@ -83,6 +91,7 @@ def build_default_registry() -> Registry:
     registry = Registry()
     registry.register(replace(TEXT_INPUT, hidden=True), TextInputRunner())
     registry.register(replace(IMAGE_INPUT, hidden=True), ImageInputRunner())
+    registry.register(replace(VIDEO_INPUT, hidden=True), VideoInputRunner())
     register_primitives(registry)
     register_loaders(registry)
     return registry

{inline_core-1.2.69 → inline_core-1.2.70}/src/inline_core/graph/runners.py

@@ -44,6 +44,13 @@ class ImageInputRunner(NodeRunner):
         return NodeResult(outputs={"image": _asset_ref(node.params.get("asset"))})
 
 
+class VideoInputRunner(NodeRunner):
+    produces_takes = False
+
+    def run(self, node: Node, inputs: dict[str, list[Any]], ctx: ExecutionContext) -> NodeResult:
+        return NodeResult(outputs={"video": _asset_ref(node.params.get("asset"))})
+
+
 def _asset_ref(raw: Any) -> AssetRef:
     if isinstance(raw, dict):
         ref = raw.get("ref")
@@ -70,3 +77,14 @@ IMAGE_INPUT = NodeDescriptor(
     outputs=(Port("image", "Image", PortKind.IMAGE),),
     icon="image",
 )
+
+#: The same frozen asset, typed as a clip. Needed because a wired video used to arrive as
+#: `input/image` whatever it actually held, so a video port refused it at validation: the reader saw
+#: "Cannot wire image into video" about a file that was already a video.
+VIDEO_INPUT = NodeDescriptor(
+    type="input/video",
+    title="Video",
+    category="Input",
+    outputs=(Port("video", "Video", PortKind.VIDEO),),
+    icon="film",
+)

{inline_core-1.2.69 → inline_core-1.2.70}/src/inline_core/models/ltx25/pipeline.py

@@ -69,8 +69,11 @@ def _require(path: Path | None, what: str) -> Path:
 
 
 def _wired(ref: Any) -> Path | None:
-    """A path handed in over a wired model port, if one was."""
-    value = getattr(ref, "path", None) if ref is not None else None
+    """The file a wired ``load/*`` node already resolved, if one is wired.
+
+    Its refs carry ``file``. Reading ``path`` matched nothing, so every wired model, VAE and text
+    encoder was silently ignored and the node fell back to the dropdown."""
+    value = getattr(ref, "file", None) if ref is not None else None
     return Path(str(value)) if value else None
 
 
@@ -168,7 +171,11 @@ def load_pipeline(
     plan = _plan(policy, paths, request.build)
 
     key = rt.PipelineKey(
-        arch="ltx-2-5",
+        # A reference render builds a different pipeline class with its own weight registry, so it
+        # cannot share a cached distilled one. That has to go in `arch` rather than `variant`:
+        # `evict_stale` keeps entries whose only difference is the variant, so putting it there left
+        # the old pipeline resident while the new one loaded on top and the card ran out at 44 GiB.
+        arch="ltx-2-5-ic" if request.reference else "ltx-2-5",
         diffusion=str(paths["transformer"]),
         vae=str(paths["video_vae"]),
         text_encoder=str(paths["text_encoder"]),
@@ -203,7 +210,14 @@ def load_pipeline(
         "quantization": memory.quantization_policy(plan, str(paths["transformer"])),
         "offload_mode": memory.offload_mode(plan),
     }
-    if request.mode == "quality":
+    if request.reference:
+        # A Control LoRA conditions on a reference clip, which the distilled pipeline cannot take.
+        # Upstream ships a separate one for it, built from the same arguments, that appends the
+        # reference as clean tokens the way the adapter was trained.
+        from .vendor.ltx_pipelines.ic_lora import ICLoraPipeline
+
+        pipe = ICLoraPipeline(**common)
+    elif request.mode == "quality":
         pipe = _quality_pipeline(common)
     else:
         from .vendor.ltx_pipelines.distilled import DistilledPipeline
@@ -265,12 +279,17 @@ def _quality_pipeline(common: dict[str, Any]) -> Any:
 
 def _lora(ref: Any) -> Any:
     """One of our `LoraRef`s as the vendored path, strength and key-rename triple."""
+    # The loader node hands over a path it already resolved under the models root, not a bare name.
+    # Re-resolving it as a name only looked right while that root was absolute, because an absolute
+    # right-hand side wins a join; under the default relative `./models` the prefix doubled.
+    # Checked before the vendored import so a missing file is reported without loading torch.
+    path = _wired(ref)
+    if path is None or not path.is_file():
+        raise ComponentError(f"{_LABEL} could not find the LoRA {getattr(ref, 'file', '')!r}.")
+
     from .vendor.ltx_core.loader import LoraPathStrengthAndSDOps
     from .vendor.ltx_core.loader.sd_ops import LTXV_LORA_COMFY_RENAMING_MAP
 
-    path = reqs.resolve("loras", str(getattr(ref, "file", "")))
-    if path is None:
-        raise ComponentError(f"{_LABEL} could not find the LoRA {getattr(ref, 'file', '')!r}.")
     # The rename map is not optional: published LTX adapters (and the ones the Trainer exports) key
     # on `diffusion_model.`, which this strips to reach the module names. Every upstream caller
     # passes it, including for the distilled LoRA.
@@ -319,7 +338,10 @@ def render(
         # The third element is the **frame count**, not a sample rate. The rate lives on the Audio
         # container as ``sampling_rate``, and taking the positional one wrote a WAV headed 49 Hz -
         # the video's frame count - which plays back forty minutes long and raises nothing.
-        frames_iter, audio, _num_frames, _tiling = pipe(**call)
+        # The IC-LoRA pipeline returns three values where the others return four: it takes an
+        # explicit `num_frames` and so has none to report back.
+        result = pipe(**call)
+        frames_iter, audio = result[0], result[1]
         for chunk in frames_iter:
             if cancel_check is not None:
                 cancel_check()

{inline_core-1.2.69 → inline_core-1.2.70}/src/inline_core/models/ltx25/runner.py

@@ -132,6 +132,11 @@ def _inputs(variant: Variant) -> tuple[Port, ...]:
         ports.append(Port("image", "First frame", PortKind.IMAGE, required=False))
     if variant.last_frame:
         ports.append(Port("last_image", "Last frame", PortKind.IMAGE, required=False))
+    # An IC-LoRA (Control LoRA) learns a transform from a reference clip, so it needs one at
+    # generation time too. Present on every variant: the reference is orthogonal to keyframes.
+    ports.append(
+        Port("reference", "Reference clip (Control LoRA)", PortKind.VIDEO, required=False)
+    )
     return tuple(ports)
 
 
@@ -183,6 +188,9 @@ class Request:
     generate_audio: bool
     enhance_prompt: bool
     conditionings: tuple[Conditioning, ...] = ()
+    #: A reference clip for a Control LoRA, as a local path. Upstream reads the file itself rather
+    #: than taking pixels, so this stays a path all the way down.
+    reference: str | None = None
 
     @property
     def seconds(self) -> float:
@@ -223,6 +231,7 @@ def build_request(
     if variant.first_frame and not conditionings:
         raise ComponentError(f"{variant.title} needs an image wired to its First frame input.")
 
+    reference = rt.first(inputs.get("reference"))
     return Request(
         prompt=prompt,
         num_frames=frames,
@@ -238,6 +247,7 @@ def build_request(
         mode=mode,
         generate_audio=bool(params.get("generate_audio", True)),
         enhance_prompt=bool(params.get("enhance_prompt", False)),
+        reference=rt.media_path(reference, "Reference clip") if reference else None,
         conditionings=tuple(conditionings),
     )
 
@@ -268,7 +278,7 @@ def call_kwargs(request: Request, scratch: Path, label: str = _LABEL) -> dict[st
     """
     from .vendor.ltx_pipelines.utils.args import ImageConditioningInput
 
-    return {
+    args: dict[str, Any] = {
         "prompt": request.prompt,
         "seed": request.seed,
         "height": request.height,
@@ -285,6 +295,12 @@ def call_kwargs(request: Request, scratch: Path, label: str = _LABEL) -> dict[st
             for c in request.conditionings
         ],
     }
+    if request.reference:
+        # Only the IC-LoRA pipeline takes this, and it is the pipeline `load_pipeline` picks when a
+        # reference is wired. Strength 1.0 keeps the reference tokens clean, which is how the
+        # adapter saw them in training.
+        args["video_conditioning"] = [(request.reference, 1.0)]
+    return args
 
 
 # --- the runner ----------------------------------------------------------------------------------

{inline_core-1.2.69 → inline_core-1.2.70}/src/inline_core/models/pipeline_runtime.py

@@ -624,6 +624,20 @@ def load_image(ref: Any, label: str) -> Any:
     raise ComponentError(f"{label} needs a readable image input.")
 
 
+def media_path(ref: Any, label: str) -> str:
+    """A wired clip as a local path, for a pipeline that opens the file itself.
+
+    Deliberately not `load_image`'s shape: upstream's IC-LoRA conditioning takes `(path, strength)`
+    and does its own decode and resize, so handing it decoded pixels would mean decoding twice and
+    guessing at the resize it wants.
+    """
+    if isinstance(ref, AssetRef) and ref.ref == "path" and ref.path:
+        return str(ref.path)
+    if isinstance(ref, Take) and ref.uri:
+        return ref.uri.removeprefix("file://")
+    raise ComponentError(f"{label} needs a readable video input.")
+
+
 def first(values: list[Any] | None) -> Any:
     return values[0] if values else None
 

{inline_core-1.2.69 → inline_core-1.2.70}/src/inline_core/studio/graph_build.py

@@ -23,16 +23,36 @@ from . import frames as fr
 from . import moodboard as mb
 
 
-def _source_output_port(source: dict[str, Any] | None, source_handle: str | None) -> str:
+def _source_output_port(
+    source: dict[str, Any] | None,
+    source_handle: str | None,
+    source_path: Callable[[dict[str, Any]], str | None] | None = None,
+) -> str:
     if source and source["type"] == "prompt":
         return "text"
-    # An asset, a rendered frame, a Load Assets loader, or a Control Space render all become an
-    # ``input/image`` source node.
+    # An asset, a rendered frame, a Load Assets loader, or a Control Space render all become a
+    # frozen source node, image or video according to what the file actually is. The port id has to
+    # match the node `_item_to_node` emits, or the edge names an output that does not exist.
     if source and source["type"] in ("asset", "frame", "loader", "controlSpace"):
-        return "image"
+        path = source_path(source) if source_path else None
+        return "video" if path and _source_type(path) == "input/video" else "image"
     return source_handle or "out"  # a 'core' item's handles already are Core port ids
 
 
+#: Suffixes the video source node claims. Everything else stays an image, which is what the image
+#: ports and the list ports expect.
+_VIDEO_SUFFIXES = (".mp4", ".mov", ".webm", ".mkv", ".avi")
+
+
+def _source_type(path: str) -> str:
+    """`input/video` for a clip, `input/image` otherwise.
+
+    Every asset used to arrive as `input/image` whatever it held, so wiring a clip into a video port
+    failed validation with "Cannot wire image into video" about a file that was already a video.
+    """
+    return "input/video" if Path(path).suffix.lower() in _VIDEO_SUFFIXES else "input/image"
+
+
 def _loader_assets(item: dict[str, Any] | None) -> list[str]:
     """The asset ids a Load Assets node holds, in the order the user arranged them."""
     if item is None or item.get("type") != "loader":
@@ -51,6 +71,7 @@ def _edges_for(
     by_id: dict[str, dict[str, Any]],
     is_list_port: Callable[[str, str], bool],
     fanned_out: dict[str, int],
+    source_path: Callable[[dict[str, Any]], str | None] | None = None,
 ) -> dict[str, list[dict[str, str]]]:
     """This node's input edges, keyed by target port.
 
@@ -73,7 +94,7 @@ def _edges_for(
         handle = data.get("targetHandle") or "in"
         source_id = c["fromItemId"]
         source = by_id.get(source_id)
-        output = _source_output_port(source, data.get("sourceHandle"))
+        output = _source_output_port(source, data.get("sourceHandle"), source_path)
         listed = bool(target_type) and is_list_port(target_type, handle)
 
         assets = _loader_assets(source) if listed else []
@@ -119,7 +140,7 @@ def _item_to_node(
             return None
         return {
             "id": item["id"],
-            "type": "input/image",
+            "type": _source_type(path),
             "params": {"asset": {"ref": "path", "path": path}},
         }
     # A Load Assets loader feeds its hero (first) asset as a frozen image source. Wired into a list
@@ -133,7 +154,7 @@ def _item_to_node(
             return None
         return {
             "id": item["id"],
-            "type": "input/image",
+            "type": _source_type(path),
             "params": {"asset": {"ref": "path", "path": path}},
         }
     # A Control Space node feeds its rendered OpenPose control map (a library asset) as a frozen
@@ -145,7 +166,7 @@ def _item_to_node(
             return None
         return {
             "id": item["id"],
-            "type": "input/image",
+            "type": _source_type(path),
             "params": {"asset": {"ref": "path", "path": path}},
         }
     # A rendered frame wired into a Core node feeds its output image as a frozen source (its hero
@@ -156,7 +177,7 @@ def _item_to_node(
             return None
         return {
             "id": item["id"],
-            "type": "input/image",
+            "type": _source_type(path),
             "params": {"asset": {"ref": "path", "path": path}},
         }
     return None
@@ -272,13 +293,27 @@ def build_workflow_graph(
         out = fr.resolve_frame_file(conn, frame_id)
         return str(folder / out["filePath"]) if out else None
 
+    def source_path(source: dict[str, Any]) -> str | None:
+        """The file behind a source item, so its node and its edge type themselves the same way."""
+        data = source.get("data") or {}
+        if source["type"] == "asset" and source.get("assetId"):
+            return resolve_asset_path(source["assetId"])
+        if source["type"] == "frame" and source.get("frameId"):
+            return resolve_frame_path(source["frameId"])
+        if source["type"] == "loader":
+            ids = data.get("assetIds") or []
+            return resolve_asset_path(ids[0]) if ids else None
+        if source["type"] == "controlSpace" and data.get("controlAssetId"):
+            return resolve_asset_path(data["controlAssetId"])
+        return None
+
     listed = is_list_port or (lambda _type, _port: False)
     closure = sorted(_upstream_closure(target_item_id, connectors))
     # Two passes: the edges decide which loaders fan out, so they must be resolved before the node
     # pass can know whether to emit one source per loader or one per asset.
     fanned_out: dict[str, int] = {}
     edges_by_node = {
-        node_id: _edges_for(node_id, connectors, by_id, listed, fanned_out)
+        node_id: _edges_for(node_id, connectors, by_id, listed, fanned_out, source_path)
         for node_id in closure
         if (by_id.get(node_id) or {}).get("type") == "core"
     }
@@ -296,10 +331,25 @@ def build_workflow_graph(
                 node["inputs"] = edges_by_node[node_id]
             nodes.append(node)
         nodes.extend(_fanned_out_sources(item, fanned_out, resolve_asset_path))
+    _prune_dangling_edges(nodes)
     _apply_facing_hints(nodes, by_id)
     return {"schemaVersion": 1, "nodes": nodes}, target_item_id
 
 
+def _prune_dangling_edges(nodes: list[dict[str, Any]]) -> None:
+    """Drop edges naming a source that produced no node - an asset that does not resolve in this
+    project (a board imported from another one, a deleted file). Those sources are skipped rather
+    than failing the run, so the edges have to go with them: left in, validation reports a bare
+    canvas id, where dropping them reports the port that is now unwired."""
+    ids = {n["id"] for n in nodes}
+    for node in nodes:
+        inputs: dict[str, list[dict[str, str]]] = node.get("inputs") or {}
+        if not inputs:
+            continue
+        kept = {port: [e for e in edges if e["from"] in ids] for port, edges in inputs.items()}
+        node["inputs"] = {port: edges for port, edges in kept.items() if edges}
+
+
 def _fanned_out_sources(
     item: dict[str, Any],
     fanned_out: dict[str, int],

inline_core-1.2.70/tests/test_ltx25_wired_refs.py

@@ -0,0 +1,55 @@
+"""What a wired ``load/*`` node hands the LTX node, and how the node reads it back.
+
+Both of these shipped broken past a green suite, and neither raised where it went wrong: the LoRA
+one only failed once the models root was relative, and the component one failed silently.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from inline_core.errors import ComponentError
+from inline_core.graph.loader_runners import ComponentRef, LoraRef
+from inline_core.models.ltx25 import pipeline
+
+
+def test_a_wired_component_is_read_off_the_field_the_loader_actually_sets(tmp_path: Path) -> None:
+    """`ComponentRef` carries `file`. Reading `path` matched nothing, so a wired transformer, VAE
+    or text encoder was silently dropped and the run used the dropdown instead."""
+    weights = tmp_path / "custom-transformer.safetensors"
+    weights.write_bytes(b"")
+    ref = ComponentRef(kind="diffusion", arch="ltx-2-5", file=str(weights))
+
+    assert pipeline._wired(ref) == weights
+
+
+def test_an_unwired_port_resolves_to_nothing() -> None:
+    assert pipeline._wired(None) is None
+
+
+def test_a_lora_is_taken_at_the_path_the_loader_resolved(tmp_path: Path, monkeypatch) -> None:
+    """The models root is relative by default (`./models`), which is what exposed this: the ref's
+    path was re-joined under `models/loras/`, so `models/loras/x.safetensors` was looked for at
+    `models/loras/models/loras/x.safetensors`. An absolute root had hidden it, because an absolute
+    right-hand side wins a join."""
+    pytest.importorskip("torch")
+    monkeypatch.chdir(tmp_path)
+    loras = tmp_path / "models" / "loras"
+    loras.mkdir(parents=True)
+    adapter = loras / "motion-8afbbc83.safetensors"
+    adapter.write_bytes(b"")
+    monkeypatch.setenv("INLINE_MODELS_DIR", "models")
+
+    # Exactly what LoadLoraRunner emits under a relative root.
+    emitted = LoraRef(file="models/loras/motion-8afbbc83.safetensors", strength=0.8)
+    resolved = pipeline._lora(emitted)
+
+    assert Path(resolved.path) == Path("models/loras/motion-8afbbc83.safetensors")
+    assert resolved.strength == pytest.approx(0.8)
+
+
+def test_a_lora_that_is_not_there_names_itself_in_the_error() -> None:
+    with pytest.raises(ComponentError, match="ghost.safetensors"):
+        pipeline._lora(LoraRef(file="models/loras/ghost.safetensors", strength=1.0))

{inline_core-1.2.69 → inline_core-1.2.70}/tests/test_studio_graph_build.py

@@ -109,3 +109,53 @@ def test_an_unresolvable_control_map_adds_nothing(conn) -> None:
     nodes = _nodes(conn, gen_id)
     assert nodes[gen_id]["inputs"]["prompt"][0]["from"] == prompt_id
     assert not nodes[gen_id]["params"].get("negative_prompt")
+
+
+def test_an_asset_this_project_does_not_have_takes_its_edge_with_it(conn) -> None:
+    """A board exported from one project and imported into another carries asset ids the new project
+    has never seen. The source node is skipped, and the edge naming it has to go too - left in, the
+    run failed validation with a bare canvas id ("No node with id '6e29da67...'")."""
+    loader = mb.add_loader(conn, 0, 0)
+    mb.update_item(conn, loader["id"], {"data": {"assetIds": ["from-another-project"]}})
+    gen = mb.add_core_node(conn, "alibaba/z-image-turbo", 0, 0)
+    mb.create_connector(conn, loader["id"], gen["id"], "image", "image")
+
+    nodes = _nodes(conn, gen["id"])
+    assert loader["id"] not in nodes
+    assert "image" not in nodes[gen["id"]]["inputs"]
+
+
+def test_one_unresolvable_asset_does_not_dangle_the_rest_of_a_fanned_out_loader(conn) -> None:
+    """A Load Assets node on a list port emits one source per asset and skips the ones that do not
+    resolve, so the numbered edges have to be pruned to match or the run dies on the gap."""
+    loader = mb.add_loader(conn, 0, 0)
+    mb.update_item(conn, loader["id"], {"data": {"assetIds": ["a1", "gone", "a1"]}})
+    gen = mb.add_core_node(conn, "black-forest-labs/flux-2", 0, 0)
+    mb.create_connector(conn, loader["id"], gen["id"], "image", "images")
+
+    graph, _ = build_workflow_graph(
+        conn, Path("/tmp"), gen["id"], lambda _type, port: port == "images"
+    )
+    nodes = {n["id"]: n for n in graph["nodes"]}
+    edges = nodes[gen["id"]]["inputs"]["images"]
+    assert [e["from"] for e in edges] == [n["id"] for n in graph["nodes"] if "::ref" in n["id"]]
+
+
+def test_a_wired_clip_becomes_a_video_source_not_an_image_one(conn) -> None:
+    """Every asset became `input/image` whatever it held, so wiring a clip into a video port failed
+    validation with "Cannot wire image into video" about a file that was already a video.
+
+    The node's type and its edge's output port are asserted together. They are one contract: typing
+    the node alone would leave the edge naming a port the node does not have.
+    """
+    conn.execute(
+        "INSERT INTO assets (id, project_id, name, file_path, kind, created_at) "
+        "VALUES ('v1', 'p', 'ref', 'assets/ref.mp4', 'video', 0)"
+    )
+    clip = mb.add_asset(conn, "v1", 0, 0)
+    gen = mb.add_core_node(conn, "lightricks/ltx-2-5-text-to-video", 0, 0)
+    mb.create_connector(conn, clip["id"], gen["id"], "image", "reference")
+
+    nodes = _nodes(conn, gen["id"])
+    assert nodes[clip["id"]]["type"] == "input/video"
+    assert nodes[gen["id"]]["inputs"]["reference"][0]["output"] == "video"