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

{pynode_flow-0.2.2 → pynode_flow-0.2.4}/.dockerignore

@@ -11,7 +11,6 @@ __pycache__/
 *.egg-info
 dist/
 build/
-.git/
 .gitignore
 .vscode/
 .idea/

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

@@ -152,6 +152,8 @@ Thumbs.db
 *.json
 # ...but keep the bundled, GUI-loadable example workflows
 !pynode/static/examples/*.json
+# ...and the example Node-RED flow shipped with the SocketNode nodes
+!pynode/nodes/SocketNode/interop/*.json
 
 # PyTorch model files
 *.pt

pynode_flow-0.2.4/DOCKER.md

@@ -0,0 +1,196 @@
+# 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
+
+### Version
+
+The version shown in the UI is derived automatically from git history during
+the Docker build — no extra flags or environment variables are needed. Tagged
+commits display a clean version (e.g. `v0.2.3`); untagged commits include the
+distance and short SHA (e.g. `v0.2.3-1-gcd272cf`).
+
+### 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.4}/Dockerfile

@@ -1,4 +1,4 @@
-FROM docker.io/nvidia/cuda:12.6.0-devel-ubuntu22.04
+FROM docker.io/nvidia/cuda:12.6.0-runtime-ubuntu22.04
 
 # Set environment variables
 ENV DEBIAN_FRONTEND=noninteractive
@@ -12,6 +12,7 @@ RUN apt-get update && apt-get install -y \
     python3-venv \
     git \
     wget \
+    gosu \
     gfortran \
     libgl1-mesa-glx \
     libgtk-3-0 \
@@ -44,16 +45,29 @@ WORKDIR /app
 # Copy application files
 COPY . /app/
 
-# Make scripts executable
-RUN chmod +x /app/setup.sh /app/install_nodes.sh
-
-# Run setup script
-RUN bash -c "source /app/setup.sh < /dev/null"
+# Derive the display version from git history, then remove .git to save
+# space.  SETUPTOOLS_SCM_PRETEND_VERSION keeps pip install happy (PEP 440);
+# the real version string is written to _version.py afterwards.
+RUN chmod +x /app/setup.sh /app/install_nodes.sh && \
+    RAW=$(git -C /app describe --tags --always 2>/dev/null || true) && \
+    if echo "$RAW" | grep -qE '^v?[0-9]+\.[0-9]+'; then \
+        VERSION=$(echo "$RAW" | sed 's/^v//'); \
+    elif [ -n "$RAW" ]; then \
+        VERSION="0.0.0+g${RAW}"; \
+    else \
+        VERSION="0.0.0"; \
+    fi && \
+    rm -rf /app/.git && \
+    SETUPTOOLS_SCM_PRETEND_VERSION=0.0.0 bash -c "source /app/setup.sh < /dev/null" && \
+    printf '__version__ = "%s"\n' "$VERSION" > /app/pynode/_version.py
 
 # Create a non-root user and give it ownership of the app directory
 RUN useradd --create-home --uid 1000 appuser \
     && chown -R appuser:appuser /app
-USER appuser
+
+# Entrypoint ensures bind-mounted directories are writable by appuser
+COPY docker-entrypoint.sh /app/docker-entrypoint.sh
+RUN chmod +x /app/docker-entrypoint.sh
 
 # Expose port
 EXPOSE 5000
@@ -62,5 +76,5 @@ EXPOSE 5000
 HEALTHCHECK --interval=30s --timeout=5s --start-period=40s --retries=3 \
     CMD ["/app/appenv/bin/python", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:5000/')"]
 
-# Run the application in production mode
+ENTRYPOINT ["/app/docker-entrypoint.sh"]
 CMD ["/app/appenv/bin/python", "-m", "pynode", "--production", "--host", "0.0.0.0", "--port", "5000"]

{pynode_flow-0.2.2 → pynode_flow-0.2.4}/Dockerfile.cpu

@@ -6,6 +6,7 @@ ENV PYTHONUNBUFFERED=1
 
 # Install system dependencies
 RUN apt-get update && apt-get install -y \
+    gosu \
     libgl1-mesa-glx \
     libglib2.0-0 \
     libsm6 \
@@ -19,15 +20,24 @@ WORKDIR /app
 # Copy application files
 COPY . /app/
 
-# Create virtual environment
-RUN python3 -m venv appenv
-
-# Activate venv and install dependencies (declared in pyproject.toml;
-# CPU-only torch is installed first so the vision extra reuses it)
-RUN . appenv/bin/activate && \
+# Derive the display version from git history, then remove .git to save
+# space.  SETUPTOOLS_SCM_PRETEND_VERSION keeps pip install happy (PEP 440);
+# the real version string is written to _version.py afterwards.
+RUN RAW=$(git describe --tags --always 2>/dev/null || true) && \
+    if echo "$RAW" | grep -qE '^v?[0-9]+\.[0-9]+'; then \
+        VERSION=$(echo "$RAW" | sed 's/^v//'); \
+    elif [ -n "$RAW" ]; then \
+        VERSION="0.0.0+g${RAW}"; \
+    else \
+        VERSION="0.0.0"; \
+    fi && \
+    rm -rf /app/.git && \
+    python3 -m venv appenv && \
+    . appenv/bin/activate && \
     pip install --upgrade pip && \
     pip install torch torchvision --index-url https://download.pytorch.org/whl/cpu && \
-    pip install -e ".[vision,mqtt]"
+    SETUPTOOLS_SCM_PRETEND_VERSION=0.0.0 pip install -e ".[vision,mqtt]" && \
+    printf '__version__ = "%s"\n' "$VERSION" > /app/pynode/_version.py
 
 # Install per-node dependencies (best-effort: a node whose vendor SDK is not
 # on PyPI, e.g. OmronCameraNode's stapipy, is skipped without failing the build)
@@ -36,7 +46,10 @@ RUN . appenv/bin/activate && pynode-install-nodes || true
 # Create a non-root user and give it ownership of the app directory
 RUN useradd --create-home --uid 1000 appuser \
     && chown -R appuser:appuser /app
-USER appuser
+
+# Entrypoint ensures bind-mounted directories are writable by appuser
+COPY docker-entrypoint.sh /app/docker-entrypoint.sh
+RUN chmod +x /app/docker-entrypoint.sh
 
 # Expose port
 EXPOSE 5000
@@ -45,5 +58,5 @@ EXPOSE 5000
 HEALTHCHECK --interval=30s --timeout=5s --start-period=40s --retries=3 \
     CMD ["/app/appenv/bin/python", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:5000/')"]
 
-# Run the application in production mode
+ENTRYPOINT ["/app/docker-entrypoint.sh"]
 CMD ["/app/appenv/bin/python", "-m", "pynode", "--production", "--host", "0.0.0.0", "--port", "5000"]

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pynode-flow
-Version: 0.2.2
+Version: 0.2.4
 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.4}/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.4}/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.4/docker-entrypoint.sh

@@ -0,0 +1,12 @@
+#!/bin/bash
+set -e
+
+# Ensure bind-mounted directories are writable by appuser (uid 1000).
+# docker-compose mounts host directories that may be owned by root.
+for dir in /app/workflows /app/workflows/services /app/logs; do
+    mkdir -p "$dir"
+    chown -R 1000:1000 "$dir" 2>/dev/null || true
+done
+
+# Drop privileges and exec the CMD
+exec gosu appuser "$@"

pynode_flow-0.2.4/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.4}/pynode/__init__.py

@@ -21,7 +21,11 @@ def _resolve_version() -> str:
     try:
         from importlib.metadata import PackageNotFoundError, version
         try:
-            return version("pynode-flow")
+            v = version("pynode-flow")
+            # 0.0.0 is the placeholder used during Docker builds; skip it so
+            # the real version written to _version.py is preferred.
+            if v != "0.0.0":
+                return v
         except PackageNotFoundError:
             pass
     except Exception:

{pynode_flow-0.2.2 → pynode_flow-0.2.4}/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.4'
+__version_tuple__ = version_tuple = (0, 2, 4)
 
-__commit_id__ = commit_id = 'g51b4c1354'
+__commit_id__ = commit_id = 'ga1c7a9d87'

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

@@ -349,6 +349,7 @@ def _register_json_route(route, methods, handler_name, endpoint_name):
         _, method, error = _resolve_node_handler(node_id, handler_name)
         if error:
             return error
+        assert method is not None
         try:
             result = method()
             if result is None:
@@ -369,6 +370,8 @@ def _register_file_upload_route(route, methods, handler_name, endpoint_name, all
             payload, status = error
             return jsonify({'success': False, 'error': payload.get_json()['error']}), status
 
+        assert method is not None
+
         if 'file' not in request.files:
             return jsonify({'success': False, 'error': 'No file provided'}), 400
 
@@ -397,9 +400,10 @@ def _register_stream_route(route, handler_name, endpoint_name):
         _, method, error = _resolve_node_handler(node_id, handler_name)
         if error:
             return error
+        assert method is not None
 
         def generate():
-            for img_data in method():
+            for img_data in method():  # type: ignore[reportGeneralTypeIssues]
                 yield (b'--frame\r\n'
                        b'Content-Type: image/jpeg\r\n\r\n' + img_data + b'\r\n')