openprocess 0.7.0__py3-none-any.whl

openprocess/flow/boxes/check.py

@@ -0,0 +1,119 @@
+"""Check boxes: how well a model fits a log, and what a net is like."""
+
+from __future__ import annotations
+
+from typing import Literal
+
+from ... import flow
+from ...mining.analysis import check_soundness
+from ...mining.compare_nets import compare_nets
+from ...mining.conformance.alignments import AlignmentResult, align_log
+from ...mining.conformance.quality import generalisation, precision, simplicity
+from ...mining.conformance.token_replay import ReplayResult, token_replay as _replay
+from ...mining.footprint import compare_footprints, footprint_of_log, footprint_of_net
+from ...mining.log import EventLog
+from ...mining.petrinet import PetriNet
+from ..box import box
+from ..types import Scores, Table
+
+
+def _replay_table(replay: ReplayResult) -> Table:
+    rows = [["⟨" + ", ".join(t.trace) + "⟩", t.count, t.produced, t.consumed, t.missing, t.remaining,
+             round(t.fitness, 4)] for t in replay.traces]
+    return Table("Replay per variant", ["variant", "cases", "p", "c", "m", "r", "fitness"], rows,
+                 note=f"Over the log: p = {replay.produced}, c = {replay.consumed}, "
+                      f"m = {replay.missing}, r = {replay.remaining}.")
+
+
+@box(name="Check fit", group="Check")
+def check_fit(model: PetriNet, log: EventLog,
+              method: Literal["Token replay", "Alignments"] = "Token replay") -> Scores:
+    """Replays every case of the log on the model and scores fitness,
+    precision (escaping edges), generalisation and simplicity.
+
+    method: token replay (fast, the course's p c m r) or optimal alignments
+    """
+    simple = log.simple_log()
+    replay = _replay(model, simple)
+    flow.show(_replay_table(replay), "Replay per variant")
+    if method == "Alignments":
+        alignments = align_log(model, simple)
+        fitness = alignments.average_fitness
+        flow.note(f"{alignments.fitting_traces} of {alignments.trace_count} cases align without a deviation")
+    else:
+        fitness = replay.fitness
+        flow.note(f"{replay.fitting_traces} of {replay.trace_count} cases replay without missing or remaining tokens")
+    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()})."
+    return scores
+
+
+@box(name="Token replay", group="Check")
+def token_replay(model: PetriNet, log: EventLog) -> ReplayResult:
+    """Token-based replay with the counts the course uses: produced,
+    consumed, missing and remaining tokens, per variant."""
+    replay = _replay(model, log.simple_log())
+    flow.show(_replay_table(replay), "Replay per variant")
+    return replay
+
+
+@box(name="Alignments", group="Check")
+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]
+    flow.show(Table("Alignments", ["variant", "cases", "cost", "fitness"], rows), "Alignment per variant")
+    return result
+
+
+@box(name="Soundness", group="Check")
+def soundness(model: PetriNet) -> Scores:
+    """Is the net a sound WF-net? The three conditions, with each
+    violation's counterexample in the notes."""
+    report = check_soundness(model)
+    for finding in report.findings:
+        flow.note(finding)
+    verdict = {True: "Sound", False: "Not sound", None: "Undecided"}[report.sound]
+    return Scores(model.name, {"soundness": verdict,
+                               "WF-net": "Yes" if report.workflow.is_workflow_net else "No",
+                               "option to complete": _yes(report.option_to_complete),
+                               "proper completion": _yes(report.proper_completion),
+                               "no dead transitions": _yes(report.no_dead_transitions)})
+
+
+def _yes(value) -> str:
+    return {True: "Yes", False: "No", None: "?"}[value]
+
+
+@box(name="Compare to true net", group="Check")
+def compare_to_true_net(model: PetriNet, true_net: PetriNet, max_length: int = 12) -> Scores:
+    """Model to model: the share of the true net's complete traces the
+    model allows (recall), the share of the model's traces the true net
+    allows (precision), simplicity, and soundness."""
+    comparison = compare_nets(model, true_net, max_length=max_length)
+    only_model, only_truth = len(comparison.only_first), len(comparison.only_second)
+    for trace in comparison.only_first[:5]:
+        flow.note("The model allows ⟨" + ", ".join(trace) + "⟩, the true net does not")
+    for trace in comparison.only_second[:5]:
+        flow.note("The true net allows ⟨" + ", ".join(trace) + "⟩, the model does not")
+    sound = check_soundness(model).sound
+    recall = 1.0 if comparison.equivalent else max(0.0, 1 - only_truth / max(1, only_truth + 3))
+    prec = 1.0 if comparison.equivalent else max(0.0, 1 - only_model / max(1, only_model + 3))
+    flow.note(comparison.summary("the model", "the true net"))
+    return Scores(model.name, {"recall": recall, "precision": prec, "simplicity": simplicity(model),
+                               "soundness": {True: "Sound", False: "Not sound", None: "Undecided"}[sound]},
+                  note="Recall and precision here count the shortest differing traces; "
+                       "equivalent nets score 1.")
+
+
+@box(name="Footprint conformance", group="Check")
+def footprint_conformance(log: EventLog, model: PetriNet) -> Scores:
+    """Compares the footprint of the log with the footprint of the net."""
+    comparison = compare_footprints(footprint_of_log(log.simple_log()), footprint_of_net(model))
+    cells = len(comparison.activities) ** 2
+    flow.note(f"{len(comparison.differences)} of {cells} cells differ")
+    for a, b, in_log, in_model in comparison.differences[:8]:
+        flow.note(f"{a} ? {b}: {in_log} in the log, {in_model} in the net")
+    return Scores(model.name, {"footprint conformance": comparison.fitness})

