pynode-flow 0.2.1__tar.gz → 0.2.2__tar.gz

pynode_flow-0.2.2/.claude/skills/pynode-workflows/SKILL.md

@@ -0,0 +1,185 @@
+---
+name: pynode-workflows
+description: Build, edit and validate PyNode workflow JSON files (nodes + connections) that users can import via the GUI or REST API. Use when asked to create example flows, generate a workflow, wire nodes together, or debug a workflow definition.
+---
+
+# Building PyNode Workflows
+
+A PyNode workflow is a JSON document describing nodes and the connections
+between them. The GUI's **Import** button (hamburger menu) accepts a flat
+workflow file and loads it into a **new tab** named after the file. The same
+document can be POSTed to `/api/workflow`.
+
+## Workflow file format
+
+```json
+{
+  "nodes": [
+    {
+      "id": "inject_1",
+      "type": "InjectNode",
+      "name": "Every 2s",
+      "config": { "props": [{"property": "payload", "value": "hi", "valueType": "str"}], "repeat": "2" },
+      "x": 80, "y": 80
+    }
+  ],
+  "connections": [
+    { "source": "inject_1", "target": "debug_1", "sourceOutput": 0, "targetInput": 0 }
+  ]
+}
+```
+
+Rules:
+- `type` is the **Python class name** of the node (e.g. `InjectNode`, `MqttOutNode`).
+  Unknown types import as disabled placeholder nodes — always validate.
+- `id` is any unique string. Use readable slugs (`camera_1`, `yolo_1`).
+- `enabled` is optional (default `true`). `x`/`y` are canvas pixels; space
+  columns ~260px apart (80, 340, 600, 860, 1120), rows ~140px apart.
+- `sourceOutput`/`targetInput` are 0-based port indexes.
+- Config values are lenient: many nodes read numbers from strings
+  (`"confidence": "0.25"`) — copy the conventions below exactly.
+- The on-disk `workflows/workflow.json` uses a different multi-workflow
+  wrapper (`{version, activeWorkflow, workflows: [...]}`); **never** write that
+  file directly — import through the GUI or API instead.
+
+## Message conventions
+
+Messages are dicts in Node-RED style: `payload`, `topic`, `_msgid`, plus extras.
+- Images travel at `msg.payload.image` as a numpy BGR array (or JPEG bytes if a
+  source has `encode_jpeg: true`). Downstream nodes locate it via their
+  `image_path` config, default `payload.image`.
+- Detections travel at `msg.payload.detections`: a list of
+  `{"bbox": [x1,y1,x2,y2], "bbox_format": "xyxy", "class_name": str,
+  "class_id": int, "confidence": float}`, with `payload.detection_count` and
+  `payload.bbox_format` alongside.
+- `MqttOutNode` publishes `msg.payload`; **`msg.topic` overrides the node's
+  configured topic** — don't set a `topic` in InjectNode when a downstream
+  MQTT-out node should control the topic.
+
+## Node catalog (config keys verified against source)
+
+### Core / logic
+| Type | Ports in→out | Config (defaults) |
+|---|---|---|
+| `InjectNode` | 0→1 | `props`: list of `{property: "payload", value, valueType: str\|num\|bool\|json\|date\|env}` (dot paths OK, e.g. `payload.count`); `topic`: str; `once`: seconds (str, empty=off); `repeat`: seconds (str, empty=off). Manual trigger button built in. |
+| `DebugNode` | 1→0 | `console`: bool; `complete`: `"payload"` (default) or `"msg"` for whole message; `drop_messages`: bool |
+| `FunctionNode` | 1→N | `func`: Python source (body of a function receiving `msg`, `node`, `time`; must `return msg` / a list for multiple outputs / `None` to drop); `outputs`: int (default 1). Full builtins and `import` are available inside the body. |
+| `SwitchNode` | 1→N | `property`: dot path (`payload`, `payload.count`); `checkall`: bool; `rules`: list of `{operator, value, valueType}` — **rule index = output index**. Operators: `eq neq lt lte gt gte between contains matches true false null nnull else`. |
+| `ChangeNode` | 1→1 | `rules`: list of `{type: set\|delete\|change\|move, path: "msg.payload...", value, valueType}` |
+| `GateNode` | 1→1 | `{}` — passes messages only while enabled; toggled live from its card |
+| `LinkOutNode` | 1→0 | `channel`: str — publishes each incoming msg to the named channel on a process-wide bus. Reaches every `LinkInNode` with the same channel, **including in other workflows**. Empty channel = disabled. `drop_messages` defaults `"false"`. |
+| `LinkInNode` | 0→1 | `channel`: str — emits every msg published on the named channel (by any `LinkOutNode`, cross-flow). Deep-copied on delivery (flow isolation). Only receives while its flow is deployed/running and the node is enabled. Empty channel = disabled. |
+| `DelayNode` | 1→1 | `mode`: `delay`\|`delay_count`\|`rate`; `timeout`: secs (delay mode); `rate` + `rate_time`: msgs per secs; `rate_drop`: `drop`\|`queue` |
+| `CounterNode` | 1→1 | `initial_value`: "0"; `increment`: "1"; `retain_payload`: "false" |
+| `RateProbeNode` | 1→1 | `window_size`: seconds (float) — passes msgs through, shows msg/s |
+
+### Vision
+| Type | Ports | Config |
+|---|---|---|
+| `CameraNode` | 0→1 | `device_index`: 0; `fps`: 30; `width`: 640; `height`: 480; `encode_jpeg`: false; `jpeg_quality`: 75 |
+| `VideoReaderNode` | 0→1 | `source`: path (upload via node properties in GUI); `fps`: 0 (=native); `loop`: bool; `jpeg_quality`: 80 |
+| `UltralyticsNode` | 1→1 | `model`: "yolo11n.pt" (auto-downloads); `confidence`: "0.25"; `iou`: "0.45"; `draw_results`: "true"/"false"; `max_det`: "300"; `include_image`: true; `include_predictions`: true; `drop_messages`: "true" (keep on!); `device`: "cpu" (portable) or `cuda:0`/`intel:gpu` |
+| `LabelFilterNode` | 1→2 | `labels`: "person, car" (comma list); `match_mode`: `any`\|`all`; `case_sensitive`: false; `filter_detections`: true (strips non-matching detections); `detections_path`: "payload.detections". **Output 0 = matched, output 1 = unmatched.** |
+| `ConfidenceFilterNode` | 1→2 | `threshold_source`: `manual`\|`msg`; `threshold`: 0.5; `detections_path`: "payload.detections"; `confidence_field`: "confidence". **Output 0 = ≥ threshold, output 1 = < threshold.** |
+| `ImageViewerNode` | 1→0 | `width`: 320; `height`: 240; `image_path`: "payload.image"; `drop_messages`: true |
+| `VideoWriterNode` | 1→0 | `path`: "./output"; `filename`: "video_{counter}"; `codec`: `mp4v`\|`avc1`\|`xvid`...; `framerate`: 30.0; `width`/`height`; `auto_resolution`: bool (match input); `clip_length`: 0 (=unlimited); `naming_mode`: "counter"; `counter_digits`: 4 |
+
+Other vision nodes: `DrawPredictionsNode`, `CropNode`, `TrackerNode`,
+`ImageFormatNode`, `SliceNode`, `BBoxMetricsNode`, `PolygonMetricsNode`,
+`InferenceNode` (multi-backend), `FrameSourceNode` (multi-source camera lib) —
+read their `DEFAULT_CONFIG`/`properties` in `pynode/nodes/<Name>/` before use.
+
+### Network
+| Type | Ports | Config |
+|---|---|---|
+| `MqttInNode` | 0→1 | `serviceId`: broker id from mqtt_services.json; `topic`: subscribe topic (wildcards `#`/`+` OK); `qos`: "0" |
+| `MqttOutNode` | 1→0 | `serviceId`; `topic`: publish topic; `qos`: "0"; `retain`: "false" |
+
+MQTT brokers are **services** stored in `mqtt_services.json` next to the
+workflow data (managed in the GUI via the node's Broker dropdown → add). A
+workflow referencing an unknown `serviceId` imports fine but the node reports
+"No MQTT broker configured" until the user picks a broker.
+
+Also available: `WebhookNode`, `RESTEndpointNode`, `mDNSNode`.
+
+## FunctionNode authoring rules
+
+The `func` string is the **body** of `def user_function(msg, node, time)` —
+top-level `return` is required to emit. `msg` is a deep copy. Imports work
+inside the body (`import cv2`, `import numpy as np`, `import random`).
+Return a list to fan out across `outputs`; `None` drops the message.
+
+Example — blur every detection bbox in-place:
+
+```python
+import cv2
+import numpy as np
+p = msg.get('payload') or {}
+img = p.get('image')
+dets = p.get('detections') or []
+if not isinstance(img, np.ndarray):
+    return msg
+h, w = img.shape[:2]
+for d in dets:
+    bbox = d.get('bbox') or []
+    if len(bbox) != 4:
+        continue
+    x1, y1, x2, y2 = [int(round(v)) for v in bbox]
+    x1 = max(0, min(x1, w - 1)); x2 = max(x1 + 1, min(x2, w))
+    y1 = max(0, min(y1, h - 1)); y2 = max(y1 + 1, min(y2, h))
+    k = max(9, ((x2 - x1) // 4)) | 1
+    p['image'][y1:y2, x1:x2] = cv2.GaussianBlur(img[y1:y2, x1:x2], (k, k), 0)
+return msg
+```
+
+When embedding code in workflow JSON, join lines with `\n` and keep
+indentation exact.
+
+## Loading a workflow
+
+- **GUI (import)**: hamburger menu → *Import* → choose the `.json` file → it
+  opens as a new tab → press *Deploy* to activate.
+- **GUI (bundled examples)**: hamburger menu → *Examples* → pick one. These are
+  the files in `pynode/static/examples/`, served statically and listed via
+  `pynode/static/examples/manifest.json`. **When adding a new bundled example,
+  drop the `.json` in that folder and add an entry to `manifest.json`** (id,
+  file, title, description, requires) or it won't appear in the menu.
+- **API**: `POST /api/workflow` with the JSON body imports into the active
+  workflow (add `?workflow=<id>` to target another; `X-API-Key` header if the
+  server has an API key). `GET /api/workflow` exports the current one —
+  building a flow in the GUI and exporting it is the best way to learn configs.
+
+## Validating a workflow file (do this for every file you produce)
+
+Run a sandboxed import — never against the real server or the repo's
+`workflows/` dir (a leaked test once destroyed real data; see
+tests/conftest.py):
+
+```python
+import json, tempfile, os
+from pynode.server import create_app  # use a venv with the vision extras
+
+td = tempfile.mkdtemp()
+app = create_app({'WORKFLOWS_DIR': os.path.join(td, 'wf'),
+                  'WORKFLOW_FILE': os.path.join(td, 'wf', 'workflow.json'),
+                  'UPLOAD_BASE_DIR': os.path.join(td, 'up'), 'TESTING': True})
+client = app.test_client()
+data = json.load(open('pynode/static/examples/01-hello-world.json'))
+r = client.post('/api/workflow', json=data)
+assert r.status_code == 201, r.get_json()
+manager = app.extensions['workflow_manager']
+with manager.state_lock:
+    eng = next(iter(manager.working_engines.values()))
+    unknown = [n.type for n in eng.nodes.values() if getattr(n, '_is_unknown_node', False)]
+assert not unknown, f"unknown node types: {unknown}"
+manager.shutdown()
+```
+
+Checklist:
+- every connection's `source`/`target` id exists; port indexes < the node's
+  `input_count`/`output_count`
+- node `type` strings match class names exactly (case-sensitive)
+- vision chains keep `drop_messages` on for slow consumers (YOLO, viewers)
+- prefer `device: "cpu"` and auto-downloading models (`yolo11n.pt`) so flows
+  run anywhere; note anything machine-specific (camera index, broker IP) in an
+  accompanying README

{pynode_flow-0.2.1 → pynode_flow-0.2.2}/.gitignore

@@ -150,6 +150,8 @@ Thumbs.db
 
 # Project specific - ignore all JSON files (workflows and backups)
 *.json
+# ...but keep the bundled, GUI-loadable example workflows
+!pynode/static/examples/*.json
 
 # PyTorch model files
 *.pt

{pynode_flow-0.2.1 → pynode_flow-0.2.2}/INSTALL.md

@@ -16,6 +16,16 @@ pip install "pynode-flow[full]"
 Nodes whose optional dependencies are missing are simply skipped at startup, so
 a core-only install still runs fine.
 
+> **Warning — conflicting `pynode` package:** an unrelated project on PyPI is
+> named `pynode`, and it also installs a top-level `pynode` package. If it is
+> present in the same environment the two clobber each other (symptoms include
+> `ImportError: cannot import name '__version__' from 'pynode' (unknown
+> location)`). Remove it before or after installing:
+>
+> ```bash
+> pip uninstall pynode
+> ```
+
 ### Optional extras
 
 Install only the node groups you need:

{pynode_flow-0.2.1 → pynode_flow-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pynode-flow
-Version: 0.2.1
+Version: 0.2.2
 Summary: Python based Node-RED-like visual workflow system
 Author: olkham
 License-Expression: MIT
@@ -84,6 +84,7 @@ https://github.com/user-attachments/assets/0b53085a-2cc6-4c26-bd43-e0de1e0716a2
   - **SwitchNode**: Route messages based on conditions
   - **DelayNode**: Delay message delivery
   - **GateNode**: Control message flow with real-time toggle
+  - **LinkNode**: Pass messages between flows via named channels (Link In / Link Out)
   - **RateProbeNode**: Monitor message throughput
   - **QueueLengthProbeNode**: Monitor queue lengths
   - **CounterNode**: Count messages
@@ -112,6 +113,12 @@ pip install "pynode-flow[full]"
 pynode
 ```
 
+or specify a port:
+
+```bash
+pynode --port 500
+```
+
 See [INSTALL.md](INSTALL.md) for the full list of extras (`vision`, `mqtt`,
 `camera`, `inference`, `vlm`, `upload`, `discovery`, `full`) and how to install
 per-node dependencies with `pynode-install-nodes`.
@@ -187,6 +194,15 @@ python -m pynode
 
 Navigate to `http://localhost:5000`
 
+### Load an Example Workflow
+
+Ten ready-made learning workflows ship with PyNode — from a two-node hello
+world up to a camera → YOLO → filter → MQTT alert pipeline (including a "blur
+every detected person" privacy flow). Load any of them straight from the
+editor: **☰ menu → Examples → pick one**, then press **Deploy**. See
+[pynode/static/examples/README.md](pynode/static/examples/README.md) for the
+guided tour and per-example prerequisites.
+
 ### Data Directory
 
 PyNode persists workflows under `<data dir>/workflows/` (`workflow.json` plus timestamped backups in `_backups/`). The data directory is resolved in this order:

{pynode_flow-0.2.1 → pynode_flow-0.2.2}/README.md

@@ -19,6 +19,7 @@ https://github.com/user-attachments/assets/0b53085a-2cc6-4c26-bd43-e0de1e0716a2
   - **SwitchNode**: Route messages based on conditions
   - **DelayNode**: Delay message delivery
   - **GateNode**: Control message flow with real-time toggle
+  - **LinkNode**: Pass messages between flows via named channels (Link In / Link Out)
   - **RateProbeNode**: Monitor message throughput
   - **QueueLengthProbeNode**: Monitor queue lengths
   - **CounterNode**: Count messages
@@ -47,6 +48,12 @@ pip install "pynode-flow[full]"
 pynode
 ```
 
+or specify a port:
+
+```bash
+pynode --port 500
+```
+
 See [INSTALL.md](INSTALL.md) for the full list of extras (`vision`, `mqtt`,
 `camera`, `inference`, `vlm`, `upload`, `discovery`, `full`) and how to install
 per-node dependencies with `pynode-install-nodes`.
@@ -122,6 +129,15 @@ python -m pynode
 
 Navigate to `http://localhost:5000`
 
+### Load an Example Workflow
+
+Ten ready-made learning workflows ship with PyNode — from a two-node hello
+world up to a camera → YOLO → filter → MQTT alert pipeline (including a "blur
+every detected person" privacy flow). Load any of them straight from the
+editor: **☰ menu → Examples → pick one**, then press **Deploy**. See
+[pynode/static/examples/README.md](pynode/static/examples/README.md) for the
+guided tour and per-example prerequisites.
+
 ### Data Directory
 
 PyNode persists workflows under `<data dir>/workflows/` (`workflow.json` plus timestamped backups in `_backups/`). The data directory is resolved in this order:

{pynode_flow-0.2.1 → pynode_flow-0.2.2}/examples/README.md

@@ -2,6 +2,11 @@
 
 This directory contains example Python scripts that demonstrate how to use PyNode workflows programmatically without the UI.
 
+> Looking for **GUI-loadable** examples instead? PyNode ships ten example
+> workflows you can load from the editor's **☰ menu → Examples**. Their source
+> and a guided tour live in
+> [pynode/static/examples/](../pynode/static/examples/README.md).
+
 ## Examples
 
 ### 1. `camera_workflow.py` - Simple Camera Display

{pynode_flow-0.2.1 → pynode_flow-0.2.2}/pynode/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.2.1'
-__version_tuple__ = version_tuple = (0, 2, 1)
+__version__ = version = '0.2.2'
+__version_tuple__ = version_tuple = (0, 2, 2)
 
-__commit_id__ = commit_id = 'g46a6184ff'
+__commit_id__ = commit_id = 'g51b4c1354'

{pynode_flow-0.2.1 → pynode_flow-0.2.2}/pynode/api/helpers.py

@@ -16,6 +16,15 @@ def _get_manager():
     return current_app.extensions['workflow_manager']
 
 
+def _get_mqtt_manager():
+    """Return the MQTTServiceManager of the app handling the current request.
+
+    Each app owns its own manager (isolated services file), so the sandboxed
+    test app never touches the real mqtt_services.json.
+    """
+    return current_app.extensions['mqtt_manager']
+
+
 def _json_error(message, status):
     """JSON error envelope: {'success': False, 'error': str}."""
     return jsonify({'success': False, 'error': message}), status

{pynode_flow-0.2.1 → pynode_flow-0.2.2}/pynode/api/nodes.py

@@ -29,6 +29,28 @@ def get_node_types():
     return jsonify(node_registry.get_node_types())
 
 
+@nodes_bp.route('/api/link-channels', methods=['GET'])
+def get_link_channels():
+    """List distinct, non-empty channel names already used by Link In/Out
+    nodes across every workflow's working engine.
+
+    Backs the properties panel's channel suggestion list, so users can pick
+    an existing channel instead of retyping it. Scans working engines (not
+    just deployed) so channels typed into not-yet-deployed nodes show up too.
+    """
+    manager = _get_manager()
+    channels = set()
+    with manager.state_lock:
+        for engine in manager.working_engines.values():
+            for node in engine.nodes.values():
+                if node.type not in ('LinkInNode', 'LinkOutNode'):
+                    continue
+                channel = str(node.config.get('channel', '') or '').strip()
+                if channel:
+                    channels.add(channel)
+    return jsonify({'success': True, 'channels': sorted(channels)})
+
+
 @nodes_bp.route('/api/nodes', methods=['GET'])
 def get_nodes():
     """Get all nodes in the working workflow."""

{pynode_flow-0.2.1 → pynode_flow-0.2.2}/pynode/api/services.py

@@ -1,8 +1,14 @@
-"""MQTT service management API."""
+"""MQTT service management API.
+
+All handlers resolve the MQTT service manager off the current app
+(``_get_mqtt_manager``) so the sandboxed test app operates on its own
+isolated services file, never the real mqtt_services.json.
+"""
 
 from flask import Blueprint, jsonify
 
-from pynode.api.helpers import _INVALID_BODY_ERROR, _get_json_body, _json_error
+from pynode.api.helpers import (
+    _INVALID_BODY_ERROR, _get_json_body, _get_mqtt_manager, _json_error)
 
 services_bp = Blueprint('services', __name__)
 
@@ -11,8 +17,7 @@ services_bp = Blueprint('services', __name__)
 def list_mqtt_services():
     """List all MQTT services."""
     try:
-        from pynode.nodes.MQTTNode.mqtt_service import mqtt_manager
-        services = mqtt_manager.list_services()
+        services = _get_mqtt_manager().list_services()
         return jsonify({'success': True, 'services': services})
     except Exception as e:
         return jsonify({'success': False, 'error': str(e)}), 500
@@ -22,7 +27,6 @@ def list_mqtt_services():
 def create_mqtt_service():
     """Create a new MQTT service."""
     try:
-        from pynode.nodes.MQTTNode.mqtt_service import mqtt_manager
         data = _get_json_body()
         if data is None:
             return _json_error(_INVALID_BODY_ERROR, 400)
@@ -33,16 +37,32 @@ def create_mqtt_service():
         if not data.get('broker'):
             return jsonify({'success': False, 'error': 'Broker address is required'}), 400
 
-        service = mqtt_manager.create_service(data)
-        return jsonify({
-            'success': True,
-            'service': {
-                'id': service.id,
-                'name': service.name,
-                'broker': service.broker,
-                'port': service.port
-            }
-        })
+        service = _get_mqtt_manager().create_service(data)
+        return jsonify({'success': True, 'service': service.to_dict()})
+    except Exception as e:
+        return jsonify({'success': False, 'error': str(e)}), 500
+
+
+@services_bp.route('/api/services/mqtt/test', methods=['POST'])
+def test_mqtt_connection():
+    """Test an MQTT connection using the SUBMITTED form values.
+
+    Does not create or modify any saved service and does not disturb live
+    connections - it spins up a short-lived throwaway client that is always
+    cleaned up. Returns ``{'success': bool, 'error': str|None}`` where
+    ``success`` reflects whether the connection succeeded.
+    """
+    try:
+        from pynode.nodes.MQTTNode.mqtt_service import test_connection
+
+        data = _get_json_body()
+        if data is None:
+            return _json_error(_INVALID_BODY_ERROR, 400)
+        if not data.get('broker'):
+            return jsonify({'success': False, 'error': 'Broker address is required'}), 400
+
+        success, error = test_connection(data)
+        return jsonify({'success': success, 'error': error})
     except Exception as e:
         return jsonify({'success': False, 'error': str(e)}), 500
 
@@ -51,15 +71,11 @@ def create_mqtt_service():
 def get_mqtt_service(service_id):
     """Get a specific MQTT service by ID."""
     try:
-        from pynode.nodes.MQTTNode.mqtt_service import mqtt_manager
-        service = mqtt_manager.get_service(service_id)
+        service = _get_mqtt_manager().get_service(service_id)
         if not service:
             return jsonify({'success': False, 'error': 'Service not found'}), 404
 
-        return jsonify({
-            'success': True,
-            'service': service.to_dict()
-        })
+        return jsonify({'success': True, 'service': service.to_dict()})
     except Exception as e:
         return jsonify({'success': False, 'error': str(e)}), 500
 
@@ -68,19 +84,15 @@ def get_mqtt_service(service_id):
 def update_mqtt_service(service_id):
     """Update an existing MQTT service."""
     try:
-        from pynode.nodes.MQTTNode.mqtt_service import mqtt_manager
         data = _get_json_body()
         if data is None:
             return _json_error(_INVALID_BODY_ERROR, 400)
 
-        service = mqtt_manager.update_service(service_id, data)
+        service = _get_mqtt_manager().update_service(service_id, data)
         if not service:
             return jsonify({'success': False, 'error': 'Service not found'}), 404
 
-        return jsonify({
-            'success': True,
-            'service': service.to_dict()
-        })
+        return jsonify({'success': True, 'service': service.to_dict()})
     except Exception as e:
         return jsonify({'success': False, 'error': str(e)}), 500
 
@@ -89,9 +101,7 @@ def update_mqtt_service(service_id):
 def delete_mqtt_service(service_id):
     """Delete an MQTT service."""
     try:
-        from pynode.nodes.MQTTNode.mqtt_service import mqtt_manager
-
-        if not mqtt_manager.delete_service(service_id):
+        if not _get_mqtt_manager().delete_service(service_id):
             return jsonify({
                 'success': False,
                 'error': 'Service not found or still in use'
@@ -100,25 +110,3 @@ def delete_mqtt_service(service_id):
         return jsonify({'success': True})
     except Exception as e:
         return jsonify({'success': False, 'error': str(e)}), 500
-
-
-@services_bp.route('/api/services/mqtt/<service_id>/test', methods=['POST'])
-def test_mqtt_service(service_id):
-    """Test connection to an MQTT service."""
-    try:
-        from pynode.nodes.MQTTNode.mqtt_service import mqtt_manager
-
-        service = mqtt_manager.get_service(service_id)
-        if not service:
-            return jsonify({'success': False, 'error': 'Service not found'}), 404
-
-        # Try to connect
-        connected = service.connect()
-
-        return jsonify({
-            'success': True,
-            'connected': connected,
-            'status': 'connected' if connected else 'failed'
-        })
-    except Exception as e:
-        return jsonify({'success': False, 'error': str(e)}), 500

{pynode_flow-0.2.1 → pynode_flow-0.2.2}/pynode/api/workflows.py

@@ -4,7 +4,7 @@ full deploy (save), incremental deploy (deploy-changes), restart and stats.
 
 import logging
 
-from flask import Blueprint, jsonify
+from flask import Blueprint, jsonify, request
 
 from pynode.api.helpers import (
     _INVALID_BODY_ERROR,
@@ -23,9 +23,24 @@ workflows_bp = Blueprint('workflows', __name__)
 
 @workflows_bp.route('/api/version', methods=['GET'])
 def get_version():
-    """Return the running PyNode version (for display in the UI)."""
-    from pynode import __version__
-    return jsonify({'success': True, 'version': __version__})
+    """Return the running PyNode version (for display in the UI).
+
+    Defensive on purpose: if the top-level ``pynode`` package resolves to a
+    namespace package (e.g. a stale, conflicting ``pynode`` distribution left
+    an ``__init__.py``-less folder in site-packages), ``from pynode import
+    __version__`` raises ImportError. Fall back to the installed distribution
+    metadata rather than returning a 500 for a purely cosmetic endpoint.
+    """
+    try:
+        from pynode import __version__ as version
+    except Exception:
+        try:
+            from importlib.metadata import version as _dist_version
+            version = _dist_version('pynode-flow')
+        except Exception:
+            logger.warning("Could not determine PyNode version", exc_info=True)
+            version = 'unknown'
+    return jsonify({'success': True, 'version': version})
 
 
 @workflows_bp.route('/api/workflows', methods=['GET'])
@@ -404,17 +419,29 @@ def deploy_changes():
 
 @workflows_bp.route('/api/workflow/restart', methods=['POST'])
 def restart_workflow():
-    """Restart all deployed workflows."""
+    """Restart deployed workflow engine(s) without a full redeploy.
+
+    Restarts every deployed engine by default (used by e.g. bulk/maintenance
+    callers). Pass ``?workflow=<id>`` to scope the restart to a single
+    workflow - the Deploy button's "Restart" action does this so it only
+    affects the currently-viewed flow, not every open tab.
+    """
     manager = _get_manager()
+    wid = request.args.get('workflow')
     try:
-        # Snapshot under the lock; engine stop/start happens outside it.
         with manager.state_lock:
-            snapshot = [
-                (wid, manager.deployed_engines.get(wid), meta['enabled'])
-                for wid, meta in manager.workflows.items()
-            ]
-
-        for wid, deployed, enabled in snapshot:
+            if wid is not None:
+                if wid not in manager.workflows:
+                    return jsonify({'success': False, 'error': 'Workflow not found'}), 404
+                snapshot = [(wid, manager.deployed_engines.get(wid), manager.workflows[wid]['enabled'])]
+            else:
+                # Snapshot under the lock; engine stop/start happens outside it.
+                snapshot = [
+                    (w, manager.deployed_engines.get(w), meta['enabled'])
+                    for w, meta in manager.workflows.items()
+                ]
+
+        for w, deployed, enabled in snapshot:
             if not deployed:
                 continue
             workflow_data = deployed.export_workflow()
@@ -431,18 +458,29 @@ def restart_workflow():
 
 @workflows_bp.route('/api/workflow/stop', methods=['POST'])
 def stop_workflows():
-    """Transiently stop ALL deployed workflow engines.
+    """Transiently stop deployed workflow engine(s).
 
     Unlike disabling a workflow, this does NOT change any workflow's
     persisted 'enabled' flag and does NOT write to disk - the next Deploy
     (full save or incremental deploy-changes) starts enabled workflows again.
+
+    Stops every deployed engine by default (used by e.g. bulk/maintenance
+    callers). Pass ``?workflow=<id>`` to scope the stop to a single
+    workflow - the Deploy button's "Stop" action does this so it only
+    affects the currently-viewed flow, not every open tab.
     """
     manager = _get_manager()
+    wid = request.args.get('workflow')
     try:
-        # Snapshot under the lock; engine stop happens outside it.
         with manager.state_lock:
-            snapshot = [manager.deployed_engines.get(wid)
-                        for wid in manager.workflows]
+            if wid is not None:
+                if wid not in manager.workflows:
+                    return jsonify({'success': False, 'error': 'Workflow not found'}), 404
+                snapshot = [manager.deployed_engines.get(wid)]
+            else:
+                # Snapshot under the lock; engine stop happens outside it.
+                snapshot = [manager.deployed_engines.get(w)
+                            for w in manager.workflows]
 
         stopped = 0
         for deployed in snapshot: