salpa-cli 0.1.2__py3-none-any.whl

bocoflow_cli/templates/individual-node/README.md

@@ -0,0 +1,37 @@
+# {{DISPLAY_NAME}} (BoCoFlow node)
+
+{{DESCRIPTION}} Wraps [<tool>](<url>) (<license>).
+
+## What it does
+
+One or two sentences: what goes in, what comes out, and why it matters. Say
+where this sits in a pipeline — what normally runs before it and after it.
+
+## Inputs
+
+- **Input (one record per line)** — paste records directly, **or**
+- **Input File** — a file with one record per line, **or**
+- records carried from a predecessor node under `data["processed"]` (chainable).
+
+## Parameters
+
+| Option | Default | Meaning |
+|--------|---------|---------|
+| ... | ... | ... |
+
+## Output
+
+- `data["processed"]` — the processed records (forwarded to the next node)
+- `data["n_in"]` / `data["n_out"]` — record counts
+- `output.txt` in the output directory
+
+## Deployment
+
+**Local (PIXI_SUBPROCESS)** — CPU-only. Deps: list them, and say which channel
+(conda-forge / bioconda) or that they are pip-only.
+
+## Status
+
+Say plainly what has and has not been verified — e.g. "`pixi install` +
+`pixi run test` green; node.py wiring confirmed by running the node on a
+canvas in Salpa." A reader needs to know what they can trust.

bocoflow_cli/templates/individual-node/_TEMPLATE_USAGE.md

@@ -0,0 +1,73 @@
+# individual-node — template usage
+
+A single node with its own pixi environment. The default starting point. For
+several related nodes sharing one environment, use `multi-node-package/`.
+
+> This file is removed by the scaffolder — it never lands in a generated package.
+> `README.md` is the *node's* README (the registry serves it), so write that one
+> for the people who will use your node.
+
+## Scaffold it
+
+```bash
+salpa new my-analyzer
+```
+
+Creates `my_analyzer/` — **underscores**, because the directory name becomes the
+Python package name, so a hyphen would break `from .core import ...`. Meanwhile
+`[package].name` inside `meta.toml` stays **kebab-case** (`my-analyzer`). Both
+spellings are correct; they are different things.
+
+## Placeholders
+
+| Placeholder | Example |
+|---|---|
+| `{{PACKAGE_NAME}}` | `my-analyzer` (kebab — goes in meta.toml) |
+| `{{CLASS_NAME}}` | `MyAnalyzer` (PascalCase — must match `meta.toml` `class_name`) |
+| `{{DISPLAY_NAME}}` | `My Analyzer` |
+| `{{DESCRIPTION}}` | `Analyzes trajectory files` |
+| `{{AUTHOR}}` | your name or organization |
+| `{{CATEGORY}}` | `Cheminformatics`, `MD Analysis`, `Structure Prep`, ... |
+| `{{HASHTAGS}}` | discovery hashtags, quoted+comma-joined (aim for 5-10) |
+
+## The two-level split — the thing to understand
+
+| File | Imports `bocoflow_core`? | Importable by `pixi run test`? |
+|---|---|---|
+| `core.py` | **no** — pure Python | **yes** — this is what your tests validate |
+| `node.py` | yes | **no** — the runtime provides `bocoflow_core` |
+
+`bocoflow_core` is supplied by the Salpa runtime and is deliberately not a pixi
+dependency, so `pixi run test` can only exercise `core.py`. Put the science in
+`core.py`; keep `node.py` a thin wrapper. Validate `node.py` by loading the node
+into Salpa and running it on a canvas.
+
+This is why `tests/test_node.py` guards the node import per-test rather than with a
+module-level skip — a module-level skip would skip the pure core tests too, and
+`pixi run test` would exit 0 having validated nothing.
+
+## Then
+
+```bash
+cd my_analyzer
+pixi install          # first real test of your pixi.toml
+pixi run test         # runs the core tests; node tests skip (expected)
+```
+
+Declare only the platforms your dependencies actually build for — pixi solves
+**all** declared platforms, so an over-declared `win-64` fails the solve for a dep
+that has no Windows build.
+
+Then load the node into Salpa (node library → Import, Local Source) and run it.
+See `salpa docs testing-and-loading-your-node`.
+
+## Checklist
+
+- [ ] `meta.toml` `class_name` matches the class in `node.py`
+- [ ] `[package].license` is set to the real license of the tool you wrap
+      (a missing license means the node silently never registers)
+- [ ] 5-10 specific hashtags
+- [ ] `pixi install` solves; `pixi run test` reports **passed** core tests, not
+      "all skipped"
+- [ ] `stream_log(..., node_id=self.node_id, progress=N)` at 0 and 100
+- [ ] the node runs on a real canvas

