strobe 0.0.1__py3-none-any.whl

strobe/__init__.py

@@ -0,0 +1,26 @@
+try:
+    from strobe._version import __version__
+except ImportError:
+    __version__ = "0.0.1.dev0"
+
+from strobe.analysis import (
+    activity_statistics,
+    check_conformance,
+    discover_dfg,
+    discover_process_model,
+    throughput_times,
+)
+from strobe.instrumentation import EventLog, StrobePlugin
+from strobe.visualization import launch_dashboard
+
+__all__ = [
+    "__version__",
+    "StrobePlugin",
+    "EventLog",
+    "discover_dfg",
+    "discover_process_model",
+    "check_conformance",
+    "throughput_times",
+    "activity_statistics",
+    "launch_dashboard",
+]

strobe/_version.py

@@ -0,0 +1,34 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
+else:
+    VERSION_TUPLE = object
+    COMMIT_ID = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
+
+__version__ = version = '0.0.1'
+__version_tuple__ = version_tuple = (0, 0, 1)
+
+__commit_id__ = commit_id = None

strobe/analysis/__init__.py

@@ -0,0 +1,11 @@
+from .conformance import check_conformance
+from .discovery import discover_dfg, discover_process_model
+from .performance import activity_statistics, throughput_times
+
+__all__ = [
+    "discover_dfg",
+    "discover_process_model",
+    "check_conformance",
+    "throughput_times",
+    "activity_statistics",
+]

strobe/analysis/conformance.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+import pandas as pd
+import pm4py
+
+
+def check_conformance(
+    df: pd.DataFrame,
+    net,
+    initial_marking,
+    final_marking,
+) -> dict[str, float]:
+    """Run token-based replay conformance checking.
+
+    Parameters
+    ----------
+    df:
+        pm4py-formatted event log DataFrame.
+    net, initial_marking, final_marking:
+        Petri net model (e.g. from :func:`~strobe.analysis.discover_process_model`).
+
+    Returns
+    -------
+    dict with keys ``fitness``, ``precision``, ``generalization``, ``simplicity``.
+    """
+    fitness = pm4py.fitness_token_based_replay(df, net, initial_marking, final_marking)
+    precision = pm4py.precision_token_based_replay(
+        df, net, initial_marking, final_marking
+    )
+    generalization = pm4py.generalization_tbr(df, net, initial_marking, final_marking)
+    simplicity = pm4py.simplicity_petri_net(net, initial_marking, final_marking)
+
+    return {
+        "fitness": fitness.get("average_trace_fitness", float("nan")),
+        "precision": float(precision),
+        "generalization": float(generalization),
+        "simplicity": float(simplicity),
+    }

strobe/analysis/discovery.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from typing import Literal
+
+import pandas as pd
+import pm4py
+
+
+def discover_dfg(
+    df: pd.DataFrame,
+) -> tuple[dict, dict, dict]:
+    """Discover a directly-follows graph from *df*.
+
+    Returns
+    -------
+    (dfg, start_activities, end_activities)
+    """
+    return pm4py.discover_dfg(df)
+
+
+def discover_process_model(
+    df: pd.DataFrame,
+    algorithm: Literal["inductive", "alpha"] = "inductive",
+    noise_threshold: float = 0.0,
+) -> tuple:
+    """Discover a Petri net from *df*.
+
+    Parameters
+    ----------
+    algorithm:
+        ``"inductive"`` uses the Inductive Miner (default);
+        ``"alpha"`` uses the Alpha Miner.
+    noise_threshold:
+        Noise filtering threshold passed to the Inductive Miner (ignored for
+        the Alpha Miner).
+
+    Returns
+    -------
+    (net, initial_marking, final_marking)
+    """
+    if algorithm == "inductive":
+        return pm4py.discover_petri_net_inductive(df, noise_threshold=noise_threshold)
+    elif algorithm == "alpha":
+        return pm4py.discover_petri_net_alpha(df)
+    else:
+        raise ValueError(
+            f"Unknown algorithm: {algorithm!r}. Choose 'inductive' or 'alpha'."
+        )

