usage-cli 0.29.32__py3-none-any.whl

agy_window_keeper.py

@@ -0,0 +1,185 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright (C) 2026 lollapalooza <https://github.com/aqua5230>
+#
+# Part of "usage". Free software licensed under the GNU Affero General Public
+# License v3.0 only; see the LICENSE file for full terms and the warranty disclaimer.
+
+"""Auto-open the next Antigravity 5-hour window."""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import shutil
+import subprocess
+import tempfile
+import threading
+import time
+from contextlib import suppress
+from pathlib import Path
+
+from menubar_agy import AgyRefreshResult
+from menubar_prefs import _agy_window_keeper_enabled
+
+logger = logging.getLogger(__name__)
+
+AGY_WINDOW_KEEPER_STATE_PATH = Path(
+    os.path.expanduser("~/.usage/agy_window_keeper.json")
+)
+PING_COOLDOWN_SECONDS = 5 * 3600
+PING_TIMEOUT_SECONDS = 180
+AGY_MODEL = "Gemini 3.5 Flash (Low)"
+_AGY_BIN_FALLBACKS = (
+    "~/.local/bin/agy",
+    "~/AppData/Local/agy/bin/agy.exe",
+)
+
+_lock = threading.Lock()
+_ping_in_flight = False
+
+
+def should_ping(
+    now: float,
+    enabled: bool,
+    last_ping_at: float | None,
+    remaining_percent: float | None,
+    stale: object | None,
+    fallback_projection: bool,
+    mock: bool,
+) -> bool:
+    """Return whether fresh quota data shows no active five-hour window.
+
+    At 100% remaining, the API reset time is a sliding placeholder, so it
+    cannot indicate an active window.
+    """
+    if not enabled or mock or fallback_projection or stale is not None:
+        return False
+    if remaining_percent is None or remaining_percent < 100.0:
+        return False
+    return last_ping_at is None or now - last_ping_at >= PING_COOLDOWN_SECONDS
+
+
+def _load_last_ping(path: Path | None = None) -> float | None:
+    state_path = AGY_WINDOW_KEEPER_STATE_PATH if path is None else path
+    if not state_path.exists():
+        return None
+    try:
+        data = json.loads(state_path.read_text(encoding="utf-8"))
+    except (OSError, UnicodeDecodeError, json.JSONDecodeError):
+        return None
+    if not isinstance(data, dict):
+        return None
+    value = data.get("last_ping_at")
+    if isinstance(value, bool) or not isinstance(value, int | float):
+        return None
+    return float(value)
+
+
+def _save_last_ping(ts: float, path: Path | None = None) -> None:
+    state_path = AGY_WINDOW_KEEPER_STATE_PATH if path is None else path
+    state_path.parent.mkdir(parents=True, exist_ok=True)
+    payload = json.dumps({"last_ping_at": ts}) + "\n"
+    tmp_path: str | None = None
+    try:
+        fd, tmp_path = tempfile.mkstemp(dir=state_path.parent, suffix=".tmp")
+        with os.fdopen(fd, "w", encoding="utf-8") as handle:
+            handle.write(payload)
+        os.replace(tmp_path, state_path)
+        tmp_path = None
+    except OSError:
+        _debug_log("agy-window-keeper state write failed", exc_info=True)
+    finally:
+        if tmp_path and os.path.exists(tmp_path):
+            with suppress(OSError):
+                os.unlink(tmp_path)
+
+
+def _resolve_agy_bin() -> str | None:
+    found = shutil.which("agy")
+    if found:
+        return found
+    for candidate in _AGY_BIN_FALLBACKS:
+        resolved = os.path.expanduser(candidate)
+        if os.path.isfile(resolved) and os.access(resolved, os.X_OK):
+            return resolved
+    return None
+
+
+def _try_acquire() -> bool:
+    global _ping_in_flight
+    with _lock:
+        if _ping_in_flight:
+            return False
+        _ping_in_flight = True
+        return True
+
+
+def _release() -> None:
+    global _ping_in_flight
+    with _lock:
+        _ping_in_flight = False
+
+
+def _run_agy_ping(agy_bin: str) -> None:
+    subprocess.run(  # noqa: S603 - resolved local Antigravity CLI
+        [agy_bin, "-p", "ok", "--model", AGY_MODEL],
+        stdin=subprocess.DEVNULL,
+        capture_output=True,
+        encoding="utf-8",
+        errors="replace",
+        timeout=PING_TIMEOUT_SECONDS,
+        cwd=os.path.expanduser("~"),
+        check=False,
+    )
+
+
+def _ping_worker(started_at: float) -> None:
+    try:
+        agy_bin = _resolve_agy_bin()
+        if agy_bin is None:
+            _debug_log("agy-window-keeper: agy binary not found, skipping ping")
+            return
+        _run_agy_ping(agy_bin)
+        _debug_log(f"agy-window-keeper: ping completed (started_at={started_at})")
+    except subprocess.TimeoutExpired:
+        _debug_log(f"agy-window-keeper: ping timed out after {PING_TIMEOUT_SECONDS}s")
+    except Exception:
+        _debug_log("agy-window-keeper: ping failed", exc_info=True)
+    finally:
+        _release()
+
+
+def maybe_ping(result: AgyRefreshResult, mock: bool) -> None:
+    """Read preferences and state, then dispatch a background ping if eligible."""
+    if mock:
+        return
+    enabled = _agy_window_keeper_enabled()
+    if not enabled:
+        return
+    projection = result.projection
+    five_hour = projection.five_hour if projection is not None else None
+    now = time.time()
+    last_ping_at = _load_last_ping()
+    if not should_ping(
+        now=now,
+        enabled=enabled,
+        last_ping_at=last_ping_at,
+        remaining_percent=(
+            five_hour.remaining_percent if five_hour is not None else None
+        ),
+        stale=projection.stale if projection is not None else None,
+        fallback_projection=projection is None,
+        mock=mock,
+    ):
+        return
+    if not _try_acquire():
+        return
+    # Stamp dispatch even on failure to avoid retrying every refresh.
+    _save_last_ping(now)
+    threading.Thread(target=_ping_worker, args=(now,), daemon=True).start()
+
+
+def _debug_log(message: str, *, exc_info: bool = False) -> None:
+    if os.environ.get("USAGE_DEBUG") == "1":
+        logger.warning(message, exc_info=exc_info)

