pynode-flow 0.2.0__py3-none-any.whl

pynode/install_nodes.py

@@ -0,0 +1,143 @@
+"""Install per-node dependencies for an installed PyNode package.
+
+Each node under ``pynode/nodes/<NodeName>/`` may ship a ``requirements.txt``
+listing packages it needs. Those files are *not* installed by ``pip install
+pynode-flow`` -- pip only reads the dependencies/extras in ``pyproject.toml``.
+
+Most node dependencies are covered by the ``pip install "pynode-flow[full]"``
+extra. This command is the escape hatch for the rest: it walks the node folders
+of the *installed* package (so it works from a plain ``pip install``, not only a
+source checkout) and runs ``pip install -r`` for each node, which is the only
+way to pull dependencies that cannot live in ``pyproject.toml`` -- e.g. vendor
+SDKs like the Omron/Sentech ``stapipy`` (OmronCameraNode).
+
+Usage::
+
+    pynode-install-nodes                 # install deps for every node
+    pynode-install-nodes --node MQTTNode # only the named node(s)
+    pynode-install-nodes --list          # show nodes with a requirements.txt
+    pynode-install-nodes --dry-run       # print what would be installed
+"""
+
+from __future__ import annotations
+
+import argparse
+import logging
+import subprocess
+import sys
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+
+def _nodes_dir() -> Path:
+    """Return the ``nodes`` directory that ships inside this package."""
+    return Path(__file__).resolve().parent / "nodes"
+
+
+def _has_real_requirements(requirements_file: Path) -> bool:
+    """True if the file lists at least one non-comment, non-blank requirement."""
+    try:
+        for raw_line in requirements_file.read_text(encoding="utf-8").splitlines():
+            line = raw_line.strip()
+            if line and not line.startswith("#"):
+                return True
+    except OSError:
+        return False
+    return False
+
+
+def find_node_requirements(nodes_dir: Path | None = None) -> list[tuple[str, Path]]:
+    """Return ``(node_name, requirements_path)`` for nodes with real requirements."""
+    nodes_dir = nodes_dir or _nodes_dir()
+    found: list[tuple[str, Path]] = []
+    if not nodes_dir.is_dir():
+        return found
+    for node_dir in sorted(p for p in nodes_dir.iterdir() if p.is_dir()):
+        if node_dir.name.startswith("__"):
+            continue
+        requirements_file = node_dir / "requirements.txt"
+        if requirements_file.is_file() and _has_real_requirements(requirements_file):
+            found.append((node_dir.name, requirements_file))
+    return found
+
+
+def install_node_requirements(
+    only: list[str] | None = None,
+    dry_run: bool = False,
+    nodes_dir: Path | None = None,
+) -> int:
+    """Install per-node requirements. Returns the number of nodes that failed."""
+    requirements = find_node_requirements(nodes_dir)
+    if only:
+        wanted = {name.lower() for name in only}
+        requirements = [item for item in requirements if item[0].lower() in wanted]
+        missing = wanted - {name.lower() for name, _ in requirements}
+        for name in sorted(missing):
+            logger.warning("No node named %r with a requirements.txt was found", name)
+
+    if not requirements:
+        logger.info("No node dependencies to install.")
+        return 0
+
+    failures = 0
+    for node_name, requirements_file in requirements:
+        logger.info("Installing requirements for %s...", node_name)
+        cmd = [sys.executable, "-m", "pip", "install", "-r", str(requirements_file)]
+        if dry_run:
+            logger.info("  [dry-run] %s", " ".join(cmd))
+            continue
+        result = subprocess.run(cmd, check=False)
+        if result.returncode == 0:
+            logger.info("  ✓ %s dependencies installed", node_name)
+        else:
+            failures += 1
+            logger.error("  ✗ Failed to install dependencies for %s", node_name)
+
+    installed = len(requirements) - failures
+    logger.info(
+        "Done. Processed %d node(s); %d succeeded, %d failed.",
+        len(requirements),
+        installed if not dry_run else 0,
+        failures,
+    )
+    return failures
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="pynode-install-nodes",
+        description="Install the per-node Python dependencies bundled with PyNode.",
+    )
+    parser.add_argument(
+        "--node",
+        action="append",
+        dest="nodes",
+        metavar="NodeName",
+        help="Only install this node's requirements (repeatable).",
+    )
+    parser.add_argument(
+        "--list",
+        action="store_true",
+        help="List nodes that ship a requirements.txt and exit.",
+    )
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Show what would be installed without running pip.",
+    )
+    args = parser.parse_args(argv)
+
+    logging.basicConfig(level=logging.INFO, format="%(message)s")
+
+    if args.list:
+        for node_name, requirements_file in find_node_requirements():
+            print(f"{node_name}: {requirements_file}")
+        return 0
+
+    failures = install_node_requirements(only=args.nodes, dry_run=args.dry_run)
+    return 1 if failures else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

