aiuse 3.2.7__tar.gz → 3.2.8__tar.gz

{aiuse-3.2.7/src/aiuse.egg-info → aiuse-3.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiuse
-Version: 3.2.7
+Version: 3.2.8
 Summary: Aggregate AI subscription/API usage and flag use-it-or-lose-it allotments
 Author: djbclark
 License-Expression: MIT
@@ -258,6 +258,17 @@ guess:
 `aiuse --full` prints this exact table when a multi-account source cannot be
 matched safely. Explicit mappings take precedence over automatic normalization.
 
+Some vendors rate-limit quota probes. aiuse reads agy's (Antigravity's) quota
+at most once every 15 minutes across every aiuse process (CLI, LaunchAgent,
+`watch`, `serve`), reusing the last reading in between. Tune or disable it per
+provider, in seconds. See
+[Antigravity pools: query rate limit](docs/antigravity-pools.md#query-rate-limit-2026-10-05):
+
+```toml
+[query_min_interval]
+antigravity = 900 # 0 disables
+```
+
 ## Daily workflow
 
 ```bash

{aiuse-3.2.7 → aiuse-3.2.8}/README.md

@@ -217,6 +217,17 @@ guess:
 `aiuse --full` prints this exact table when a multi-account source cannot be
 matched safely. Explicit mappings take precedence over automatic normalization.
 
+Some vendors rate-limit quota probes. aiuse reads agy's (Antigravity's) quota
+at most once every 15 minutes across every aiuse process (CLI, LaunchAgent,
+`watch`, `serve`), reusing the last reading in between. Tune or disable it per
+provider, in seconds. See
+[Antigravity pools: query rate limit](docs/antigravity-pools.md#query-rate-limit-2026-10-05):
+
+```toml
+[query_min_interval]
+antigravity = 900 # 0 disables
+```
+
 ## Daily workflow
 
 ```bash

{aiuse-3.2.7 → aiuse-3.2.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aiuse"
-version = "3.2.7"
+version = "3.2.8"
 description = "Aggregate AI subscription/API usage and flag use-it-or-lose-it allotments"
 readme = "README.md"
 requires-python = ">=3.11"

{aiuse-3.2.7 → aiuse-3.2.8}/src/aiuse/__init__.py

@@ -1,3 +1,3 @@
 """Aggregate provider quotas and flag use-it-or-lose-it allotments."""
 
-__version__ = "3.2.7"
+__version__ = "3.2.8"

{aiuse-3.2.7 → aiuse-3.2.8}/src/aiuse/collectors/codexbar.py

@@ -21,6 +21,7 @@ from aiuse.models import coerce_float as _f
 from aiuse.models import coerce_int as _int_or_none
 
 from .base import CollectorError, run_json, which
+from .throttle import QueryGate
 
 # Providers that are typically pure prepaid / API balance (not use-or-lose monthly)
 PREPAID_HINTS = {
@@ -107,6 +108,7 @@ def collect_codexbar(
     providers: str | list[str] | None = "enabled",
     timeout: float = 45.0,
     discovery_timeout: float | None = None,
+    min_intervals: dict[str, float] | None = None,
 ) -> list[AccountUsage]:
     if not which("codexbar"):
         raise CollectorError("codexbar not found on PATH")
@@ -124,8 +126,11 @@ def collect_codexbar(
 
     accounts: list[AccountUsage] = []
     errors: list[str] = []
+    reuse_notes: dict[str, str] = {}
 
-    for provider_arg, outcome in _query_providers(provider_list, timeout=timeout):
+    for provider_arg, outcome in _query_providers(
+        provider_list, timeout=timeout, min_intervals=min_intervals, reuse_notes=reuse_notes
+    ):
         if isinstance(outcome, CollectorError):
             name = provider_arg or "enabled providers"
             errors.append(f"{name}: {outcome}")
@@ -137,7 +142,10 @@ def collect_codexbar(
                     row_provider = str(row.get("provider", "")).strip().lower()
                     if row_provider and row_provider != provider_arg.lower():
                         continue
-                accounts.append(_from_row(row))
+                account = _from_row(row)
+                if provider_arg is not None and provider_arg in reuse_notes:
+                    account.notes = list(account.notes) + [reuse_notes[provider_arg]]
+                accounts.append(account)
                 zen = _opencode_zen_from_row(row)
                 if zen is not None:
                     accounts.append(zen)
@@ -202,6 +210,8 @@ def _query_providers(
     provider_list: list[str | None],
     *,
     timeout: float = 45.0,
+    min_intervals: dict[str, float] | None = None,
+    reuse_notes: dict[str, str] | None = None,
 ) -> list[tuple[str | None, Any]]:
     """Run one `codexbar usage` call per entry in provider_list, concurrently.
 
@@ -210,22 +220,51 @@ def _query_providers(
     error ordering stays deterministic. Duplicate entries are queried once —
     querying the same provider twice concurrently is never useful and would
     otherwise race on which duplicate's outcome survives.
+
+    Providers listed in ``min_intervals`` go through a cross-process
+    :class:`QueryGate`; when one is throttled its last stored payload is
+    returned instead and ``reuse_notes[provider]`` explains why.
     """
     deduped: list[str | None] = list(dict.fromkeys(provider_list))
+    intervals = min_intervals or {}
+    notes = reuse_notes if reuse_notes is not None else {}
+
+    def run(provider_arg: str | None) -> Any:
+        if provider_arg is not None and intervals.get(provider_arg.lower(), 0) > 0:
+            return _query_provider_gated(provider_arg, intervals[provider_arg.lower()], timeout=timeout, notes=notes)
+        return _query_provider(provider_arg, timeout=timeout)
+
     if len(deduped) <= 1:
-        return [(provider_arg, _query_provider(provider_arg, timeout=timeout)) for provider_arg in deduped]
+        return [(provider_arg, run(provider_arg)) for provider_arg in deduped]
 
     workers = min(len(deduped), _MAX_CONCURRENT_PROVIDER_QUERIES)
     with ThreadPoolExecutor(max_workers=workers) as pool:
-        futures = {
-            pool.submit(_query_provider, provider_arg, timeout=timeout): provider_arg for provider_arg in deduped
-        }
+        futures = {pool.submit(run, provider_arg): provider_arg for provider_arg in deduped}
         outcomes: dict[str | None, Any] = {}
         for future in as_completed(futures):
             outcomes[futures[future]] = future.result()
     return [(provider_arg, outcomes[provider_arg]) for provider_arg in deduped]
 
 
+def _query_provider_gated(
+    provider_arg: str,
+    min_interval: float,
+    *,
+    timeout: float,
+    notes: dict[str, str],
+) -> Any:
+    provider = provider_arg.lower()
+    with QueryGate(provider, min_interval=min_interval, wait=timeout + 15.0) as gate:
+        if gate.allowed:
+            outcome = _query_provider(provider_arg, timeout=timeout)
+            gate.record("codexbar", outcome)
+            return outcome
+        reused_at = gate.reused_from("codexbar")
+        if reused_at is not None:
+            notes[provider_arg] = f"{gate.describe()}; reused CodexBar's result from {reused_at.isoformat()}."
+        return gate.reuse("codexbar")
+
+
 def _query_provider(provider_arg: str | None, *, timeout: float = 45.0) -> Any:
     # Omitting --provider asks CodexBar for its enabled-provider list and data
     # (only reached as a fallback if _discover_enabled_providers() fails).

{aiuse-3.2.7 → aiuse-3.2.8}/src/aiuse/collectors/openusage.py

@@ -15,6 +15,7 @@ import subprocess
 import urllib.error
 import urllib.parse
 import urllib.request
+from contextlib import ExitStack
 from typing import Any
 
 from aiuse.models import (
@@ -30,6 +31,7 @@ from aiuse.models import (
 )
 
 from .base import CollectorError, run_json, which
+from .throttle import QueryGate
 
 DEFAULT_OPENUSAGE_BASE = "http://127.0.0.1:6736"
 DEFAULT_HTTP_TIMEOUT = 30.0
@@ -96,13 +98,15 @@ def collect_openusage_ai(
     base_url: str = DEFAULT_OPENUSAGE_BASE,
     force_refresh: bool = True,
     try_launch_app: bool = True,
+    min_intervals: dict[str, float] | None = None,
 ) -> list[AccountUsage]:
     """Fetch OpenUsage limits via CLI first, then loopback HTTP."""
-    payload, via = _fetch_limits(
+    payload, via, throttle_note = _fetch_limits_gated(
         timeout=timeout,
         base_url=base_url,
         force_refresh=force_refresh,
         try_launch_app=try_launch_app,
+        min_intervals=min_intervals or {},
     )
     if not isinstance(payload, dict):
         raise CollectorError("OpenUsage returned non-object JSON")
@@ -120,7 +124,10 @@ def collect_openusage_ai(
     for provider_id, body in providers.items():
         if not isinstance(body, dict):
             continue
-        accounts.append(_from_provider(str(provider_id), body, via=via))
+        account = _from_provider(str(provider_id), body, via=via)
+        if throttle_note and account.provider in _gated_providers(min_intervals):
+            account.notes = list(account.notes) + [throttle_note]
+        accounts.append(account)
 
     errors = payload.get("errors") or []
     if errors and accounts:
@@ -142,6 +149,51 @@ def collect_openusage_ai(
     return accounts
 
 
+def _gated_providers(min_intervals: dict[str, float] | None) -> set[str]:
+    return {provider for provider, seconds in (min_intervals or {}).items() if seconds > 0}
+
+
+def _fetch_limits_gated(
+    *,
+    timeout: float,
+    base_url: str,
+    force_refresh: bool,
+    try_launch_app: bool,
+    min_intervals: dict[str, float],
+) -> tuple[dict[str, Any], str, str | None]:
+    """``_fetch_limits`` with ``--force`` withheld while any gated provider is throttled.
+
+    A forced CLI refresh makes OpenUsage re-query every provider it has enabled,
+    so it counts as a query of each gated provider that comes back in the
+    payload. Without ``--force`` OpenUsage serves its own cached reading.
+    """
+    gated = sorted(_gated_providers(min_intervals))
+    if not force_refresh or not gated or not which("openusage"):
+        payload, via = _fetch_limits(
+            timeout=timeout, base_url=base_url, force_refresh=force_refresh, try_launch_app=try_launch_app
+        )
+        return payload, via, None
+
+    with ExitStack() as stack:
+        gates = [
+            stack.enter_context(QueryGate(provider, min_interval=min_intervals[provider], wait=timeout + 15.0))
+            for provider in gated
+        ]
+        blocked = [gate for gate in gates if not gate.allowed]
+        payload, via = _fetch_limits(
+            timeout=timeout, base_url=base_url, force_refresh=not blocked, try_launch_app=try_launch_app
+        )
+        if blocked:
+            reasons = "; ".join(gate.describe() for gate in blocked)
+            return payload, via, f"OpenUsage refresh not forced: {reasons}."
+        if via == "cli":
+            returned = payload.get("providers") if isinstance(payload, dict) else None
+            for gate in gates:
+                if isinstance(returned, dict) and gate.provider in {str(k).lower() for k in returned}:
+                    gate.record("openusage_ai", store=False)
+        return payload, via, None
+
+
 def _fetch_limits(
     *,
     timeout: float,

{aiuse-3.2.7 → aiuse-3.2.8}/src/aiuse/collectors/runner.py

@@ -35,6 +35,7 @@ from .openrouter import collect_openrouter
 from .openusage import collect_openusage_ai
 from .openusage_sh import collect_openusage_sh
 from .qwencloud import collect_qwencloud
+from .throttle import min_intervals
 from .tokscale import collect_tokscale
 
 # Prefer earlier sources for *selection* (what drives the ladder). All live
@@ -95,6 +96,7 @@ def run_collectors(config: dict[str, Any] | None = None) -> Snapshot:
     config = config or {}
     collectors_cfg = config.get("collectors") or {}
     snapshot = Snapshot(collected_at=utcnow())
+    intervals = min_intervals(config)
 
     # Each collector shells out (or hits loopback) independently — run concurrently.
     # Correctness: long default timeouts; all enabled sources always queried.
@@ -114,6 +116,7 @@ def run_collectors(config: dict[str, Any] | None = None) -> Snapshot:
                     providers=providers,
                     timeout=codexbar_timeout,
                     discovery_timeout=discovery_timeout,
+                    min_intervals=intervals,
                 ),
             )
         )
@@ -144,6 +147,7 @@ def run_collectors(config: dict[str, Any] | None = None) -> Snapshot:
                     force_refresh=force,
                     try_launch_app=launch,
                     base_url=base,
+                    min_intervals=intervals,
                 ),
             )
         )

aiuse-3.2.8/src/aiuse/collectors/throttle.py

@@ -0,0 +1,197 @@
+"""Cross-process minimum interval between live quota queries for one provider.
+
+Some vendors punish a burst of quota probes with rate limits that also stop the
+user's real work: agy (antigravity) answers queries in quick succession with
+429s on every model. Every aiuse entry point — the CLI, the ``aiuse sample``
+LaunchAgent, ``aiuse watch``, ``aiuse serve`` — collects through the same
+collectors, and several can run at once, so the limit is enforced here through
+a locked state file per provider rather than inside any one process.
+
+While a provider is throttled, a collector reuses the payload it stored on its
+last allowed query (CodexBar rows carry their own ``updatedAt``, so the reused
+row reports its true age) or skips the part of its call that would reach the
+vendor (OpenUsage's ``--force``).
+"""
+
+from __future__ import annotations
+
+import fcntl
+import json
+import os
+import time
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Any
+
+from aiuse.analysis import history
+from aiuse.config import DEFAULT_QUERY_MIN_INTERVAL
+from aiuse.models import parse_dt, utcnow
+
+from .base import CollectorError
+
+
+def throttle_dir() -> Path:
+    return history.snapshot_dir().parent / "query-throttle"
+
+
+def min_intervals(config: dict[str, Any] | None) -> dict[str, float]:
+    """Provider -> minimum seconds between live queries (config over defaults)."""
+    table = dict(DEFAULT_QUERY_MIN_INTERVAL)
+    configured = (config or {}).get("query_min_interval")
+    if isinstance(configured, dict):
+        for provider, value in configured.items():
+            try:
+                table[str(provider).strip().lower()] = max(0.0, float(value))
+            except (TypeError, ValueError):
+                continue
+    return {provider: seconds for provider, seconds in table.items() if seconds > 0}
+
+
+def _format_duration(seconds: float) -> str:
+    seconds = max(0, int(round(seconds)))
+    if seconds < 60:
+        return f"{seconds}s"
+    minutes, secs = divmod(seconds, 60)
+    if minutes < 60:
+        return f"{minutes}m{secs:02d}s" if secs else f"{minutes}m"
+    hours, minutes = divmod(minutes, 60)
+    return f"{hours}h{minutes:02d}m"
+
+
+class QueryGate:
+    """Hold one provider's query lock and decide whether a live query may run.
+
+    Usage::
+
+        with QueryGate("antigravity", min_interval=900, wait=60) as gate:
+            if gate.allowed:
+                outcome = query()
+                gate.record("codexbar", outcome)
+            else:
+                outcome = gate.reuse("codexbar")
+
+    The lock is held for the whole block, so a second process arriving mid-query
+    waits (up to ``wait`` seconds) and then sees the fresh ``queried_at`` instead
+    of firing its own query. A process that cannot get the lock in time is
+    treated as throttled.
+    """
+
+    def __init__(
+        self,
+        provider: str,
+        *,
+        min_interval: float,
+        wait: float,
+        directory: Path | None = None,
+    ) -> None:
+        self.provider = provider
+        self.min_interval = float(min_interval)
+        self.wait = max(0.0, float(wait))
+        self.directory = directory if directory is not None else throttle_dir()
+        self.allowed = False
+        self.locked = False
+        self.state: dict[str, Any] = {}
+        self.now: datetime = utcnow()
+        self._lock_fd: int | None = None
+
+    @property
+    def _state_path(self) -> Path:
+        return self.directory / f"{self.provider}.json"
+
+    @property
+    def last_queried_at(self) -> datetime | None:
+        return parse_dt(self.state.get("queried_at"))
+
+    @property
+    def next_allowed_at(self) -> datetime | None:
+        last = self.last_queried_at
+        return None if last is None else last + timedelta(seconds=self.min_interval)
+
+    def __enter__(self) -> QueryGate:
+        self.directory.mkdir(parents=True, exist_ok=True)
+        self._lock_fd = os.open(self.directory / f"{self.provider}.lock", os.O_CREAT | os.O_RDWR, 0o600)
+        deadline = time.monotonic() + self.wait
+        while True:
+            try:
+                fcntl.flock(self._lock_fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+                self.locked = True
+                break
+            except BlockingIOError:
+                if time.monotonic() >= deadline:
+                    break
+                time.sleep(0.25)
+        self.state = self._read_state()
+        self.now = utcnow()
+        last = self.last_queried_at
+        self.allowed = self.locked and (
+            last is None or last > self.now or (self.now - last).total_seconds() >= self.min_interval
+        )
+        return self
+
+    def __exit__(self, *exc: object) -> None:
+        if self._lock_fd is not None:
+            if self.locked:
+                fcntl.flock(self._lock_fd, fcntl.LOCK_UN)
+            os.close(self._lock_fd)
+            self._lock_fd = None
+
+    def _read_state(self) -> dict[str, Any]:
+        try:
+            data = json.loads(self._state_path.read_text(encoding="utf-8"))
+        except (OSError, UnicodeDecodeError, json.JSONDecodeError):
+            return {}
+        return data if isinstance(data, dict) else {}
+
+    def record(self, source: str, outcome: Any = None, *, store: bool = True) -> None:
+        """Mark a live query by ``source`` as of now (after it ran); optionally keep its outcome."""
+        if not self.locked:
+            return
+        at = utcnow()
+        self.state["queried_at"] = at.isoformat()
+        self.state["queried_by"] = source
+        if store:
+            entry: dict[str, Any] = {"fetched_at": at.isoformat()}
+            if isinstance(outcome, BaseException):
+                entry["error"] = str(outcome)
+            else:
+                entry["payload"] = outcome
+            self.state.setdefault("sources", {})[source] = entry
+        tmp = self._state_path.with_suffix(f".json.{os.getpid()}.tmp")
+        try:
+            tmp.write_text(json.dumps(self.state, default=str), encoding="utf-8")
+            os.replace(tmp, self._state_path)
+        except OSError:
+            tmp.unlink(missing_ok=True)
+
+    def describe(self) -> str:
+        """Human-readable reason a query was skipped (for notes and errors)."""
+        interval = _format_duration(self.min_interval)
+        last = self.last_queried_at
+        if not self.locked and last is None:
+            return f"{self.provider} quota query skipped: another aiuse process is querying it"
+        if last is None:
+            return f"{self.provider} quota queried at most every {interval}"
+        age = _format_duration((self.now - last).total_seconds())
+        nxt = self.next_allowed_at
+        remaining = _format_duration((nxt - self.now).total_seconds()) if nxt else "0s"
+        by = self.state.get("queried_by") or "aiuse"
+        return (
+            f"{self.provider} quota queried at most every {interval} "
+            f"(last query {age} ago via {by}; next allowed in {remaining})"
+        )
+
+    def reuse(self, source: str) -> Any:
+        """The payload ``source`` stored on its last allowed query, else a CollectorError."""
+        entry = (self.state.get("sources") or {}).get(source)
+        if isinstance(entry, dict):
+            if "payload" in entry:
+                return entry["payload"]
+            if entry.get("error"):
+                return CollectorError(f"{entry['error']} [{self.describe()}]")
+        return CollectorError(self.describe())
+
+    def reused_from(self, source: str) -> datetime | None:
+        entry = (self.state.get("sources") or {}).get(source)
+        if isinstance(entry, dict) and "payload" in entry:
+            return parse_dt(entry.get("fetched_at"))
+        return None

{aiuse-3.2.7 → aiuse-3.2.8}/src/aiuse/config.py

@@ -24,6 +24,10 @@ CSWAP_TIMEOUT = 90.0
 # `openusage-sh export` polls every configured provider. A quiet run is about
 # 30s, and the same export often crosses 45s while the other collectors run.
 OPENUSAGE_SH_TIMEOUT = 90.0
+# Minimum seconds between live quota queries per provider, shared by every aiuse
+# process (collectors/throttle.py). agy answers probes in quick succession with
+# 429s on every model, so its quota is read at most once per 15 minutes.
+DEFAULT_QUERY_MIN_INTERVAL: dict[str, float] = {"antigravity": 900.0}
 
 DEFAULT_CONFIG: dict[str, Any] = {
     # Subprocess timeouts (seconds). ``default`` applies to any tool that does
@@ -226,6 +230,9 @@ DEFAULT_CONFIG: dict[str, Any] = {
         "qwencloud": {"enabled": True},
         "bailian": {"enabled": True},
     },
+    # Provider id -> minimum seconds between live quota queries, across all aiuse
+    # processes (CLI, `aiuse sample`, watch, serve). 0 disables the limit.
+    "query_min_interval": dict(DEFAULT_QUERY_MIN_INTERVAL),
     # Source-specific local account ids can be mapped to the account label used
     # by other collectors.  Normally this stays empty: runner.py automatically
     # resolves providers where every source has exactly one named account.
@@ -267,7 +274,17 @@ DEFAULT_CONFIG: dict[str, Any] = {
 
 # Top-level and nested keys recognized by the loader / doctor (unknown → warning).
 KNOWN_TOP_LEVEL_KEYS = frozenset(
-    {"timeouts", "analysis", "plans", "collectors", "account_aliases", "macos", "sampling", "attribution"}
+    {
+        "timeouts",
+        "analysis",
+        "plans",
+        "collectors",
+        "query_min_interval",
+        "account_aliases",
+        "macos",
+        "sampling",
+        "attribution",
+    }
 )
 KNOWN_TIMEOUT_KEYS = frozenset(
     {
@@ -446,6 +463,19 @@ def validate_config(config: dict[str, Any] | None) -> list[str]:
                 if ek not in KNOWN_COLLECTOR_ENTRY_KEYS:
                     issues.append(f"warning: unknown collectors.{name} key {ek!r}")
 
+    query_min_interval = cfg.get("query_min_interval")
+    if query_min_interval is not None and not isinstance(query_min_interval, dict):
+        issues.append("error: query_min_interval must be a provider -> seconds mapping")
+    elif isinstance(query_min_interval, dict):
+        for provider, value in query_min_interval.items():
+            try:
+                seconds = float(value)
+            except (TypeError, ValueError):
+                issues.append(f"error: query_min_interval.{provider} must be a number of seconds (got {value!r})")
+                continue
+            if seconds < 0:
+                issues.append(f"error: query_min_interval.{provider} must not be negative (got {seconds:g})")
+
     aliases = cfg.get("account_aliases")
     if aliases is not None and not isinstance(aliases, dict):
         issues.append("error: account_aliases must be a provider -> source -> account mapping")

{aiuse-3.2.7 → aiuse-3.2.8/src/aiuse.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiuse
-Version: 3.2.7
+Version: 3.2.8
 Summary: Aggregate AI subscription/API usage and flag use-it-or-lose-it allotments
 Author: djbclark
 License-Expression: MIT
@@ -258,6 +258,17 @@ guess:
 `aiuse --full` prints this exact table when a multi-account source cannot be
 matched safely. Explicit mappings take precedence over automatic normalization.
 
+Some vendors rate-limit quota probes. aiuse reads agy's (Antigravity's) quota
+at most once every 15 minutes across every aiuse process (CLI, LaunchAgent,
+`watch`, `serve`), reusing the last reading in between. Tune or disable it per
+provider, in seconds. See
+[Antigravity pools: query rate limit](docs/antigravity-pools.md#query-rate-limit-2026-10-05):
+
+```toml
+[query_min_interval]
+antigravity = 900 # 0 disables
+```
+
 ## Daily workflow
 
 ```bash

{aiuse-3.2.7 → aiuse-3.2.8}/src/aiuse.egg-info/SOURCES.txt

@@ -49,6 +49,7 @@ src/aiuse/collectors/openusage.py
 src/aiuse/collectors/openusage_sh.py
 src/aiuse/collectors/qwencloud.py
 src/aiuse/collectors/runner.py
+src/aiuse/collectors/throttle.py
 src/aiuse/collectors/tokscale.py
 src/aiuse/tui/__init__.py
 src/aiuse/tui/app.py
@@ -78,6 +79,7 @@ tests/test_opencode_zen.py
 tests/test_openrouter.py
 tests/test_openusage_parse.py
 tests/test_pace.py
+tests/test_query_throttle.py
 tests/test_qwencloud.py
 tests/test_release_script.py
 tests/test_report.py

aiuse-3.2.8/tests/test_query_throttle.py

@@ -0,0 +1,181 @@
+"""Cross-process minimum interval between live quota queries (agy / antigravity)."""
+
+from __future__ import annotations
+
+import json
+from datetime import timedelta
+
+from aiuse.collectors import codexbar, openusage
+from aiuse.collectors.base import CollectorError
+from aiuse.collectors.throttle import QueryGate, min_intervals, throttle_dir
+from aiuse.config import DEFAULT_CONFIG, validate_config
+from aiuse.models import utcnow
+
+_AGY_ROW = {
+    "provider": "antigravity",
+    "source": "local",
+    "usage": {"primary": {"usedPercent": 10, "windowMinutes": 300}},
+}
+
+
+def _backdate(provider: str, seconds: float) -> None:
+    path = throttle_dir() / f"{provider}.json"
+    state = json.loads(path.read_text())
+    state["queried_at"] = (utcnow() - timedelta(seconds=seconds)).isoformat()
+    path.write_text(json.dumps(state))
+
+
+def test_antigravity_defaults_to_fifteen_minutes():
+    assert DEFAULT_CONFIG["query_min_interval"]["antigravity"] == 900
+    assert min_intervals({}) == {"antigravity": 900.0}
+    assert min_intervals(DEFAULT_CONFIG) == {"antigravity": 900.0}
+
+
+def test_config_can_change_or_disable_a_limit():
+    assert min_intervals({"query_min_interval": {"antigravity": 1800}}) == {"antigravity": 1800.0}
+    assert min_intervals({"query_min_interval": {"antigravity": 0}}) == {}
+    assert min_intervals({"query_min_interval": {"Grok": 60}}) == {"antigravity": 900.0, "grok": 60.0}
+
+
+def test_validate_config_checks_query_min_interval():
+    assert not [i for i in validate_config({"query_min_interval": {"antigravity": 900}}) if "query_min" in i]
+    issues = validate_config({"query_min_interval": {"antigravity": "soon", "grok": -1}})
+    assert any("query_min_interval.antigravity must be a number" in i for i in issues)
+    assert any("query_min_interval.grok must not be negative" in i for i in issues)
+    assert any("must be a provider -> seconds mapping" in i for i in validate_config({"query_min_interval": 5}))
+
+
+def test_gate_allows_one_query_per_interval_and_reuses_the_payload():
+    with QueryGate("antigravity", min_interval=900, wait=0) as gate:
+        assert gate.allowed
+        gate.record("codexbar", [_AGY_ROW])
+
+    with QueryGate("antigravity", min_interval=900, wait=0) as gate:
+        assert not gate.allowed
+        assert gate.reuse("codexbar") == [_AGY_ROW]
+        assert "at most every 15m" in gate.describe()
+        assert "via codexbar" in gate.describe()
+
+    _backdate("antigravity", 901)
+    with QueryGate("antigravity", min_interval=900, wait=0) as gate:
+        assert gate.allowed
+
+
+def test_gate_held_by_another_process_counts_as_throttled():
+    with QueryGate("antigravity", min_interval=900, wait=0) as first:
+        assert first.allowed
+        with QueryGate("antigravity", min_interval=900, wait=0) as second:
+            assert not second.allowed
+            assert "another aiuse process" in second.describe()
+            assert isinstance(second.reuse("codexbar"), CollectorError)
+
+
+def test_codexbar_queries_antigravity_once_per_interval(monkeypatch):
+    calls: list[str | None] = []
+
+    def fake_query(provider_arg, *, timeout=45.0):
+        calls.append(provider_arg)
+        return [dict(_AGY_ROW, provider=provider_arg)]
+
+    monkeypatch.setattr(codexbar, "_query_provider", fake_query)
+    limits = {"antigravity": 900.0}
+
+    first_notes: dict[str, str] = {}
+    first = codexbar._query_providers(["codex", "antigravity"], min_intervals=limits, reuse_notes=first_notes)
+    second_notes: dict[str, str] = {}
+    second = codexbar._query_providers(["codex", "antigravity"], min_intervals=limits, reuse_notes=second_notes)
+
+    assert calls.count("antigravity") == 1
+    assert calls.count("codex") == 2
+    assert dict(second)["antigravity"] == dict(first)["antigravity"]
+    assert first_notes == {}
+    assert "reused CodexBar's result" in second_notes["antigravity"]
+
+
+def test_codexbar_reused_rows_carry_the_throttle_note(monkeypatch):
+    monkeypatch.setattr(codexbar, "which", lambda _cmd: "/usr/bin/codexbar")
+    monkeypatch.setattr(codexbar, "_query_provider", lambda provider_arg, *, timeout=45.0: [_AGY_ROW])
+
+    codexbar.collect_codexbar(providers="antigravity", min_intervals={"antigravity": 900.0})
+    accounts = codexbar.collect_codexbar(providers="antigravity", min_intervals={"antigravity": 900.0})
+
+    assert [a.provider for a in accounts] == ["antigravity"]
+    assert any("queried at most every 15m" in note for note in accounts[0].notes)
+
+
+def test_a_failed_antigravity_query_still_counts(monkeypatch):
+    calls: list[str | None] = []
+
+    def failing_query(provider_arg, *, timeout=45.0):
+        calls.append(provider_arg)
+        return CollectorError("HTTP 429 RESOURCE_EXHAUSTED")
+
+    monkeypatch.setattr(codexbar, "_query_provider", failing_query)
+    limits = {"antigravity": 900.0}
+    codexbar._query_providers(["antigravity"], min_intervals=limits)
+    [(_, outcome)] = codexbar._query_providers(["antigravity"], min_intervals=limits)
+
+    assert calls == ["antigravity"]
+    assert isinstance(outcome, CollectorError)
+    assert "429" in str(outcome) and "next allowed in" in str(outcome)
+
+
+def test_codexbar_without_limits_is_unchanged(monkeypatch):
+    calls: list[str | None] = []
+    monkeypatch.setattr(
+        codexbar, "_query_provider", lambda provider_arg, *, timeout=45.0: calls.append(provider_arg) or [_AGY_ROW]
+    )
+    codexbar._query_providers(["antigravity"])
+    codexbar._query_providers(["antigravity"])
+    assert calls == ["antigravity", "antigravity"]
+    assert not (throttle_dir() / "antigravity.json").exists()
+
+
+def test_openusage_withholds_force_while_antigravity_is_throttled(monkeypatch):
+    forced: list[bool] = []
+    payload = {
+        "schema": "openusage.limits.v1",
+        "providers": {
+            "antigravity": {
+                "displayName": "Antigravity",
+                "resources": {"geminiSession": {"kind": "consumption", "unit": "percent", "used": 10}},
+            },
+            "codex": {
+                "displayName": "Codex",
+                "resources": {"session": {"kind": "consumption", "unit": "percent", "used": 5}},
+            },
+        },
+    }
+
+    def fake_fetch(*, timeout, base_url, force_refresh, try_launch_app):
+        forced.append(force_refresh)
+        return payload, "cli"
+
+    monkeypatch.setattr(openusage, "which", lambda _cmd: "/usr/local/bin/openusage")
+    monkeypatch.setattr(openusage, "_fetch_limits", fake_fetch)
+    limits = {"antigravity": 900.0}
+
+    openusage.collect_openusage_ai(min_intervals=limits)
+    accounts = openusage.collect_openusage_ai(min_intervals=limits)
+
+    assert forced == [True, False]
+    by_provider = {a.provider: a for a in accounts}
+    assert any("refresh not forced" in n for n in by_provider["antigravity"].notes)
+    assert not any("refresh not forced" in n for n in by_provider["codex"].notes)
+
+
+def test_openusage_force_without_antigravity_does_not_spend_the_slot(monkeypatch):
+    payload = {
+        "providers": {
+            "codex": {
+                "displayName": "Codex",
+                "resources": {"session": {"kind": "consumption", "unit": "percent", "used": 5}},
+            }
+        }
+    }
+    monkeypatch.setattr(openusage, "which", lambda _cmd: "/usr/local/bin/openusage")
+    monkeypatch.setattr(openusage, "_fetch_limits", lambda **_kw: (payload, "cli"))
+    openusage.collect_openusage_ai(min_intervals={"antigravity": 900.0})
+
+    with QueryGate("antigravity", min_interval=900, wait=0) as gate:
+        assert gate.allowed