haybale-graph-editor 0.0.2__py3-none-any.whl

haybale_graph_editor/__init__.py

@@ -0,0 +1,59 @@
+"""haybale-graph-editor: graph editor library for Haywire.
+
+Provides the GraphContainer protocol, GraphAppState registry, and
+GraphEditor surface. Decoupled from any specific graph source — source
+libraries register their containers, this library renders them.
+"""
+
+from importlib.metadata import version as _pkg_version
+from pathlib import Path
+
+from haywire.core.library.base import BaseLibrary
+from haywire.core.library.decorator import library
+from haywire.core.state import LibraryStateRegistry
+from haywire.ui.editor.registry import EditorTypeRegistry
+
+# Public API re-exports
+from haybale_graph_editor.protocols import GraphContainer
+from haybale_graph_editor.state.graph_app_state import GraphAppState
+from haywire.ui.panel.registry import PanelRegistry
+
+__all__ = ["GraphContainer", "GraphAppState", "Library"]
+
+
+@library(
+    label="Graph Editor",
+    id="graph_editor",
+    version=_pkg_version("haybale-graph-editor"),
+    description="Visual graph editor library — host-agnostic",
+    url="",
+    help_url="",
+    author="",
+    author_url="",
+    dependencies=[],
+    tags=["graph-editor"],
+    file_watcher=True,
+)
+class Library(BaseLibrary):
+    """Graph Editor library."""
+
+    def register_components(self):
+        base_path = Path(__file__).parent
+
+        self.add_folder_to_registry(
+            folder_path=str(base_path / "state"),
+            registry_cls=LibraryStateRegistry,
+        )
+
+        self.add_folder_to_registry(
+            folder_path=str(base_path / "panels"),
+            registry_cls=PanelRegistry,
+        )
+
+        self.add_folder_to_registry(
+            folder_path=str(base_path / "editors"),
+            registry_cls=EditorTypeRegistry,
+        )
+
+    def validate(self) -> bool:
+        return True

haybale_graph_editor/editors/graph_canvas/__init__.py

@@ -0,0 +1,16 @@
+from .connection_info_popup import EdgeInfoPopup
+from .graph_canvas_manager import GraphCanvasManager
+from .node_menu_builder import NodeMenuBuilder
+from .ui_edge import EdgeVisualState
+from .ui_edge import UIEdge
+from .ui_node import UINode
+
+__all__ = [
+    "EdgeInfoPopup",
+    "EdgeVisualState",
+    "GraphCanvasManager",
+    "GraphEventMetadata",
+    "NodeMenuBuilder",
+    "UIEdge",
+    "UINode",
+]

haybale_graph_editor/editors/graph_canvas/connection_info_popup.py

