openprocess 0.12.0__tar.gz → 0.12.1__tar.gz

{openprocess-0.12.0/openprocess.egg-info → openprocess-0.12.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openprocess
-Version: 0.12.0
+Version: 0.12.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
@@ -873,7 +873,11 @@ extra) and *Predict the next activity*. Or start empty.
   and cleared an invoice?) and *Compliance by attribute* (per vendor: cases,
   share that fits, value), with *Case attribute* to keep one category and
   *Bubble chart* to draw it. [examples/bpi2019](examples/bpi2019/README.md)
-  uses them on the BPI Challenge 2019.
+  uses them on the BPI Challenge 2019. *Dotted chart* saves a dotted chart
+  as a figure (the same dots as the log page's tab), and *Who does what*
+  counts each activity per resource;
+  [examples/energy_contracts](examples/energy_contracts/README.md) uses them
+  with the course's miners and checks on the 2AMI10 exam log.
 - **Connections** (at the bottom of the sidebar, or *View ▸ Connections*)
   draws what flows in, OpenProcess and its boxes, what flows out, and the
   optional tools (pandas, numpy, scipy, matplotlib, …) with whether each is

{openprocess-0.12.0 → openprocess-0.12.1}/README.md

@@ -834,7 +834,11 @@ extra) and *Predict the next activity*. Or start empty.
   and cleared an invoice?) and *Compliance by attribute* (per vendor: cases,
   share that fits, value), with *Case attribute* to keep one category and
   *Bubble chart* to draw it. [examples/bpi2019](examples/bpi2019/README.md)