analyzer/__init__.py

@@ -0,0 +1,5 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright (C) 2026 lollapalooza <https://github.com/aqua5230>
+#
+# Part of "usage". Free software licensed under the GNU Affero General Public
+# License v3.0 only; see the LICENSE file for full terms and the warranty disclaimer.

analyzer/aggregator.py

@@ -0,0 +1,139 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright (C) 2026 lollapalooza <https://github.com/aqua5230>
+#
+# Part of "usage". Free software licensed under the GNU Affero General Public
+# License v3.0 only; see the LICENSE file for full terms and the warranty disclaimer.
+
+from collections import defaultdict
+
+from adapters.types import DailyStats, MonthlyStats, SessionStats, UsageEntry, WeeklyStats
+from pricing import calculate_cost
+
+
+def aggregate_daily(entries: list[UsageEntry]) -> list[DailyStats]:
+    by_date: dict[str, DailyStats] = {}
+    sessions_by_date: dict[str, set[str]] = defaultdict(set)
+
+    for e in entries:
+        date_str = e.timestamp.astimezone().strftime("%Y-%m-%d")
+        if date_str not in by_date:
+            by_date[date_str] = DailyStats(date=date_str)
+        s = by_date[date_str]
+        cost = calculate_cost(e)
+        s.input_tokens += e.input_tokens
+        s.output_tokens += e.output_tokens
+        s.cache_creation_tokens += e.cache_creation_tokens
+        s.cache_read_tokens += e.cache_read_tokens
+        s.total_tokens += e.total_tokens
+        s.cost_usd += cost
+        s.message_count += e.message_count
+        s.models[e.model] = s.models.get(e.model, 0) + e.total_tokens
+        sessions_by_date[date_str].add(e.session_id)
+
+    for date_str, sessions in sessions_by_date.items():
+        by_date[date_str].session_count = len(sessions)
+
+    return sorted(by_date.values(), key=lambda s: s.date)
+
+
+def aggregate_monthly(entries: list[UsageEntry]) -> list[MonthlyStats]:
+    by_month: dict[str, MonthlyStats] = {}
+    sessions_by_month: dict[str, set[str]] = defaultdict(set)
+
+    for e in entries:
+        month_str = e.timestamp.astimezone().strftime("%Y-%m")
+        if month_str not in by_month:
+            by_month[month_str] = MonthlyStats(month=month_str)
+        s = by_month[month_str]
+        cost = calculate_cost(e)
+        s.input_tokens += e.input_tokens
+        s.output_tokens += e.output_tokens
+        s.cache_creation_tokens += e.cache_creation_tokens
+        s.cache_read_tokens += e.cache_read_tokens
+        s.total_tokens += e.total_tokens
+        s.cost_usd += cost
+        s.message_count += e.message_count
+        s.models[e.model] = s.models.get(e.model, 0) + e.total_tokens
+        sessions_by_month[month_str].add(e.session_id)
+
+    for month_str, sessions in sessions_by_month.items():
+        by_month[month_str].session_count = len(sessions)
+
+    return sorted(by_month.values(), key=lambda s: s.month)
+
+
+def aggregate_weekly(entries: list[UsageEntry]) -> list[WeeklyStats]:
+    from datetime import timedelta
+
+    by_week: dict[str, WeeklyStats] = {}
+    sessions_by_week: dict[str, set[str]] = defaultdict(set)
+
+    for e in entries:
+        local_ts = e.timestamp.astimezone()
+        monday = local_ts.date() - timedelta(days=local_ts.weekday())
+        sunday = monday + timedelta(days=6)
+        week_key = monday.isoformat()
+        if week_key not in by_week:
+            by_week[week_key] = WeeklyStats(
+                week=week_key,
+                week_start=monday.strftime("%m-%d"),
+                week_end=sunday.strftime("%m-%d"),
+            )
+        s = by_week[week_key]
+        cost = calculate_cost(e)
+        s.input_tokens += e.input_tokens
+        s.output_tokens += e.output_tokens
+        s.cache_creation_tokens += e.cache_creation_tokens
+        s.cache_read_tokens += e.cache_read_tokens
+        s.total_tokens += e.total_tokens
+        s.cost_usd += cost
+        s.message_count += e.message_count
+        s.models[e.model] = s.models.get(e.model, 0) + e.total_tokens
+        sessions_by_week[week_key].add(e.session_id)
+
+    for week_key, sessions in sessions_by_week.items():
+        by_week[week_key].session_count = len(sessions)
+
+    return sorted(by_week.values(), key=lambda s: s.week)
+
+
+def aggregate_sessions(entries: list[UsageEntry]) -> list[SessionStats]:
+    by_session: dict[str, list[UsageEntry]] = defaultdict(list)
+
+    for e in entries:
+        by_session[e.session_id].append(e)
+
+    sessions: list[SessionStats] = []
+    for session_id, session_entries in by_session.items():
+        session_entries.sort(key=lambda e: e.timestamp)
+        first = session_entries[0]
+        last = session_entries[-1]
+        duration = (last.timestamp - first.timestamp).total_seconds() / 60
+
+        models: dict[str, int] = defaultdict(int)
+        for e in session_entries:
+            models[e.model] += e.total_tokens
+        primary_model = max(models, key=lambda model: models[model]) if models else "unknown"
+
+        s = SessionStats(
+            session_id=session_id,
+            project=first.project,
+            model=primary_model,
+            start_time=first.timestamp,
+            end_time=last.timestamp,
+            duration_minutes=round(duration, 1),
+        )
+        for e in session_entries:
+            cost = calculate_cost(e)
+            s.input_tokens += e.input_tokens
+            s.output_tokens += e.output_tokens
+            s.cache_creation_tokens += e.cache_creation_tokens
+            s.cache_read_tokens += e.cache_read_tokens
+            s.total_tokens += e.total_tokens
+            s.cost_usd += cost
+            s.message_count += e.message_count
+
+        sessions.append(s)
+
+    sessions.sort(key=lambda s: s.start_time, reverse=True)
+    return sessions

