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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pynode-flow
-Version: 0.2.2
+Version: 0.2.3
 Summary: Python based Node-RED-like visual workflow system
 Author: olkham
 License-Expression: MIT
@@ -214,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.2 → pynode_flow-0.2.3}/README.md

@@ -149,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.2 → 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.3/plan-pynodeReview-2026-07-18.prompt.md

@@ -0,0 +1,135 @@
+# PyNode Project Review Plan — 2026-07-18
+
+Follow-up to the July 2026 overhaul (see `plan-pynodeRepoReview.prompt.md`). This plan captures
+the full findings of the 2026-07-18 project review. Phases A–D are being executed now;
+E–H are deferred and can be picked up in any later session.
+
+Status legend: `[NOW]` in progress this session · `[LATER]` deferred · `[DECIDE]` needs a user decision.
+
+---
+
+## Phase A [NOW] — Quick bug fixes + compose port
+
+1. **Dead `include_predictions` toggle** — `pynode/nodes/UltralyticsNode/ultralytics_node.py:348`
+   reads `if include_predictions or True:` so the "Include Predictions in Output" checkbox does
+   nothing. Honor the flag (use `get_config_bool` for string-safety; same for `include_image`).
+2. **docker-compose port typo** — `docker-compose.yml` publishes `"500:5000"`; DOCKER.md documents
+   port 5000. Change to `"5000:5000"`.
+3. **Silent node-import failures** — `pynode/nodes/__init__.py` `_try_import_python_files` swallows
+   every exception with bare `continue`; a custom node with a syntax error vanishes from the palette
+   with no log output. Log warnings (missing optional deps may stay at debug level).
+4. Minor cleanups: dead `system_error_node` variable in `workflow_engine.py:367`; ImageViewerNode
+   MJPEG generator loops forever after node stop (holds a waitress thread); ImageViewerNode's shared
+   `last_sent_timestamp` makes the SSE broadcaster and the `/frame` polling route steal frames from
+   each other; `socket.inet_ntoa` in `mdns_manager.py` throws on IPv6 service records.
+
+Acceptance: full test suite passes; toggling "Include Predictions" actually changes output;
+node import errors appear in the log.
+
+## Phase B [NOW] — Model / node storage directories
+
+Problem: `YOLO('yolo26n.pt')` downloads weights into the process CWD and `export(format='openvino')`
+writes next to the source; strays currently exist in 4 places (repo root, `models/`,
+`pynode/models/`, `pynode/nodes/`). A pip-installed PyNode launched from inside a venv would scatter
+files there. Also `[tool.setuptools.package-data] nodes/**/*` would bake a stray `.pt` in
+`pynode/nodes/` into a locally built wheel.
+
+1. `pynode/config.py`: add `PYNODE_MODELS_DIR` env var + `resolve_models_dir()` → default
+   `<data_dir>/models/`; `--models-dir` CLI flag in `main.py` (mirror the `--data-dir` pattern).
+2. `BaseNode.get_storage_dir(subdir=None)` → `<data_dir>/node_storage/<NodeType>/`, created lazily.
+   General rule going forward: nodes never write binaries outside their storage dir.
+3. UltralyticsNode: resolve bare model names to an absolute path under the models dir before calling
+   `YOLO()` (Ultralytics downloads named assets to an absolute path; the OpenVINO export then lands
+   in the same folder). Check legacy locations first to avoid re-downloading; never move/delete
+   existing user files automatically (`pynode/models/` holds real user models).
+4. Packaging: `[tool.setuptools.exclude-package-data]` for `*.pt` / `*_openvino_model` so strays
+   can't enter wheels.
+5. Document (README/INSTALL): env var, CLI flag, where models live per install type.
+
+Deferred idea: settings UI for the models folder.
+
+## Phase C [NOW] — mDNS in Docker: fix + docs
+
+Root cause: default bridge network; mDNS is link-local multicast (224.0.0.251:5353) which Docker's
+bridge/NAT does not forward. `HOST_IP` only fixes the advertised address, not reachability.
+
+1. DOCKER.md: new "mDNS / service discovery" section — explain the limitation; document `HOST_IP`
+   (currently undocumented); give options in order: `network_mode: host` (Linux; ports mapping
+   ignored; does NOT help on Docker Desktop Win/Mac), macvlan, host-side avahi reflector
+   (`enable-reflector=yes`) or mdns-repeater sidecar.
+2. docker-compose.yml: commented-out `network_mode: host` alternative block with the caveats.
+3. Advertised `service_port` must match the externally reachable port (relates to A2).
+
+## Phase D [NOW] — send() copy semantics (biggest perf win)
+
+`BaseNode.send()` deep-copies the message per recipient (`base_node.py:254`); raw numpy frames make
+this ~6 MB memcpy per hop per recipient. Adopt Node-RED semantics: **last recipient gets the
+original message, only additional wires get deep copies** — zero frame copies in the common
+single-connection case. Contract change: *senders must not mutate a message after calling send().*
+
+1. Audit every node for post-`send()` mutation and source nodes for numpy buffer reuse; fix
+   offenders to create fresh messages instead.
+2. Implement last-recipient-no-copy in both the queued path and the sink "direct processing" path.
+3. Update/adjust tests that assert sender-side isolation; document the contract in base_node.py.
+
+## Phase E [LATER] — Remaining performance items
+
+- Sink "direct processing" runs on the sender's thread (ImageViewer JPEG encode inside the camera
+  loop) and skips `drop_while_busy`; route sinks through the normal queue or apply drop checks.
+- Idle worker threads busy-poll every 10–100 ms (`base_node.py:296`); switch to blocking
+  `queue.get()` with a `None` sentinel pushed in `on_stop()`.
+- `sort_msg_keys` runs on every send per recipient; sort at display time in DebugNode instead.
+- Waitress `threads=10` (`main.py:103`): each SSE client and MJPEG viewer permanently holds a
+  thread → silent API starvation. Make threads a CLI flag, default higher (~24), document.
+- Dockerfile uses `cuda:12.6.0-devel` (~8 GB base); switch to `-runtime` or multi-stage.
+
+## Phase F [LATER] — UI/UX
+
+- Canvas node search (Ctrl+F: find by name/type, pan to node).
+- Per-node runtime status text on canvas (Node-RED `status()` equivalent: "model loaded", fps,
+  drop count) — SSE plumbing (`sse_handlers`) already exists.
+- Palette manager UI (falls out of Phase G).
+- Light theme (style.css is dark-only; tokenize colors to CSS variables first).
+- Groups/subflows — biggest structural gap vs Node-RED; affects workflow JSON schema, decide
+  deliberately before other schema work.
+
+## Phase G [LATER] — Live node install from an approved registry
+
+Constraints today: registries built once at import (`node_registry.py:154-156`); node `api_routes`
+registered as real Flask routes at app creation (`api/nodes.py:418`, frozen after first request).
+
+1. **Registry**: curated JSON index in a separate GitHub repo (`pynode-registry`), served raw:
+   name, description, pip requirement/git URL, version, author, category, `verified` flag.
+   Approval = PR review.
+2. **External nodes dir**: also scan `<data_dir>/nodes/` (Node-RED `~/.node-red` pattern) —
+   cheap, enables "drop a folder in, restart". Later: `[project.entry-points."pynode.nodes"]`.
+3. **API**: `GET /api/palette/catalog` (cached), `POST /api/palette/install` (pip via
+   `sys.executable -m pip`, reuse install_nodes.py pattern), `DELETE` for removal.
+4. **Activation v1**: install + "restart to activate" banner.
+   **v2 (hot reload)**: make cache builders re-runnable, `palette-updated` SSE event, convert
+   per-node API routes to one catch-all `/api/nodes/<node_id>/<path:sub>` dispatching through the
+   registry dict at request time (removes the Flask route-freeze problem).
+5. **Security**: only names from the curated index, pinned versions, behind the API key. Never
+   accept arbitrary pip specs from the UI.
+
+## Phase H [DECIDE] — Naming
+
+- **GitHub repo rename** `olkham/pynode` → `olkham/pynode-flow`: recommended; cheap, GitHub
+  redirects, removes PyPI/repo mismatch. Update `[project.urls]`, README.
+- **Import package rename** (`pynode` → `pynode_flow`): argument for = the unrelated PyPI `pynode`
+  0.1.0 namespace-collision trap (see 2026-07-18 incident); argument against = breaks all imports
+  and custom nodes; mismatched dist/import names are normal (opencv-python/cv2).
+  Recommendation: keep `pynode` import; add a startup guard that detects the conflicting `pynode`
+  dist (importlib.metadata) and fails loudly with "uninstall the unrelated pynode package".
+  If ever renaming, the pre-1.0 window is the only sane time.
+
+---
+
+## Execution notes (any session picking this up)
+
+- User commits phases themselves; do not commit.
+- Test safety (hard rules, see memory `pynode-test-safety-incident`): tests must build apps via
+  `create_app` with tmp paths (tests/conftest.py `api_client`); join every thread before fixture
+  teardown; after test work verify `git status --porcelain -- workflows/` is empty. A live PyNode
+  server may be running against this repo — its own saves to workflows/ are not test leakage.
+- Suite size at time of writing: 306 tests.

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

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

