pynode-flow 0.2.0__py3-none-any.whl

pynode/nodes/RateProbeNode/rate_probe_node.py

@@ -0,0 +1,183 @@
+"""
+Rate Probe Node - monitors message throughput rate.
+Passes messages through while tracking and displaying the rate.
+"""
+
+import time
+from typing import Any, Dict
+from collections import deque
+from pynode.nodes.base_node import BaseNode, Info, MessageKeys
+
+_info = Info()
+_info.add_text("Monitors message throughput rate by counting messages within a time window. Displays the rate on the node and outputs rate information.")
+_info.add_header("Inputs")
+_info.add_bullets(
+    ("Input 0:", "Any message to count")
+)
+_info.add_header("Outputs")
+_info.add_bullets(
+    ("Output 0:", f"Message with rate statistics in {MessageKeys.PAYLOAD}")
+)
+_info.add_header("Configuration")
+_info.add_bullets(
+    ("Window Size:", "Time window in seconds for calculating the rate (default: 1 second)")
+)
+_info.add_header("Output Message")
+_info.add_code(f'{MessageKeys.MSG}.{MessageKeys.PAYLOAD}.rate').text(" - Messages per second as a number").end()
+_info.add_code(f'{MessageKeys.MSG}.{MessageKeys.PAYLOAD}.display').text(" - Human-readable rate string (e.g., '30/s', '2.5k/s')").end()
+_info.add_code(f'{MessageKeys.MSG}.{MessageKeys.PAYLOAD}.message_count').text(" - Number of messages in the current window").end()
+
+
+class RateProbeNode(BaseNode):
+    """
+    Rate Probe node - monitors and displays message rate.
+    Passes all messages through unchanged while tracking throughput.
+    """
+    info = str(_info)
+    display_name = 'Rate Probe'
+    icon = '📊'
+    category = 'node probes'
+    color = '#E2D96E'
+    border_color = '#B8AF4A'
+    text_color = '#000000'
+    input_count = 1
+    output_count = 1
+    ui_component = 'rate-display'
+    ui_component_config = {
+        'format': '{value}/s',
+        'precision': 1
+    }
+
+    api_routes = [
+        {'route': 'rate', 'methods': ['GET'], 'handler': 'get_rate_info'},
+    ]
+
+    sse_handlers = [
+        {'type': 'rate', 'handler': 'get_rate_sse', 'throttle': 0.5},
+    ]
+
+    DEFAULT_CONFIG = {
+        'window_size': 1.0,  # in seconds
+        MessageKeys.DROP_MESSAGES: 'false'
+    }
+
+    properties = [
+        {
+            'name': MessageKeys.DROP_MESSAGES,
+            'label': 'Drop Messages When Busy',
+            'type': 'checkbox',
+            'default': False
+        },
+        {
+            'name': 'window_size',
+            'label': 'Window Size (seconds)',
+            'type': 'number',
+            'default': DEFAULT_CONFIG['window_size'],
+            'help': 'Time window for calculating rate'
+        }
+    ]
+    
+    def __init__(self, node_id=None, name="rate probe"):
+        super().__init__(node_id, name)
+        # Store timestamps of recent messages
+        self._timestamps = deque()
+        self._current_rate = 0.0
+        self._last_update = time.time()
+    
+    def on_input(self, msg: Dict[str, Any], input_index: int = 0):
+        """
+        Pass through the message and update rate calculation.
+        Sends rate information as the payload.
+        """
+        current_time = time.time()
+        window_size = self.get_config_float('window_size', 1.0)
+        
+        # Add current timestamp
+        self._timestamps.append(current_time)
+        
+        # Remove timestamps outside the window
+        cutoff = current_time - window_size
+        while self._timestamps and self._timestamps[0] < cutoff:
+            self._timestamps.popleft()
+        
+        # Calculate rate (messages per second)
+        if window_size > 0:
+            self._current_rate = len(self._timestamps) / window_size
+        else:
+            self._current_rate = 0.0
+        
+        self._last_update = current_time
+        
+        # Preserve original message properties (like frame_count) and add rate info
+        # Note: send() handles deep copying, so we modify msg directly
+        msg[MessageKeys.PAYLOAD] = {
+            'rate': self._current_rate,
+            'display': self.get_rate_display(),
+            'window_size': window_size,
+            'message_count': len(self._timestamps)
+        }
+        msg[MessageKeys.TOPIC] = msg.get(MessageKeys.TOPIC, 'rate')
+        self.send(msg)
+    
+    def get_rate(self) -> float:
+        """Get the current message rate."""
+        current_time = time.time()
+        window_size = self.get_config_float('window_size', 1.0)
+        
+        # Clean up old timestamps
+        cutoff = current_time - window_size
+        while self._timestamps and self._timestamps[0] < cutoff:
+            self._timestamps.popleft()
+        
+        # Recalculate rate
+        if window_size > 0:
+            self._current_rate = len(self._timestamps) / window_size
+        
+        return self._current_rate
+    
+    def get_rate_display(self) -> str:
+        """Get formatted rate string for display."""
+        rate = self.get_rate()
+        if rate >= 1000:
+            # Format as k/s, hide .0 precision
+            formatted = f"{rate/1000:.1f}".rstrip('0').rstrip('.')
+            return f"{formatted}k/s"
+        elif rate >= 1:
+            # Format as /s, hide .0 precision
+            formatted = f"{rate:.1f}".rstrip('0').rstrip('.')
+            return f"{formatted}/s"
+        elif rate > 0:
+            # Below 1/s, show seconds per message
+            interval = 1 / rate
+            if interval >= 60:
+                # Show in minutes
+                minutes = interval / 60
+                formatted = f"{minutes:.1f}".rstrip('0').rstrip('.')
+                return f"{formatted}m/msg"
+            else:
+                # Show in seconds
+                formatted = f"{interval:.1f}".rstrip('0').rstrip('.')
+                return f"{formatted}s/msg"
+        else:
+            return "0/s"
+    
+    def on_stop(self):
+        """Clear timestamps when stopped."""
+        self._timestamps.clear()
+        self._current_rate = 0.0
+        super().on_stop()
+
+    def get_rate_info(self):
+        """API route handler: return rate info as dict."""
+        rate = self.get_rate()
+        return {
+            'rate': rate,
+            'display': self.get_rate_display(),
+        }
+
+    def get_rate_sse(self):
+        """SSE handler: return rate data for broadcast."""
+        return {
+            'display': self.get_rate_display(),
+            'rate': self.get_rate(),
+        }

pynode/nodes/RateProbeNode/requirements.txt

@@ -0,0 +1 @@
+# No external dependencies - uses only Python standard library

pynode/nodes/RoboflowUploadNode/__init__.py

@@ -0,0 +1,3 @@
+from .roboflow_upload_node import RoboflowUploadNode
+
+__all__ = ['RoboflowUploadNode']

pynode/nodes/RoboflowUploadNode/requirements.txt

@@ -0,0 +1 @@
+roboflow>=1.0.0

pynode/nodes/RoboflowUploadNode/roboflow_upload_node.py

@@ -0,0 +1,229 @@
+"""
+Roboflow Upload Node - uploads images to a Roboflow project for annotation.
+"""
+
+import base64
+import logging
+import os
+import tempfile
+import threading
+from datetime import datetime
+from typing import Any, Dict
+import numpy as np
+import cv2
+
+from pynode.nodes.base_node import BaseNode, Info, MessageKeys
+
+logger = logging.getLogger(__name__)
+
+_info = Info()
+_info.add_text("Uploads images to a Roboflow project for annotation and training.")
+_info.add_header("Inputs")
+_info.add_bullets(
+    ("Input 0:", "Message containing an image in any supported format (numpy array, base64 JPEG, camera dict).")
+)
+_info.add_header("Outputs")
+_info.add_bullets(
+    ("Output 0:", "The original message is passed through after upload.")
+)
+_info.add_header("Properties")
+_info.add_bullets(
+    ("API Key:", "Roboflow API key from workspace settings."),
+    ("Workspace ID:", "Roboflow workspace identifier (e.g. my-workspace)."),
+    ("Project ID:", "Roboflow project identifier (e.g. my-project)."),
+    ("Split:", "Which dataset split to upload to (train, valid, or test)."),
+    ("Batch Name:", "Name for the upload batch (optional)."),
+    ("Rate Limit:", "Minimum seconds between uploads (0 = no limit).")
+)
+_info.add_header("Notes")
+_info.add_text("Requires the roboflow package. The node connects to Roboflow when the workflow starts and disconnects when it stops.")
+
+
+class RoboflowUploadNode(BaseNode):
+    """Uploads images to Roboflow for annotation."""
+
+    display_name = 'Roboflow Upload'
+    icon = '\u2B06'
+    category = 'output'
+    color = '#6706CE'
+    border_color = '#4A049A'
+    text_color = '#FFFFFF'
+    input_count = 1
+    output_count = 1
+    info = str(_info)
+
+    DEFAULT_CONFIG = {
+        'api_key': '',
+        'workspace_id': '',
+        'project_id': '',
+        'split': 'train',
+        'batch_name': 'pynode',
+        'rate_limit': 0,
+        MessageKeys.DROP_MESSAGES: True
+    }
+
+    properties = [
+        {
+            'name': 'api_key',
+            'label': 'API Key',
+            'type': 'text',
+            'default': '',
+            'placeholder': 'Your Roboflow API key',
+            'help': 'API key from Roboflow workspace settings'
+        },
+        {
+            'name': 'workspace_id',
+            'label': 'Workspace ID',
+            'type': 'text',
+            'default': '',
+            'placeholder': 'e.g. my-workspace',
+            'help': 'Roboflow workspace identifier'
+        },
+        {
+            'name': 'project_id',
+            'label': 'Project ID',
+            'type': 'text',
+            'default': '',
+            'placeholder': 'e.g. my-project',
+            'help': 'Roboflow project identifier'
+        },
+        {
+            'name': 'split',
+            'label': 'Dataset Split',
+            'type': 'select',
+            'options': [
+                {'value': 'train', 'label': 'Train'},
+                {'value': 'valid', 'label': 'Validation'},
+                {'value': 'test', 'label': 'Test'}
+            ],
+            'default': 'train',
+            'help': 'Which dataset split to upload images to'
+        },
+        {
+            'name': 'batch_name',
+            'label': 'Upload Batch Name',
+            'type': 'text',
+            'default': 'pynode',
+            'placeholder': 'e.g. my-batch',
+            'help': 'Name for the upload batch (optional)'
+        },
+        {
+            'name': 'rate_limit',
+            'label': 'Rate Limit (seconds)',
+            'type': 'number',
+            'default': 0,
+            'min': 0,
+            'help': 'Minimum seconds between uploads (0 = no limit)'
+        },
+        {
+            'name': MessageKeys.DROP_MESSAGES,
+            'label': 'Drop Messages When Busy',
+            'type': 'checkbox',
+            'default': True
+        }
+    ]
+
+    def __init__(self, node_id=None, name="roboflow upload"):
+        super().__init__(node_id, name)
+        self._rf_project = None
+        self._last_upload_time = 0.0
+        self._lock = threading.Lock()
+
+    def on_start(self):
+        """Connect to Roboflow when the workflow starts."""
+        super().on_start()
+        self._connect()
+
+    def on_stop(self):
+        """Disconnect from Roboflow when the workflow stops."""
+        self._rf_project = None
+        super().on_stop()
+
+    def configure(self, config: Dict[str, Any]):
+        """Apply configuration."""
+        super().configure(config)
+
+    def _connect(self):
+        """Establish connection to Roboflow."""
+        api_key = self.config.get('api_key', '').strip()
+        workspace_id = self.config.get('workspace_id', '').strip()
+        project_id = self.config.get('project_id', '').strip()
+
+        if not api_key or not workspace_id or not project_id:
+            self.report_error("Roboflow API Key, Workspace ID, and Project ID are all required")
+            return
+
+        try:
+            from roboflow import Roboflow
+        except ImportError:
+            self.report_error("roboflow package not installed. Install with: pip install roboflow")
+            return
+
+        try:
+            rf = Roboflow(api_key=api_key)
+            workspace = rf.workspace(workspace_id)
+            self._rf_project = workspace.project(project_id)
+            logger.info(f"[RoboflowUploadNode] Connected to {workspace_id}/{project_id}")
+        except Exception as e:
+            self.report_error(f"Roboflow connection failed: {e}")
+            self._rf_project = None
+
+    def on_input(self, msg: Dict[str, Any], input_index: int = 0):
+        """Decode image from message and upload to Roboflow."""
+        if not self._rf_project:
+            self.report_error("Not connected to Roboflow (check configuration)")
+            self.send(msg)
+            return
+
+        # Rate limiting
+        rate_limit = self.get_config_float('rate_limit', 0)
+        if rate_limit > 0:
+            import time
+            now = time.time()
+            with self._lock:
+                if now - self._last_upload_time < rate_limit:
+                    self.send(msg)
+                    return
+                self._last_upload_time = now
+
+        # Extract and decode image
+        payload = msg.get(MessageKeys.PAYLOAD)
+        if payload is None:
+            self.report_error("No payload in message")
+            self.send(msg)
+            return
+
+        image, _ = self.decode_image(payload)
+        if image is None:
+            self.report_error("Could not decode image from message payload")
+            self.send(msg)
+            return
+
+        # Encode to JPEG and write to a temp file (Roboflow SDK requires a file path)
+        timestamp = datetime.utcnow().strftime('%Y%m%d_%H%M%S_%f')[:-3]
+        filename = f"pynode_{timestamp}.jpg"
+        temp_path = os.path.join(tempfile.gettempdir(), filename)
+
+        try:
+            success, buffer = cv2.imencode('.jpg', image, [cv2.IMWRITE_JPEG_QUALITY, 95])
+            if not success:
+                self.report_error("Failed to encode image as JPEG")
+                self.send(msg)
+                return
+
+            with open(temp_path, 'wb') as f:
+                f.write(buffer.tobytes())
+
+            batch_name = self.config.get('batch_name', '').strip() or None
+            self._rf_project.upload(temp_path, batch_name=batch_name)
+
+        except Exception as e:
+            self.report_error(f"Roboflow upload failed: {e}")
+        finally:
+            try:
+                if os.path.exists(temp_path):
+                    os.remove(temp_path)
+            except Exception:
+                pass
+
+        self.send(msg)

