pynode-flow 0.2.0__py3-none-any.whl

pynode/nodes/DelayNode/delay_node.py

@@ -0,0 +1,218 @@
+"""
+Delay node - delays message delivery.
+Similar to Node-RED's delay node.
+"""
+
+import time
+import threading
+from collections import deque
+from typing import Any, Dict
+from pynode.nodes.base_node import BaseNode, Info, MessageKeys
+
+_info = Info()
+_info.add_text("Delays or rate-limits message delivery. Similar to Node-RED's delay node.")
+_info.add_header("Input")
+_info.add_bullets(
+    ("msg:", "Any message to be delayed or rate-limited."),
+)
+_info.add_header("Output")
+_info.add_bullets(
+    ("msg:", "The original message after the configured delay."),
+)
+_info.add_header("Modes")
+_info.add_bullets(
+    ("Delay each message:", "Hold each message for a fixed time before sending."),
+    ("Delay by message count:", "Release messages after N more messages arrive."),
+    ("Rate limit:", "Limit throughput to N messages per time period."),
+)
+_info.add_header("Properties")
+_info.add_bullets(
+    ("Delay (seconds):", "Time to delay each message."),
+    ("Delay (messages):", "Number of messages to buffer before releasing."),
+    ("Rate/Time:", "Messages per time period for rate limiting."),
+    ("Intermediate Messages:", "Drop or queue messages during rate limiting."),
+)
+
+
+class DelayNode(BaseNode):
+    """
+    Delay node - delays message delivery (non-blocking).
+    Similar to Node-RED's delay node.
+    """
+    info = str(_info)
+    display_name = 'Delay'
+    icon = '⧗'
+    category = 'function'
+    color = '#E6E0F8'
+    border_color = '#9F93C6'
+    text_color = '#000000'
+    input_count = 1
+    output_count = 1
+    
+    DEFAULT_CONFIG = {
+        'mode': 'delay',
+        'timeout': 0,
+        'delay_count': 1,
+        'rate': 1,
+        'rate_time': 1,
+        'rate_drop': 'drop',
+        'drop_messages': False
+    }
+    
+    properties = [
+        {
+            'name': 'mode',
+            'label': 'Mode',
+            'type': 'select',
+            'options': [
+                {'value': 'delay', 'label': 'Delay each message'},
+                {'value': 'delay_count', 'label': 'Delay by message count'},
+                {'value': 'rate', 'label': 'Rate limit'}
+            ]
+        },
+        {
+            'name': 'timeout',
+            'label': 'Delay (seconds)',
+            'type': 'number',
+            'default': DEFAULT_CONFIG['timeout'],
+            'help': 'Delay time in seconds (for time-based delay)',
+            'showIf': {'mode': ['delay']}
+        },
+        {
+            'name': 'delay_count',
+            'label': 'Delay (messages)',
+            'type': 'number',
+            'default': DEFAULT_CONFIG['delay_count'],
+            'min': 1,
+            'help': 'Number of messages to delay by (for count-based delay)',
+            'showIf': {'mode': 'delay_count'}
+        },
+        {
+            'name': 'rate',
+            'label': 'Rate Limit (count)',
+            'type': 'number',
+            'default': DEFAULT_CONFIG['rate'],
+            'showIf': {'mode': 'rate'}
+        },
+        {
+            'name': 'rate_time',
+            'label': 'Per Time (seconds)',
+            'type': 'number',
+            'default': DEFAULT_CONFIG['rate_time'],
+            'showIf': {'mode': 'rate'}
+        },
+        {
+            'name': 'rate_drop',
+            'label': 'Intermediate Messages',
+            'type': 'select',
+            'options': [
+                {'value': 'drop', 'label': 'Drop'},
+                {'value': 'queue', 'label': 'Queue'}
+            ],
+            'showIf': {'mode': 'rate'}
+        }
+    ]
+    
+    def __init__(self, node_id=None, name="delay"):
+        super().__init__(node_id, name)
+        self.last_send_time = 0
+        self.queued_messages = []
+        self.processing_queue = False
+        self.queue_lock = threading.Lock()
+        # Buffer for count-based delay
+        self._message_buffer: deque = deque()
+    
+    def on_start(self):
+        """Initialize on start."""
+        super().on_start()
+        self._message_buffer.clear()
+    
+    def on_input(self, msg: Dict[str, Any], input_index: int = 0):
+        """
+        Handle message based on mode: delay each message, delay by count, or rate limit.
+        """
+        mode = self.config.get('mode', 'delay')
+        
+        if mode == 'delay':
+            # Delay each message by time
+            timeout = self.get_config_float('timeout', 1)
+            timer = threading.Timer(timeout, self.send, args=(msg,))
+            timer.daemon = True
+            timer.start()
+        elif mode == 'delay_count':
+            # Delay by message count
+            self._delay_by_count(msg)
+        else:
+            # Rate limiting mode
+            self._rate_limit(msg)
+    
+    def _delay_by_count(self, msg: Dict[str, Any]):
+        """
+        Delay messages by a number of messages.
+        Each message is released after N more messages have arrived.
+        """
+        delay_count = self.get_config_int('delay_count', 1)
+        
+        # Add message to buffer
+        self._message_buffer.append(msg)
+        
+        # If buffer has more messages than delay count, release the oldest
+        while len(self._message_buffer) > delay_count:
+            oldest_msg = self._message_buffer.popleft()
+            self.send(oldest_msg)
+    
+    def _rate_limit(self, msg: Dict[str, Any]):
+        """
+        Rate limit messages - only send at specified rate.
+        """
+        rate = self.get_config_int('rate', 1)
+        rate_time = self.get_config_float('rate_time', 1)
+        rate_drop = self.config.get('rate_drop', 'drop')
+        
+        # Calculate interval: time / count
+        interval = rate_time / rate
+        
+        with self.queue_lock:
+            current_time = time.time()
+            time_since_last = current_time - self.last_send_time
+            
+            if time_since_last >= interval and not self.queued_messages:
+                # Enough time has passed and no queue, send immediately
+                self.send(msg)
+                self.last_send_time = current_time
+            else:
+                # Too soon or queue exists, handle based on drop/queue setting
+                if rate_drop == 'queue':
+                    self.queued_messages.append(msg)
+                    # Start processing queue if not already running
+                    if not self.processing_queue:
+                        self.processing_queue = True
+                        delay = max(0, interval - time_since_last)
+                        timer = threading.Timer(delay, self._process_queued)
+                        timer.daemon = True
+                        timer.start()
+                # else: drop (do nothing)
+    
+    def _process_queued(self):
+        """Process next queued message if available."""
+        with self.queue_lock:
+            if not self.queued_messages:
+                self.processing_queue = False
+                return
+            
+            msg = self.queued_messages.pop(0)
+            current_time = time.time()
+            self.send(msg)
+            self.last_send_time = current_time
+            
+            # Schedule next message if queue not empty
+            if self.queued_messages:
+                rate = self.get_config_int('rate', 1)
+                rate_time = self.get_config_float('rate_time', 1)
+                interval = rate_time / rate
+                
+                timer = threading.Timer(interval, self._process_queued)
+                timer.daemon = True
+                timer.start()
+            else:
+                self.processing_queue = False