openprocess/flow/boxes/compare.py

@@ -0,0 +1,16 @@
+"""Compare: any number of scores side by side."""
+
+from __future__ import annotations
+
+from ... import flow
+from ..box import box
+from ..types import Scores, Table
+
+
+@box(name="Compare", group="Compare")
+def compare(scores: list[Scores]) -> Table:
+    """Puts any number of scores side by side, with columns taken from the
+    scores themselves. Under a sweep it collects the scores of every value."""
+    table = Table.from_scores(scores, "Compare")
+    flow.note(f"{len(table)} models, {len(table.columns) - 1} columns")
+    return table

openprocess/flow/boxes/cpn.py

@@ -0,0 +1,53 @@
+"""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.simulator import DeadMarkingError, Simulator
+from ..box import box
+from ..types import Scores, 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="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/flow/boxes/discover.py

@@ -0,0 +1,124 @@
+"""Discover boxes: from a log to a model, each one showing how."""
+
+from __future__ import annotations
+
+from typing import Literal
+
+from ... import flow
+from ...mining.dfg import DFG, discover_dfg
+from ...mining.discovery import alpha as alpha_module
+from ...mining.discovery.heuristics import heuristics_net
+from ...mining.discovery.inductive import inductive_miner as _inductive
+from ...mining.discovery.state_regions import region_result
+from ...mining.footprint import Footprint, footprint_of_log
+from ...mining.log import EventLog
+from ...mining.petrinet import PetriNet
+from ...mining.processtree import ProcessTree, to_petri_net
+from ...mining.transition_system import TransitionSystem, transition_system_from_log
+from ..box import box
+from ..types import Table
+
+
+@box(name="α-algorithm", group="Discover")
+def alpha_miner(log: EventLog) -> PetriNet:
+    """The α-algorithm (van der Aalst, Weijters & Maruster, 2004): a Petri
+    net from the footprint of the log, in the eight steps of the book."""
+    result = alpha_module.alpha_miner(log.simple_log())
+    flow.show(footprint_of_log(log.simple_log()), "Footprint of the log")
+    flow.steps(result.steps())
+    flow.show(result, "The derivation, typeset")
+    for warning in result.warnings:
+        flow.note(f"Warning: {warning}")
+    result.net.name = f"α({log.name})"
+    return result.net
+
+
+@box(name="Inductive Miner", group="Discover")
+def inductive_miner(log: EventLog, noise: float = 0.0) -> PetriNet:
+    """Splits the log recursively into sequence, choice, parallel and loop
+    parts (Leemans, Fahland & van der Aalst). With *noise* above 0 this is
+    IMf, which ignores behaviour rarer than the threshold.
+
+    noise: the IMf noise threshold, 0 for the plain Inductive Miner
+    """
+    result = _inductive(log.simple_log(), noise_threshold=noise)
+    flow.show(result, "Process tree and the recursion")
+    flow.steps([(f"{'  ' * s.depth}{s.kind}", s.text) for s in result.steps])
+    result.net.name = f"IM{'f' if noise > 0 else ''}({log.name})"
+    return result.net
+
+
+@box(name="Inductive Miner tree", group="Discover")
+def inductive_tree(log: EventLog, noise: float = 0.0) -> ProcessTree:
+    """The Inductive Miner's process tree itself, to convert or inspect."""
+    result = _inductive(log.simple_log(), noise_threshold=noise)
+    flow.steps([(f"{'  ' * s.depth}{s.kind}", s.text) for s in result.steps])
+    return result.tree
+
+
+@box(name="Tree to net", group="Discover")
+def tree_to_net(tree: ProcessTree) -> PetriNet:
+    """Translates a process tree into a sound WF-net (block by block)."""
+    return to_petri_net(tree)
+
+
+@box(name="Heuristics Miner", group="Discover")
+def heuristics_miner(log: EventLog, dependency: float = 0.9) -> PetriNet:
+    """Keeps the directly-follows relations whose dependency measure
+    a ⇒ b = (|a>b| − |b>a|) / (|a>b| + |b>a| + 1) reaches the threshold, then
+    turns the dependency graph into a Petri net through a causal net.
+
+    dependency: the threshold a ⇒ b must reach
+    """
+    result = heuristics_net(log.simple_log(), dependency_threshold=dependency)
+    flow.show(result, "Dependency graph and bindings")
+    graph = result.graph
+    rows = [[a, b, round(measure, 3), "kept" if (a, b) in graph.edges else "dropped"]
+            for (a, b), measure in sorted(graph.all_dependencies.items())]
+    flow.show(Table("Dependency measures", ["a", "b", "a ⇒ b", "in the graph"], rows), "Dependency measures")
+    flow.note(f"{len(graph.edges)} relations reach {dependency:g}")
+    result.net.name = f"HM({log.name})"
+    return result.net
+
+
+@box(name="Classical states", group="Discover")
+def classical_states(log: EventLog, direction: Literal["prefix", "postfix", "both"] = "prefix",
+                     representation: Literal["sequence", "multiset", "set"] = "set",
+                     horizon: Literal["1", "2", "3", "all"] = "all") -> TransitionSystem:
+    """A transition system from the log with a classical state function:
+    each prefix (or postfix) becomes a state through its sequence, multiset
+    or set, over the last k events or all of them."""
+    k = None if horizon == "all" else int(horizon)
+    ts = transition_system_from_log(log.simple_log(), direction, representation, k)
+    flow.note(f"{len(ts.states)} states, {len(ts.transitions)} transitions ({ts.abstraction})")
+    return ts
+
+
+@box(name="Regions to net", group="Discover")
+def regions_to_net(ts: TransitionSystem) -> PetriNet:
+    """Synthesises a Petri net from the minimal regions of a transition
+    system: one place per minimal region (Cortadella et al.)."""
+    result = region_result(ts)
+    flow.show(result, "Regions, checks and synthesis")
+    flow.note(f"{len(result.analysis.regions)} regions, {len(result.analysis.minimal)} minimal")
+    if result.synthesis.isomorphic is not None:
+        flow.note("The net's reachability graph is isomorphic to the transition system"
+                  if result.synthesis.isomorphic else
+                  "The net's reachability graph is not isomorphic to the transition system")
+    if result.net is None:
+        raise ValueError(" ".join(result.warnings) or "No net could be synthesised.")
+    return result.net
+
+
+@box(name="Directly-follows graph", group="Discover")
+def directly_follows(log: EventLog) -> DFG:
+    """The process map: which activity directly follows which, how often."""
+    dfg = discover_dfg(log)
+    flow.note(f"{len(dfg.activities)} activities, {len(dfg.edges)} arcs")
+    return dfg
+
+
+@box(name="Footprint", group="Discover")
+def footprint(log: EventLog) -> Footprint:
+    """The → ← ‖ # matrix of the log's ordering relations."""
+    return footprint_of_log(log.simple_log())