analyzer/blocks.py

@@ -0,0 +1,80 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+# Copyright (C) 2026 lollapalooza <https://github.com/aqua5230>
+#
+# Part of "usage". Free software licensed under the GNU Affero General Public
+# License v3.0 only; see the LICENSE file for full terms and the warranty disclaimer.
+
+from collections.abc import Sequence
+from datetime import datetime, timedelta, timezone
+
+from adapters.types import DailyStats, P90Limits, SessionBlock, UsageEntry
+from pricing import calculate_cost
+
+BLOCK_DURATION = timedelta(hours=5)
+
+
+def analyze_blocks(entries: list[UsageEntry]) -> list[SessionBlock]:
+    if not entries:
+        return []
+
+    sorted_entries = sorted(entries, key=lambda e: e.timestamp)
+    blocks: list[SessionBlock] = []
+    current_block: SessionBlock | None = None
+
+    for entry in sorted_entries:
+        if current_block is None or entry.timestamp >= current_block.end_time:
+            if current_block and entry.timestamp >= current_block.end_time:
+                gap_duration = entry.timestamp - current_block.end_time
+                if gap_duration > timedelta(minutes=5):
+                    gap = SessionBlock(
+                        start_time=current_block.end_time,
+                        end_time=entry.timestamp,
+                        is_gap=True,
+                    )
+                    blocks.append(gap)
+
+            current_block = SessionBlock(
+                start_time=entry.timestamp,
+                end_time=entry.timestamp + BLOCK_DURATION,
+            )
+            blocks.append(current_block)
+
+        cost = calculate_cost(entry)
+        current_block.entries.append(entry)
+        current_block.input_tokens += entry.input_tokens
+        current_block.output_tokens += entry.output_tokens
+        current_block.cache_creation_tokens += entry.cache_creation_tokens
+        current_block.cache_read_tokens += entry.cache_read_tokens
+        current_block.total_tokens += entry.total_tokens
+        current_block.cost_usd += cost
+
+    now = datetime.now(timezone.utc)
+    for block in blocks:
+        if block.is_gap:
+            continue
+        if block.end_time > now and block.entries:
+            block.is_active = True
+            elapsed = (now - block.start_time).total_seconds() / 60
+            if elapsed > 0:
+                block.burn_rate = block.total_tokens / elapsed
+
+    return blocks
+
+
+def calculate_p90(daily_stats: list[DailyStats]) -> P90Limits:
+    if len(daily_stats) < 3:
+        return P90Limits()
+
+    token_values = sorted(d.total_tokens for d in daily_stats)
+    cost_values = sorted(d.cost_usd for d in daily_stats)
+    msg_values = sorted(d.message_count for d in daily_stats)
+
+    def p90(values: Sequence[float]) -> float:
+        idx = int(len(values) * 0.9)
+        return values[min(idx, len(values) - 1)]
+
+    return P90Limits(
+        token_limit=int(p90(token_values)),
+        cost_limit=round(p90(cost_values), 2),
+        message_limit=int(p90(msg_values)),
+    )