bocoflow_cli/templates/individual-node/core.py

@@ -0,0 +1,49 @@
+"""Pure-Python core for {{PACKAGE_NAME}}.
+
+The science lives here; node.py is a thin BoCoFlow wrapper around it. Keeping
+the two apart is what makes this file unit-testable on its own: a bare pixi env
+can import core.py but NOT node.py (node.py needs bocoflow_core, which the
+runtime provides and is deliberately not a pixi dependency).
+
+No BoCoFlow imports here — pure Python, unit-testable standalone.
+
+Heavy dependencies (rdkit, MDAnalysis, ...) should be imported INSIDE the
+function that needs them, not at module scope, so the pure helpers below stay
+importable even when the heavy dep is missing.
+"""
+
+from __future__ import annotations
+
+from typing import Dict, List
+
+
+def read_records(text: str = "", file_path: str = "") -> List[str]:
+    """Collect input records from a text block (one per line) and/or a file.
+
+    Note: file reads pass encoding="utf-8" — bare open()/read_text() default to
+    cp1252 on Windows and silently corrupt non-ASCII.
+    """
+    records: List[str] = []
+    if text:
+        records += [ln.strip() for ln in text.splitlines() if ln.strip()]
+    if file_path:
+        with open(file_path, encoding="utf-8") as fh:
+            records += [ln.strip() for ln in fh if ln.strip()]
+    return records
+
+
+def process(records: List[str]) -> Dict:
+    """TODO: replace this with your real computation.
+
+    The default implementation is a placeholder that simply reports what it was
+    given, so the template runs green out of the box. Return a plain dict — the
+    node wrapper is responsible for turning it into a NodeResult.
+    """
+    # --- Replace from here ------------------------------------------------
+    processed = [r.upper() for r in records]
+    # --- to here ----------------------------------------------------------
+    return {
+        "processed": processed,
+        "n_in": len(records),
+        "n_out": len(processed),
+    }

bocoflow_cli/templates/individual-node/meta.toml

@@ -0,0 +1,48 @@
+# Node package metadata — the registry reads THIS file to discover your node.
+# Replace every double-brace placeholder below.
+#
+# Guide: https://salpa.app/docs/custom-nodes  (also bundled — run `salpa docs`)
+
+[package]
+# kebab-case, globally unique (the registry keys on it and collisions silently
+# overwrite). The DIRECTORY uses underscores. Keep this line comment-free — some
+# tooling parses it literally.
+name = "{{PACKAGE_NAME}}"
+version = "0.1.0"
+description = "{{DESCRIPTION}}"
+author = "{{AUTHOR}}"
+license = "MIT"                    # REQUIRED — a node with no license is skipped at
+                                   # load time and silently never appears in the
+                                   # palette. Set the real license of the tool you wrap.
+bocoflow_core_version = ">=2.0.0"
+
+[node]
+class_name = "{{CLASS_NAME}}"      # REQUIRED — must match the class in node.py exactly
+display_name = "{{DISPLAY_NAME}}"  # REQUIRED — shown in the UI
+num_in = 1                         # input ports (use 0 for a source node)
+num_out = 1                        # output ports
+category = "{{CATEGORY}}"          # e.g. "Cheminformatics", "MD Analysis", "Structure Prep"
+
+# Hashtags drive discovery — use 5-10, lowercase-with-hyphens, and be specific
+# ("gromacs-mdrun", not "simulation"). Cover: what it does, the tool it wraps,
+# the scientific domain, and the input/output types.
+hashtags = [{{HASHTAGS}}]
+
+[node.metadata]
+icon = "📦"                        # an emoji — real packages use emoji, not SVG
+tooltip = "{{DESCRIPTION}}"        # short behavioural one-liner; keep it distinct
+                                   # from description, e.g. "SMILES → protonation
+                                   # states at a pH window (1→N protomers)"
+
+[node.features]
+supports_resume = false
+requires_gpu = false
+parallel_capable = false
+long_running = false               # affects UI behaviour for slow nodes
+# default_timeout = 3600           # seconds; omit for the default
+
+[dependencies]
+python = ">=3.10"                  # Runtime deps belong in pixi.toml, NOT here.
+
+[documentation]
+readme = "README.md"

