pynode-flow 0.2.0__py3-none-any.whl

pynode/nodes/ChangeNode/change_node.py

@@ -0,0 +1,255 @@
+"""
+Change node - modifies message properties.
+Similar to Node-RED's change node.
+"""
+
+import json
+import re
+from typing import Any, Dict
+from pynode.nodes.base_node import BaseNode, Info, MessageKeys
+
+_info = Info()
+_info.add_text("Modifies message properties using configurable rules. Similar to Node-RED's change node.")
+_info.add_header("Input")
+_info.add_bullets(
+    ("msg:", "Any message to be modified according to the configured rules."),
+)
+_info.add_header("Output")
+_info.add_bullets(
+    ("msg:", "The modified message after all rules have been applied."),
+)
+_info.add_header("Operations")
+_info.add_bullets(
+    ("Set:", "Set a property to a value or copy from another property."),
+    ("Change:", "Search and replace text within a property."),
+    ("Delete:", "Remove a property from the message."),
+    ("Move:", "Move a property to a different location."),
+)
+
+
+class ChangeNode(BaseNode):
+    """
+    Change node - modifies message properties.
+    Similar to Node-RED's change node.
+    
+    Supports operations:
+    - set: Set a property to a value or another property's value
+    - change: Search and replace within a property
+    - delete: Remove a property
+    - move: Move a property to another location
+    """
+    info = str(_info)
+    display_name = 'Change'
+    icon = '✎'
+    category = 'function'
+    color = '#E6E0F8'
+    border_color = '#9F93C6'
+    text_color = '#000000'
+    input_count = 1
+    output_count = 1
+    
+    # Custom UI component for rule editing
+    ui_component = 'change-rules-editor'
+    ui_component_config = {
+        'operations': ['set', 'change', 'move', 'delete'],
+        'value_types': [
+            {'value': 'str', 'label': 'String'},
+            {'value': 'num', 'label': 'Number'},
+            {'value': 'bool', 'label': 'Boolean'},
+            {'value': 'json', 'label': 'JSON'},
+            {'value': 'msg', 'label': 'msg.'},
+            {'value': 'flow', 'label': 'flow.'},
+            {'value': 'global', 'label': 'global.'}
+        ]
+    }
+    
+    DEFAULT_CONFIG = {
+        'rules': []
+    }
+    
+    properties = [
+        {
+            'name': 'rules',
+            'label': 'Rules',
+            'type': 'changeRules',
+            'default': [],
+            'help': 'Define rules to modify message properties'
+        }
+    ]
+    
+    def __init__(self, node_id=None, name="change"):
+        super().__init__(node_id, name)
+    
+    def _delete_nested_value(self, obj: Dict, path: str) -> bool:
+        """
+        Delete a value at a nested path
+        
+        Args:
+            obj: The object to delete from
+            path: Dot-separated path string
+            
+        Returns:
+            True if deleted, False otherwise
+        """
+        # Handle msg. prefix
+        if path.startswith('msg.'):
+            path = path[4:]
+        
+        parts = path.split('.')
+        current = obj
+        
+        # Navigate to parent of target
+        for part in parts[:-1]:
+            match = re.match(r'(\w+)\[(\d+)\]', part)
+            if match:
+                key, index = match.groups()
+                if isinstance(current, dict) and key in current:
+                    current = current[key]
+                    if isinstance(current, (list, tuple)) and int(index) < len(current):
+                        current = current[int(index)]
+                    else:
+                        return False
+                else:
+                    return False
+            elif isinstance(current, dict) and part in current:
+                current = current[part]
+            else:
+                return False
+        
+        # Delete the final key
+        final_key = parts[-1]
+        match = re.match(r'(\w+)\[(\d+)\]', final_key)
+        if match:
+            key, index = match.groups()
+            if isinstance(current, dict) and key in current:
+                if isinstance(current[key], list) and int(index) < len(current[key]):
+                    del current[key][int(index)]
+                    return True
+        elif isinstance(current, dict) and final_key in current:
+            del current[final_key]
+            return True
+        
+        return False
+    
+    def _resolve_value(self, msg: Dict, value: Any, value_type: str) -> Any:
+        """
+        Resolve a value based on its type.
+        
+        Args:
+            msg: The message object
+            value: The value or path
+            value_type: Type of the value ('str', 'num', 'bool', 'json', 'msg', etc.)
+            
+        Returns:
+            The resolved value
+        """
+        if value_type == 'msg':
+            # Get value from message path
+            return self._get_nested_value(msg, value)
+        elif value_type == 'num':
+            try:
+                return float(value) if '.' in str(value) else int(value)
+            except (ValueError, TypeError):
+                return 0
+        elif value_type == 'bool':
+            if isinstance(value, bool):
+                return value
+            return str(value).lower() in ('true', '1', 'yes', 'on')
+        elif value_type == 'json':
+            if isinstance(value, str):
+                try:
+                    return json.loads(value)
+                except json.JSONDecodeError:
+                    return value
+            return value
+        elif value_type == 'str':
+            return str(value) if value is not None else ''
+        else:
+            # Default: return as-is
+            return value
+    
+    def on_input(self, msg: Dict[str, Any], input_index: int = 0):
+        """
+        Apply change rules to the message.
+        """
+        rules = self.config.get('rules', [])
+        
+        # Handle rules as JSON string (from UI)
+        if isinstance(rules, str):
+            try:
+                rules = json.loads(rules)
+            except json.JSONDecodeError:
+                rules = []
+        
+        for rule in rules:
+            if not isinstance(rule, dict):
+                continue
+                
+            rule_type = rule.get('type', rule.get('t', 'set'))
+            property_path = rule.get('path', rule.get('p', rule.get('property', f'msg.{MessageKeys.PAYLOAD}')))
+            
+            try:
+                if rule_type == 'set':
+                    # Set property to a value
+                    value = rule.get('value', rule.get('to', ''))
+                    value_type = rule.get('valueType', rule.get('tot', 'str'))
+                    
+                    # Handle path value type (read from another msg property)
+                    if value_type == 'path':
+                        resolved_value = self._get_nested_value(msg, 'msg.' + str(value) if not str(value).startswith('msg.') else value)
+                    elif value_type == 'date':
+                        import time
+                        resolved_value = int(time.time() * 1000)
+                    elif value_type == 'env':
+                        import os
+                        resolved_value = os.environ.get(str(value), '')
+                    else:
+                        resolved_value = self._resolve_value(msg, value, value_type)
+                    
+                    self._set_nested_value(msg, property_path, resolved_value)
+                    
+                elif rule_type == 'change':
+                    # Search and replace within a property
+                    search = rule.get('search', rule.get('from', ''))
+                    search_type = rule.get('searchType', rule.get('fromt', 'str'))
+                    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
+                    if replace_type == 'path':
+                        replace_value = self._get_nested_value(msg, 'msg.' + str(replace) if not str(replace).startswith('msg.') else replace)
+                    else:
+                        replace_value = str(replace)
+                    
+                    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)
+                    
+                elif rule_type == 'delete':
+                    # Delete a property
+                    self._delete_nested_value(msg, property_path)
+                    
+                elif rule_type == 'move':
+                    # Move property to another location
+                    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)
+                            
+            except Exception as e:
+                self.report_error(f"Error applying rule {rule_type} on {property_path}: {str(e)}")
+        
+        self.send(msg)

