pynode-flow 0.2.0__py3-none-any.whl

pynode/nodes/SwitchNode/switch_node.py

@@ -0,0 +1,259 @@
+"""
+Switch node - routes messages based on rules.
+Similar to Node-RED's switch node.
+Supports dynamic rules with multiple outputs.
+"""
+
+import re
+from typing import Any, Dict, List
+from pynode.nodes.base_node import BaseNode, Info, MessageKeys
+
+_info = Info()
+_info.add_text("Routes messages to different outputs based on configurable rules. Each rule creates an output port - messages are sent to outputs where rules match.")
+_info.add_header("Inputs")
+_info.add_bullets(
+    ("Input 0:", "Message to evaluate and route")
+)
+_info.add_header("Outputs")
+_info.add_bullets(
+    ("Output N:", "One output per rule - message sent to matching rule outputs")
+)
+_info.add_header("Configuration")
+_info.add_bullets(
+    ("Property:", "Message property to evaluate (e.g., payload, topic)"),
+    ("Rules:", "List of conditions - each creates an output port"),
+    ("Check all:", "If enabled, checks all rules; otherwise stops at first match")
+)
+_info.add_header("Operators")
+_info.add_bullets(
+    ("eq/neq:", "Equals / not equals"),
+    ("lt/lte/gt/gte:", "Less than, greater than (or equal)"),
+    ("between:", "Value is in range (format: 'min,max')"),
+    ("contains/matches:", "String contains or regex matches"),
+    ("true/false/null/nnull:", "Boolean and null checks"),
+    ("empty/nempty:", "Check if value is empty"),
+    ("else:", "Catch-all (always matches)")
+)
+
+
+class SwitchNode(BaseNode):
+    """
+    Switch node - routes messages based on rules.
+    Each rule creates a separate output port.
+    Messages are routed to the first matching rule's output.
+    """
+    info = str(_info)
+    display_name = 'Switch'
+    icon = '⎇'
+    category = 'logic'
+    color = '#E9967A'
+    border_color = '#CA7C5F'
+    text_color = '#000000'
+    input_count = 1
+    output_count = 1  # Will be dynamically updated based on rules
+    
+    DEFAULT_CONFIG = {
+        'property': MessageKeys.PAYLOAD,
+        'checkall': False,
+        'rules': [
+            {'operator': 'eq', 'value': '', 'valueType': 'str'}
+        ]
+    }
+    
+    properties = [
+        {
+            'name': 'property',
+            'label': 'Property',
+            'type': 'text',
+            'help': 'The message property to evaluate (e.g., payload, topic)'
+        },
+        {
+            'name': 'rules',
+            'label': 'Rules',
+            'type': 'rules',  # Custom type for rules editor
+            'help': 'Define routing rules - each rule creates an output port'
+        },
+        {
+            'name': 'checkall',
+            'label': 'Check all rules',
+            'type': 'checkbox',
+            'default': DEFAULT_CONFIG['checkall'],
+            'help': 'If checked, checks all rules and sends to all matching outputs. If unchecked, stops at first match.'
+        }
+    ]
+    
+    def __init__(self, node_id=None, name="switch"):
+        super().__init__(node_id, name)
+        self._update_output_count()
+    
+    def configure(self, config: Dict[str, Any]):
+        """Override configure to update output count when rules change."""
+        super().configure(config)
+        self._update_output_count()
+    
+    def _update_output_count(self):
+        """Update the output count based on the number of rules."""
+        rules = self.config.get('rules', [])
+        self.output_count = max(1, len(rules))
+    
+    def _convert_value(self, value_str: str, value_type: str) -> Any:
+        """
+        Convert string value to the appropriate type.
+        """
+        if value_type == 'num':
+            try:
+                return float(value_str) if '.' in value_str else int(value_str)
+            except (ValueError, TypeError):
+                return 0
+        elif value_type == 'bool':
+            return str(value_str).lower() in ('true', '1', 'yes', 'on')
+        elif value_type == 'json':
+            try:
+                import json
+                return json.loads(value_str)
+            except Exception:
+                return value_str
+        else:  # 'str' or default
+            return str(value_str)
+    
+    def _evaluate_rule(self, msg_value: Any, rule: Dict[str, Any]) -> bool:
+        """
+        Evaluate a single rule against a message value.
+        
+        Supported operators:
+        - eq: equals (==)
+        - neq: not equals (!=)
+        - lt: less than (<)
+        - lte: less than or equal (<=)
+        - gt: greater than (>)
+        - gte: greater than or equal (>=)
+        - between: value is between two numbers
+        - contains: string contains substring
+        - matches: regex match
+        - true: value is truthy
+        - false: value is falsy
+        - null: value is None
+        - nnull: value is not None
+        - empty: value is empty (empty string, list, dict, etc.)
+        - nempty: value is not empty
+        - haskey: dict has key
+        - else: always matches (catch-all)
+        """
+        operator = rule.get('operator', 'eq')
+        rule_value = rule.get('value', '')
+        value_type = rule.get('valueType', 'str')
+        
+        try:
+            # Type-specific comparisons
+            if operator == 'eq':
+                compare_value = self._convert_value(rule_value, value_type)
+                return msg_value == compare_value
+            
+            elif operator == 'neq':
+                compare_value = self._convert_value(rule_value, value_type)
+                return msg_value != compare_value
+            
+            elif operator == 'lt':
+                compare_value = self._convert_value(rule_value, value_type)
+                return msg_value < compare_value
+            
+            elif operator == 'lte':
+                compare_value = self._convert_value(rule_value, value_type)
+                return msg_value <= compare_value
+            
+            elif operator == 'gt':
+                compare_value = self._convert_value(rule_value, value_type)
+                return msg_value > compare_value
+            
+            elif operator == 'gte':
+                compare_value = self._convert_value(rule_value, value_type)
+                return msg_value >= compare_value
+            
+            elif operator == 'between':
+                # Expects rule_value to be "min,max"
+                parts = str(rule_value).split(',')
+                if len(parts) == 2:
+                    min_val = self._convert_value(parts[0].strip(), value_type)
+                    max_val = self._convert_value(parts[1].strip(), value_type)
+                    return min_val <= msg_value <= max_val
+                return False
+            
+            elif operator == 'contains':
+                return str(rule_value) in str(msg_value)
+            
+            elif operator == 'matches':
+                # Regex match
+                pattern = str(rule_value)
+                return bool(re.search(pattern, str(msg_value)))
+            
+            elif operator == 'true':
+                return bool(msg_value)
+            
+            elif operator == 'false':
+                return not bool(msg_value)
+            
+            elif operator == 'null':
+                return msg_value is None
+            
+            elif operator == 'nnull':
+                return msg_value is not None
+            
+            elif operator == 'empty':
+                if msg_value is None:
+                    return True
+                if isinstance(msg_value, (str, list, dict, tuple)):
+                    return len(msg_value) == 0
+                return False
+            
+            elif operator == 'nempty':
+                if msg_value is None:
+                    return False
+                if isinstance(msg_value, (str, list, dict, tuple)):
+                    return len(msg_value) > 0
+                return True
+            
+            elif operator == 'haskey':
+                if isinstance(msg_value, dict):
+                    return str(rule_value) in msg_value
+                return False
+            
+            elif operator == 'else':
+                # Catch-all rule - always matches
+                return True
+            
+            else:
+                return False
+                
+        except (TypeError, ValueError, AttributeError):
+            return False
+    
+    def on_input(self, msg: Dict[str, Any], input_index: int = 0):
+        """
+        Route message based on rules.
+        Each rule is checked in order, and messages are sent to matching output(s).
+        """
+        property_path = self.config.get('property', MessageKeys.PAYLOAD)
+        check_all = self.config.get('checkall', False)
+        rules = self.config.get('rules', [])
+        
+        if not rules:
+            # No rules defined, send to output 0
+            self.send(msg, 0)
+            return
+        
+        # Get the value to evaluate
+        msg_value = self._get_nested_value(msg, property_path)
+        
+        # Check each rule
+        matched_any = False
+        for idx, rule in enumerate(rules):
+            if self._evaluate_rule(msg_value, rule):
+                self.send(msg, idx)
+                matched_any = True
+                
+                # If not checking all rules, stop at first match
+                if not check_all:
+                    break
+        
+        # If no rules matched and we have an 'else' rule, it should have matched
+        # Otherwise, message is not sent anywhere (filtered out)