pynode/nodes/SliceNode/README.md

@@ -0,0 +1,149 @@
+# Slice Node - SAHI-style Image Tiling
+
+This module provides nodes for slicing large images into tiles for improved small object detection, based on the SAHI (Slicing Aided Hyper Inference) methodology.
+
+## Nodes
+
+### SliceImageNode
+
+Divides images into overlapping tiles for better detection of small objects in large images.
+
+**Properties:**
+- **Output Mode**: 
+  - `Array`: All slices in one message (use with Split node)
+  - `Split`: Separate message per slice (direct to detector)
+- **Auto Slice Resolution**: Automatically calculate slice parameters based on image size
+- **Slice Width/Height**: Size of each tile in pixels (default: 640x640)
+- **Overlap Width/Height Ratio**: Fractional overlap between tiles (default: 0.2 = 20%)
+- **Include Full Image**: Whether to include the original image at full scale in output (for dual-scale detection)
+
+**Output Format (Array mode):**
+```json
+{
+  "payload": {
+    "slices": [
+      {
+        "image": "<encoded_image>",
+        "offset": [x, y],
+        "bbox": [x1, y1, x2, y2],
+        "slice_index": 0,
+        "is_full_image": true/false,
+        "original_width": 1920,
+        "original_height": 1080
+      }
+    ],
+    "slice_count": 5,
+    "original_width": 1920,
+    "original_height": 1080
+  }
+}
+```
+
+**Output Format (Split mode):**
+Each slice sent as separate message with `parts` metadata for collection:
+```json
+{
+  "payload": {
+    "image": "<encoded_image>",
+    "offset": [x, y],
+    ...
+  },
+  "parts": {
+    "index": 0,
+    "count": 5,
+    "id": "<parent_msg_id>"
+  },
+  "slice_offset": [x, y],
+  "is_full_image": false
+}
+```
+
+### SliceCollectorNode
+
+Collects detection predictions from multiple image slices and merges them into a single unified result.
+
+**Properties:**
+- **Collection Timeout**: Maximum time to wait for all slices (default: 5 seconds)
+- **NMS IoU Threshold**: IoU threshold for Non-Maximum Suppression (default: 0.5)
+- **Match Metric**: `IoU` or `IoS` (Intersection over Smaller)
+- **Class Agnostic NMS**: Whether to apply NMS across all classes or per-class
+
+**Features:**
+- Transforms slice-local coordinates to original image coordinates
+- Applies NMS to remove duplicate detections from overlapping regions
+- Handles full image detections separately and merges with slice detections
+- Tracks collections by message ID for concurrent processing
+
+### MergeSlicePredictionsNode
+
+Alternative merge node that expects predictions already collected in a single message.
+
+## Workflow Examples
+
+### Workflow 1: Split Mode (Recommended)
+
+```
+[Camera] → [SliceImage (split)] → [YOLO] → [SliceCollector] → [Output]
+```
+
+1. SliceImageNode in "Split" mode sends each tile as a separate message
+2. YOLO processes each tile
+3. SliceCollectorNode collects all predictions and merges them
+
+### Workflow 2: Array Mode
+
+```
+[Camera] → [SliceImage (array)] → [Split] → [YOLO] → [SliceCollector] → [Output]
+```
+
+1. SliceImageNode outputs all tiles in an array
+2. Split node separates them into individual messages
+3. YOLO processes each tile
+4. SliceCollectorNode collects and merges
+
+### Workflow 3: Batch Processing
+
+```
+[Camera] → [SliceImage (array)] → [Custom Processing]
+```
+
+Process all slices together in a custom node that can handle arrays.
+
+## SAHI Methodology
+
+The Slicing Aided Hyper Inference approach:
+
+1. **Slice**: Divide large image into smaller overlapping tiles
+2. **Detect**: Run object detection on each tile
+3. **Transform**: Convert tile-local coordinates to original image coordinates
+4. **Merge**: Apply NMS to remove duplicates from overlapping regions
+
+### Why Include Full Image?
+
+Running detection on both tiles AND the full image provides:
+- Tiles: Better detection of small objects
+- Full image: Better detection of large objects that may be split across tiles
+
+The merge step combines both for comprehensive detection.
+
+## Configuration Tips
+
+### Tile Size
+- Match your detector's training resolution (e.g., 640x640 for YOLO)
+- Smaller tiles = more tiles but better small object detection
+- Larger tiles = fewer tiles but may miss small objects
+
+### Overlap Ratio
+- 0.2 (20%) is a good default
+- Increase for dense scenes with many small objects
+- Decrease for faster processing with fewer duplicates
+
+### NMS Threshold
+- 0.5 is a good default
+- Lower = more aggressive duplicate removal
+- Higher = keep more detections (may have duplicates)
+
+## Dependencies
+
+- OpenCV (cv2)
+- NumPy

pynode/nodes/SliceNode/__init__.py

@@ -0,0 +1,5 @@
+from .slice_image_node import SliceImageNode
+from .merge_predictions_node import MergeSlicePredictionsNode
+from .slice_collector_node import SliceCollectorNode
+
+__all__ = ['SliceImageNode', 'MergeSlicePredictionsNode', 'SliceCollectorNode']