pynode-flow 0.2.5__tar.gz → 0.2.7__tar.gz

{pynode_flow-0.2.5 → pynode_flow-0.2.7}/.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.5 → pynode_flow-0.2.7}/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.5 → pynode_flow-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pynode-flow
-Version: 0.2.5
+Version: 0.2.7
 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, 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.5 → pynode_flow-0.2.7}/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, 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.5 → pynode_flow-0.2.7}/pynode/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.2.5'
-__version_tuple__ = version_tuple = (0, 2, 5)
+__version__ = version = '0.2.7'
+__version_tuple__ = version_tuple = (0, 2, 7)
 
-__commit_id__ = commit_id = 'g5581f8362'
+__commit_id__ = commit_id = 'g6f8c52570'

{pynode_flow-0.2.5 → pynode_flow-0.2.7}/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.5 → pynode_flow-0.2.7}/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.5 → pynode_flow-0.2.7}/pynode/nodes/DebugNode/debug_node.py

@@ -112,13 +112,24 @@ class DebugNode(BaseNode):
                 return f"<numpy array, shape={val.shape}, dtype={val.dtype}>"
             elif isinstance(val, dict):
                 return {k: truncate_values(v, maxlen) for k, v in val.items()}
-            elif isinstance(val, list):
+            elif isinstance(val, (list, tuple)):
                 return [truncate_values(v, maxlen) for v in val]
+            elif isinstance(val, (np.integer, np.floating, np.bool_)):
+                # numpy scalars are not JSON serializable
+                return val.item()
+            elif isinstance(val, str) or val is None or isinstance(val, (int, float, bool)):
+                if isinstance(val, str) and len(val) > maxlen:
+                    return val[:maxlen] + f"... [truncated, {len(val)} chars]"
+                return val
             else:
+                # Any other live object (e.g. a supervision Detections at
+                # payload.sv) must be stringified: a raw object stored here
+                # poisons json.dumps for the debug API AND kills the shared
+                # SSE stream that also carries image-viewer frames.
                 s = str(val)
                 if len(s) > maxlen:
                     return s[:maxlen] + f"... [truncated, {len(s)} chars]"
-                return val
+                return s
 
         display_output = truncate_values(output)
 

{pynode_flow-0.2.5 → pynode_flow-0.2.7}/pynode/nodes/ImageUploadNode/image_upload_node.py

@@ -31,6 +31,13 @@ _info.add_bullets(
     ("Repeat Rate (fps):", "How many times per second to re-send (e.g. 1 = "
                            "once per second, 20 = 20 fps)."),
 )
