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

pynode_flow-0.2.3/.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.3}/.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.3/DOCKER.md

@@ -0,0 +1,189 @@
+# Docker Setup for PyNode
+
+## Prerequisites
+
+- Docker Engine with GPU support (NVIDIA Container Toolkit)
+- Docker Compose v1.28+ (for GPU support)
+- NVIDIA GPU with CUDA support
+
+## Quick Start
+
+### Build and Run
+
+```bash
+docker-compose up --build
+```
+
+### Run in Background
+
+```bash
+docker-compose up -d
+```
+
+### View Logs
+
+```bash
+docker-compose logs -f
+```
+
+### Stop the Application
+
+```bash
+docker-compose down
+```
+
+## Configuration
+
+### Ports
+
+The application runs on port `5000` by default. To change the port, edit `docker-compose.yml`:
+
+```yaml
+ports:
+  - "8080:5000"  # Change 8080 to your desired port
+```
+
+### GPU Support
+
+The Docker Compose file is configured to use all available NVIDIA GPUs. To limit GPU access:
+
+```yaml
+deploy:
+  resources:
+    reservations:
+      devices:
+        - driver: nvidia
+          device_ids: ['0']  # Use only GPU 0
+          capabilities: [gpu]
+```
+
+### Persistent Storage
+
+The following directories are mounted for persistence:
+- `./workflows` - Saved workflows
+- `./logs` - Application logs
+
+## Building
+
+### Custom CUDA Version
+
+To use a different CUDA version, edit the `Dockerfile`:
+
+```dockerfile
+FROM nvidia/cuda:12.8.0-runtime-ubuntu22.04  # Change CUDA version
+```
+
+### Without GPU Support
+
+For CPU-only deployment, use the CPU Dockerfile:
+
+```bash
+docker build -f Dockerfile.cpu -t pynode-cpu .
+docker run -p 5000:5000 pynode-cpu
+```
+
+## Accessing the Application
+
+Once running, access the web interface at:
+- http://localhost:5000
+
+## mDNS / Service Discovery
+
+### The Limitation
+
+The default `docker-compose.yml` uses Docker's standard bridge network. mDNS
+(multicast DNS) relies on link-local multicast traffic (UDP `224.0.0.251:5353`),
+which the bridge network's NAT does not forward in either direction. With the
+default compose file, PyNode's mDNS nodes can broadcast and listen *inside*
+the container, but that traffic never reaches the LAN — so other machines on
+your network cannot discover the container, and the container cannot discover
+services running elsewhere.
+
+### `HOST_IP`
+
+The `HOST_IP` environment variable (see `docker-compose.yml`) only controls
+the IP address **advertised** in mDNS service records - it does *not* make
+multicast traffic reach the LAN. Setting `HOST_IP` without one of the fixes
+below just means the (unreachable) mDNS records will advertise the right
+address instead of the container's internal one; it does not fix discovery.
+
+### Fixing It
+
+**Option 1: `network_mode: host` (Linux hosts only, full fix)**
+
+On Linux, host networking removes the network isolation between the
+container and the host, so multicast works exactly as it would for a
+process running directly on the host:
+
+```yaml
+services:
+  pynode:
+    network_mode: host
+    # ports: mapping is ignored in host mode - the container shares the
+    # host's network stack directly, so remove/comment out `ports:` above.
+```
+
+This does **not** work on Docker Desktop for Windows/macOS - Docker Desktop
+runs containers inside a lightweight VM, and `network_mode: host` there still
+does not bridge multicast across the VM boundary.
+
+**Option 2: macvlan network**
+
+A macvlan network gives the container its own IP address directly on the LAN
+(as if it were a separate physical device), which also allows multicast to
+work normally. This works on Docker Desktop as well as Linux, but requires
+more setup (a dedicated IP, and typically a way for the host itself to reach
+the container since macvlan interfaces are not reachable from the host by
+default). See the
+[Docker macvlan network documentation](https://docs.docker.com/network/drivers/macvlan/)
+for setup details.
+
+**Option 3: mDNS reflector on the host**
+
+When host networking isn't available (e.g. Docker Desktop), run an mDNS
+reflector on the host to bridge multicast between the host's network and the
+container's bridge network:
+
+- **avahi-daemon** (Linux) - enable reflection in `/etc/avahi/avahi-daemon.conf`:
+  ```ini
+  [reflector]
+  enable-reflector=yes
+  ```
+- **mdns-repeater** - run as a sidecar/host process that repeats mDNS packets
+  between interfaces.
+
+This is the option that works when host networking isn't an option, at the
+cost of an extra moving part to run and maintain.
+
+### Port Matching
+
+Whichever option you use, the port PyNode advertises in its mDNS records
+must match the port other machines can actually reach it on (the *published*
+port), not just the container's internal port. If you remap ports (e.g.
+`"8080:5000"`), make sure discovery consumers connect using the published
+port (`8080`), not the internal one.
+
+## Troubleshooting
+
+### GPU Not Detected
+
+Verify NVIDIA Container Toolkit is installed:
+```bash
+docker run --rm --gpus all nvidia/cuda:12.6.0-base-ubuntu22.04 nvidia-smi
+```
+
+### Permission Issues
+
+Ensure the mounted directories have proper permissions:
+```bash
+mkdir -p workflows logs
+chmod 777 workflows logs
+```
+
+### Rebuild from Scratch
+
+```bash
+docker-compose down
+docker-compose build --no-cache
+docker-compose up
+```