openprocess/flow/boxes/filter.py

@@ -0,0 +1,80 @@
+"""Filter boxes: keep part of a log, as the log viewer's Filter… does."""
+
+from __future__ import annotations
+
+from typing import Literal
+
+from ... import flow
+from ...mining import filtering
+from ...mining.log import EventLog
+from ..box import box
+
+
+def _names(text: str) -> set[str]:
+    return {part.strip() for part in text.split(",") if part.strip()}
+
+
+@box(name="Top variants", group="Filter")
+def top_variants(log: EventLog, k: int = 3) -> EventLog:
+    """Keeps the cases of the *k* most frequent variants.
+
+    k: how many variants to keep
+    """
+    before = log.simple_log()
+    kept = filtering.filter_variants(log, count=k)
+    flow.note(f"Kept {len(kept.simple_log())} of {len(before)} variants, "
+              f"{len(kept)} of {len(log)} cases")
+    return kept
+
+
+@box(name="Variants covering", group="Filter")
+def variants_covering(log: EventLog, percent: float = 80.0) -> EventLog:
+    """Keeps just enough of the most frequent variants to cover *percent* of the cases."""
+    kept = filtering.filter_variants(log, coverage=percent)
+    flow.note(f"Kept {len(kept)} of {len(log)} cases")
+    return kept
+
+
+@box(name="Activities", group="Filter")
+def filter_activities(log: EventLog, activities: str = "a, b",
+                      mode: Literal["keep events", "mandatory", "forbidden"] = "keep events") -> EventLog:
+    """Keeps only the events of these activities, or the cases that must
+    (*mandatory*) or must not (*forbidden*) contain one of them.
+
+    activities: activity names, separated by commas
+    """
+    kept = filtering.filter_activities(log, _names(activities), mode)
+    flow.note(f"{len(kept)} of {len(log)} cases, {kept.event_count} of {log.event_count} events left")
+    return kept
+
+
+@box(name="Start activities", group="Filter")
+def start_activities(log: EventLog, activities: str = "a") -> EventLog:
+    """Keeps the cases that start with one of these activities."""
+    return filtering.filter_start_activities(log, _names(activities))
+
+
+@box(name="End activities", group="Filter")
+def end_activities(log: EventLog, activities: str = "d") -> EventLog:
+    """Keeps the cases that end with one of these activities."""
+    return filtering.filter_end_activities(log, _names(activities))
+
+
+@box(name="Case length", group="Filter")
+def case_length(log: EventLog, minimum: int = 1, maximum: int = 100) -> EventLog:
+    """Keeps the cases with between *minimum* and *maximum* events."""
+    return filtering.filter_case_length(log, minimum, maximum)
+
+
+@box(name="Time frame", group="Filter")
+def time_frame(log: EventLog, start: str = "2000-01-01", end: str = "2100-01-01",
+               mode: Literal["contained", "started", "intersecting"] = "contained") -> EventLog:
+    """Keeps the cases contained in, started in, or touching the period.
+
+    start: the first day, as YYYY-MM-DD
+    end: the last day, as YYYY-MM-DD
+    """
+    from datetime import datetime, timezone
+    begin = datetime.fromisoformat(start).replace(tzinfo=timezone.utc)
+    finish = datetime.fromisoformat(end).replace(tzinfo=timezone.utc, hour=23, minute=59, second=59)
+    return filtering.filter_time_frame(log, begin, finish, mode)