{pynode_flow-0.2.2 → pynode_flow-0.2.3}/pynode/config.py

@@ -11,6 +11,11 @@ Environment variables
   are persisted under ``<data dir>/workflows/`` (``workflow.json`` plus the
   ``_backups/`` folder). Overridden by the ``--data-dir`` CLI flag. See
   :func:`resolve_data_dir` for the full precedence.
+- ``PYNODE_MODELS_DIR``: directory for shared model weights (e.g. YOLO
+  ``.pt`` files and exported OpenVINO models). Nodes must download/read model
+  binaries here instead of scattering them into the process CWD. Defaults to
+  ``<data dir>/models``. Overridden by the ``--models-dir`` CLI flag. See
+  :func:`resolve_models_dir` for the full precedence.
 - ``PYNODE_API_KEY``: API key required on all ``/api/`` requests
   (``X-API-Key`` header or ``api_key`` query parameter). Empty/unset = auth
   disabled. Overridden by the ``--api-key`` CLI flag.
@@ -23,6 +28,7 @@ import os
 
 # Environment variable names (single source of truth).
 ENV_DATA_DIR = 'PYNODE_DATA_DIR'
+ENV_MODELS_DIR = 'PYNODE_MODELS_DIR'
 ENV_API_KEY = 'PYNODE_API_KEY'
 ENV_CORS_ORIGINS = 'PYNODE_CORS_ORIGINS'
 