+_info.add_header("Send Now")
+_info.add_bullets(
+    ("Send button:", "Click the button on the node to send the uploaded "
+                     "image on demand. Set Repeat Rate to 0 (or leave Repeat "
+                     "Send off) and trigger the image through your flow "
+                     "whenever you want."),
+)
 _info.add_header("Outputs")
 _info.add_bullets(
     ("Output 0:", "Message with the uploaded image in payload. Emitted once "
@@ -54,8 +61,13 @@ class ImageUploadNode(BaseNode):
     ui_component = 'image-drop'
     ui_component_config = {
         'tooltip': 'Drop an image here',
+        'send_action': 'send_now',
+        'send_tooltip': 'Send uploaded image',
     }
 
+    # UI-triggerable actions (see BaseNode.actions)
+    actions = ['send_now']
+
     DEFAULT_CONFIG = {
         'repeat_send': False,
         'repeat_rate': 10,
@@ -121,6 +133,15 @@ class ImageUploadNode(BaseNode):
         if msg is not None:
             self.send(msg)
 
+    def send_now(self):
+        """UI action: send the currently uploaded image on demand.
+
+        Lets a user trigger the image through their flow whenever they click
+        the button, independent of Repeat Send.
+        """
+        self._send_once()
+        return {'sent': self._image_data is not None}
+
     def receive_image(self, image_bytes: bytes, filename: str = ""):
         """
         Called by the server when an image is uploaded to this node.

pynode_flow-0.2.7/pynode/nodes/InferenceNode/InferenceEngine/device_detection.py

@@ -0,0 +1,314 @@
+"""OpenVINO device detection and device-string translation helpers.
+
+This module must stay importable when openvino (and ultralytics/torch) are
+NOT installed: enumeration is attempted lazily on first use and falls back to
+a static device list when openvino is unavailable or enumeration fails.
+
+Device naming background:
+
+- ``openvino.Core().available_devices`` returns names like
+  ``['CPU', 'GPU', 'NPU']`` (single GPU) or ``['CPU', 'GPU.0', 'GPU.1']``
+  (multiple GPUs).
+- PyNode/Ultralytics config values use the ``intel:<device>`` form
+  (``intel:gpu``, ``intel:gpu.1`` ...). Ultralytics strips the ``intel:``
+  prefix and passes the uppercased remainder to OpenVINO, so on a multi-GPU
+  system a plain ``intel:gpu`` becomes ``GPU`` which is NOT in
+  ``available_devices`` and Ultralytics silently falls back to ``AUTO``.
+  :func:`resolve_intel_device` fixes that by resolving ``intel:gpu`` to the
+  first detected Intel GPU (e.g. ``intel:gpu.0``).
+- The GPU plugin enumerates every OpenCL-capable GPU, including non-Intel
+  ones it cannot compile models for (an NVIDIA card can appear as
+  ``GPU.1`` -> ``NVIDIA TITAN RTX (dGPU)``), so GPU entries are filtered by
+  their ``FULL_DEVICE_NAME`` before being offered as OpenVINO targets.
+
+Workflows carry the device string of the machine they were built on, which
+may not exist after a hardware change or an export/import.
+:func:`validate_device` checks a configured device against the hardware
+actually present and returns the closest usable substitute plus a warning.
+"""
+
+import logging
+from typing import Dict, List, Optional, Tuple
+
+logger = logging.getLogger(__name__)
+
+# Static fallback used when openvino is not importable or enumeration fails.
+# It mirrors the historical hardcoded dropdown (CPU/GPU/NPU) so behavior is
+# unchanged on systems without openvino.
+FALLBACK_DEVICES: List[str] = ['CPU', 'GPU', 'NPU']
+
+# Cache: (devices, detected). ``detected`` is False when the fallback list is
+# in use. Enumeration can be slow, so it runs once (lazily) per process.
+_device_cache: Optional[Tuple[List[str], bool]] = None
+
+# FULL_DEVICE_NAME per enumerated device (e.g. 'GPU.0' -> 'Intel(R) UHD
+# Graphics 770 (iGPU)'). Populated alongside _device_cache; empty when names
+# could not be queried or the fallback list is in use.
+_device_names: Dict[str, str] = {}
+
+
+def _enumerate_openvino_devices() -> Optional[Tuple[List[str], Dict[str, str]]]:
+    """Return ``(devices, names)`` from OpenVINO, or None if unavailable."""
+    try:
+        from openvino import Core  # type: ignore
+    except ImportError:
+        try:
+            # Older openvino releases expose Core under openvino.runtime
+            from openvino.runtime import Core  # type: ignore
+        except ImportError:
+            return None
+    try:
+        core = Core()
+        devices = list(core.available_devices)
+    except Exception as e:
+        logger.warning(f"OpenVINO device enumeration failed: {e}")
+        return None
+    names: Dict[str, str] = {}
+    for device in devices:
+        try:
+            names[device] = str(core.get_property(device, 'FULL_DEVICE_NAME'))
+        except Exception:
+            pass
+    return devices, names
+
+
+def get_openvino_devices(refresh: bool = False) -> Tuple[List[str], bool]:
+    """Return ``(devices, detected)``.
+
+    ``devices`` is e.g. ``['CPU', 'GPU.0', 'GPU.1']`` when openvino is
+    available, otherwise :data:`FALLBACK_DEVICES`. ``detected`` says whether
+    real enumeration succeeded. The result is cached after the first call.
+    """
+    global _device_cache, _device_names
+    if refresh or _device_cache is None:
+        result = _enumerate_openvino_devices()
+        if result and result[0]:
+            devices, names = result
+            _device_cache = (devices, True)
+            _device_names = names
+        else:
+            _device_cache = (list(FALLBACK_DEVICES), False)
+            _device_names = {}
+    devices, detected = _device_cache
+    return list(devices), detected
+
+
+def get_openvino_device_names() -> Dict[str, str]:
+    """Return FULL_DEVICE_NAME per device (may be empty), e.g.
+    ``{'GPU.0': 'Intel(R) UHD Graphics 770 (iGPU)'}``."""
+    get_openvino_devices()  # ensure enumeration has been attempted
+    return dict(_device_names)
+
+
+def _gpu_devices(devices: List[str]) -> List[str]:
+    """Filter GPU entries ('GPU', 'GPU.0', ...) preserving enumeration order."""
+    return [d for d in devices if d == 'GPU' or d.startswith('GPU.')]
+
+
+def _intel_gpu_devices(devices: List[str]) -> List[str]:
+    """GPU entries that are actually Intel GPUs.
+
+    OpenVINO's GPU plugin enumerates every OpenCL GPU, so on a machine with
+    an NVIDIA card ``available_devices`` can contain e.g. ``GPU.1`` ->
+    ``NVIDIA TITAN RTX (dGPU)`` even though the plugin cannot compile models
+    for it. Devices whose FULL_DEVICE_NAME is unknown are kept (older
+    openvino releases and the static fallback list carry no names).
+    """
+    names = get_openvino_device_names()
+    intel_gpus = []
+    for device in _gpu_devices(devices):
+        name = names.get(device)
+        if name is None or 'intel' in name.lower():
+            intel_gpus.append(device)
+    return intel_gpus
+
+
+def get_cuda_devices() -> List[str]:
+    """Return ``['cuda:0', ...]`` via torch, or ``[]`` when torch is missing,
+    is a CPU-only build, or no NVIDIA GPU is present."""
+    try:
+        import torch  # type: ignore
+    except ImportError:
+        return []
+    try:
+        if not torch.cuda.is_available():
+            return []
+        return [f'cuda:{i}' for i in range(torch.cuda.device_count())]
+    except Exception as e:
+        logger.warning(f"CUDA device enumeration failed: {e}")
+        return []
+
+
+def get_intel_device_options() -> List[Dict[str, str]]:
+    """Build the Intel OpenVINO entries for the hardware dropdown.
+
+    - Intel CPU is always offered.
+    - One entry per detected Intel GPU (non-Intel GPUs that OpenVINO merely
+      enumerates via OpenCL are excluded); if there is exactly one GPU the
+      label has no index. Values keep the device suffix (``intel:gpu.0``
+      etc.) and labels carry the FULL_DEVICE_NAME when known.
+    - NPU is offered only when present in the device list (the static
+      fallback list includes it, preserving the old dropdown when openvino
+      is not installed).
+    """
+    devices, _detected = get_openvino_devices()
+    names = get_openvino_device_names()
+
+    options: List[Dict[str, str]] = [
+        {'value': 'intel:cpu', 'label': 'Intel CPU (OpenVINO)'},
+    ]
+
+    gpus = _intel_gpu_devices(devices)
+    for gpu in gpus:
+        if len(gpus) == 1:
+            label = 'Intel GPU (OpenVINO)'
+        elif '.' in gpu:
+            label = f'Intel GPU {gpu.split(".", 1)[1]} (OpenVINO)'
+        else:
+            label = 'Intel GPU (OpenVINO)'
+        if names.get(gpu):
+            label = f'{label} - {names[gpu]}'
+        options.append({
+            'value': f'intel:{gpu.lower()}',
+            'label': label,
+        })
+
+    if any(d == 'NPU' or d.startswith('NPU.') for d in devices):
+        options.append({'value': 'intel:npu', 'label': 'Intel NPU (OpenVINO)'})
+
+    return options
+
+
+def resolve_intel_device(device: str) -> str:
+    """Resolve a plain ``intel:gpu`` to the first detected GPU.
+
+    ``intel:gpu`` (any case) becomes e.g. ``intel:gpu.0`` on multi-GPU
+    systems so the exact device - not AUTO - is targeted. Anything else
+    (``intel:gpu.1``, ``intel:cpu``, ``cuda:0``, ``cpu`` ...) is returned
+    unchanged, and when detection is unavailable the input is returned as-is
+    (backward compatible with saved workflows on systems without openvino).
+    """
+    if not isinstance(device, str) or device.lower() != 'intel:gpu':
+        return device
+
+    devices, detected = get_openvino_devices()
+    if not detected:
+        return device
+
+    gpus = _intel_gpu_devices(devices)
+    if not gpus:
+        return device
+    return f'intel:{gpus[0].lower()}'
+
+
+def validate_device(device: str) -> Tuple[str, Optional[str]]:
+    """Check a configured device against the hardware present on THIS machine.
+
+    Saved workflows carry device strings from whatever machine they were
+    built on; after a hardware change or an export/import the configured
+    device may simply not exist here. Returns ``(usable_device, warning)``:
+    ``warning`` is None when the device is usable as-is (modulo the plain
+    ``intel:gpu`` -> ``intel:gpu.N`` resolution). When it is not, the closest
+    present device is substituted - another Intel GPU if one exists, else the
+    first CUDA GPU, else CPU - and the warning explains the switch so the
+    user can fix the config. Devices that cannot be verified (openvino not
+    installed, unrecognized strings) are returned unchanged.
+    """
+    if not isinstance(device, str) or not device:
+        return device, None
+    lower = device.lower()
+
+    if lower in ('cpu', 'intel:cpu'):
+        return device, None
+
+    if lower.startswith('cuda') or lower.isdigit():
+        cuda_devices = get_cuda_devices()
+        if not cuda_devices:
+            try:
+                import torch  # type: ignore  # noqa: F401
+                reason = ('CUDA is not available - no NVIDIA GPU, or a '
+                          'CPU-only PyTorch build is installed')
+            except ImportError:
+                reason = 'PyTorch is not installed'
+            return 'cpu', (f"Configured device '{device}' is not usable "
+                           f"({reason}). Falling back to 'cpu'.")
+        index = 0
+        if lower.isdigit():
+            index = int(lower)
+        elif ':' in lower:
+            try:
+                index = int(lower.split(':', 1)[1])
+            except ValueError:
+                index = 0
+        if index >= len(cuda_devices):
+            return cuda_devices[0], (
+                f"Configured device '{device}' not found (only "
+                f"{len(cuda_devices)} CUDA device(s) present). Using "
+                f"'{cuda_devices[0]}' instead.")
+        return device, None
+
+    if lower.startswith('intel:'):
+        devices, detected = get_openvino_devices()
+        if not detected:
+            # Cannot verify without openvino enumeration; keep the existing
+            # pass-through behavior for saved workflows.
+            return device, None
+        target = lower.split(':', 1)[1].upper()
+
+        if target == 'GPU' or target.startswith('GPU.'):
+            gpus = _intel_gpu_devices(devices)
+            if target in gpus:
+                return device, None
+            if target == 'GPU' and gpus:
+                # Plain 'intel:gpu' -> first Intel GPU (not a hardware change)
+                return f'intel:{gpus[0].lower()}', None
+            if gpus:
+                substitute = f'intel:{gpus[0].lower()}'
+                names = get_openvino_device_names()
+                extra = ''
+                if target in _gpu_devices(devices) and names.get(target):
+                    # The index exists but points at a non-Intel OpenCL GPU
+                    extra = (f" ('{target}' is {names[target]}, which "
+                             "OpenVINO cannot target)")
+                return substitute, (
+                    f"Configured device '{device}' is not available on this "
+                    f"machine{extra}. Using '{substitute}' instead.")
+            fallback = _fallback_device()
+            return fallback, (
+                f"Configured device '{device}' is not available on this "
+                f"machine (no Intel GPU detected by OpenVINO). Falling back "
+                f"to '{fallback}'.")
+
+        if target == 'NPU' or target.startswith('NPU.'):
+            if any(d == 'NPU' or d.startswith('NPU.') for d in devices):
+                return device, None
+            fallback = _fallback_device()
+            return fallback, (
+                f"Configured device '{device}' is not available on this "
+                f"machine (no Intel NPU detected). Falling back to "
+                f"'{fallback}'.")
+
+        return device, None
+
+    return device, None
+
+
+def _fallback_device() -> str:
+    """Best present device to substitute for an absent one: the first CUDA
+    GPU when torch can use one, otherwise CPU."""
+    cuda_devices = get_cuda_devices()
+    return cuda_devices[0] if cuda_devices else 'cpu'
+
+
+def to_openvino_device_name(device: str) -> str:
+    """Translate a config value to the OpenVINO device name Ultralytics uses.
+
+    ``intel:gpu.1`` -> ``GPU.1``; ``intel:gpu`` -> first detected GPU (e.g.
+    ``GPU.0``) or ``GPU`` when detection is unavailable; non-``intel:``
+    values are just uppercased (matching Ultralytics' behavior of
+    ``device.split(':')[1].upper()``).
+    """
+    resolved = resolve_intel_device(device)
+    if isinstance(resolved, str) and resolved.lower().startswith('intel:'):
+        return resolved.split(':', 1)[1].upper()
+    return str(resolved).upper()

{pynode_flow-0.2.5 → pynode_flow-0.2.7}/pynode/nodes/InferenceNode/InferenceEngine/engines/ultralytics_engine.py

@@ -31,13 +31,16 @@ except ImportError:
         from base_engine import BaseInferenceEngine
 
 try:
-    from ..device_detection import resolve_intel_device, to_openvino_device_name
+    from ..device_detection import (
+        resolve_intel_device, to_openvino_device_name, validate_device)
 except ImportError:
     try:
-        from InferenceEngine.device_detection import resolve_intel_device, to_openvino_device_name
+        from InferenceEngine.device_detection import (
+            resolve_intel_device, to_openvino_device_name, validate_device)
     except ImportError:
         # Standalone: inference_engine_dir was inserted into sys.path above
-        from device_detection import resolve_intel_device, to_openvino_device_name
+        from device_detection import (
+            resolve_intel_device, to_openvino_device_name, validate_device)
 
 
 from ultralytics import YOLO
@@ -133,10 +136,13 @@ class UltralyticsEngine(BaseInferenceEngine):
         if device is None:
             device = self.device
 
-        # Resolve a plain 'intel:gpu' (e.g. from saved workflow configs) to the
-        # first detected GPU ('intel:gpu.0') so multi-GPU systems target a real
-        # OpenVINO device instead of the nonexistent 'GPU' -> AUTO fallback.
-        device = resolve_intel_device(device)
+        # Resolve a plain 'intel:gpu' to the first detected Intel GPU and swap
+        # devices that are not present on this machine (hardware change, or a
+        # workflow imported from another machine) for the closest present one.
+        device, device_warning = validate_device(device)
+        if device_warning:
+            logger.warning(device_warning)
+            self.use_openvino = device.lower().startswith('intel:')
 
         if model_file is None:
             model_file = self.model_path

{pynode_flow-0.2.5 → pynode_flow-0.2.7}/pynode/nodes/InferenceNode/inference_node.py

@@ -226,6 +226,9 @@ class InferenceNode(BaseNode):
         self._current_engine_type = None
         self._current_model_path = None
         self._current_device = None
+        # Device actually in use after hardware validation (may differ from
+        # the configured device when that hardware is absent on this machine)
+        self._active_device = None
     
     def _get_engine_factory(self):
         """Get the inference engine factory (lazy import)."""
@@ -267,30 +270,46 @@ class InferenceNode(BaseNode):
         factory = self._get_engine_factory()
         if factory is None:
             return False
-        
+
+        # Validate the configured device against hardware actually present
+        # (saved workflows can reference devices from another machine)
+        active_device = device
+        try:
+            from pynode.nodes.InferenceNode.InferenceEngine.device_detection import (
+                validate_device,
+            )
+            active_device, device_warning = validate_device(device)
+            if device_warning:
+                logger.warning(device_warning)
+                self.report_error(device_warning)
+        except Exception as e:
+            logger.warning(f"Device validation failed: {e}")
+
         try:
             # Create the engine instance
-            logger.info(f"Creating {engine_type} engine with model: {model_path}, device: {device}")
+            logger.info(f"Creating {engine_type} engine with model: {model_path}, device: {active_device}")
             self.engine = factory.create(
                 engine_type=engine_type,
                 model_path=model_path,
-                device=device
+                device=active_device
             )
-            
+
             # Load the model
-            if not self.engine.load(model_path, device):
+            if not self.engine.load(model_path, active_device):
                 self.report_error(f"Failed to load model: {model_path}")
                 self.engine = None
                 self._engine_loaded = False
                 return False
             
-            # Update state
+            # Update state (_current_device stays the CONFIGURED value so the
+            # needs_reload comparison against config doesn't churn)
             self._engine_loaded = True
             self._current_engine_type = engine_type
             self._current_model_path = model_path
             self._current_device = device
-            
-            logger.info(f"Successfully loaded {engine_type} engine on {device}")
+            self._active_device = active_device
+
+            logger.info(f"Successfully loaded {engine_type} engine on {active_device}")
             return True
             
         except Exception as e:
@@ -422,7 +441,7 @@ class InferenceNode(BaseNode):
             
             # Add engine info to payload
             payload_out['engine_type'] = self._current_engine_type
-            payload_out['device'] = self._current_device
+            payload_out['device'] = self._active_device or self._current_device
             
             # Preserve original message properties and update payload
             msg[MessageKeys.PAYLOAD] = payload_out

{pynode_flow-0.2.5 → pynode_flow-0.2.7}/pynode/nodes/Qwen3VLMNode/qwen3_vlm_node.py

@@ -222,7 +222,20 @@ class Qwen3VLMNode(BaseNode):
             return True
 
         model_name = self.config.get("model_name", "Qwen/Qwen3-VL-2B-Instruct")
+        # Validate against hardware actually present: a workflow saved on a
+        # machine with more (or different) GPUs would otherwise hand an
+        # absent device straight to device_map and fail on load.
         device = self.config.get("device", "cpu")
+        try:
+            from pynode.nodes.InferenceNode.InferenceEngine.device_detection import (
+                validate_device,
+            )
+            device, device_warning = validate_device(device)
+            if device_warning:
+                logger.warning(device_warning)
+                self.report_error(device_warning)
+        except Exception as exc:  # pragma: no cover - defensive
+            logger.warning("Device validation failed: %s", exc)
 
         token = self.config.get("hf_token", "").strip() or None