pynode-flow 0.2.6__tar.gz → 0.2.8__tar.gz

{pynode_flow-0.2.6 → pynode_flow-0.2.8}/.claude/skills/pynode-workflows/SKILL.md

@@ -84,11 +84,30 @@ Messages are dicts in Node-RED style: `payload`, `topic`, `_msgid`, plus extras.
 | `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`,
+Other vision nodes: `DrawPredictionsNode`, `CropNode`,
 `ImageFormatNode`, `SliceNode`, `BBoxMetricsNode`, `PolygonMetricsNode`,
 `InferenceNode` (multi-backend), `FrameSourceNode` (multi-source camera lib) —
 read their `DEFAULT_CONFIG`/`properties` in `pynode/nodes/<Name>/` before use.
 
+### Supervision
+Nodes built on the `supervision` library (`[vision]` extra). They register even
+without it installed, reporting an error and passing messages through.
+
+| Type | Ports | Config |
+|---|---|---|
+| `SupervisionTrackerNode` | 1→1 | `track_thresh`: "0.25"; `track_buffer`: "30" (frames a lost track is kept, scaled by `frame_rate`); `match_thresh`: "0.8" (IoU); `min_consecutive_frames`: "1" (raise to 2-3 to kill ghost tracks); `frame_rate`: "30" (**set to the real source fps**). Adds `track_id` to each detection plus `payload.tracks`/`track_count`. Has a `reset` action — a new object needs 2 frames before it is reported. **Does not draw** — wire an `SupervisionAnnotateNode` after it. |
+| `SupervisionAnnotateNode` | 1→1 | `annotators`: list from `box round_box box_corner ellipse circle triangle dot color label percentage_bar blur pixelate background_overlay trace heatmap` (applied in a fixed order: pixel effects → shapes → labels; default `["box","label"]`); `color_lookup`: `class`\|`track`\|`index` (`track` falls back to `class` without ids); `thickness`/`text_scale`: "auto" (resolution-scaled) or a number; `show_class`/`show_confidence`/`show_track_id`: bool (label content); `trace_length`: "30". `trace` needs a `SupervisionTrackerNode` upstream; `heatmap` accumulates over time. `reset` action clears trace/heatmap state. |
+| `SupervisionLineCounterNode` | 1→**2** | `line`: "x1,y1,x2,y2" (image px; the GUI has a draw-on-frame editor); `anchors`: `corners`\|`center`\|`bottom_center`; `min_crossing_frames`: "1"; `draw`: "true"/"false". **Needs tracked detections** (SV Tracker upstream). Output 0 = every msg + `payload.line_in`/`line_out`/`line_in_by_class`/`line_out_by_class` and the line drawn; **output 1 = one msg per crossing** `{event:'line_crossing', direction, track_id, class_id, class_name, bbox, in_count, out_count}`. Actions: `reset` (zero counts), `set_geometry` (live line update, resets counts). |
+| `SupervisionZoneNode` | 1→**2** | `polygon`: JSON "[[x,y],...]" (image px; draw-on-frame editor in GUI); `anchor`: `bottom_center`\|`center`\|`top_center`; `filter_to_zone`: bool (drop outside detections); `draw`: "true"/"false"; `opacity`: "0.15". Output 0 = every msg + `payload.zone_count` and `in_zone` on each detection; **output 1 = enter/exit events** (needs track ids) `{event:'enter'\|'exit', track_id, class_id, class_name, bbox, zone_count}`. Actions: `reset` (event state), `set_geometry` (live polygon update). |
+| `SupervisionSmootherNode` | 1→1 | `length`: "5" (frames averaged per box). Smooths bbox jitter; **needs track ids** (SV Tracker upstream) — place between tracker and annotate/zones. Untracked input passes through with one warning. `reset` action clears history. |
+| `SupervisionFilterNode` | 1→**2** | All criteria optional (empty = off): `min_confidence`/`max_confidence`; `allow_classes`/`deny_classes` (comma names or numeric ids); `min_area`/`max_area` (px²); `min_aspect`/`max_aspect` (w/h); `top_k`; `dedupe`: `off`\|`nms`\|`nmm` + `dedupe_threshold`: "0.5" + `overlap_metric`: `iou`\|`ios` + `class_agnostic`: bool. Output 0 = kept, output 1 = rejected by criteria (both always fire; NMS/NMM-suppressed are dropped, not rejected). |
+| `SupervisionSinkNode` | 1→1 | `format`: `csv` (row per detection, safe for long runs)\|`json` (in-memory, written on stop/rotate); `path`: "./output"; `filename`: base → `<base>_<YYYYmmdd-HHMMSS>.<ext>`. Row = xyxy, class_id, confidence, tracker_id, class_name, frame, timestamp. Empty frames advance the frame counter but write no rows; the file opens on the first detection. Passes msgs through with `payload.sink_file`/`sink_rows`. `new_file` action rotates. |
+
+Detections travel as `payload.detections` (list of dicts, read by every core
+node) and, alongside it, `payload.sv` — the live `sv.Detections` object, which
+also carries masks and tracker ids. Use `pynode/nodes/supervision_utils.py`
+(`to_sv` / `write_back`) rather than converting by hand.
+
 ### Network
 | Type | Ports | Config |
 |---|---|---|
