pynode-flow 0.2.0__py3-none-any.whl

pynode/nodes/FilterNode/__init__.py

@@ -0,0 +1,3 @@
+from .filter_node import FilterNode
+
+__all__ = ['FilterNode']

pynode/nodes/FilterNode/filter_node.py

@@ -0,0 +1,102 @@
+"""
+Filter Node - filters messages based on conditions.
+"""
+
+from typing import Any, Dict
+from pynode.nodes.base_node import BaseNode, Info, MessageKeys
+
+_info = Info()
+_info.add_text("Filters messages based on various conditions. Only passes messages that meet the specified criteria.")
+_info.add_header("Inputs")
+_info.add_bullets(
+    ("Input 0:", "Any message to be filtered.")
+)
+_info.add_header("Outputs")
+_info.add_bullets(
+    ("Output 0:", "Messages that pass the filter.")
+)
+_info.add_header("Filter Modes")
+_info.add_bullets(
+    ("Block:", "Block unless payload value changes."),
+    ("Dedupe:", "Block duplicate payloads (same as Block)."),
+    ("Drop First:", "Drop the first N messages, pass the rest."),
+    ("Keep First:", "Keep only the first N messages, drop the rest.")
+)
+
+
+class FilterNode(BaseNode):
+    """
+    Filter Node - only passes messages that meet specified conditions.
+    """
+    display_name = 'Filter'
+    icon = '🔍'
+    category = 'function'
+    color = '#FFB6C1'
+    border_color = '#FF69B4'
+    text_color = '#000000'
+    input_count = 1
+    output_count = 1
+    info = str(_info)
+    
+    properties = [
+        {
+            'name': 'mode',
+            'label': 'Mode',
+            'type': 'select',
+            'options': [
+                {'value': 'block', 'label': 'Block unless value changes'},
+                {'value': 'dedupe', 'label': 'Deduplicate (block duplicates)'},
+                {'value': 'drop_first', 'label': 'Drop first N messages'},
+                {'value': 'keep_first', 'label': 'Keep only first N messages'}
+            ]
+        },
+        {
+            'name': 'count',
+            'label': 'Count',
+            'type': 'number',
+            'default': 1
+        }
+    ]
+    
+    def __init__(self, node_id=None, name="filter"):
+        super().__init__(node_id, name)
+        self.configure({
+            'mode': 'dedupe',
+            'count': 1,
+            'drop_messages': False
+        })
+        self.last_value = None
+        self.message_count = 0
+    
+    def on_input(self, msg: Dict[str, Any], input_index: int = 0):
+        """Filter messages based on configured mode."""
+        mode = self.config.get('mode', 'dedupe')
+        payload = msg.get(MessageKeys.PAYLOAD)
+        
+        should_send = False
+        
+        if mode == 'block':
+            # Block unless value changes
+            if payload != self.last_value:
+                should_send = True
+                self.last_value = payload
+        elif mode == 'dedupe':
+            # Deduplicate
+            if payload != self.last_value:
+                should_send = True
+                self.last_value = payload
+        elif mode == 'drop_first':
+            # Drop first N messages
+            count = self.get_config_int('count', 1)
+            self.message_count += 1
+            if self.message_count > count:
+                should_send = True
+        elif mode == 'keep_first':
+            # Keep only first N messages
+            count = self.get_config_int('count', 1)
+            self.message_count += 1
+            if self.message_count <= count:
+                should_send = True
+        
+        if should_send:
+            self.send(msg)

pynode/nodes/FilterNode/requirements.txt

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

pynode/nodes/FrameSourceNode/__init__.py

@@ -0,0 +1,4 @@
+from .frame_source_node import FrameSourceNode
+
+__all__ = ['FrameSourceNode']
+

pynode/nodes/FrameSourceNode/frame_source_node.py

