openprocess 0.16.1__tar.gz → 0.16.2__tar.gz

{openprocess-0.16.1/openprocess.egg-info → openprocess-0.16.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openprocess
-Version: 0.16.1
+Version: 0.16.2
 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
@@ -742,6 +742,9 @@ course).
 
 ## For developers
 
+Want to report a wrong result, add an algorithm or fix something? See
+[**CONTRIBUTING.md**](CONTRIBUTING.md).
+
 ```bash
 pytest -q                 # the whole suite, including GUI tests that run offscreen
 openprocess --help              # command line: check, simulate, state space, mining
@@ -1089,7 +1092,10 @@ Plainly stated:
    each use its own copy of the page. Subpages used once, at any depth,
    simulate.
 2. **No CPN monitors or simulation reports**, and **no fairness
-   properties** in the state space report (it says so).
+   properties** in the state space report (it says so). **Transition
+   priorities and code segments are kept but not run**: a model that uses
+   them simulates differently from CPN Tools, and the Problems tab and the
+   state space report list where.
 3. **CPN ML is a large subset, not all of Standard ML**: no `exception`
    declarations or `handle`, no `datatype` or `structure` declarations, and
    characters are one-letter strings. See

{openprocess-0.16.1 → openprocess-0.16.2}/README.md

@@ -700,6 +700,9 @@ course).
 
 ## For developers
 
+Want to report a wrong result, add an algorithm or fix something? See
+[**CONTRIBUTING.md**](CONTRIBUTING.md).
+
 ```bash
 pytest -q                 # the whole suite, including GUI tests that run offscreen
 openprocess --help              # command line: check, simulate, state space, mining
@@ -1047,7 +1050,10 @@ Plainly stated:
    each use its own copy of the page. Subpages used once, at any depth,
    simulate.
 2. **No CPN monitors or simulation reports**, and **no fairness
-   properties** in the state space report (it says so).
+   properties** in the state space report (it says so). **Transition
+   priorities and code segments are kept but not run**: a model that uses
+   them simulates differently from CPN Tools, and the Problems tab and the
+   state space report list where.
 3. **CPN ML is a large subset, not all of Standard ML**: no `exception`
    declarations or `handle`, no `datatype` or `structure` declarations, and
    characters are one-letter strings. See

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

{openprocess-0.16.1 → openprocess-0.16.2}/openprocess/analysis/state_space.py

@@ -451,6 +451,13 @@ class StateSpace:
         if self.partial:
             add("  WARNING: the properties below describe only the explored")
             add("           fragment and are not proofs about the whole model.")
+        ignored = getattr(self.net, "warnings", [])
+        if ignored:
+            add(f"  WARNING: {len(ignored)} transition priorities or code segments are not")
+            add("           implemented and were not used: this state space can differ")
+            add("           from the one CPN Tools computes.")
+            for issue in ignored[:max_listed]:
+                add(f"             {issue.element_name or issue.element_id} ({issue.field_name})")
         add("")
 
         add("Boundedness Properties")

{openprocess-0.16.1 → openprocess-0.16.2}/openprocess/flow/boxes/check.py