@@ -164,12 +183,15 @@ 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)
+# A fresh app has NO workflows - create one first, then import into it.
+r = client.post('/api/workflows', json={'name': 'validate'})
+wf_id = r.get_json()['id']
+data = json.load(open('pynode/static/examples/01-hello-world.json', encoding='utf-8'))
+r = client.post(f'/api/workflow?workflow={wf_id}', 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()))
+    eng = manager.working_engines[wf_id]
     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()

{pynode_flow-0.2.6 → pynode_flow-0.2.8}/Dockerfile

@@ -1,9 +1,11 @@
-FROM docker.io/nvidia/cuda:12.6.0-runtime-ubuntu22.04
+FROM docker.io/nvidia/cuda:12.8.1-runtime-ubuntu22.04
 
 # Set environment variables
 ENV DEBIAN_FRONTEND=noninteractive
 ENV PYTHONUNBUFFERED=1
-ENV CUDA_VERSION=12.6
+# cu128 PyTorch wheels are the first to ship Blackwell (sm_120, e.g. RTX 50xx)
+# kernels; older cu126 builds raise "no kernel image is available".
+ENV CUDA_VERSION=12.8
 
 # Install system dependencies
 RUN apt-get update && apt-get install -y \

{pynode_flow-0.2.6 → pynode_flow-0.2.8}/INSTALL.md

@@ -32,7 +32,7 @@ Install only the node groups you need:
 
 | Extra | Installs | Nodes it enables |
 |-------|----------|------------------|
-| `vision` | ultralytics, torch, torchvision, supervision | UltralyticsNode, TrackerNode, DrawPredictionsNode, … |
+| `vision` | ultralytics, torch, torchvision, supervision | UltralyticsNode, DrawPredictionsNode, the Supervision nodes, … |
 | `mqtt` | paho-mqtt | MQTTNode |
 | `camera` | framesource[full] | FrameSourceNode |
 | `inference` | onnxruntime (+ `vision`) | InferenceNode |