@@ -0,0 +1,319 @@
+"""
+Frame Source node - captures frames from various video sources.
+"""
+
+import cv2
+import base64
+import os
+import threading
+import time
+import sys
+from pathlib import Path
+from typing import Any, Dict
+from pynode.nodes.base_node import BaseNode, Info, MessageKeys
+
+_info = Info()
+_info.add_text("Captures frames from various video sources and outputs them as messages. Supports webcams, video files, RTSP streams, image folders, and specialized cameras.")
+_info.add_header("Outputs")
+_info.add_bullets(
+    ("Output 0:", "Frame message with image data (numpy array or JPEG encoded).")
+)
+_info.add_header("Source Types")
+_info.add_bullets(
+    ("Webcam:", "Local USB webcam (source = device index, e.g. 0)"),
+    ("Video File:", "MP4, AVI, or other video files"),
+    ("RTSP Stream:", "IP camera RTSP URL"),
+    ("Image Folder:", "Directory of images to cycle through"),
+    ("Basler:", "Basler industrial camera"),
+    ("RealSense:", "Intel RealSense depth camera (includes depth data)"),
+    ("Screen Capture:", "Desktop screen recording"),
+    ("GenICam:", "GenICam-compatible industrial cameras"),
+    ("Audio Spectrogram:", "Audio visualization as frames")
+)
+_info.add_header("Output Format")
+_info.add_bullets(
+    (f"{MessageKeys.PAYLOAD}.image:", "Image data as numpy array or base64 JPEG"),
+    (f"{MessageKeys.PAYLOAD}.frame_count:", "Frame sequence number"),
+    (f"{MessageKeys.PAYLOAD}.width/height:", "Frame dimensions"),
+    (f"{MessageKeys.PAYLOAD}.loop:", "Indicates if the video/folder is looping")
+)
+
+# Add FrameSource package to path
+_framesource_path = Path(__file__).parent / 'FrameSource'
+if str(_framesource_path) not in sys.path:
+    sys.path.insert(0, str(_framesource_path))
+
+from frame_source import FrameSourceFactory
+
+
+class FrameSourceNode(BaseNode):
+    """
+    Frame Source node - captures frames from a webcam and outputs them as messages.
+    """
+    display_name = 'Frame Source'
+    icon = '📷'
+    category = 'input'
+    color = '#C0DEED'
+    border_color = '#7FA7C9'
+    text_color = '#000000'
+    input_count = 0  # No input
+    output_count = 1
+    info = str(_info)
+
+    api_routes = [
+        {
+            'route': 'upload_video',
+            'methods': ['POST'],
+            'handler': 'handle_upload_video',
+            'type': 'file_upload',
+            'allowed_extensions': {'.mp4', '.avi', '.mkv', '.mov', '.wmv', '.flv', '.webm', '.m4v', '.mpg', '.mpeg'},
+        },
+    ]
+
+    DEFAULT_CONFIG = {
+        MessageKeys.CAMERA.SOURCE_TYPE: 'webcam',
+        MessageKeys.CAMERA.SOURCE: 0,
+        MessageKeys.CAMERA.FPS: 30,
+        MessageKeys.CAMERA.WIDTH: 640,
+        MessageKeys.CAMERA.HEIGHT: 480,
+        MessageKeys.CAMERA.ENCODE_JPEG: False,
+        MessageKeys.CAMERA.JPEG_QUALITY: 75,
+        MessageKeys.VIDEO.LOOP: True
+    }
+
+    properties = [
+        {
+            'name': MessageKeys.CAMERA.SOURCE_TYPE,
+            'label': 'Source Type',
+            'type': 'select',
+            'options': [
+                {'value': 'webcam', 'label': 'Webcam'},
+                {'value': 'video_file', 'label': 'Video File'},
+                {'value': 'ipcam', 'label': 'RTSP Stream'},
+                {'value': 'folder', 'label': 'Image Folder'},
+                {'value': 'basler', 'label': 'Basler Camera'},
+                {'value': 'realsense', 'label': 'RealSense'},
+                {'value': 'screen', 'label': 'Screen Capture'},
+                {'value': 'genicam', 'label': 'GenICam Camera'},
+                {'value': 'audio_spectrogram', 'label': 'Audio Spectrogram'}
+            ],
+            'default': DEFAULT_CONFIG[MessageKeys.CAMERA.SOURCE_TYPE],
+        },
+        {
+            'name': MessageKeys.CAMERA.SOURCE,
+            'label': 'Video File',
+            'type': 'file',
+            'accept': '.mp4,.avi,.mkv,.mov,.wmv,.flv,.webm,.m4v,.mpg,.mpeg',
+            'uploadRoute': 'upload_video',
+            'placeholder': 'Upload or enter video file path...',
+            'showIf': {MessageKeys.CAMERA.SOURCE_TYPE: 'video_file'},
+        },
+        {
+            'name': MessageKeys.CAMERA.SOURCE,
+            'label': 'Source',
+            'type': 'text',
+            'default': str(DEFAULT_CONFIG[MessageKeys.CAMERA.SOURCE]),
+            'showIf': {MessageKeys.CAMERA.SOURCE_TYPE: ['webcam', 'ipcam', 'folder', 'basler', 'realsense', 'screen', 'genicam', 'audio_spectrogram']},
+        },
+        {
+            'name': MessageKeys.CAMERA.FPS,
+            'label': 'Frame Rate (FPS)',
+            'type': 'number',
+            'default': DEFAULT_CONFIG[MessageKeys.CAMERA.FPS]
+        },
+        {
+            'name': MessageKeys.VIDEO.LOOP,
+            'label': 'Loop Video/Folder',
+            'type': 'checkbox',
+            'default': DEFAULT_CONFIG[MessageKeys.VIDEO.LOOP],
+            'showIf': {MessageKeys.CAMERA.SOURCE_TYPE: ['video_file', 'folder']}
+        },
+        {
+            'name': MessageKeys.CAMERA.WIDTH,
+            'label': 'Width',
+            'type': 'number',
+            'default': DEFAULT_CONFIG[MessageKeys.CAMERA.WIDTH]
+        },
+        {
+            'name': MessageKeys.CAMERA.HEIGHT,
+            'label': 'Height',
+            'type': 'number',
+            'default': DEFAULT_CONFIG[MessageKeys.CAMERA.HEIGHT]
+        },
+        {
+            'name': MessageKeys.CAMERA.ENCODE_JPEG,
+            'label': 'Encode as JPEG',
+            'type': 'checkbox',
+            'default': DEFAULT_CONFIG[MessageKeys.CAMERA.ENCODE_JPEG]
+        },
+        {
+            'name': MessageKeys.CAMERA.JPEG_QUALITY,
+            'label': 'JPEG Quality (1-100)',
+            'type': 'number',
+            'default': DEFAULT_CONFIG[MessageKeys.CAMERA.JPEG_QUALITY]
+        }
+    ]
+    
+    def __init__(self, node_id=None, name="camera"):
+        super().__init__(node_id, name)
+        self.camera = None
+        self.capture_thread = None
+        self.running = False
+        self.frame_count = 0
+    
+    def handle_upload_video(self, file_bytes, filename):
+        """Handle video file upload via the dynamic API route."""
+        try:
+            # Save to a videos directory next to this node
+            videos_dir = os.path.join(os.path.dirname(__file__), 'videos')
+            os.makedirs(videos_dir, exist_ok=True)
+            
+            file_path = os.path.join(videos_dir, os.path.basename(filename))
+            with open(file_path, 'wb') as f:
+                f.write(file_bytes)
+            
+            return {
+                'success': True,
+                'file_path': file_path,
+                'filename': filename
+            }
+        except Exception as e:
+            return {
+                'success': False,
+                'error': str(e)
+            }
+
+    def on_start(self):
+        """Start the camera capture when workflow starts."""
+        super().on_start()  # Start base node worker thread
+        
+        source_type = self.config.get(MessageKeys.CAMERA.SOURCE_TYPE, 'webcam')
+        source = self.config.get(MessageKeys.CAMERA.SOURCE, 0)
+        fps = self.get_config_int(MessageKeys.CAMERA.FPS, 30)
+        width = self.get_config_int(MessageKeys.CAMERA.WIDTH, 640)
+        height = self.get_config_int(MessageKeys.CAMERA.HEIGHT, 480)
+        loop = self.get_config_bool(MessageKeys.VIDEO.LOOP, False)
+        
+        try:
+            # Create camera with config including resolution and fps
+            self.camera = FrameSourceFactory.create(
+                source_type, 
+                source=source,
+                width=width,
+                height=height,
+                fps=fps,
+                loop=loop
+            )
+            
+            if not self.camera.connect():
+                self.report_error(f"Failed to connect to {source_type} source: {source}")
+                return
+            
+            self.frame_count = 0  # Reset frame counter on start
+            
+            # Start capture thread
+            self.running = True
+            self.capture_thread = threading.Thread(target=self._capture_loop, args=(fps,), daemon=True)
+            self.capture_thread.start()
+            
+        except Exception as e:
+            self.report_error(f"Error starting camera: {e}")
+    
+    def on_stop(self):
+        """Stop the camera capture when workflow stops."""
+        super().on_stop()  # Stop base node worker thread
+        
+        self.running = False
+        
+        if self.capture_thread:
+            self.capture_thread.join(timeout=2.0)
+            self.capture_thread = None
+        
+        if self.camera:
+            self.camera.release()
+            self.camera = None
+    
+    def on_close(self):
+        """Cleanup when node is deleted."""
+        self.on_stop()
+    
+    def _capture_loop(self, fps):
+        """Capture frames in a loop and send them as messages."""
+        frame_interval = 1.0 / fps
+        encode_jpeg = self.config.get(MessageKeys.CAMERA.ENCODE_JPEG, False)
+        
+        while self.running and self.camera and self.camera.isOpened():
+            start_time = time.time()
+            
+            try:
+                ret, frame = self.camera.read()
+                
+                # Check if frame has 4 channels (RGBD data)
+                if ret and frame is not None and len(frame.shape) == 3 and frame.shape[2] == 4:
+                    # Split RGB and depth channels
+                    rgb_frame = frame[:, :, :3]
+                    depth_channel = frame[:, :, 3]
+                    frame = rgb_frame
+                    has_depth = True
+                else:
+                    has_depth = False
+                    depth_channel = None
+                
+                if not ret or frame is None:
+                    self.report_error("Failed to capture frame")
+                    time.sleep(frame_interval)
+                    continue
+                
+                # Prepare the payload
+                if encode_jpeg:
+                    # Encode frame as JPEG with quality setting
+                    jpeg_quality = self.get_config_int(MessageKeys.IMAGE.JPEG_QUALITY, 75)
+                    encode_params = [cv2.IMWRITE_JPEG_QUALITY, jpeg_quality]
+                    ret, buffer = cv2.imencode('.jpg', frame, encode_params)
+                    if ret:
+                        # Convert to bytes (more efficient than base64)
+                        jpeg_bytes = buffer.tobytes()
+                        # Convert to base64 for JSON transmission
+                        jpeg_base64 = base64.b64encode(jpeg_bytes).decode('utf-8')
+                        payload = {
+                            MessageKeys.IMAGE.FORMAT: 'jpeg',
+                            MessageKeys.IMAGE.ENCODING: 'base64',
+                            MessageKeys.IMAGE.DATA: jpeg_base64,
+                            MessageKeys.IMAGE.WIDTH: frame.shape[1],
+                            MessageKeys.IMAGE.HEIGHT: frame.shape[0]
+                        }
+                    else:
+                        self.report_error("Failed to encode JPEG")
+                        continue
+                else:
+                    # Send raw frame as numpy array
+                    payload = {
+                        MessageKeys.IMAGE.FORMAT: 'bgr',
+                        MessageKeys.IMAGE.ENCODING: 'numpy',
+                        MessageKeys.IMAGE.DATA: frame,
+                        MessageKeys.IMAGE.WIDTH: frame.shape[1],
+                        MessageKeys.IMAGE.HEIGHT: frame.shape[0]
+                    }
+                
+                # Create message payload
+                message_payload: Dict[str, Any] = {MessageKeys.IMAGE.PATH: payload}
+                
+                # Add depth data if available (compatible with RealsenseDepthNode)
+                if has_depth:
+                    message_payload['depth'] = depth_channel
+                
+                # Increment frame counter
+                self.frame_count += 1
+                
+                # Create and send message
+                msg = self.create_message(payload=message_payload, topic='camera/frame', frame_count=self.frame_count)
+                self.send(msg)
+                
+            except Exception as e:
+                self.report_error(f"Error capturing frame: {e}")
+            
+            # Maintain frame rate
+            elapsed = time.time() - start_time
+            sleep_time = max(0, frame_interval - elapsed)
+            if sleep_time > 0:
+                time.sleep(sleep_time)