bocoflow_cli/templates/individual-node/node.py

@@ -0,0 +1,136 @@
+"""{{PACKAGE_NAME}} — {{DESCRIPTION}}
+
+BoCoFlow node wrapper. The computation itself lives in core.py; this file only
+handles BoCoFlow I/O — reading parameters, resolving paths, streaming progress,
+and shaping the NodeResult.
+"""
+
+import os
+
+from bocoflow_core.node import Node, NodeException, NodeResult
+from bocoflow_core.parameters import (
+    FileParameterEdit,
+    FolderParameter,
+    TextParameter,
+    # Also available: StringParameter, IntegerParameter, FloatParameter,
+    # BooleanParameter, SelectParameter
+)
+from bocoflow_core.stream_logger import stream_log
+
+# Standard 3-stage import. Do not replace this with a plain `from .core import` —
+# each stage covers a real context, and stage 3 is what lets the SERVER import
+# node.py (to read OPTIONS for the UI) without your heavy deps installed.
+try:
+    from .core import process, read_records          # package context (pytest/direct)
+except ImportError:
+    try:
+        from core import process, read_records        # node_runner injects node_dir on path
+    except ImportError:
+        process = read_records = None                 # server env: heavy deps absent
+
+
+def _merge_predecessors(predecessor_data):
+    """Flatten upstream node `data` dicts into one carry-forward dict."""
+    merged = {}
+    for pred in (predecessor_data or []):
+        if not isinstance(pred, dict):
+            continue
+        scope = pred.get("data") if isinstance(pred.get("data"), dict) else pred
+        for k, v in scope.items():
+            if k not in ("success", "message", "metadata", "files"):
+                merged[k] = v
+    return merged
+
+
+class {{CLASS_NAME}}(Node):
+    """{{DESCRIPTION}}"""
+
+    # Mirrors meta.toml. The registry reads meta.toml; these attributes are the
+    # in-code fallback and keep node.py readable on its own.
+    category = "{{CATEGORY}}"
+    tags = [{{HASHTAGS}}]
+
+    # NOTE: do NOT add force_to_run — it is inherited from Node.BASE_OPTIONS.
+    OPTIONS = {
+        "text_input": TextParameter(
+            "Input (one record per line)", default="",
+            docstring="Records to process, one per line. Leave empty to use an "
+                      "input file or data carried from a predecessor node.",
+        ),
+        "input_file": FileParameterEdit(
+            "Input File (optional)",
+            docstring="Optional input file, one record per line.",
+        ),
+        "output_dir": FolderParameter(
+            "Output Directory",
+            docstring="Directory where output files will be written.",
+        ),
+        # --- Add your node-specific parameters below ---
+    }
+
+    def execute(self, predecessor_data, flow_vars):
+        """Run the node.
+
+        Args:
+            predecessor_data: list of result dicts from upstream nodes (or None).
+            flow_vars: dict of parameter name -> Parameter. Read with .get_value().
+
+        Returns:
+            str: JSON from NodeResult.to_json()
+        """
+        stream_log("Starting {{CLASS_NAME}}...", node_id=self.node_id, progress=0)
+        try:
+            # Stage-3 import landed (see above) — the real deps are missing.
+            if process is None:
+                raise NodeException(
+                    "setup",
+                    "core.py could not be imported. Check that this node's pixi "
+                    "environment installed its dependencies (`pixi install`).",
+                )
+
+            carried = _merge_predecessors(predecessor_data)
+            result = NodeResult()
+
+            text = flow_vars["text_input"].get_value() or ""
+            file_val = flow_vars["input_file"].get_value()
+            file_path = self.resolve_path(file_val) if file_val else ""
+
+            records = read_records(text, file_path)
+            # Fall back to records carried from an upstream node.
+            if not records and carried.get("processed"):
+                upstream = carried["processed"]
+                records = upstream if isinstance(upstream, list) else [upstream]
+            if not records:
+                raise NodeException(
+                    "input",
+                    "No input provided (via text, file, or a predecessor node).",
+                )
+
+            stream_log(
+                f"Processing {len(records)} record(s)...",
+                node_id=self.node_id, progress=40,
+            )
+            out = process(records)
+
+            out_dir = self.resolve_path(flow_vars["output_dir"].get_value())
+            os.makedirs(out_dir, exist_ok=True)
+            out_file = os.path.join(out_dir, "output.txt")
+            with open(out_file, "w", encoding="utf-8") as fh:
+                for record in out["processed"]:
+                    fh.write(f"{record}\n")
+
+            result.data = {
+                **carried,                 # carry upstream keys forward
+                **out,                     # this node's own outputs
+                "output_file": self.format_output_path(out_file),
+            }
+            result.files["output"] = {"output_file": result.data["output_file"]}
+            result.success = True
+            result.message = f"{out['n_in']} record(s) in → {out['n_out']} out"
+            stream_log(result.message, node_id=self.node_id, progress=100)
+            return result.to_json()
+
+        except NodeException:
+            raise                          # keep the original stage tag
+        except Exception as e:
+            raise NodeException("execution", str(e))

