| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136 |
- """Usage-window allowances as the server sends them: one list, in display order.
- The Portal account (``usage_window.gauges``) and the API (``x-nous-credits-window-gauges``, also on the 402)
- send the same shape, so Hermes draws whatever arrives and a new allowance needs no Hermes release.
- ``scope`` says which models a full gauge stops: ``all`` = every paid model, ``top_tier`` = the models the
- gateway marks top tier. Free models draw on nothing.
- Hermes keeps only its own words for the ids it knows (they are translated and fitted to each surface);
- any other id shows the server's ``label``.
- """
- from __future__ import annotations
- import json
- import time
- from dataclasses import dataclass
- from typing import Any, Iterable, Optional
- BP_FULL = 10_000
- SCOPE_ALL = "all"
- SCOPE_TOP_TIER = "top_tier"
- _SCOPES = frozenset({SCOPE_ALL, SCOPE_TOP_TIER})
- # The pause reasons that mean the subscription payment failed. Any other reason (including "unknown",
- # sent for a malformed one) is still a pause, with copy that does not claim a payment failed.
- PAYMENT_PAUSE_REASONS = frozenset({"payment_past_due"})
- def paused_for_payment(reason: Any) -> bool:
- return reason in PAYMENT_PAUSE_REASONS
- @dataclass(frozen=True)
- class WindowGauge:
- id: str
- scope: str # SCOPE_ALL | SCOPE_TOP_TIER
- label: str # the server's display fallback
- used_bp: int # 0..10000
- resets_at_ms: Optional[int] = None
- @property
- def full(self) -> bool:
- return self.used_bp >= BP_FULL
- @property
- def used_fraction(self) -> float:
- return min(1.0, max(0.0, self.used_bp / BP_FULL))
- def parse_gauges(value: Any) -> Optional[tuple[WindowGauge, ...]]:
- """The wire list (a JSON array, or its string form from a header) → gauges in order. None when absent,
- unreadable or empty. An entry with an unknown scope, a repeated id or a bad percent is dropped: an
- older Hermes must never misread a kind of limit it does not know."""
- if isinstance(value, tuple) and all(isinstance(g, WindowGauge) for g in value):
- return value or None
- if isinstance(value, str):
- try:
- value = json.loads(value)
- except ValueError:
- return None
- if not isinstance(value, list):
- return None
- out: list[WindowGauge] = []
- seen: set[str] = set()
- for item in value:
- if not isinstance(item, dict):
- continue
- gid, scope, bp = item.get("id"), item.get("scope"), item.get("used_bp")
- if not isinstance(gid, str) or not gid or gid in seen or scope not in _SCOPES:
- continue
- if isinstance(bp, bool) or not isinstance(bp, int) or not 0 <= bp <= BP_FULL:
- continue
- reset = _plausible_reset_ms(item.get("resets_at_ms"))
- label = item.get("label")
- seen.add(gid)
- out.append(WindowGauge(gid, scope, label.strip() if isinstance(label, str) and label.strip() else gid,
- bp, reset))
- return tuple(out) or None
- # A reset more than a year ahead is a bad stamp (the longest allowance is a month): shown as unknown, never
- # as a date or a duration decades away. A past stamp needs no bound: it already reads "shortly".
- _RESET_MAX_AHEAD_MS = 366 * 86_400_000
- def _plausible_reset_ms(value: Any) -> Optional[int]:
- if not isinstance(value, int) or isinstance(value, bool):
- return None
- return value if 0 < value <= time.time() * 1000 + _RESET_MAX_AHEAD_MS else None
- def all_scope(gauges: Iterable[WindowGauge]) -> tuple[WindowGauge, ...]:
- return tuple(g for g in gauges if g.scope == SCOPE_ALL)
- def top_tier_gauge(gauges: Iterable[WindowGauge]) -> Optional[WindowGauge]:
- return next((g for g in gauges if g.scope == SCOPE_TOP_TIER), None)
- def binding_gauge(gauges: Iterable[WindowGauge]) -> Optional[WindowGauge]:
- """The all-scope gauge that binds: of the full ones, the one that frees up LAST (with the day and the
- week both full, the day's reset alone lets nothing through); else the fullest (ties → first listed)."""
- alls = all_scope(gauges)
- if not alls:
- return None
- full = [g for g in alls if g.full]
- if full:
- return max(full, key=lambda g: g.resets_at_ms or 0)
- return max(alls, key=lambda g: g.used_bp)
- # Hermes's words for the ids it knows: (row title, "for <phrase>", "your <name> limit", picker short name).
- _WORDS: dict[str, tuple[str, str, str, str]] = {
- "day": ("Today", "today", "daily", "today"),
- "week": ("This week", "this week", "weekly", "week"),
- "month": ("This month", "this month", "monthly", "month"),
- "top_tier": ("Large models (monthly)", "your monthly large-model usage", "monthly large-model", "large models (monthly)"),
- }
- def _words(g: WindowGauge) -> Optional[tuple[str, str, str, str]]:
- return _WORDS.get(g.id)
- def gauge_title(g: WindowGauge) -> str:
- """Row title in ``/usage``: ``Today``; an unknown id shows the server's label."""
- return w[0] if (w := _words(g)) else g.label
- def gauge_limit_name(g: WindowGauge) -> str:
- """``You've hit your <name> limit``: ``daily``; an unknown id shows the server's label."""
- return w[2] if (w := _words(g)) else g.label
- def gauge_short(g: WindowGauge) -> str:
- """Picker summary row name: ``today``; an unknown id shows the server's label."""
- return w[3] if (w := _words(g)) else g.label
|