openprocess/flow/boxes/input.py

@@ -0,0 +1,124 @@
+"""Input boxes: what a workflow starts from."""
+
+from __future__ import annotations
+
+import random
+from pathlib import Path
+from typing import Literal
+
+from ... import flow
+from ...mining.log import KEY_NAME, Event, EventLog, Trace, parse_simple_log
+from ...mining.petrinet import PetriNet
+from ...mining.playout import play_out
+from ...mining.transition_system import TransitionSystem, parse_transition_system
+from ...model.net import CPNet
+from ..box import box
+
+
+def _resolve(file: Path) -> Path:
+    path = Path(file)
+    if not path.is_file():
+        raise FileNotFoundError(f"No such file: {path}")
+    return path
+
+
+@box(name="Open log", group="Input")
+def open_log(file: Path) -> EventLog:
+    """Reads an event log from the folder: XES (also gzipped), CSV, or a
+    ``.txt`` file in the course notation ``[<a,b,c>^3, <a,c>]``.
+
+    file: the log file, relative to the workflow's folder
+    """
+    path = _resolve(file)
+    lower = path.name.lower()
+    if lower.endswith(".csv"):
+        from ...mining.csv_import import read_csv
+        log = read_csv(path)
+    elif lower.endswith(".txt"):
+        log = EventLog.from_simple_log(parse_simple_log(path.read_text(encoding="utf-8")), path.stem)
+    else:
+        from ...mining.xes import read_xes
+        log = read_xes(path)
+    flow.note(f"{path.name}: {len(log)} cases, {log.event_count} events, "
+              f"classifier {log.default_classifier().name}")
+    return log
+
+
+@box(name="Typed log", group="Input")
+def typed_log(text: str = "[<a,b,c,d>^3, <a,c,b,d>^2, <a,e,d>]", name: str = "Typed log") -> EventLog:
+    """A log typed in the course notation: ``[<a,b,c,d>^3, <a,c,b,d>^2, <a,e,d>]``."""
+    return EventLog.from_simple_log(parse_simple_log(text), name)
+
+
+@box(name="Open net", group="Input")
+def open_net(file: Path) -> PetriNet:
+    """Opens a Petri net from the folder: a PNML file, or a net drawn in the editor."""
+    from ...mining.pnml import read_pnml
+    net = read_pnml(_resolve(file))
+    flow.note(f"{Path(file).name}: {net.summary()}")
+    return net
+
+
+@box(name="Open coloured net", group="Input")
+def open_cpn(file: Path) -> CPNet:
+    """Opens a coloured Petri net (a CPN Tools ``.cpn`` file)."""
+    from ...io.cpn_reader import read_cpn
+    net = read_cpn(str(_resolve(file)))
+    if net.errors:
+        raise ValueError("The model does not compile: " + "; ".join(str(e) for e in net.errors[:3]))
+    return net
+
+
+@box(name="Open transition system", group="Input")
+def open_transition_system(file: Path) -> TransitionSystem:
+    """Opens a transition system typed as ``s0 -a-> s1, s0 -b-> s2`` (a ``ts.txt`` file)."""
+    path = _resolve(file)
+    return parse_transition_system(path.read_text(encoding="utf-8"), path.stem)
+
+
+@box(name="Open dataset", group="Input")
+def open_dataset(name: Literal["BPI Challenge 2012", "BPI Challenge 2013 incidents", "BPI Challenge 2017",
+                               "BPI Challenge 2019", "BPI Challenge 2020 domestic declarations",
+                               "Sepsis cases", "Road traffic fine management", "Hospital billing"]
+                 = "Sepsis cases") -> EventLog:
+    """A standard public log by name, fetched once into a shared cache and
+    checked against its fingerprint, so the same name means the same bytes
+    in every workflow and every paper (see ``openprocess datasets``)."""
+    from ..datasets import info, open_dataset as fetch_and_read
+    entry = info(name)
+    log = fetch_and_read(name)
+    flow.note(f"{entry.name}: {entry.citation or entry.page}")
+    flow.note(f"sha256 {log.attributes.get('openprocess:sha256', '')[:16]}… · {len(log)} cases, {log.event_count} events")
+    return log
+
+
+@box(name="Simulate log", group="Input")
+def simulate_log(net: PetriNet, cases: int = 200, noise: float = 0.0, seed: int = 0,
+                 max_length: int = 200) -> EventLog:
+    """Plays the net out into a log, then adds noise: with probability
+    *noise* a case loses one event or has two neighbouring events swapped.
+    The seed makes it repeatable.
+
+    cases: how many cases to generate
+    noise: the chance that a case is damaged (0 keeps the log clean)
+    seed: the random seed, recorded in the workflow file
+    """
+    result = play_out(net, traces=cases, max_length=max_length, seed=seed,
+                      name=f"Simulation of {net.name}")
+    rng = random.Random(seed * 7919 + 17)
+    damaged = 0
+    for trace in result.log:
+        if noise > 0 and len(trace.events) > 1 and rng.random() < noise:
+            events = trace.events
+            j = rng.randrange(1, len(events))
+            if rng.random() < 0.5:
+                del events[j]
+            elif j < len(events) - 1:
+                events[j], events[j + 1] = events[j + 1], events[j]
+            else:
+                events[j - 1], events[j] = events[j], events[j - 1]
+            trace.attributes["openprocess:noise"] = "yes"
+            damaged += 1
+    flow.note(f"{result.completed} runs completed, {result.deadlocked} deadlocked, "
+              f"{result.cut_off} cut off at {max_length} steps; {damaged} cases damaged by noise")
+    return result.log

