openprocess 0.7.0__tar.gz → 0.7.1__tar.gz

{openprocess-0.7.0/openprocess.egg-info → openprocess-0.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openprocess
-Version: 0.7.0
+Version: 0.7.1
 Summary: Process mining, Petri nets and workflows in one open app: every algorithm visible, every result reproducible, every step teachable
 Author: Sam Struthers
 License: MIT

{openprocess-0.7.0 → openprocess-0.7.1}/openprocess/__init__.py

@@ -48,7 +48,7 @@ from .sim.simulator import Simulator
 #: The one place the version number is written (pyproject.toml, the update
 #: check and packaging/build.py read it from here).  A release is tagged
 #: "v" + this, e.g. v0.2.0.
-__version__ = "0.7.0"
+__version__ = "0.7.1"
 
 __all__ = [
     "Arc", "BindingElement", "CPNet", "Marking", "Multiset", "Page", "Place",

{openprocess-0.7.0 → openprocess-0.7.1}/openprocess/flow/box.py

@@ -374,10 +374,15 @@ class Called:
 
     @property
     def where(self) -> str:
-        """The file as shown: ``openprocess/mining/discovery/alpha.py:86``."""
+        """The file as shown: ``openprocess/mining/discovery/alpha.py:86`` for the
+        package's own code (whatever the folder it was cloned into is called),
+        else the file's name."""
         path = Path(self.file)
-        parts = path.parts
-        shown = "/".join(parts[parts.index("openprocess"):]) if "openprocess" in parts else path.name
+        root = Path(__file__).resolve().parents[2]          # the folder holding the package
+        try:
+            shown = path.resolve().relative_to(root).as_posix()
+        except ValueError:
+            shown = path.name
         return shown + (f":{self.line}" if self.line else "")
 
 

{openprocess-0.7.0 → openprocess-0.7.1}/openprocess/gui/studio/app.py

@@ -150,6 +150,28 @@ def reveal_label() -> str:
 
 
 
+def report_unexpected_errors() -> None:
+    """An error nobody caught shows a dialog with the traceback instead of
+    vanishing into a terminal the app may not have (in the bundle, it has none)."""
+    import sys
+    import traceback
+    previous = sys.excepthook
+
+    def hook(kind, value, trace) -> None:
+        previous(kind, value, trace)
+        text = "".join(traceback.format_exception(kind, value, trace))
+        try:
+            box = QMessageBox(QMessageBox.Critical, "Something went wrong",
+                              f"{kind.__name__}: {value}")
+            box.setInformativeText("OpenProcess keeps running. If it happens again, please report "
+                                   "it with the details below at https://github.com/s4mstruthers/openprocess/issues.")
+            box.setDetailedText(text)
+            box.exec()
+        except Exception:  # noqa: BLE001 - never fail inside the error reporter
+            pass
+    sys.excepthook = hook
+
+
 def app_icon() -> QIcon:
     """The OpenProcess logo (Dock, window and About box)."""
     return QIcon(str(Path(__file__).resolve().parents[1] / "resources" / "openprocess-icon.png"))
@@ -2415,16 +2437,23 @@ class StudioWindow(QMainWindow):
             self._show_update_dialog(release)      # asked for: the dialog with the notes
         else:
             # At launch: a bar at the top that does not stop anyone working.
-            self.update_bar.offer(release, self._can_install(release))
+            self.update_bar.offer(release, self._can_install(release), self._update_way(release)[1])
 
-    def _can_install(self, release) -> bool:
+    def _update_way(self, release):
+        """How this copy was installed, and how ``release`` can be put over it
+        (see :func:`updates.update_way`; None: only the release page helps)."""
         from . import updates
-        return updates.installed_app() is not None and release.download_for() is not None
+        install = updates.how_installed()
+        return install, updates.update_way(install, release)
+
+    def _can_install(self, release) -> bool:
+        return self._update_way(release)[1] is not None
 
     def _show_update_dialog(self, release) -> None:
         """What's new in ``release`` (and the versions before it), and what to do."""
         from . import updates
-        dialog = updates.UpdateDialog(release, self._can_install(release), self)
+        install, way = self._update_way(release)
+        dialog = updates.UpdateDialog(release, self._can_install(release), self, install, way)
         dialog.exec()
         self._update_action(release, {dialog.SKIP: "skip", dialog.PAGE: "page",
                                       dialog.INSTALL: "install"}.get(dialog.outcome))
@@ -2439,10 +2468,51 @@ class StudioWindow(QMainWindow):
                                          "about the next version", 6000)
         elif action == "page":
             QDesktopServices.openUrl(QUrl(release.page))
-        elif not self._can_install(release):       # "How to Update" (run from source)
+        elif not self._can_install(release):       # "How to Update": the dialog says how
             self._show_update_dialog(release)
         else:
-            self._install_update(release)
+            install, way = self._update_way(release)
+            if way == "app":
+                self._install_update(release)
+            else:
+                self._run_update(release, install, way)
+
+    def _run_update(self, release, install, way: str) -> None:
+        """A pip install or a checkout: run the update commands in the background,
+        then offer to restart into the new version."""
+        from PySide6.QtWidgets import QProgressDialog
+        from . import updates
+        progress = QProgressDialog(f"Updating to OpenProcess {release.version}…", None, 0, 0, self)
+        progress.setWindowTitle("Software Update")
+        progress.setWindowModality(Qt.WindowModal)
+        progress.setMinimumDuration(0)
+        progress.setAutoClose(False)
+        progress.show()
+
+        def failed(message: str) -> None:
+            progress.close()
+            QMessageBox.warning(self, "Software Update", "The update did not go through.\n\n"
+                                f"{message}\n\nYou can also get it from {release.page}")
+
+        def done(output: str) -> None:
+            progress.close()
+            self._after_update(release, output)
+
+        run_in_background(lambda: updates.run_update(install, release, way), done, failed)
+
+    def _after_update(self, release, output: str) -> None:
+        from . import updates
+        box = QMessageBox(self)
+        box.setWindowTitle("Software Update")
+        box.setText(f"OpenProcess {release.version} is installed.")
+        box.setInformativeText("OpenProcess starts again to use it. Your open files come back.")
+        box.setDetailedText(output)
+        restart = box.addButton("Restart Now", QMessageBox.AcceptRole)
+        box.addButton("Later", QMessageBox.RejectRole)
+        box.exec()
+        if box.clickedButton() is restart and self.close():
+            updates.run_detached(updates.restart_command())
+            QApplication.quit()
 
     def _install_update(self, release) -> None:
         """Download and unpack the update in the background, then restart into it."""
@@ -4005,6 +4075,7 @@ def main(argv: list[str] | None = None) -> int:
     application = QApplication.instance() or QApplication(argv)
     application.setApplicationName(APPLICATION_NAME)
     application.setWindowIcon(app_icon())
+    report_unexpected_errors()
     application.setStyle("Fusion")
     application.setFont(theme.ui_font(13))
     application.setStyleSheet(style.stylesheet())

{openprocess-0.7.0 → openprocess-0.7.1}/openprocess/gui/studio/updates.py

@@ -9,12 +9,20 @@ the download for this system is chosen by the names the build gives them
     OpenProcess-<version>-Windows-<arch>.zip
     OpenProcess-<version>-Linux-<arch>.tar.gz
 
-Installing replaces the app the user is running.  The app cannot overwrite
-itself while it runs, so it downloads and unpacks the new version, writes a
-small script that waits for the app to quit, swaps the old app for the new
-one (keeping the old one until the new one is in place) and starts it, and
-then quits.  OpenProcess run from source (``git clone`` + ``pip install -e``) is
-never touched: it only gets told what to run.
+Installing depends on how this copy was installed (:func:`how_installed`):
+
+* **a downloaded app** cannot overwrite itself while it runs, so it
+  downloads and unpacks the new version, writes a small script that waits
+  for the app to quit, swaps the old app for the new one (keeping the old
+  one until the new one is in place) and starts it, and then quits;
+* **a pip install** runs ``pip install --upgrade "openprocess[app]"`` in
+  the same Python and restarts;
+* **a checkout** (``git clone`` + ``pip install -e``) runs ``git pull`` and
+  the editable install again and restarts, but only when the checkout has
+  no uncommitted changes; a copy without ``.git`` is only told what to run.
+
+A release without a download for this system (as 0.7.0 was for CPNpy, whose
+files have another name) can only be opened on the release page.
 
 Everything but :class:`UpdateDialog` (at the end) works without a window.
 """
@@ -96,6 +104,83 @@ def installed_app() -> Path | None:
     return executable.parent                    # OpenProcess/OpenProcess(.exe)
 
 
+@dataclass(frozen=True)
+class Install:
+    """How this copy of OpenProcess was installed, which decides how it updates."""
+
+    #: ``"app"``: a downloaded bundle; ``"source"``: a checkout; ``"pip"``: a package.
+    kind: str
+    #: The bundle, the checkout's folder, or the package's folder.
+    path: Path
+    #: A checkout with a ``.git`` folder, so ``git pull`` works.
+    git: bool = False
+
+
+def _package_dir() -> Path:
+    from ... import __file__ as package_init
+    return Path(package_init).resolve().parent
+
+
+def how_installed() -> Install:
+    app = installed_app()
+    if app is not None:
+        return Install("app", app)
+    package = _package_dir()
+    root = package.parent
+    if (root / "pyproject.toml").is_file():
+        return Install("source", root, git=(root / ".git").exists())
+    return Install("pip", package)
+
+
+def update_way(install: Install, release: "Release") -> str | None:
+    """How ``release`` can be installed over ``install``: ``"app"`` (download and
+    swap), ``"pip"`` (pip in the same environment), ``"source"`` (``git pull``
+    and the editable install again), or None (only the release page helps)."""
+    if install.kind == "app":
+        return "app" if release.download_for() is not None else None
+    if install.kind == "pip":
+        return "pip"
+    if install.kind == "source" and install.git:
+        return "source"
+    return None
+
+
+def update_commands(install: Install, release: "Release", way: str) -> list[list[str]]:
+    """The commands that update a pip install or a checkout, in order."""
+    python = sys.executable
+    if way == "pip":
+        return [[python, "-m", "pip", "install", "--upgrade", f"openprocess[app]=={release.version}"]]
+    if way == "source":
+        return [["git", "-C", str(install.path), "pull", "--ff-only"],
+                [python, "-m", "pip", "install", "-e", f"{install.path}[app]"]]
+    raise ValueError(f"no commands for {way!r}")
+
+
+def run_update(install: Install, release: "Release", way: str, run=subprocess.run) -> str:
+    """Run the update commands; their output, or :class:`RuntimeError` with it."""
+    if way == "source":
+        status = run(["git", "-C", str(install.path), "status", "--porcelain"],
+                     capture_output=True, text=True)
+        if status.returncode == 0 and status.stdout.strip():
+            raise RuntimeError("The checkout has uncommitted changes, which git pull would have "
+                               "to merge. Commit or stash them, then update again.")
+    output: list[str] = []
+    for command in update_commands(install, release, way):
+        output.append("$ " + " ".join(command))
+        result = run(command, capture_output=True, text=True)
+        output.append(((result.stdout or "") + (result.stderr or "")).strip())
+        if result.returncode != 0:
+            raise RuntimeError("\n".join(output).strip())
+    return "\n".join(output).strip()
+
+
+def restart_command() -> list[str]:
+    """The command that starts this OpenProcess again (after a pip or source update)."""
+    if getattr(sys, "frozen", False):
+        return [sys.executable] + sys.argv[1:]
+    return [sys.executable] + sys.argv
+
+
 # ---------------------------------------------------------------------------
 # The latest release
 # ---------------------------------------------------------------------------
@@ -349,11 +434,18 @@ class UpdateDialog(QDialog):
 
     INSTALL, LATER, SKIP, PAGE = range(4)
 
-    def __init__(self, release: Release, can_install: bool, parent=None) -> None:
+    def __init__(self, release: Release, can_install: bool, parent=None,
+                 install: Install | None = None, way: str | None = None) -> None:
         super().__init__(parent)
         self.setWindowTitle("Software Update")
         self.setMinimumSize(520, 420)
         self.outcome = self.LATER
+        install = install or how_installed()
+        if way is None and can_install:
+            way = update_way(install, release) or "app"
+        if not can_install:
+            way = None
+        self.way = way
         layout = QVBoxLayout(self)
         layout.setSpacing(10)
         heading = QLabel(f"<b>OpenProcess {release.version} is available</b> — you have "
@@ -364,18 +456,21 @@ class UpdateDialog(QDialog):
         notes.setOpenExternalLinks(True)
         notes.setMarkdown(release.notes or "_No release notes._")
         layout.addWidget(notes, 1)
-        if not can_install:
-            hint = QLabel("You are running OpenProcess from its source code, which it does not "
-                          "change by itself. To update, run <code>git pull</code> in your "
-                          "OpenProcess folder, then <code>conda env update -f environment.yml "
-                          "--prune</code> (or <code>pip install -e \".[app]\"</code>).")
+        text = update_hint(install, release, way)
+        if text:
+            hint = QLabel(text)
             hint.setWordWrap(True)
+            hint.setOpenExternalLinks(True)
             layout.addWidget(hint)
         buttons = QDialogButtonBox()
-        if can_install:
-            install = buttons.addButton("Download && Install", QDialogButtonBox.AcceptRole)
-            install.clicked.connect(lambda: self._finish(self.INSTALL))
-            install.setDefault(True)
+        if way == "app":
+            action = buttons.addButton("Download && Install", QDialogButtonBox.AcceptRole)
+            action.clicked.connect(lambda: self._finish(self.INSTALL))
+            action.setDefault(True)
+        elif way in ("pip", "source"):
+            action = buttons.addButton("Update && Restart", QDialogButtonBox.AcceptRole)
+            action.clicked.connect(lambda: self._finish(self.INSTALL))
+            action.setDefault(True)
         else:
             page = buttons.addButton("Open Release Page", QDialogButtonBox.AcceptRole)
             page.clicked.connect(lambda: self._finish(self.PAGE))
@@ -393,6 +488,30 @@ class UpdateDialog(QDialog):
             self.reject()
 
 
+def update_hint(install: Install, release: Release, way: str | None) -> str:
+    """What the dialog says under the notes: how this copy updates, or why it cannot."""
+    if way == "app":
+        return ""
+    if way == "pip":
+        return ("You installed OpenProcess with pip. <i>Update &amp; Restart</i> runs "
+                "<code>pip install --upgrade \"openprocess[app]\"</code> in this same Python, then "
+                "starts OpenProcess again.")
+    if way == "source":
+        return (f"You are running OpenProcess from a checkout ({install.path}). <i>Update &amp; "
+                "Restart</i> runs <code>git pull</code> there and <code>pip install -e "
+                "\".[app]\"</code> in this Python (a conda environment keeps working), then starts "
+                "OpenProcess again. It refuses while the checkout has uncommitted changes.")
+    if install.kind == "app":
+        return (f"This release has no download for {system_name()} ({architecture()}), so it "
+                "cannot be installed from here. The release page shows what it has.")
+    if install.kind == "source":
+        return (f"You are running OpenProcess from a copy of its source ({install.path}) that is "
+                "not a git checkout, so it cannot update itself. Get the new version from the "
+                "release page, or clone the repository and run <code>pip install -e "
+                "\".[app]\"</code>.")
+    return ""
+
+
 class UpdateBar(QFrame):
     """A slim bar at the top of the window: a new version is out.
 
@@ -431,9 +550,15 @@ class UpdateBar(QFrame):
         self.release: Release | None = None
         self.setVisible(False)
 
-    def offer(self, release: Release, can_install: bool) -> None:
+    def offer(self, release: Release, can_install: bool, way: str | None = None) -> None:
         self.release = release
         self.text.setText(f"<b>OpenProcess {release.version} is available</b> — you have "
                           f"{__version__}.")
-        self.install_button.setText("Install Now" if can_install else "How to Update")
+        if not can_install:
+            label = "How to Update"
+        elif way in ("pip", "source"):
+            label = "Update Now"
+        else:
+            label = "Install Now"
+        self.install_button.setText(label)
         self.setVisible(True)

{openprocess-0.7.0 → openprocess-0.7.1/openprocess.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openprocess
-Version: 0.7.0
+Version: 0.7.1
 Summary: Process mining, Petri nets and workflows in one open app: every algorithm visible, every result reproducible, every step teachable
 Author: Sam Struthers
 License: MIT

{openprocess-0.7.0 → openprocess-0.7.1}/tests/test_updates.py

@@ -288,6 +288,8 @@ def test_a_new_version_at_launch_is_a_bar_not_a_dialog(monkeypatch):
     window.show()
     monkeypatch.setattr(window, "_install_update", installs.append)
     monkeypatch.setattr(window, "_can_install", lambda release: True)
+    monkeypatch.setattr(window, "_update_way", lambda release: (
+        updates.Install("app", Path("/Applications/OpenProcess.app")), "app"))
     bar = window.update_bar
 
     def check():
@@ -326,6 +328,8 @@ def test_running_from_source_only_says_how_to_update(monkeypatch):
 
     application = QApplication.instance() or QApplication([])
     monkeypatch.delattr(sys, "frozen", raising=False)
+    # A copy of the source without .git: nothing the app can run for you.
+    monkeypatch.setattr(updates, "how_installed", lambda: updates.Install("source", ROOT, git=False))
     shown, installs = [], []
 
     def fake_exec(dialog):
@@ -348,11 +352,108 @@ def test_running_from_source_only_says_how_to_update(monkeypatch):
     bar.install_button.click()
     _pump(application, 0.1)
     assert installs == [] and len(shown) == 1
-    assert "git pull" in " ".join(label.text() for label in shown[0].findChildren(
+    assert "not a git checkout" in " ".join(label.text() for label in shown[0].findChildren(
         updates.QLabel))
     window.close()
 
 
+def test_how_this_copy_was_installed_decides_how_it_updates(monkeypatch, tmp_path):
+    release = Release.from_github(dict(GITHUB_ANSWER, tag_name="v99.0.0"))
+    # A downloaded app: the download, when the release has one for this system.
+    monkeypatch.setattr(updates, "installed_app", lambda: tmp_path / "OpenProcess.app")
+    app = updates.how_installed()
+    assert app.kind == "app" and updates.update_way(app, release) == "app"
+    none = Release.from_github(dict(GITHUB_ANSWER, tag_name="v99.0.0", assets=[]))
+    assert updates.update_way(app, none) is None
+    assert "no download for" in updates.update_hint(app, none, None)
+    # A checkout: git pull and the editable install; without .git, only advice.
+    monkeypatch.setattr(updates, "installed_app", lambda: None)
+    checkout = tmp_path / "src"
+    (checkout / "openprocess").mkdir(parents=True)
+    (checkout / "pyproject.toml").write_text("[project]\nname = 'openprocess'\n")
+    monkeypatch.setattr(updates, "_package_dir", lambda: checkout / "openprocess")
+    copy = updates.how_installed()
+    assert copy.kind == "source" and not copy.git and updates.update_way(copy, release) is None
+    (checkout / ".git").mkdir()
+    source = updates.how_installed()
+    assert source.git and updates.update_way(source, release) == "source"
+    commands = updates.update_commands(source, release, "source")
+    assert commands[0][:4] == ["git", "-C", str(checkout), "pull"]
+    assert commands[1][-2:] == ["-e", f"{checkout}[app]"]
+    # A pip install: pip, pinned to the release.
+    site = tmp_path / "site-packages" / "openprocess"
+    site.mkdir(parents=True)
+    monkeypatch.setattr(updates, "_package_dir", lambda: site)
+    pip = updates.how_installed()
+    assert pip.kind == "pip" and updates.update_way(pip, release) == "pip"
+    assert updates.update_commands(pip, release, "pip")[0][-1] == "openprocess[app]==99.0.0"
+    assert "pip install --upgrade" in updates.update_hint(pip, release, "pip")
+    assert updates.restart_command()[0] == sys.executable
+
+
+def test_run_update_runs_the_commands_and_refuses_a_dirty_checkout(tmp_path):
+    release = Release.from_github(dict(GITHUB_ANSWER, tag_name="v99.0.0"))
+    source = updates.Install("source", tmp_path, git=True)
+    calls = []
+
+    class Done:
+        def __init__(self, code=0, out="ok"):
+            self.returncode, self.stdout, self.stderr = code, out, ""
+
+    def fake_run(command, **kwargs):
+        calls.append(command)
+        if command[3:] == ["status", "--porcelain"]:
+            return Done(out=" M changed.py\n" if fake_run.dirty else "")
+        return Done(code=1, out="boom") if fake_run.fail else Done()
+    fake_run.dirty, fake_run.fail = True, False
+    with pytest.raises(RuntimeError, match="uncommitted changes"):
+        updates.run_update(source, release, "source", run=fake_run)
+    assert len(calls) == 1                                   # nothing was pulled
+    fake_run.dirty = False
+    output = updates.run_update(source, release, "source", run=fake_run)
+    assert calls[2][3] == "pull" and "pip" in calls[3][2]
+    assert output.startswith("$ git -C") and "ok" in output
+    fake_run.fail = True
+    with pytest.raises(RuntimeError, match="boom"):
+        updates.run_update(updates.Install("pip", tmp_path), release, "pip", run=fake_run)
+
+
+def test_a_pip_install_updates_with_pip_and_offers_a_restart(monkeypatch):
+    from PySide6.QtWidgets import QApplication
+
+    from openprocess.gui.studio.app import StudioWindow
+
+    application = QApplication.instance() or QApplication([])
+    monkeypatch.setattr(updates, "how_installed", lambda: updates.Install("pip", ROOT))
+    monkeypatch.setattr(updates, "fetch_latest", lambda: Release.from_github(
+        dict(GITHUB_ANSWER, tag_name="v99.0.0")))
+    ran, after = [], []
+    monkeypatch.setattr(updates, "run_update", lambda install, release, way: (
+        ran.append((install.kind, way)) or "$ pip install …\nSuccessfully installed"))
+    window = StudioWindow()
+    window.show()
+    monkeypatch.setattr(window, "_after_update", lambda release, output: after.append(output))
+    window.check_for_updates(manual=False)
+    for _ in range(300):
+        if window.update_bar.isVisible():
+            break
+        _pump(application, 0.01)
+    bar = window.update_bar
+    assert bar.isVisible() and bar.install_button.text() == "Update Now"
+    bar.install_button.click()
+    for _ in range(300):
+        if after:
+            break
+        _pump(application, 0.01)
+    assert ran == [("pip", "pip")] and "Successfully installed" in after[0]
+    dialog = updates.UpdateDialog(Release.from_github(dict(GITHUB_ANSWER, tag_name="v99.0.0")),
+                                  True, None, updates.Install("pip", ROOT), "pip")
+    texts = [b.text() for b in dialog.findChildren(updates.QPushButton)]
+    assert "Update && Restart" in texts
+    assert "pip install --upgrade" in " ".join(l.text() for l in dialog.findChildren(updates.QLabel))
+    window.close()
+
+
 def test_release_notes_script_writes_utf8_on_windows_too(tmp_path):
     """Regression (v0.3.2 build): printing "✕" failed on Windows, whose stdout
     encoding is cp1252.  Run the script with that encoding to check."""