bocoflow_cli/templates/individual-node/pixi.toml

@@ -0,0 +1,44 @@
+# Pixi Environment Definition
+# This file defines the isolated environment for this node
+# See: https://pixi.sh/
+
+[workspace]
+name = "{{PACKAGE_NAME}}"
+version = "0.1.0"
+description = "{{DESCRIPTION}}"
+channels = ["conda-forge"]
+# Declare ONLY platforms your deps actually build for (pixi solves ALL of them).
+# Many bioconda / specialized packages lack win-64 (and sometimes osx-arm64) — trim as needed.
+platforms = ["linux-64", "osx-64", "osx-arm64", "win-64"]
+
+[dependencies]
+# Core Python requirement
+python = ">=3.10,<3.13"
+
+# Redis client for real-time log streaming from subprocess to UI.
+# Keeps stream_log() calls in your node appearing in the UI immediately.
+redis-py = ">=5.0.0"
+
+# pytest MUST be in the default env (not just [feature.dev]) so `pixi run test` works
+pytest = ">=7.0"
+
+# Add your conda-forge dependencies here
+# Examples:
+# numpy = ">=1.24"
+# pandas = ">=2.0"
+# scipy = ">=1.10"
+# matplotlib = ">=3.7"
+
+# Add a [pypi-dependencies] table only if you need pip-only packages that are
+# not on conda-forge. Prefer conda-forge — and if you add one here, check it
+# doesn't conflict with a conda-pinned version of the same dep.
+#
+# Do NOT add `bocoflow_core` here — the Salpa runtime provides it, not this
+# environment. That's exactly why `pixi run test` can import core.py but not node.py.
+
+[tasks]
+# Define tasks that can be run with `pixi run <task>`
+# Use `python -m pytest` so the package root is on sys.path (for `from core import ...`).
+# `-rs` prints skip reasons: the node.py tests skip in this bare env (they need the
+# bocoflow_core runtime) — that's expected, not a failure. Validate node.py on the stack.
+test = "python -m pytest tests/ -v -rs"

