openprocess 0.10.6__tar.gz → 0.11.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openprocess
-Version: 0.10.6
+Version: 0.11.3
 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
@@ -281,8 +281,9 @@ which space you were in.
   state; it stays in the folder.
 - **Flat lists, the same in both spaces.** The folder's own files first,
   then each subfolder's under a caption naming it ("Week 5 / Part 1").
-  Nothing to unfold except LOGS. An empty folder shows in both spaces until
-  it has files.
+  Click a caption to fold its files away or bring them back; the app
+  remembers which are folded, per folder. An empty folder shows in both
+  spaces until it has files.
 - **Organise from the app**: right-click for **New Folder…**, **Rename…**,
   **Show in Finder** and **Move to Bin** (recoverable from the Bin; never a
   hard delete). **Drag files onto a subfolder** to move them on disk. An open
@@ -373,7 +374,9 @@ Nets drawn as in the lectures and the book:
 - **Places** are circles with black tokens inside, drawn as dots up to 5 and
   as a number above that.
 - **Transitions** are boxes with their name inside. A **silent (τ)**
-  transition is a black bar.
+  transition is a black bar: the **τ** tool (toolbar or palette) adds one
+  with a click, and the Element tab's *Silent* box turns an ordinary
+  transition into τ and back.
 - **Arc weights** above 1 are written on the arc.
 - **Names** go inside the places and transitions, which grow to fit them.
   Tick **Names outside** in the toolbar to put them underneath instead; you
@@ -528,17 +531,19 @@ links to the definitions it builds on; **Help ▸ Definitions** lists them all.
   for bounded nets; for unbounded ones, up to a trace length (and it says
   so).
 
-| Process map | Discovering a model |
+| Process map | Discover in Mine →: the miner is a box, its result beside the canvas |
 |---|---|
 | ![Process map](docs/screenshots/studio-process-map.png) | ![Discover](docs/screenshots/studio-discover.png) |
 
-| α-algorithm result | Conformance (alignments on the model) |
+| α-algorithm result | *How*: the eight steps, from the footprint to α(L) |
 |---|---|
-| ![Alpha](docs/screenshots/studio-alpha.png) | ![Conformance](docs/screenshots/studio-conformance.png) |
+| ![Alpha](docs/screenshots/studio-alpha.png) | ![The eight steps of the α-algorithm](docs/screenshots/studio-alpha-how.png) |
 
-| Comparing two logs | Linked dotted charts of three boarding strategies |
+| Check fit: every score, and how it was computed | Comparing two logs |
 |---|---|
-| ![Comparing two logs](docs/screenshots/compare.png) | ![Linked dotted charts](docs/screenshots/compare-dotted.png) |
+| ![Conformance](docs/screenshots/studio-conformance.png) | ![Comparing two logs](docs/screenshots/compare.png) |
+
+![Linked dotted charts of two logs, one scale and one colour per activity](docs/screenshots/compare-dotted.png)
 
 The app follows the system's light or dark appearance:
 
@@ -555,6 +560,8 @@ sidebar, **Learn ▸ Open Exercise Pack…**, or **Learn ▸ Open Demo Exercises
 exercises): the window switches to a view made for working through a pack
 without distractions, and *Exit* brings your folder back exactly as it was.
 
+![An exercise in Learn: the worksheet with its answer boxes on the left, the exercise's log, given net and workflow on the right](docs/screenshots/learn-exercise.png)
+
 - **The worksheet** on the left is the question top to bottom, with an
   answer box wherever one is needed: yes/no, multiple choice, a set
   (`{a, b}`, sets of sets, or pairs like `({a}, {b,d})`), a number, a short
@@ -742,7 +749,10 @@ generated from `openprocess/mining/definitions.py`; after editing a definition,
 Likewise [`docs/references.md`](docs/references.md) — every source OpenProcess's
 notation and algorithms follow, also in the app under **Help ▸ References** —
 is generated from `openprocess/references.py` with
-`python -m openprocess.references > docs/references.md`.
+`python -m openprocess.references > docs/references.md`. The screenshots in
+this README come from the app itself: `python docs/make_screenshots.py`
+renders every page offscreen into `docs/screenshots/`, so run it after a
+change to the app's looks.
 
 The engines (`openprocess.mining`, `openprocess.ml`, `openprocess.sim`, `openprocess.analysis`)
 have **no dependencies**, so they work in a notebook or a script:
@@ -758,7 +768,10 @@ print(report.sound, report.findings)
 
 [**docs/how-it-works.md**](docs/how-it-works.md) covers the architecture, the
 CPN ML subset, binding search, timed nets, the state space, the file format
-and the project layout.
+and the project layout. [**docs/design.md**](docs/design.md) is the *why*:
+the problem, the claim, the three ideas and the decisions that follow from
+them. `tests/cross_check_inductive_miner.py` compares the built-in Inductive
+Miner with PM4Py's on hundreds of logs and reports where they differ.
 
 ## Workflows
 
@@ -769,17 +782,20 @@ Miner, a fitness check), *Compare discovery* (three miners side by side),
 confidence* (bootstrap intervals, a test and a plot; needs the `science`
 extra) and *Predict the next activity*. Or start empty.
 