pynode/main.py

@@ -0,0 +1,118 @@
+"""
+PyNode - A Node-RED-like Visual Workflow System with Python Backend
+
+This is a complete system for creating visual workflows with Python nodes.
+Each node represents a function/operation and can be connected to create data pipelines.
+
+Quick Start:
+1. Install: pip install -e .
+2. Run: pynode
+3. Open browser: http://localhost:5000
+
+Usage Example:
+    from pynode.workflow_engine import WorkflowEngine
+    from pynode.nodes import InjectNode, DebugNode
+    
+    engine = WorkflowEngine()
+    engine.register_node_type(InjectNode)
+    engine.register_node_type(DebugNode)
+    
+    inject = engine.create_node('InjectNode', name='my_inject')
+    debug = engine.create_node('DebugNode', name='my_debug')
+    engine.connect_nodes(inject.id, debug.id)
+    engine.start()
+"""
+
+import argparse
+import logging
+import os
+
+logger = logging.getLogger(__name__)
+
+
+def main():
+    """Main entry point for PyNode application."""
+    # Parse command line arguments
+    parser = argparse.ArgumentParser(description='PyNode Visual Workflow System')
+    parser.add_argument('--production', action='store_true',
+                        help='Run in production mode using Waitress server')
+    parser.add_argument('--host', default='0.0.0.0',
+                        help='Host address to bind to (default: 0.0.0.0)')
+    parser.add_argument('--port', type=int, default=5000,
+                        help='Port to bind to (default: 5000)')
+    parser.add_argument('--log-level', default='INFO',
+                        help='Logging level (DEBUG, INFO, WARNING, ERROR). Default: INFO')
+    parser.add_argument('--cors-origins', default=None,
+                        help='Comma-separated list of allowed CORS origins '
+                             '(default: * i.e. all origins). '
+                             'Also settable via the PYNODE_CORS_ORIGINS env var.')
+    parser.add_argument('--api-key', default=None,
+                        help='Require this API key on all /api/ requests '
+                             '(X-API-Key header or api_key query parameter). '
+                             'Also settable via the PYNODE_API_KEY env var. '
+                             'Default: no authentication.')
+    parser.add_argument('--data-dir', default=None,
+                        help='Directory for PyNode data; workflows are '
+                             'persisted under <data-dir>/workflows/. '
+                             'Also settable via the PYNODE_DATA_DIR env var. '
+                             'Default: the source checkout root when running '
+                             'from a checkout, otherwise ~/.pynode.')
+    args = parser.parse_args()
+
+    # Configure application-wide logging
+    logging.basicConfig(
+        level=getattr(logging, args.log_level.upper(), logging.INFO),
+        format='%(asctime)s [%(levelname)s] %(name)s: %(message)s'
+    )
+
+    # CORS and the data directory are configured when pynode.server is first
+    # imported (it builds the module-level default app), so the CLI flags
+    # must be exported to the environment BEFORE the import below.
+    # (This is why the server import lives inside main() rather than at
+    # module top.) The env var names live in pynode.config.
+    if args.cors_origins is not None:
+        os.environ['PYNODE_CORS_ORIGINS'] = args.cors_origins
+    if args.data_dir is not None:
+        os.environ['PYNODE_DATA_DIR'] = args.data_dir
+
+    from pynode.server import app, load_workflow_from_disk
+
+    # The API key is read dynamically from app.config on every request, so
+    # it can simply be set after import. CLI flag wins over the env var
+    # (which server.py already applied as the app.config default).
+    if args.api_key is not None:
+        app.config['PYNODE_API_KEY'] = args.api_key
+
+    if app.config.get('PYNODE_API_KEY'):
+        logger.info("API key authentication ENABLED: /api/ requests require "
+                    "the X-API-Key header or api_key query parameter")
+    if args.cors_origins is not None:
+        logger.info(f"CORS allowed origins: {args.cors_origins}")
+
+    # Load workflow from disk on startup
+    logger.info("Loading workflow from disk...")
+    load_workflow_from_disk()
+    
+    if args.production:
+        # Production mode with Waitress
+        try:
+            from waitress import serve
+            logger.info("Starting PyNode server in PRODUCTION mode...")
+            logger.info(f"Server running at: http://{args.host}:{args.port}")
+            logger.info("Supports unlimited concurrent connections")
+            serve(app, host=args.host, port=args.port, threads=10, 
+                  channel_timeout=120, backlog=1024, connection_limit=1000)
+        except ImportError:
+            logger.error("waitress not installed. Install with: pip install waitress")
+            logger.warning("Falling back to development server...")
+            app.run(debug=False, host=args.host, port=args.port, threaded=True)
+    else:
+        # Development mode with Flask built-in server
+        logger.info("Starting PyNode server in DEVELOPMENT mode...")
+        logger.info(f"Server running at: http://{args.host}:{args.port}")
+        logger.info("For production use: pynode --production")
+        app.run(debug=False, host=args.host, port=args.port, threaded=True)
+
+
+if __name__ == '__main__':
+    main()