bocoflow_cli/templates/individual-node/tests/test_node.py

@@ -0,0 +1,86 @@
+"""Tests for the {{PACKAGE_NAME}} node.
+
+Two levels, and the split is load-bearing:
+
+  * core.py is pure Python, so it imports in a bare pixi env and its tests
+    ALWAYS run under `pixi run test`. This is the only part `pixi run test`
+    can actually validate.
+  * node.py imports bocoflow_core, which the RUNTIME provides and which is
+    deliberately NOT a pixi dependency. So node.py cannot import here — its
+    tests carry @needs_runtime and skip. Validate node.py by loading the node
+    into Salpa and running it on a canvas.
+
+Guard the node import PER-TEST with @needs_runtime. Do not use a module-level
+`pytestmark` — that skips the pure core tests below as well, and then
+`pixi run test` exits 0 having validated nothing at all.
+"""
+
+import json
+import os
+
+import pytest
+
+from core import process, read_records          # pure — always importable here
+
+try:
+    from node import {{CLASS_NAME}}
+    _NODE_OK = True
+except Exception:  # node.py imports bocoflow_core (runtime-provided)
+    _NODE_OK = False
+
+needs_runtime = pytest.mark.skipif(
+    not _NODE_OK,
+    reason="node.py needs the bocoflow_core runtime; load the node into Salpa to validate it",
+)
+
+
+# ---- pure core (these RUN in the bare pixi env) ----------------------------
+
+def test_read_records_from_text():
+    assert read_records("alpha\nbeta\n\n  gamma  ") == ["alpha", "beta", "gamma"]
+
+
+def test_read_records_from_file(tmp_path):
+    p = tmp_path / "in.txt"
+    p.write_text("alpha\nbeta\n", encoding="utf-8")
+    assert read_records("", str(p)) == ["alpha", "beta"]
+
+
+def test_process_counts():
+    out = process(["alpha", "beta"])
+    assert out["n_in"] == 2
+    assert out["n_out"] == 2
+
+
+# If core.py needs a heavy dep, guard just those tests:
+#     pytest.importorskip("rdkit")
+
+
+# ---- node wiring (needs the bocoflow_core runtime) -------------------------
+
+@needs_runtime
+def test_node_instantiation_and_options():
+    node = {{CLASS_NAME}}({"node_id": "test"})
+    for key in ("text_input", "input_file", "output_dir"):
+        assert key in node.OPTIONS
+
+
+@needs_runtime
+def test_execute_end_to_end(tmp_path):
+    class _P:  # minimal Parameter stub. Build flow_vars from these rather than
+        def __init__(self, v):  # from node.OPTIONS — those Parameter objects are
+            self._v = v         # class attributes shared across every instance,
+                                # so set_value() on them leaks across tests.
+        def get_value(self):
+            return self._v
+
+    node = {{CLASS_NAME}}({"node_id": "test"})  # node_info dict; node_id feeds stream_log(node_id=...)
+    flow_vars = {
+        "text_input": _P("alpha\nbeta"),
+        "input_file": _P(""),
+        "output_dir": _P(str(tmp_path)),
+    }
+    result = json.loads(node.execute(None, flow_vars))
+    assert result["success"] is True
+    assert result["data"]["n_in"] == 2
+    assert os.path.exists(tmp_path / "output.txt")

bocoflow_cli/templates/multi-node-package/README.md

