statable 3.1.0__py3-none-any.whl

statable_gui/transition_editor_direct/edit_dialogs.py

@@ -0,0 +1,160 @@
+# statable_gui/transition_editor_direct/edit_dialogs.py
+"""\nNode edit dialog (else checkbox support, condition builder support)\n"""
+
+from PySide6.QtWidgets import (
+    QDialog, QVBoxLayout, QHBoxLayout, QPushButton,
+    QLabel, QComboBox, QLineEdit, QListWidget, QAbstractItemView, QCheckBox
+)
+from PySide6.QtCore import Qt
+
+
+class BaseEditDialog(QDialog):
+    def __init__(self, item, parent=None):
+        super().__init__(parent)
+        self.item = item
+        self.setMinimumWidth(400)
+
+    def _add_buttons(self, layout):
+        btn_layout = QHBoxLayout()
+        btn_layout.addStretch()
+        cancel_btn = QPushButton(self.tr("Cancel"))
+        cancel_btn.clicked.connect(self.reject)
+        btn_layout.addWidget(cancel_btn)
+        ok_btn = QPushButton(self.tr("OK"))
+        ok_btn.clicked.connect(self.accept)
+        btn_layout.addWidget(ok_btn)
+        layout.addLayout(btn_layout)
+
+
+class FunctionEditDialog(BaseEditDialog):
+    def __init__(self, item, role_functions=None, parent=None):
+        super().__init__(item, parent)
+        self.setWindowTitle(self.tr("Edit role function"))
+        self.role_functions = role_functions or []
+
+        layout = QVBoxLayout(self)
+        h1 = QHBoxLayout()
+        h1.addWidget(QLabel(self.tr("Function name:")))
+        self.func_combo = QComboBox()
+        self.func_combo.setEditable(True)
+        self.func_combo.addItems(self.role_functions)
+        self.func_combo.setCurrentText(item.name)
+        h1.addWidget(self.func_combo)
+        layout.addLayout(h1)
+        self._add_buttons(layout)
+
+    def get_result(self):
+        return self.func_combo.currentText(), {}
+
+
+class TransitionEditDialog(BaseEditDialog):
+    def __init__(self, item, states=None, role_functions=None, global_defs=None, state_machine=None, parent=None):
+        super().__init__(item, parent)
+        self.setWindowTitle(self.tr("Edit state transition event"))
+        self.states = states or []
+        self.role_functions = role_functions or []
+        self.global_defs = global_defs
+        self.state_machine = state_machine
+
+        layout = QVBoxLayout(self)
+
+        h0 = QHBoxLayout()
+        h0.addWidget(QLabel(self.tr("Event:")))
+        self.event_label = QLabel(item.params.get('event', item.name))
+        h0.addWidget(self.event_label)
+        layout.addLayout(h0)
+
+        h1 = QHBoxLayout()
+        h1.addWidget(QLabel(self.tr("Condition:")))
+        self.cond_edit = QLineEdit(item.params.get('condition', ''))
+        h1.addWidget(self.cond_edit)
+
+        cond_builder_btn = QPushButton(self.tr("Edit condition..."))
+        cond_builder_btn.clicked.connect(self._open_condition_builder)
+        h1.addWidget(cond_builder_btn)
+        layout.addLayout(h1)
+
+        layout.addWidget(QLabel(self.tr("Pre-transition processing:")))
+        self.pre_list = QListWidget()
+        self.pre_list.setDragDropMode(QAbstractItemView.InternalMove)
+        self.pre_list.setDefaultDropAction(Qt.MoveAction)
+        for a in item.params.get('pre_actions', []):
+            self.pre_list.addItem(a)
+        layout.addWidget(self.pre_list)
+
+        pre_btn = QHBoxLayout()
+        add_pre_btn = QPushButton(self.tr("Add"))
+        add_pre_btn.clicked.connect(self._add_pre)
+        pre_btn.addWidget(add_pre_btn)
+        del_pre_btn = QPushButton(self.tr("Delete"))
+        del_pre_btn.clicked.connect(self._del_pre)
+        pre_btn.addWidget(del_pre_btn)
+        layout.addLayout(pre_btn)
+
+        self.has_else_check = QCheckBox(self.tr("Use else condition"))
+        self.has_else_check.setChecked(item.params.get('has_else', True))
+        layout.addWidget(self.has_else_check)
+
+        h3 = QHBoxLayout()
+        h3.addWidget(QLabel(self.tr("else target:")))
+        self.else_target_combo = QComboBox()
+        self.else_target_combo.setEditable(True)
+        self.else_target_combo.addItems(self.states)
+        self.else_target_combo.setCurrentText(item.params.get('else_target', ''))
+        h3.addWidget(self.else_target_combo)
+        layout.addLayout(h3)
+
+        h2 = QHBoxLayout()
+        h2.addWidget(QLabel(self.tr("Target:")))
+        self.target_combo = QComboBox()
+        self.target_combo.setEditable(True)
+        self.target_combo.addItems(self.states)
+        self.target_combo.setCurrentText(item.params.get('target', ''))
+        h2.addWidget(self.target_combo)
+        layout.addLayout(h2)
+
+        self._add_buttons(layout)
+
+    def _add_pre(self):
+        if self.role_functions:
+            self.pre_list.addItem(self.role_functions[0])
+
+    def _del_pre(self):
+        row = self.pre_list.currentRow()
+        if row >= 0:
+            self.pre_list.takeItem(row)
+
+    def _open_condition_builder(self):
+        from statable_gui.condition_builder_dialog import ConditionBuilderDialog
+        dlg = ConditionBuilderDialog(
+            condition=self.cond_edit.text(),
+            global_defs=self.global_defs,
+            state_machine=self.state_machine,
+            parent=self
+        )
+        if dlg.exec() == QDialog.Accepted:
+            self.cond_edit.setText(dlg.get_condition_text())
+
+    def get_result(self):
+        condition = self.cond_edit.text()
+        pre_actions = [self.pre_list.item(i).text() for i in range(self.pre_list.count())]
+        target = self.target_combo.currentText()
+        has_else = self.has_else_check.isChecked()
+        else_target = self.else_target_combo.currentText() if has_else else ""
+
+        edited = f"{self.event_label.text()}: {condition} → {target}"
+        if pre_actions:
+            edited += f" (pre: {', '.join(pre_actions)})"
+        if has_else:
+            edited += f" [else→{else_target}]" if else_target else " [else]"
+
+        params = {
+            'event': self.event_label.text(),
+            'condition': condition,
+            'pre_actions': pre_actions,
+            'target': target,
+            'has_else': has_else,
+            'else_target': else_target,
+            'else_actions': [],   # Future support
+        }
+        return edited, params