{pynode_flow-0.2.1 → pynode_flow-0.2.3}/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.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pynode-flow
-Version: 0.2.1
+Version: 0.2.3
 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:
@@ -198,6 +214,25 @@ PyNode persists workflows under `<data dir>/workflows/` (`workflow.json` plus ti
 
 The resolved location is logged at startup (`Workflow data directory: ...`).
 
+### Models Directory
+
+Nodes that download or generate model weights (e.g. the YOLO node's `.pt`
+files and exported OpenVINO models) write them into a shared **models
+directory** instead of the process working directory. It is resolved in this
+order:
+
+1. `pynode --models-dir <path>` CLI flag,
+2. `PYNODE_MODELS_DIR` environment variable,
+3. `<data dir>/models` otherwise — so `<repo>/models` for a source checkout and
+   `~/.pynode/models` for a regular `pip install`.
+
+> **Upgrading:** older PyNode versions downloaded model files into whatever the
+> working directory happened to be, so stray `.pt` files and
+> `*_openvino_model/` folders may exist in the repo root, `pynode/models/` or
+> `pynode/nodes/`. PyNode still reads models from those legacy locations, but
+> nothing is migrated automatically — you can move them into the models
+> directory manually when convenient.
+
 ## Securing PyNode
 
 **PyNode executes arbitrary Python by design** (e.g. FunctionNode runs whatever code is in the workflow), so anyone who can reach the API can run code on the host. Authentication is the trust boundary — secure the server before exposing it beyond your own machine:

{pynode_flow-0.2.1 → pynode_flow-0.2.3}/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:
@@ -133,6 +149,25 @@ PyNode persists workflows under `<data dir>/workflows/` (`workflow.json` plus ti
 
 The resolved location is logged at startup (`Workflow data directory: ...`).
 
+### Models Directory
+
+Nodes that download or generate model weights (e.g. the YOLO node's `.pt`
+files and exported OpenVINO models) write them into a shared **models
+directory** instead of the process working directory. It is resolved in this
+order:
+
+1. `pynode --models-dir <path>` CLI flag,
+2. `PYNODE_MODELS_DIR` environment variable,
+3. `<data dir>/models` otherwise — so `<repo>/models` for a source checkout and
+   `~/.pynode/models` for a regular `pip install`.
+
+> **Upgrading:** older PyNode versions downloaded model files into whatever the
+> working directory happened to be, so stray `.pt` files and
+> `*_openvino_model/` folders may exist in the repo root, `pynode/models/` or
+> `pynode/nodes/`. PyNode still reads models from those legacy locations, but
+> nothing is migrated automatically — you can move them into the models
+> directory manually when convenient.
+
 ## Securing PyNode
 
 **PyNode executes arbitrary Python by design** (e.g. FunctionNode runs whatever code is in the workflow), so anyone who can reach the API can run code on the host. Authentication is the trust boundary — secure the server before exposing it beyond your own machine:

{pynode_flow-0.2.1 → pynode_flow-0.2.3}/docker-compose.yml

@@ -5,7 +5,12 @@ services:
       dockerfile: Dockerfile
     container_name: pynode
     ports:
-      - "500:5000"
+      - "5000:5000"
+    # Uncomment for mDNS support on Linux hosts (see DOCKER.md > mDNS /
+    # Service Discovery). Not effective on Docker Desktop for Windows/macOS.
+    # Remove the `ports:` mapping above when enabling this - it is ignored
+    # in host networking mode.
+    # network_mode: host
     volumes:
       # Mount persistent data
       - ./workflows:/app/workflows

{pynode_flow-0.2.1 → pynode_flow-0.2.3}/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