@@ -37,6 +43,9 @@ CHECKOUT_DIR = os.path.dirname(PKG_DIR)
 # Name of the workflows subdirectory inside the data dir.
 WORKFLOWS_SUBDIR = 'workflows'
 
+# Name of the models subdirectory inside the data dir (shared model weights).
+MODELS_SUBDIR = 'models'
+
 
 def _is_source_checkout(base_dir):
     """True if ``base_dir`` looks like a writable PyNode source checkout.
@@ -91,3 +100,36 @@ def resolve_workflows_dir(cli_data_dir=None, environ=None, checkout_dir=None):
         resolve_data_dir(cli_data_dir=cli_data_dir, environ=environ,
                          checkout_dir=checkout_dir),
         WORKFLOWS_SUBDIR)
+
+
+def resolve_models_dir(cli_models_dir=None, environ=None, checkout_dir=None):
+    """Resolve the shared models directory for downloaded model weights.
+
+    Nodes that download or generate model binaries (YOLO ``.pt`` files,
+    exported OpenVINO models, etc.) must place them here rather than in the
+    process CWD, so a pip-installed PyNode launched from a read-only or
+    arbitrary directory does not scatter files around.
+
+    Precedence:
+
+    1. ``cli_models_dir`` (the ``--models-dir`` CLI flag),
+    2. the ``PYNODE_MODELS_DIR`` environment variable,
+    3. ``<resolve_data_dir(...)>/models`` (the ``models`` subdirectory of the
+       resolved data dir — for a source checkout this is ``<repo>/models``,
+       for a pip install ``~/.pynode/models``).
+
+    Like :func:`resolve_data_dir`, the directory is only resolved here, never
+    created — creation happens lazily at the point of use.
+    """
+    environ = os.environ if environ is None else environ
+
+    if cli_models_dir:
+        return os.path.abspath(os.path.expanduser(cli_models_dir))
+
+    env_dir = environ.get(ENV_MODELS_DIR)
+    if env_dir:
+        return os.path.abspath(os.path.expanduser(env_dir))
+
+    return os.path.join(
+        resolve_data_dir(environ=environ, checkout_dir=checkout_dir),
+        MODELS_SUBDIR)

{pynode_flow-0.2.2 → pynode_flow-0.2.3}/pynode/main.py

@@ -57,6 +57,11 @@ def main():
                              'Also settable via the PYNODE_DATA_DIR env var. '
                              'Default: the source checkout root when running '
                              'from a checkout, otherwise ~/.pynode.')
+    parser.add_argument('--models-dir', default=None,
+                        help='Directory for shared model weights (YOLO .pt '
+                             'files, exported OpenVINO models, etc.). '
+                             'Also settable via the PYNODE_MODELS_DIR env var. '
+                             'Default: <data-dir>/models.')
     args = parser.parse_args()
 
     # Configure application-wide logging
@@ -74,6 +79,10 @@ def main():
         os.environ['PYNODE_CORS_ORIGINS'] = args.cors_origins
     if args.data_dir is not None:
         os.environ['PYNODE_DATA_DIR'] = args.data_dir
+    # Node code (which has no Flask app context) resolves the models dir from
+    # the env var / defaults, so export the CLI flag before the server import.
+    if args.models_dir is not None:
+        os.environ['PYNODE_MODELS_DIR'] = args.models_dir
 
     from pynode.server import app, load_workflow_from_disk
 

{pynode_flow-0.2.2 → pynode_flow-0.2.3}/pynode/nodes/ImageViewerNode/image_viewer_node.py

@@ -88,7 +88,8 @@ class ImageViewerNode(BaseNode):
         super().__init__(node_id, name)
         self.current_frame = None
         self.frame_timestamp = 0
-        self.last_sent_timestamp = 0
+        self.last_sent_timestamp = 0  # dedupe state for the polled GET 'frame' route
+        self._sse_last_sent = 0  # dedupe state for the SSE 'frame' broadcaster
     
     def on_input(self, msg: Dict[str, Any], input_index: int = 0):
         """