pynode/nodes/FrameSourceNode/requirements.txt

@@ -0,0 +1 @@
+framesource[full]

pynode/nodes/FunctionNode/__init__.py

@@ -0,0 +1,3 @@
+from .function_node import FunctionNode
+
+__all__ = ['FunctionNode']

pynode/nodes/FunctionNode/function_node.py

@@ -0,0 +1,168 @@
+"""
+Function node - executes custom Python code on messages.
+Similar to Node-RED's function node.
+"""
+
+import time
+import copy
+from typing import Any, Dict
+from pynode.nodes.base_node import BaseNode, Info, MessageKeys
+
+_info = Info()
+_info.add_text("Executes custom Python code on incoming messages. Similar to Node-RED's function node.")
+_info.add_header("Inputs")
+_info.add_bullets(
+    ("Input 0:", "Any message to process.")
+)
+_info.add_header("Outputs")
+_info.add_bullets(
+    ("Output 0-N:", "Processed message(s). Configure number of outputs in properties.")
+)
+_info.add_header("Available Variables")
+_info.add_bullets(
+    ("msg:", "The incoming message dictionary."),
+    ("node:", "Reference to this node (for node.send(), node.report_error())."),
+    ("time:", "Python time module.")
+)
+_info.add_header("Example")
+_info.add_code(f"msg['{MessageKeys.PAYLOAD}'] = msg['{MessageKeys.PAYLOAD}'] * 2\nreturn msg").text("Doubles the payload value and returns the modified message.").end()
+_info.add_header("Multiple Outputs")
+_info.add_code(f"return [msg, None, {{'{MessageKeys.PAYLOAD}': 'alt'}}]").text("Returns array to send to different outputs. None skips that output.").end()
+
+
+class FunctionNode(BaseNode):
+    """
+    Function node - executes custom Python code on messages.
+    Similar to Node-RED's function node.
+    """
+    display_name = 'Function'
+    icon = 'ƒ'
+    category = 'function'
+    color = '#E6E0F8'
+    border_color = '#9F93C6'
+    text_color = '#000000'
+    input_count = 1
+    output_count = 1
+    info = str(_info)
+    
+    properties = [
+        {
+            'name': 'func',
+            'label': 'Function',
+            'type': 'textarea'
+        },
+        {
+            'name': 'outputs',
+            'label': 'Outputs',
+            'type': 'number',
+            'default': 1,
+            'min': 1,
+            'max': 10
+        }
+    ]
+    
+    def __init__(self, node_id=None, name="function"):
+        super().__init__(node_id, name)
+    
+    def configure(self, config: Dict[str, Any]):
+        """Configure the node and update output_count based on outputs setting."""
+        super().configure(config)
+        self.output_count = self.get_config_int('outputs', 1)
+    
+    def on_input(self, msg: Dict[str, Any], input_index: int = 0):
+        """
+        Execute the function code on the incoming message.
+        """
+        try:
+            func_code = self.config.get('func', 'return msg')
+            
+            # Wrap the user's code in a function to support return statements
+            wrapped_code = f'''def user_function(msg, node, time):
+{chr(10).join("    " + line for line in func_code.split(chr(10)))}
+
+result = user_function(msg, node, time)
+'''
+            
+            # Create a deep copy to avoid modifying the original and handle non-serializable objects
+            try:
+                msg_copy = copy.deepcopy(msg)
+            except Exception:
+                # If deep copy fails, use shallow copy and let user handle it
+                msg_copy = msg.copy()
+            
+            # Create a safe execution context with helpful utilities
+            context = {
+                'msg': msg_copy,
+                'node': self,
+                'time': time,
+                # Add common utilities
+                'isinstance': isinstance,
+                'dict': dict,
+                'list': list,
+                'str': str,
+                'int': int,
+                'float': float,
+                'set': set,
+                'tuple': tuple
+            }
+            
+            # Execute the wrapped function
+            exec(wrapped_code, context)
+            
+            # Get the result
+            result = context.get('result')
+            
+            if result is not None:
+                if isinstance(result, list):
+                    # Multiple outputs
+                    for idx, out_msg in enumerate(result):
+                        if out_msg is not None:
+                            self.send(out_msg, idx)
+                else:
+                    # Single output
+                    self.send(result)
+                    
+        except SyntaxError as e:
+            # Provide helpful syntax error messages with line numbers
+            line_num = e.lineno - 1 if e.lineno else 0  # Adjust for wrapper function
+            user_lines = func_code.split('\n')
+            
+            error_context = f"Syntax error on line {line_num}: {e.msg}\n"
+            if 0 <= line_num - 1 < len(user_lines):
+                error_context += f"  {line_num}: {user_lines[line_num - 1]}\n"
+            if 0 <= line_num < len(user_lines):
+                error_context += f"→ {line_num + 1}: {user_lines[line_num]}\n"
+            if line_num + 1 < len(user_lines):
+                error_context += f"  {line_num + 2}: {user_lines[line_num + 1]}\n"
+            
+            self.report_error(error_context)
+            error_msg = self.create_message(
+                payload={'error': error_context, 'type': 'SyntaxError'},
+                topic='error'
+            )
+            self.send(error_msg)
+            
+        except Exception as e:
+            # Provide more helpful error messages
+            error_str = str(e)
+            payload_type = type(msg.get(MessageKeys.PAYLOAD)).__name__
+            
+            # Add context-specific hints
+            if "does not support item assignment" in error_str:
+                hint = f"Hint: msg['{MessageKeys.PAYLOAD}'] is a {payload_type}, not a dict. "
+                if payload_type in ['float', 'int', 'str', 'bool']:
+                    hint += f"To add an index, wrap it: msg['{MessageKeys.PAYLOAD}'] = {{'value': msg['{MessageKeys.PAYLOAD}'], 'index': 0}}"
+                error_str = hint + " Error: " + error_str
+            
+            # Report error to the error system
+            self.report_error(f"Function error: {error_str}")
+            # Also send error downstream for debugging
+            error_msg = self.create_message(
+                payload={
+                    'error': error_str,
+                    'original_payload': msg.get(MessageKeys.PAYLOAD),
+                    'payload_type': payload_type
+                },
+                topic='error'
+            )
+            self.send(error_msg)

