openprocess 0.10.5__tar.gz → 0.10.6__tar.gz

{openprocess-0.10.5/openprocess.egg-info → openprocess-0.10.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openprocess
-Version: 0.10.5
+Version: 0.10.6
 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
@@ -833,7 +833,11 @@ extra) and *Predict the next activity*. Or start empty.
   draws what flows in, OpenProcess and its boxes, what flows out, and the
   optional tools (pandas, numpy, scipy, matplotlib, …) with whether each is
   installed, how to install it and the boxes it brings. All of it is read
-  from the box library.
+  from the box library. *Install…* works in the downloaded app too: it carries
+  pip and installs into a folder of your own (on a Mac,
+  `~/Library/Application Support/OpenProcess/packages`), and the boxes that
+  need the package come alive without a restart. PM4Py needs a Python
+  install (`pip install pm4py`), as parts of it are built from source.
 - **Motion** is kept short: a space switch, the side panel and Canvas ↔
   Summary settle in a fifth of a second, and a box pulses once when it
   finishes. `OPENPROCESS_NO_MOTION=1` turns it off.
@@ -969,6 +973,16 @@ Plainly stated:
 Next up: several instances of a subpage, CPN monitors, and signed apps that
 open without a security prompt.
 
+## Cite
+
+If OpenProcess helped with a course, a thesis or a paper, cite it. *Help ▸
+Cite OpenProcess…* in the app gives BibTeX and a one-line citation, and
+each algorithm's Code tab has *Cite* for the paper it follows. GitHub's
+*Cite this repository* reads [CITATION.cff](CITATION.cff). Releases are
+archived on Zenodo, which gives each version a DOI; the all-versions DOI
+goes into `CITATION.cff` (`doi:`) once the first release is archived, and
+the app's citations pick it up from there.
+
 ## Licence
 
 MIT. See [LICENSE](LICENSE).

{openprocess-0.10.5 → openprocess-0.10.6}/README.md

@@ -794,7 +794,11 @@ extra) and *Predict the next activity*. Or start empty.
   draws what flows in, OpenProcess and its boxes, what flows out, and the
   optional tools (pandas, numpy, scipy, matplotlib, …) with whether each is
   installed, how to install it and the boxes it brings. All of it is read
-  from the box library.
+  from the box library. *Install…* works in the downloaded app too: it carries
+  pip and installs into a folder of your own (on a Mac,
+  `~/Library/Application Support/OpenProcess/packages`), and the boxes that
+  need the package come alive without a restart. PM4Py needs a Python
+  install (`pip install pm4py`), as parts of it are built from source.
 - **Motion** is kept short: a space switch, the side panel and Canvas ↔
   Summary settle in a fifth of a second, and a box pulses once when it
   finishes. `OPENPROCESS_NO_MOTION=1` turns it off.
@@ -930,6 +934,16 @@ Plainly stated:
 Next up: several instances of a subpage, CPN monitors, and signed apps that
 open without a security prompt.
 
+## Cite
+
+If OpenProcess helped with a course, a thesis or a paper, cite it. *Help ▸
+Cite OpenProcess…* in the app gives BibTeX and a one-line citation, and
+each algorithm's Code tab has *Cite* for the paper it follows. GitHub's
+*Cite this repository* reads [CITATION.cff](CITATION.cff). Releases are
+archived on Zenodo, which gives each version a DOI; the all-versions DOI
+goes into `CITATION.cff` (`doi:`) once the first release is archived, and
+the app's citations pick it up from there.
+
 ## Licence
 
 MIT. See [LICENSE](LICENSE).