pynode/nodes/SyncNode/__init__.py

@@ -0,0 +1,3 @@
+from .sync_node import SyncNode
+
+__all__ = ['SyncNode']

pynode/nodes/SyncNode/sync_node.py

@@ -0,0 +1,287 @@
+"""
+Sync Node - buffers messages based on an index and releases them on command.
+Useful for synchronizing multiple message streams or batch processing.
+"""
+
+from typing import Any, Dict, List
+from pynode.nodes.base_node import BaseNode, Info, MessageKeys
+
+_info = Info()
+_info.add_text("Buffers messages by index and releases them on command. Useful for collecting messages out of order and releasing them in sequence, or for batch processing.")
+_info.add_header("Inputs")
+_info.add_bullets(
+    ("Input 0:", "Messages to buffer (with index property) or release command")
+)
+_info.add_header("Outputs")
+_info.add_bullets(
+    ("Output 0:", "Buffered messages released in order, or as an array")
+)
+_info.add_header("Configuration")
+_info.add_bullets(
+    ("Index Property:", "Property name containing the message index (e.g., 'index', 'id')"),
+    ("Release Payload:", "Payload value that triggers release (default: 'release')"),
+    ("Output Mode:", "Sequential (one by one) or Array (all at once)"),
+    ("Sort Order:", "Ascending, descending, or arrival order"),
+    ("Clear After Release:", "Whether to clear the buffer after releasing"),
+    ("Max Buffer Size:", "Maximum messages to buffer (oldest dropped when full)")
+)
+_info.add_header("Usage")
+_info.add_text("Send messages with an index property to buffer them. Send a message with payload='release' to output all buffered messages in order.")
+
+
+class SyncNode(BaseNode):
+    """
+    Sync node - buffers messages by index and releases them on command.
+    Messages are stored until a "release" payload is received.
+    """
+    info = str(_info)
+    display_name = 'Sync'
+    icon = '🔄'
+    category = 'logic'
+    color = '#E2D96E'
+    border_color = '#B8AF4A'
+    text_color = '#000000'
+    input_count = 1
+    output_count = 1
+    
+    DEFAULT_CONFIG = {
+        'index_property': 'index',
+        'release_payload': 'release',
+        'output_mode': 'sequential',
+        'sort_order': 'ascending',
+        'clear_on_release': 'true',
+        'max_buffer_size': '1000',
+        'allow_duplicates': 'false'
+    }
+    
+    properties = [
+        {
+            'name': 'index_property',
+            'label': 'Index Property',
+            'type': 'text',
+            'default': DEFAULT_CONFIG['index_property'],
+            'help': 'Property name containing the message index (e.g., "index", "id", "sequence")'
+        },
+        {
+            'name': 'release_payload',
+            'label': 'Release Payload',
+            'type': 'text',
+            'default': DEFAULT_CONFIG['release_payload'],
+            'help': 'Payload value that triggers release (default: "release")'
+        },
+        {
+            'name': 'output_mode',
+            'label': 'Output Mode',
+            'type': 'select',
+            'options': [
+                {'value': 'sequential', 'label': 'Sequential (one by one)'},
+                {'value': 'array', 'label': 'Array (all at once)'}
+            ],
+            'default': DEFAULT_CONFIG['output_mode'],
+            'help': 'How to output buffered messages'
+        },
+        {
+            'name': 'sort_order',
+            'label': 'Sort Order',
+            'type': 'select',
+            'options': [
+                {'value': 'ascending', 'label': 'Ascending (0, 1, 2, ...)'},
+                {'value': 'descending', 'label': 'Descending (..., 2, 1, 0)'},
+                {'value': 'none', 'label': 'None (arrival order)'}
+            ],
+            'default': DEFAULT_CONFIG['sort_order'],
+            'help': 'How to sort messages before release',
+            'showIf': {'output_mode': 'sequential'}
+        },
+        {
+            'name': 'clear_on_release',
+            'label': 'Clear After Release',
+            'type': 'select',
+            'options': [
+                {'value': 'true', 'label': 'Yes (clear buffer)'},
+                {'value': 'false', 'label': 'No (keep buffer)'}
+            ],
+            'default': DEFAULT_CONFIG['clear_on_release'],
+            'help': 'Clear buffer after releasing messages'
+        },
+        {
+            'name': 'max_buffer_size',
+            'label': 'Max Buffer Size',
+            'type': 'text',
+            'default': DEFAULT_CONFIG['max_buffer_size'],
+            'help': 'Maximum number of messages to buffer (0 = unlimited)'
+        },
+        {
+            'name': 'allow_duplicates',
+            'label': 'Allow Duplicate Indices',
+            'type': 'select',
+            'options': [
+                {'value': 'false', 'label': 'No (keep first)'},
+                {'value': 'true', 'label': 'Yes (overwrite with latest)'}
+            ],
+            'default': DEFAULT_CONFIG['allow_duplicates'],
+            'help': 'Allow multiple messages for the same index (false = keep first, true = keep latest)'
+        }
+    ]
+    
+    def __init__(self, node_id=None, name="sync"):
+        super().__init__(node_id, name)
+        # Buffer to store messages: {index: msg}
+        self._buffer: Dict[Any, Dict[str, Any]] = {}
+        # Track arrival order for non-sorted output
+        self._arrival_order: List[Any] = []
+    
+    def on_input(self, msg: Dict[str, Any], input_index: int = 0):
+        """
+        Buffer message by index or release buffered messages.
+        """
+        try:
+            payload = msg.get(MessageKeys.PAYLOAD)
+            release_trigger = self.config.get('release_payload', 'release')
+            
+            # Check if this is a release command
+            if payload == release_trigger:
+                self._release_messages(msg)
+                return
+            
+            # Otherwise, buffer the message
+            index_property = self.config.get('index_property', 'index')
+            
+            # Get index from message
+            if index_property in msg:
+                msg_index = msg[index_property]
+            else:
+                # If no index property, use arrival order
+                msg_index = len(self._buffer)
+            
+            # Check buffer size limit
+            max_size = self.get_config_int('max_buffer_size', 1000)
+            if max_size > 0 and len(self._buffer) >= max_size:
+                self.report_error(f"Buffer full ({max_size} messages), dropping oldest message")
+                # Remove oldest message
+                if self._arrival_order:
+                    oldest_index = self._arrival_order.pop(0)
+                    if oldest_index in self._buffer:
+                        del self._buffer[oldest_index]
+            
+            # Check if duplicate indices are allowed
+            allow_duplicates = self.get_config_bool('allow_duplicates', False)
+            
+            if msg_index in self._buffer:
+                if allow_duplicates:
+                    # Overwrite with latest message
+                    self._buffer[msg_index] = msg
+                else:
+                    # Keep first message, drop this one
+                    # Silently ignore duplicate (already in buffer)
+                    return
+            else:
+                # Store message in buffer (new index)
+                self._buffer[msg_index] = msg
+                # Track arrival order
+                self._arrival_order.append(msg_index)
+            
+        except Exception as e:
+            self.report_error(f"Error buffering message: {str(e)}")
+    
+    def _release_messages(self, trigger_msg: Dict[str, Any]):
+        """
+        Release buffered messages according to configuration.
+        """
+        try:
+            if not self._buffer:
+                # No messages to release
+                output_msg = self.create_message(
+                    payload={
+                        'status': 'empty',
+                        'message': 'No messages in buffer'
+                    },
+                    topic=trigger_msg.get(MessageKeys.TOPIC, 'sync/release')
+                )
+                self.send(output_msg)
+                return
+            
+            # Get sorted indices
+            indices = self._get_sorted_indices()
+            
+            output_mode = self.config.get('output_mode', 'sequential')
+            
+            if output_mode == 'sequential':
+                # Send messages one by one
+                for idx in indices:
+                    if idx in self._buffer:
+                        self.send(self._buffer[idx])
+                
+                # Send completion message
+                completion_msg = self.create_message(
+                    payload={
+                        'status': 'complete',
+                        'released_count': len(indices),
+                        'indices': indices
+                    },
+                    topic=trigger_msg.get(MessageKeys.TOPIC, 'sync/complete')
+                )
+                self.send(completion_msg)
+                
+            elif output_mode == 'array':
+                # Send all messages as an array
+                messages = [self._buffer[idx] for idx in indices if idx in self._buffer]
+                
+                array_msg = self.create_message(
+                    payload={
+                        'messages': messages,
+                        'count': len(messages),
+                        'indices': indices
+                    },
+                    topic=trigger_msg.get(MessageKeys.TOPIC, 'sync/array')
+                )
+                self.send(array_msg)
+            
+            # Clear buffer if configured
+            if self.get_config_bool('clear_on_release', True):
+                self._buffer.clear()
+                self._arrival_order.clear()
+            
+        except Exception as e:
+            self.report_error(f"Error releasing messages: {str(e)}")
+    
+    def _get_sorted_indices(self) -> List[Any]:
+        """
+        Get list of indices sorted according to configuration.
+        """
+        sort_order = self.config.get('sort_order', 'ascending')
+        
+        if sort_order == 'none':
+            # Return in arrival order
+            return self._arrival_order.copy()
+        
+        # Get indices and try to sort them
+        indices = list(self._buffer.keys())
+        
+        try:
+            if sort_order == 'ascending':
+                return sorted(indices)
+            elif sort_order == 'descending':
+                return sorted(indices, reverse=True)
+        except TypeError:
+            # If indices can't be compared (mixed types), use arrival order
+            return self._arrival_order.copy()
+        
+        return indices
+    
+    def get_buffer_status(self) -> Dict[str, Any]:
+        """
+        Get current buffer status.
+        """
+        return {
+            'buffer_size': len(self._buffer),
+            'indices': list(self._buffer.keys()),
+            'arrival_order': self._arrival_order.copy()
+        }
+    
+    def clear_buffer(self):
+        """
+        Manually clear the buffer.
+        """
+        self._buffer.clear()
+        self._arrival_order.clear()