pynode/node_registry.py

@@ -0,0 +1,156 @@
+"""Static node-type registries built once at import time.
+
+Node classes are static for the lifetime of the process, so everything here
+(the reference engine used for introspection, the node-types cache served by
+/api/node-types, and the api_routes / sse_handlers registries used for
+dynamic route registration and SSE broadcasting) is safely shared by every
+Flask app / WorkflowManager instance.
+"""
+
+import logging
+
+from pynode.workflow_engine import WorkflowEngine
+from pynode import nodes
+
+logger = logging.getLogger(__name__)
+
+
+def create_workflow_engine():
+    """Create a new WorkflowEngine with all node types registered."""
+    engine = WorkflowEngine()
+    for node_class in nodes.get_all_node_types():
+        engine.register_node_type(node_class)
+    return engine
+
+
+# Reference engine for node type introspection only
+reference_engine = create_workflow_engine()
+
+# Cache for node types (built once at startup or on first request)
+_node_types_cache = None
+
+
+def build_node_types_cache():
+    """Build the node types cache from registered node types."""
+    global _node_types_cache
+
+    from pynode.nodes.base_node import BaseNode
+    base_properties = getattr(BaseNode, 'properties', [])
+
+    # Define category ordering (compared case-insensitively; display casing is
+    # applied by the frontend, e.g. 'opencv' renders as 'OpenCV').
+    category_order = [
+        'common',
+        'input',
+        'output',
+        'function',
+        'logic',
+        'network',
+        'vision',
+        'analysis',
+        'node probes',
+        'opencv'
+    ]
+    category_rank = {c.lower(): i for i, c in enumerate(category_order)}
+
+    node_types = []
+    for name, node_class in reference_engine.node_types.items():
+        # Skip ErrorNode - it's a system node that shouldn't be manually added
+        if node_class.hidden:
+            continue
+
+        display_name = getattr(node_class, 'display_name', name)
+        icon = getattr(node_class, 'icon', '◆')
+        category = getattr(node_class, 'category', 'custom')
+        color = getattr(node_class, 'color', '#2d2d30')
+        border_color = getattr(node_class, 'border_color', '#555')
+        text_color = getattr(node_class, 'text_color', '#d4d4d4')
+        input_count = getattr(node_class, 'input_count', 1)
+        output_count = getattr(node_class, 'output_count', 1)
+
+        # Handle callable properties (get_properties classmethod)
+        if hasattr(node_class, 'get_properties') and callable(node_class.get_properties):
+            node_properties = node_class.get_properties()
+        else:
+            node_properties = getattr(node_class, 'properties', [])
+
+        # Ensure node_properties is iterable (list or tuple)
+        if not isinstance(node_properties, (list, tuple)):
+            node_properties = []
+
+        # Get property names from node-specific properties to avoid duplicates
+        node_prop_names = {prop.get('name') for prop in node_properties if isinstance(prop, dict)}
+
+        # Add base properties that aren't overridden by node-specific properties
+        merged_properties = [prop for prop in base_properties if prop.get('name') not in node_prop_names]
+        # Add all node-specific properties
+        merged_properties.extend(node_properties)
+
+        ui_component = getattr(node_class, 'ui_component', None)
+        ui_component_config = getattr(node_class, 'ui_component_config', {})
+        info = getattr(node_class, 'info', '')
+
+        node_types.append({
+            'type': name,
+            'name': display_name,
+            'icon': icon,
+            'category': category,
+            'color': color,
+            'borderColor': border_color,
+            'textColor': text_color,
+            'inputCount': input_count,
+            'outputCount': output_count,
+            'properties': merged_properties,
+            'uiComponent': ui_component,
+            'uiComponentConfig': ui_component_config,
+            'info': info
+        })
+
+    # Sort node types by category order, then alphabetically by name within
+    # each category. Category comparison is case-insensitive so e.g. nodes
+    # declaring 'opencv' or 'OpenCV' land in the same bucket.
+    def get_category_sort_key(node_type):
+        category = str(node_type['category']).lower()
+        # Categories not in the list go to the end (custom/system/third party)
+        order_index = category_rank.get(category, len(category_order))
+        return (order_index, node_type['name'].lower(), node_type['name'])
+
+    node_types.sort(key=get_category_sort_key)
+
+    _node_types_cache = node_types
+    return _node_types_cache
+
+
+def get_node_types():
+    """Return the node-types cache, building it on first use if needed."""
+    if _node_types_cache is None:
+        build_node_types_cache()
+    return _node_types_cache
+
+
+# Build a registry of node types that have SSE handlers
+# Maps node_type_name -> list of sse_handler defs
+sse_handler_registry = {}
+
+# Build a registry of node types that have api_routes
+# Maps node_type_name -> list of route defs
+api_route_registry = {}
+
+
+def _build_node_registries():
+    """Scan all node classes and build registries for API routes and SSE handlers."""
+    for node_class in nodes.get_all_node_types():
+        node_type_name = node_class.__name__
+
+        api_routes = getattr(node_class, 'api_routes', [])
+        if api_routes:
+            api_route_registry[node_type_name] = api_routes
+
+        sse_handlers = getattr(node_class, 'sse_handlers', [])
+        if sse_handlers:
+            sse_handler_registry[node_type_name] = sse_handlers
+
+
+# Build caches/registries at import
+build_node_types_cache()
+_build_node_registries()