+| The canvas: *Compare discovery*, three miners side by side | Summary: every box's key figure, and the process map |
+|---|---|
+| ![The canvas of a Compare discovery analysis, the Compare box's table beside it](docs/screenshots/workflow-canvas.png) | ![The Summary view: a tile per box, the process map under them](docs/screenshots/workflow-summary.png) |
+
 - **The page is the canvas.** Its header has **Canvas | Summary**, then
   **+ Add box**, **Run ▶**, and **⋯** for Re-run, Record, Export experiment
   and Save. The sidebar beside it lists the folder's analyses and, folded
   under them, its logs.
-- **+ Add box** (or a double-click on the canvas) opens every box, by group:
-  the six core groups side by side (Input, Filter, Discover, Check, Compare,
-  Output) and one line for the rest (Science, Predict, Coloured nets, Sweep,
-  your own boxes) with *Show all*. Under *Input*, **the folder's own files**:
-  one click adds the box that reads the file, already set. Type to search
-  them all: "alpha" finds the α-algorithm, "boarding" the log; Enter adds the
-  first match.
+- **+ Add box** (or a double-click on the canvas) opens every box, one
+  section per group (Input, Filter, Discover, Check, Compare, Output, then
+  Science, Predict, Coloured nets, Sweep and your own boxes), in a list that
+  scrolls. Under *Input*, **the folder's own files**: one click adds the box
+  that reads the file, already set. Type to search them all: "alpha" finds
+  the α-algorithm, "boarding" the log; Enter adds the first match.
 - **Files flow into the canvas.** Drop a log, an OCEL 2.0 object-centric log
   (`.jsonocel`), a PNML file, a .cpn or a ts.txt on the canvas and it becomes
   its input box at that spot; an input
@@ -825,8 +841,18 @@ extra) and *Predict the next activity*. Or start empty.
   `boxes/`, so it is listed under *Yours* and can be used in any workflow.
 - **Export experiment** (under ⋯) writes a zip with the workflow file and its record,
   the inputs, your boxes, every result as a file (CSV, PNML, SVG, XES), a
-  `requirements.lock` and a README that says what was run: supplementary
-  material for a paper, which `openprocess run --check` can verify.
+  `requirements.lock`, a `run.py` that runs the same analysis as a plain
+  script, and a README that says what was run: supplementary material for a
+  paper, which `openprocess run --check` can verify. Drop such a zip on
+  OpenProcess and it is unpacked into a folder of its own and run again.
+- **Export as Python script** (under ⋯) writes the analysis as a `.py` file:
+  the same boxes, settings and connections, run with `python analysis.py`,
+  the results written beside it.
+- **Every result knows where it came from**: a figure saved as SVG carries
+  the analysis, the box, its settings and the result's fingerprint in its
+  metadata; a CSV gets a `.provenance.json` beside it.
+- **⌘Z and ⇧⌘Z** undo and redo on the canvas: boxes, connections, moves,
+  settings, groups.
 - **The side panel** resizes by dragging the gap beside it; double-click the
   gap, or *View ▸ Reset Workflow Layout*, for its default width.
 - **Connections** (at the bottom of the sidebar, or *View ▸ Connections*)

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

@@ -242,8 +242,9 @@ which space you were in.
   state; it stays in the folder.
 - **Flat lists, the same in both spaces.** The folder's own files first,
   then each subfolder's under a caption naming it ("Week 5 / Part 1").
