agentloop-profiler 0.1.0__py3-none-any.whl

dashboard/streamlit_compat.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from functools import wraps
+from importlib.metadata import PackageNotFoundError, version
+from typing import Any
+
+_STRETCH_WIDTH_MIN_VERSION = (1, 49)
+
+
+def _streamlit_version() -> tuple[int, int]:
+    try:
+        raw = version("streamlit")
+    except PackageNotFoundError:
+        return (0, 0)
+    parts = raw.split(".")
+    try:
+        return (int(parts[0]), int(parts[1]))
+    except (IndexError, ValueError):
+        return (0, 0)
+
+
+def _normalize_dataframe_kwargs(kwargs: dict[str, Any]) -> dict[str, Any]:
+    """Translate the modern stretch width to the older supported API."""
+    normalized = dict(kwargs)
+    if normalized.get("width") == "stretch":
+        normalized["width"] = None
+        normalized["use_container_width"] = True
+    return normalized
+
+
+def install_dataframe_width_compat() -> None:
+    """Keep the dashboard compatible with the declared Streamlit 1.34+ floor.
+
+    Streamlit 1.49 added string dataframe widths such as ``"stretch"``. Older
+    supported releases use ``use_container_width=True`` instead. The dashboard
+    package installs this adapter only for Streamlit versions below 1.49 so the
+    modern API remains untouched on current releases.
+    """
+    if _streamlit_version() >= _STRETCH_WIDTH_MIN_VERSION:
+        return
+
+    import streamlit as st
+    from streamlit.delta_generator import DeltaGenerator
+
+    original_method = DeltaGenerator.dataframe
+    if getattr(original_method, "__agentloop_width_compat__", False):
+        return
+
+    @wraps(original_method)
+    def dataframe_method(self, *args, **kwargs):
+        return original_method(self, *args, **_normalize_dataframe_kwargs(kwargs))
+
+    dataframe_method.__agentloop_width_compat__ = True
+    DeltaGenerator.dataframe = dataframe_method
+
+    original_module_function = st.dataframe
+
+    @wraps(original_module_function)
+    def dataframe(*args, **kwargs):
+        return original_module_function(*args, **_normalize_dataframe_kwargs(kwargs))
+
+    dataframe.__agentloop_width_compat__ = True
+    st.dataframe = dataframe

dashboard/trace_upload.py