@@ -0,0 +1,32 @@
+# {{DISPLAY_NAME}} (BoCoFlow package)
+
+{{PACKAGE_DESCRIPTION}}
+
+A multi-node package: several related nodes that share one pixi environment and
+chain into a pipeline.
+
+## Nodes
+
+| Node | Does |
+|------|------|
+| {{NODE1_DISPLAY_NAME}} | {{NODE1_DESCRIPTION}} |
+| {{NODE2_DISPLAY_NAME}} | {{NODE2_DESCRIPTION}} |
+
+## Pipeline
+
+`{{NODE1_DISPLAY_NAME}} → {{NODE2_DISPLAY_NAME}}` — node one prepares the input
+and writes it to `result.data`; node two reads that from `predecessor_data`.
+
+## Bundled workflow
+
+`workflows/{{PACKAGE_NAME}}-pipeline.json` wires the nodes together. Build it on
+the canvas and export to replace the stub.
+
+## Deployment
+
+**Local (PIXI_SUBPROCESS)** — one shared environment (`pixi.toml`) for all nodes.
+List the dependencies and their channels here.
+
+## Status
+
+Say plainly what has and has not been verified end-to-end.

bocoflow_cli/templates/multi-node-package/_TEMPLATE_USAGE.md

@@ -0,0 +1,74 @@
+# multi-node-package — template usage
+
+Several related nodes that **share one pixi environment** and chain into a
+pipeline. For a single standalone node, use `individual-node/` instead.
+
+> This file is removed by the scaffolder.
+
+## Scaffold it
+
+```bash
+salpa new my-suite -t multi-node-package
+```
+
+Creates `my_suite/` with two starter nodes, `node_one/` and `node_two/`. Rename
+them to real names — **underscored**, because the directory name becomes the
+Python package name.
+
+## The layout, and the three files that must agree
+
+```
+my_suite/
+├── package.toml        # lists the nodes + names the shared environment
+├── pixi.toml           # THE shared env (one, not one per node)
+├── node_one/           # meta.toml + node.py + core.py + tests/
+├── node_two/
+└── workflows/          # the bundled demo pipeline (build on canvas, export)
+```
+
+The **shared_environment name** appears in three places and they must match:
+`pixi.toml` `[workspace].name`, `package.toml` `[package.environment]`, and
+**every** node's `meta.toml` `[node].shared_environment`. The runtime reads the
+per-node copy. The scaffolder writes all three; if you add a node by hand, set it
+in that node's meta.toml too.
+
+**Conflicting deps? Give that one node its own env.** A member whose dependencies
+can't co-exist with the shared set can opt out: omit `shared_environment` from its
+`meta.toml` and give it its own `pixi.toml` (all its deps + `redis-py`, not
+`bocoflow_core`). The runtime builds that isolated env lazily on first run; the
+rest keep sharing.
+
+## Adding a node
+
+1. Copy an existing node directory (underscored name).
+2. Add its directory name to `[package.nodes].nodes` in `package.toml`.
+3. Keep its `meta.toml` `class_name` in sync with the class in its `node.py`, and
+   set a globally-unique `[package].name` and the `shared_environment`.
+4. Add a `test-<node>` task in the root `pixi.toml` and to `test`'s depends-on.
+
+## Stdlib-only? Drop the environment
+
+If every node uses only the standard library, delete the root `pixi.toml` AND
+`[package.environment]` in `package.toml`. The nodes then run in-process with no
+environment to build.
+
+## Then
+
+```bash
+cd my_suite
+pixi install
+pixi run test         # runs each node's core tests; node tests skip (expected)
+```
+
+Then load the package into Salpa (node library → Import, Local Source) and run the
+pipeline. See `salpa docs multi-node-packages`.
+
+## Checklist
+
+- [ ] every node dir in `[package.nodes]`, each with a unique `[package].name`
+- [ ] `class_name` matches the class in each `node.py`
+- [ ] `[package].license` set on every node (missing = the node never registers)
+- [ ] the shared-env name matches across the three files above
+- [ ] `pixi install` solves; `pixi run test` reports **passed** core tests
+- [ ] the bundled workflow is a real canvas export with a `template_info.name`
+- [ ] the pipeline runs end-to-end on a canvas