{pynode_flow-0.2.6 → pynode_flow-0.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pynode-flow
-Version: 0.2.6
+Version: 0.2.8
 Summary: Python based Node-RED-like visual workflow system
 Author: olkham
 License-Expression: MIT
@@ -94,7 +94,8 @@ carries its own documentation in the editor's **Information** panel (ℹ️ tab)
 | **Output** | Image Viewer, Image Writer, Video Writer, Message Writer, Roboflow Upload |
 | **Logic** | Switch (route on conditions), Gate, Sync, Auto Sync |
 | **Network** | MQTT In / Out, UDP In / Out, TCP In / Out, REST Endpoint, Webhook, mDNS Broadcast / Discovery |
-| **Vision** | YOLO, Inference, Tracker, Supervision Tracker, Crop, Slice Image / Slice Collector, Draw Predictions, Confidence Filter, Label Filter, Merge Predictions, Image Format, Qwen3-VL, vLLM |
+| **Vision** | YOLO, Inference, Crop, Slice Image / Slice Collector, Draw Predictions, Class Map (relabel classes), Confidence Filter, Label Filter, Merge Predictions, Image Format, Qwen3-VL, vLLM |
+| **Supervision** | SV Tracker (ByteTrack), SV Annotate (15 visual styles: boxes, labels, traces, heat maps, privacy blur/pixelate), SV Line Counter (in/out crossing counts + events), SV Polygon Zone (occupancy, enter/exit events) — zone geometry drawn directly on a live frame — SV Smoother (de-jitter boxes), SV Detection Filter (confidence/class/area/aspect/top-K + NMS/NMM), SV Sink (CSV/JSON detection logging) |
 | **Analysis** | BBox Metrics, Polygon Metrics, Point in Shape |
 | **OpenCV** | ~28 image-processing nodes: Blur, Threshold, Morphology, Edge Detector, Find Contours, Perspective, Resize, Rotate, Colormap, Histogram, FFT, Template Match, RealSense Depth, and more |
 | **Node Probes** | Rate Probe, Queue Length Probe, Counter |

{pynode_flow-0.2.6 → pynode_flow-0.2.8}/README.md

@@ -29,7 +29,8 @@ carries its own documentation in the editor's **Information** panel (ℹ️ tab)
 | **Output** | Image Viewer, Image Writer, Video Writer, Message Writer, Roboflow Upload |
 | **Logic** | Switch (route on conditions), Gate, Sync, Auto Sync |
 | **Network** | MQTT In / Out, UDP In / Out, TCP In / Out, REST Endpoint, Webhook, mDNS Broadcast / Discovery |
-| **Vision** | YOLO, Inference, Tracker, Supervision Tracker, Crop, Slice Image / Slice Collector, Draw Predictions, Confidence Filter, Label Filter, Merge Predictions, Image Format, Qwen3-VL, vLLM |
+| **Vision** | YOLO, Inference, Crop, Slice Image / Slice Collector, Draw Predictions, Class Map (relabel classes), Confidence Filter, Label Filter, Merge Predictions, Image Format, Qwen3-VL, vLLM |
+| **Supervision** | SV Tracker (ByteTrack), SV Annotate (15 visual styles: boxes, labels, traces, heat maps, privacy blur/pixelate), SV Line Counter (in/out crossing counts + events), SV Polygon Zone (occupancy, enter/exit events) — zone geometry drawn directly on a live frame — SV Smoother (de-jitter boxes), SV Detection Filter (confidence/class/area/aspect/top-K + NMS/NMM), SV Sink (CSV/JSON detection logging) |
 | **Analysis** | BBox Metrics, Polygon Metrics, Point in Shape |
 | **OpenCV** | ~28 image-processing nodes: Blur, Threshold, Morphology, Edge Detector, Find Contours, Perspective, Resize, Rotate, Colormap, Histogram, FFT, Template Match, RealSense Depth, and more |
 | **Node Probes** | Rate Probe, Queue Length Probe, Counter |

{pynode_flow-0.2.6 → pynode_flow-0.2.8}/pynode/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.2.6'
-__version_tuple__ = version_tuple = (0, 2, 6)
+__version__ = version = '0.2.8'
+__version_tuple__ = version_tuple = (0, 2, 8)
 
-__commit_id__ = commit_id = 'gfd6285bef'
+__commit_id__ = commit_id = 'g7b8eff347'

{pynode_flow-0.2.6 → pynode_flow-0.2.8}/pynode/api/sse.py

@@ -40,7 +40,12 @@ def debug_stream():
                 try:
                     # Wait for data from broadcast thread
                     data = q.get(timeout=1.0)
-                    yield f'data: {json.dumps(data)}\n\n'
+                    # default=str: one non-JSON-serializable value (a numpy
+                    # scalar, a live supervision object, ...) must degrade to
+                    # its repr, not raise - a raise here closes the stream
+                    # that carries ALL live UI updates (debug AND viewer
+                    # frames) for this client.
+                    yield f'data: {json.dumps(data, default=str)}\n\n'
                 except queue.Empty:
                     # Send keepalive
                     yield 'data: {"type": "keepalive"}\n\n'

{pynode_flow-0.2.6 → pynode_flow-0.2.8}/pynode/node_registry.py

@@ -47,6 +47,7 @@ def build_node_types_cache():
         'logic',
         'network',
         'vision',
+        'supervision',
         'analysis',
         'node probes',
         'opencv'

{pynode_flow-0.2.6 → pynode_flow-0.2.8}/pynode/nodes/ChangeNode/change_node.py

@@ -5,7 +5,7 @@ Similar to Node-RED's change node.
 
 import json
 import re
-from typing import Any, Dict
+from typing import Any, Dict, List, Optional, Tuple
 from pynode.nodes.base_node import BaseNode, Info, MessageKeys
 
 _info = Info()
@@ -25,6 +25,18 @@ _info.add_bullets(
     ("Delete:", "Remove a property from the message."),
     ("Move:", "Move a property to a different location."),
 )
+_info.add_header("Lists")
+_info.add_text(
+    "Tick 'is list' on a rule when the property holds a list of objects, and "
+    "give the key to work on. The rule then applies to that key in every item, "
+    "however many there are - for example relabelling each detection:"
+)
+_info.add_code("in msg.payload.detections - is list, key class_name - search 2, replace drone").end()
+_info.add_text(
+    "Search-and-replace works on substrings of text values. A value that is "
+    "not text (a number, a boolean) is replaced only when the search matches "
+    "the whole value, and the replacement keeps the type you selected."
+)
 
 
 class ChangeNode(BaseNode):
@@ -52,6 +64,9 @@ class ChangeNode(BaseNode):
     ui_component = 'change-rules-editor'
     ui_component_config = {
         'operations': ['set', 'change', 'move', 'delete'],
+        # Per-rule list mode: apply the rule to `key` inside every item of the
+        # list at the rule's path (see _rule_targets).
+        'list_fields': ['isList', 'key'],
         'value_types': [
             {'value': 'str', 'label': 'String'},
             {'value': 'num', 'label': 'Number'},
@@ -131,6 +146,87 @@ class ChangeNode(BaseNode):
         
         return False
     
+    def _rule_targets(self, msg: Dict, rule: Dict, path: str) -> List[Tuple[Optional[Dict], str]]:
+        """Work out the places a rule applies to.
+
+        Normally that is one place: the property path itself. With ``isList``
+        set, the path must hold a list, and the rule applies to ``key`` inside
+        every object in it - the way to rewrite a field on all detections
+        without knowing how many there are.
+
+        Args:
+            msg: The message being modified.
+            rule: The rule definition.
+            path: The rule's property path.
+
+        Returns:
+            ``(container, key)`` pairs. ``container`` is None for a plain
+            property path, in which case ``key`` is that path.
+        """
+        if not rule.get('isList', rule.get('is_list', False)):
+            return [(None, path)]
+
+        key = str(rule.get('key', rule.get('itemKey', '')) or '').strip()
+        if not key:
+            self.report_error(f"List rule on {path} needs an item key")
+            return []
+
+        items = self._get_nested_value(msg, path)
+        if not isinstance(items, (list, tuple)):
+            self.report_error(f"List rule on {path}: not a list")
+            return []
+
+        return [(item, key) for item in items if isinstance(item, dict)]
+
+    def _target_get(self, msg: Dict, target: Tuple[Optional[Dict], str]) -> Any:
+        """Read a target - a message path, or a key inside a list item."""
+        container, key = target
+        if container is None:
+            return self._get_nested_value(msg, key)
+        return container.get(key)
+
+    def _target_set(self, msg: Dict, target: Tuple[Optional[Dict], str], value: Any) -> None:
+        """Write a target."""
+        container, key = target
+        if container is None:
+            self._set_nested_value(msg, key, value)
+        else:
+            container[key] = value
+
+    def _target_delete(self, msg: Dict, target: Tuple[Optional[Dict], str]) -> bool:
+        """Remove a target, reporting whether anything was there."""
+        container, key = target
+        if container is None:
+            return self._delete_nested_value(msg, key)
+        if key in container:
+            del container[key]
+            return True
+        return False
+
+    def _apply_change(self, msg: Dict, target: Tuple[Optional[Dict], str],
+                      search: Any, search_type: str,
+                      replacement_text: str, replacement_value: Any) -> None:
+        """Search and replace inside one target.
+
+        Text is replaced by substring (or regex). Anything else - a number, a
+        boolean - has no substring to work on, so it is replaced only when the
+        search matches the whole value, and it takes the typed replacement.
+        """
+        current = self._target_get(msg, target)
+        if current is None:
+            return
+
+        if isinstance(current, str):
+            if search_type == 'regex':
+                try:
+                    self._target_set(msg, target, re.sub(str(search), replacement_text, current))
+                except re.error:
+                    self.report_error(f"Invalid regex pattern: {search}")
+            else:
+                self._target_set(msg, target, current.replace(str(search), replacement_text))
+        elif not isinstance(current, (dict, list, tuple)) and str(current) == str(search):
+            self._target_set(msg, target, replacement_value)
+
     def _resolve_value(self, msg: Dict, value: Any, value_type: str) -> Any:
         """
         Resolve a value based on its type.
@@ -189,6 +285,11 @@ class ChangeNode(BaseNode):
             property_path = rule.get('path', rule.get('p', rule.get('property', f'msg.{MessageKeys.PAYLOAD}')))
             
             try:
+                # One target for a plain path; one per list item in list mode.
+                targets = self._rule_targets(msg, rule, property_path)
+                if not targets:
+                    continue
+
                 if rule_type == 'set':
                     # Set property to a value
                     value = rule.get('value', rule.get('to', ''))
@@ -206,7 +307,8 @@ class ChangeNode(BaseNode):
                     else:
                         resolved_value = self._resolve_value(msg, value, value_type)
                     
-                    self._set_nested_value(msg, property_path, resolved_value)
+                    for target in targets:
+                        self._target_set(msg, target, resolved_value)
                     
                 elif rule_type == 'change':
                     # Search and replace within a property
@@ -215,39 +317,36 @@ class ChangeNode(BaseNode):
                     replace = rule.get('replace', rule.get('to', ''))
                     replace_type = rule.get('replaceType', rule.get('tot', 'str'))
                     
-                    current_value = self._get_nested_value(msg, property_path)
-                    
-                    # Resolve replace value
+                    # Resolve the replacement twice over: the text form drives
+                    # substring and regex replacement, the typed form replaces a
+                    # whole non-text value (see _apply_change).
                     if replace_type == 'path':
-                        replace_value = self._get_nested_value(msg, 'msg.' + str(replace) if not str(replace).startswith('msg.') else replace)
+                        replacement_value = self._get_nested_value(msg, 'msg.' + str(replace) if not str(replace).startswith('msg.') else replace)
                     else:
-                        replace_value = str(replace)
+                        replacement_value = self._resolve_value(msg, replace, replace_type)
+                    replacement_text = str(replacement_value) if replacement_value is not None else ''
                     
-                    if current_value is not None:
-                        if isinstance(current_value, str):
-                            if search_type == 'regex':
-                                try:
-                                    new_value = re.sub(search, str(replace_value) if replace_value else '', current_value)
-                                    self._set_nested_value(msg, property_path, new_value)
-                                except re.error as e:
-                                    self.report_error(f"Invalid regex pattern: {search}")
-                            else:
-                                new_value = current_value.replace(str(search), str(replace_value) if replace_value else '')
-                                self._set_nested_value(msg, property_path, new_value)
+                    for target in targets:
+                        self._apply_change(msg, target, search, search_type,
+                                           replacement_text, replacement_value)
                     
                 elif rule_type == 'delete':
                     # Delete a property
-                    self._delete_nested_value(msg, property_path)
+                    for target in targets:
+                        self._target_delete(msg, target)
                     
                 elif rule_type == 'move':
-                    # Move property to another location
+                    # Move property to another location. In list mode the
+                    # destination is a key inside the same item.
                     to_path = rule.get('toPath', rule.get('to', rule.get('toProperty', '')))
                     
                     if to_path:
-                        current_value = self._get_nested_value(msg, property_path)
-                        if current_value is not None:
-                            self._set_nested_value(msg, to_path, current_value)
-                            self._delete_nested_value(msg, property_path)
+                        for target in targets:
+                            container, _ = target
+                            current_value = self._target_get(msg, target)
+                            if current_value is not None:
+                                self._target_set(msg, (container, to_path), current_value)
+                                self._target_delete(msg, target)
                             
             except Exception as e:
                 self.report_error(f"Error applying rule {rule_type} on {property_path}: {str(e)}")

pynode_flow-0.2.8/pynode/nodes/ClassMapNode/__init__.py

@@ -0,0 +1,3 @@
+from ..ClassMapNode.class_map_node import ClassMapNode
+
+__all__ = ['ClassMapNode']