pynode/nodes/AutoSyncNode/auto_sync_node.py

@@ -0,0 +1,151 @@
+"""
+Auto Sync Node - joins messages from multiple inputs and outputs them together.
+Simply buffers the latest message from each input and outputs all when a new message arrives.
+"""
+
+from typing import Any, Dict, Optional
+from pynode.nodes.base_node import BaseNode, Info, MessageKeys
+
+_info = Info()
+_info.add_text("Joins messages from multiple inputs by buffering the latest message from each input and outputting them together when any new message arrives.")
+_info.add_header("Inputs")
+_info.add_bullets(
+    ("Input 0-N:", "Messages to synchronize. The node buffers the latest message from each input."),
+)
+_info.add_header("Output")
+_info.add_bullets(
+    ("payload.messages:", "Array of payloads from all buffered messages."),
+    ("payload.sync_values:", "Array of sync property values from each message."),
+    ("payload.delta:", "Difference between max and min sync values."),
+)
+_info.add_header("Properties")
+_info.add_bullets(
+    ("Number of Inputs:", "How many input ports to synchronize (2-10)."),
+    ("Sync Property Path:", "Property path to extract for delta calculation (e.g., 'frame_count')."),
+)
+
+
+class AutoSyncNode(BaseNode):
+    """
+    Auto Sync node - joins messages from multiple inputs.
+    Buffers the latest message from each input and outputs them together
+    along with the delta between sync property values.
+    """
+    info = str(_info)
+    display_name = 'Auto Sync'
+    icon = '⚡'
+    category = 'logic'
+    color = '#FFB347'
+    border_color = '#CC8F39'
+    text_color = '#000000'
+    input_count = 2  # Default, can be changed via properties
+    output_count = 1
+    
+    DEFAULT_CONFIG = {
+        'input_count': 2,
+        'sync_property': 'frame_count'
+    }
+    
+    properties = [
+        {
+            'name': 'input_count',
+            'label': 'Number of Inputs',
+            'type': 'number',
+            'default': DEFAULT_CONFIG['input_count'],
+            'min': 2,
+            'max': 10,
+            'help': 'Number of input ports to join'
+        },
+        {
+            'name': 'sync_property',
+            'label': 'Sync Property Path',
+            'type': 'text',
+            'default': DEFAULT_CONFIG['sync_property'],
+            'help': 'Property path to compare for delta (e.g., "frame_count", "timestamp")'
+        }
+    ]
+    
+    def __init__(self, node_id=None, name="auto sync"):
+        super().__init__(node_id, name)
+        self._buffers: Dict[int, Optional[Dict[str, Any]]] = {}
+    
+    def configure(self, config: Dict[str, Any]):
+        """Configure node and update input count."""
+        super().configure(config)
+        
+        new_input_count = self.get_config_int('input_count', 2)
+        if new_input_count != self.input_count:
+            self.input_count = new_input_count
+            self._buffers = {i: None for i in range(self.input_count)}
+    
+    def on_start(self):
+        """Initialize buffers on start."""
+        super().on_start()
+        self._buffers = {i: None for i in range(self.input_count)}
+    
+    def _get_sync_value(self, msg: Dict[str, Any]) -> Optional[float]:
+        """Extract the sync property value from a message."""
+        sync_property = self.config.get('sync_property', 'frame_count')
+        
+        # Try direct message property first
+        value = msg.get(sync_property)
+        
+        # If not found, try nested path
+        if value is None:
+            value = self._get_nested_value(msg, sync_property)
+        
+        # If still not found, try in payload
+        if value is None and MessageKeys.PAYLOAD in msg:
+            value = self._get_nested_value(msg[MessageKeys.PAYLOAD], sync_property)
+        
+        # Convert to float if possible
+        if value is not None:
+            try:
+                return float(value)
+            except (ValueError, TypeError):
+                return None
+        
+        return None
+    
+    def on_input(self, msg: Dict[str, Any], input_index: int = 0):
+        """Process incoming messages."""
+        if input_index >= self.input_count:
+            self.report_error(f"Received message on invalid input {input_index}")
+            return
+        
+        # Buffer the message
+        self._buffers[input_index] = msg
+        
+        # Check if all inputs have messages
+        messages = []
+        sync_values = []
+        
+        for i in range(self.input_count):
+            buffered = self._buffers.get(i)
+            if buffered is None:
+                return  # Not all inputs have messages yet
+            messages.append(buffered)
+            sync_values.append(self._get_sync_value(buffered))
+        
+        # All inputs have messages - compute delta and output
+        valid_values = [v for v in sync_values if v is not None]
+        if valid_values:
+            delta = max(valid_values) - min(valid_values)
+        else:
+            delta = None
+        
+        # Build output
+        out_msg = {
+            MessageKeys.PAYLOAD: {
+                'messages': [m.get(MessageKeys.PAYLOAD) for m in messages],
+                'sync_values': sync_values,
+                'delta': delta
+            }
+        }
+        
+        # Copy other properties from first message
+        for key in messages[0]:
+            if key not in (MessageKeys.PAYLOAD, MessageKeys.MSG_ID):
+                out_msg[key] = messages[0][key]
+        
+        self.send(out_msg)

pynode/nodes/BBoxMetricsNode/__init__.py

@@ -0,0 +1,3 @@
+from .bbox_metrics_node import BBoxMetricsNode
+
+__all__ = ['BBoxMetricsNode']