bocoflow_cli/templates/multi-node-package/node_one/README.md

@@ -0,0 +1,14 @@
+# {{NODE1_DISPLAY_NAME}}
+
+{{NODE1_DESCRIPTION}}
+
+Part of the **{{DISPLAY_NAME}}** package. Stage 1 of the pipeline.
+
+## Inputs
+
+- **Input (one record per line)** — paste directly, or supply an input file.
+
+## Output
+
+- `data["prepared"]` — the prepared records (read by {{NODE2_DISPLAY_NAME}})
+- `prepared.txt` in the output directory

bocoflow_cli/templates/multi-node-package/node_one/core.py

@@ -0,0 +1,37 @@
+"""Pure-Python core for {{PACKAGE_NAME}} node one.
+
+The science lives here; node.py is a thin BoCoFlow wrapper. Keeping them apart
+is what makes this file unit-testable: a bare pixi env can import core.py but
+NOT node.py (node.py needs bocoflow_core, which the runtime provides and which
+is deliberately not a pixi dependency).
+
+No BoCoFlow imports here — pure Python. Import heavy dependencies inside the
+function that needs them, not at module scope.
+"""
+
+from __future__ import annotations
+
+from typing import Dict, List
+
+
+def read_records(text: str = "", file_path: str = "") -> List[str]:
+    """Collect input records from a text block (one per line) and/or a file.
+
+    Note: file reads pass encoding="utf-8" — bare open()/read_text() default to
+    cp1252 on Windows and silently corrupt non-ASCII.
+    """
+    records: List[str] = []
+    if text:
+        records += [ln.strip() for ln in text.splitlines() if ln.strip()]
+    if file_path:
+        with open(file_path, encoding="utf-8") as fh:
+            records += [ln.strip() for ln in fh if ln.strip()]
+    return records
+
+
+def prepare(records: List[str]) -> Dict:
+    """TODO: replace with this node's real first-stage computation."""
+    # --- Replace from here ------------------------------------------------
+    prepared = [r.strip().lower() for r in records]
+    # --- to here ----------------------------------------------------------
+    return {"prepared": prepared, "n_prepared": len(prepared)}

bocoflow_cli/templates/multi-node-package/node_one/meta.toml

@@ -0,0 +1,43 @@
+# Per-node metadata. One of these per node directory listed in package.toml.
+#
+# Note there is NO [dependencies] block: in a shared-environment package the deps
+# live in the package's root pixi.toml, not here.
+
+[package]
+# kebab-case, and GLOBALLY unique — the registry keys on it and a collision
+# silently overwrites the other node. Prefixing with the package name keeps it
+# unique. Keep this line comment-free.
+name = "{{PACKAGE_NAME}}-node-one"
+version = "0.1.0"
+description = "{{NODE1_DESCRIPTION}}"
+author = "{{AUTHOR}}"
+license = "MIT"                     # REQUIRED — a node with no license is skipped at
+                                    # load time and silently never appears in the
+                                    # palette.
+
+[node]
+class_name = "{{NODE1_CLASS_NAME}}"     # must match the class in node.py exactly
+display_name = "{{NODE1_DISPLAY_NAME}}"
+shared_environment = "{{SHARED_ENV}}"   # must match [package.environment] in
+                                        # package.toml. To isolate a node with
+                                        # conflicting deps, omit this AND add a
+                                        # per-node pixi.toml (see package.toml);
+                                        # omit both → server env, imports fail.
+num_in = 0                              # a source node — no upstream input
+num_out = 1
+category = "{{CATEGORY}}"
+
+hashtags = [{{HASHTAGS}}]
+
+[node.metadata]
+icon = "📥"
+tooltip = "{{NODE1_DESCRIPTION}}"
+
+[node.features]
+supports_resume = false
+requires_gpu = false
+parallel_capable = false
+long_running = false
+
+[documentation]
+readme = "README.md"