-  uses them on the BPI Challenge 2019.
+  uses them on the BPI Challenge 2019. *Dotted chart* saves a dotted chart
+  as a figure (the same dots as the log page's tab), and *Who does what*
+  counts each activity per resource;
+  [examples/energy_contracts](examples/energy_contracts/README.md) uses them
+  with the course's miners and checks on the 2AMI10 exam log.
 - **Connections** (at the bottom of the sidebar, or *View ▸ Connections*)
   draws what flows in, OpenProcess and its boxes, what flows out, and the
   optional tools (pandas, numpy, scipy, matplotlib, …) with whether each is

{openprocess-0.12.0 → openprocess-0.12.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.12.0"
+__version__ = "0.12.1"
 
 __all__ = [
     "Arc", "BindingElement", "CPNet", "Marking", "Multiset", "Page", "Place",

{openprocess-0.12.0 → openprocess-0.12.1}/openprocess/flow/boxes/measure.py

@@ -5,7 +5,9 @@ the goods receipt?  Did one user record an invoice and also clear it?  How
 compliant is each vendor, and with how much money?  Each box answers one such
 question for every case, in a table (and, where it helps, the cases
 themselves, to analyse further), and works on a large log without building
-its events (:func:`openprocess.mining.cases.cases`).  The BPI Challenge 2019
+its events (:func:`openprocess.mining.cases.cases`).  The dotted chart and
+*Who does what* are the first look at a log: when things happen, and who
+does them.  The BPI Challenge 2019
 analysis in ``examples/bpi2019`` is built from them.
 """
 
@@ -18,10 +20,11 @@ from typing import Literal
 
 from ... import flow
 from ...mining.cases import case_value, cases
+from ...mining.dotted import SORT_MODES, X_MODES, DotSettings, Dots, svg
 from ...mining.log import EventLog
 from ...mining.petrinet import PetriNet
 from ..box import box
-from ..types import Table
+from ..types import Figure, Table
 
 UNITS = {"hours": 3600.0, "days": 86400.0}
 
@@ -192,4 +195,71 @@ def compliance_by(model: PetriNet, log: EventLog, attribute: str = "Vendor",
     return Table(f"Compliance by {attribute}", columns, rows)
 
 
-__all__ = ["RuleResult", "compliance_by", "order_rule", "segregation_of_duties", "time_between"]
+@box(name="Dotted chart", group="Measure")
+def dotted_chart(log: EventLog,
+                 x: Literal["Actual time", "Time since case start", "Relative to case duration (%)",
+                            "Logical: order in log", "Logical: position in case"] = "Actual time",
+                 rows: str = "Case", colour: str = "Activity",
+                 sort: Literal["First event", "Last event", "Duration", "Number of events", "Name"] = "First event",
+                 unit: Literal["Auto", "Seconds", "Minutes", "Hours", "Days", "Weeks"] = "Auto") -> Figure:
+    """Every event as a dot (Song & van der Aalst, 2007): *x* says when, the
+    row what it belongs to, the colour one more attribute; the same dots as
+    the dotted chart in Mine, saved as a figure. Patterns to look for: the
+    arrival rate (the slope of the first dots), batches (vertical lines),
+    waiting (long gaps in a row), and in Time since case start, how long
+    each step takes after the case begins.
+
+    x: when: actual time, time since the case started, the share of the case's duration, or a logical position
+    rows: Case, Activity, Resource, Lifecycle or any event attribute
+    colour: Activity, Resource, Lifecycle, Case, None or any event attribute
+    sort: the order of the rows
+    unit: the time unit of the x axis (Auto: dates and durations)
+    """
+    settings = DotSettings(x_mode=X_MODES.index(x), rows=rows, colour_by=colour, sort=SORT_MODES.index(sort))
+    dots = Dots(log, log.default_classifier(), settings)
+    if not len(dots):
+        raise ValueError(f"{log.name} has no events to draw")
+    if dots.mode != settings.x_mode:
+        flow.note(f"The log has no timestamps, so x is {X_MODES[dots.mode].lower()}")
+    flow.note(f"{len(dots):,} events in {len(dots.row_values):,} rows ({rows}), "
+              f"{len(dots.colour_values):,} colours ({colour})")
+    if dots.mode == 0 and dots.origin is not None:
+        from datetime import timedelta
+        flow.note(f"From {dots.origin:%d %b %Y %H:%M} to "
+                  f"{dots.origin + timedelta(seconds=dots.x_max - dots.x_min):%d %b %Y %H:%M}")
+    title = f"{log.name}: {rows.lower()} by {X_MODES[dots.mode].lower()}, colour by {colour.lower()}"
+    return Figure("Dotted chart", svg=svg(dots, title, unit),
+                  caption=f"Dotted chart: rows {rows}, x {X_MODES[dots.mode]}, colour {colour}, "
+                          f"sorted by {sort.lower()}.")
+
+
+@box(name="Who does what", group="Measure")
+def who_does_what(log: EventLog, by: str = "org:resource") -> Table:
+    """How often each activity is done by each value of the event attribute
+    *by* (each resource, say): one row per activity, one column per value,
+    most frequent first. It shows the roles in a process: who only does one
+    step, who does several, and which steps nobody else does.
+
+    by: the event attribute to count by (org:resource, or any other)
+    """
+    counts: dict[str, Counter] = {}
+    totals: Counter = Counter()
+    for case in cases(log, (by,)):
+        for activity, value in zip(case.activities, case.columns[by]):
+            name = "–" if value is None else str(value)
+            counts.setdefault(activity, Counter())[name] += 1
+            totals[name] += 1
+    if not totals or set(totals) == {"–"}:
+        raise ValueError(f"No event of {log.name} has the attribute {by!r}")
+    values = [v for v, _ in totals.most_common()]
+    activities = sorted(counts, key=lambda a: -sum(counts[a].values()))
+    rows = [[a, *[counts[a][v] for v in values], sum(counts[a].values())] for a in activities]
+    for value in values:
+        done = [a for a in activities if counts[a][value]]
+        if len(done) == 1:
+            flow.note(f"{value} only does {done[0]}")
+    return Table(f"Who does what ({by})", ["activity", *values, "events"], rows)
+
+
+__all__ = ["RuleResult", "compliance_by", "dotted_chart", "order_rule", "segregation_of_duties",
+           "time_between", "who_does_what"]

{openprocess-0.12.0 → openprocess-0.12.1}/openprocess/gui/studio/app.py

@@ -101,6 +101,7 @@ from .workspace import (
     exercise_files, file_kind, file_stem, file_suffix,
     made_by_openprocess, safe_file_name, unique_path,
 )
+from .loading import Loading, LoadingPage
 from .workers import run_in_background
 
 APPLICATION_NAME = "OpenProcess Studio"
@@ -181,6 +182,17 @@ def _same_file(a: Path, b: Path) -> bool:
         return False
 
 
+#: How long a read may take before the loading page shows (a small file never flashes it).
+LOADING_DELAY_MS = 350
+
+
+def _file_size(path: str) -> int:
+    try:
+        return Path(path).stat().st_size
+    except OSError:
+        return 0
+
+
 def _signature(path: str | Path) -> tuple[int, int] | None:
     """(modification time, size) of a file, or None when it is not there."""
     try:
@@ -581,6 +593,12 @@ class StudioWindow(QMainWindow):
         self.connections_page = ConnectionsPage()
         self.connections_page.install_requested.connect(self.install_tool)
         self.content.addWidget(self.connections_page)
+        #: What the main area shows while a file you opened is read (see _start_loading).
+        self.loading_page = LoadingPage()
+        self.loading_page.cancel_requested.connect(self._cancel_loading)
+        self.content.addWidget(self.loading_page)
+        self._loads: dict[str, Loading] = {}
+        self._before_loading = None
         # Above the pages: "a new version is out" (see check_automatically).
         from .updates import UpdateBar
         self.update_bar = UpdateBar()
@@ -1572,8 +1590,7 @@ class StudioWindow(QMainWindow):
             page = ComparePage(document)
             page.tabs.changed.connect(lambda i: self.remembered.__setitem__("compare_tab", i))
         elif isinstance(document, WorkflowDocument):
-            page = WorkflowPage(document, self.library(),
-                                self.workspace.folder if self.workspace is not None else None)
+            page = WorkflowPage(document, self.library(), self._workflow_folder(document))
             page.open_document.connect(lambda doc, source=document: self.add_document(doc, near=source.path))
             page.edit_requested.connect(lambda net, origin, doc=document: self.edit_petri_net(net, origin, doc))
             page.keep_requested.connect(lambda doc=document: self.keep_workflow(doc))
@@ -2527,14 +2544,24 @@ class StudioWindow(QMainWindow):
                         self._rebuild_sidebar()
                         return
                     mapping = dialog.mapping()
-                log = read_csv(path, mapping)
-                self.add_document(LogDocument(log, path=path),
-                                  options={"csv_mapping": asdict(mapping)})
+                self._start_loading(path, "Reading the event log")
+                folder = self._folder_switches
+
+                def csv_loaded(log, mapping=mapping) -> None:
+                    self._finish_loading(path)
+                    if folder != self._folder_switches:
+                        self._opening.discard(self._key(path))
+                        return
+                    self.add_document(LogDocument(log, path=path), options={"csv_mapping": asdict(mapping)})
+
+                run_in_background(lambda: read_csv(path, mapping), csv_loaded,
+                                  lambda message: self._load_failed(path, message, size))
             elif lower.endswith((".xes", ".xes.gz", ".gz")):
-                self.statusBar().showMessage(f"Reading {name}…")
+                loading = self._start_loading(path, "Reading the event log")
                 folder = self._folder_switches
 
                 def loaded(log) -> None:
+                    self._finish_loading(path)
                     if folder != self._folder_switches:
                         # The folder was switched or closed while this was
                         # loading: it belongs to the folder that was left.
@@ -2543,8 +2570,8 @@ class StudioWindow(QMainWindow):
                     self.add_document(LogDocument(log, path=path))
                     self.statusBar().showMessage(f"Opened {name}: {len(log):,} cases", 6000)
 
-                run_in_background(lambda: read_xes(path), loaded,
-                                  lambda message: self._could_not_open(path, message, size))
+                run_in_background(lambda: read_xes(path, progress=loading.report), loaded,
+                                  lambda message: self._load_failed(path, message, size))
             else:
                 QMessageBox.information(self, "Unsupported file",
                                         f"{name}: open .xes, .csv, .pnml or .cpn files (or a "
@@ -2554,6 +2581,61 @@ class StudioWindow(QMainWindow):
         except Exception as error:  # noqa: BLE001 - surface any import problem
             self._could_not_open(path, str(error), size)
 
+    # -- reading a large file: the loading page --------------------------------------------------
+    def _start_loading(self, path: str, title: str) -> Loading:
+        """Start reading ``path`` on a worker.  For a file the user opened (not
+        one reopened with its folder), the main area shows the loading page
+        if the read takes more than a moment, so a large log never leaves the
+        window looking stuck; the window keeps working meanwhile."""
+        key = self._key(path)
+        loading = Loading(path, title, size=_file_size(path))
+        self._loads[key] = loading
+        self.statusBar().showMessage(f"Reading {Path(path).name}…")
+        if key not in self._restore_paths:
+            origin = self.content.currentWidget()
+            QTimer.singleShot(LOADING_DELAY_MS, lambda: self._show_loading(key, origin))
+        return loading
+
+    def _show_loading(self, key: str, origin) -> None:
+        loading = self._loads.get(key)
+        if loading is None or self.in_learn:
+            return                                       # done already, or Learn has the window
+        if self.content.currentWidget() not in (origin, self.loading_page):
+            return                                       # you went to another page meanwhile: stay there
+        if self.content.currentWidget() is not self.loading_page:
+            self._before_loading = self.content.currentWidget()
+        self.loading_page.show_loading(loading)
+        self.content.setCurrentWidget(self.loading_page)
+
+    def _finish_loading(self, path: str) -> None:
+        """The read ended (done, failed or stopped): leave the loading page if it shows this file."""
+        loading = self._loads.pop(self._key(path), None)
+        if loading is None or self.loading_page.loading is not loading:
+            return
+        self.loading_page.stop()
+        self.loading_page.loading = None
+        waiting = next(iter(self._loads.values()), None)
+        if waiting is not None and self.content.currentWidget() is self.loading_page:
+            self.loading_page.show_loading(waiting)       # another file you opened is still coming
+        elif self.content.currentWidget() is self.loading_page:
+            back = self._before_loading
+            self.content.setCurrentWidget(back if back is not None and self.content.indexOf(back) >= 0
+                                          else self.content.widget(0))
+
+    def _cancel_loading(self, path: str) -> None:
+        self.statusBar().showMessage(f"Stopping {Path(path).name}…")
+
+    def _load_failed(self, path: str, message: str, before: tuple | None) -> None:
+        loading = self._loads.get(self._key(path))
+        cancelled = loading is not None and loading.cancelled
+        self._finish_loading(path)
+        if cancelled:
+            self._opening.discard(self._key(path))
+            self._rebuild_sidebar()
+            self.statusBar().showMessage(f"Stopped reading {Path(path).name}", 6000)
+            return
+        self._could_not_open(path, message, before)
+
     def _could_not_open(self, path: str, message: str, before: tuple | None) -> None:
         self._opening.discard(self._key(path))
         self._rebuild_sidebar()
@@ -2762,6 +2844,18 @@ class StudioWindow(QMainWindow):
         self.statusBar().showMessage(f"{document.name} against {Path(path).name}: click Check fit for the "
                                      "scores and how they were computed", 10000)
 
+    def _workflow_folder(self, document) -> str | None:
+        """The folder a workflow's files are relative to: the open folder, or
+        the workflow file's own folder when it was opened from somewhere else
+        (an example double-clicked, a file from a download), as
+        ``openprocess run`` reads it."""
+        folder = self.workspace.folder if self.workspace is not None else None
+        if document.path:
+            own = Path(document.path).resolve().parent
+            if folder is None or not own.is_relative_to(Path(folder).resolve()):
+                return str(own)
+        return folder
+
     def library(self):
         """The boxes available in this window (the folder's boxes/ included)."""
         from ...flow.library import library_for