pycforge-sdk 0.6.3__py3-none-any.whl

pycforge_sdk/gui/dialogs.py

@@ -0,0 +1,310 @@
+"""Familiar PyCForge dialog chrome for explicit, explained SDK actions."""
+from pathlib import Path
+from PySide6.QtCore import QDir, Qt, QTimer, QSize
+from PySide6.QtGui import QFontDatabase
+from PySide6.QtWidgets import (QDialog, QVBoxLayout, QHBoxLayout, QFormLayout,
+    QLineEdit, QComboBox, QDialogButtonBox, QFileSystemModel, QTreeView,
+    QPlainTextEdit, QSplitter)
+from .visual.qt_dialog_chrome import install_dialog_chrome
+from .visual.qt_screen_geometry import fit_window_to_available_screen
+from .visual.qt_file_icons import PyCForgeFileIconProvider
+from .visual.qt_icons import load_pycforge_icon
+from .widgets import label, button
+from .jobs import JobRunner
+from .identity import SDK_QSS, sdk_icon, sdk_badge
+from ..discovery import interpreters_at, support_folder
+
+
+class Dialog(QDialog):
+    def __init__(self, title, parent=None, *, resizable=True):
+        super().__init__(parent)
+        self.setWindowTitle(title)
+        self.setWindowIcon(sdk_icon())
+        self.setStyleSheet(SDK_QSS)
+        self.setProperty("dialogFrame", True)
+        self.body = QVBoxLayout(self)
+        self.body.setContentsMargins(12, 8, 12, 12)
+        self.chrome = install_dialog_chrome(self, self.body, resizable=resizable)
+        self.chrome.title_bar.add_toolbar_widget(sdk_badge(self))
+        self._fitted = False
+
+    def showEvent(self, event):
+        if not self._fitted:
+            self._fitted = True
+            fit_window_to_available_screen(self, preferred=(self.width(), self.height()), minimum=(400, 180))
+        super().showEvent(event)
+
+    def buttons(self, accept="OK"):
+        box = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel)
+        box.button(QDialogButtonBox.StandardButton.Ok).setText(accept)
+        for key, icon in ((QDialogButtonBox.StandardButton.Ok, "check"),
+                          (QDialogButtonBox.StandardButton.Cancel, "cancel")):
+            box.button(key).setIcon(load_pycforge_icon(icon))
+            box.button(key).setIconSize(QSize(20, 20))
+        box.accepted.connect(self.accept)
+        box.rejected.connect(self.reject)
+        self.body.addWidget(box)
+        return box
+
+
+class Prompt(Dialog):
+    @staticmethod
+    def ask(parent, title, message, choices):
+        dlg = Prompt(title, parent, resizable=False)
+        dlg.body.addWidget(label(message))
+        row = QHBoxLayout()
+        dlg.choice = "cancel"
+        for key, text in choices:
+            def choose(_checked=False, value=key):
+                dlg.choice = value
+                dlg.accept()
+            icon = {"cancel":"cancel", "discard":"close", "save":"save-python", "replace":"save-as",
+                    "register":"module"}.get(key, "check")
+            row.addWidget(button(text, icon, choose))
+        dlg.body.addLayout(row)
+        dlg.resize(530, 210)
+        dlg.exec()
+        return dlg.choice
+
+
+class PathDialog(Dialog):
+    """A themed asynchronous filesystem tree; selection never executes a file."""
+    def __init__(self, title, parent=None, *, initial="", mode="file", suffix="", description=""):
+        super().__init__(title, parent)
+        self.setObjectName("PyCForgeFileDialog")
+        self.mode, self.suffix = mode, suffix
+        if description:
+            self.body.addWidget(label(description))
+        if mode == "engine":
+            self.body.addWidget(label("Select PyCForge's installation folder, its Python environment, or its installed SDK support folder. "
+                "The SDK will find and check the matching engine. Selecting python.exe directly also works. "
+                "A source folder alone needs a working PyCForge installation."))
+        path = Path(initial).expanduser() if initial else Path.home()
+        path = path.absolute()
+        folder = path if path.is_dir() else path.parent
+        while not folder.is_dir() and folder.parent != folder:
+            folder = folder.parent
+        self._directory = folder
+        self.location = QLineEdit(str(folder))
+        self.location.setAccessibleName("Folder")
+        row = QHBoxLayout()
+        row.addWidget(label("Folder")); row.addWidget(self.location, 1)
+        row.addWidget(button("Up", "move-up", self.up))
+        row.addWidget(button("Go", "chevron-right", self.navigate))
+        self.body.addLayout(row)
+        places = QHBoxLayout()
+        places.addWidget(button("Home", "open", self.home))
+        places.addWidget(label("Drives"))
+        self.drives = QComboBox()
+        self.drives.setAccessibleName("Drives and filesystem roots")
+        self.drives.addItem("Choose a drive…", None)
+        for drive in QDir.drives():
+            self.drives.addItem(load_pycforge_icon("open"), drive.absoluteFilePath(), drive.absoluteFilePath())
+        self.drives.activated.connect(self.drive_selected)
+        places.addWidget(self.drives, 1)
+        self.body.addLayout(places)
+        self.model = QFileSystemModel(self)
+        self.model.setReadOnly(True)
+        self.icon_provider = PyCForgeFileIconProvider()
+        self.model.setIconProvider(self.icon_provider)
+        self.model.setFilter(QDir.Filter.AllDirs | QDir.Filter.NoDotAndDotDot |
+            (QDir.Filter(0) if mode in ("directory", "new_directory") else QDir.Filter.Files))
+        if suffix:
+            self.model.setNameFilters(["*"+suffix]); self.model.setNameFilterDisables(False)
+        self.model.setRootPath(str(folder))
+        self.tree = QTreeView()
+        self.tree.setObjectName("FileTree")
+        self.tree.setIconSize(QSize(24, 24))
+        self.tree.setModel(self.model)
+        self.tree.setRootIndex(self.model.index(str(folder)))
+        self.tree.setColumnWidth(0, 390)
+        self.tree.setAccessibleName("Files and folders")
+        self.tree.clicked.connect(self.selected)
+        self.tree.selectionModel().currentChanged.connect(lambda current, previous: self.selected(current))
+        self.tree.doubleClicked.connect(self.activated)
+        self.body.addWidget(self.tree, 1)
+        self.path = QLineEdit(str(path) if initial or mode == "directory" else "")
+        self.path.setAccessibleName("Selected path")
+        self.body.addWidget(label("Selected folder" if mode in ("directory", "new_directory") else
+                                 "PyCForge installation, support folder, or Python interpreter" if mode == "engine" else "Selected file"))
+        self.body.addWidget(self.path)
+        self.problem = label("")
+        self.body.addWidget(self.problem)
+        self.buttons("Locate PyCForge" if mode == "engine" else "Select Folder" if mode == "directory" else
+                     "Use this path" if mode in ("save", "new_directory") else "Choose")
+        self.location.returnPressed.connect(self.navigate)
+        self.resize(820, 560)
+
+    def navigate(self):
+        path = Path(self.location.text().strip()).expanduser()
+        if not path.is_absolute(): path = self._directory / path
+        if not path.is_dir():
+            self.problem.setText("Enter an accessible folder or choose a drive."); return False
+        name = Path(self.path.text()).name if self.path.text().strip() else ""
+        self._directory = path.absolute()
+        self.model.setRootPath(str(self._directory))
+        self.tree.setRootIndex(self.model.index(str(self._directory)))
+        self.tree.clearSelection()
+        self.location.setText(str(self._directory))
+        self.path.setText(str(self._directory) if self.mode in ("directory", "engine") else
+                          str(self._directory/name) if self.mode in ("save", "new_directory") and name else "")
+        self.problem.setText("")
+        return True
+
+    def up(self):
+        self.location.setText(str(self._directory.parent)); self.navigate()
+
+    def home(self):
+        self.location.setText(str(Path.home())); self.navigate()
+
+    def drive_selected(self, index):
+        value = self.drives.itemData(index)
+        if value:
+            self.location.setText(value); self.navigate()
+
+    def selected(self, index):
+        if not index.isValid() or not hasattr(self, 'path'): return
+        path = self.model.filePath(index)
+        if self.mode in ("directory", "engine") or not Path(path).is_dir():
+            self.path.setText(path)
+
+    def activated(self, index):
+        path = self.model.filePath(index)
+        if Path(path).is_dir():
+            self.location.setText(path); self.navigate()
+        else:
+            self.accept()
+
+    def accept(self):
+        if self.location.text().strip() != str(self._directory) and not self.navigate(): return
+        path = Path(self.path.text()).expanduser()
+        if not self.path.text().strip():
+            self.problem.setText("Choose a path first."); return
+        if not path.is_absolute():
+            path = self._directory / path
+        if self.mode == "engine":
+            # Preserve a support-folder selection so discovery must match it,
+            # rather than accepting an unrelated interpreter found nearby.
+            support = support_folder(path)
+            resolved = path if support else engine_interpreter(path)
+            if resolved is None:
+                self.problem.setText("Select the Python executable containing PyCForge, or its environment folder. "
+                    "An installer, wheel, project file or PyCForge launcher cannot be used here.")
+                return
+            path = resolved
+        if self.mode == "file" and not path.is_file():
+            self.problem.setText("Choose an existing file."); return
+        if self.mode == "directory" and not path.is_dir():
+            self.problem.setText("Choose an existing folder."); return
+        if self.mode in ("save", "new_directory"):
+            if self.suffix and not path.suffix: path = path.with_suffix(self.suffix)
+            if path.is_dir() or not path.parent.is_dir() or (self.mode == "new_directory" and path.exists()):
+                self.problem.setText("Enter a new name inside an existing folder."); return
+        if self.suffix and path.suffix.lower() != self.suffix:
+            self.problem.setText("Choose a " + self.suffix + " file."); return
+        self.path.setText(str(path.absolute()))
+        super().accept()
+
+    @staticmethod
+    def choose(parent, title, *, initial="", mode="file", suffix="", description=""):
+        dlg = PathDialog(title, parent, initial=initial, mode=mode, suffix=suffix, description=description)
+        try:
+            return dlg.path.text() if dlg.exec() == QDialog.DialogCode.Accepted else ""
+        finally:
+            dlg.deleteLater()
+
+
+def engine_interpreter(path):
+    """Resolve a selected environment without executing or importing anything."""
+    found = interpreters_at(path)
+    return found[0] if found else None
+
+
+class NewProjectDialog(Dialog):
+    def __init__(self, templates, parent=None):
+        super().__init__("New conversion extension", parent)
+        self.templates = templates
+        self.body.addWidget(label("Choose a starter. The engine supplies its supported contracts and fixtures; you supply the extension's identity and explanations."))
+        form = QFormLayout()
+        self.template = QComboBox()
+        for item in templates: self.template.addItem(item["title"], item["id"])
+        self.description = label("")
+        self.template.currentIndexChanged.connect(self.explain)
+        form.addRow("Starter", self.template)
+        form.addRow(self.description)
+        self.author = QLineEdit(); self.author.setPlaceholderText("Your name or organization")
+        form.addRow("Author", self.author)
+        self.directory = QLineEdit(); self.directory.setPlaceholderText("A new project folder")
+        row = QHBoxLayout(); row.addWidget(self.directory, 1)
+        row.addWidget(button("Browse", "open", self.browse))
+        form.addRow("New folder", row)
+        self.body.addLayout(form)
+        self.problem = label(""); self.body.addWidget(self.problem)
+        self.buttons("Create project")
+        self.explain(); self.resize(700, 370)
+
+    def explain(self):
+        i = self.template.currentIndex()
+        self.description.setText(self.templates[i]["description"] if i >= 0 else "Connect to an engine to see its starters.")
+
+    def browse(self):
+        value = PathDialog.choose(self, "New project folder", initial=self.directory.text(), mode="new_directory",
+            description="Choose the parent folder, then enter a new folder name for this SDK project.")
+        if value: self.directory.setText(value)
+
+    def accept(self):
+        if not self.author.text().strip() or not self.directory.text().strip() or self.template.currentIndex() < 0:
+            self.problem.setText("Choose a starter, enter your author name and choose a new folder."); return
+        super().accept()
+
+
+class SourceDialog(Dialog):
+    def __init__(self, snapshot, filename, configuration, parent=None):
+        super().__init__("Fixture source — " + filename, parent)
+        self.snapshot, self.filename, self.configuration = snapshot, filename, configuration
+        self.saved_snapshot = None
+        self.close_pending = False
+        self.body.addWidget(label("Edit the fixture source. Saving changes its identity and requires new verification. This editor does not run Python."))
+        self.source = QPlainTextEdit(snapshot["sources"][filename])
+        code_font = QFontDatabase.systemFont(QFontDatabase.SystemFont.FixedFont)
+        code_font.setPointSize(max(11, self.font().pointSize())); self.source.setFont(code_font)
+        self.source.setAccessibleName("Fixture source")
+        self.source.setLineWrapMode(QPlainTextEdit.LineWrapMode.NoWrap)
+        self.body.addWidget(self.source, 1)
+        self.problem = label(""); self.body.addWidget(self.problem)
+        self.controls = QHBoxLayout()
+        self.save = button("Save source", "save-python", self.save_source)
+        self.close_button = button("Close", "close", self.reject)
+        self.controls.addWidget(self.save); self.controls.addWidget(self.close_button)
+        self.body.addLayout(self.controls)
+        self.runner = JobRunner(self)
+        self.runner.finished.connect(self.finished_save)
+        self.resize(920, 650)
+
+    def save_source(self):
+        self.save.setEnabled(False); self.source.setReadOnly(True)
+        self.problem.setText("Saving fixture…")
+        self.runner.start(self.configuration, "save_source", (self.snapshot["directory"], self.filename, self.source.toPlainText()),
+                          {"expected_sha256": self.snapshot["project_sha256"]})
+
+    def finished_save(self, method, result, revision):
+        self.save.setEnabled(True); self.source.setReadOnly(False)
+        if result["status"] == "succeeded":
+            self.snapshot = self.saved_snapshot = result["data"]
+            self.problem.setText("Saved. Run Scan and Verify fixtures for the changed source.")
+        else:
+            self.problem.setText("\n".join(d["message"] for d in result["diagnostics"]))
+        if self.close_pending:
+            self.close_pending = False; QTimer.singleShot(0, self.reject)
+
+    def reject(self):
+        if self.runner.busy:
+            self.close_pending = True
+            self.runner.cancel(); self.problem.setText("Canceling; waiting for the save operation to finish."); return
+        if self.source.toPlainText() != self.snapshot["sources"][self.filename]:
+            if Prompt.ask(self, "Unsaved fixture", "Close and discard your unsaved source changes?",
+                          [("discard", "Discard changes"), ("cancel", "Keep editing")]) != "discard": return
+        super().reject()
+
+    def closeEvent(self, event):
+        event.ignore(); self.reject()