@@ -0,0 +1,134 @@
+"""
+ConnectionInfoPopup - Detailed connection information display component
+
+This component provides a dedicated popup for inspecting edge/connection details including:
+- Connection path (nodes and ports)
+- Validation status
+- Error details with full error rendering
+- Warning messages
+- Adapter chain visualization and testing
+- Execution statistics
+"""
+
+from nicegui import ui
+from typing import Optional
+
+from haywire.core.edge.edge import Edge
+from haywire.core.errors.haywire_exception import HaywireException
+from haywire.core.edge.edge_wrapper import EdgeWrapperState
+
+from haywire.ui import elements as hui
+from haywire.ui.errors.error_info import error_render_detail
+
+from haywire.ui.components.popup import Popup
+
+
+class EdgeInfoPopup:
+    """Dedicated popup for displaying detailed connection/edge information."""
+
+    def __init__(self):
+        self._info_popup: Optional[Popup] = None
+
+    def show(self, x: float, y: float, edge_id: str, edge: Edge, state: EdgeWrapperState):
+        """Show detailed connection information in a dedicated popup."""
+        # Close any existing popup first
+        self.close()
+
+        # Create a larger popup for detailed information
+        popup = Popup.create_context_menu(
+            "Connection Details", x + 10, y + 10, width="400px", clamp_to_viewport=False
+        )
+
+        with popup:
+            with ui.column().classes("w-full gap-2 p-2"):
+                # Header with connection status
+                with ui.row().classes("w-full"):
+                    ui.label(f"{edge.edge_type}").classes("text-xs hw-text-muted ml-2 mt-2")
+                    is_valid = state.is_valid()
+                    status_icon = "✓" if is_valid else "✗"
+                    status_color = "hw-text-success" if is_valid else "hw-text-danger"
+                    status_text = "Valid" if is_valid else "Invalid"
+                    ui.label(f"{status_icon} {status_text}").classes(f"text-sm font-bold {status_color}")
+
+                ui.separator().classes("my-2")
+
+                # Error Section (if present, expandable, default open)
+                error = state.get_error()
+                if error and isinstance(error, HaywireException):
+                    with hui.expansion_section("Error Details"):
+                        with (
+                            ui.card()
+                            .classes("w-full p-3")
+                            .style("background: var(--hw-danger-bg); border: 1px solid var(--hw-danger);")
+                        ):
+                            ui.label(f"Category: {error.category}").classes("text-xs hw-text-danger ml-2")
+                            # Render the error detail with button to show full details
+                            error_render_detail(error)
+
+                # Warning Section (if present, expandable, default open)
+                if state.has_warning():
+                    with hui.expansion_section("Warning"):
+                        with (
+                            ui.card()
+                            .classes("w-full p-3")
+                            .style("background: var(--hw-bg-surface); border: 1px solid var(--hw-border);")
+                        ):
+                            with ui.column():
+                                for warning in state.warnings:
+                                    ui.label(f"⚠ {warning}").classes("text-xs hw-text-warning ml-2")
+
+                # Adapter Chain Section (if available, expandable, default closed)
+                if edge.chain_adapter_keys:
+                    with hui.expansion_section("Adapter Chain", default_open=False):
+                        with (
+                            ui.card()
+                            .classes("w-full p-3")
+                            .style("background: var(--hw-bg-surface); border: 1px solid var(--hw-border);")
+                        ):
+                            # Display each adapter in the chain
+                            for i, adapter_key in enumerate(edge.chain_adapter_keys, 1):
+                                ui.label(f"{i}. {adapter_key}").classes("text-xs hw-text-accent ml-2")
+
+                if state.execution_count > 0:
+                    # Execution Statistics Section (expandable, default closed)
+                    with hui.expansion_section("Execution Statistics", default_open=False):
+                        exec_count = state.execution_count
+                        ui.label(f"Execution Count: {exec_count}").classes("text-xs hw-text-muted ml-2")
+
+                        avg_time = state.average_execution_time_us
+                        if avg_time > 0:
+                            ui.label(f"Average Time: {avg_time:.1f} μs").classes(
+                                "text-xs hw-text-muted ml-2"
+                            )
+                        else:
+                            ui.label("Average Time: Not measured").classes("text-xs hw-text-dim ml-2")
+
+                        ui.label(f"Tested value: {state.example_test_value}").classes(
+                            "text-xs hw-text-muted ml-2"
+                        )
+                        ui.label(f"Tested result: {state.example_test_result}").classes(
+                            "text-xs hw-text-muted ml-2"
+                        )
+
+                # Connection Path Section (Expandable, default closed)
+                with hui.expansion_section("Connection Path", default_open=False):
+                    ui.label("Connection Path").classes("font-semibold text-sm")
+                    ui.label(f"{edge.source_node_id} [{edge.outlet_port_id}]").classes("text-xs opacity-70")
+                    ui.label("↓").classes("text-xs opacity-50 ml-2")
+                    ui.label(f"{edge.sink_node_id} [{edge.inlet_port_id}]").classes("text-xs opacity-70")
+
+                # Close button
+                ui.separator().classes("my-2")
+                btn_close = ui.button("Close", on_click=lambda: self.close())
+                btn_close.props("flat")
+                btn_close.classes("w-full text-sm py-2")
+
+        popup.open()
+        self._info_popup = popup
+
+    def close(self):
+        """Close the connection info popup."""
+        if self._info_popup:
+            self._info_popup.close()
+            self._info_popup.delete()
+            self._info_popup = None

haybale_graph_editor/editors/graph_canvas/event_handlers.py