strobe/analysis/performance.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+import pandas as pd
+
+from strobe.instrumentation.event_log import EventLog
+
+
+def throughput_times(df: pd.DataFrame) -> pd.Series:
+    """Compute per-case wall-clock duration (last event − first event).
+
+    Returns
+    -------
+    pd.Series indexed by case ID, values are :class:`~datetime.timedelta`.
+    """
+    ts_col = EventLog.TIMESTAMP
+    case_col = EventLog.CASE_ID
+
+    grouped = df.groupby(case_col)[ts_col]
+    return grouped.max() - grouped.min()
+
+
+def activity_statistics(df: pd.DataFrame) -> pd.DataFrame:
+    """Compute per-activity execution statistics using ``strobe:duration_s``.
+
+    Columns: ``count``, ``mean_duration_s``, ``min_duration_s``, ``max_duration_s``.
+
+    If the ``strobe:duration_s`` column is absent, duration columns contain
+    ``NaN``.
+    """
+    activity_col = EventLog.ACTIVITY
+    duration_col = "strobe:duration_s"
+
+    if duration_col not in df.columns:
+        counts = df.groupby(activity_col).size().rename("count")
+        stats = counts.to_frame()
+        stats["mean_duration_s"] = float("nan")
+        stats["min_duration_s"] = float("nan")
+        stats["max_duration_s"] = float("nan")
+        return stats.reset_index()
+
+    stats = (
+        df.groupby(activity_col)[duration_col]
+        .agg(
+            count="count",
+            mean_duration_s="mean",
+            min_duration_s="min",
+            max_duration_s="max",
+        )
+        .reset_index()
+    )
+    stats = stats.rename(columns={activity_col: "activity"})
+    return stats

strobe/instrumentation/__init__.py

@@ -0,0 +1,4 @@
+from .event_log import EventLog
+from .plugin import StrobePlugin
+
+__all__ = ["EventLog", "StrobePlugin"]

strobe/instrumentation/event_log.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+from datetime import datetime
+from pathlib import Path
+
+import pandas as pd
+import pm4py
+
+
+class EventLog:
+    """Internal accumulator that stores events and exports to XES / DataFrame."""
+
+    CASE_ID = "case:concept:name"
+    ACTIVITY = "concept:name"
+    TIMESTAMP = "time:timestamp"
+
+    def __init__(self) -> None:
+        self._events: list[dict] = []
+
+    def add_event(
+        self,
+        case_id: str,
+        activity: str,
+        timestamp: datetime,
+        **attrs,
+    ) -> None:
+        """Append one event to the log.
+
+        Extra keyword arguments are stored under a ``strobe:`` namespace prefix
+        so they survive XES round-trips.
+        """
+        event: dict = {
+            self.CASE_ID: case_id,
+            self.ACTIVITY: activity,
+            self.TIMESTAMP: timestamp,
+        }
+        for key, value in attrs.items():
+            namespaced = key if key.startswith("strobe:") else f"strobe:{key}"
+            event[namespaced] = value
+        self._events.append(event)
+
+    def to_dataframe(self) -> pd.DataFrame:
+        """Return a pm4py-compatible DataFrame."""
+        if not self._events:
+            df = pd.DataFrame(columns=[self.CASE_ID, self.ACTIVITY, self.TIMESTAMP])
+        else:
+            df = pd.DataFrame(self._events)
+        df = pm4py.format_dataframe(
+            df,
+            case_id=self.CASE_ID,
+            activity_key=self.ACTIVITY,
+            timestamp_key=self.TIMESTAMP,
+        )
+        return df
+
+    def write_xes(self, path: str | Path) -> None:
+        """Export the log to an XES file at *path*."""
+        pm4py.write_xes(self.to_dataframe(), str(path))
+
+    @classmethod
+    def read_xes(cls, path: str | Path) -> "EventLog":
+        """Load an XES file and return a new :class:`EventLog`."""
+        df = pm4py.read_xes(str(path))
+        log = cls()
+        for _, row in df.iterrows():
+            case_id = row[cls.CASE_ID]
+            activity = row[cls.ACTIVITY]
+            timestamp = row[cls.TIMESTAMP]
+            extra = {
+                k: v
+                for k, v in row.items()
+                if k not in (cls.CASE_ID, cls.ACTIVITY, cls.TIMESTAMP)
+                and not k.startswith("@@")
+            }
+            log.add_event(case_id, activity, timestamp, **extra)
+        return log