@@ -0,0 +1,57 @@
+"""Decode an uploaded trace file into an :class:`AgentTrace`, or say what to fix.
+
+The Ingest page reads an uploaded file on every Streamlit rerun, so the three ways a
+file can be unusable -- not UTF-8, not JSON, not a trace -- arrive as three exceptions
+from three layers, each with its own idea of what a useful message looks like. Doing
+that translation inline in ``app.py`` put the only copy of it inside a page that can
+only be exercised through ``AppTest``. It lives here so it can be unit tested directly.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from agentloop.schema import TraceValidationError
+from agentloop.tracer import AgentTrace
+
+
+class TraceUploadError(ValueError):
+    """An uploaded trace the operator can fix, carrying the reason it was rejected.
+
+    ``str(exc)`` is the operator-facing clause and nothing else -- no prefix, no
+    trailing period -- so a caller can place it in whatever sentence its surface
+    needs. It subclasses :class:`ValueError`, matching
+    :class:`~agentloop.schema.TraceValidationError`.
+    """
+
+
+def parse_uploaded_trace(payload: bytes) -> AgentTrace:
+    """Return the trace in ``payload``, or raise :class:`TraceUploadError` saying why not.
+
+    A parse position is reported only for malformed JSON, which is the only failure
+    that has one: a decode error is located by byte offset, and a schema violation is
+    located by field path.
+    """
+
+    try:
+        text = payload.decode("utf-8")
+    except UnicodeDecodeError as exc:
+        raise TraceUploadError(
+            f"the file is not UTF-8 text ({exc.reason} at byte {exc.start})"
+        ) from exc
+
+    try:
+        document: Any = json.loads(text)
+    except json.JSONDecodeError as exc:
+        raise TraceUploadError(f"{exc.msg} at line {exc.lineno}, column {exc.colno}") from exc
+
+    if not isinstance(document, dict):
+        # json.loads happily returns a list, string or number, and from_dict would
+        # then fail on subscripting rather than on the schema.
+        raise TraceUploadError(f"a trace must be a JSON object, not {type(document).__name__}")
+
+    try:
+        return AgentTrace.from_dict(document)
+    except TraceValidationError as exc:
+        raise TraceUploadError(str(exc)) from exc

dashboard/value_view.py

@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+import json
+from typing import Any
+
+
+def money(value: float | None, decimals: int = 2) -> str:
+    return "unavailable" if value is None else f"${float(value):,.{decimals}f}"
+
+
+def seconds(ms: float) -> str:
+    return f"{float(ms) / 1000:,.2f}s"
+
+
+def percentage(value: float | None, decimals: int = 1) -> str:
+    return "unavailable" if value is None else f"{float(value):.{decimals}f}%"
+
+
+def _streamlit() -> Any:
+    try:
+        import streamlit as st
+    except ModuleNotFoundError as exc:
+        raise ModuleNotFoundError(
+            "Install dashboard support with: uv sync --locked --extra dashboard"
+        ) from exc
+    return st
+
+
+def assumption_inputs(prefix: str = "") -> tuple[int, float, float]:
+    st = _streamlit()
+    c1, c2, c3 = st.columns(3)
+    runs_per_month = c1.number_input(
+        "Runs per month",
+        min_value=0,
+        value=5000,
+        step=500,
+        key=f"{prefix}runs_per_month",
+    )
+    engineer_hourly_rate_usd = c2.number_input(
+        "Engineer hourly rate",
+        min_value=0.0,
+        value=150.0,
+        step=25.0,
+        key=f"{prefix}engineer_hourly_rate_usd",
+    )
+    incident_cost_usd = c3.number_input(
+        "Reliability event cost",
+        min_value=0.0,
+        value=500.0,
+        step=100.0,
+        key=f"{prefix}incident_cost_usd",
+    )
+    return int(runs_per_month), float(engineer_hourly_rate_usd), float(incident_cost_usd)
+
+
+def render_value_report(value: dict, *, show_download: bool = True) -> None:
+    st = _streamlit()
+    monthly = value["monthly_value"]
+    per_run = value["per_run"]
+    pricing = value.get("pricing", {})
+    reliability = value["reliability"]
+
+    st.subheader("Operational value")
+    c1, c2, c3, c4 = st.columns(4)
+    c1.metric("Monthly value", money(monthly["total_value_usd"]))
+    c2.metric("Cost savings / month", money(monthly["direct_model_cost_savings_usd"]))
+    c3.metric("Engineering hours saved", monthly["engineering_hours_saved"])
+    c4.metric("Latency hours saved", monthly["latency_hours_saved"])
+
+    c5, c6, c7, c8 = st.columns(4)
+    c5.metric("Latency saved / run", seconds(per_run["latency_savings_ms"]))
+    c6.metric("Cost saved / run", money(per_run["cost_savings_usd"], decimals=6))
+    c7.metric("Reliability risk", f"{reliability['risk_score']}/100")
+    c8.metric("High confidence fixes", reliability["high_confidence_fixes"])
+
+    st.subheader("Pricing scenario")
+    p1, p2, p3, p4 = st.columns(4)
+    p1.metric("Modeled tier", pricing.get("suggested_plan") or "unavailable")
+    p2.metric("Modeled price", money(pricing.get("suggested_monthly_price_usd", 0), decimals=0))
+    ratio = pricing.get("value_to_price_ratio")
+    p3.metric("Value / price", "n/a" if ratio is None else f"{ratio}x")
+    p4.metric("Monthly value", money(pricing.get("estimated_monthly_value_usd", 0)))
+
+    st.info(pricing.get("rationale", "No pricing rationale available."))
+
+    notes = pricing.get("scenario_notes", [])
+    if notes:
+        st.markdown("#### Scenario includes")
+        st.write("\n".join(f"- {note}" for note in notes))
+
+    st.subheader("Value summary")
+    st.write(value["value_summary"])
+
+    risks = reliability.get("top_risks", [])
+    if risks:
+        st.subheader("Top reliability risks")
+        st.write("\n".join(f"- {risk}" for risk in risks))
+
+    if show_download:
+        st.download_button(
+            "Download value report JSON",
+            data=json.dumps(value, indent=2),
+            file_name="agentloop_value_report.json",
+            mime="application/json",
+        )