@@ -0,0 +1,46 @@
+"""
+Event handler registration system for the enhanced graph canvas event system.
+
+This module provides:
+- Decorator for registering event handlers
+- Type-safe handler registration
+- Automatic handler discovery
+- build_event_handler_map: scan multiple handler sources into a dispatch map
+"""
+
+from typing import Callable, Dict, List, Type
+from haywire.ui.components.graph.event_definitions import BaseGraphEvent
+
+
+def handles_event(*event_classes: Type[BaseGraphEvent]):
+    """Decorator to register methods as handlers for specific event classes"""
+
+    def decorator(func: Callable):
+        setattr(func, "_handles_event_classes", event_classes)
+        return func
+
+    return decorator
+
+
+def build_event_handler_map(sources: List[object]) -> Dict[str, Callable]:
+    """
+    Build an event-type → handler mapping by scanning a list of handler sources.
+
+    For each source object, scans all methods for the ``_handles_event_classes``
+    attribute set by the ``@handles_event`` decorator.  When two sources register
+    the same event type the later source wins.
+
+    Args:
+        sources: Objects whose methods should be scanned for ``@handles_event``.
+
+    Returns:
+        Dict mapping event_type strings to bound handler methods.
+    """
+    handlers: Dict[str, Callable] = {}
+    for source in sources:
+        for method_name in dir(source):
+            method = getattr(source, method_name)
+            if hasattr(method, "_handles_event_classes"):
+                for event_class in method._handles_event_classes:
+                    handlers[event_class.event_type] = method
+    return handlers

haybale_graph_editor/editors/graph_canvas/graph_canvas_manager.py