pynode/nodes/ChangeNode/requirements.txt

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

pynode/nodes/ConfidenceFilterNode/__init__.py

@@ -0,0 +1,4 @@
+from .confidence_filter_node import ConfidenceFilterNode
+
+__all__ = ['ConfidenceFilterNode']
+

pynode/nodes/ConfidenceFilterNode/confidence_filter_node.py

@@ -0,0 +1,208 @@
+"""
+Confidence Filter Node - filters messages based on detection confidence.
+Passes through messages that contain detections meeting the confidence threshold.
+"""
+
+from typing import Any, Dict, List
+from pynode.nodes.base_node import BaseNode, Info, MessageKeys
+
+_info = Info()
+_info.add_text("Splits detection arrays based on confidence scores, sending high-confidence detections to output 0 and low-confidence to output 1.")
+_info.add_header("Input")
+_info.add_bullets(
+    (f"{MessageKeys.PAYLOAD}.detections:", "Array of detection objects, each containing a confidence score."),
+)
+_info.add_header("Outputs")
+_info.add_bullets(
+    ("Output 0:", "Message with detections having confidence >= threshold."),
+    ("Output 1:", "Message with detections having confidence < threshold."),
+)
+_info.add_header("Properties")
+_info.add_bullets(
+    ("Threshold:", "Minimum confidence score (0-1) to separate detections."),
+    ("Threshold Source:", "Use configured value or read from msg.threshold."),
+    ("Detections Path:", "Path to the detections array in the message."),
+    ("Confidence Field:", "Name of the confidence field within each detection."),
+)
+
+
+class ConfidenceFilterNode(BaseNode):
+    """
+    Confidence Filter node - splits detection arrays based on confidence scores.
+    Always outputs to both ports:
+    Output 0: Detections with confidence >= threshold
+    Output 1: Detections with confidence < threshold
+    """
+    info = str(_info)
+    display_name = 'Confidence Filter'
+    icon = '📊'
+    category = 'vision'
+    color = '#C7E9C0'
+    border_color = '#74C476'
+    text_color = '#000000'
+    input_count = 1
+    output_count = 2  # Output 0: >= threshold, Output 1: < threshold
+    
+    DEFAULT_CONFIG = {
+        'threshold_source': 'manual',  # or 'msg'
+        'threshold': 0.5,
+        'detections_path': f'{MessageKeys.PAYLOAD}.{MessageKeys.CV.DETECTIONS}',
+        'confidence_field': MessageKeys.CV.CONFIDENCE
+    }
+    
+    properties = [
+        {
+            'name': 'threshold_source',
+            'label': 'Threshold Source',
+            'type': 'select',
+            'options': [
+                {'value': 'manual', 'label': 'Use manual value'},
+                {'value': 'msg', 'label': 'Use msg.threshold'}
+            ],
+            'default': DEFAULT_CONFIG['threshold_source'],
+            'help': 'Where to read the threshold value from'
+        },
+        {
+            'name': 'threshold',
+            'label': 'Confidence Threshold',
+            'type': 'number',
+            'default': DEFAULT_CONFIG['threshold'],
+            'min': 0,
+            'max': 1,
+            'step': 0.01,
+            'help': 'Minimum confidence score (0-1) to pass to output 0',
+            'showIf': {'threshold_source': 'manual'}
+        },
+        {
+            'name': 'detections_path',
+            'label': 'Detections Path',
+            'type': 'text',
+            'default': DEFAULT_CONFIG['detections_path'],
+            'help': f'Path to detections array in message (e.g., "{MessageKeys.PAYLOAD}.{MessageKeys.CV.DETECTIONS}")'
+        },
+        {
+            'name': 'confidence_field',
+            'label': 'Confidence Field',
+            'type': 'text',
+            'default': DEFAULT_CONFIG['confidence_field'],
+            'help': 'Name of the confidence field in each detection object'
+        }
+    ]
+    
+    def __init__(self, node_id=None, name="confidence filter"):
+        super().__init__(node_id, name)
+    
+    def on_input(self, msg: Dict[str, Any], input_index: int = 0):
+        """
+        Split detections based on confidence threshold.
+        Always outputs to both ports:
+        Output 0: Detections with confidence >= threshold
+        Output 1: Detections with confidence < threshold
+        """
+        # Get threshold from msg or config based on setting
+        threshold_source = self.config.get('threshold_source', 'manual')
+        if threshold_source == MessageKeys.MSG and MessageKeys.CV.THRESHOLD in msg:
+            try:
+                threshold = float(msg[MessageKeys.CV.THRESHOLD])
+            except (TypeError, ValueError):
+                threshold = self.get_config_float(MessageKeys.CV.THRESHOLD, 0.5)
+        else:
+            threshold = self.get_config_float(MessageKeys.CV.THRESHOLD, 0.5)
+        
+        detections_path = self.config.get('detections_path', f'{MessageKeys.PAYLOAD}.{MessageKeys.CV.DETECTIONS}')
+        confidence_field = self.config.get('confidence_field', MessageKeys.CV.CONFIDENCE)
+        
+        # Get detections array from message
+        detections = self._get_nested_value(msg, detections_path)
+        
+        if not isinstance(detections, list):
+            # No detections array found, send empty arrays to both outputs
+            # Use shallow copies - send() will deep copy for downstream isolation
+            msg[MessageKeys.CV.THRESHOLD] = threshold
+            high_msg = msg.copy()
+            low_msg = msg.copy()
+            
+            # Copy payload dict since shallow copy shares nested objects
+            payload = msg.get(MessageKeys.PAYLOAD, {})
+            if isinstance(payload, dict):
+                high_msg[MessageKeys.PAYLOAD] = payload.copy()
+                low_msg[MessageKeys.PAYLOAD] = payload.copy()
+            
+            # Set empty detection arrays
+            high_msg[MessageKeys.PAYLOAD][MessageKeys.CV.DETECTIONS] = []
+            low_msg[MessageKeys.PAYLOAD][MessageKeys.CV.DETECTIONS] = []
+            
+            # Update detection counts if they exist
+            if MessageKeys.CV.DETECTION_COUNT in msg:
+                high_msg[MessageKeys.CV.DETECTION_COUNT] = 0
+                low_msg[MessageKeys.CV.DETECTION_COUNT] = 0
+                
+            elif MessageKeys.PAYLOAD in msg and isinstance(msg[MessageKeys.PAYLOAD], dict) and MessageKeys.CV.DETECTION_COUNT in msg[MessageKeys.PAYLOAD]:
+                high_msg[MessageKeys.PAYLOAD][MessageKeys.CV.DETECTION_COUNT] = 0
+                low_msg[MessageKeys.PAYLOAD][MessageKeys.CV.DETECTION_COUNT] = 0
+                
+            else:
+                high_msg[MessageKeys.CV.DETECTION_COUNT] = 0
+                low_msg[MessageKeys.CV.DETECTION_COUNT] = 0
+            
+            self.send(high_msg, 0)
+            self.send(low_msg, 1)
+            return
+        
+        # Split detections based on confidence
+        high_confidence_detections = []
+        low_confidence_detections = []
+        
+        for detection in detections:
+            if not isinstance(detection, dict):
+                # Invalid detection, add to low confidence
+                low_confidence_detections.append(detection)
+                continue
+            
+            confidence = detection.get(confidence_field)
+            if confidence is None:
+                # No confidence field, add to low confidence
+                low_confidence_detections.append(detection)
+                continue
+            
+            try:
+                confidence = float(confidence)
+                if confidence >= threshold:
+                    high_confidence_detections.append(detection)
+                else:
+                    low_confidence_detections.append(detection)
+            except (TypeError, ValueError):
+                # Invalid confidence value, add to low confidence
+                low_confidence_detections.append(detection)
+        
+        # Create output messages - use shallow copies since send() deep copies
+        msg[MessageKeys.CV.THRESHOLD] = threshold
+        high_msg = msg.copy()
+        low_msg = msg.copy()
+        
+        # Copy payload dict since shallow copy shares nested objects
+        payload = msg.get(MessageKeys.PAYLOAD, {})
+        if isinstance(payload, dict):
+            high_msg[MessageKeys.PAYLOAD] = payload.copy()
+            low_msg[MessageKeys.PAYLOAD] = payload.copy()
+        
+        # Set filtered detection arrays directly on payload
+        high_msg[MessageKeys.PAYLOAD][MessageKeys.CV.DETECTIONS] = high_confidence_detections
+        low_msg[MessageKeys.PAYLOAD][MessageKeys.CV.DETECTIONS] = low_confidence_detections
+        
+        # Update detection counts if they exist
+        if MessageKeys.CV.DETECTION_COUNT in msg:
+            high_msg[MessageKeys.CV.DETECTION_COUNT] = len(high_confidence_detections)
+            low_msg[MessageKeys.CV.DETECTION_COUNT] = len(low_confidence_detections)
+            
+        elif MessageKeys.PAYLOAD in msg and isinstance(msg[MessageKeys.PAYLOAD], dict) and MessageKeys.CV.DETECTION_COUNT in msg[MessageKeys.PAYLOAD]:
+            high_msg[MessageKeys.PAYLOAD][MessageKeys.CV.DETECTION_COUNT] = len(high_confidence_detections)
+            low_msg[MessageKeys.PAYLOAD][MessageKeys.CV.DETECTION_COUNT] = len(low_confidence_detections)
+            
+        else:
+            high_msg[MessageKeys.CV.DETECTION_COUNT] = len(high_confidence_detections)
+            low_msg[MessageKeys.CV.DETECTION_COUNT] = len(low_confidence_detections)
+        
+        # Always send to both outputs
+        self.send(high_msg, 0)  # High confidence detections
+        self.send(low_msg, 1)   # Low confidence detections