pynode/nodes/TemplateNode/requirements.txt

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

pynode/nodes/TemplateNode/template_node.py

@@ -0,0 +1,86 @@
+"""
+Template for creating custom nodes.
+This demonstrates how third-party developers can create their own nodes.
+"""
+
+from typing import Any, Dict
+from pynode.nodes.base_node import BaseNode, Info, MessageKeys
+
+# Build info content
+_info = Info()
+_info.add_text("Template node for creating custom third-party nodes.")
+_info.add_text("Copy this file and modify to create your own nodes.")
+_info.add_header("Inputs")
+_info.add_bullet("Input 0:", "Any message to process through the template")
+_info.add_header("Outputs")
+_info.add_bullet("Output 0:", "Message with payload replaced by template output")
+_info.add_header("Properties")
+_info.add_bullet("Template:", "Text template with {{payload}} and {{topic}} placeholders")
+_info.add_bullet("Output Format:", "Format type: plain, json, or html")
+_info.add_header("Template Variables")
+_info.add_bullet("{{payload}}:", "Replaced with the message payload")
+_info.add_bullet("{{topic}}:", "Replaced with the message topic")
+
+
+class TemplateNode(BaseNode):
+    """
+    Template node - example of a custom third-party node.
+    Copy this file and modify to create your own nodes.
+    """
+    # Visual properties
+    display_name = 'Template'
+    icon = '📄'
+    category = 'system'  # Categories: input, output, function, logic, custom
+    color = '#FFA07A'
+    border_color = '#FF7F50'
+    text_color = '#000000'
+    input_count = 0
+    output_count = 0
+    info = str(_info)
+    hidden = True  # Hide this template node from the palette
+    
+    # Property schema for the properties panel
+    # This defines what fields appear in the UI when the node is selected
+    properties = [
+        {
+            'name': 'template',
+            'label': 'Template',
+            'type': 'textarea'  # Types: text, textarea, select, button
+        },
+        {
+            'name': 'format',
+            'label': 'Output Format',
+            'type': 'select',
+            'options': [
+                {'value': 'plain', 'label': 'Plain Text'},
+                {'value': 'json', 'label': 'JSON'},
+                {'value': 'html', 'label': 'HTML'}
+            ]
+        }
+    ]
+    
+    def __init__(self, node_id=None, name="template"):
+        super().__init__(node_id, name)
+        self.configure({
+            'template': 'Hello {{payload}}',
+            'format': 'plain'
+        })
+    
+    def on_input(self, msg: Dict[str, Any], input_index: int = 0):
+        """
+        Process incoming messages.
+        This method is called when a message arrives at the node.
+        """
+        template = self.config.get('template', '')
+        format_type = self.config.get('format', 'plain')
+        
+        # Simple template replacement (in production, use a proper template engine)
+        output = template.replace('{{payload}}', str(msg.get(MessageKeys.PAYLOAD, '')))
+        output = output.replace('{{topic}}', str(msg.get(MessageKeys.TOPIC, '')))
+        
+        # Preserve original message properties (like frame_count) and update payload
+        # Note: send() handles deep copying, so we modify msg directly
+        msg[MessageKeys.PAYLOAD] = output
+        
+        # Send to connected nodes
+        self.send(msg)

pynode/nodes/TrackerNode/__init__.py

@@ -0,0 +1,2 @@
+from .tracker_node import TrackerNode
+from .supervision_tracker_node import SupervisionTrackerNode