@@ -126,8 +127,10 @@ class ImageViewerNode(BaseNode):
     
     def get_current_frame(self):
         """
-        Get the current frame for display in the UI.
-        Only returns frames that haven't been sent yet.
+        Get the current frame for display in the UI via the polled GET 'frame' route.
+        Only returns frames that haven't been sent yet via this route. Tracks its
+        own dedupe state (last_sent_timestamp) so it doesn't steal frames from the
+        SSE broadcaster (get_current_frame_sse), which polls independently.
         """
         if self.current_frame and self.frame_timestamp > self.last_sent_timestamp:
             self.last_sent_timestamp = self.frame_timestamp
@@ -135,18 +138,22 @@ class ImageViewerNode(BaseNode):
         return None
 
     def get_current_frame_sse(self):
-        """SSE handler: return frame wrapped in 'data' key for client compatibility."""
-        frame = self.get_current_frame()
-        if frame:
-            return {'data': frame}
+        """SSE handler: return frame wrapped in 'data' key for client compatibility.
+        Tracks its own dedupe state (_sse_last_sent) so it doesn't steal frames
+        from the polled GET 'frame' route (get_current_frame)."""
+        if self.current_frame and self.frame_timestamp > self._sse_last_sent:
+            self._sse_last_sent = self.frame_timestamp
+            return {'data': self.current_frame}
         return None
 
     def get_mjpeg_stream(self):
-        """Generator for MJPEG streaming. Yields (content_type, image_bytes) tuples."""
+        """Generator for MJPEG streaming. Yields (content_type, image_bytes) tuples.
+        Exits once the node is stopped so the stream doesn't keep a server
+        thread alive forever."""
         import time
         import base64
         last_timestamp = 0
-        while True:
+        while not self._stop_worker_flag:
             try:
                 if self.frame_timestamp > last_timestamp and self.current_frame:
                     last_timestamp = self.frame_timestamp

{pynode_flow-0.2.2 → pynode_flow-0.2.3}/pynode/nodes/LinkNode/link_bus.py