{openprocess-0.10.5 → openprocess-0.10.6}/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.10.5"
+__version__ = "0.10.6"
 
 __all__ = [
     "Arc", "BindingElement", "CPNet", "Marking", "Multiset", "Page", "Place",

{openprocess-0.10.5 → openprocess-0.10.6}/openprocess/citation.py

@@ -14,6 +14,7 @@ from __future__ import annotations
 import datetime as _dt
 import re
 from dataclasses import dataclass, field
+from pathlib import Path
 
 from . import references as _references
 
@@ -27,6 +28,23 @@ def app_version() -> str:
     return __version__
 
 
+def concept_doi() -> str:
+    """The DOI Zenodo gives the software (all versions), from ``CITATION.cff``
+    at the top of the repository or installed beside the package; "" until
+    the first release is archived."""
+    import re
+    for candidate in (Path(__file__).resolve().parents[1] / "CITATION.cff",
+                      Path(__file__).resolve().parent / "CITATION.cff"):
+        try:
+            text = candidate.read_text(encoding="utf-8")
+        except OSError:
+            continue
+        found = re.search(r"^doi:\s*(\S+)\s*$", text, re.M)
+        if found:
+            return found.group(1).strip("'\"")
+    return ""
+
+
 # ---------------------------------------------------------------------------
 # One entry
 # ---------------------------------------------------------------------------
@@ -137,45 +155,54 @@ def entries_for_module(module: str) -> list[Entry]:
 # ---------------------------------------------------------------------------
 # The app itself
 # ---------------------------------------------------------------------------
-def app_entry(version: str | None = None, year: int | None = None) -> Entry:
+def app_entry(version: str | None = None, year: int | None = None, doi: str | None = None) -> Entry:
     version = version or app_version()
     year = year or _dt.date.today().year
+    doi = concept_doi() if doi is None else doi
     return Entry("software", "openprocess", {
         "author": " and ".join(f"{last}, {first}" for last, first in APP_AUTHORS),
         "title": APP_TITLE,
         "version": version,
         "year": str(year),
+        "doi": doi,
         "url": APP_URL,
         "note": "Every algorithm shows its code and the paper it follows; every analysis keeps a record "
                 "that runs again",
     })
 
 
-def app_bibtex(version: str | None = None, year: int | None = None) -> str:
-    return app_entry(version, year).bibtex()
+def app_bibtex(version: str | None = None, year: int | None = None, doi: str | None = None) -> str:
+    return app_entry(version, year, doi).bibtex()
 
 
-def app_text(version: str | None = None, year: int | None = None) -> str:
+def app_text(version: str | None = None, year: int | None = None, doi: str | None = None) -> str:
     """The citation in one line, as a reference list would have it."""
     version = version or app_version()
     year = year or _dt.date.today().year
+    doi = concept_doi() if doi is None else doi
     authors = ", ".join(f"{first} {last}" for last, first in APP_AUTHORS)
-    return f"{authors}. {APP_TITLE} (version {version}) [software], {year}. {APP_URL}"
+    where = f"https://doi.org/{doi}" if doi else APP_URL
+    return f"{authors}. {APP_TITLE} (version {version}) [software], {year}. {where}"
 
 
-def cff_text(version: str | None = None, released: _dt.date | None = None) -> str:
-    """The contents of ``CITATION.cff`` (Citation File Format 1.2.0) for ``version``."""
+def cff_text(version: str | None = None, released: _dt.date | None = None, doi: str = "") -> str:
+    """The contents of ``CITATION.cff`` (Citation File Format 1.2.0) for
+    ``version``; ``doi`` is Zenodo's concept DOI once the first release is archived."""
     version = version or app_version()
     released = released or _dt.date.today()
     authors = "\n".join(f"  - family-names: {last}\n    given-names: {first}" for last, first in APP_AUTHORS)
+    def quoted(text: str) -> str:               # a YAML string: a colon in the title would otherwise break it
+        return '"' + text.replace('\\', '\\\\').replace('"', '\\"') + '"'
+
     return (
         "cff-version: 1.2.0\n"
-        "message: If you use OpenProcess in teaching or research, please cite it as below.\n"
+        f"message: {quoted('If you use OpenProcess in teaching or research, please cite it as below.')}\n"
         "type: software\n"
-        f"title: {APP_TITLE}\n"
+        f"title: {quoted(APP_TITLE)}\n"
         f"version: {version}\n"
         f"date-released: {released.isoformat()}\n"
-        f"repository-code: {APP_URL}\n"
+        + (f"doi: {doi}\n" if doi else "")
+        + f"repository-code: {APP_URL}\n"
         f"url: {APP_URL}\n"
         "license: MIT\n"
         "keywords:\n  - process mining\n  - Petri nets\n  - workflow nets\n  - conformance checking\n"

{openprocess-0.10.5 → openprocess-0.10.6}/openprocess/flow/__init__.py

@@ -35,12 +35,13 @@ from .library import Library, library_for, standard_library
 from .record import check, differences, load, save
 from .runner import Cache, Result, Run, Runner
 from .sweep import Sweep
-from .types import (AlignmentResult, Any, CPNet, DFG, Dataset, EventLog, Figure, Footprint, Marking,
+from .types import (Column, AlignmentResult, Any, CPNet, DFG, Dataset, EventLog, Figure, Footprint, Marking,
                     PetriNet, Predictions, Predictor, ProcessTree, Regions, ReplayResult, Scores,
                     SimpleLog, Table, Text, TransitionSystem, register_type)
 from .workflow import Edge, Group, Node, Workflow, WorkflowError, to_python, workflow
 
 __all__ = [
+    "Column",
     "AlignmentResult", "Any", "Box", "BoxError", "BoxSpec", "CPNet", "Cache", "DFG", "Dataset", "Edge",
     "EventLog", "Explanation", "Figure", "Footprint", "Group", "Library", "Marking", "Node", "PetriNet",
     "Port", "Predictions", "Predictor", "ProcessTree", "Regions", "ReplayResult", "Result", "Run",

{openprocess-0.10.5 → openprocess-0.10.6}/openprocess/flow/box.py

@@ -18,6 +18,7 @@ parameters whose type is a OpenProcess type             input connection points,
 the return type                                   the output; a dataclass of typed fields gives several
 ``int``, ``float``, ``bool``, ``str`` with a default  a setting, with the default as its value
 ``Literal["a", "b"]``                             a setting that is a choice
+``Column``                                        a setting that is a column of a connected table
 ``Path``                                          a setting that is a file in the folder
 the docstring                                     the help text
 ``inspect.getsource``                             the Code tab
@@ -44,7 +45,7 @@ from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any, Callable, Literal, Union, get_args, get_origin, get_type_hints
 
-from .types import TypeInfo, is_known, type_info
+from .types import Column, TypeInfo, is_known, type_info
 
 SETTING_TYPES = (int, float, bool, str)
 
@@ -106,7 +107,7 @@ class Setting:
     """A parameter that is not an input: shown as a control in the side panel."""
 
     name: str
-    kind: str                        # "int", "float", "bool", "str", "choice", "path"
+    kind: str                        # "int", "float", "bool", "str", "choice", "path", "column"
     default: Any
     choices: tuple = ()
     help: str = ""
@@ -273,12 +274,14 @@ def _setting_from(name: str, annotation, default, has_default: bool, doc_hints:
         kind = "int"
     elif annotation is float:
         kind = "float"
+    elif annotation is Column:
+        kind = "column"
     elif annotation is str:
         kind = "str"
     else:
         raise BoxError(
             f"parameter {name!r} has type {_type_text(annotation)}, which is neither a OpenProcess "
-            f"type (an input) nor int, float, bool, str, Literal[...] or Path (a setting)")
+            f"type (an input) nor int, float, bool, str, Literal[...], Column or Path (a setting)")
     if not has_default:
         raise BoxError(f"setting {name!r} needs a default value (e.g. {name}: {kind} = ...)")
     if kind == "float" and isinstance(default, int) and not isinstance(default, bool):

{openprocess-0.10.5 → openprocess-0.10.6}/openprocess/flow/boxes/science.py

@@ -17,7 +17,7 @@ from ...mining.log import EventLog
 from ...mining.petrinet import PetriNet
 from ..box import box
 from ..convert import convert
-from ..types import Figure, Scores, Table
+from ..types import Column, Figure, Scores, Table
 
 
 @box(name="Describe log", group="Science", needs="pandas")
@@ -109,7 +109,7 @@ def correlate(table: Table) -> Table:
 
 @box(name="Plot", group="Science", needs="matplotlib")
 def plot(scores: list[Scores] = (), tables: list[Table] = (),
-         x: str = "", y: str = "") -> Figure:
+         x: Column = "", y: Column = "") -> Figure:
     """Bars per model for scores, histograms for bootstrap tables, or a line
     of column *y* against column *x* of a table (a sweep). The figure is a
     matplotlib figure, converted to SVG; its code is this box's code.

{openprocess-0.10.5 → openprocess-0.10.6}/openprocess/flow/reproducibility.py

@@ -34,6 +34,15 @@ class Status:
     def tone(self) -> str:
         return {"reproduces": "good", "changed": "warning", "differs": "critical"}.get(self.state, "muted")
 
+    @property
+    def short(self) -> str:
+        """Two or three words for a badge; :attr:`headline` is the sentence."""
+        if self.state == "changed":
+            count = len(self.details)
+            return f"{count} change{'s' if count != 1 else ''} since"
+        return {"unrecorded": "Not recorded", "reproduces": "Reproducible", "differs": "Differs from the record",
+                "unchecked": "Recorded, not run"}.get(self.state, self.headline)
+
 
 def status(workflow: Workflow, record: Record | None, run: Run | None, folder=None) -> Status:
     """The analysis's reproducibility, from its record and its latest run."""

{openprocess-0.10.5 → openprocess-0.10.6}/openprocess/flow/runner.py

@@ -41,6 +41,25 @@ WAITING, RUNNING, DONE, FAILED, IDLE, BLOCKED, SKIPPED = (
     "waiting", "running", "done", "failed", "idle", "blocked", "skipped")
 
 
+def columns_connected(workflow: Workflow, run: "Run | None", node: Node) -> list[str]:
+    """The columns of the tables connected to ``node``, as of ``run``: what a
+    ``Column`` setting lists.  Empty until the boxes before it have run."""
+    if run is None:
+        return []
+    from .types import Table
+    out: list[str] = []
+    for sources in workflow.inputs_of(node).values():
+        for source_id, output in sources:
+            result = run.result(source_id)
+            if result is None or result.status != DONE:
+                continue
+            value = result.values.get(output, result.value)
+            for item in (value if isinstance(value, (list, tuple)) else [value]):
+                if isinstance(item, Table):
+                    out.extend(column for column in item.columns if column not in out)
+    return out
+
+
 @dataclass
 class Result:
     """What one box produced in one run (one per sweep variant)."""
@@ -270,6 +289,14 @@ class Runner:
                     values.append(self._fit(value, port))
                     keys.append(upstream.key + ":" + output)
             inputs[port.name] = values if port.many else values[0]
+        # Nothing plugged in at all (every input optional, as Plot's are): the box
+        # would run on nothing and fail.  Wait instead, and say what to connect.
+        if spec.inputs and not any(fed[port.name] for port in spec.inputs):
+            labels = [port.label or port.name for port in spec.inputs]
+            result.status = IDLE
+            result.message = "Connect " + (labels[0] if len(labels) == 1 else
+                                           ", ".join(labels[:-1]) + " or " + labels[-1])
+            return result
         # A file not chosen yet (a box just added from the list): wait and say
         # so, rather than run and fail with a traceback about None.
         for setting in spec.settings:
@@ -376,5 +403,5 @@ def run_in_process(spec: BoxSpec, inputs: dict, settings: dict, timeout: float |
     return outcome[1], outcome[2]
 
 
-__all__ = ["BLOCKED", "Cache", "DONE", "FAILED", "IDLE", "RUNNING", "Result", "Run", "Runner",
+__all__ = ["columns_connected", "BLOCKED", "Cache", "DONE", "FAILED", "IDLE", "RUNNING", "Result", "Run", "Runner",
            "WAITING", "run_in_process", "settings_key"]

{openprocess-0.10.5 → openprocess-0.10.6}/openprocess/flow/types.py

@@ -112,6 +112,17 @@ class Table:
             writer.writerows(self.rows)
 
 
+
+class Column(str):
+    """The name of a column of a table connected to the box.
+
+    A setting typed ``Column`` (``x: Column = ""``) is a plain string to the
+    function.  In the app it is a list of the connected table's columns to
+    pick from, once the box before it has run; a name can still be typed.
+    It is a setting, not an input: the table is the input.
+    """
+
+
 @dataclass
 class Figure:
     """A picture: SVG text, or PNG bytes, as a box made it."""
@@ -286,6 +297,7 @@ for _cls, _key, _name, _colour in (
     register_type(_cls, _key, _name, _colour)
 
 __all__ = [
+    "Column",
     "AlignmentResult", "Any", "CPNet", "DFG", "Dataset", "EventLog", "Figure", "Footprint", "OCDFG", "OCEL",
     "Marking", "PetriNet", "Predictions", "Predictor", "ProcessTree", "Regions", "ReplayResult",
     "Scores", "SimpleLog", "Table", "Text", "TransitionSystem", "TypeInfo", "TYPES",

{openprocess-0.10.5 → openprocess-0.10.6}/openprocess/gui/flow/page.py

@@ -36,7 +36,8 @@ from PySide6.QtWidgets import (
 from ...flow import record as records
 from ...flow import reproducibility, snapshots
 from ...flow.library import Library
-from ...flow.runner import BLOCKED, DONE, FAILED, IDLE, RUNNING, WAITING, Cache, Result, Run, Runner
+from ...flow.runner import (BLOCKED, DONE, FAILED, IDLE, RUNNING, WAITING, Cache, Result, Run, Runner,
+                            columns_connected)
 from ...flow.types import EventLog, Figure, PetriNet, Scores, Table
 from ...flow.workflow import Edge, Workflow, group_to_python, to_python
 from .. import theme
@@ -341,7 +342,7 @@ class WorkflowPage(QWidget):
     def refresh_title(self) -> None:
         self.header.set_text(self.workflow.name, self._subtitle())
         status = self._repro
-        self.header.set_badge(status.headline, status.tone,
+        self.header.set_badge(status.short, status.tone,
                               "\n".join([status.headline] + ["· " + d for d in status.details]
                                         + ["", "Click for the record."]),
                               self.show_record)
@@ -879,7 +880,8 @@ class WorkflowPage(QWidget):
             return how_widget(result.explanation, self, result.value)
         if index == 2:
             return code_widget(spec, self)
-        settings = SettingsWidget(spec, node.settings, self.folder)
+        settings = SettingsWidget(spec, node.settings, self.folder,
+                                  columns=columns_connected(self.workflow, self.run, node))
         settings.changed.connect(lambda name, value, nid=node.id: self._setting_changed(nid, name, value))
         return settings
 

{openprocess-0.10.5 → openprocess-0.10.6}/openprocess/gui/flow/viewers.py

@@ -658,9 +658,11 @@ class SettingsWidget(QWidget):
 
     changed = Signal(str, object)
 
-    def __init__(self, spec: BoxSpec, settings: dict, folder: Path | None = None, parent=None) -> None:
+    def __init__(self, spec: BoxSpec, settings: dict, folder: Path | None = None, parent=None,
+                 columns: list[str] | None = None) -> None:
         super().__init__(parent)
         self.spec, self.folder = spec, folder
+        self.columns = list(columns or [])          # of the tables connected to the box, for Column settings
         layout = QVBoxLayout(self)
         layout.setContentsMargins(0, 0, 0, 0)
         layout.setSpacing(10)
@@ -706,6 +708,8 @@ class SettingsWidget(QWidget):
             control.valueChanged.connect(lambda v, s=setting: self.changed.emit(s.name, v))
         elif setting.kind == "path":
             control = self._path_control(setting, value)
+        elif setting.kind == "column":
+            control = self._column_control(setting, value)
         else:
             control = QLineEdit(str(value) if not swept else "")
             control.editingFinished.connect(lambda s=setting, c=control: self.changed.emit(s.name, c.text()))
@@ -757,6 +761,41 @@ class SettingsWidget(QWidget):
         edit.setStyleSheet("")
         self.changed.emit(setting.name, sweep)
 
+    def _column_control(self, setting: Setting, value) -> QComboBox:
+        """A column of a connected table: the table's columns to pick from, once
+        the box before this one has run, or a name typed in.  The first entry
+        is no column at all (Plot without x and y draws bars, not a line)."""
+        control = QComboBox()
+        control.setEditable(True)
+        control.setSizeAdjustPolicy(QComboBox.AdjustToMinimumContentsLengthWithIcon)
+        control.setMinimumContentsLength(12)
+        control.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
+        control.setMaxVisibleItems(14)
+        control.lineEdit().setPlaceholderText(
+            "Pick a column…" if self.columns else "Connect a table and run it; its columns are listed here")
+        control.addItem("—", "")
+        for name in self.columns:
+            control.addItem(name, name)
+        control.setCurrentText("" if value in (None, "") else str(value))
+        last = {"text": control.currentText()}
+
+        def report(text: str, s=setting):
+            if text == last["text"]:                # only a real change: see _path_control
+                return
+            last["text"] = text
+            self.changed.emit(s.name, text)
+
+        def picked(index: int, c=control):
+            text = c.itemData(index) if index >= 0 else c.currentText()
+            text = "" if text is None else str(text)
+            if c.currentText() != text:
+                c.setCurrentText(text)
+            report(text)
+
+        control.currentIndexChanged.connect(picked)
+        control.lineEdit().editingFinished.connect(lambda c=control: report(c.currentText().strip()))
+        return control
+
     def _path_control(self, setting: Setting, value) -> QComboBox:
         """The file field: a list of the folder's files to pick from, or a
         path typed or pasted (quotes and shell escapes are tolerated)."""

{openprocess-0.10.5 → openprocess-0.10.6}/openprocess/gui/learn/answer_boxes.py

@@ -27,7 +27,7 @@ from PySide6.QtWidgets import (
 from ...learn import answers, notation
 from ...learn.checks import CORRECT, INCORRECT, PARTIAL, UNKNOWN
 from ..studio.markdown_view import MarkdownLabel
-from ..studio.widgets import button, hbox, label
+from ..studio.widgets import Chip, button, hbox, label
 
 #: What the card's caption says above each kind of box.
 CAPTIONS = {
@@ -781,7 +781,7 @@ class TaskCard(QFrame):
         if task.points != 1:
             caption += f"  ·  {task.points:g} points"
         self.caption = label(caption.upper(), "taskCaption")
-        self.chip = label("", "statusChip")
+        self.chip = Chip()
         self.chip.setHidden(True)
         layout.addLayout(hbox(self.caption, None, self.chip))
         layout.addWidget(editor)
@@ -852,9 +852,7 @@ class TaskCard(QFrame):
         if shown is not None:
             text, colour = shown
             self.chip.setText(("✓ " if colour == "good" else "") + text)
-            self.chip.setProperty("state", colour)
-            self.chip.style().unpolish(self.chip)
-            self.chip.style().polish(self.chip)
+            self.chip.set_state(colour)
         self.setProperty("state", (shown or ("", ""))[1])
         self.style().unpolish(self)
         self.style().polish(self)

{openprocess-0.10.5 → openprocess-0.10.6}/openprocess/gui/studio/app.py

@@ -883,11 +883,12 @@ class StudioWindow(QMainWindow):
         """*Install…* on a Connections card: pip installs the package into this
         app's Python, in the background; the boxes that need it come alive."""
         import importlib
+        from ... import packages
         from .connections import package_for
         package = package_for(name)
-        command = [sys.executable, "-m", "pip", "install", package]
+        command = packages.install_command(package)
         answer = QMessageBox.question(
-            self, "Install a tool", f"Install {package} into this app's Python?\n\nThis runs:\n"
+            self, "Install a tool", f"Install {package} {packages.where_text()}?\n\nThis runs:\n"
             f"{' '.join(command)}\n\nThe app stays usable meanwhile.",
             QMessageBox.Yes | QMessageBox.Cancel, QMessageBox.Yes)
         if answer != QMessageBox.Yes:
@@ -899,6 +900,7 @@ class StudioWindow(QMainWindow):
         def done(result) -> None:
             code, output = result
             self.connections_page.installing.discard(name)
+            packages.activate()                    # the downloaded app: the new folder, on the path
             importlib.invalidate_caches()
             self.connections_page.refresh(self.library(), self.workspace.folder if self.workspace else None)
             if code == 0:
@@ -1465,7 +1467,9 @@ class StudioWindow(QMainWindow):
         if options:
             self.open_options[document.id] = options
         self._make_page(document)
-        if not keep_unsaved:
+        # A view of a box's result waits for Keep in folder (a model has its own Keep,
+        # which _materialise shows); everything else becomes a file now.
+        if not keep_unsaved and (not self.is_view(document) or isinstance(document, ModelDocument)):
             self._materialise(document, near)
         if document.path:
             key = self._key(document.path)
@@ -1567,6 +1571,12 @@ class StudioWindow(QMainWindow):
             origin = getattr(document, "origin", "") if isinstance(document, CpnDocument) else ""
             text = f"‹ A copy, {origin}" if origin else f"‹ Back to {source.name}"
             page.header.set_back(text, lambda _checked=False, s=source: self.back_to(s))
+            if self.is_view(document) and self.workspace is not None and not hasattr(page, "keep_button"):
+                # A view is not a file of the folder until you say so.
+                page.keep_view_button = button("Keep in folder", lambda _checked=False, d=document: self.keep_view(d),
+                                               kind="primary", tooltip="Save this as a file in the folder; until "
+                                               "then it is only a view of the box's result")
+                page.header.actions.insertWidget(0, page.keep_view_button)
         self.pages[document.id] = page
         # The page sits in a scroll area: if the window is made smaller than
         # the page's minimum size, scroll bars appear instead of the window
@@ -1581,6 +1591,30 @@ class StudioWindow(QMainWindow):
         self.content.addWidget(holder)
         return page
 
+    @staticmethod
+    def is_view(document) -> bool:
+        """A page opened from a box's result (Open as log ›): a view of something
+        the workflow can make again.  Not saved to the folder unless kept, and
+        closed without a question."""
+        return getattr(document, "opened_from", None) is not None and not document.path and \
+            isinstance(document, (LogDocument, TransitionSystemDocument, ModelDocument))
+
+    def keep_view(self, document) -> None:
+        """A view's *Keep in folder*: now it is a file of the folder like any other."""
+        source = getattr(document, "opened_from", None)
+        near = getattr(source, "path", None)
+        self._materialise(document, near)
+        if document.path:
+            page = self.pages.get(document.id)
+            keep = getattr(page, "keep_view_button", None)
+            if keep is not None:
+                keep.setVisible(False)
+            self._remember_identity(document)
+            self._update_autosave(document)
+            self._rebuild_sidebar()
+            self._select_document(document)
+            self.statusBar().showMessage(f"Kept as {Path(document.path).name}", 6000)
+
     def back_to(self, source) -> None:
         """A page's Back link: the analysis it was opened from, if it is still open."""
         if source in self.documents:
@@ -1769,8 +1803,9 @@ class StudioWindow(QMainWindow):
             if isinstance(other, ComparisonDocument) and other not in documents and \
                     any(log.id in removed_logs for log in other.logs):
                 documents.append(other)
-        # A comparison is recreated in a moment, so it needs no confirmation.
-        unsaved = [d for d in documents if not isinstance(d, ComparisonDocument) and
+        # A comparison is recreated in a moment, and a view of a box's result
+        # can be opened again from the box, so neither needs a confirmation.
+        unsaved = [d for d in documents if not isinstance(d, ComparisonDocument) and not self.is_view(d) and
                    (not d.path or d.missing or getattr(d, "dirty", False))]
         if unsaved and confirm:
             names = "\n".join(f"• {d.name}" for d in unsaved[:8])
@@ -4459,6 +4494,8 @@ def main(argv: list[str] | None = None) -> int:
             ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID("OpenProcess.Studio")
         except (AttributeError, OSError):
             pass
+    from ... import packages
+    packages.activate()                           # packages installed from Connections
     application = QApplication.instance() or QApplication(argv)
     application.setApplicationName(APPLICATION_NAME)
     application.setWindowIcon(app_icon())

{openprocess-0.10.5 → openprocess-0.10.6}/openprocess/gui/studio/connections.py

@@ -18,7 +18,7 @@ from PySide6.QtCore import Signal
 from PySide6.QtWidgets import QScrollArea, QVBoxLayout, QWidget
 
 from ...flow.library import Library
-from .widgets import Card, PageHeader, button, flow, hbox, label
+from .widgets import Card, Chip, PageHeader, button, flow, hbox, label
 
 #: (title, what it is, the input boxes' function names)
 INPUTS = [
@@ -50,9 +50,17 @@ def package_for(tool: str) -> str:
 
 
 def can_install() -> bool:
-    """Whether the app can run pip for itself: a Python install with pip, not
-    the downloaded app (whose bundled Python has no pip and is read-only)."""
-    return not getattr(sys, "frozen", False) and find_spec("pip") is not None
+    """Whether Install… can work here (see :mod:`openprocess.packages`: from a
+    Python install pip runs in that Python; the downloaded app carries pip and
+    installs into a folder of the user's own)."""
+    from ... import packages
+    return packages.can_install()
+
+
+def installable(tool: str) -> bool:
+    """Whether Install… works for this tool here (pip, and a package this build can install)."""
+    from ... import packages
+    return can_install() and packages.installable(package_for(tool))
 
 
 def _by_function(library: Library) -> dict[str, object]:
@@ -117,9 +125,7 @@ class ConnectionsPage(QWidget):
             item.setMinimumWidth(200)
             item.setMaximumWidth(300)
             if status:
-                chip = label(status, "statusChip")
-                chip.setStyleSheet(f"background: {_tone(tone)}; color: white;")
-                item.header.addWidget(chip)
+                item.header.addWidget(Chip(status, fill=_tone(tone), ink="white"))
             if boxes:
                 item.add(label("Boxes: " + ", ".join(boxes), "muted", wrap=True))
             self.cards[title] = item
@@ -152,14 +158,19 @@ class ConnectionsPage(QWidget):
                 text, status, tone = "Installed.", "ready", "good"
             elif name in self.installing:
                 text, status, tone = "Installing… (a minute or two; the app stays usable)", "installing", "muted"
+            elif installable(name):
+                from ... import packages
+                text, status, tone = (f"Not installed. Install… puts it {packages.where_text()}; the boxes "
+                                      "that need it come alive without a restart."), "not installed", "warning"
             elif can_install():
-                text, status, tone = f"Not installed. Install… runs {tool['install']} for this app.", \
-                    "not installed", "warning"
+                text, status, tone = (f"Not installed. The downloaded app installs only packages that come "
+                                      f"ready-built, and this one needs building: in a Python install, run "
+                                      f"{tool['install']}."), "not installed", "warning"
             else:
-                text, status, tone = (f"Not installed. The downloaded app cannot install packages: in a "
-                                      f"Python install, run {tool['install']}."), "not installed", "warning"
+                text, status, tone = (f"Not installed, and this build has no pip: in a Python install, run "
+                                      f"{tool['install']}."), "not installed", "warning"
             item = card(name, text, tool["boxes"], status, tone)
-            if not tool["installed"] and can_install() and name not in self.installing:
+            if not tool["installed"] and installable(name) and name not in self.installing:
                 install = button("Install…", lambda _checked=False, n=name: self.install_requested.emit(n),
                                  kind="primary", tooltip=f"Runs {tool['install']} in the background")
                 self.install_buttons[name] = install