statable_gui/transition_editor_direct/overview_tab.py

@@ -0,0 +1,173 @@
+# statable_gui/transition_editor_direct/overview_tab.py
+"""Overview tab widget (v2.2).
+
+Shows coverage analysis for the current cell and the whole state machine.
+"""
+
+import logging
+from typing import Optional
+
+from PySide6.QtCore import Qt
+from PySide6.QtGui import QFont
+from PySide6.QtWidgets import (
+    QWidget, QVBoxLayout, QHBoxLayout, QPushButton, QPlainTextEdit,
+    QLabel, QSplitter,
+)
+
+from .draft import ActionDraft
+from .coverage_analyzer import CoverageAnalyzer
+
+logger = logging.getLogger("transition_editor_direct.overview_tab")
+
+
+class OverviewTab(QWidget):
+    """Overview tab: coverage / reachability report."""
+
+    def __init__(self, draft: ActionDraft,
+                 state_machine=None, parent=None):
+        super().__init__(parent)
+        self.draft = draft
+        self.state_machine = state_machine
+        self.analyzer = CoverageAnalyzer()
+
+        self._build_ui()
+        self.refresh()
+
+    def _build_ui(self):
+        layout = QVBoxLayout(self)
+
+        top = QHBoxLayout()
+        top.addWidget(QLabel(self.tr("Coverage / reachability report")))
+        top.addStretch()
+        refresh_btn = QPushButton(self.tr("Refresh"))
+        refresh_btn.clicked.connect(self.refresh)
+        top.addWidget(refresh_btn)
+        layout.addLayout(top)
+
+        splitter = QSplitter(Qt.Vertical)
+
+        # Cell-internal
+        cell_box = QWidget()
+        cell_layout = QVBoxLayout(cell_box)
+        cell_layout.setContentsMargins(0, 0, 0, 0)
+        cell_layout.addWidget(QLabel(self.tr("Cell-level analysis")))
+        self.cell_view = QPlainTextEdit()
+        self.cell_view.setReadOnly(True)
+        self.cell_view.setFont(QFont("Consolas", 10))
+        cell_layout.addWidget(self.cell_view)
+        splitter.addWidget(cell_box)
+
+        # State graph
+        graph_box = QWidget()
+        graph_layout = QVBoxLayout(graph_box)
+        graph_layout.setContentsMargins(0, 0, 0, 0)
+        graph_layout.addWidget(QLabel(self.tr("State graph analysis")))
+        self.graph_view = QPlainTextEdit()
+        self.graph_view.setReadOnly(True)
+        self.graph_view.setFont(QFont("Consolas", 10))
+        graph_layout.addWidget(self.graph_view)
+        splitter.addWidget(graph_box)
+
+        layout.addWidget(splitter)
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+    def refresh(self):
+        """Recompute analysis and update views."""
+        self._refresh_cell_view()
+        self._refresh_graph_view()
+
+    def get_summary_text(self) -> str:
+        """Return a plain-text summary (test-friendly)."""
+        return (self.cell_view.toPlainText() + "\n\n"
+                + self.graph_view.toPlainText())
+
+    # ------------------------------------------------------------------
+    # Internals
+    # ------------------------------------------------------------------
+    def _refresh_cell_view(self):
+        sm = self.state_machine
+        source = self.draft.source
+        event = self.draft.event
+
+        lines = []
+        lines.append(f"Cell: {source} -[{event or 'Completion'}]->")
+
+        if sm is None:
+            lines.append("(state machine not available)")
+            self.cell_view.setPlainText("\n".join(lines))
+            return
+
+        report = self.analyzer.analyze_cell(sm, source, event)
+        lines.append(f"Transitions: {report.transitions_count}")
+        lines.append("")
+
+        if report.unreachable_labels:
+            lines.append("Unreachable transitions:")
+            for lbl in report.unreachable_labels:
+                lines.append(f"  - {lbl}")
+        else:
+            lines.append("Unreachable transitions: none")
+
+        lines.append("")
+
+        if report.duplicate_targets:
+            lines.append("Duplicate targets:")
+            for tgt, labels in report.duplicate_targets.items():
+                lines.append(f"  - {tgt}: {', '.join(labels)}")
+        else:
+            lines.append("Duplicate targets: none")
+
+        lines.append("")
+
+        if report.overlap_pairs:
+            lines.append("Possible condition overlaps:")
+            for a, b in report.overlap_pairs:
+                lines.append(f"  - {a} and {b}")
+        else:
+            lines.append("Possible condition overlaps: none")
+
+        self.cell_view.setPlainText("\n".join(lines))
+
+    def _refresh_graph_view(self):
+        sm = self.state_machine
+        lines = []
+
+        if sm is None:
+            lines.append("(state machine not available)")
+            self.graph_view.setPlainText("\n".join(lines))
+            return
+
+        report = self.analyzer.analyze_state_graph(sm)
+
+        lines.append(f"States: {len(sm.states)}")
+        lines.append(f"Initial: {getattr(sm, 'initial_state', None) or '(unset)'}")
+        lines.append("")
+
+        if report.unreachable_states:
+            lines.append("Unreachable states:")
+            for s in report.unreachable_states:
+                lines.append(f"  - {s}")
+        else:
+            lines.append("Unreachable states: none")
+
+        lines.append("")
+
+        if report.terminal_states:
+            lines.append("Terminal states (no outgoing):")
+            for s in report.terminal_states:
+                lines.append(f"  - {s}")
+        else:
+            lines.append("Terminal states: none")
+
+        lines.append("")
+
+        if report.self_loops:
+            lines.append("Self loops:")
+            for src, evt in report.self_loops:
+                lines.append(f"  - {src} -[{evt or 'Completion'}]-> {src}")
+        else:
+            lines.append("Self loops: none")
+
+        self.graph_view.setPlainText("\n".join(lines))

