generic-ml-cache-cli 0.6.0__tar.gz → 0.7.0__tar.gz

{generic_ml_cache_cli-0.6.0 → generic_ml_cache_cli-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: generic-ml-cache-cli
-Version: 0.6.0
+Version: 0.7.0
 Summary: Terminal UI for generic-ml-cache: the gmlcache command. A thin inbound driver over generic-ml-cache-core -- reads config, provides the data source, maps commands onto the core library.
 Project-URL: Homepage, https://github.com/danielslobozian/generic-ml-cache
 Project-URL: Repository, https://github.com/danielslobozian/generic-ml-cache
@@ -24,7 +24,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Utilities
 Requires-Python: >=3.9
 Requires-Dist: argcomplete<4,>=3
-Requires-Dist: generic-ml-cache-core>=0.6.0
+Requires-Dist: generic-ml-cache-core>=0.7.0
 Provides-Extra: dev
 Requires-Dist: coverage>=7; extra == 'dev'
 Requires-Dist: pytest-cov; extra == 'dev'

{generic_ml_cache_cli-0.6.0 → generic_ml_cache_cli-0.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "generic-ml-cache-cli"
-version = "0.6.0"
+version = "0.7.0"
 description = "Terminal UI for generic-ml-cache: the gmlcache command. A thin inbound driver over generic-ml-cache-core -- reads config, provides the data source, maps commands onto the core library."
 readme = "README.md"
 requires-python = ">=3.9"
@@ -25,7 +25,7 @@ classifiers = [
   "Programming Language :: Python :: 3.13",
   "Topic :: Utilities",
 ]
-dependencies = ["generic-ml-cache-core>=0.6.0", "argcomplete>=3,<4"]
+dependencies = ["generic-ml-cache-core>=0.7.0", "argcomplete>=3,<4"]
 
 [project.urls]
 Homepage = "https://github.com/danielslobozian/generic-ml-cache"

{generic_ml_cache_cli-0.6.0 → generic_ml_cache_cli-0.7.0}/src/generic_ml_cache_cli/cli.py

@@ -45,6 +45,7 @@ from generic_ml_cache_core.application.domain.model.run.cache_mode import CacheM
 from generic_ml_cache_core.application.domain.model.run.persistence_depth import PersistenceDepth
 from generic_ml_cache_core.application.domain.model.execution.execution_state import ExecutionState
 from generic_ml_cache_core.application.domain.model.execution.ml_execution import MlExecution
+from generic_ml_cache_core.application.usecase.session_report import build_session_report
 from generic_ml_cache_core.application.port.inbound.run_managed_local_execution_command import (
     RunManagedLocalExecutionCommand,
 )
@@ -896,45 +897,115 @@ def _cmd_session_start(args: argparse.Namespace) -> int:
     return 0
 
 
-#: events where a real client call ran (vs. HIT, which replayed, or an offline MISS).
-_EXECUTED_EVENTS = {"record", "run", "would_hit", "would_miss"}
+_TOKEN_BLOCKS = " ▏▎▍▌▋▊▉█"
+
+
+def _activity_bar(value: int, maxval: int, width: int = 10) -> str:
+    if maxval <= 0:
+        return " " * width
+    filled = value / maxval * width
+    full = int(filled)
+    bar = "█" * full + (_TOKEN_BLOCKS[int((filled - full) * 8)] if full < width else "")
+    return (bar + " " * width)[:width]
+
+
+def _comma(n: int) -> str:
+    return f"{n:,}"
+
+
+def _render_session_report(report) -> str:
+    lines = [f"session     : {report.session_id}"]
+    if report.span_start:
+        span = (
+            report.span_start
+            if report.day_count == 1
+            else f"{report.span_start} → {report.span_end}"
+        )
+        plural = "" if report.day_count == 1 else "s"
+        lines.append(f"span        : {span}  ({report.day_count} day{plural})")
+    lines.append(
+        f"invocations : {report.invocations}   "
+        f"executions : {report.executions}   hits : {report.hits}"
+    )
+    if report.unknown_usage:
+        lines.append(f"unknown     : {report.unknown_usage} execution(s) reported no usage")
+    if report.by_model:
+        lines.append("")
+        lines.append("by provider / model:")
+        for m in report.by_model:
+            lines.append(
+                f"  {m.client + ' / ' + m.model:<16} spent {_comma(m.spent_tokens):>9} tok"
+                f" (in {_comma(m.spent_input):>8} · out {_comma(m.spent_output):>7})"
+                f"   saved {_comma(m.saved_tokens):>9} tok   {m.executions} exec · {m.hits} hit"
+            )
+    if report.by_day:
+        lines.append("")
+        lines.append("by day (activity):")
+        maxinv = max(d.invocations for d in report.by_day)
+        for d in report.by_day:
+            lines.append(
+                f"  {d.day}  {_activity_bar(d.invocations, maxinv)}  {d.invocations:>3} calls"
+                f"   ({d.executions} exec · {d.hits} hit)"
+            )
+    return "\n".join(lines)
+
+
+def _session_report_json(report) -> dict:
+    return {
+        "session": report.session_id,
+        "invocations": report.invocations,
+        "executions": report.executions,
+        "hits": report.hits,
+        "unknown_usage": report.unknown_usage,
+        "span": {"start": report.span_start, "end": report.span_end, "days": report.day_count},
+        "by_model": [
+            {
+                "client": m.client,
+                "model": m.model,
+                "spent_input": m.spent_input,
+                "spent_output": m.spent_output,
+                "spent_tokens": m.spent_tokens,
+                "saved_tokens": m.saved_tokens,
+                "executions": m.executions,
+                "hits": m.hits,
+            }
+            for m in report.by_model
+        ],
+        "by_day": [
+            {
+                "day": d.day,
+                "invocations": d.invocations,
+                "executions": d.executions,
+                "hits": d.hits,
+            }
+            for d in report.by_day
+        ],
+    }
 
 
 def _cmd_session_report(args: argparse.Namespace) -> int:
     store_root = _store_root()
     if store_root is None:
         return 4
-    counts = build_use_cases(store_root).metrics.session_event_counts(args.session_id)
-    invocations = sum(counts.values())
-    executions = sum(n for event, n in counts.items() if event in _EXECUTED_EVENTS)
-    hits = counts.get("hit", 0)
+    wired = build_use_cases(store_root)
+    events = wired.metrics.session_events(args.session_id)
+    # Join each event's execution to its token usage (the current execution per key).
+    usage_by_key = {}
+    for key in {e.execution_key for e in events if e.execution_key}:
+        execution = wired.repository.find_current(key)
+        if execution is not None:
+            usage_by_key[key] = execution.token_usage
+    report = build_session_report(args.session_id, events, usage_by_key)
 
     if args.json:
         import json
 
-        print(
-            json.dumps(
-                {
-                    "session": args.session_id,
-                    "invocations": invocations,
-                    "executions": executions,
-                    "hits": hits,
-                    "events": counts,
-                },
-                indent=2,
-            )
-        )
+        print(json.dumps(_session_report_json(report), indent=2))
         return 0
-
-    if invocations == 0:
+    if report.invocations == 0:
         print(f"no events recorded for session {args.session_id!r}")
         return 0
-    print(f"session     : {args.session_id}")
-    print(f"invocations : {invocations}")
-    print(f"executions  : {executions}  (real client calls)")
-    print(f"hits        : {hits}  (served from cache)")
-    breakdown = ", ".join(f"{event}={counts[event]}" for event in sorted(counts))
-    print(f"events      : {breakdown}")
+    print(_render_session_report(report))
     return 0
 
 

{generic_ml_cache_cli-0.6.0 → generic_ml_cache_cli-0.7.0}/tests/test_session_cli.py

@@ -71,25 +71,39 @@ def test_session_report_rolls_up_invocations_executions_hits(capsys):
 
     assert main(["session", "report", "wf"]) == 0
     out = capsys.readouterr().out
-    assert "invocations : 2" in out
-    assert "executions  : 1" in out
-    assert "hits        : 1" in out
+    assert "invocations : 2   executions : 1   hits : 1" in out
+    assert "by provider / model:" in out and "fake / m1" in out
+    assert "by day (activity):" in out
+    # no dollars anywhere in the render (cost is a client-specific advisory estimate)
+    assert "$" not in out and "cost" not in out.lower()
 
 
 def test_session_report_json(capsys):
     import json
 
-    main(_RUN + ["--session", "wf"])
+    main(_RUN + ["--session", "wf"])  # one record (the fake client reports no usage)
     capsys.readouterr()
     assert main(["session", "report", "wf", "--json"]) == 0
-    data = json.loads(capsys.readouterr().out)
-    assert data == {
-        "session": "wf",
-        "invocations": 1,
-        "executions": 1,
-        "hits": 0,
-        "events": {"record": 1},
-    }
+    out = capsys.readouterr().out
+    assert "cost" not in out.lower() and "usd" not in out.lower() and "$" not in out
+    data = json.loads(out)
+    assert data["session"] == "wf"
+    assert (data["invocations"], data["executions"], data["hits"]) == (1, 1, 0)
+    assert data["unknown_usage"] == 1
+    assert data["span"]["days"] == 1
+    assert data["by_model"] == [
+        {
+            "client": "fake",
+            "model": "m1",
+            "spent_input": 0,
+            "spent_output": 0,
+            "spent_tokens": 0,
+            "saved_tokens": 0,
+            "executions": 1,
+            "hits": 0,
+        }
+    ]
+    assert len(data["by_day"]) == 1 and data["by_day"][0]["invocations"] == 1
 
 
 def test_session_report_unknown_session_is_clean(capsys):