@@ -48,6 +48,12 @@ def check_fit(model: PetriNet, log: EventLog,
     scores = Scores(model.name, {"fitness": fitness, "precision": precision(model, simple),
                                  "generalisation": generalisation(replay), "simplicity": simplicity(model)})
     scores.note = f"Checked against all {replay.trace_count} cases of {log.name} ({method.lower()})."
+    if replay.unknown_events:
+        missing = ", ".join(f"{a} ({n:,})" for a, n in replay.unknown_totals().most_common(5))
+        text = (f"{replay.unknown_events:,} events are of activities the model does not have: {missing}"
+                f"{', …' if len(replay.unknown_totals()) > 5 else ''}.")
+        flow.note(text + " In token replay each counts one missing and one remaining token.")
+        scores.note += " " + text
     if method == "Alignments" and alignments.incomplete:
         cases = sum(a.count for a in alignments.incomplete)
         scores.note += (f" No optimal alignment was found for {len(alignments.incomplete)} variants "

{openprocess-0.16.1 → openprocess-0.16.2}/openprocess/flow/derivation.py

@@ -94,7 +94,8 @@ def value_markdown(value: Any, limit: int = 50) -> str:
                 + _md_table(["Variant", "Cases", "p", "c", "m", "r"], rows))
     if isinstance(value, AlignmentResult):
         rows = [[f"⟨{', '.join(a.trace)}⟩", a.count, a.cost, f"{a.fitness:.3f}"] for a in value.alignments[:limit]]
-        return (f"Fitness {value.average_fitness:.4f}; {value.fitting_traces:,} of {value.trace_count:,} cases "
+        return (f"Fitness {'' if value.exact else 'at least '}{value.average_fitness:.4f}; "
+                f"{value.fitting_traces:,} of {value.trace_count:,} cases "
                 f"align without a deviation\n\n" + _md_table(["Variant", "Cases", "Cost", "Fitness"], rows))
     if isinstance(value, OCEL):
         return value.summary()

{openprocess-0.16.1 → openprocess-0.16.2}/openprocess/flow/figures.py

@@ -49,7 +49,7 @@ def tile_parts(value) -> tuple[str, str] | None:
     if isinstance(value, ReplayResult):
         return f"{value.fitness:.2f} fitness", f"{value.fitting_traces:,} of {value.trace_count:,} cases fit"
     if isinstance(value, AlignmentResult):
-        return (f"{value.average_fitness:.2f} fitness",
+        return (f"{'' if value.exact else '≥ '}{value.average_fitness:.2f} fitness",
                 f"{value.fitting_traces:,} of {value.trace_count:,} cases align")
     if isinstance(value, Text):
         first = str(value).strip().splitlines()[0] if str(value).strip() else ""

{openprocess-0.16.1 → openprocess-0.16.2}/openprocess/gui/flow/report.py

@@ -293,8 +293,14 @@ class Section(QFrame):
         if result is not None and result.status == DONE:
             parts = key_figure(result.value)
             if parts is not None:
-                tile = StatTile("Key figure", *parts)
-                tile.setMaximumWidth(320)
+                figure, line = parts
+                if len(line) > 72:
+                    line = line[:71].rstrip() + "…"
+                tile = StatTile("Key figure", figure, line)
+                # One line each, the tile as wide as they need: a wrapped line in a
+                # tile of fixed height was drawn over the figure above it.
+                tile.value.setWordWrap(False)
+                tile.sub.setWordWrap(False)
                 self.body_layout.addWidget(tile, 0, Qt.AlignLeft)
         self.body_widget = page.result_view(node, result)
         self.body_layout.addWidget(self.body_widget)

{openprocess-0.16.1 → openprocess-0.16.2}/openprocess/gui/flow/viewers.py

@@ -362,6 +362,10 @@ def result_widget(value, page=None, node=None) -> QWidget:
         add(label(f"Fitness {value.fitness:.4f}: p = {value.produced}, c = {value.consumed}, "
                   f"m = {value.missing}, r = {value.remaining}; {value.fitting_traces} of "
                   f"{value.trace_count} cases fit.", "muted", wrap=True))
+        if value.unknown_events:
+            add(label(f"{value.unknown_events:,} events are of activities the model does not have ("
+                      + ", ".join(f"{a}: {n:,}" for a, n in value.unknown_totals().most_common(8))
+                      + "). Each counts one missing and one remaining token.", "muted", wrap=True))
     elif isinstance(value, AlignmentResult):
         from ..studio.alignment_view import AlignmentList, legend_items, projection
         from ..studio.widgets import Legend, LegendSwatch

{openprocess-0.16.1 → openprocess-0.16.2}/openprocess/gui/learn/answer_boxes.py

@@ -42,9 +42,13 @@ CAPTIONS = {
 }
 
 #: Status of a task -> (chip text, status colour key).
+#: The answer was shown before it was given: right now, but it does not count.
+SHOWN = "shown"
+
 STATUS = {
     CORRECT: ("Correct", "good"), PARTIAL: ("Almost", "warning"),
     INCORRECT: ("Not yet", "critical"), "done": ("Done", "good"),
+    SHOWN: ("Answer shown", "muted"),
 }
 
 
@@ -771,6 +775,9 @@ class TaskCard(QFrame):
         self.status: str | None = None
         #: The share of the block's points the last check gave (for partial answers).
         self.share: float = 0.0
+        #: *Show answer* was pressed before the answer was right: a right answer
+        #: after that is the shown one typed in, so it is not marked Correct.
+        self.revealed: bool = False
         #: In an exam there is no hint, no answer, and Check only says if it is right.
         self.exam = exam
         layout = QVBoxLayout(self)
@@ -838,7 +845,7 @@ class TaskCard(QFrame):
     # -- feedback ------------------------------------------------------------------------
     def _edited(self) -> None:
         # Feedback is about the answer as it was: it goes when you change it.
-        if self.status in (CORRECT, PARTIAL, INCORRECT) or not self.feedback.isHidden():
+        if self.status in (CORRECT, PARTIAL, INCORRECT, SHOWN) or not self.feedback.isHidden():
             self.set_status(None)
             self.feedback.setHidden(True)
             self._clear_detail()
@@ -876,8 +883,12 @@ class TaskCard(QFrame):
         status = result.status
         self.share = float(getattr(result, "share", 0.0) or 0.0)
         icon = {CORRECT: "✓", PARTIAL: "◐", INCORRECT: "✕"}.get(status, "")
-        self.feedback.setText(f"<b>{icon}</b>&nbsp; {escape(result.message)}" if icon
-                              else escape(result.message))
+        message = escape(result.message)
+        if self.revealed and status in (CORRECT, PARTIAL):
+            # Still told whether it is right, but it earns nothing and is not "done".
+            status, self.share = SHOWN, 0.0
+            message += " <i>The answer was shown first, so this does not count.</i>"
+        self.feedback.setText(f"<b>{icon}</b>&nbsp; {message}" if icon else message)
         self.feedback.setProperty("state", STATUS.get(status, ("", ""))[1])
         self._repolish(self.feedback)
         self.feedback.setHidden(False)
@@ -912,8 +923,17 @@ class TaskCard(QFrame):
         self.solution_label.body.set_markdown(text)
         self.solution_label.setHidden(False)
         self.answer_button.setHidden(True)
-        if self.task.type == "open" and self.status != "done":
-            self.assess_row.setHidden(False)
+        if self.task.type == "open":
+            if self.status != "done":
+                self.assess_row.setHidden(False)
+        elif self.status not in (CORRECT, "done") and not self.revealed:
+            # An answer that was already right stays right; anything else was not
+            # answered before the answer was seen.  (An open answer is judged by
+            # yourself against the model answer, so showing it is the point.)
+            self.revealed = True
+            if self.status == PARTIAL:
+                self.set_status(None)
+            self.changed.emit(self.task)
 
     def assess(self, had_it: bool) -> None:
         self.assess_row.setHidden(True)

{openprocess-0.16.1 → openprocess-0.16.2}/openprocess/gui/learn/mode.py

@@ -59,7 +59,7 @@ from ...learn.checks import check as check_answer
 from ...learn.checks import expected, footprint_of, model_answer_text
 from ...learn.exam import ExamState, marks_csv
 from ...learn.pack import Exercise, Pack, load_pack
-from .answer_boxes import TaskCard, debounce, make_editor
+from .answer_boxes import SHOWN, TaskCard, debounce, make_editor
 from .concealment import Concealment
 from ..studio.markdown_view import MarkdownLabel
 from ..studio.widgets import SegmentedControl, button, hbox, label, scroll
@@ -802,7 +802,7 @@ class ExerciseView(QWidget):
             self._workflow_timer = debounce(self, WORKFLOW_SAVE_DELAY, self._save_workflow)
         self._workflow_timer.start()
         card = self.cards.get(task.id)
-        if card is not None and card.status in (CORRECT, PARTIAL, INCORRECT):
+        if card is not None and card.status in (CORRECT, PARTIAL, INCORRECT, SHOWN):
             card.editor.changed.emit()             # the old verdict no longer applies
 
     def _workflow_saved(self, task) -> None:
@@ -839,7 +839,7 @@ class ExerciseView(QWidget):
             self._net_timers[task.id] = timer
         timer.start()
         card = self.cards.get(task.id)
-        if card is not None and card.status in (CORRECT, PARTIAL, INCORRECT):
+        if card is not None and card.status in (CORRECT, PARTIAL, INCORRECT, SHOWN):
             card.editor.changed.emit()             # the old verdict no longer applies
 
     def _save_net(self, page, target: Path) -> None:
@@ -1004,6 +1004,7 @@ class ExerciseView(QWidget):
         saved = self.progress.get(card.task.id, {})
         if card.task.type not in ("net", "workflow") and "answer" in saved:
             card.editor.set_value(saved["answer"])
+        card.revealed = bool(saved.get("shown"))
         status = saved.get("status")
         if status:
             card.set_status(status)
@@ -1018,6 +1019,10 @@ class ExerciseView(QWidget):
             entry["status"] = card.status
         else:
             entry.pop("status", None)
+        if card.revealed:
+            entry["shown"] = True
+        else:
+            entry.pop("shown", None)
         if card.status == PARTIAL and card.share:
             entry["share"] = round(card.share, 4)
         else:

{openprocess-0.16.1 → openprocess-0.16.2}/openprocess/gui/studio/cpn_page.py

@@ -823,7 +823,11 @@ class CpnPage(QWidget):
     def _update_sim_status(self) -> None:
         if not self.simulating:
             problems = len(self.net.errors)
-            self.sim_status.setText("✓ compiles" if not problems else
+            ignored = len(self.net.warnings)
+            self.sim_status.setText((f"⚠ compiles, but {ignored} priorit"
+                                     f"{'y or code segment is' if ignored == 1 else 'ies or code segments are'}"
+                                     " not used — see the Problems tab" if ignored else "✓ compiles")
+                                    if not problems else
                                     f"⚠ {problems} problem{'s' * (problems != 1)} — see "
                                     "the Problems tab")
             return
@@ -909,18 +913,19 @@ class CpnPage(QWidget):
 
     def _fill_problems(self) -> None:
         errors = list(self.net.errors)
-        count = len(errors)
+        warnings = list(self.net.warnings)
+        count = len(errors) + len(warnings)
         self.inspector_tabs.buttons[2].setText(f"Problems ({count})" if count else "Problems")
         card = self.problems_card
         card.clear()
         if not errors:
             card.add(Verdict("Model compiles", "good", "Every declaration and inscription "
                              "parsed. The model is ready to simulate."))
-            return
-        for issue in errors[:200]:
+        for issue in (errors + warnings)[:200]:
             row = QWidget()
             title = f"{issue.element_name or 'Declarations'} — {issue.field_name}"
-            layout = hbox(Verdict(title, "critical", issue.message), spacing=6)
+            layout = hbox(Verdict(title, "critical" if issue in errors else "warning",
+                                  issue.message), spacing=6)
             if issue.element_id:
                 layout.addWidget(button("Show", lambda _=False, i=issue.element_id:
                                         self.reveal_element(i), kind="ghost"), 0, Qt.AlignTop)

{openprocess-0.16.1 → openprocess-0.16.2}/openprocess/gui/studio/instances.py

@@ -237,6 +237,8 @@ def properties(props: PropertyReport, key: str) -> list[str]:
             m = marking(net, graph.states[state])
             return [f"{m0} {firing(net, graph.path_to(state))} {m}",
                     f"\\forall t \\in T \\colon t \\text{{ is not enabled in }} {m}"]
+        if props.deadlock_free is None:
+            return ["\\text{not decided: the state space is unbounded or too large}"]
         return [f"\\forall M \\in {reach} \\; \\exists t \\in T \\colon t "
                 "\\text{ enabled in } M"]
     if key == "dead_transition":

{openprocess-0.16.1 → openprocess-0.16.2}/openprocess/gui/studio/model_page.py

@@ -627,7 +627,9 @@ class ModelPage(ConcealsResults, QWidget):
                                f"log-level {alignments.log_fitness:.3f}")
             tiles["tbr"].set(f"{replay.fitness:.3f}",
                              f"m {replay.missing:,} · r {replay.remaining:,} · "
-                             f"c {replay.consumed:,} · p {replay.produced:,}")
+                             f"c {replay.consumed:,} · p {replay.produced:,}"
+                             + (f" · {replay.unknown_events:,} events not in the model"
+                                if replay.unknown_events else ""))
             tiles["precision"].set(f"{prec:.3f}", "escaping edges (ETC)")
             tiles["generalisation"].set(f"{gen:.3f}", "token-based")
             tiles["simplicity"].set(f"{simp:.3f}", "arc degree")

{openprocess-0.16.1 → openprocess-0.16.2}/openprocess/mcp/api.py

@@ -1020,6 +1020,7 @@ def cpn_info(path: str) -> dict:
     compile problems."""
     net = _cpn(path)
     return {"name": net.name, "problems": [str(e) for e in net.errors],
+            "not_implemented": [str(w) for w in net.warnings],
             "pages": [{"name": p.name, "places": len(p.places), "transitions": len(p.transitions),
                        "arcs": len(p.arcs)} for p in net.pages],
             "colour_sets": {n: type(c).__name__ for n, c in sorted(net.declarations.colour_sets.items())},
@@ -1041,6 +1042,7 @@ def cpn_simulate(path: str, steps: int = 50, seed: int = 0) -> dict:
     return {"steps": taken, "asked": steps, "clock": simulator.clock, "dead": taken < steps,
             "log": [record.describe(net) for record in simulator.log][-200:],
             "final_marking": simulator.marking.describe(net),
+            "not_implemented": [str(w) for w in net.warnings],
             "cite": citations("openprocess.sim"),
             "reproduce": f"openprocess simulate {_q(path)} --steps {steps} --seed {seed}"}
 

{openprocess-0.16.1 → openprocess-0.16.2}/openprocess/mining/analysis.py

@@ -338,8 +338,18 @@ class PropertyReport:
         return self.bounded and self.bound <= 1
 
     @property
-    def deadlock_free(self) -> bool:
-        return not self.dead_markings
+    def deadlock_free(self) -> bool | None:
+        """False with a dead marking in hand (in a coverability graph too: a
+        dead node stands for reachable markings in which nothing is enabled).
+        None when no dead marking was found but the search cannot prove there
+        is none: a coverability graph's ω enables what a finite marking may
+        not, so it can hide a deadlock, and a truncated graph has unexplored
+        markings."""
+        if self.dead_markings:
+            return False
+        if self.graph.has_omega or self.graph.truncated:
+            return None
+        return True
 
     @property
     def terminating(self) -> bool | None:
@@ -375,8 +385,12 @@ class PropertyReport:
                      else "some run can go on forever"
                      + (" (the net is unbounded)" if self.graph.has_omega
                         else ": the reachability graph has a cycle")))
-        rows.append(("Deadlock-free", self.deadlock_free,
-                     "every reachable marking enables something" if self.deadlock_free
+        deadlock_free = self.deadlock_free
+        rows.append(("Deadlock-free", deadlock_free,
+                     "every reachable marking enables something" if deadlock_free
+                     else ("not decided: the net is unbounded, and the coverability graph can "
+                           "hide a deadlock" if self.graph.has_omega
+                           else "not decided (truncated state space)") if deadlock_free is None
                      else f"{len(self.dead_markings)} dead marking(s), e.g. "
                      + self.graph.states[self.dead_markings[0]].describe(net)
                      + " via " + self.graph.describe_path(self.dead_markings[0])))
@@ -672,7 +686,7 @@ class ShortCircuitReport:
         return self.properties.safe
 
     @property
-    def deadlock_free(self) -> bool:
+    def deadlock_free(self) -> bool | None:
         return self.properties.deadlock_free
 
     @property

{openprocess-0.16.1 → openprocess-0.16.2}/openprocess/mining/conformance/alignments.py

@@ -119,6 +119,15 @@ class AlignmentResult:
     empty_trace_cost: int = 0
     #: What the reader should know: searches that were cut short, and why.
     notes: list[str] = field(default_factory=list)
+    #: False when the search for the model's shortest run gave up: the
+    #: empty-trace cost is then unknown (counted as 0), which makes every
+    #: fitness a lower bound.  (Named as a working value so that a result's
+    #: fingerprint is what it was; ``notes`` says so when it is False.)
+    _empty_trace_complete: bool = True
+
+    @property
+    def empty_trace_complete(self) -> bool:
+        return self._empty_trace_complete
 
     @property
     def trace_count(self) -> int:
@@ -129,16 +138,25 @@ class AlignmentResult:
         """The variants whose optimal alignment was not found (state limit)."""
         return [a for a in self.alignments if not a.complete]
 
+    @property
+    def exact(self) -> bool:
+        """Was an optimal alignment found for every variant and for the empty
+        trace?  If not, the fitness values are lower bounds, not the fitness."""
+        return self.empty_trace_complete and not self.incomplete
+
     @property
     def average_fitness(self) -> float:
-        """Mean of the per-trace fitness values (weighted by frequency)."""
+        """Mean of the per-trace fitness values (weighted by frequency).  A
+        variant whose search gave up counts as 0: a lower bound (see :attr:`exact`)."""
         total = self.trace_count
         return sum(a.fitness * a.count for a in self.alignments) / total if total else 1.0
 
     @property
     def log_fitness(self) -> float:
-        """1 − total cost / total worst-case cost."""
-        cost = sum(a.cost * a.count for a in self.alignments)
+        """1 − total cost / total worst-case cost.  A variant whose search gave
+        up counts its worst case, as it counts 0 in :attr:`average_fitness`."""
+        cost = sum((a.cost if a.complete else len(a.trace) + self.empty_trace_cost) * a.count
+                   for a in self.alignments)
         worst = sum((len(a.trace) + self.empty_trace_cost) * a.count for a in self.alignments)
         return 1 - cost / worst if worst else 1.0
 
@@ -307,7 +325,7 @@ def align_log(net: PetriNet, log: SimpleLog, max_states: int = MAX_STATES,
     from .. import parallel
     compiled = _CompiledNet(net)
     empty = align_trace(net, (), 1, max_states, compiled)
-    result = AlignmentResult(net, empty_trace_cost=empty.cost)
+    result = AlignmentResult(net, empty_trace_cost=empty.cost, _empty_trace_complete=empty.complete)
     variants = sorted(log.items(), key=lambda item: (-item[1], item[0]))
     count = parallel.workers() if workers is None else workers
     if parallel.worth_it(variants, count, "align"):
@@ -318,7 +336,9 @@ def align_log(net: PetriNet, log: SimpleLog, max_states: int = MAX_STATES,
         alignment = searched[number - 1] if searched is not None else align_trace(net, trace, count, max_states,
                                                                                    compiled)
         worst = len(trace) + empty.cost
-        alignment.fitness = 1 - alignment.cost / worst if worst else 1.0
+        # max: with the empty-trace cost unknown (counted as 0) the worst case is
+        # too small, and the value must stay a lower bound of the fitness.
+        alignment.fitness = max(0.0, 1 - alignment.cost / worst) if worst else 1.0
         if not alignment.complete:
             alignment.fitness = 0.0
         result.alignments.append(alignment)
@@ -340,7 +360,9 @@ def align_log(net: PetriNet, log: SimpleLog, max_states: int = MAX_STATES,
             f"variants ({cases:,} cases): the search stopped at {max_states:,} states. Their "
             f"cost is unknown and their fitness is counted as 0."
             if result.incomplete else
-            f"The search for the model's shortest run stopped at {max_states:,} states.")
+            f"The search for the model's shortest run stopped at {max_states:,} states, so the "
+            f"worst-case cost every fitness is measured against is too small: each fitness "
+            f"is a lower bound.")
         reason = _unbounded_reason(net)
         if reason:
             result.notes.append(reason)

{openprocess-0.16.1 → openprocess-0.16.2}/openprocess/mining/conformance/token_replay.py

@@ -34,6 +34,19 @@ through silent moves, then the one missing the fewest tokens.  These are
 heuristics -- token replay is fast but not always optimal, which is why
 alignments exist (see :mod:`alignments`).
 
+Activities the model does not have
+----------------------------------
+The book replays logs whose activities all occur in the model.  A real log
+often has more.  Skipping such an event would count it as if it fitted (a
+trace of nothing but unknown activities would score 1), so it is counted as
+what it is, something the log did that the model cannot do: the event is
+replayed as a transition of its own with one input and one output place that
+nothing else touches.  Its input token is missing and its output token
+remains, so each such event adds 1 to each of p, c, m and r.  This is
+OpenProcess's convention, not a published one; ``unknown_events`` on the
+result says how many events it applied to, and the tokens are counted under
+the activity (they belong to no place of the model).
+
 Diagnostics
 -----------
 Per place we keep the total missing and remaining tokens, and per transition
@@ -59,7 +72,9 @@ class TraceReplay:
     consumed: int
     missing: int
     remaining: int
-    #: activities that do not occur in the model at all
+    #: the activity of every event the model has no transition for, in trace
+    #: order; each counts one missing and one remaining token (see the module's
+    #: "Activities the model does not have")
     unknown_activities: list[str] = field(default_factory=list)
     #: indices of events whose transition was not enabled
     problem_events: list[int] = field(default_factory=list)
@@ -120,6 +135,19 @@ class ReplayResult:
     def trace_count(self) -> int:
         return sum(t.count for t in self.traces)
 
+    @property
+    def unknown_events(self) -> int:
+        """Events whose activity the model does not have, frequency-weighted."""
+        return sum(len(t.unknown_activities) * t.count for t in self.traces)
+
+    def unknown_totals(self) -> Counter:
+        """Those events per activity, frequency-weighted."""
+        totals: Counter = Counter()
+        for t in self.traces:
+            for activity in t.unknown_activities:
+                totals[activity] += t.count
+        return totals
+
     def place_totals(self) -> tuple[Counter, Counter]:
         """(missing, remaining) per place, frequency-weighted."""
         missing, remaining = Counter(), Counter()
@@ -368,11 +396,17 @@ def replay_trace(net: PetriNet, trace: tuple[str, ...], count: int = 1,
         result.fired[transition] += 1
         return current - pre + post
 
+    unknown_remaining = 0
     for index, activity in enumerate(trace):
         candidates = by_label.get(activity)
         if not candidates:
+            # No transition for it: one token missing to do it, one left behind.
             result.unknown_activities.append(activity)
             result.problem_events.append(index)
+            result.produced += 1
+            result.consumed += 1
+            result.missing += 1
+            unknown_remaining += 1
             continue
         chosen: str | None = next((t for t in candidates if net.is_enabled(marking, t)), None)
         if chosen is None:
@@ -408,7 +442,7 @@ def replay_trace(net: PetriNet, trace: tuple[str, ...], count: int = 1,
         marking = marking + short
     result.consumed += final.total
     leftover = marking - final
-    result.remaining = leftover.total
+    result.remaining = leftover.total + unknown_remaining
     result.remaining_by_place.update(dict(leftover.items()))
     return result
 

{openprocess-0.16.1 → openprocess-0.16.2}/openprocess/model/net.py

@@ -316,6 +316,10 @@ class CPNet:
         #: declarations.  Recreated by :meth:`compile`.
         self.evaluator = Evaluator(seed=seed)
         self.errors: list[CompileIssue] = []
+        #: What the model says that OpenProcess does not do (a transition's
+        #: priority, its code segment): it still simulates, differently from
+        #: CPN Tools.  Filled by :meth:`compile`.
+        self.warnings: list[CompileIssue] = []
         #: place id -> the id under which its tokens are stored in a Marking.
         #: Identity for ordinary places; the group representative for places in
         #: a fusion set (see :meth:`marking_key`).
@@ -360,6 +364,7 @@ class CPNet:
         empty list means the model is ready to simulate.
         """
         self.errors = []
+        self.warnings = []
         self.evaluator = Evaluator(seed=self.seed)
         self._build_fusion_map()
 
@@ -396,6 +401,20 @@ class CPNet:
                     transition.guard_ast = parse_guard(guard)
                 except CPNMLError as error:
                     self._record(transition.id, transition.name, "guard", str(error))
+            priority = transition.priority_text.strip()
+            if priority and priority != "P_NORMAL":
+                self.warnings.append(CompileIssue(
+                    transition.id, transition.name, "priority",
+                    f"the priority {priority} is not used: priorities are not implemented, so "
+                    "this transition can fire whenever it is enabled, also when CPN Tools "
+                    "would let another one go first. Simulation and the state space can "
+                    "differ from CPN Tools."))
+            if transition.code_text.strip():
+                self.warnings.append(CompileIssue(
+                    transition.id, transition.name, "code segment",
+                    "the code segment is not run: code segments are not implemented, so its "
+                    "action does not happen and the variables it would set stay unbound or "
+                    "are bound freely. Simulation and the state space can differ from CPN Tools."))
             delay = transition.time_text.strip().lstrip("@+").strip()
             if delay:
                 try:

{openprocess-0.16.1 → openprocess-0.16.2/openprocess.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openprocess
-Version: 0.16.1
+Version: 0.16.2
 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
@@ -742,6 +742,9 @@ course).
 
 ## For developers
 
+Want to report a wrong result, add an algorithm or fix something? See
+[**CONTRIBUTING.md**](CONTRIBUTING.md).
+
 ```bash
 pytest -q                 # the whole suite, including GUI tests that run offscreen
 openprocess --help              # command line: check, simulate, state space, mining
@@ -1089,7 +1092,10 @@ Plainly stated:
    each use its own copy of the page. Subpages used once, at any depth,
    simulate.
 2. **No CPN monitors or simulation reports**, and **no fairness
-   properties** in the state space report (it says so).
+   properties** in the state space report (it says so). **Transition
+   priorities and code segments are kept but not run**: a model that uses
+   them simulates differently from CPN Tools, and the Problems tab and the
+   state space report list where.
 3. **CPN ML is a large subset, not all of Standard ML**: no `exception`
    declarations or `handle`, no `datatype` or `structure` declarations, and
    characters are one-letter strings. See