setiastrosuitepro 1.6.7__py3-none-any.whl

setiastro/saspro/bundles.py

@@ -0,0 +1,61 @@
+# pro/bundles.py
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import List, Dict, Optional
+from PyQt6.QtCore import QObject, pyqtSignal
+
+@dataclass
+class ViewBundle:
+    id: str
+    name: str
+    doc_uids: List[str] = field(default_factory=list)  # store stable doc UIDs
+
+class BundleManager(QObject):
+    changed = pyqtSignal()
+    def __init__(self, dm):
+        super().__init__()
+        self.dm = dm
+        self._by_id: Dict[str, ViewBundle] = {}
+
+    def add(self, b: ViewBundle):
+        self._by_id[b.id] = b
+        self.changed.emit()
+
+    def remove(self, bid: str):
+        self._by_id.pop(bid, None)
+        self.changed.emit()
+
+    def get(self, bid: str) -> Optional[ViewBundle]:
+        return self._by_id.get(bid)
+
+    def all(self) -> list[ViewBundle]:
+        return list(self._by_id.values())
+
+    def add_doc(self, bid: str, doc_uid: str):
+        b = self._by_id.get(bid)
+        if not b: return
+        if doc_uid not in b.doc_uids:
+            b.doc_uids.append(doc_uid)
+            self.changed.emit()
+
+    def remove_doc(self, bid: str, doc_uid: str):
+        b = self._by_id.get(bid)
+        if not b: return
+        if doc_uid in b.doc_uids:
+            b.doc_uids.remove(doc_uid)
+            self.changed.emit()
+
+    def docs(self, bid: str):
+        b = self._by_id.get(bid)
+        if not b: return []
+        out = []
+        for uid in b.doc_uids:
+            d = getattr(self.dm, "find_document_by_uid", None)
+            if callable(d):
+                doc = d(uid)
+            else:
+                # fallback: linear scan over open docs if you don't have an index
+                doc = next((x for x in getattr(self.dm, "documents", []) if getattr(x, "uid", None) == uid), None)
+            if doc:
+                out.append(doc)
+        return out

setiastro/saspro/bundles_dock.py