-  Nothing to unfold except LOGS. An empty folder shows in both spaces until
-  it has files.
+  Click a caption to fold its files away or bring them back; the app
+  remembers which are folded, per folder. An empty folder shows in both
+  spaces until it has files.
 - **Organise from the app**: right-click for **New Folder…**, **Rename…**,
   **Show in Finder** and **Move to Bin** (recoverable from the Bin; never a
   hard delete). **Drag files onto a subfolder** to move them on disk. An open
@@ -334,7 +335,9 @@ Nets drawn as in the lectures and the book:
 - **Places** are circles with black tokens inside, drawn as dots up to 5 and
   as a number above that.
 - **Transitions** are boxes with their name inside. A **silent (τ)**
-  transition is a black bar.
+  transition is a black bar: the **τ** tool (toolbar or palette) adds one
+  with a click, and the Element tab's *Silent* box turns an ordinary
+  transition into τ and back.
 - **Arc weights** above 1 are written on the arc.
 - **Names** go inside the places and transitions, which grow to fit them.
   Tick **Names outside** in the toolbar to put them underneath instead; you
@@ -489,17 +492,19 @@ links to the definitions it builds on; **Help ▸ Definitions** lists them all.
   for bounded nets; for unbounded ones, up to a trace length (and it says
   so).
 
-| Process map | Discovering a model |
+| Process map | Discover in Mine →: the miner is a box, its result beside the canvas |
 |---|---|
 | ![Process map](docs/screenshots/studio-process-map.png) | ![Discover](docs/screenshots/studio-discover.png) |
 
-| α-algorithm result | Conformance (alignments on the model) |
+| α-algorithm result | *How*: the eight steps, from the footprint to α(L) |
 |---|---|
-| ![Alpha](docs/screenshots/studio-alpha.png) | ![Conformance](docs/screenshots/studio-conformance.png) |
+| ![Alpha](docs/screenshots/studio-alpha.png) | ![The eight steps of the α-algorithm](docs/screenshots/studio-alpha-how.png) |
 
-| Comparing two logs | Linked dotted charts of three boarding strategies |
+| Check fit: every score, and how it was computed | Comparing two logs |
 |---|---|
-| ![Comparing two logs](docs/screenshots/compare.png) | ![Linked dotted charts](docs/screenshots/compare-dotted.png) |
+| ![Conformance](docs/screenshots/studio-conformance.png) | ![Comparing two logs](docs/screenshots/compare.png) |
+
+![Linked dotted charts of two logs, one scale and one colour per activity](docs/screenshots/compare-dotted.png)
 
 The app follows the system's light or dark appearance:
 
@@ -516,6 +521,8 @@ sidebar, **Learn ▸ Open Exercise Pack…**, or **Learn ▸ Open Demo Exercises
 exercises): the window switches to a view made for working through a pack
 without distractions, and *Exit* brings your folder back exactly as it was.
 
+![An exercise in Learn: the worksheet with its answer boxes on the left, the exercise's log, given net and workflow on the right](docs/screenshots/learn-exercise.png)
+
 - **The worksheet** on the left is the question top to bottom, with an
   answer box wherever one is needed: yes/no, multiple choice, a set
   (`{a, b}`, sets of sets, or pairs like `({a}, {b,d})`), a number, a short
@@ -703,7 +710,10 @@ generated from `openprocess/mining/definitions.py`; after editing a definition,
 Likewise [`docs/references.md`](docs/references.md) — every source OpenProcess's
 notation and algorithms follow, also in the app under **Help ▸ References** —
 is generated from `openprocess/references.py` with
-`python -m openprocess.references > docs/references.md`.
+`python -m openprocess.references > docs/references.md`. The screenshots in
+this README come from the app itself: `python docs/make_screenshots.py`
+renders every page offscreen into `docs/screenshots/`, so run it after a
+change to the app's looks.
 
 The engines (`openprocess.mining`, `openprocess.ml`, `openprocess.sim`, `openprocess.analysis`)
 have **no dependencies**, so they work in a notebook or a script:
@@ -719,7 +729,10 @@ print(report.sound, report.findings)
 
 [**docs/how-it-works.md**](docs/how-it-works.md) covers the architecture, the
 CPN ML subset, binding search, timed nets, the state space, the file format
-and the project layout.
+and the project layout. [**docs/design.md**](docs/design.md) is the *why*:
+the problem, the claim, the three ideas and the decisions that follow from
+them. `tests/cross_check_inductive_miner.py` compares the built-in Inductive
+Miner with PM4Py's on hundreds of logs and reports where they differ.
 
 ## Workflows
 
@@ -730,17 +743,20 @@ Miner, a fitness check), *Compare discovery* (three miners side by side),
 confidence* (bootstrap intervals, a test and a plot; needs the `science`
 extra) and *Predict the next activity*. Or start empty.
 