strobe/instrumentation/plugin.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+import json
+from datetime import datetime, timezone
+
+import pandas as pd
+from google.adk.plugins.base_plugin import BasePlugin
+
+from .event_log import EventLog
+
+
+class StrobePlugin(BasePlugin):
+    """ADK plugin that captures tool, LLM, and agent callbacks as XES events."""
+
+    def __init__(self) -> None:
+        super().__init__(name="strobe")
+        self._log = EventLog()
+        self._pending: dict[tuple, datetime] = {}
+
+    # ── Tool callbacks ──────────────────────────────────────────────────────
+
+    async def before_tool_callback(self, tool, tool_args, tool_context):
+        key = (tool_context.invocation_id, tool_context.function_call_id)
+        self._pending[key] = datetime.now(timezone.utc)
+
+    async def after_tool_callback(self, tool, tool_args, tool_context, tool_response):
+        key = (tool_context.invocation_id, tool_context.function_call_id)
+        start = self._pending.pop(key, None)
+        now = datetime.now(timezone.utc)
+        duration = (now - start).total_seconds() if start is not None else None
+
+        attrs: dict = {}
+        if start is not None:
+            attrs["start_time"] = start.isoformat()
+        if duration is not None:
+            attrs["duration_s"] = duration
+        try:
+            attrs["tool_args"] = json.dumps(tool_args)
+        except (TypeError, ValueError):
+            attrs["tool_args"] = str(tool_args)
+        try:
+            attrs["tool_result"] = json.dumps(tool_response)
+        except (TypeError, ValueError):
+            attrs["tool_result"] = str(tool_response)
+
+        self._log.add_event(
+            case_id=tool_context.invocation_id,
+            activity=f"tool:{tool.name}",
+            timestamp=now,
+            **attrs,
+        )
+
+    # ── LLM callbacks ───────────────────────────────────────────────────────
+
+    async def before_model_callback(self, callback_context, llm_request):
+        key = (callback_context.invocation_id, "llm")
+        self._pending[key] = datetime.now(timezone.utc)
+
+    async def after_model_callback(self, callback_context, llm_response):
+        key = (callback_context.invocation_id, "llm")
+        start = self._pending.pop(key, None)
+        now = datetime.now(timezone.utc)
+        duration = (now - start).total_seconds() if start is not None else None
+
+        model_name = getattr(llm_response, "model", None) or getattr(
+            llm_response, "model_version", None
+        )
+
+        attrs: dict = {}
+        if start is not None:
+            attrs["start_time"] = start.isoformat()
+        if duration is not None:
+            attrs["duration_s"] = duration
+        if model_name:
+            attrs["model_name"] = str(model_name)
+
+        usage = getattr(llm_response, "usage_metadata", None)
+        if usage is not None:
+            input_tokens = getattr(usage, "prompt_token_count", None)
+            output_tokens = getattr(usage, "candidates_token_count", None)
+            if input_tokens is not None:
+                attrs["input_tokens"] = input_tokens
+            if output_tokens is not None:
+                attrs["output_tokens"] = output_tokens
+
+        activity = f"llm:{model_name}" if model_name else "llm"
+        self._log.add_event(
+            case_id=callback_context.invocation_id,
+            activity=activity,
+            timestamp=now,
+            **attrs,
+        )
+
+    # ── Agent callbacks ──────────────────────────────────────────────────────
+
+    async def before_agent_callback(self, callback_context):
+        agent_name = getattr(callback_context, "agent_name", "unknown")
+        key = (callback_context.invocation_id, f"agent:{agent_name}")
+        self._pending[key] = datetime.now(timezone.utc)
+
+    async def after_agent_callback(self, callback_context):
+        agent_name = getattr(callback_context, "agent_name", "unknown")
+        key = (callback_context.invocation_id, f"agent:{agent_name}")
+        start = self._pending.pop(key, None)
+        now = datetime.now(timezone.utc)
+        duration = (now - start).total_seconds() if start is not None else None
+
+        attrs: dict = {}
+        if start is not None:
+            attrs["start_time"] = start.isoformat()
+        if duration is not None:
+            attrs["duration_s"] = duration
+
+        self._log.add_event(
+            case_id=callback_context.invocation_id,
+            activity=f"agent:{agent_name}",
+            timestamp=now,
+            **attrs,
+        )
+
+    # ── Export ───────────────────────────────────────────────────────────────
+
+    @property
+    def event_log(self) -> EventLog:
+        return self._log
+
+    def to_dataframe(self) -> pd.DataFrame:
+        return self._log.to_dataframe()
+
+    def write_xes(self, path) -> None:
+        self._log.write_xes(path)