@@ -0,0 +1,114 @@
+# pro/bundles_dock.py
+from __future__ import annotations
+from PyQt6.QtWidgets import QDockWidget, QListWidget, QListWidgetItem, QMenu, QInputDialog
+from PyQt6.QtCore import Qt, QMimeData, QByteArray
+import json
+
+from setiastro.saspro.dnd_mime import MIME_CMD  # you already use this
+
+class BundlesDock(QDockWidget):
+    def __init__(self, mw, bm, pipelines):
+        super().__init__("Bundles", mw)
+        self.mw = mw
+        self.bm = bm
+        self.pipelines = pipelines
+
+        self.list = QListWidget(self)
+        self.list.setSelectionMode(self.list.SelectionMode.SingleSelection)
+        self.list.setAcceptDrops(True)
+        self.list.setDragEnabled(False)
+        self.setWidget(self.list)
+
+        self.setAllowedAreas(Qt.DockWidgetArea.LeftDockWidgetArea | Qt.DockWidgetArea.RightDockWidgetArea)
+        self._refresh()
+        bm.changed.connect(self._refresh)
+
+        self.list.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
+        self.list.customContextMenuRequested.connect(self._ctx)
+
+    def _refresh(self):
+        self.list.clear()
+        for b in self.bm.all():
+            it = QListWidgetItem(f"{b.name}  ({len(b.doc_uids)} views)")
+            it.setData(Qt.ItemDataRole.UserRole, b.id)
+            self.list.addItem(it)
+
+    def _ctx(self, pos):
+        it = self.list.itemAt(pos)
+        m = QMenu(self)
+        m.addAction("New Bundle…", self._new_bundle)
+        if it:
+            bid = it.data(Qt.ItemDataRole.UserRole)
+            m.addSeparator()
+            m.addAction("Rename…", lambda: self._rename(bid))
+            m.addAction("Delete", lambda: self._delete(bid))
+            m.addSeparator()
+            m.addAction("Run Pipeline…", lambda: self._pick_and_run(bid))
+        m.exec(self.list.mapToGlobal(pos))
+
+    def _new_bundle(self):
+        name, ok = QInputDialog.getText(self, "New Bundle", "Name:")
+        if not ok or not name.strip(): return
+        import uuid
+        from setiastro.saspro.bundles import ViewBundle
+        self.bm.add(ViewBundle(id=uuid.uuid4().hex, name=name.strip()))
+
+    def _rename(self, bid):
+        b = self.bm.get(bid); 
+        if not b: return
+        name, ok = QInputDialog.getText(self, "Rename Bundle", "Name:", text=b.name)
+        if ok and name.strip():
+            b.name = name.strip()
+            self.bm.changed.emit()
+
+    def _delete(self, bid):
+        self.bm.remove(bid)
+
+    # --- DnD: add docs or run commands ---
+    def dragEnterEvent(self, e):
+        if e.mimeData().hasFormat(MIME_CMD):
+            e.acceptProposedAction(); return
+        # Let your explorer/subwindow provide a doc UID mime if you have one; example below:
+        if e.mimeData().hasFormat("application/x-saspro-doc-uid"):
+            e.acceptProposedAction(); return
+        e.ignore()
+
+    def dropEvent(self, e):
+        it = self.list.itemAt(e.position().toPoint())
+        if not it:
+            e.ignore(); return
+        bid = it.data(Qt.ItemDataRole.UserRole)
+
+        md: QMimeData = e.mimeData()
+        # 1) drop a command/pipeline onto a bundle -> run across all docs in the bundle
+        if md.hasFormat(MIME_CMD):
+            try:
+                payload = json.loads(bytes(md.data(MIME_CMD)).decode("utf-8"))
+            except Exception:
+                e.ignore(); return
+            docs = self.bm.docs(bid)
+            if not docs:
+                e.ignore(); return
+            # Pipeline support via "pipeline:<id>" (see MW patch below)
+            self.mw._run_payload_on_docs(payload, docs)
+            e.acceptProposedAction(); return
+
+        # 2) drop doc(s) onto a bundle -> add
+        if md.hasFormat("application/x-saspro-doc-uid"):
+            uid = bytes(md.data("application/x-saspro-doc-uid")).decode("utf-8")
+            self.bm.add_doc(bid, uid)
+            e.acceptProposedAction(); return
+
+        e.ignore()
+
+    # quick picker to run a pipeline without DnD
+    def _pick_and_run(self, bid):
+        plist = self.pipelines.all()
+        if not plist:
+            return
+        names = [p.name for p in plist]
+        i, ok = QInputDialog.getItem(self, "Run Pipeline", "Pick:", names, 0, False)
+        if not ok: return
+        p = plist[names.index(i)]
+        payload = {"command_id": f"pipeline:{p.id}", "preset": {}}
+        self.mw._run_payload_on_docs(payload, self.bm.docs(bid))

setiastro/saspro/cheat_sheet.py