pynode/nodes/FunctionNode/requirements.txt

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

pynode/nodes/GateNode/gate_node.py

@@ -0,0 +1,60 @@
+"""
+Gate node - allows messages to pass through or blocks them.
+Can be toggled on/off directly from the UI without redeployment.
+"""
+
+from typing import Any, Dict
+from pynode.nodes.base_node import BaseNode, Info, MessageKeys
+
+_info = Info()
+_info.add_text("Allows or blocks messages from passing through. Can be toggled on/off in real-time from the UI without redeploying.")
+_info.add_header("Inputs")
+_info.add_bullets(
+    ("Input 0:", "Any message.")
+)
+_info.add_header("Outputs")
+_info.add_bullets(
+    ("Output 0:", "Messages pass through when gate is open.")
+)
+_info.add_header("Usage")
+_info.add_bullets(
+    ("Toggle:", "Click the toggle button on the node to open/close the gate."),
+    ("Open:", "Messages pass through unchanged."),
+    ("Closed:", "Messages are silently discarded.")
+)
+
+
+class GateNode(BaseNode):
+    """
+    Gate node - allows or blocks messages based on enabled state.
+    Can be toggled in real-time from the UI.
+    """
+    display_name = 'Gate'
+    icon = '🚪'
+    category = 'logic'
+    color = '#FFE5B4'
+    border_color = '#FFD700'
+    text_color = '#000000'
+    input_count = 1
+    output_count = 1
+    info = str(_info)
+    ui_component = 'toggle'
+    ui_component_config = {
+        'action': 'toggle_gate',
+        'label': 'Open'
+    }
+    
+    properties = []  # No properties panel needed
+    
+    def __init__(self, node_id=None, name="gate"):
+        super().__init__(node_id, name)
+        self.enabled = True  # Gate is open (enabled) by default
+        self.configure({})
+    
+    def on_input(self, msg: Dict[str, Any], input_index: int = 0):
+        """
+        Pass message through if gate is enabled, otherwise discard it.
+        """
+        if self.enabled:
+            self.send(msg)
+        # If gate is disabled, message is silently discarded

pynode/nodes/GateNode/requirements.txt

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

pynode/nodes/GetiUploadNode/__init__.py

@@ -0,0 +1,3 @@
+from .geti_upload_node import GetiUploadNode
+
+__all__ = ['GetiUploadNode']