@@ -23,6 +23,7 @@ Design notes
   inventing a parallel notion of "alive".
 """
 
+import copy
 import threading
 
 
@@ -68,8 +69,13 @@ class LinkBus:
         with self._lock:
             subs = self._subscribers.get(channel)
             targets = list(subs) if subs else []
+        # Each subscriber's LinkInNode.send() may take the single-recipient fast
+        # path (which shares the payload), so when more than one subscriber
+        # receives we hand each its own deepcopy - otherwise every receiving
+        # flow would alias one payload. A single subscriber shares (cheap).
+        isolate = len(targets) > 1
         for node in targets:
-            _deliver(node, msg)
+            _deliver(node, copy.deepcopy(msg) if isolate else msg)
 
     def subscriber_count(self, channel):
         """Number of registered subscribers on ``channel`` (for tests/introspection)."""

{pynode_flow-0.2.2 → pynode_flow-0.2.3}/pynode/nodes/OmronCameraNode/omron_camera_node.py

@@ -494,7 +494,15 @@ class OmronCameraNode(BaseNode):
     # Image conversion
     # ------------------------------------------------------------------
     def _stapi_image_to_numpy(self, st, st_image) -> Optional[np.ndarray]:
-        """Convert a STAPI image to a BGR numpy array."""
+        """Convert a STAPI image to a BGR numpy array.
+
+        The returned array must NOT alias the STAPI acquisition buffer: this is
+        called inside the ``retrieve_buffer`` context, and that buffer is
+        requeued (and overwritten by future frames) as soon as the context
+        exits. ``cv2.cvtColor`` allocates fresh output arrays, but the plain
+        ``arr.reshape(...)`` paths return a view over ``raw`` - those are copied
+        explicitly so a frame handed to ``send()`` owns its pixels (see the
+        source-node buffer-reuse rule in base_node's module docstring)."""
         raw = st_image.get_image_data()
         arr = np.frombuffer(raw, dtype=np.uint8)
         h, w = st_image.height, st_image.width
@@ -521,7 +529,8 @@ class OmronCameraNode(BaseNode):
             return cv2.cvtColor(bayer, cv2.COLOR_BayerRG2BGR)
 
         elif pix_fmt == st.EStPixelFormatNamingConvention.BGR8:
-            return arr.reshape(h, w, 3)
+            # .copy() so we don't alias the STAPI buffer (requeued on ctx exit).
+            return arr.reshape(h, w, 3).copy()
 
         elif pix_fmt == st.EStPixelFormatNamingConvention.Mono8:
             gray = arr.reshape(h, w)
@@ -534,7 +543,8 @@ class OmronCameraNode(BaseNode):
         else:
             # Blind fallback: try 3-channel first, then 1-channel → gray2bgr
             try:
-                return arr.reshape(h, w, 3)
+                # .copy() so we don't alias the STAPI buffer (requeued on exit).
+                return arr.reshape(h, w, 3).copy()
             except Exception:
                 try:
                     gray = arr.reshape(h, w)

{pynode_flow-0.2.2 → pynode_flow-0.2.3}/pynode/nodes/SwitchNode/switch_node.py

@@ -4,6 +4,7 @@ Similar to Node-RED's switch node.
 Supports dynamic rules with multiple outputs.
 """
 
+import copy
 import re
 from typing import Any, Dict, List
 from pynode.nodes.base_node import BaseNode, Info, MessageKeys
@@ -248,9 +249,14 @@ class SwitchNode(BaseNode):
         matched_any = False
         for idx, rule in enumerate(rules):
             if self._evaluate_rule(msg_value, rule):
-                self.send(msg, idx)
+                # With check_all, the same msg can match several rules and go to
+                # multiple outputs. send()'s single-recipient fast path shares
+                # the payload, so the first output may share msg but every later
+                # output needs an isolated copy (otherwise the branches alias
+                # one payload). The common single-match case still shares.
+                self.send(msg if not matched_any else copy.deepcopy(msg), idx)
                 matched_any = True
-                
+
                 # If not checking all rules, stop at first match
                 if not check_all:
                     break

pynode_flow-0.2.3/pynode/nodes/UltralyticsNode/__init__.py

@@ -0,0 +1,11 @@
+# ultralytics_node imports torch at module level. Guard it so lightweight
+# submodules (e.g. model_paths, which has no heavy imports) stay importable in
+# a core-only install without torch/ultralytics. When the vision deps are
+# missing the node is simply unavailable (node auto-discovery already tolerates
+# this via its own ImportError handling).
+try:
+    from .ultralytics_node import UltralyticsNode
+    __all__ = ['UltralyticsNode']
+except ImportError:
+    __all__ = []
+