+| The canvas: *Compare discovery*, three miners side by side | Summary: every box's key figure, and the process map |
+|---|---|
+| ![The canvas of a Compare discovery analysis, the Compare box's table beside it](docs/screenshots/workflow-canvas.png) | ![The Summary view: a tile per box, the process map under them](docs/screenshots/workflow-summary.png) |
+
 - **The page is the canvas.** Its header has **Canvas | Summary**, then
   **+ Add box**, **Run ▶**, and **⋯** for Re-run, Record, Export experiment
   and Save. The sidebar beside it lists the folder's analyses and, folded
   under them, its logs.
-- **+ Add box** (or a double-click on the canvas) opens every box, by group:
-  the six core groups side by side (Input, Filter, Discover, Check, Compare,
-  Output) and one line for the rest (Science, Predict, Coloured nets, Sweep,
-  your own boxes) with *Show all*. Under *Input*, **the folder's own files**:
-  one click adds the box that reads the file, already set. Type to search
-  them all: "alpha" finds the α-algorithm, "boarding" the log; Enter adds the
-  first match.
+- **+ Add box** (or a double-click on the canvas) opens every box, one
+  section per group (Input, Filter, Discover, Check, Compare, Output, then
+  Science, Predict, Coloured nets, Sweep and your own boxes), in a list that
+  scrolls. Under *Input*, **the folder's own files**: one click adds the box
+  that reads the file, already set. Type to search them all: "alpha" finds
+  the α-algorithm, "boarding" the log; Enter adds the first match.
 - **Files flow into the canvas.** Drop a log, an OCEL 2.0 object-centric log
   (`.jsonocel`), a PNML file, a .cpn or a ts.txt on the canvas and it becomes
   its input box at that spot; an input
@@ -786,8 +802,18 @@ extra) and *Predict the next activity*. Or start empty.
   `boxes/`, so it is listed under *Yours* and can be used in any workflow.
 - **Export experiment** (under ⋯) writes a zip with the workflow file and its record,
   the inputs, your boxes, every result as a file (CSV, PNML, SVG, XES), a
-  `requirements.lock` and a README that says what was run: supplementary
-  material for a paper, which `openprocess run --check` can verify.
+  `requirements.lock`, a `run.py` that runs the same analysis as a plain
+  script, and a README that says what was run: supplementary material for a
+  paper, which `openprocess run --check` can verify. Drop such a zip on
+  OpenProcess and it is unpacked into a folder of its own and run again.
+- **Export as Python script** (under ⋯) writes the analysis as a `.py` file:
+  the same boxes, settings and connections, run with `python analysis.py`,
+  the results written beside it.
+- **Every result knows where it came from**: a figure saved as SVG carries
+  the analysis, the box, its settings and the result's fingerprint in its
+  metadata; a CSV gets a `.provenance.json` beside it.
+- **⌘Z and ⇧⌘Z** undo and redo on the canvas: boxes, connections, moves,
+  settings, groups.
 - **The side panel** resizes by dragging the gap beside it; double-click the
   gap, or *View ▸ Reset Workflow Layout*, for its default width.
 - **Connections** (at the bottom of the sidebar, or *View ▸ Connections*)

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

{openprocess-0.10.6 → openprocess-0.11.3}/openprocess/cli.py

@@ -249,6 +249,8 @@ def command_mine_conform(arguments: argparse.Namespace) -> int:
     print(f"Generalisation         {generalisation(replay):.4f}")
     print(f"Simplicity             {simplicity(net):.4f}")
     print(f"Fitting cases          {alignments.fitting_traces} / {alignments.trace_count}")
+    for note in alignments.notes:
+        print(f"Note: {note}")
     return 0
 
 

{openprocess-0.10.6 → openprocess-0.11.3}/openprocess/flow/boxes/check.py