@@ -0,0 +1,213 @@
+# pro/cheat_sheet.py
+"""
+Keyboard shortcut cheat sheet dialog.
+
+Displays all keyboard shortcuts and mouse gestures in a tabbed dialog.
+"""
+
+from PyQt6.QtWidgets import (
+    QDialog, QVBoxLayout, QHBoxLayout, QTabWidget, QWidget,
+    QTableWidget, QTableWidgetItem, QHeaderView, QPushButton,
+    QApplication, QMessageBox
+)
+from PyQt6.QtGui import QAction, QShortcut, QKeySequence
+from PyQt6.QtCore import Qt, QCoreApplication
+
+
+def _qs_to_str(seq: QKeySequence) -> str:
+    """Convert a QKeySequence to a human-readable string."""
+    return seq.toString(QKeySequence.SequenceFormat.NativeText).strip()
+
+
+def _clean_text(text: str) -> str:
+    """Remove common Unicode decoration from text."""
+    if not text:
+        return ""
+    # Remove common ellipsis, arrows, etc.
+    return text.replace("…", "").replace("→", "->").replace("←", "<-").strip()
+
+
+def _uniq_keep_order(items):
+    """Return unique items preserving order."""
+    seen = set()
+    out = []
+    for x in items:
+        if x in seen:
+            continue
+        seen.add(x)
+        out.append(x)
+    return out
+
+
+def _seqs_for_action(act: QAction):
+    """Get non-empty key sequences for an action."""
+    seqs = [s for s in act.shortcuts() or []] or ([act.shortcut()] if act.shortcut() else [])
+    return [s for s in seqs if not s.isEmpty()]
+
+
+def _where_for_action(act: QAction) -> str:
+    """Determine where an action is available (Menus/Toolbar or Window)."""
+    try:
+        parent = act.parent()
+        if parent is not None:
+            pn = parent.__class__.__name__
+            if pn.startswith("QMenu") or pn.startswith("QToolBar"):
+                return QCoreApplication.translate("CheatSheet", "Menus/Toolbar")
+    except Exception:
+        pass
+    return QCoreApplication.translate("CheatSheet", "Window")
+
+
+def _describe_action(act: QAction) -> str:
+    """Get a human-readable description for an action."""
+    try:
+        desc = _clean_text(
+            act.statusTip() or act.toolTip() or act.text() or act.objectName() or ""
+        )
+    except Exception:
+        desc = ""
+
+    if not desc:
+        desc = QCoreApplication.translate("CheatSheet", "Action")
+    return desc
+
+
+def _describe_shortcut(sc: QShortcut) -> str:
+    """Get a human-readable description for a shortcut."""
+    try:
+        hint = sc.property("hint")
+        desc = _clean_text(hint or sc.whatsThis() or sc.objectName() or "")
+    except Exception:
+        desc = ""
+
+    if not desc:
+        desc = QCoreApplication.translate("CheatSheet", "Shortcut")
+    return desc
+
+def add_extra_shortcuts(rows):
+    """
+    Add app-level shortcuts that aren't represented by QActions/QShortcuts.
+    rows: list of (shortcut_str, action_str, where_str)
+    """
+    rows.append((
+        _clean_text("Ctrl+K"),
+        _clean_text("Toggle Show/Hide Mask"),
+        QCoreApplication.translate("CheatSheet", "Window"),
+    ))
+    rows.append((
+        _clean_text("Ctrl+Alt+M"),
+        _clean_text("SASpro Neon Invaders (Easter Egg)"),
+        QCoreApplication.translate("CheatSheet", "Window"),
+    ))
+    
+def _where_for_shortcut(sc: QShortcut) -> str:
+    """Determine where a shortcut is available."""
+    try:
+        par = sc.parent()
+        if par is not None:
+            return par.__class__.__name__
+    except Exception:
+        pass
+    return QCoreApplication.translate("CheatSheet", "Window")
+
+
+class CheatSheetDialog(QDialog):
+    """
+    Dialog showing all keyboard shortcuts and mouse gestures.
+    
+    Displays two tabs:
+    - Keyboard shortcuts (from QActions)
+    - Mouse/drag gestures
+    """
+    
+    def __init__(self, parent, keyboard_rows, gesture_rows):
+        super().__init__(parent)
+        self.setWindowTitle(self.tr("Keyboard Shortcut Cheat Sheet"))
+        self.setWindowFlag(Qt.WindowType.Window, True)
+        self.setWindowModality(Qt.WindowModality.NonModal)
+        self.setModal(False)
+        self.resize(780, 520)
+        
+        self._keyboard_rows = keyboard_rows
+        self._gesture_rows = gesture_rows
+
+        tabs = QTabWidget(self)
+
+        # --- Keyboard tab ---
+        pg_keys = QWidget(tabs)
+        v1 = QVBoxLayout(pg_keys)
+        tbl_keys = QTableWidget(0, 3, pg_keys)
+        tbl_keys.setHorizontalHeaderLabels([self.tr("Shortcut"), self.tr("Action"), self.tr("Where")])
+        tbl_keys.verticalHeader().setVisible(False)
+        tbl_keys.setEditTriggers(QTableWidget.EditTrigger.NoEditTriggers)
+        tbl_keys.setSelectionBehavior(QTableWidget.SelectionBehavior.SelectRows)
+        tbl_keys.setSelectionMode(QTableWidget.SelectionMode.SingleSelection)
+        tbl_keys.horizontalHeader().setSectionResizeMode(0, QHeaderView.ResizeMode.ResizeToContents)
+        tbl_keys.horizontalHeader().setSectionResizeMode(1, QHeaderView.ResizeMode.Stretch)
+        tbl_keys.horizontalHeader().setSectionResizeMode(2, QHeaderView.ResizeMode.ResizeToContents)
+        v1.addWidget(tbl_keys)
+
+        # Populate keyboard shortcuts
+        for s, action, where in keyboard_rows:
+            r = tbl_keys.rowCount()
+            tbl_keys.insertRow(r)
+            tbl_keys.setItem(r, 0, QTableWidgetItem(s))
+            tbl_keys.setItem(r, 1, QTableWidgetItem(action))
+            tbl_keys.setItem(r, 2, QTableWidgetItem(where))
+
+        # --- Mouse/Drag tab ---
+        pg_mouse = QWidget(tabs)
+        v2 = QVBoxLayout(pg_mouse)
+        tbl_mouse = QTableWidget(0, 3, pg_mouse)
+        tbl_mouse.setHorizontalHeaderLabels([self.tr("Gesture"), self.tr("Context"), self.tr("Effect")])
+        tbl_mouse.verticalHeader().setVisible(False)
+        tbl_mouse.setEditTriggers(QTableWidget.EditTrigger.NoEditTriggers)
+        tbl_mouse.setSelectionBehavior(QTableWidget.SelectionBehavior.SelectRows)
+        tbl_mouse.setSelectionMode(QTableWidget.SelectionMode.SingleSelection)
+        tbl_mouse.horizontalHeader().setSectionResizeMode(0, QHeaderView.ResizeMode.ResizeToContents)
+        tbl_mouse.horizontalHeader().setSectionResizeMode(1, QHeaderView.ResizeMode.ResizeToContents)
+        tbl_mouse.horizontalHeader().setSectionResizeMode(2, QHeaderView.ResizeMode.Stretch)
+        v2.addWidget(tbl_mouse)
+
+        # Populate mouse gestures
+        for gesture, context, effect in gesture_rows:
+            r = tbl_mouse.rowCount()
+            tbl_mouse.insertRow(r)
+            tbl_mouse.setItem(r, 0, QTableWidgetItem(gesture))
+            tbl_mouse.setItem(r, 1, QTableWidgetItem(context))
+            tbl_mouse.setItem(r, 2, QTableWidgetItem(effect))
+
+        tabs.addTab(pg_keys, self.tr("Base Keyboard"))
+        tabs.addTab(pg_mouse, self.tr("Additional & Mouse & Drag"))
+
+        # Buttons
+        btns = QHBoxLayout()
+        btns.addStretch(1)
+
+        b_copy = QPushButton(self.tr("Copy"))
+        b_copy.clicked.connect(self._copy_all)
+        b_close = QPushButton(self.tr("Close"))
+        b_close.clicked.connect(self.accept)
+        btns.addWidget(b_copy)
+        btns.addWidget(b_close)
+
+        top = QVBoxLayout(self)
+        top.addWidget(tabs)
+        top.addLayout(btns)
+
+    def _copy_all(self):
+        """Copy all shortcuts to clipboard as plain text."""
+        lines = []
+        lines.append("== Keyboard ==")
+        for s, a, w in self._keyboard_rows:
+            lines.append(f"{s:20}  {a}  [{w}]")
+        lines.append("")
+        lines.append("== Mouse & Drag ==")
+        for g, c, e in self._gesture_rows:
+            lines.append(f"{g:24}  {c:18}  {e}")
+        QApplication.clipboard().setText("\n".join(lines))
+        QMessageBox.information(self, self.tr("Copied"), self.tr("Cheat sheet copied to clipboard."))
+
+
+# Legacy alias for backward compatibility
+_CheatSheetDialog = CheatSheetDialog