pynode/nodes/ConfidenceFilterNode/requirements.txt

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

pynode/nodes/CounterNode/__init__.py

@@ -0,0 +1,3 @@
+from .counter_node import CounterNode
+
+__all__ = ['CounterNode']

pynode/nodes/CounterNode/counter_node.py

@@ -0,0 +1,191 @@
+"""
+Counter Node - counts messages and displays the count with a reset button.
+Demonstrates the use of UI components (button + rate-display).
+"""
+
+from typing import Any, Dict
+from pynode.nodes.base_node import BaseNode, Info, MessageKeys
+
+_info = Info()
+_info.add_text("Counts incoming messages and outputs the running total. Includes a reset button to restart the count.")
+_info.add_header("Input")
+_info.add_bullets(
+    ("msg:", "Any message triggers the counter increment."),
+)
+_info.add_header("Output")
+_info.add_bullets(
+    ("payload.count:", "Current count value."),
+    ("payload.original_payload:", "The original payload from the input message."),
+    ("payload.display:", "Formatted count for display."),
+)
+_info.add_header("Properties")
+_info.add_bullets(
+    ("Initial Value:", "Starting count value."),
+    ("Increment By:", "Amount to add per message."),
+)
+_info.add_header("UI")
+_info.add_text("Click the reset button on the node to reset the counter to initial value.")
+
+
+class CounterNode(BaseNode):
+    """
+    Counter node - counts incoming messages and displays the total.
+    Can be reset via button click.
+    """
+    info = str(_info)
+    display_name = 'Counter'
+    icon = '🔢'
+    category = 'node probes'
+    color = '#E2D96E'
+    border_color = '#B8AF4A'
+    text_color = '#000000'
+    input_count = 1
+    output_count = 1
+    
+    # Counter display UI component with reset button
+    ui_component = 'counter-display'
+    ui_component_config = {
+        'format': '{value}',
+        'action': 'reset_counter',
+        'tooltip': 'Reset Count'
+    }
+    
+    # UI-triggerable actions (see BaseNode.actions)
+    actions = ['reset_counter']
+
+    # get_count_sse does its own change-detection (returns None when the count
+    # is unchanged), so a low throttle just bounds the cheap comparison rate
+    # while letting visible updates through almost immediately.
+    sse_handlers = [
+        {'type': 'counter', 'handler': 'get_count_sse', 'throttle': 0.1},
+    ]
+    
+    DEFAULT_CONFIG = {
+        'initial_value': '0',
+        'increment': '1',
+        'retain_payload': 'false',
+        MessageKeys.DROP_MESSAGES: 'false'
+    }
+    
+    properties = [
+        {
+            'name': MessageKeys.DROP_MESSAGES,
+            'label': 'Drop Messages When Busy',
+            'type': 'checkbox',
+            'default': False
+        },
+        {
+            'name': 'initial_value',
+            'label': 'Initial Value',
+            'type': 'text',
+            'default': DEFAULT_CONFIG['initial_value'],
+            'help': 'Starting count value'
+        },
+        {
+            'name': 'increment',
+            'label': 'Increment By',
+            'type': 'text',
+            'default': DEFAULT_CONFIG['increment'],
+            'help': 'Amount to increment per message'
+        },
+        {
+            'name': 'retain_payload',
+            'label': 'Retain Original Payload',
+            'type': 'select',
+            'options': [
+                {'value': 'false', 'label': 'No - Replace payload with count info'},
+                {'value': 'true', 'label': 'Yes - Merge count info into payload'}
+            ],
+            'default': DEFAULT_CONFIG['retain_payload'],
+            'help': 'Whether to keep original payload data or replace it'
+        }
+    ]
+    
+    def __init__(self, node_id=None, name="counter"):
+        super().__init__(node_id, name)
+        self.count = 0
+        # Last value emitted via SSE; None means nothing emitted yet so the
+        # first poll always broadcasts the current count.
+        self._last_sse_count = None
+        self._reset_to_initial()
+    
+    def _reset_to_initial(self):
+        """Reset counter to initial value from config."""
+        self.count = self.get_config_int('initial_value', 0)
+    
+    def on_input(self, msg: Dict[str, Any], input_index: int = 0):
+        """
+        Increment counter and pass through with count information.
+        """
+        # Get increment value
+        increment = self.get_config_int('increment', 1)
+        
+        # Increment counter
+        self.count += increment
+        
+        # Build count info
+        count_info = {
+            'count': self.count,
+            'display': self.get_count_display()
+        }
+        
+        # Check if we should retain original payload
+        if self.get_config_bool('retain_payload', False):
+            original_payload = msg.get(MessageKeys.PAYLOAD, {})
+            if isinstance(original_payload, dict):
+                new_payload = original_payload.copy()
+                new_payload.update(count_info)
+            else:
+                new_payload = {
+                    'original_data': original_payload,
+                    **count_info
+                }
+        else:
+            new_payload = count_info
+        
+        msg[MessageKeys.PAYLOAD] = new_payload
+        msg[MessageKeys.TOPIC] = msg.get(MessageKeys.TOPIC, 'counter')
+        
+        self.send(msg)
+    
+    def get_count(self) -> int:
+        """Get the current count value."""
+        return self.count
+    
+    def get_count_display(self) -> str:
+        """Get formatted count string for display."""
+        return str(self.count)
+    
+    def reset_counter(self):
+        """
+        Action triggered by the reset button.
+        Resets counter to initial value and sends notification.
+        """
+        self._reset_to_initial()
+        
+        # Send reset notification
+        msg = self.create_message(
+            payload={
+                'count': self.count,
+                'action': 'reset',
+                'display': self.get_count_display()
+            },
+            topic='counter/reset'
+        )
+        self.send(msg)
+
+    def get_count_sse(self):
+        """SSE handler: return counter data for broadcast.
+
+        Change-detection: returns None when the count has not changed since
+        the last emitted value, so the broadcast worker skips redundant
+        messages (it treats a None result as "nothing to send").
+        """
+        count = self.get_count()
+        if count == self._last_sse_count:
+            return None
+        self._last_sse_count = count
+        return {
+            'display': self.get_count_display(),
+            'count': count,
+        }

pynode/nodes/CropNode/__init__.py

@@ -0,0 +1,4 @@
+from .crop_node import CropNode
+
+__all__ = ['CropNode']
+