openprocess 0.12.1__tar.gz → 0.13.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openprocess
-Version: 0.12.1
+Version: 0.13.0
 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
@@ -26,6 +26,7 @@ Requires-Dist: PySide6>=6.6; extra == "gui"
 Requires-Dist: certifi; extra == "gui"
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: mcp>=2.3; extra == "dev"
 Provides-Extra: science
 Requires-Dist: numpy>=1.24; extra == "science"
 Requires-Dist: pandas>=2.0; extra == "science"
@@ -35,6 +36,8 @@ Provides-Extra: predict
 Requires-Dist: scikit-learn>=1.3; extra == "predict"
 Provides-Extra: pm4py
 Requires-Dist: pm4py>=2.7; extra == "pm4py"
+Provides-Extra: mcp
+Requires-Dist: mcp>=2.3; extra == "mcp"
 Dynamic: license-file
 
 <p align="center">
@@ -91,6 +94,7 @@ tools (and, until version 0.7, went by the name CPNpy):
 - [For developers](#for-developers)
 - [Workflows](#workflows)
 - [Workflows from Python](#workflows-from-python)
+- [AI assistants](#ai-assistants)
 - [Limitations and roadmap](#limitations-and-roadmap)
 
 ---
@@ -1017,6 +1021,36 @@ the clone is older than the latest release. See
 
 ---
 
+## AI assistants
+
+OpenProcess comes with an **MCP server**, so Claude (Desktop or Code), Cursor
+or any other assistant that speaks the Model Context Protocol can use it the
+way you do:
+
+```bash
+pip install "openprocess[app,mcp]"
+openprocess mcp install claude-desktop      # or claude-code, cursor; "print" for the JSON
+```
+
+Then ask in your own words, naming your files: *"Summarise
+`Week 2/plane_boarding.xes` and show me its dotted chart"*, *"Discover a model
+with IMf at 0.2, check its fit and open it in OpenProcess"*, *"Why is
+`order_handling.pnml` unsound?"*, *"Write three exercises about token replay
+for Week 7"*. Its 30 tools cover logs, discovery, conformance, net analysis,
+diagrams, BPMN, workflows and boxes, exercise packs and coloured nets.
+
+What the assistant is told, before anything else: **cite** the works every
+algorithm follows (each result carries them), say **how to reproduce** each
+number, keep analyses as **workflows** with their record (`openprocess run
+FILE --check`), write a new algorithm as a **`@box`** in the folder's
+`boxes/`, work in **your folder**, and **open** what it made in OpenProcess.
+Every file it writes is journaled with a backup: the status bar says *AI
+changed N files · Review*, with a diff, *Undo* and *Keep* for each.
+
+The full guide is [openprocess/mcp/connecting.md](openprocess/mcp/connecting.md)
+(also *Help ▸ Connect an AI Assistant*). The same operations are plain Python
+in `openprocess.mcp.api`, without the MCP SDK.
+
 ## Limitations and roadmap
 
 Plainly stated:

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

@@ -52,6 +52,7 @@ tools (and, until version 0.7, went by the name CPNpy):
 - [For developers](#for-developers)
 - [Workflows](#workflows)
 - [Workflows from Python](#workflows-from-python)
+- [AI assistants](#ai-assistants)
 - [Limitations and roadmap](#limitations-and-roadmap)
 
 ---
@@ -978,6 +979,36 @@ the clone is older than the latest release. See
 
 ---
 
+## AI assistants
+
+OpenProcess comes with an **MCP server**, so Claude (Desktop or Code), Cursor
+or any other assistant that speaks the Model Context Protocol can use it the
+way you do:
+
+```bash
+pip install "openprocess[app,mcp]"
+openprocess mcp install claude-desktop      # or claude-code, cursor; "print" for the JSON
+```
+
+Then ask in your own words, naming your files: *"Summarise
+`Week 2/plane_boarding.xes` and show me its dotted chart"*, *"Discover a model
+with IMf at 0.2, check its fit and open it in OpenProcess"*, *"Why is
+`order_handling.pnml` unsound?"*, *"Write three exercises about token replay
+for Week 7"*. Its 30 tools cover logs, discovery, conformance, net analysis,
+diagrams, BPMN, workflows and boxes, exercise packs and coloured nets.
+
+What the assistant is told, before anything else: **cite** the works every
+algorithm follows (each result carries them), say **how to reproduce** each
+number, keep analyses as **workflows** with their record (`openprocess run
+FILE --check`), write a new algorithm as a **`@box`** in the folder's
+`boxes/`, work in **your folder**, and **open** what it made in OpenProcess.
+Every file it writes is journaled with a backup: the status bar says *AI
+changed N files · Review*, with a diff, *Undo* and *Keep* for each.
+
+The full guide is [openprocess/mcp/connecting.md](openprocess/mcp/connecting.md)
+(also *Help ▸ Connect an AI Assistant*). The same operations are plain Python
+in `openprocess.mcp.api`, without the MCP SDK.
+
 ## Limitations and roadmap
 
 Plainly stated:

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

{openprocess-0.12.1 → openprocess-0.13.0}/openprocess/cli.py

@@ -1,9 +1,10 @@
 """Command-line interface: ``openprocess <command> [options]``.
 
 The CLI exists so that the engine is usable without the GUI -- in a script, in
-a notebook, from a Makefile, or over SSH.  Every command works on a ``.cpn``
-file, except ``example``, which writes one of the built-in demo models so you
-have something to try immediately.
+a notebook, from a Makefile, or over SSH.  The first five commands work on a
+``.cpn`` file (``example`` writes one of the built-in demo models so you have
+something to try immediately); the others take event logs, PNML nets,
+workflow files and exercise packs.
 
 Commands
 --------
@@ -24,6 +25,7 @@ Commands
                 ``--export`` and ``--report`` write a zip and an HTML page
 ``boxes``       list the boxes (OpenProcess's own, a folder's ``boxes/``, packages)
 ``datasets``    the public logs known by name: ``list``, ``fetch``, ``where``
+``mcp``         the MCP server for AI assistants; ``install CLIENT``, ``status``
 """
 
 from __future__ import annotations
@@ -338,7 +340,7 @@ def command_mine_invariants(arguments: argparse.Namespace) -> int:
 # ---------------------------------------------------------------------------
 def command_exercises_check(arguments: argparse.Namespace) -> int:
     """List a pack's exercises and answer boxes; report mistakes in them."""
-    from .learn.checks import Context, TaskError, model_answer_text, validate
+    from .learn.checks import Context, TaskError, computed_answer_text, validate
     from .learn.pack import load_pack
     pack = load_pack(arguments.folder)
     if not pack.exercises:
@@ -357,11 +359,15 @@ def command_exercises_check(arguments: argparse.Namespace) -> int:
             checked = "checked" if task.checkable else "self-checked"
             line = f"  - {task.id:<8} {task.type:<10} {checked}"
             if arguments.answers and task.type not in ("net", "footprint", "trace", "open"):
+                # The answer the app works out (not the author's solution text),
+                # so the author can compare the two.
                 try:
-                    answer = model_answer_text(exercise, task, context)
+                    answer = computed_answer_text(exercise, task, context)
                 except TaskError as error:
                     answer = f"(cannot work it out: {error})"
                 line += "  →  " + " ".join(answer.split())[:100]
+                if task.solution and task.type not in ("open",):
+                    line += "   (solution: " + " ".join(task.solution.split())[:60] + ")"
             print(line)
         for problem in found:
             print(f"  ! {problem}")
@@ -452,6 +458,10 @@ def command_run(arguments: argparse.Namespace) -> int:
         target.write_text(requirements_lock(record), encoding="utf-8")
         print(f"Wrote {target}")
         return 0
+    if arguments.sweep and arguments.check:
+        print("openprocess: --check compares the recorded results, which a sweep changes; "
+              "run the two separately", file=sys.stderr)
+        return 2
     for spec in arguments.sweep or []:
         name, _, values = spec.partition("=")
         node_id, _, setting = name.rpartition(".")
@@ -517,7 +527,10 @@ def _brief(value) -> str:
     from .flow.figures import tile_parts
     from .flow.types import Figure, Scores, Table
     if dataclasses.is_dataclass(value) and not isinstance(value, type) and tile_parts(value):
-        return " · ".join(tile_parts(value))
+        big, small = tile_parts(value)
+        if " · " in big and big.count(" · ") == small.count(" · "):      # "8 · 7" over "places · transitions"
+            return " · ".join(f"{a} {b}" for a, b in zip(big.split(" · "), small.split(" · ")))
+        return f"{big} ({small})" if small and small not in big else big
     if isinstance(value, Scores):
         return ", ".join(f"{k} {v:.3f}" if isinstance(v, float) else f"{k} {v}" for k, v in value.metrics.items())
     if isinstance(value, Table):
@@ -533,26 +546,70 @@ def _brief(value) -> str:
 
 
 def _write_outputs(workflow, run, folder: Path) -> None:
-    from .flow.types import Figure, Scores, Table
+    """Every result that has a file form (tables, scores, figures, nets, logs,
+    texts), named after its box; the same files --export puts in the zip."""
+    from .flow.record import as_file
+    from .flow.types import Figure, Table
     folder.mkdir(parents=True, exist_ok=True)
+    written = 0
     for node in workflow.order():
         value = run.value(node)
         stem = f"{node.id} {workflow.title(node)}".replace("/", "-")
-        if isinstance(value, Table):
+        if isinstance(value, Table):              # with their provenance sidecars
             value.to_csv(folder / f"{stem}.csv")
-        elif isinstance(value, Scores):
-            Table.from_scores([value]).to_csv(folder / f"{stem}.csv")
-        elif isinstance(value, Figure):
+        elif isinstance(value, Figure) and (value.svg or value.png):
             value.save(folder / f"{stem}.svg" if value.svg else folder / f"{stem}.png")
-        elif value.__class__.__name__ == "PetriNet":
-            from .mining.pnml import write_pnml
-            write_pnml(value, folder / f"{stem}.pnml")
-    print(f"Wrote the results into {folder}")
+        else:
+            found = as_file(value, stem)
+            if found is None:
+                continue
+            name, content = found
+            if isinstance(content, bytes):
+                (folder / name).write_bytes(content)
+            else:
+                (folder / name).write_text(content, encoding="utf-8")
+        written += 1
+    print(f"Wrote {written} result file(s) into {folder}")
+
+
+def command_mcp(arguments: argparse.Namespace) -> int:
+    """``openprocess mcp``: the MCP server, and connecting assistants to it."""
+    if arguments.action == "install":
+        from .mcp.install import install
+        if not arguments.client:
+            print("openprocess: say which assistant: claude-desktop, claude-code, cursor, windsurf, or print",
+                  file=sys.stderr)
+            return 2
+        try:
+            print(install(arguments.client))
+        except ValueError as error:
+            print(f"openprocess: {error}", file=sys.stderr)
+            return 1
+        return 0
+    if arguments.action == "status":
+        from .mcp.install import server_command, status
+        print("Server command: " + " ".join(server_command()))
+        for client, state in status().items():
+            print(f"  {client:16} {'connected' if state['configured'] else 'not connected':14} {state['config'] or ''}")
+        return 0
+    try:
+        from .mcp.server import main as serve
+    except ImportError as error:
+        print(f"openprocess: {error}", file=sys.stderr)
+        return 1
+    argv = ["--http", "--host", arguments.host, "--port", str(arguments.port)] if arguments.http else []
+    return serve(argv)
 
 
 def command_boxes(arguments: argparse.Namespace) -> int:
     from .flow import library_for
-    library = library_for(arguments.folder)
+    folder = arguments.folder
+    if folder is not None and not (Path(folder) / "boxes").is_dir():
+        # The folder given is itself a folder of box files (Week 5/boxes).
+        library = library_for(None)
+        library.load_folder(folder)
+    else:
+        library = library_for(folder)
     for group, specs in library.by_group().items():
         print(f"{group}")
         for spec in specs:
@@ -577,8 +634,9 @@ def command_datasets(arguments: argparse.Namespace) -> int:
         return 0
     try:
         path = datasets.fetch(arguments.name)
-    except datasets.DatasetMissing as error:
-        print(f"openprocess: {error}", file=sys.stderr)
+    except (datasets.DatasetMissing, KeyError) as error:
+        message = error.args[0] if isinstance(error, KeyError) and error.args else error
+        print(f"openprocess: {message}", file=sys.stderr)
         return 1
     print(f"{arguments.name}: {path}\nsha256 {datasets.sha256_file(path)}")
     return 0
@@ -587,7 +645,8 @@ def command_datasets(arguments: argparse.Namespace) -> int:
 def build_parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(
         prog="openprocess",
-        description="Coloured Petri Net tools: edit, simulate and analyse .cpn models.",
+        description="OpenProcess from the command line: process mining on event logs, Petri net "
+                    "analysis, coloured net simulation, workflows, exercise packs and an MCP server.",
     )
     subparsers = parser.add_subparsers(dest="command", required=True)
 
@@ -683,6 +742,17 @@ def build_parser() -> argparse.ArgumentParser:
     dataset_commands.add_parser("where", help="print the cache folder")
     datasets.set_defaults(handler=command_datasets)
 
+    mcp = subparsers.add_parser("mcp", help="serve OpenProcess to AI assistants (Model Context Protocol)",
+                                description="Without a command: serve on stdio, as an assistant starts it. "
+                                            "`install CLIENT` connects Claude Desktop, Claude Code or Cursor; "
+                                            "`status` says which have it.")
+    mcp.add_argument("action", nargs="?", choices=["serve", "install", "status"], default="serve")
+    mcp.add_argument("client", nargs="?", help="for install: claude-desktop, claude-code, cursor, windsurf or print")
+    mcp.add_argument("--http", action="store_true", help="serve Streamable HTTP on localhost instead of stdio")
+    mcp.add_argument("--host", default="127.0.0.1")
+    mcp.add_argument("--port", type=int, default=8765)
+    mcp.set_defaults(handler=command_mcp)
+
     mine = subparsers.add_parser("mine", help="process mining on event logs")
     mining = mine.add_subparsers(dest="mining_command", required=True)
     stats = mining.add_parser("stats", help="summarise an event log")

{openprocess-0.12.1 → openprocess-0.13.0}/openprocess/flow/__init__.py

@@ -35,14 +35,14 @@ 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 (Column, AlignmentResult, Any, CPNet, DFG, Dataset, EventLog, Figure, Footprint, Marking,
+from .types import (BPMN, 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",
+    "AlignmentResult", "Any", "BPMN", "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",
     "Runner", "Scores", "Setting", "SimpleLog", "Sweep", "Table", "Text", "TransitionSystem", "Workflow",

{openprocess-0.12.1 → openprocess-0.13.0}/openprocess/flow/box.py

@@ -255,6 +255,13 @@ class Box:
     def __repr__(self) -> str:
         return f"<box {self.spec.id}>"
 
+    def publish(self, name: str | None = None) -> dict:
+        """Make this box, defined in a notebook or a script, a box of the folder
+        open in OpenProcess Studio: its source goes to ``boxes/<name>.py`` there
+        (see :func:`openprocess.flow.studio.publish_box`)."""
+        from .studio import publish_box
+        return publish_box(self, name)
+
 
 # ---------------------------------------------------------------------------
 # Reading the signature

{openprocess-0.12.1 → openprocess-0.13.0}/openprocess/flow/boxes/check.py

@@ -48,6 +48,11 @@ 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 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 "
+                        f"({cases:,} cases), counted as fitness 0, so this fitness is a lower bound; "
+                        "token replay gives a figure for every case.")
     return scores
 
 

openprocess-0.13.0/openprocess/flow/boxes/cpn.py

@@ -0,0 +1,97 @@
+"""Coloured net boxes: play a CPN out many times, and compute its state space."""
+
+from __future__ import annotations
+
+from typing import Literal
+
+from ... import flow
+from ...analysis.state_space import StateSpace
+from ...mining.log import EventLog
+from ...model.net import CPNet
+from ...sim.export import case_variables, simulation_to_log
+from ...sim.performance import analyse_performance
+from ...sim.simulator import DeadMarkingError, Simulator
+from ..box import box
+from ..types import Scores, Table, Text
+
+
+@box(name="Simulate CPN", group="Coloured nets")
+def simulate_cpn(net: CPNet, steps: int = 500, case_variable: str = "", seed: int = 0,
+                 unit: Literal["seconds", "minutes", "hours", "days"] = "minutes") -> EventLog:
+    """Runs the simulator for *steps* firings and turns the firing history
+    into an event log: one case per value of *case_variable* (the variable
+    that identifies a case in the inscriptions, e.g. ``p`` or ``order``),
+    one event per firing, the model time as the timestamp.
+
+    case_variable: the variable whose value is the case id (empty: the first one found)
+    """
+    simulator = Simulator(net, seed=seed)
+    try:
+        fired = simulator.run(steps)
+    except DeadMarkingError:
+        fired = simulator.step_count
+    variable = case_variable or next(iter(case_variables(net)), "")
+    if not variable:
+        raise ValueError("No variable to use as the case id: set case_variable")
+    log = simulation_to_log(net, simulator.log, variable, unit)
+    flow.note(f"{fired} firings, model time {simulator.clock}, case variable {variable}: "
+              f"{len(log)} cases, {log.event_count} events")
+    return log
+
+
+@box(name="Performance", group="Coloured nets")
+def performance(net: CPNet, runs: int = 10, steps: int = 1000, warm_up: float = 0.0, seed: int = 0,
+                distribution: Literal["throughput", "waiting time"] = "throughput") -> Table:
+    """Runs a timed coloured net *runs* times (seeds *seed*, *seed* + 1, …),
+    each for *steps* firings or until it is dead, and reports one row per
+    transition (firings, throughput in firings per time unit, utilisation:
+    the share of the model time during which one of its firings was still in
+    progress) and one per place (the waiting time of its tokens from their
+    time stamp to their consumption, the time-averaged number of tokens, and
+    occupancy: the share of the time it was not empty), after the first
+    *warm_up* time units of every run, averaged over the runs. An untimed
+    net is measured in steps instead. The samples behind the table are one
+    number per run, for Compare samples and Plot.
+
+    runs: how many seeded runs to average over
+    steps: firings per run (a run stops earlier when the model is dead)
+    warm_up: model time left out at the start of every run (firings, for an untimed net)
+    seed: the first run's seed; run k uses seed + k
+    distribution: what the samples hold per run: the model's throughput, or its mean waiting time
+    """
+    result = analyse_performance(net, runs=runs, steps=steps, warm_up=warm_up, seed=seed)
+    for note in result.notes:
+        flow.note(note)
+    for run in result.runs:
+        flow.note(result.summary(run))
+    flow.show(Table("Per run", ["run", "seed", "firings", "end", "stopped", "throughput", "mean waiting"],
+                    [[k, run.seed, run.firings, run.end, "dead" if run.dead else "steps",
+                      None if run.throughput is None else round(run.throughput, 4),
+                      None if run.waiting_mean is None else round(run.waiting_mean, 4)]
+                     for k, run in enumerate(result.runs)]), "Per run")
+    samples = result.samples(distribution)
+    dead = sum(run.dead for run in result.runs)
+    note = (f"{runs} runs of up to {steps} firings, seeds {seed} to {seed + runs - 1}, the first {warm_up:g} "
+            f"{'time units' if result.timed else 'firings'} of each left out"
+            f"{f'; {dead} of them ended in a dead marking' if dead else ''}. "
+            f"Throughput is firings per {result.unit}; waiting time runs from a token's time stamp to its "
+            f"consumption; utilisation is the share of the time a firing of the transition was in progress; "
+            f"occupancy the share of the time the place was not empty. "
+            f"The samples are the per-run {distribution} of the whole model.")
+    return Table(f"Performance of {net.name}", list(result.columns), result.rows(),
+                 samples=samples or None, note=note)
+
+
+@box(name="State space", group="Coloured nets", heavy=True)
+def state_space(net: CPNet, max_nodes: int = 10000) -> Scores:
+    """The reachability graph of a coloured net and its report: dead and
+    home markings, bounds, dead and live transitions (as CPN Tools reports
+    them). The full report is in the notes."""
+    space = StateSpace(net).generate(max_nodes=max_nodes)
+    report = space.report()
+    flow.show(Text(report, "State space report"), "Report")
+    dead = space.dead_markings()
+    return Scores(net.name, {"nodes": space.node_count, "arcs": space.arc_count,
+                             "dead markings": len(dead), "home markings": len(space.home_markings()),
+                             "dead transitions": len(space.dead_transitions()),
+                             "complete": "No (stopped at the limit)" if space.unexplored_count else "Yes"})

{openprocess-0.12.1 → openprocess-0.13.0}/openprocess/flow/boxes/discover.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from typing import Literal
 
 from ... import flow
+from ...mining.bpmn import BPMN, bpmn_to_petri_net, petri_net_to_bpmn, tree_to_bpmn as _tree_to_bpmn
 from ...mining.dfg import DFG, discover_dfg
 from ...mining.discovery import alpha as alpha_module
 from ...mining.discovery.heuristics import heuristics_net
@@ -62,6 +63,41 @@ def tree_to_net(tree: ProcessTree) -> PetriNet:
     return to_petri_net(tree)
 
 
+@box(name="Tree to BPMN", group="Discover")
+def tree_to_bpmn(tree: ProcessTree) -> BPMN:
+    """Translates a process tree into a BPMN model, block by block: a
+    sequence is a chain, a choice exclusive gateways, a parallel block
+    parallel gateways, a loop exclusive gateways with a flow back, and τ an
+    empty flow."""
+    model = _tree_to_bpmn(tree)
+    flow.note(model.summary())
+    return model
+
+
+@box(name="BPMN to net", group="Discover")
+def bpmn_to_net(model: BPMN) -> PetriNet:
+    """The Petri net semantics of a BPMN model (Dijkman, Dumas & Ouyang,
+    2008): tasks become transitions, sequence flows places, parallel
+    gateways silent transitions, exclusive gateways places, the start event
+    the source place and the end event the sink place."""
+    net = bpmn_to_petri_net(model)
+    flow.note(net.summary())
+    for warning in model.warnings:
+        flow.note(f"Warning: {warning}")
+    return net
+
+
+@box(name="Net to BPMN", group="Discover")
+def net_to_bpmn(net: PetriNet) -> BPMN:
+    """A BPMN model of a WF-net: transitions become tasks (with parallel
+    gateways where they split or join), places with several producers or
+    consumers exclusive gateways, and silent steps plain flows. Exact for
+    free-choice nets, the kind the Inductive Miner produces."""
+    model = petri_net_to_bpmn(net)
+    flow.note(model.summary())
+    return model
+
+
 @box(name="Heuristics Miner", group="Discover")
 def heuristics_miner(log: EventLog, dependency: float = 0.9) -> PetriNet:
     """Keeps the directly-follows relations whose dependency measure

{openprocess-0.12.1 → openprocess-0.13.0}/openprocess/flow/boxes/input.py

@@ -7,6 +7,7 @@ from pathlib import Path
 from typing import Literal
 
 from ... import flow
+from ...mining.bpmn import BPMN
 from ...mining.log import KEY_NAME, Event, EventLog, Trace, parse_simple_log
 from ...mining.petrinet import PetriNet
 from ...mining.playout import play_out
@@ -95,6 +96,23 @@ def open_net(file: Path) -> PetriNet:
     return net
 
 
+@box(name="Open BPMN", group="Input")
+def open_bpmn(file: Path) -> BPMN:
+    """Opens a BPMN 2.0 model (a ``.bpmn`` file from Camunda Modeler, bpmn.io,
+    Signavio, ...): its start and end events, tasks, exclusive and parallel
+    gateways and sequence flows. Pools, lanes, message flows and data are
+    read past; what had to be approximated is noted.
+
+    file: the ``.bpmn`` file. Choose… picks it; a name alone means a file in the workflow's folder
+    """
+    from ...mining.bpmn import read_bpmn
+    model = read_bpmn(_resolve(file))
+    flow.note(f"{Path(file).name}: {model.summary()}")
+    for warning in model.warnings:
+        flow.note(f"Warning: {warning}")
+    return model
+
+
 @box(name="Open coloured net", group="Input")
 def open_cpn(file: Path) -> CPNet:
     """Opens a coloured Petri net (a CPN Tools ``.cpn`` file).

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

@@ -20,7 +20,7 @@ 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.dotted import SORT_MODES, X_MODES, DotSettings, Dots, how_to_read, svg
 from ...mining.log import EventLog
 from ...mining.petrinet import PetriNet
 from ..box import box
@@ -229,8 +229,7 @@ def dotted_chart(log: EventLog,
                   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()}.")
+                  caption=f"{how_to_read(settings, dots.mode)} Colour: {colour}.")
 
 
 @box(name="Who does what", group="Measure")

{openprocess-0.12.1 → openprocess-0.13.0}/openprocess/flow/boxes/output.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from pathlib import Path
 
 from ... import flow
+from ...mining.bpmn import BPMN
 from ...mining.log import EventLog
 from ...mining.petrinet import PetriNet
 from ..box import box
@@ -25,6 +26,15 @@ def save_pnml(model: PetriNet, file: str = "model.pnml") -> None:
     flow.note(f"Wrote {file}")
 
 
+@box(name="Save as BPMN", group="Output")
+def save_bpmn(model: BPMN, file: str = "model.bpmn") -> None:
+    """Writes the model as BPMN 2.0 XML with a diagram (Camunda Modeler,
+    bpmn.io and Signavio open it)."""
+    from ...mining.bpmn import write_bpmn
+    write_bpmn(model, _target(file))
+    flow.note(f"Wrote {file}")
+
+
 @box(name="Save log", group="Output")
 def save_log(log: EventLog, file: str = "log.xes") -> None:
     """Writes the log as XES (``.xes`` or ``.xes.gz``) or CSV (``.csv``)."""