@@ -0,0 +1,217 @@
+"""
+GraphCanvasManager — facade that wires handler objects to the Vue canvas.
+
+Public API is unchanged; all event-handling and visual-management logic has
+been moved into focused handler classes under handlers/.
+"""
+
+import logging
+import traceback
+from typing import Callable, Dict, Set
+from nicegui import ui
+
+from haywire.core.graph.editor import Editor
+
+from haywire.ui.components.zoom.pan import ZoomPanContainer
+from haywire.ui.components.graph.canvas import GraphCanvasVue
+from haywire.ui.components.graph.event_definitions import BaseGraphEvent, GRAPH_EVENT_REGISTRY
+from haywire.core.session.session import Session
+
+from ...state.edit_state import EditState
+from .event_handlers import build_event_handler_map
+from .handlers.interaction import InteractionHandlers
+from .handlers.selection import SelectionHandlers
+from .handlers.visual_layer import VisualLayerHandlers
+from .handlers.context_menu import ContextMenuHandlers, SessionContextMenuProvider
+
+logger = logging.getLogger(__name__)
+
+
+class GraphCanvasManager:
+    """
+    Facade that wires canvas event handlers and the Vue component together.
+
+    Responsibilities kept here:
+    - Canvas/zoom/menu construction (_setup_canvas)
+    - Building and connecting handler objects
+    - Event dispatch (build_event_handler_map + _handle_canvas_event)
+    - Public facade methods (sync_with_graph, cleanup, …)
+
+    All domain logic lives in the handler sub-objects:
+    - visual_layer  → VisualLayerHandlers
+    - selection     → SelectionHandlers
+    - interactions  → InteractionHandlers
+    - context_menus → ContextMenuHandlers
+    """
+
+    def __init__(self, editor: Editor, skin_factory, node_factory, panel_registry, session: "Session"):
+        self.editor = editor
+        self.skin_factory = skin_factory
+        self.node_factory = node_factory
+        self._panel_registry = panel_registry
+        self._session = session
+        self.session_id = session.session_id[:8]
+
+        self.graph = editor.graph
+
+        # Vue component references built in _setup_canvas
+        self.zoom_container, self.canvas_vue = self._setup_canvas()
+
+        # Build handler objects
+        self.visual_layer = VisualLayerHandlers(
+            graph=self.graph,
+            editor=self.editor,
+            skin_factory=self.skin_factory,
+            canvas_vue=self.canvas_vue,
+            context=self._session.context,
+        )
+        self.selection = SelectionHandlers(
+            graph=self.graph,
+            editor=self.editor,
+            session_id=self.session_id,
+            session=self._session,
+        )
+        self.interactions = InteractionHandlers(editor=self.editor)
+
+        context_menu_provider = SessionContextMenuProvider(
+            context=self._session.context,
+            session=self._session,
+            panel_registry=self._panel_registry,
+            on_emit_event=self._handle_canvas_event,
+            on_emit_sync_event=self.canvas_vue.emit_sync_event,
+        )
+
+        self.context_menu_handlers = ContextMenuHandlers(
+            visual_layer=self.visual_layer,
+            provider=context_menu_provider,
+        )
+
+        # Build dispatch map from all handler sources
+        self._event_handlers: Dict[str, Callable] = build_event_handler_map(
+            [
+                self.visual_layer,
+                self.selection,
+                self.interactions,
+                self.context_menu_handlers,
+            ]
+        )
+
+        self._validate_handler_coverage()
+
+        # Subscribe for incremental validation updates
+        self.graph.subscribe_to_validation(self.visual_layer.on_validated)
+
+        logger.info(f"🔧 GraphCanvasManager for {self.session_id} is setup")
+
+    # =========================================================================
+    # Setup
+    # =========================================================================
+
+    def _setup_canvas(self) -> tuple[ZoomPanContainer, GraphCanvasVue]:
+        """Create zoom container and Vue canvas component."""
+        zoom_container = (
+            ZoomPanContainer()
+            .classes("w-full flex-grow")
+            .style("border: 2px solid var(--hw-border);")
+            .style("height: 100%;")
+        )
+
+        with zoom_container.content_container:
+            canvas_vue = GraphCanvasVue(
+                zoom_container=zoom_container,
+                on_canvas_event=self._handle_canvas_event,
+                canvas_width=self.graph.canvas_width,
+                canvas_height=self.graph.canvas_height,
+            )
+        return zoom_container, canvas_vue
+
+    def _validate_handler_coverage(self):
+        """Warn if any user event lacks a registered handler."""
+        user_events = [
+            event_type
+            for event_type, event_class in GRAPH_EVENT_REGISTRY.items()
+            if getattr(event_class, "category", "user") == "user"
+        ]
+        missing = [et for et in user_events if et not in self._event_handlers]
+        if missing:
+            logger.warning(f"⚠️  Missing handlers for events: {missing}")
+        else:
+            logger.debug(f"✅ All {len(user_events)} user events have registered handlers")
+
+    # =========================================================================
+    # Event routing
+    # =========================================================================
+
+    def _handle_canvas_event(self, event: BaseGraphEvent):
+        """Dispatch incoming canvas events to the appropriate handler."""
+        event_type = event.event_type
+        handler = self._event_handlers.get(event_type)
+
+        if handler:
+            logger.debug(f"🔧 Calling handler for {event_type}: {handler.__name__}")
+            try:
+                handler(event)
+            except Exception as e:
+                logger.error(f"❌ Error calling handler for {event_type}: {e}")
+                ui.notify(f"Error while processing {event.description}: {e}", type="negative")
+                traceback.print_exc()
+        else:
+            logger.warning(f"No handler found for event type: {event_type}")
+
+    # =========================================================================
+    # Public facade — unchanged external API
+    # =========================================================================
+
+    def sync_with_graph(self):
+        """Synchronise visual representation with the current graph state."""
+        self.visual_layer.sync_with_graph()
+
+    def sync_selections(self):
+        """Emit consolidated selection sync event to Vue."""
+        self.visual_layer.sync_selections(
+            self.selection.selected_nodes,
+            self.selection.selected_edges,
+        )
+
+    def clear_all_visuals(self):
+        """Clear all visual representations."""
+        self.visual_layer.clear_all_visuals()
+        self.selection.selected_nodes.clear()
+        self.selection.selected_edges.clear()
+
+    # Kept for callers that still reference these directly
+    @property
+    def node_panels(self) -> Dict:
+        return self.visual_layer.node_panels
+
+    @property
+    def edge_paths(self) -> Dict:
+        return self.visual_layer.edge_paths
+
+    @property
+    def selected_nodes(self) -> Set[str]:
+        return self.selection.selected_nodes
+
+    @property
+    def selected_edges(self) -> Set[str]:
+        return self.selection.selected_edges
+
+    def _has_clipboard_content(self) -> bool:
+        clipboard = self._session.context.data[EditState].clipboard
+        return clipboard is not None and len(clipboard.nodes) > 0
+
+    def cleanup(self):
+        """Unsubscribe from graph validation and release resources."""
+        logger.info(f"🔧 Shutting down GraphCanvasManager for {self.session_id} ...")
+
+        try:
+            self.graph.unsubscribe_from_validation(self.visual_layer.on_validated)
+        except Exception as exc:
+            logger.warning(f"GraphCanvasManager: unsubscribe error: {exc}")
+
+        if self.canvas_vue:
+            self.canvas_vue.cleanup()
+
+        self.visual_layer.cleanup()
+
+        logger.info(f"🔧 GraphCanvasManager for {self.session_id} is shut down")

haybale_graph_editor/editors/graph_canvas/handlers/__init__.py

@@ -0,0 +1,11 @@
+"""
+Canvas event handler objects for GraphCanvasManager.
+
+Each module provides a focused handler class that owns the state and
+dependencies relevant to one concern:
+
+- interaction.py   — drag events, edge click
+- selection.py     — selection state, clipboard (copy/paste)
+- visual_layer.py  — node/edge visual registry, graph sync
+- context_menu.py  — context menu routing via IContextMenuProvider
+"""