strobe/visualization/__init__.py

@@ -0,0 +1,17 @@
+from .app import launch_dashboard
+from .plots import (
+    plot_activity_statistics,
+    plot_conformance,
+    plot_dfg,
+    plot_petri_net,
+    plot_throughput_times,
+)
+
+__all__ = [
+    "launch_dashboard",
+    "plot_dfg",
+    "plot_petri_net",
+    "plot_throughput_times",
+    "plot_activity_statistics",
+    "plot_conformance",
+]

strobe/visualization/app.py

@@ -0,0 +1,174 @@
+"""Streamlit dashboard for strobe event-log analysis.
+
+Run directly::
+
+    streamlit run strobe/visualization/app.py
+
+Or from Python via :func:`launch_dashboard`.
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import tempfile
+from pathlib import Path
+
+
+def launch_dashboard(xes_path: str | Path | None = None) -> subprocess.Popen:
+    """Launch the Streamlit dashboard in a subprocess.
+
+    Parameters
+    ----------
+    xes_path:
+        Optional path to a ``.xes`` file. When provided, the dashboard will
+        load it automatically via the ``STROBE_XES_PATH`` environment variable.
+
+    Returns
+    -------
+    The :class:`subprocess.Popen` handle for the launched process.
+    """
+    env = os.environ.copy()
+    if xes_path is not None:
+        env["STROBE_XES_PATH"] = str(xes_path)
+
+    app_file = Path(__file__).resolve()
+    return subprocess.Popen(
+        ["streamlit", "run", str(app_file)],
+        env=env,
+    )
+
+
+# ---------------------------------------------------------------------------
+# Everything below only runs when this file is executed by Streamlit.
+# ---------------------------------------------------------------------------
+
+
+def _run_app() -> None:  # pragma: no cover
+    from typing import Literal
+
+    import pandas as pd
+    import pm4py
+    import streamlit as st
+
+    from strobe.analysis.conformance import check_conformance
+    from strobe.analysis.discovery import discover_dfg, discover_process_model
+    from strobe.analysis.performance import activity_statistics, throughput_times
+    from strobe.visualization.plots import (
+        plot_activity_statistics,
+        plot_conformance,
+        plot_dfg,
+        plot_petri_net,
+        plot_throughput_times,
+    )
+
+    st.set_page_config(page_title="strobe dashboard", layout="wide")
+    st.title("strobe — Process Mining Dashboard")
+
+    # ------------------------------------------------------------------
+    # Sidebar: data source + discovery options
+    # ------------------------------------------------------------------
+    with st.sidebar:
+        st.header("Data")
+        env_path = os.environ.get("STROBE_XES_PATH")
+        uploaded = st.file_uploader("Upload XES file", type=["xes"])
+
+        xes_source: bytes | None = None
+        if uploaded is not None:
+            xes_source = uploaded.read()
+        elif env_path:
+            st.info(f"Using env: {env_path}")
+            xes_source = Path(env_path).read_bytes()
+
+        st.header("Discovery")
+        algorithm: Literal["inductive", "alpha"] = st.selectbox(
+            "Algorithm", ["inductive", "alpha"]
+        )
+        noise_threshold = 0.0
+        if algorithm == "inductive":
+            noise_threshold = st.slider(
+                "Noise threshold", min_value=0.0, max_value=1.0, value=0.0, step=0.05
+            )
+
+    if xes_source is None:
+        st.info("Upload a XES file in the sidebar to begin.")
+        st.stop()
+
+    # ------------------------------------------------------------------
+    # Load + format event log (cached)
+    # ------------------------------------------------------------------
+    @st.cache_data(show_spinner="Loading event log…")
+    def _load_df(raw: bytes, algo: str, noise: float) -> pd.DataFrame:
+        with tempfile.NamedTemporaryFile(suffix=".xes", delete=False) as f:
+            f.write(raw)
+            tmp_path = f.name
+        df = pm4py.read_xes(tmp_path)
+        return df
+
+    @st.cache_data(show_spinner="Discovering process model…")
+    def _discover(raw: bytes, algo: Literal["inductive", "alpha"], noise: float):
+        df = _load_df(raw, algo, noise)
+        dfg_result = discover_dfg(df)
+        model_result = discover_process_model(df, algorithm=algo, noise_threshold=noise)
+        return df, dfg_result, model_result
+
+    df, (dfg, start_acts, end_acts), (net, im, fm) = _discover(
+        xes_source, algorithm, noise_threshold
+    )
+
+    # ------------------------------------------------------------------
+    # Tabs
+    # ------------------------------------------------------------------
+    tab_model, tab_throughput, tab_activities, tab_conformance = st.tabs(
+        ["Process model", "Throughput", "Activities", "Conformance"]
+    )
+
+    with tab_model:
+        col1, col2 = st.columns(2)
+        with col1:
+            st.subheader("Directly-Follows Graph")
+            st.plotly_chart(
+                plot_dfg(dfg, start_acts, end_acts), use_container_width=True
+            )
+        with col2:
+            st.subheader("Petri Net")
+            st.plotly_chart(plot_petri_net(net, im, fm), use_container_width=True)
+
+    with tab_throughput:
+        st.subheader("Per-case throughput times")
+        tt = throughput_times(df)
+        st.plotly_chart(plot_throughput_times(tt), use_container_width=True)
+        st.dataframe(
+            tt.rename("duration").dt.total_seconds().rename("duration_s").reset_index()
+        )
+
+    with tab_activities:
+        st.subheader("Activity statistics")
+        stats = activity_statistics(df)
+        st.plotly_chart(plot_activity_statistics(stats), use_container_width=True)
+        st.dataframe(stats)
+
+    with tab_conformance:
+        st.subheader("Conformance scores")
+
+        @st.cache_data(show_spinner="Running conformance check…")
+        def _conformance(
+            raw: bytes, algo: Literal["inductive", "alpha"], noise: float
+        ) -> dict[str, float]:
+            df2, _, (net2, im2, fm2) = _discover(raw, algo, noise)
+            return check_conformance(df2, net2, im2, fm2)
+
+        scores = _conformance(xes_source, algorithm, noise_threshold)
+        st.plotly_chart(plot_conformance(scores), use_container_width=True)
+
+        col_fit, col_prec, col_gen, col_simp = st.columns(4)
+        col_fit.metric("Fitness", f"{scores['fitness']:.3f}")
+        col_prec.metric("Precision", f"{scores['precision']:.3f}")
+        col_gen.metric("Generalization", f"{scores['generalization']:.3f}")
+        col_simp.metric("Simplicity", f"{scores['simplicity']:.3f}")
+
+
+if __name__ == "__main__" or os.environ.get(
+    "STREAMLIT_SCRIPT_RUN_CTX"
+):  # pragma: no cover
+    _run_app()

strobe/visualization/plots.py

@@ -0,0 +1,339 @@
+"""Pure Plotly figure factories — no Streamlit dependency."""
+
+from __future__ import annotations
+
+from collections import defaultdict, deque
+
+import networkx as nx
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+
+
+def _hierarchical_layout(G: nx.DiGraph, spacing: float = 2.0) -> dict:
+    """Compute hierarchical (top-down flowchart) positions for a directed graph.
+
+    Uses BFS from source nodes to assign layers, arranging them top-to-bottom
+    for a flowchart-like appearance. Falls back to spring layout if no sources found.
+    """
+    # Assign nodes to layers using BFS from sources
+    in_degree = dict(G.in_degree())
+    sources = [n for n in G.nodes() if in_degree[n] == 0]
+
+    if not sources:
+        # No sources found (all nodes in cycles), use spring layout fallback
+        return nx.spring_layout(G, seed=42)
+
+    layer_assignment = {}
+    queue = deque(sources)
+
+    for source in sources:
+        layer_assignment[source] = 0
+
+    while queue:
+        node = queue.popleft()
+
+        for successor in G.successors(node):
+            # Assign to max layer of predecessors + 1
+            max_pred_layer = max(
+                (layer_assignment.get(pred, -1) for pred in G.predecessors(successor)),
+                default=-1,
+            )
+            new_layer = max_pred_layer + 1
+            layer_assignment[successor] = max(
+                layer_assignment.get(successor, -1), new_layer
+            )
+
+            if (
+                successor not in layer_assignment
+                or layer_assignment[successor] == new_layer
+            ):
+                queue.append(successor)
+
+    # Group nodes by layer
+    layers_dict = defaultdict(list)
+    for node, layer in layer_assignment.items():
+        layers_dict[layer].append(node)
+
+    # Compute positions: layers go top-to-bottom, nodes spread left-right
+    pos = {}
+    max_layer = max(layers_dict.keys()) if layers_dict else 0
+
+    for layer, nodes in sorted(layers_dict.items()):
+        y = max_layer - layer  # top-down: layer 0 at top
+        num_nodes = len(nodes)
+        for i, node in enumerate(nodes):
+            # Spread nodes horizontally
+            x = (i - num_nodes / 2) * spacing
+            pos[node] = (x, y)
+
+    return pos
+
+
+def plot_dfg(dfg: dict, start_activities: dict, end_activities: dict) -> go.Figure:
+    """Return an interactive DFG figure.
+
+    Edge width and colour encode frequency. Hover shows the frequency count.
+    """
+    G = nx.DiGraph()
+    for (src, tgt), freq in dfg.items():
+        G.add_edge(src, tgt, freq=freq)
+    for act in list(start_activities) + list(end_activities):
+        if act not in G:
+            G.add_node(act)
+
+    pos = _hierarchical_layout(G)
+
+    max_freq = max((d["freq"] for _, _, d in G.edges(data=True)), default=1)
+
+    edge_traces = []
+    for src, tgt, data in G.edges(data=True):
+        freq = data["freq"]
+        x0, y0 = pos[src]
+        x1, y1 = pos[tgt]
+        width = 1 + 5 * freq / max_freq
+        color = f"rgba(31,119,180,{0.3 + 0.7 * freq / max_freq:.2f})"
+        edge_traces.append(
+            go.Scatter(
+                x=[x0, x1, None],
+                y=[y0, y1, None],
+                mode="lines",
+                line=dict(width=width, color=color),
+                hoverinfo="text",
+                text=f"{src} → {tgt}: {freq}",
+                showlegend=False,
+            )
+        )
+
+    node_x, node_y, node_text, node_hover = [], [], [], []
+    node_colors = []
+    for node in G.nodes():
+        x, y = pos[node]
+        node_x.append(x)
+        node_y.append(y)
+        node_text.append(node)
+        if node in start_activities and node in end_activities:
+            label = f"{node}<br>(start+end)"
+            node_colors.append("purple")
+        elif node in start_activities:
+            label = f"{node}<br>(start)"
+            node_colors.append("green")
+        elif node in end_activities:
+            label = f"{node}<br>(end)"
+            node_colors.append("red")
+        else:
+            label = node
+            node_colors.append("steelblue")
+        node_hover.append(label)
+
+    node_trace = go.Scatter(
+        x=node_x,
+        y=node_y,
+        mode="markers+text",
+        text=node_text,
+        textposition="top center",
+        hovertext=node_hover,
+        hoverinfo="text",
+        marker=dict(size=20, color=node_colors, line=dict(width=2, color="white")),
+        showlegend=False,
+    )
+
+    fig = go.Figure(data=edge_traces + [node_trace])
+    fig.update_layout(
+        title="Directly-Follows Graph",
+        xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+        yaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+        plot_bgcolor="white",
+        margin=dict(l=20, r=20, t=40, b=20),
+    )
+    return fig
+
+
+def plot_petri_net(net, initial_marking, final_marking) -> go.Figure:
+    """Return an interactive Petri net figure.
+
+    Places are rendered as circles; transitions as squares.
+    Source/sink places are highlighted in green/red.
+    """
+    G = nx.DiGraph()
+    place_ids = {}
+    trans_ids = {}
+
+    source_places = set(initial_marking.keys())
+    sink_places = set(final_marking.keys())
+
+    for place in net.places:
+        node_id = f"p:{place.name}"
+        place_ids[place] = node_id
+        G.add_node(node_id, kind="place", name=place.name)
+
+    for trans in net.transitions:
+        node_id = f"t:{trans.name}"
+        trans_ids[trans] = node_id
+        label = trans.label if trans.label else f"τ({trans.name})"
+        G.add_node(node_id, kind="transition", name=label)
+
+    for arc in net.arcs:
+        src = arc.source
+        tgt = arc.target
+        src_id = place_ids.get(src) or trans_ids.get(src)
+        tgt_id = place_ids.get(tgt) or trans_ids.get(tgt)
+        if src_id and tgt_id:
+            G.add_edge(src_id, tgt_id)
+
+    pos = _hierarchical_layout(G)
+
+    edge_traces = []
+    for src_id, tgt_id in G.edges():
+        x0, y0 = pos[src_id]
+        x1, y1 = pos[tgt_id]
+        edge_traces.append(
+            go.Scatter(
+                x=[x0, x1, None],
+                y=[y0, y1, None],
+                mode="lines",
+                line=dict(width=1.5, color="gray"),
+                hoverinfo="none",
+                showlegend=False,
+            )
+        )
+
+    place_x, place_y, place_text, place_colors = [], [], [], []
+    for place, node_id in place_ids.items():
+        x, y = pos[node_id]
+        place_x.append(x)
+        place_y.append(y)
+        place_text.append(place.name)
+        if place in source_places and place in sink_places:
+            place_colors.append("purple")
+        elif place in source_places:
+            place_colors.append("green")
+        elif place in sink_places:
+            place_colors.append("red")
+        else:
+            place_colors.append("steelblue")
+
+    place_trace = go.Scatter(
+        x=place_x,
+        y=place_y,
+        mode="markers+text",
+        text=place_text,
+        textposition="top center",
+        hoverinfo="text",
+        marker=dict(
+            symbol="circle",
+            size=18,
+            color=place_colors,
+            line=dict(width=2, color="white"),
+        ),
+        name="Places",
+    )
+
+    trans_x, trans_y, trans_text = [], [], []
+    for trans, node_id in trans_ids.items():
+        x, y = pos[node_id]
+        trans_x.append(x)
+        trans_y.append(y)
+        label = trans.label if trans.label else f"τ({trans.name})"
+        trans_text.append(label)
+
+    trans_trace = go.Scatter(
+        x=trans_x,
+        y=trans_y,
+        mode="markers+text",
+        text=trans_text,
+        textposition="top center",
+        hoverinfo="text",
+        marker=dict(
+            symbol="square",
+            size=16,
+            color="orange",
+            line=dict(width=2, color="white"),
+        ),
+        name="Transitions",
+    )
+
+    fig = go.Figure(data=edge_traces + [place_trace, trans_trace])
+    fig.update_layout(
+        title="Petri Net",
+        xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+        yaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+        plot_bgcolor="white",
+        margin=dict(l=20, r=20, t=40, b=20),
+    )
+    return fig
+
+
+def plot_throughput_times(series: pd.Series) -> go.Figure:
+    """Return a violin + box plot of per-case throughput times (in seconds)."""
+    durations_s = series.dt.total_seconds()
+    fig = px.violin(
+        y=durations_s,
+        box=True,
+        points="all",
+        labels={"y": "Duration (s)"},
+        title="Throughput Times",
+    )
+    fig.update_layout(margin=dict(l=20, r=20, t=40, b=20))
+    return fig
+
+
+def plot_activity_statistics(df: pd.DataFrame) -> go.Figure:
+    """Return a dual-axis grouped bar chart: count (left) + mean duration (right)."""
+    fig = make_subplots(specs=[[{"secondary_y": True}]])
+
+    activities = df["activity"] if "activity" in df.columns else df.iloc[:, 0]
+
+    fig.add_trace(
+        go.Bar(
+            x=activities,
+            y=df["count"],
+            name="Count",
+            marker_color="steelblue",
+        ),
+        secondary_y=False,
+    )
+    fig.add_trace(
+        go.Bar(
+            x=activities,
+            y=df["mean_duration_s"],
+            name="Mean duration (s)",
+            marker_color="darkorange",
+        ),
+        secondary_y=True,
+    )
+
+    fig.update_layout(
+        title="Activity Statistics",
+        barmode="group",
+        margin=dict(l=20, r=20, t=40, b=20),
+    )
+    fig.update_yaxes(title_text="Count", secondary_y=False)
+    fig.update_yaxes(title_text="Mean duration (s)", secondary_y=True)
+    return fig
+
+
+def plot_conformance(scores: dict[str, float]) -> go.Figure:
+    """Return a horizontal bar chart of the four conformance metrics."""
+    metrics = ["fitness", "precision", "generalization", "simplicity"]
+    values = [scores.get(m, 0.0) for m in metrics]
+    colors = [f"rgba({int(255 * (1 - v))},{int(200 * v)},80,0.85)" for v in values]
+
+    fig = go.Figure(
+        go.Bar(
+            x=values,
+            y=metrics,
+            orientation="h",
+            marker=dict(color=colors),
+            text=[f"{v:.3f}" for v in values],
+            textposition="outside",
+            hovertemplate="%{y}: %{x:.3f}<extra></extra>",
+        )
+    )
+    fig.update_layout(
+        title="Conformance Scores",
+        xaxis=dict(range=[0, 1.1], title="Score"),
+        margin=dict(l=20, r=60, t=40, b=20),
+    )
+    return fig

strobe-0.0.1.dist-info/METADATA

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: strobe
+Version: 0.0.1
+Summary: Process Mining & Agent Instrumentation for AI Agent Frameworks
+Requires-Python: >=3.13
+Requires-Dist: google-adk>=1.0.0
+Requires-Dist: pandas>=2.0.0
+Requires-Dist: plotly>=5.18.0
+Requires-Dist: pm4py>=2.7.0
+Requires-Dist: streamlit>=1.32.0

strobe-0.0.1.dist-info/RECORD

@@ -0,0 +1,15 @@
+strobe/__init__.py,sha256=32IUlfzGttYEFQ2kSGvL4MFcj84jEL0luUspHwPav4I,577
+strobe/_version.py,sha256=qf6R-J7-UyuABBo8c0HgaquJ8bejVbf07HodXgwAwgQ,704
+strobe/analysis/__init__.py,sha256=ZwFhPegU6eCDUGvCkWHEb-v_v3sAvyzqhoHMuOmhsrc,307
+strobe/analysis/conformance.py,sha256=bCNSCmd1p0uus-7yqAu0UwaDe9cNqm-dd9Bo93ixEwk,1148
+strobe/analysis/discovery.py,sha256=fIAjBXEmLl7FaJnmOTSQaPdplJuPqWYBLexdQe1UOP8,1203
+strobe/analysis/performance.py,sha256=TPE1TdVeeXgyQDuAaEaR0MWETIkx92ZmDo2bpSckZ2M,1536
+strobe/instrumentation/__init__.py,sha256=0oF5981MhcrlzOiAu-r1C2A9UfFAAA3E3pyx-sQmv4s,105
+strobe/instrumentation/event_log.py,sha256=kopYmAFbUt6rCeXQr7NjoQW2BGxh4Ov1kLa5xwb2hAQ,2328
+strobe/instrumentation/plugin.py,sha256=F1yeOQlatGVGhEqTbJ80hGq8mk9Vc92XYACS_NCbdGU,5236
+strobe/visualization/__init__.py,sha256=TcmYuPkRanbKUP1OlSaZ6qOxpqrbHyUj2IQCwPCK6ws,332
+strobe/visualization/app.py,sha256=9pG3cSbz-IO5KzWOrFr-HHMK1T1R-XC0SyuRytmCCGg,6118
+strobe/visualization/plots.py,sha256=MbXK2qAY02yA0uU_f9aBgGvn3ZKtV5uvPjuzslfnV4g,10504
+strobe-0.0.1.dist-info/METADATA,sha256=a-LwOF591VoUwyQxKtwR3mOM19srNVabrxTG1ptddUc,299
+strobe-0.0.1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+strobe-0.0.1.dist-info/RECORD,,

strobe-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any