pynode/nodes/DelayNode/requirements.txt

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

pynode/nodes/DrawPredictionsNode/__init__.py

@@ -0,0 +1,3 @@
+from ..DrawPredictionsNode.draw_predictions_node import DrawPredictionsNode
+
+__all__ = ['DrawPredictionsNode']

pynode/nodes/DrawPredictionsNode/draw_predictions_node.py

@@ -0,0 +1,365 @@
+"""
+Draw Predictions Node - draws detection predictions (bounding boxes, labels) on images.
+Takes predictions from UltralyticsNode and original image, outputs annotated image.
+"""
+
+import base64
+import cv2
+import logging
+import numpy as np
+from typing import Any, Dict, Optional
+from pynode.nodes.base_node import BaseNode, Info, MessageKeys
+
+logger = logging.getLogger(__name__)
+
+_info = Info()
+_info.add_text("Draws detection results (bounding boxes and labels) on images.")
+_info.add_header("Inputs")
+_info.add_bullets(
+    ("Input 0:", "Message with payload.predictions (from YOLO or Inference) and payload.image (base64)"),
+)
+_info.add_header("Outputs")
+_info.add_bullets(
+    ("Output 0:", "Annotated image with bounding boxes and labels drawn"),
+)
+_info.add_header("Configuration")
+_info.add_bullets(
+    ("Line Width:", "Thickness of bounding box lines"),
+    ("Font Scale:", "Size of label text"),
+    ("Text Color:", "Color of label text"),
+    ("Show Confidence:", "Display confidence scores on labels"),
+    ("Show Class:", "Display class names on labels"),
+)
+
+
+class DrawPredictionsNode(BaseNode):
+    """
+    Draw Predictions Node - visualizes YOLO or Inference detection results on images.
+    Expects msg.payload.predictions (from YOLO or Inference) and msg.payload.image (base64).
+    """
+    display_name = 'Draw Predictions'
+    info = str(_info)
+    icon = '🎨'
+    category = 'vision'
+    color = '#FF6B9D'
+    border_color = '#CC5680'
+    text_color = '#FFFFFF'
+    input_count = 1
+    output_count = 1
+    ui_component = 'toggle'
+    ui_component_config = {
+        'action': 'toggle_drawing',
+        'label': 'Draw'
+    }
+
+    # UI-triggerable actions (see BaseNode.actions)
+    actions = ['toggle_drawing']
+
+    DEFAULT_CONFIG = {
+        'detections_path': 'payload.detections',
+        'line_width': '2',
+        'font_scale': '1',
+        'text_thickness': '2',
+        'text_color': 'white',
+        'show_confidence': 'true',
+        'show_class': 'true'
+    }
+
+    properties = [
+        {
+            'name': 'detections_path',
+            'label': 'Detections/Tracks Path',
+            'type': 'text',
+            'default': DEFAULT_CONFIG['detections_path'],
+            'description': 'Dot-separated path to detections/tracks list (e.g. payload.detections or payload.tracks)'
+        },
+        {
+            'name': 'enabled',
+            'label': 'Drawing Enabled',
+            'type': 'toggle',
+            'action': 'toggle_drawing',
+            'stateField': 'drawingEnabled',
+            'help': 'Toggle drawing on/off'
+        },
+        {
+            'name': 'line_width',
+            'label': 'Line Width',
+            'type': 'text',
+            'default': DEFAULT_CONFIG['line_width'],
+            'help': 'Thickness of bounding box lines'
+        },
+        {
+            'name': 'font_scale',
+            'label': 'Font Scale',
+            'type': 'text',
+            'default': DEFAULT_CONFIG['font_scale'],
+            'help': 'Size of label text'
+        },
+        {
+            'name': 'text_thickness',
+            'label': 'Text Thickness',
+            'type': 'text',
+            'default': DEFAULT_CONFIG['text_thickness'],
+            'help': 'Thickness of label text'
+        },
+        {
+            'name': 'text_color',
+            'label': 'Text Color',
+            'type': 'select',
+            'options': [
+                {'value': 'white', 'label': 'White'},
+                {'value': 'black', 'label': 'Black'},
+                {'value': 'red', 'label': 'Red'},
+                {'value': 'green', 'label': 'Green'},
+                {'value': 'blue', 'label': 'Blue'},
+                {'value': 'yellow', 'label': 'Yellow'}
+            ],
+            'default': DEFAULT_CONFIG['text_color'],
+            'help': 'Color of label text'
+        },
+        {
+            'name': 'show_confidence',
+            'label': 'Show Confidence',
+            'type': 'select',
+            'options': [
+                {'value': 'true', 'label': 'Yes'},
+                {'value': 'false', 'label': 'No'}
+            ],
+            'default': DEFAULT_CONFIG['show_confidence'],
+            'help': 'Display confidence scores on labels'
+        },
+        {
+            'name': 'show_class',
+            'label': 'Show Class Name',
+            'type': 'select',
+            'options': [
+                {'value': 'true', 'label': 'Yes'},
+                {'value': 'false', 'label': 'No'}
+            ],
+            'default': DEFAULT_CONFIG['show_class'],
+            'help': 'Display class names on labels'
+        }
+    ]
+    
+    def __init__(self, node_id=None, name="Draw Predictions"):
+        super().__init__(node_id, name)
+        self.drawing_enabled = True  # Drawing is enabled by default
+        self.configure({
+            'line_width': '2',
+            'font_scale': '0.5',
+            'text_thickness': '1',
+            'text_color': 'white',
+            'show_confidence': 'true',
+            'show_class': 'true'
+        })
+        
+        # Color palette for different classes
+        self.colors = [
+            (255, 0, 0),     # Red
+            (0, 255, 0),     # Green
+            (0, 0, 255),     # Blue
+            (255, 255, 0),   # Yellow
+            (255, 0, 255),   # Magenta
+            (0, 255, 255),   # Cyan
+            (255, 128, 0),   # Orange
+            (128, 0, 255),   # Purple
+            (0, 255, 128),   # Spring Green
+            (255, 0, 128),   # Rose
+        ]
+        
+        # Text color mapping
+        self.text_colors = {
+            'white': (255, 255, 255),
+            'black': (0, 0, 0),
+            'red': (0, 0, 255),      # BGR format
+            'green': (0, 255, 0),
+            'blue': (255, 0, 0),
+            'yellow': (0, 255, 255)
+        }
+    
+    def _decode_image(self, image_data: str) -> Optional[np.ndarray]:
+        """Decode base64 image to numpy array."""
+        try:
+            # Remove data URL prefix if present
+            if ',' in image_data:
+                image_data = image_data.split(',', 1)[1]
+            
+            # Decode base64
+            img_bytes = base64.b64decode(image_data)
+            nparr = np.frombuffer(img_bytes, np.uint8)
+            img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
+            return img
+        except Exception as e:
+            self.report_error(f"Failed to decode image: {str(e)}")
+            return None
+    
+    def _encode_image(self, img: np.ndarray) -> Optional[str]:
+        """Encode numpy array to base64 JPEG."""
+        try:
+            _, buffer = cv2.imencode('.jpg', img)
+            img_bytes = buffer.tobytes()
+            img_base64 = base64.b64encode(img_bytes).decode('utf-8')
+            return img_base64
+        except Exception as e:
+            self.report_error(f"Failed to encode image: {str(e)}")
+            return None
+    
+    def _get_color(self, class_id: int) -> tuple:
+        """Get color for a class ID."""
+        return self.colors[class_id % len(self.colors)]
+    
+    def toggle_drawing(self):
+        """Toggle drawing on/off."""
+        self.drawing_enabled = not self.drawing_enabled
+        status = "enabled" if self.drawing_enabled else "disabled"
+        logger.info(f"Draw Predictions ({self.id}): Drawing {status}")
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Serialize node to dictionary for API/storage, including drawing state."""
+        data = super().to_dict()
+        data['drawingEnabled'] = self.drawing_enabled
+        return data
+    
+    def on_input(self, msg: Dict[str, Any], input_index: int = 0):
+        """Draw predictions/tracks on image, with configurable path and track_id support."""
+        # If drawing is disabled, pass through the message unchanged
+        if not self.drawing_enabled:
+            self.send(msg)
+            return
+
+        # Get detections/tracks path from config
+        detections_path = self.config.get('detections_path', self.DEFAULT_CONFIG['detections_path'])
+
+        detections = self._get_nested_value(msg, detections_path)
+        payload = msg.get(MessageKeys.PAYLOAD, {})
+        image_data = payload.get(MessageKeys.IMAGE.PATH)
+
+        if image_data is None:
+            self.report_error(f"No image data in message. Expected msg.{MessageKeys.PAYLOAD}.{MessageKeys.IMAGE.PATH}")
+            return
+
+        # Decode image using base node helper and make a copy to avoid modifying upstream data
+        img, input_format = self.decode_image({MessageKeys.IMAGE.PATH: image_data})
+        if img is None or input_format is None:
+            self.report_error("Failed to decode image from payload")
+            return
+        img = img.copy()
+
+        # Check if there are any detections/tracks
+        if isinstance(detections, np.ndarray):
+            has_detections = len(detections) > 0
+        else:
+            has_detections = bool(detections)
+
+        if not has_detections:
+            self.send(msg)
+            return
+
+        # Get configuration
+        line_width = self.get_config_int('line_width', 2)
+        font_scale = self.get_config_float('font_scale', 0.5)
+        text_thickness = self.get_config_int('text_thickness', 1)
+        text_color_name = self.config.get('text_color', 'white')
+        text_color = self.text_colors.get(text_color_name, (255, 255, 255))
+        show_confidence = self.get_config_bool('show_confidence', True)
+        show_class = self.get_config_bool('show_class', True)
+
+        # Draw each detection/track
+        for i, det in enumerate(detections):
+            try:
+                bbox = det.get('bbox', [0, 0, 0, 0])
+                if isinstance(bbox, np.ndarray):
+                    bbox = bbox.tolist()
+                x1, y1, x2, y2 = bbox
+                class_id = det.get('class_id', 0)
+                class_name = det.get('class_name', 'unknown')
+                confidence = det.get('confidence', 0.0)
+                track_id = det.get('track_id', None)
+
+                x1, y1, x2, y2 = int(x1), int(y1), int(x2), int(y2)
+                color = self._get_color(class_id)
+                cv2.rectangle(img, (x1, y1), (x2, y2), color, line_width)
+
+                # Build label text
+                label_parts = []
+                if track_id is not None:
+                    label_parts.append(f"TrackID: {track_id}")
+                if show_class:
+                    label_parts.append(class_name)
+                if show_confidence:
+                    label_parts.append(f"({confidence:.2f})")
+
+
+                if label_parts:
+                    label = ' '.join(label_parts)
+                    (text_width, text_height), baseline = cv2.getTextSize(
+                        label, cv2.FONT_HERSHEY_SIMPLEX, font_scale, 1
+                    )
+                    # Clamp label position to image bounds
+                    img_h, img_w = img.shape[:2]
+                    # Default: draw above the box with proper padding for tall characters
+                    padding = int(4 * font_scale)  # Scale padding with font size
+                    # Add extra height for tall characters like parentheses
+                    extra_height = int(text_height * 0.3)  # 30% extra for ascenders
+                    label_top = y1 - text_height - baseline - padding - extra_height
+                    label_bottom = y1  # Touch the bounding box directly
+                    text_org_y = y1 - baseline - padding
+                    # Gradually clamp label so it stays within image bounds
+                    if label_top < 0:
+                        shift = -label_top
+                        label_top += shift
+                        label_bottom += shift
+                        text_org_y += shift
+                    if label_bottom > img_h:
+                        shift = label_bottom - img_h
+                        label_top -= shift
+                        label_bottom -= shift
+                        text_org_y -= shift
+                    # Clamp horizontally
+                    label_left = x1
+                    label_right = x1 + text_width
+                    
+                    # If text overflows right edge, shift it left
+                    if label_right > img_w:
+                        shift = label_right - img_w
+                        label_left -= shift
+                        label_right -= shift
+                    
+                    # Ensure left edge doesn't go below 0
+                    label_left = max(label_left, 0)
+                    label_right = min(label_left + text_width, img_w)
+                    # Draw label background
+                    cv2.rectangle(
+                        img,
+                        (label_left, label_top),
+                        (label_right, label_bottom),
+                        color,
+                        -1  # Filled
+                    )
+                    # Draw label text
+                    cv2.putText(
+                        img,
+                        label,
+                        (label_left, text_org_y),
+                        cv2.FONT_HERSHEY_SIMPLEX,
+                        font_scale,
+                        text_color,
+                        text_thickness,
+                        cv2.LINE_AA
+                    )
+            except Exception as e:
+                import traceback
+                self.report_error(f"Failed to draw detection {i}: {str(e)}\n{traceback.format_exc()}")
+                continue
+
+        # Encode image back to same format as input using base node helper
+        encoded_image = self.encode_image(img, input_format)
+        if encoded_image is not None:
+            if not isinstance(msg.get(MessageKeys.PAYLOAD), dict):
+                msg[MessageKeys.PAYLOAD] = {}
+            msg[MessageKeys.PAYLOAD][MessageKeys.IMAGE.PATH] = encoded_image
+        else:
+            self.report_error("Failed to encode output image")
+            return
+
+        self.send(msg)

pynode/nodes/DrawPredictionsNode/requirements.txt

@@ -0,0 +1,2 @@
+opencv-python>=4.5.0
+numpy>=1.19.0

pynode/nodes/ErrorNode/error_node.py

@@ -0,0 +1,94 @@
+"""
+Error node - captures and displays error messages from any node in the workflow.
+Automatically receives error events and displays them in the debug panel.
+"""
+
+from typing import Any, Dict
+from pynode.nodes.base_node import BaseNode, Info, MessageKeys
+
+# Build info content
+_info = Info()
+_info.add_text("Captures and displays error messages from any node in the workflow.")
+_info.add_text("Unlike debug nodes that need to be wired, error nodes automatically receive errors from all nodes.")
+_info.add_header("Properties")
+_info.add_bullet("Filter by Node:", "Only show errors from nodes matching this filter (leave empty for all errors)")
+_info.add_header("Features")
+_info.add_bullet("Auto-capture:", "Receives errors from all workflow nodes automatically")
+_info.add_bullet("History:", "Keeps the last 100 errors")
+_info.add_bullet("Filtering:", "Can filter errors by node name")
+
+
+class ErrorNode(BaseNode):
+    """
+    Error node - displays error messages in the debug panel.
+    Unlike debug nodes that need to be wired, error nodes automatically
+    capture errors from all nodes in the workflow.
+    """
+    display_name = 'Error'
+    icon = '⚠️'
+    category = 'system'
+    color = '#FF6B6B'
+    border_color = '#E63946'
+    text_color = '#FFFFFF'
+    input_count = 0  # No input - errors come automatically
+    output_count = 0  # No output - errors are displayed only
+    info = str(_info)
+    hidden = True  # Hide from palette; it's a system node
+    
+    properties = [
+        {
+            'name': 'filter',
+            'label': 'Filter by Node',
+            'type': 'text',
+            'placeholder': 'Leave empty for all errors'
+        }
+    ]
+    
+    def __init__(self, node_id=None, name="error"):
+        super().__init__(node_id, name)
+        self.configure({'filter': ''})
+        self.errors = []
+        self.max_errors = 100  # Keep last 100 errors
+        self.is_system_node = False  # Can be set to True for the system error node
+    
+    def on_input(self, msg: Dict[str, Any], input_index: int = 0):
+        """
+        This won't be called since input_count = 0.
+        Errors are captured via handle_error() method.
+        """
+        pass
+    
+    def handle_error(self, source_node_id: str, source_node_name: str, error_msg: str):
+        """
+        Handle error messages from any node in the workflow.
+        This is called by the workflow engine when any node reports an error.
+        """
+        # Check filter
+        node_filter = self.config.get('filter', '').strip()
+        if node_filter and node_filter.lower() not in source_node_name.lower():
+            return  # Skip this error
+        
+        # Create error entry
+        import time
+        error_entry = {
+            'timestamp': time.time(),
+            'source_node_id': source_node_id,
+            'source_node_name': source_node_name,
+            'message': error_msg,
+            'type': 'error'
+        }
+        
+        # Add to errors list
+        self.errors.append(error_entry)
+        
+        # Trim to max size
+        if len(self.errors) > self.max_errors:
+            self.errors = self.errors[-self.max_errors:]
+    
+    def get_errors(self):
+        """Get all captured errors (returns a copy so clearing doesn't affect it)."""
+        return list(self.errors)
+    
+    def clear_errors(self):
+        """Clear all captured errors."""
+        self.errors.clear()

pynode/nodes/ErrorNode/requirements.txt

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