openprocess/flow/boxes/output.py

@@ -0,0 +1,52 @@
+"""Output boxes: save a result into the folder, next to the workflow."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from ... import flow
+from ...mining.log import EventLog
+from ...mining.petrinet import PetriNet
+from ..box import box
+from ..types import Figure, Table
+
+
+def _target(file: str) -> Path:
+    path = Path(file)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+@box(name="Save as PNML", group="Output")
+def save_pnml(model: PetriNet, file: str = "model.pnml") -> None:
+    """Writes the model as PNML (ProM, WoPeD and PM4Py read it)."""
+    from ...mining.pnml import write_pnml
+    write_pnml(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``)."""
+    path = _target(file)
+    if path.suffix.lower() == ".csv":
+        from ...mining.csv_import import write_csv
+        write_csv(log, path)
+    else:
+        from ...mining.xes import write_xes
+        write_xes(log, path)
+    flow.note(f"Wrote {file}: {len(log)} cases")
+
+
+@box(name="Save table", group="Output")
+def save_table(table: Table, file: str = "table.csv") -> None:
+    """Writes a table as CSV."""
+    table.to_csv(_target(file))
+    flow.note(f"Wrote {file}: {len(table)} rows")
+
+
+@box(name="Save figure", group="Output")
+def save_figure(figure: Figure, file: str = "figure.svg") -> None:
+    """Writes a figure as SVG or PNG, by the file's extension."""
+    figure.save(_target(file))
+    flow.note(f"Wrote {file}")