statable_gui/transition_editor_direct/palette_widget.py

@@ -0,0 +1,233 @@
+# statable_gui/transition_editor_direct/palette_widget.py
+"""\nCollapsible palette by category\n(shared library support / double-click edit / drag start support)\n\n[v1.5 fix]\n  - refresh_lists: rf.name -> rf.qualified_name (bug #88)\n    Driver.Init and App.Init were both shown as \"Init\",\n    causing wrong edit target; fixed\n  - _generate_unique_name: added namespace collision check\n"""
+
+import json
+import logging
+
+from PySide6.QtCore import Qt, QMimeData, Signal
+from PySide6.QtGui import QDrag
+from PySide6.QtWidgets import (
+    QWidget, QVBoxLayout, QListWidget, QListWidgetItem,
+    QAbstractItemView, QPushButton, QLabel, QGroupBox,
+)
+
+logger = logging.getLogger("transition_editor_direct.palette")
+
+
+class PaletteListWidget(QListWidget):
+    MIME_TYPE = "application/x-flow-item"
+    item_edit_requested = Signal(str)
+
+    def __init__(self, item_type: str, parent=None):
+        super().__init__(parent)
+        self.item_type = item_type
+        self.setDragEnabled(True)
+        self.setDragDropMode(QAbstractItemView.DragOnly)
+        self.setSelectionMode(QAbstractItemView.SingleSelection)
+
+    def mimeData(self, items):
+        mime = QMimeData()
+        if items:
+            data = {
+                "item_type": self.item_type,
+                "name": items[0].text(),
+            }
+            mime.setData(self.MIME_TYPE, json.dumps(data).encode("utf-8"))
+            mime.setText(items[0].text())
+            logger.debug(
+                f"PaletteListWidget.mimeData: type={self.item_type}, "
+                f"name='{items[0].text()}'"
+            )
+        return mime
+
+    def startDrag(self, supported_actions):
+        """Override drag start to reliably execute QDrag"""
+        item = self.currentItem()
+        if item is None:
+            logger.debug("PaletteListWidget.startDrag: no current item")
+            return
+
+        logger.debug(
+            f"PaletteListWidget.startDrag: type={self.item_type}, "
+            f"name='{item.text()}'"
+        )
+
+        mime_data = QMimeData()
+        data = {
+            "item_type": self.item_type,
+            "name": item.text(),
+        }
+        mime_data.setData(self.MIME_TYPE, json.dumps(data).encode("utf-8"))
+        mime_data.setText(item.text())
+
+        drag = QDrag(self)
+        drag.setMimeData(mime_data)
+        result = drag.exec_(Qt.CopyAction)
+        logger.debug(f"PaletteListWidget.startDrag: drag result={result}")
+
+    def mouseDoubleClickEvent(self, event):
+        logger.debug(
+            f"PaletteListWidget.mouseDoubleClickEvent called: "
+            f"type={self.item_type}"
+        )
+        item = self.itemAt(event.position().toPoint())
+        if item:
+            text = item.text()
+            logger.debug(f"  item text = '{text}'")
+            logger.debug(f"  emitting item_edit_requested('{text}')")
+            self.item_edit_requested.emit(text)
+            event.accept()
+            return
+        logger.debug("  no item at click position")
+        super().mouseDoubleClickEvent(event)
+
+
+class PaletteWidget(QWidget):
+    """Collapsible palette by category (event selection screen)"""
+
+    edit_function_requested = Signal(str)
+    edit_transition_requested = Signal(str)
+
+    def __init__(self, role_function_library=None,
+                 condition_library=None, parent=None):
+        super().__init__(parent)
+        self.role_function_library = role_function_library
+        self.condition_library = condition_library
+        self._setup_ui()
+        self.refresh_lists()
+        logger.debug("PaletteWidget initialized")
+
+    def _setup_ui(self):
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(4, 4, 4, 4)
+        layout.setSpacing(4)
+
+        title_label = QLabel(self.tr("Event selection screen"))
+        title_label.setStyleSheet("font-weight: bold; font-size: 14px;")
+        title_label.setAlignment(Qt.AlignCenter)
+        layout.addWidget(title_label)
+
+        # Role function section
+        func_group = QGroupBox(self.tr("Role function"))
+        v1 = QVBoxLayout(func_group)
+        v1.setContentsMargins(4, 4, 4, 4)
+        v1.setSpacing(2)
+
+        self.function_list = PaletteListWidget("function")
+        self.function_list.item_edit_requested.connect(
+            self._on_function_item_edit_requested
+        )
+        v1.addWidget(self.function_list)
+
+        add_func_btn = QPushButton(self.tr("+ Role functionAdd"))
+        add_func_btn.clicked.connect(self._add_function)
+        v1.addWidget(add_func_btn)
+
+        # Transition condition section
+        transition_group = QGroupBox(self.tr("Transition condition"))
+        v2 = QVBoxLayout(transition_group)
+        v2.setContentsMargins(4, 4, 4, 4)
+        v2.setSpacing(2)
+
+        self.transition_list = PaletteListWidget("transition")
+        self.transition_list.item_edit_requested.connect(
+            self._on_transition_item_edit_requested
+        )
+        v2.addWidget(self.transition_list)
+
+        add_transition_btn = QPushButton(self.tr("+ Transition conditionAdd"))
+        add_transition_btn.clicked.connect(self._add_transition)
+        v2.addWidget(add_transition_btn)
+
+        layout.addWidget(func_group)
+        layout.addWidget(transition_group)
+        layout.addStretch()
+
+    def _generate_unique_name(self, base_name: str, library) -> str:
+        """\n        Generate a unique name\n\n        [v1.5 improvement]\n          RoleFunctionLibrary.role_functions is keyed by qualified_name,\n          so collision checks against existing keys must be done with both\n          base_name (bare name) and qualified_name.\n        """
+        existing_names = set()
+        if hasattr(library, 'role_functions'):
+            existing_names = set(library.role_functions.keys())
+        elif hasattr(library, 'condition_templates'):
+            existing_names = set(library.condition_templates.keys())
+
+        def _collides(name: str) -> bool:
+            if name in existing_names:
+                return True
+            # Also detect suffix match of 'Namespace.Name'
+            return any(k.endswith('.' + name) for k in existing_names)
+
+        if not _collides(base_name):
+            return base_name
+
+        index = 2
+        while _collides(f"{base_name}_{index}"):
+            index += 1
+        return f"{base_name}_{index}"
+
+    def _add_function(self):
+        from statable_gui.libcntrl.role_function_library import RoleFunction
+        base_name = "NewFunction"
+        name = self._generate_unique_name(
+            base_name, self.role_function_library
+        )
+        try:
+            self.role_function_library.add(
+                RoleFunction(name=name, title=name)
+            )
+            logger.debug(f"Added new role function to library: {name}")
+        except ValueError as e:
+            logger.warning(f"Failed to add role function: {e}")
+        self.refresh_lists()
+
+    def _add_transition(self):
+        from statable_gui.libcntrl.condition_library import ConditionTemplate
+        base_name = "NewEvent"
+        name = self._generate_unique_name(
+            base_name, self.condition_library
+        )
+        try:
+            self.condition_library.add(
+                ConditionTemplate(name=name, condition="")
+            )
+            logger.debug(f"Added new condition template to library: {name}")
+        except ValueError as e:
+            logger.warning(f"Failed to add condition template: {e}")
+        self.refresh_lists()
+
+    def _on_function_item_edit_requested(self, name: str):
+        """\n        Role function edit request\n\n        [v1.5 fix]\n          name can be qualified_name ('Driver.Init') or\n          bare name ('Init'). ActionEditorDialog downstream resolves\n          via RoleFunctionLibrary.get(name), so both work correctly.\n        """
+        logger.debug(
+            f"PaletteWidget._on_function_item_edit_requested: "
+            f"name='{name}'"
+        )
+        self.edit_function_requested.emit(name)
+
+    def _on_transition_item_edit_requested(self, name: str):
+        logger.debug(
+            f"PaletteWidget._on_transition_item_edit_requested: "
+            f"name='{name}'"
+        )
+        self.edit_transition_requested.emit(name)
+
+    def refresh_lists(self):
+        """\n        Rebuild the role function / transition condition list\n\n        [v1.5 fix]\n          Role functions shown by qualified_name ('Driver.Init').\n          With bare names only, namespace collisions cause wrong edit target.\n        """
+        logger.debug("PaletteWidget.refresh_lists called")
+        if self.role_function_library:
+            self.function_list.clear()
+            for rf in self.role_function_library.list_all():
+                display_name = getattr(rf, 'qualified_name', None) or rf.name
+                self.function_list.addItem(display_name)
+            logger.debug(
+                f"Function list refreshed: "
+                f"{self.function_list.count()} items"
+            )
+
+        if self.condition_library:
+            self.transition_list.clear()
+            for ct in self.condition_library.list_all():
+                self.transition_list.addItem(ct.name)
+            logger.debug(
+                f"Transition list refreshed: "
+                f"{self.transition_list.count()} items"
+            )