flowgraph 0.1.2__tar.gz → 0.1.7__tar.gz

{flowgraph-0.1.2/src/flowgraph.egg-info → flowgraph-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flowgraph
-Version: 0.1.2
+Version: 0.1.7
 Summary: Headless typed workflow engine and execution runtime
 Author: Felipe Bordeu
 Maintainer: Felipe Bordeu
@@ -31,10 +31,16 @@ Requires-Dist: scipy>=1.10
 Requires-Dist: pandas
 Requires-Dist: h5py
 Requires-Dist: pillow>=10.0
+Requires-Dist: numpy>=1.24
+Requires-Dist: openpyxl>=3.1.5
+Provides-Extra: imagej
+Requires-Dist: pyimagej; extra == "imagej"
+Requires-Dist: scyjava; extra == "imagej"
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0; extra == "dev"
 Requires-Dist: pytest-cov>=5.0; extra == "dev"
 Requires-Dist: ruff>=0.6; extra == "dev"
+Requires-Dist: build; extra == "dev"
 Provides-Extra: ml
 Requires-Dist: pyplaid; extra == "ml"
 Provides-Extra: cosapp
@@ -55,7 +61,14 @@ for compatible external clients.
 > development, experimentation, and early adopter feedback. APIs and workflow
 > behavior may change before `1.0.0`. See [`Release Policy`](docs/policies/release-policy.md).
 
-## Development
+## Incremental workflow execution
+
+`WorkflowExecutor` remains stateless. Use `WorkflowSession` for selected targets,
+dependency-aware cache reuse, forced runs and session lifecycle. See
+[`Incremental execution`](doc/reference/incremental-execution.md) for the Python
+API, node safety contracts, transport options and resource limits.
+
+## Development setup
 
 ```bash
 uv sync --extra dev
@@ -72,14 +85,81 @@ The `flowgraph` command is headless and has no GUI runtime dependency:
 
 ```bash
 uv run flowgraph inspect workflow.json
+uv run flowgraph inspect workflow.json --full
+uv run flowgraph inspect workflow.json -i name=value --override node-id.parameter=value
 uv run flowgraph run workflow.json --input name=value
+uv run flowgraph run workflow.json -i name=value
 uv run flowgraph run workflow.json --override node-id.parameter=value
 uv run flowgraph run workflow.json --json-output results.json
 ```
 
+Use `--input` or its short form `-i` for each published workflow input; repeat
+the option to provide multiple inputs.
+`flowgraph inspect` displays the resolved default to the right of each published
+input, or marks it as required or having conflicting saved values.
+Inspection is compact by default; add `--full` (or `-f`) to include the workflow
+graph. Arbitrary-code warnings remain visible in both modes.
+Inspection accepts the same `--input` / `-i` and `--override` assignments as
+execution: overrides update the displayed defaults, and explicit inputs take
+precedence and are marked `(--input)`. It never executes nodes or saves changes.
+When an input is omitted, `flowgraph run` uses its downstream node's saved
+parameter value and prints a warning to stderr identifying the input, value,
+and parameter. This also works for directly exported parameters and nested
+workflow inputs. Explicit inputs take precedence; parameter overrides are applied
+before resolving defaults. Inputs without usable saved values remain required,
+and conflicting saved values require an explicit `--input`.
+For examples and warning output, see
+[Omitted inputs and saved parameter values](doc/user-guide/workflows.md#omitted-inputs-and-saved-parameter-values).
+
 Workflows use the versioned `flowgraph-workflow` JSON format. Core validation and
 execution are UI-independent.
 
+### JSON execution boundary
+
+Python clients and browser-hosted Python workers use the same entry point:
+
+```python
+from flowgraph.application.workflow_execution import execute_workflow_json
+
+result_json = execute_workflow_json(workflow_json)
+```
+
+The response includes execution order, public outputs, retained node values,
+display previews, warnings, and structured errors. A process-local node registry
+is reused, but each call reconstructs its workflow. This API does not provide a
+server, authentication, cancellation, or filesystem isolation.
+
+Mesh display previews retain scalar values or vector magnitudes in `fields` and
+`cell_fields`. Multi-component fields additionally expose their original tuples
+in `field_components` and `cell_field_components`, indexed by vertex or surface
+triangle respectively, so viewers can select an individual component without
+rerunning the workflow. These preview projections do not modify the input mesh.
+
+The former WASM-specific execution module has been removed without a compatibility
+alias. Browser clients must update their import and rebuild/stage their core wheel
+together; the workflow file and execution response formats are unchanged.
+
+## Experimental local server
+
+The prototype branch includes an authenticated, loopback-only execution API:
+
+```bash
+uv run flowgraph serve --workspace /absolute/path/to/existing/workspace
+```
+
+Port 8765 and the allowed editor origin `https://flowgraph-web.fbw-es.com` are
+defaults; explicit `--allow-origin` values replace that origin. The editor still
+requires bearer authentication and browser local-network permission. Click the
+printed **Open editor** link to pass the token and port automatically; keep the
+link private.
+
+It runs one workflow at a time in a cancellable native subprocess and provides
+runtime metadata, catalog, and workspace file endpoints. Core is API-only and never
+serves editor assets. Web and desktop clients own their GUI hosting and explicitly
+allow their origin with `--allow-origin`. Native workflow code is **not sandboxed**.
+See [Local server API and limitations](docs/local-server.md) for authentication,
+request/response formats, examples, limits, and shutdown behavior.
+
 ## Package artifacts
 
 Build the portable, pure-Python source distribution and wheel with:
@@ -91,12 +171,18 @@ uv build --out-dir dist/
 The resulting wheel is compatible with all supported Python platforms. See
 `packaging/README.md` for release details.
 
-The initial supported publication channels are GitHub source releases and
-PyPI. Conda, Docker, operating-system package managers, and third-party mirrors
-are not supported release channels at this time. See
+The repository also includes a Conda recipe under `packaging/conda/`. FlowGraph
+is distributed through the [`flowgraph` Anaconda channel](https://anaconda.org/channels/flowgraph):
+
+```bash
+conda install -c flowgraph flowgraph
+```
+
+Docker, operating-system package managers, and third-party mirrors are not
+supported release channels at this time. See
 [`Release Channels`](docs/policies/release-channels.md) for the release policy.
 
-FlowGraph Core declares Python 3.11 or newer. CI covers Python 3.11 and 3.13 on
+FlowGraph Core declares Python 3.11 or newer. CI covers Python 3.11, 3.12, 3.13, and 3.14 on
 GitHub-hosted Ubuntu, Windows, and macOS runners; a platform/version combination
 is supported only after its release-candidate job passes. See
 [`Support Policy`](docs/policies/support-policy.md) for compatibility, deprecation,
@@ -116,6 +202,12 @@ behavior.
 
 ## Documentation and support
 
+- [FlowGraph documentation](https://flowgraph.readthedocs.io/en/latest/)
+- [Built-in node catalog](doc/reference/adapters/index.md) and
+  [Python custom-node guide](doc/user-guide/custom-nodes.md).
+- The website documentation lives in `doc/` (outside the Python package).
+  To build the Read the Docs site locally, run
+  `uv run --with zensical zensical build -f zensical.toml` from this repository.
 - [`Architecture`](docs/architecture.md) describes the core boundaries and workflow
   model.
 - [`Support Policy`](docs/policies/support-policy.md) describes supported environments and

flowgraph-0.1.7/README.md

@@ -0,0 +1,190 @@
+# FlowGraph Core
+
+`FlowGraph` is the GUI-free Python workflow engine. It provides typed workflow
+composition, validation, persistence, execution, adapters, mesh and image data
+operations, browser-WASM execution support, and metadata-only catalog export
+for compatible external clients.
+
+> **Alpha status:** FlowGraph Core `0.1.x` is an alpha series for evaluation,
+> development, experimentation, and early adopter feedback. APIs and workflow
+> behavior may change before `1.0.0`. See [`Release Policy`](docs/policies/release-policy.md).
+
+## Incremental workflow execution
+
+`WorkflowExecutor` remains stateless. Use `WorkflowSession` for selected targets,
+dependency-aware cache reuse, forced runs and session lifecycle. See
+[`Incremental execution`](doc/reference/incremental-execution.md) for the Python
+API, node safety contracts, transport options and resource limits.
+
+## Development setup
+
+```bash
+uv sync --extra dev
+uv run pytest
+uv run ruff check .
+```
+
+See [`Contributing`](.github/CONTRIBUTING.md) for prerequisites, development
+workflow, testing, documentation, and pull-request expectations.
+
+## Headless workflows
+
+The `flowgraph` command is headless and has no GUI runtime dependency:
+
+```bash
+uv run flowgraph inspect workflow.json
+uv run flowgraph inspect workflow.json --full
+uv run flowgraph inspect workflow.json -i name=value --override node-id.parameter=value
+uv run flowgraph run workflow.json --input name=value
+uv run flowgraph run workflow.json -i name=value
+uv run flowgraph run workflow.json --override node-id.parameter=value
+uv run flowgraph run workflow.json --json-output results.json
+```
+
+Use `--input` or its short form `-i` for each published workflow input; repeat
+the option to provide multiple inputs.
+`flowgraph inspect` displays the resolved default to the right of each published
+input, or marks it as required or having conflicting saved values.
+Inspection is compact by default; add `--full` (or `-f`) to include the workflow
+graph. Arbitrary-code warnings remain visible in both modes.
+Inspection accepts the same `--input` / `-i` and `--override` assignments as
+execution: overrides update the displayed defaults, and explicit inputs take
+precedence and are marked `(--input)`. It never executes nodes or saves changes.
+When an input is omitted, `flowgraph run` uses its downstream node's saved
+parameter value and prints a warning to stderr identifying the input, value,
+and parameter. This also works for directly exported parameters and nested
+workflow inputs. Explicit inputs take precedence; parameter overrides are applied
+before resolving defaults. Inputs without usable saved values remain required,
+and conflicting saved values require an explicit `--input`.
+For examples and warning output, see
+[Omitted inputs and saved parameter values](doc/user-guide/workflows.md#omitted-inputs-and-saved-parameter-values).
+
+Workflows use the versioned `flowgraph-workflow` JSON format. Core validation and
+execution are UI-independent.
+
+### JSON execution boundary
+
+Python clients and browser-hosted Python workers use the same entry point:
+
+```python
+from flowgraph.application.workflow_execution import execute_workflow_json
+
+result_json = execute_workflow_json(workflow_json)
+```
+
+The response includes execution order, public outputs, retained node values,
+display previews, warnings, and structured errors. A process-local node registry
+is reused, but each call reconstructs its workflow. This API does not provide a
+server, authentication, cancellation, or filesystem isolation.
+
+Mesh display previews retain scalar values or vector magnitudes in `fields` and
+`cell_fields`. Multi-component fields additionally expose their original tuples
+in `field_components` and `cell_field_components`, indexed by vertex or surface
+triangle respectively, so viewers can select an individual component without
+rerunning the workflow. These preview projections do not modify the input mesh.
+
+The former WASM-specific execution module has been removed without a compatibility
+alias. Browser clients must update their import and rebuild/stage their core wheel
+together; the workflow file and execution response formats are unchanged.
+
+## Experimental local server
+
+The prototype branch includes an authenticated, loopback-only execution API:
+
+```bash
+uv run flowgraph serve --workspace /absolute/path/to/existing/workspace
+```
+
+Port 8765 and the allowed editor origin `https://flowgraph-web.fbw-es.com` are
+defaults; explicit `--allow-origin` values replace that origin. The editor still
+requires bearer authentication and browser local-network permission. Click the
+printed **Open editor** link to pass the token and port automatically; keep the
+link private.
+
+It runs one workflow at a time in a cancellable native subprocess and provides
+runtime metadata, catalog, and workspace file endpoints. Core is API-only and never
+serves editor assets. Web and desktop clients own their GUI hosting and explicitly
+allow their origin with `--allow-origin`. Native workflow code is **not sandboxed**.
+See [Local server API and limitations](docs/local-server.md) for authentication,
+request/response formats, examples, limits, and shutdown behavior.
+
+## Package artifacts
+
+Build the portable, pure-Python source distribution and wheel with:
+
+```bash
+uv build --out-dir dist/
+```
+
+The resulting wheel is compatible with all supported Python platforms. See
+`packaging/README.md` for release details.
+
+The repository also includes a Conda recipe under `packaging/conda/`. FlowGraph
+is distributed through the [`flowgraph` Anaconda channel](https://anaconda.org/channels/flowgraph):
+
+```bash
+conda install -c flowgraph flowgraph
+```
+
+Docker, operating-system package managers, and third-party mirrors are not
+supported release channels at this time. See
+[`Release Channels`](docs/policies/release-channels.md) for the release policy.
+
+FlowGraph Core declares Python 3.11 or newer. CI covers Python 3.11, 3.12, 3.13, and 3.14 on
+GitHub-hosted Ubuntu, Windows, and macOS runners; a platform/version combination
+is supported only after its release-candidate job passes. See
+[`Support Policy`](docs/policies/support-policy.md) for compatibility, deprecation,
+maintenance, and unsupported-use policies.
+
+## Catalog export
+
+FlowGraph can export non-executable node metadata for tools that need to author
+or structurally validate workflow JSON:
+
+```bash
+uv run python -m flowgraph.application.workflow_web_catalog node-catalog.json
+```
+
+The catalog intentionally excludes node executors and other callable runtime
+behavior.
+
+## Documentation and support
+
+- [FlowGraph documentation](https://flowgraph.readthedocs.io/en/latest/)
+- [Built-in node catalog](doc/reference/adapters/index.md) and
+  [Python custom-node guide](doc/user-guide/custom-nodes.md).
+- The website documentation lives in `doc/` (outside the Python package).
+  To build the Read the Docs site locally, run
+  `uv run --with zensical zensical build -f zensical.toml` from this repository.
+- [`Architecture`](docs/architecture.md) describes the core boundaries and workflow
+  model.
+- [`Support Policy`](docs/policies/support-policy.md) describes supported environments and
+  compatibility expectations.
+- [`SECURITY.md`](SECURITY.md) explains private vulnerability reporting and the
+  security boundaries of workflows and adapters.
+- [`Changelog`](docs/changelog.md) records release changes and known limitations.
+- [`docs/workflow-format.md`](docs/workflow-format.md) documents persistence,
+  compatibility, and capability boundaries.
+
+## Optional integrations
+
+The `ml` extra enables the PyPlaid adapter and the `cosapp` extra enables the
+CoSApp adapter. Neither extra is part of the minimum core support guarantee.
+Install an extra only when its upstream dependency, license terms, platform
+requirements, and integration behavior have been reviewed for the target
+release:
+
+```bash
+uv sync --extra ml
+uv sync --extra cosapp
+```
+
+Optional adapters may execute external tools or user-provided models. Treat
+their workflows as trusted input and test the exact dependency versions before
+production use.
+
+## License
+
+FlowGraph Core is licensed under the [BSD 3-Clause License](LICENSE). Release
+compliance requires review of the exact dependency lockfile, build artifacts,
+third-party notices, native dependencies, and applicable license obligations.

{flowgraph-0.1.2 → flowgraph-0.1.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "flowgraph"
-version = "0.1.2"
+version = "0.1.7"
 description = "Headless typed workflow engine and execution runtime"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -35,13 +35,20 @@ dependencies = [
   "pandas",
   "h5py",
   "pillow>=10.0",
+  "numpy>=1.24",
+  "openpyxl>=3.1.5",
 ]
 
 [project.optional-dependencies]
+imagej = [
+  "pyimagej",
+  "scyjava",
+]
 dev = [
   "pytest>=8.0",
   "pytest-cov>=5.0",
   "ruff>=0.6",
+  "build",
 ]
 ml = [
   "pyplaid",
@@ -81,3 +88,16 @@ pythonpath = [".", "src"]
 target-version = "py311"
 line-length = 100
 
+#[tool.uv.sources]
+#muscat = { git = "https://gitlab.com/drti/muscat.git", rev = "ParMmg" }
+##micromamba install -n uv_muscat_build_packages scotch mmgsuite=*=h* kokkos=*=h*
+## uv pip install ipywidgets
+## uv pip install jupyterlab
+##export OMP_PROC_BIND=spread
+##export OMP_PLACES=threads
+##LD_LIBRARY_PATH=/home/fbw/.local/share/mamba/envs/uv_muscat_build_packages/lib/ uv run jupyter lab
+
+#[tool.uv]
+#config-settings-package = {muscat = {"cmake.args" = ["-DCMAKE_PREFIX_PATH=/home/fbw/.local/share/mamba/envs/uv_muscat_build_packages/lib/cmake/",
+#"-DSCOTCH_ROOT=/home/fbw/.local/share/mamba/envs/uv_muscat_build_packages/"
+#]}}

{flowgraph-0.1.2 → flowgraph-0.1.7}/src/flowgraph/adapters/__init__.py

@@ -5,6 +5,7 @@ from dataclasses import dataclass
 from flowgraph.adapters.controls import AVAILABLE_NODES as CONTROL_AVAILABLE_NODES
 from flowgraph.adapters.cosapp import AVAILABLE_NODES as COSAPP_AVAILABLE_NODES
 from flowgraph.adapters.documentation import AVAILABLE_NODES as DOCUMENTATION_AVAILABLE_NODES
+from flowgraph.adapters.field_gradient import SCALAR_FIELD_GRADIENT, VECTOR_FIELD_GRADIENT
 from flowgraph.adapters.field_ops import AVAILABLE_NODES as FIELD_OPS_AVAILABLE_NODES
 from flowgraph.adapters.file_conversion import MESH_FILE_CONVERSION
 from flowgraph.adapters.files import (
@@ -14,36 +15,49 @@ from flowgraph.adapters.files import (
 )
 from flowgraph.adapters.filters import (
     CREATE_MUSCAT_ELEMENT_FILTER,
+    CREATE_MUSCAT_NODE_FILTER,
     FILTER_MESH_WITH_MUSCAT,
+    SELECTOR_OPERATORS,
 )
 from flowgraph.adapters.image_tools import AVAILABLE_NODES as IMAGE_TOOLS_AVAILABLE_NODES
+from flowgraph.adapters.imagej import AVAILABLE_NODES as IMAGEJ_AVAILABLE_NODES
+from flowgraph.adapters.mesh_analysis import MESH_NODES, SET_MESH_FIELD
+from flowgraph.adapters.mesh_composition import FIELD_COMPOSITION_NODES, MESH_COMPOSITION_NODES
 from flowgraph.adapters.mesh_creation_tools import AVAILABLE_NODES as MESH_CREATION_AVAILABLE_NODES
 from flowgraph.adapters.mesh_generations import CSV_TO_MESH
 from flowgraph.adapters.mesh_ops import AVAILABLE_NODES as MESH_OPS_AVAILABLE_NODES
+from flowgraph.adapters.paraview import PARAVIEW_BRIDGE
 from flowgraph.adapters.plaid_bridge import AVAILABLE_NODES as PLAID_AVAILABLE_NODES
 from flowgraph.adapters.readers import (
     LOAD_CSV,
     LOAD_MESHIO,
     LOAD_MESHLANE,
     LOAD_MUSCAT,
+    READ_TABLE,
 )
 from flowgraph.adapters.remote_files import DOWNLOAD_URL
 from flowgraph.adapters.simple_sources import (
+    SET_ARRAY_1D,
+    SET_BOOLEAN,
     SET_FLOAT,
     SET_INT,
-    SET_LIST_FLOAT,
     SET_LIST_INT,
     SET_LIST_STR,
     SET_STRING,
+    SET_VEC2D,
+    SET_VEC2DI,
     SET_VEC3D,
 )
 from flowgraph.adapters.sinks import AVAILABLE_NODES as SINKS_AVAILABLE_NODES
+from flowgraph.adapters.table_tools import AVAILABLE_NODES as TABLE_TOOLS_AVAILABLE_NODES
 from flowgraph.adapters.user_code import AVAILABLE_NODES as USER_CODE_AVAILABLE_NODES
+from flowgraph.adapters.vector_tools import AVAILABLE_NODES as VECTOR_TOOLS_AVAILABLE_NODES
 from flowgraph.adapters.workflow import AVAILABLE_NODES as WORKFLOW_AVAILABLE_NODES
 from flowgraph.adapters.workflow_interfaces import (
     AVAILABLE_NODES as WORKFLOW_INTERFACE_AVAILABLE_NODES,
 )
-from flowgraph.adapters.writers import WRITE_MESHIO, WRITE_MESHLANE, WRITE_MUSCAT
+from flowgraph.adapters.writers import WRITE_MESHIO, WRITE_MESHLANE, WRITE_MUSCAT, WRITE_TABLE
+from flowgraph.adapters.zones import AVAILABLE_NODES as ZONE_AVAILABLE_NODES
 from flowgraph.application.workflow_core import NodeDefinition
 
 
@@ -93,9 +107,13 @@ ADAPTERS = AdapterCatalog(
         AdapterGroup(
             "Inputs",
             subgroups=(
-                AdapterGroup("Scalars", (SET_STRING, SET_INT, SET_FLOAT)),
                 AdapterGroup(
-                    "Lists/Vectors", (SET_LIST_STR, SET_LIST_INT, SET_LIST_FLOAT, SET_VEC3D)
+                    "Scalars",
+                    (SET_STRING, SET_BOOLEAN, SET_INT, SET_FLOAT) + CONTROL_AVAILABLE_NODES,
+                ),
+                AdapterGroup(
+                    "Lists/Vectors",
+                    (SET_LIST_STR, SET_LIST_INT, SET_ARRAY_1D, SET_VEC2D, SET_VEC2DI, SET_VEC3D),
                 ),
                 AdapterGroup(
                     "Files",
@@ -108,25 +126,38 @@ ADAPTERS = AdapterCatalog(
             subgroups=(
                 AdapterGroup(
                     "Readers",
-                    (LOAD_MUSCAT, LOAD_MESHIO, LOAD_MESHLANE, LOAD_CSV),
+                    (LOAD_MUSCAT, LOAD_MESHIO, LOAD_MESHLANE, LOAD_CSV, READ_TABLE),
                 ),
-                AdapterGroup("Mesh Gens", (CSV_TO_MESH,)),
-                AdapterGroup("Mesh Creation", MESH_CREATION_AVAILABLE_NODES),
+                AdapterGroup("Mesh Creation", (CSV_TO_MESH,) + MESH_CREATION_AVAILABLE_NODES),
                 AdapterGroup(
                     "Filters",
-                    (CREATE_MUSCAT_ELEMENT_FILTER, FILTER_MESH_WITH_MUSCAT),
+                    (
+                        CREATE_MUSCAT_ELEMENT_FILTER,
+                        CREATE_MUSCAT_NODE_FILTER,
+                        FILTER_MESH_WITH_MUSCAT,
+                    )
+                    + SELECTOR_OPERATORS,
+                    subgroups=(AdapterGroup("Zones", ZONE_AVAILABLE_NODES),),
+                ),
+                AdapterGroup(
+                    "Mesh Ops", MESH_OPS_AVAILABLE_NODES + MESH_NODES + MESH_COMPOSITION_NODES
+                ),
+                AdapterGroup(
+                    "Field Ops",
+                    FIELD_OPS_AVAILABLE_NODES
+                    + (SET_MESH_FIELD, SCALAR_FIELD_GRADIENT, VECTOR_FIELD_GRADIENT)
+                    + FIELD_COMPOSITION_NODES,
                 ),
-                AdapterGroup("Mesh Ops", MESH_OPS_AVAILABLE_NODES),
-                AdapterGroup("Field Ops", FIELD_OPS_AVAILABLE_NODES),
                 AdapterGroup("File Conversion", (MESH_FILE_CONVERSION,)),
-                AdapterGroup("Writers", (WRITE_MUSCAT, WRITE_MESHLANE, WRITE_MESHIO)),
+                AdapterGroup("Writers", (WRITE_MUSCAT, WRITE_MESHLANE, WRITE_MESHIO, WRITE_TABLE)),
             ),
         ),
-        AdapterGroup("Controls", CONTROL_AVAILABLE_NODES),
         AdapterGroup("Image Tools", IMAGE_TOOLS_AVAILABLE_NODES),
-        AdapterGroup("Code", USER_CODE_AVAILABLE_NODES),
+        AdapterGroup("Table Tools", TABLE_TOOLS_AVAILABLE_NODES),
+        AdapterGroup("Vector Tools", VECTOR_TOOLS_AVAILABLE_NODES),
+        AdapterGroup("Code", USER_CODE_AVAILABLE_NODES + IMAGEJ_AVAILABLE_NODES),
         AdapterGroup("Workflow", WORKFLOW_INTERFACE_AVAILABLE_NODES + WORKFLOW_AVAILABLE_NODES),
-        AdapterGroup("Sinks", SINKS_AVAILABLE_NODES),
+        AdapterGroup("Sinks", SINKS_AVAILABLE_NODES + (PARAVIEW_BRIDGE,)),
         AdapterGroup("Doc", DOCUMENTATION_AVAILABLE_NODES),
         AdapterGroup(
             "External Tools",

flowgraph-0.1.7/src/flowgraph/adapters/calculator.py

@@ -0,0 +1,120 @@
+"""Trusted Python-expression calculator with positional and upstream-name inputs."""
+
+import builtins
+import keyword
+import re
+from collections import Counter
+from collections.abc import Mapping
+from typing import Any
+
+import numpy as np
+
+from flowgraph.application.workflow_core import (
+    ExecContext,
+    NodeDefinition,
+    NodeInstance,
+    NodeRegistry,
+    ParameterDefinition,
+    PortDefinition,
+    PortDirection,
+    WorkflowEdge,
+)
+
+from .data_types import ANY, ParameterKind
+
+
+def _numeric_value(value: Any, label: str) -> Any:
+    """Normalize lists and expose numeric array storage through a read-only view."""
+    if isinstance(value, list):
+        value = np.asarray(value)
+    if isinstance(value, np.ndarray):
+        if value.dtype.kind not in "buifc":
+            raise TypeError(f"Calculator {label} must contain numeric values")
+        view = value.view(np.ndarray)
+        view.flags.writeable = False
+        return view
+    if isinstance(value, (bool, int, float, complex, np.number, np.bool_)):
+        if np.asarray(value).dtype.kind not in "buifc":
+            raise TypeError(f"Calculator {label} must be numeric")
+        return value.item() if isinstance(value, np.generic) else value
+    raise TypeError(f"Calculator {label} must be a numeric scalar or NumPy array")
+
+
+def _calculate(
+    inputs: Mapping[str, Any],
+    parameters: Mapping[str, Any],
+    input_edges: Mapping[str, WorkflowEdge],
+) -> Mapping[str, Any]:
+    """Evaluate one trusted expression; this is intentionally not a sandbox."""
+    formula = inputs.get("formula", parameters.get("formula", "0"))
+    if not isinstance(formula, str) or not formula.strip():
+        raise ValueError("Calculator formula must be a non-empty Python expression")
+
+    namespace = {
+        name: _numeric_value(inputs[name], f"input {name!r}")
+        for index in range(1, 126)
+        if (name := f"input_{index}") in inputs
+    }
+    data_names = frozenset(namespace)
+    names = Counter(edge.source_port for name, edge in input_edges.items() if name in data_names)
+    for name, edge in input_edges.items():
+        alias = edge.source_port
+        if (
+            name in data_names
+            and names[alias] == 1
+            and alias.isidentifier()
+            and not keyword.iskeyword(alias)
+            and not re.fullmatch(r"input_[0-9]+", alias)
+            and alias not in {"np", "__builtins__"}
+            and not hasattr(builtins, alias)
+        ):
+            namespace[alias] = namespace[name]
+    namespace.update(np=np, __builtins__=builtins.__dict__)
+    try:
+        # One shared namespace also makes aliases available inside comprehensions/lambdas.
+        result = eval(compile(formula.strip(), "<calculator formula>", "eval"), namespace)
+    except Exception as error:
+        raise ValueError(f"Calculator formula failed ({type(error).__name__}): {error}") from error
+    if isinstance(result, list):
+        raise TypeError("Calculator result must be a numeric scalar or NumPy array; use np.array")
+    return {"result": _numeric_value(result, "result")}
+
+
+def _calculator(
+    inputs: Mapping[str, Any],
+    parameters: Mapping[str, Any],
+    _exec_context: ExecContext | None = None,
+) -> Mapping[str, Any]:
+    """Evaluate using numbered names when called without workflow provenance."""
+    return _calculate(inputs, parameters, {})
+
+
+def _calculator_instance(
+    _instance: NodeInstance,
+    inputs: Mapping[str, Any],
+    parameters: Mapping[str, Any],
+    _registry: NodeRegistry,
+    input_edges: Mapping[str, WorkflowEdge],
+    _exec_context: ExecContext,
+) -> Mapping[str, Any]:
+    """Resolve optional aliases from actual upstream output port names."""
+    return _calculate(inputs, parameters, input_edges)
+
+
+CALCULATOR = NodeDefinition(
+    id="calculator",
+    label="Calculator",
+    icon="mdi-calculator",
+    description="Evaluate a trusted Python expression with np, numbered inputs and unique aliases.",
+    requirements=("py:numpy",),
+    ports=(
+        PortDefinition("input", PortDirection.INPUT, ANY, "Input", required=False, expandable=125),
+        PortDefinition("result", PortDirection.OUTPUT, ANY, "Result"),
+    ),
+    parameters=(ParameterDefinition("formula", ParameterKind.TEXT, "Formula", "0", "input_1 * 2"),),
+    executor=_calculator,
+    edge_aware_instance_executor=_calculator_instance,
+    cache_policy="always",
+)
+
+__all__ = ["CALCULATOR"]