salpa-cli 0.1.2__py3-none-any.whl

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

@@ -0,0 +1,97 @@
+"""{{PACKAGE_NAME}} — node one: {{NODE1_DESCRIPTION}}
+
+Stage 1 of the pipeline. Reads input and writes prepared records, which node two
+picks up from `predecessor_data`.
+"""
+
+import os
+
+from bocoflow_core.node import Node, NodeException, NodeResult
+from bocoflow_core.parameters import (
+    FileParameterEdit,
+    FolderParameter,
+    TextParameter,
+)
+from bocoflow_core.stream_logger import stream_log
+
+# Standard 3-stage import. Stage 3 is what lets the SERVER import node.py to read
+# OPTIONS for the UI without this package's dependencies installed.
+try:
+    from .core import prepare, read_records          # package context (pytest/direct)
+except ImportError:
+    try:
+        from core import prepare, read_records        # node_runner injects node_dir on path
+    except ImportError:
+        prepare = read_records = None                 # server env: heavy deps absent
+
+
+class {{NODE1_CLASS_NAME}}(Node):
+    """{{NODE1_DESCRIPTION}}"""
+
+    category = "{{CATEGORY}}"
+    tags = [{{HASHTAGS}}]
+
+    OPTIONS = {
+        "text_input": TextParameter(
+            "Input (one record per line)", default="",
+            docstring="Records to prepare, one per line. Leave empty to use a file.",
+        ),
+        "input_file": FileParameterEdit(
+            "Input File (optional)",
+            docstring="Optional input file, one record per line.",
+        ),
+        "output_dir": FolderParameter(
+            "Output Directory",
+            docstring="Directory where prepared records are written.",
+        ),
+    }
+
+    def execute(self, predecessor_data, flow_vars):
+        stream_log("Preparing records...", node_id=self.node_id, progress=0)
+        try:
+            if prepare is None:
+                raise NodeException(
+                    "setup",
+                    "core.py could not be imported. Check that this package's shared "
+                    "pixi environment installed its dependencies (`pixi install`).",
+                )
+
+            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)
+            if not records:
+                raise NodeException("input", "No input provided (via text or file).")
+
+            stream_log(
+                f"Preparing {len(records)} record(s)...",
+                node_id=self.node_id, progress=40,
+            )
+            out = prepare(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, "prepared.txt")
+            with open(out_file, "w", encoding="utf-8") as fh:
+                for record in out["prepared"]:
+                    fh.write(f"{record}\n")
+
+            # Keys placed in result.data are what node two reads from
+            # predecessor_data — this dict IS the contract between the two nodes.
+            result.data = {
+                **out,
+                "prepared_file": self.format_output_path(out_file),
+            }
+            result.files["output"] = {"prepared_file": result.data["prepared_file"]}
+            result.success = True
+            result.message = f"Prepared {out['n_prepared']} record(s)"
+            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("prepare", str(e))

bocoflow_cli/templates/multi-node-package/node_one/tests/test_node.py