@@ -40,6 +40,8 @@ def check_fit(model: PetriNet, log: EventLog,
         alignments = align_log(model, simple)
         fitness = alignments.average_fitness
         flow.note(f"{alignments.fitting_traces} of {alignments.trace_count} cases align without a deviation")
+        for note in alignments.notes:
+            flow.note(note)
     else:
         fitness = replay.fitness
         flow.note(f"{replay.fitting_traces} of {replay.trace_count} cases replay without missing or remaining tokens")
@@ -63,8 +65,11 @@ def alignments(model: PetriNet, log: EventLog) -> AlignmentResult:
     """Optimal alignments of every variant with the model (A* over the
     synchronous product, standard cost function)."""
     result = align_log(model, log.simple_log())
-    rows = [["⟨" + ", ".join(a.trace) + "⟩", a.count, a.cost, round(a.fitness, 4)] for a in result.alignments]
+    rows = [["⟨" + ", ".join(a.trace) + "⟩", a.count, a.cost if a.complete else "?", round(a.fitness, 4)]
+            for a in result.alignments]
     flow.show(Table("Alignments", ["variant", "cases", "cost", "fitness"], rows), "Alignment per variant")
+    for note in result.notes:
+        flow.note(note)
     return result
 
 

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

@@ -110,11 +110,13 @@ def correlate(table: Table) -> Table:
 @box(name="Plot", group="Science", needs="matplotlib")
 def plot(scores: list[Scores] = (), tables: list[Table] = (),
          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
+    """Bars per model for scores, histograms for bootstrap tables, or column
+    *y* of a table against column *x*: bars when *x* holds names (a model per
+    bar), a line when it holds numbers (a sweep). Once *x* and *y* are set
+    they decide the figure, whatever else is connected. The figure is a
     matplotlib figure, converted to SVG; its code is this box's code.
 
-    x: a column of the table to put on the x axis (lines only)
+    x: a column of the table to put on the x axis
     y: the column to plot against it
     """
     import matplotlib
@@ -122,7 +124,24 @@ def plot(scores: list[Scores] = (), tables: list[Table] = (),
     import matplotlib.pyplot as plt
     fig, ax = plt.subplots(figsize=(5.5, 3.2))
     scores, tables = list(scores), list(tables)
-    if scores:
+    if tables and x and y:
+        for table in tables:
+            for name in (x, y):
+                if name not in table.columns:
+                    raise ValueError(f"{table.name} has no column {name!r}; it has {', '.join(table.columns)}")
+        numeric = all(isinstance(v, (int, float)) and not isinstance(v, bool) for t in tables for v in t.column(x))
+        for table in tables:
+            values = [float(v) for v in table.column(y)]
+            if numeric:
+                ax.plot(table.column(x), values, marker="o", label=table.name)
+            else:
+                ax.bar([str(v) for v in table.column(x)], values, label=table.name)
+        ax.set_xlabel(x)
+        ax.set_ylabel(y)
+        if len(tables) > 1:
+            ax.legend(fontsize=8)
+        caption = f"{y} against {x}."
+    elif scores:
         metrics = [m for m in dict.fromkeys(k for s in scores for k in s.metrics)
                    if all(isinstance(s.metrics.get(m, 0.0), (int, float)) for s in scores)]
         width = 0.8 / max(1, len(metrics))
@@ -134,14 +153,6 @@ def plot(scores: list[Scores] = (), tables: list[Table] = (),
         ax.set_ylim(0, 1.05)
         ax.legend(fontsize=8)
         caption = f"{len(scores)} models, {len(metrics)} scores each."
-    elif tables and x and y:
-        for table in tables:
-            ax.plot(table.column(x), table.column(y), marker="o", label=table.name)
-        ax.set_xlabel(x)
-        ax.set_ylabel(y)
-        if len(tables) > 1:
-            ax.legend(fontsize=8)
-        caption = f"{y} against {x}."
     elif tables:
         for table in tables:
             if table.samples:
@@ -150,7 +161,7 @@ def plot(scores: list[Scores] = (), tables: list[Table] = (),
         ax.legend(fontsize=8)
         caption = f"{len(tables)} bootstrap distribution{'s' if len(tables) != 1 else ''}."
     else:
-        raise ValueError("Connect scores, or tables with samples or an x and y column")
+        raise ValueError("Connect scores, or tables with samples, or a table and set both x and y")
     fig.tight_layout()
     figure = convert(fig, Figure)
     plt.close(fig)

{openprocess-0.10.6 → openprocess-0.11.3}/openprocess/flow/convert.py

@@ -15,6 +15,7 @@ class and the target (a class, or a dotted name).
 from __future__ import annotations
 
 import importlib
+import importlib.util
 from typing import Any, Callable
 
 from ..mining.log import KEY_NAME, KEY_RESOURCE, KEY_TIME, EventLog, SimpleLog
@@ -25,11 +26,49 @@ _converters: dict[tuple[str, str], Callable] = {}
 
 
 def _name(target) -> str:
+    """The name a type is registered under: ``module.qualname`` for a class,
+    a dotted string as given.  Nothing is imported here, so registering a
+    converter for ``"pandas.core.frame.DataFrame"`` costs nothing when pandas
+    is absent, and importing this module never imports pandas."""
     if isinstance(target, str):
         return target
     return f"{target.__module__}.{target.__qualname__}"
 
 
+def _resolve(dotted: str):
+    """The class a dotted name points at, or None when it cannot be found.
+
+    Tries the longest module prefix first (``a.b.c.D`` as module ``a.b.c``,
+    attribute ``D``), then shorter ones, so both ``pandas.DataFrame`` and
+    ``pandas.core.frame.DataFrame`` resolve to the same class.  A name whose
+    top-level package is not installed resolves to None without importing
+    anything.
+    """
+    parts = dotted.split(".")
+    if len(parts) < 2 or importlib.util.find_spec(parts[0]) is None:
+        return None
+    for split in range(len(parts) - 1, 0, -1):
+        try:
+            obj = importlib.import_module(".".join(parts[:split]))
+        except ImportError:
+            continue
+        for attribute in parts[split:]:
+            obj = getattr(obj, attribute, None)
+            if obj is None:
+                break
+        else:
+            if isinstance(obj, type):
+                return obj
+    return None
+
+
+def _canonical(name: str) -> str:
+    """``name`` as the class it points at is defined (``module.qualname``),
+    or ``name`` itself when it points at nothing importable."""
+    resolved = _resolve(name)
+    return name if resolved is None else _name(resolved)
+
+
 def register(source, target, function: Callable) -> None:
     """``function(value) -> converted`` for a value of class ``source``."""
     _converters[(_name(source), _name(target))] = function
@@ -39,20 +78,49 @@ def _class_names(value) -> list[str]:
     return [f"{cls.__module__}.{cls.__qualname__}" for cls in type(value).__mro__]
 
 
+def _find(value: Any, target) -> Callable | None:
+    """The registered converter from ``value``'s class (or a base class) to
+    ``target``, or None.
+
+    A class may be named by where it is imported from (``"pandas.DataFrame"``)
+    or where it is defined (``"pandas.core.frame.DataFrame"``, which pandas
+    2 reports as the class's module, while pandas 3 reports ``"pandas"``).
+    Both the source and the target are matched by resolving the names to the
+    class.  Only registered names in the same top-level package as the value
+    or the target are resolved, so looking up a pandas conversion imports
+    pandas and nothing else, and only once a conversion is asked for.
+    """
+    wanted = _name(target)
+    wanted_names = {wanted, _canonical(wanted)}
+    target_package = wanted.split(".")[0]
+    value_names = set(_class_names(value))
+    value_package = type(value).__module__.split(".")[0]
+
+    def matches(registered: str, names: set[str], package: str) -> bool:
+        if registered in names:
+            return True
+        return registered.split(".")[0] == package and _canonical(registered) in names
+
+    for (source, registered), function in _converters.items():
+        if matches(source, value_names, value_package) and \
+                matches(registered, wanted_names, target_package):
+            return function
+    return None
+
+
 def can_convert(value: Any, target) -> bool:
-    return any((name, _name(target)) in _converters for name in _class_names(value))
+    return _name(target) in _class_names(value) or _find(value, target) is not None
 
 
 def convert(value: Any, target):
     """Convert ``value`` to ``target`` (a class or a dotted name)."""
     wanted = _name(target)
-    for name in _class_names(value):
-        if name == wanted:
-            return value
-        function = _converters.get((name, wanted))
-        if function is not None:
-            return function(value)
-    raise TypeError(f"No converter from {type(value).__name__} to {wanted}")
+    if wanted in _class_names(value):
+        return value
+    function = _find(value, target)
+    if function is None:
+        raise TypeError(f"No converter from {type(value).__name__} to {wanted}")
+    return function(value)
 
 
 def converters() -> list[tuple[str, str]]:

openprocess-0.11.3/openprocess/flow/history.py

@@ -0,0 +1,113 @@
+"""Undo and redo for a workflow, by snapshots.
+
+A workflow is small (its dict form, :meth:`Workflow.to_dict`, is a few
+kilobytes), so every change keeps the whole state before it: adding,
+removing, wiring, moving or grouping boxes, a setting, a rename.  Undo puts
+a snapshot back; the page then runs the boxes again, and the cache serves
+the ones that did not change.  Snapshots are taken where the page already
+learns of a change, so no edit is instrumented by hand, and a box author
+never sees any of this.
+"""
+
+from __future__ import annotations
+
+import time
+
+#: How many steps back are kept.
+LIMIT = 100
+#: A drag arrives as several moves; those within this many seconds are one step.
+MOVE_SECONDS = 1.5
+
+
+def describe(before: dict, after: dict) -> str:
+    """What changed from ``before`` to ``after``, for "Undo adding a box"."""
+    b = {n["id"]: n for n in before.get("boxes", [])}
+    a = {n["id"]: n for n in after.get("boxes", [])}
+    added, removed = set(a) - set(b), set(b) - set(a)
+    if added:
+        return "adding a box" if len(added) == 1 else f"adding {len(added)} boxes"
+    if removed:
+        return "removing a box" if len(removed) == 1 else f"removing {len(removed)} boxes"
+    if before.get("connections") != after.get("connections"):
+        return "a connection"
+    if before.get("groups") != after.get("groups"):
+        return "grouping"
+    for node_id in a:
+        if a[node_id].get("settings") != b[node_id].get("settings"):
+            return "a setting"
+        if a[node_id].get("title", "") != b[node_id].get("title", ""):
+            return "a rename"
+    if any(a[i].get("position") != b[i].get("position") for i in a):
+        return "a move"
+    if any(a[i].get("layout") != b[i].get("layout") for i in a):
+        return "tidying a drawing"
+    if before.get("name") != after.get("name"):
+        return "a rename"
+    return "a change"
+
+
+class History:
+    """The states a workflow went through; :attr:`state` is the current one."""
+
+    def __init__(self, snapshot: dict, limit: int = LIMIT) -> None:
+        self.state = snapshot
+        self.limit = limit
+        self.undo_stack: list[dict] = []
+        self.redo_stack: list[dict] = []
+        self._last: tuple[str | None, float] = (None, 0.0)
+
+    def record(self, snapshot: dict, kind: str = "change", now: float | None = None) -> bool:
+        """The workflow is now ``snapshot``; the state before it becomes undoable.
+        Returns whether anything changed.  ``kind`` "move" folds a drag's
+        steps into one."""
+        if snapshot == self.state:
+            return False
+        now = time.monotonic() if now is None else now
+        last_kind, last_time = self._last
+        if not (kind == "move" and last_kind == "move" and now - last_time < MOVE_SECONDS and self.undo_stack):
+            self.undo_stack.append(self.state)
+            del self.undo_stack[:-self.limit]
+        self.redo_stack.clear()
+        self.state = snapshot
+        self._last = (kind, now)
+        return True
+
+    @property
+    def can_undo(self) -> bool:
+        return bool(self.undo_stack)
+
+    @property
+    def can_redo(self) -> bool:
+        return bool(self.redo_stack)
+
+    @property
+    def undo_label(self) -> str:
+        return describe(self.undo_stack[-1], self.state) if self.undo_stack else ""
+
+    @property
+    def redo_label(self) -> str:
+        return describe(self.state, self.redo_stack[-1]) if self.redo_stack else ""
+
+    def undo(self) -> tuple[str, dict] | None:
+        """Step back: (what is undone, the state to restore), or None."""
+        if not self.undo_stack:
+            return None
+        before = self.undo_stack.pop()
+        label = describe(before, self.state)
+        self.redo_stack.append(self.state)
+        self.state = before
+        self._last = (None, 0.0)
+        return label, before
+
+    def redo(self) -> tuple[str, dict] | None:
+        if not self.redo_stack:
+            return None
+        after = self.redo_stack.pop()
+        label = describe(self.state, after)
+        self.undo_stack.append(self.state)
+        self.state = after
+        self._last = (None, 0.0)
+        return label, after
+
+
+__all__ = ["History", "describe", "LIMIT", "MOVE_SECONDS"]