@@ -0,0 +1,64 @@
+"""Tests for {{PACKAGE_NAME}} node one.
+
+core.py is pure Python and imports fine here, so its tests ALWAYS run.
+node.py imports bocoflow_core, which the RUNTIME provides and which is not a
+pixi dependency — so its tests carry @needs_runtime and skip. Validate node.py
+by loading the node into Salpa and running it.
+
+Guard per-test with @needs_runtime, never with a module-level `pytestmark` —
+a module-level mark skips the core tests too, and `pixi run test` then exits 0
+having validated nothing.
+"""
+
+import json
+import os
+
+import pytest
+
+from core import prepare, read_records          # pure — always importable here
+
+try:
+    from node import {{NODE1_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_prepare_normalizes():
+    out = prepare(["Alpha", "Beta"])
+    assert out["prepared"] == ["alpha", "beta"]
+    assert out["n_prepared"] == 2
+
+
+# ---- node wiring (needs the bocoflow_core runtime) -------------------------
+
+@needs_runtime
+def test_execute_writes_prepared_file(tmp_path):
+    class _P:  # minimal Parameter stub — build flow_vars from these rather than
+        def __init__(self, v):  # from node.OPTIONS, whose Parameter objects are
+            self._v = v         # class attributes shared across every instance.
+
+        def get_value(self):
+            return self._v
+
+    node = {{NODE1_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_prepared"] == 2
+    assert os.path.exists(tmp_path / "prepared.txt")

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

@@ -0,0 +1,15 @@
+# {{NODE2_DISPLAY_NAME}}
+
+{{NODE2_DESCRIPTION}}
+
+Part of the **{{DISPLAY_NAME}}** package. Stage 2 of the pipeline — reads what
+{{NODE1_DISPLAY_NAME}} produced from `predecessor_data`.
+
+## Inputs
+
+- The `prepared` records from an upstream {{NODE1_DISPLAY_NAME}} node.
+
+## Output
+
+- `data["longest"]` / `data["n_summarized"]`
+- `summary.txt` in the output directory

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

@@ -0,0 +1,20 @@
+"""Pure-Python core for {{PACKAGE_NAME}} node two.
+
+No BoCoFlow imports here — pure Python. See node_one/core.py for why the
+core/node split matters.
+"""
+
+from __future__ import annotations
+
+from typing import Dict, List
+
+
+def summarize(records: List[str]) -> Dict:
+    """TODO: replace with this node's real second-stage computation."""
+    # --- Replace from here ------------------------------------------------
+    longest = max(records, key=len) if records else ""
+    # --- to here ----------------------------------------------------------
+    return {
+        "n_summarized": len(records),
+        "longest": longest,
+    }

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

@@ -0,0 +1,36 @@
+# 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. Keep this line comment-free.
+name = "{{PACKAGE_NAME}}-node-two"
+version = "0.1.0"
+description = "{{NODE2_DESCRIPTION}}"
+author = "{{AUTHOR}}"
+license = "MIT"                     # REQUIRED — see node_one/meta.toml
+
+[node]
+class_name = "{{NODE2_CLASS_NAME}}"     # must match the class in node.py exactly
+display_name = "{{NODE2_DISPLAY_NAME}}"
+shared_environment = "{{SHARED_ENV}}"   # must match [package.environment] in package.toml
+num_in = 1                              # consumes node_one's output
+num_out = 1
+category = "{{CATEGORY}}"
+
+hashtags = [{{HASHTAGS}}]
+
+[node.metadata]
+icon = "📤"
+tooltip = "{{NODE2_DESCRIPTION}}"
+
+[node.features]
+supports_resume = false
+requires_gpu = false
+parallel_capable = false
+long_running = false
+
+[documentation]
+readme = "README.md"

bocoflow_cli/templates/multi-node-package/node_two/node.py

@@ -0,0 +1,101 @@
+"""{{PACKAGE_NAME}} — node two: {{NODE2_DESCRIPTION}}
+
+Stage 2 of the pipeline. Reads what node one placed in its `result.data` via
+`predecessor_data`, and demonstrates how nodes in a package chain together.
+"""
+
+import os
+
+from bocoflow_core.node import Node, NodeException, NodeResult
+from bocoflow_core.parameters import FolderParameter
+from bocoflow_core.stream_logger import stream_log
+
+try:
+    from .core import summarize                  # package context (pytest/direct)
+except ImportError:
+    try:
+        from core import summarize                # node_runner injects node_dir on path
+    except ImportError:
+        summarize = None                          # server env: heavy deps absent
+
+
+def _merge_predecessors(predecessor_data):
+    """Flatten upstream node `data` dicts into one carry-forward dict.
+
+    This is how a node reads what its upstream neighbour produced: whatever the
+    previous node put in `result.data` arrives here.
+    """
+    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 {{NODE2_CLASS_NAME}}(Node):
+    """{{NODE2_DESCRIPTION}}"""
+
+    category = "{{CATEGORY}}"
+    tags = [{{HASHTAGS}}]
+
+    OPTIONS = {
+        "output_dir": FolderParameter(
+            "Output Directory",
+            docstring="Directory where the summary is written.",
+        ),
+    }
+
+    def execute(self, predecessor_data, flow_vars):
+        stream_log("Summarizing...", node_id=self.node_id, progress=0)
+        try:
+            if summarize is None:
+                raise NodeException(
+                    "setup",
+                    "core.py could not be imported. Check that this package's shared "
+                    "pixi environment installed its dependencies (`pixi install`).",
+                )
+
+            carried = _merge_predecessors(predecessor_data)
+            result = NodeResult()
+
+            # node_one put "prepared" in its result.data — that is the contract.
+            records = carried.get("prepared")
+            if not records:
+                raise NodeException(
+                    "input",
+                    "No 'prepared' records from the upstream node. Connect this "
+                    "node's input to {{NODE1_DISPLAY_NAME}} and run that first.",
+                )
+
+            stream_log(
+                f"Summarizing {len(records)} record(s)...",
+                node_id=self.node_id, progress=40,
+            )
+            out = summarize(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, "summary.txt")
+            with open(out_file, "w", encoding="utf-8") as fh:
+                fh.write(f"records: {out['n_summarized']}\n")
+                fh.write(f"longest: {out['longest']}\n")
+
+            result.data = {
+                **carried,                 # carry upstream keys forward
+                **out,
+                "summary_file": self.format_output_path(out_file),
+            }
+            result.files["output"] = {"summary_file": result.data["summary_file"]}
+            result.success = True
+            result.message = f"Summarized {out['n_summarized']} record(s)"
+            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("summarize", str(e))

bocoflow_cli/templates/multi-node-package/node_two/tests/test_node.py

@@ -0,0 +1,72 @@
+"""Tests for {{PACKAGE_NAME}} node two.
+
+See node_one/tests/test_node.py for why the node import is guarded per-test with
+@needs_runtime rather than a module-level pytestmark.
+"""
+
+import json
+import os
+
+import pytest
+
+from core import summarize                       # pure — always importable here
+
+try:
+    from node import {{NODE2_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_summarize_counts_and_longest():
+    out = summarize(["alpha", "be", "gamma-longest"])
+    assert out["n_summarized"] == 3
+    assert out["longest"] == "gamma-longest"
+
+
+def test_summarize_handles_empty():
+    assert summarize([])["n_summarized"] == 0
+
+
+# ---- node wiring (needs the bocoflow_core runtime) -------------------------
+
+@needs_runtime
+def test_execute_reads_predecessor_data(tmp_path):
+    class _P:
+        def __init__(self, v):
+            self._v = v
+
+        def get_value(self):
+            return self._v
+
+    node = {{NODE2_CLASS_NAME}}({"node_id": "test"})
+    # Shaped exactly like what node one returns: the upstream result.data dict.
+    predecessor_data = [{"data": {"prepared": ["alpha", "beta"], "n_prepared": 2}}]
+    flow_vars = {"output_dir": _P(str(tmp_path))}
+
+    result = json.loads(node.execute(predecessor_data, flow_vars))
+    assert result["success"] is True
+    assert result["data"]["n_summarized"] == 2
+    assert result["data"]["n_prepared"] == 2      # upstream keys carried forward
+    assert os.path.exists(tmp_path / "summary.txt")
+
+
+@needs_runtime
+def test_execute_without_predecessor_raises():
+    class _P:
+        def __init__(self, v):
+            self._v = v
+
+        def get_value(self):
+            return self._v
+
+    node = {{NODE2_CLASS_NAME}}({"node_id": "test"})
+    with pytest.raises(Exception):
+        node.execute(None, {"output_dir": _P("/tmp")})

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

@@ -0,0 +1,63 @@
+# Multi-node package manifest.
+#
+# The PRESENCE of this file is what makes this a multi-node package — it is how
+# the registry and the installer tell one from a single-node package. Replace
+# every double-brace placeholder below.
+#
+# Guide: https://salpa.app/docs/custom-nodes
+#        (also bundled — run `salpa docs multi-node-packages`)
+
+[package]
+# kebab-case; the DIRECTORY uses underscores. Keep this line comment-free.
+name = "{{PACKAGE_NAME}}"
+version = "0.1.0"
+description = "{{PACKAGE_DESCRIPTION}}"
+author = "{{AUTHOR}}"
+license = "MIT"                    # use the real license of the tools you wrap
+
+[package.nodes]
+# REQUIRED. These are DIRECTORY names (underscores) — not the kebab-case
+# [package].name inside each node's meta.toml. This list drives both registry
+# discovery and what the installer copies: a node missing here does not ship.
+nodes = [
+    "node_one",
+    "node_two",
+]
+
+[package.environment]
+# ONE environment shared by every node in this package — the main reason to use a
+# multi-node package rather than N single-node ones. Put ALL nodes' deps here.
+#
+# Normally this name also appears as `shared_environment` in EVERY node's meta.toml,
+# and the runtime reads that per-node copy — keep them in sync (the easiest thing to
+# get wrong here).
+#
+# OPT-OUT — a node whose deps CONFLICT with the shared env can run in its OWN env:
+# omit `shared_environment` in that node's meta.toml AND give it its own pixi.toml
+# (declaring all its deps + `redis-py`, but NOT `bocoflow_core` — the runtime installs
+# that). The runtime builds that env lazily on first run; the rest keep sharing.
+# A node that omits BOTH falls to the server env, where its imports fail.
+#
+# The shared env itself is the pixi.toml beside this file. The installer stages it
+# into shared_environments/<name>/ for you — never create that by hand.
+#
+# Stdlib-only nodes need no environment: delete this section AND the root
+# pixi.toml, and the nodes run IN_PROCESS.
+shared_environment = "{{SHARED_ENV}}"
+
+[package.metadata]
+category = "{{CATEGORY}}"          # e.g. "Molecular Dynamics", "Metal Docking"
+hashtags = [{{HASHTAGS}}]
+# platform_note = "Requires X, which has no Windows conda package."
+
+[package.documentation]
+readme = "README.md"
+
+[package.workflows]
+# A bundled demo workflow. To be registrable, the JSON must carry a top-level
+# `template_info` object with a `name` — a plain saved .bcflow is skipped with a
+# "No template_info" warning and nothing is registered.
+#
+# The path below is only used to FIND the file. The published entry is always
+# packages/<pkg>/workflows/<basename>, so the file must live in workflows/.
+examples = ["workflows/{{PACKAGE_NAME}}-pipeline.json"]

bocoflow_cli/templates/multi-node-package/pixi.toml

@@ -0,0 +1,46 @@
+# THE shared environment for every node in this package.
+#
+# There is exactly one of these per package — by default every member node shares
+# it and ships no pixi.toml of its own. On install, this file is staged to
+# shared_environments/{{SHARED_ENV}}/pixi.toml, which is what the registry
+# resolves for each node that declares `shared_environment` in its meta.toml.
+# This file is the source of truth; the staged copy is generated.
+#
+# Exception — a member whose deps CONFLICT with this shared set can opt out and run
+# in its own env: see the OPT-OUT note in package.toml's [package.environment].
+#
+# Delete this file (and [package.environment] in package.toml) if every node is
+# stdlib-only — they will run IN_PROCESS instead.
+
+[workspace]
+# must match [package.environment].shared_environment (keep this line comment-free)
+name = "{{SHARED_ENV}}"
+version = "0.1.0"
+description = "Shared environment for {{PACKAGE_NAME}} nodes"
+channels = ["conda-forge"]
+# Declare ONLY platforms your deps actually build for — pixi solves ALL declared
+# platforms, so one dep with no win-64 build fails the whole solve. Many
+# bioconda / specialized toolchains have no win-64 and sometimes no osx-arm64.
+platforms = ["linux-64", "osx-64", "osx-arm64", "win-64"]
+
+[dependencies]
+python = ">=3.10,<3.13"
+
+# Redis client for stream_log() — real-time node logs and progress in the UI.
+redis-py = ">=5.0.0"
+
+# pytest must be in the DEFAULT env (not a [feature.dev] table) or `pixi run test`
+# reports "pytest: command not found".
+pytest = ">=7"
+
+# --- Dependencies for ALL nodes in this package go here, not per-node ---
+# numpy = ">=1.24"
+
+[tasks]
+# Run each node's tests from inside its own directory so `from core import ...`
+# resolves — node dirs are not importable packages from the package root.
+# `-rs` prints skip reasons: node.py tests skip in this bare env (they need the
+# bocoflow_core runtime) — expected, not a failure. Add one line per node as it grows.
+test-node-one = { cmd = "python -m pytest tests/ -v -rs", cwd = "node_one" }
+test-node-two = { cmd = "python -m pytest tests/ -v -rs", cwd = "node_two" }
+test = { depends-on = ["test-node-one", "test-node-two"] }

bocoflow_cli/templates/multi-node-package/workflows/{{PACKAGE_NAME}}-pipeline.json

@@ -0,0 +1,26 @@
+{
+  "_comment": "Bundled demo workflow. This stub carries only the template_info block the registry needs. The real graph/react/settings/flow_vars are produced by BUILDING the pipeline on the canvas and exporting it (Workflow -> Export). Replace this whole file with that export, keeping template_info. A graph authored by hand rarely loads — node_id UUIDs, links, and react layout must be internally consistent.",
+  "version": "2.0",
+  "template_info": {
+    "id": "{{PACKAGE_NAME}}-pipeline",
+    "name": "{{DISPLAY_NAME}} Pipeline",
+    "description": "{{PACKAGE_DESCRIPTION}}",
+    "required_packages": ["{{PACKAGE_NAME}}"],
+    "category": "{{CATEGORY}}",
+    "difficulty": "beginner",
+    "estimated_time": "2 minutes",
+    "tags": [{{HASHTAGS}}, "pipeline", "workflow-template"],
+    "author": "{{AUTHOR}}"
+  },
+  "metadata": {},
+  "react": { "nodes": [], "edges": [] },
+  "settings": {},
+  "graph": {
+    "directed": true,
+    "multigraph": false,
+    "graph": {},
+    "nodes": [],
+    "links": []
+  },
+  "flow_vars": {}
+}

salpa_cli-0.1.2.dist-info/METADATA

@@ -0,0 +1,79 @@
+Metadata-Version: 2.4
+Name: salpa-cli
+Version: 0.1.2
+Summary: Salpa node authoring CLI — scaffold node packages that match the shipped template contract.
+Project-URL: Homepage, https://bocores.com/salpa-cli
+Project-URL: Documentation, https://salpa.app/docs/custom-nodes
+Author: BoundaryComputing
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: cli,computational-science,node-authoring,salpa,scaffold,workflow
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Software Development :: Code Generators
+Requires-Python: >=3.10
+Requires-Dist: rich>=13
+Requires-Dist: typer>=0.12
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# salpa-cli
+
+The Salpa node authoring CLI. Scaffolds node packages that match the shipped
+template contract — the deterministic path to a new node.
+
+```bash
+python3 -m pip install salpa-cli
+salpa new my-analyzer          # interactive
+salpa new my-suite -t multi-node-package --yes
+```
+
+Installing adds the `salpa` command. If your shell can't find `salpa` afterward,
+your Python scripts directory isn't on your `PATH` —
+installing into a virtual environment is the simplest fix (it puts `salpa` on `PATH`).
+
+`salpa new` creates `./<under_scored_name>/` from a bundled template, with every
+placeholder substituted and the directory underscored (the dir name becomes the
+Python package name, so a hyphen would break `from .core import ...`; meta.toml's
+`name` stays kebab-case).
+
+## Templates
+
+Templates ship inside the wheel and are the single source of truth for the node
+contract, so there is no second copy to drift.
+
+| Template | For |
+|----------|-----|
+| `individual-node` | one node with its own pixi env (default) |
+| `multi-node-package` | several related nodes sharing one pixi env, chained via `predecessor_data` |
+
+## Options
+
+```
+salpa new [NAME]
+  -t, --template     individual-node | multi-node-package
+  -d, --description  one-line description
+      --author       author name
+      --category     UI category (e.g. "Cheminformatics")
+  -o, --output       directory to create the package in (default: .)
+  -y, --yes          non-interactive: accept defaults, no prompts
+      --install      run `pixi install` in the new package afterwards
+```
+
+## Authoring guide
+
+`salpa docs` prints the bundled node-authoring guide. Full documentation:
+https://salpa.app/docs/custom-nodes
+
+## Reserved
+
+`salpa publish` / `install` / `run` are reserved for later and not implemented
+in v1. v1 is `salpa new` (plus `salpa docs`).

salpa_cli-0.1.2.dist-info/RECORD

@@ -0,0 +1,35 @@
+bocoflow_cli/__init__.py,sha256=SnQMExFig29NtzL6ml6lKCXoQAFxpM_amfVQAlxC1CQ,257
+bocoflow_cli/cli.py,sha256=yDXMurakQOT1yGzCGunZraWyAuknqNEIMe3R942BAZw,9504
+bocoflow_cli/docs.py,sha256=GkBL9uppFFOy_hbYLS06G5CvxzORqskkcdpkmgm-fvo,1607
+bocoflow_cli/scaffold.py,sha256=h2kmpVkmg87jnWKo4TDEtuDdqmwu1DL3O4MRHOtvdb4,7135
+bocoflow_cli/docs/README.md,sha256=jjKTiaI7HaCcKqnWRbd4FVsGvo1kV_IlMYvpSjYp1FQ,804
+bocoflow_cli/docs/multi-node-packages.md,sha256=NR_2dL260IA8yx1elBrXQriWMBXB82IATmmWAhgeT-M,1731
+bocoflow_cli/docs/node-package-structure.md,sha256=uKNK7j_Ug_FxIHk8E1tPD5qFX6XbIp0DaG6MH9tEkzQ,3516
+bocoflow_cli/docs/testing-and-loading-your-node.md,sha256=xsozYebKdI6lsc-LHeetRPHV4uMwE5fIeig2UrYx5kk,1244
+bocoflow_cli/templates/individual-node/README.md,sha256=9VBzXcy5aAW9g8CUf5V6Roba1naTCYdbYnRU0gMNaPo,1130
+bocoflow_cli/templates/individual-node/_TEMPLATE_USAGE.md,sha256=MVYWxoRs2ysdPXwRCptY5S_S71gZWz05salMdkTob60,2978
+bocoflow_cli/templates/individual-node/core.py,sha256=Rwnxw4hRuEsdF5ekvkezIIZYp6UVeMpX6EYoTCIXoK0,1885
+bocoflow_cli/templates/individual-node/meta.toml,sha256=z_iFX6FFc-Mx7Uu1mFCB-u18SHduQ0MfsW_zNfWjzDc,2136
+bocoflow_cli/templates/individual-node/node.py,sha256=3xyAJgOSTeoO0x1h5RHqZ2PUdvxHGJGbK0gzpHkFd64,5441
+bocoflow_cli/templates/individual-node/pixi.toml,sha256=EctsjeA1LIP9WZjD5xntqcP8lDlcfPdeCLMID6jggZc,1687
+bocoflow_cli/templates/individual-node/tests/test_node.py,sha256=1awhi1BXf8X-m8esfjdqJdzKPEOB2oUHEnMM9VaW5eg,2910
+bocoflow_cli/templates/multi-node-package/README.md,sha256=b17FimZIE6X4UddbTDuO37OpzFg5yvyt-qg9_M2XX9c,851
+bocoflow_cli/templates/multi-node-package/_TEMPLATE_USAGE.md,sha256=RCS9OJIIINn0ClnCwipWelJIV112I18u3QcDlTNkpu8,2920
+bocoflow_cli/templates/multi-node-package/package.toml,sha256=OWP2w6n1viBCFFD5su8hv4Ir2Y2gsOSXB02RTlt0IDk,2708
+bocoflow_cli/templates/multi-node-package/pixi.toml,sha256=kYvURCZLrQ1SVT5vPcnOEcIGviafUvqJ4Nvw9WGqwmc,2182
+bocoflow_cli/templates/multi-node-package/node_one/README.md,sha256=blMdEey02NerIsU1A6rfaNHlRxYPN-xymtZ1XQoEk4c,339
+bocoflow_cli/templates/multi-node-package/node_one/core.py,sha256=JlG9paitNlbncVxDvDn5SVUydMhQF8YIrLMSq4GzVcM,1470
+bocoflow_cli/templates/multi-node-package/node_one/meta.toml,sha256=Vb9s2QY9vznEVazPkZEeLtrbnxL07v7OY_bMu1Npym8,1632
+bocoflow_cli/templates/multi-node-package/node_one/node.py,sha256=Wu492KxqKo40zLmZuVVKU2lXu074pe-HvecTOaS1KvQ,3651
+bocoflow_cli/templates/multi-node-package/node_one/tests/test_node.py,sha256=_HGuABb4x3POwS4DQb_uFhjghhPsJmHCc18xLw5hXuo,2174
+bocoflow_cli/templates/multi-node-package/node_two/README.md,sha256=KoUcgmyPD7BOKubiheFPt3p9SBF6d7Tfk3I-dJlP-9U,367
+bocoflow_cli/templates/multi-node-package/node_two/core.py,sha256=LYERqJKVFzJ7bbCBcLdiVYFbR5p-RR9b4mtG8-m8OAU,634
+bocoflow_cli/templates/multi-node-package/node_two/meta.toml,sha256=yQxjlSxSWJJqXHaXmZT-zbiDuE5Z65_CvmvtWOqoTDA,1120
+bocoflow_cli/templates/multi-node-package/node_two/node.py,sha256=WtDfMYTjaAF0Go-4vhjMevFWJYnASkiK6ER8tSAfc4w,3789
+bocoflow_cli/templates/multi-node-package/node_two/tests/test_node.py,sha256=7UdAKcHq0YVmy_iazaahDJB72pYZbi5_IWnqNJrQGdE,2117
+bocoflow_cli/templates/multi-node-package/workflows/{{PACKAGE_NAME}}-pipeline.json,sha256=sJMD2EcV-I-sCSddpBNpAY3kth69cqidkJGBVX25k2E,1033
+salpa_cli-0.1.2.dist-info/METADATA,sha256=cHkq2KTTFsCt_N6AQjFuUe2PVQgBB4AHqzDUBYK-tPQ,2916
+salpa_cli-0.1.2.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+salpa_cli-0.1.2.dist-info/entry_points.txt,sha256=WTdnthEebNs7iECOOw6UFtaQw7-oBkpdzJGQRZ_NNSs,79
+salpa_cli-0.1.2.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+salpa_cli-0.1.2.dist-info/RECORD,,

salpa_cli-0.1.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

salpa_cli-0.1.2.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+bocoflow = bocoflow_cli.cli:app
+salpa = bocoflow_cli.cli:app