codex-meter 0.3.0__py3-none-any.whl

codex_meter/models.py

@@ -0,0 +1,282 @@
+from __future__ import annotations
+
+import datetime as dt
+from dataclasses import dataclass, field
+from decimal import Decimal
+from pathlib import Path
+
+
+def _safe_int(value: object) -> int:
+    try:
+        return int(value or 0)
+    except (TypeError, ValueError):
+        return 0
+
+
+def decimal_value(value: object) -> Decimal:
+    if isinstance(value, Decimal):
+        return value
+    return Decimal(str(value))
+
+
+def decimal_string(value: object) -> str:
+    amount = decimal_value(value)
+    if amount == 0:
+        return "0"
+    return format(amount.normalize(), "f")
+
+
+@dataclass(frozen=True)
+class Usage:
+    input_tokens: int = 0
+    cached_input_tokens: int = 0
+    output_tokens: int = 0
+    reasoning_output_tokens: int = 0
+    total_tokens: int = 0
+
+    @property
+    def uncached_input_tokens(self) -> int:
+        return max(0, self.input_tokens - self.cached_input_tokens)
+
+    def is_zero(self) -> bool:
+        return not (
+            self.input_tokens
+            or self.cached_input_tokens
+            or self.output_tokens
+            or self.reasoning_output_tokens
+            or self.total_tokens
+        )
+
+    @classmethod
+    def from_dict(cls, raw: object) -> Usage:
+        if not isinstance(raw, dict):
+            return cls()
+        return cls(
+            input_tokens=_safe_int(raw.get("input_tokens")),
+            cached_input_tokens=_safe_int(raw.get("cached_input_tokens")),
+            output_tokens=_safe_int(raw.get("output_tokens")),
+            reasoning_output_tokens=_safe_int(raw.get("reasoning_output_tokens")),
+            total_tokens=_safe_int(raw.get("total_tokens")),
+        )
+
+
+@dataclass(frozen=True)
+class Rates:
+    input: Decimal | float
+    cached_input: Decimal | float
+    output: Decimal | float
+    reasoning_output: Decimal | float | None = None
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "input", decimal_value(self.input))
+        object.__setattr__(self, "cached_input", decimal_value(self.cached_input))
+        object.__setattr__(self, "output", decimal_value(self.output))
+        if self.reasoning_output is not None:
+            object.__setattr__(self, "reasoning_output", decimal_value(self.reasoning_output))
+
+    @property
+    def effective_reasoning_output(self) -> Decimal:
+        return self.reasoning_output if self.reasoning_output is not None else self.output
+
+
+@dataclass(frozen=True)
+class LongContextRule:
+    threshold: int
+    input_mult: float
+    output_mult: float
+
+
+@dataclass(frozen=True)
+class PricingSource:
+    name: str
+    url: str
+    checked: str
+
+
+@dataclass(frozen=True)
+class RuntimeOptions:
+    session_root: Path
+    state_db: Path
+    config_path: Path
+    start: dt.datetime
+    end: dt.datetime
+    timezone: str
+    pricing_mode: str
+    service_tier: str
+    unknown_service_tier: str
+    tier_overrides: Path | None
+    rates_file: Path | None
+    dedupe: bool
+    parse_cache: bool
+    default_model: str
+    show_prompts: bool
+    offline: bool
+    compact: bool
+    width: int | None
+    top_threads: int
+
+
+@dataclass(frozen=True)
+class ThreadMeta:
+    rollout_path: str = ""
+    title: str = ""
+    first_user_message: str = ""
+    cwd: str = ""
+    git_branch: str = ""
+    git_origin_url: str = ""
+    model: str = ""
+    reasoning_effort: str = ""
+    created_at: int = 0
+    updated_at: int = 0
+
+
+@dataclass(frozen=True)
+class TierOverride:
+    service_tier: str
+    session: str | None = None
+    start: dt.datetime | None = None
+    end: dt.datetime | None = None
+
+
+@dataclass(frozen=True)
+class UsageEvent:
+    timestamp: dt.datetime
+    path: Path
+    session_id: str
+    usage: Usage
+    model: str
+    service_tier: str
+    tier_source: str
+    thread: ThreadMeta
+    usage_source: str = "last_token_usage"
+    model_context_window: int = 0
+    plan_type: str = ""
+    credits: object = None
+    primary_used_percent: object = None
+    primary_window_minutes: object = None
+    primary_resets_at: object = None
+    secondary_used_percent: object = None
+    secondary_window_minutes: object = None
+    secondary_resets_at: object = None
+    rate_limit_reached_type: str = ""
+
+
+@dataclass(frozen=True)
+class RateLimitSample:
+    timestamp: dt.datetime
+    path: Path
+    session_id: str
+    plan_type: str = ""
+    credits: object = None
+    primary_used_percent: object = None
+    primary_window_minutes: object = None
+    primary_resets_at: object = None
+    secondary_used_percent: object = None
+    secondary_window_minutes: object = None
+    secondary_resets_at: object = None
+    rate_limit_reached_type: str = ""
+
+
+@dataclass
+class CostTotals:
+    api_dollars: Decimal | float = Decimal("0")
+    standard_credits: Decimal | float = Decimal("0")
+    adjusted_credits: Decimal | float = Decimal("0")
+    api_unpriced_events: int = 0
+    credit_unpriced_events: int = 0
+    estimated_events: int = 0
+    ambiguous_reasoning_events: int = 0
+    local_override_events: int = 0
+
+    def __post_init__(self) -> None:
+        self.api_dollars = decimal_value(self.api_dollars)
+        self.standard_credits = decimal_value(self.standard_credits)
+        self.adjusted_credits = decimal_value(self.adjusted_credits)
+
+    @property
+    def unpriced_events(self) -> int:
+        return max(self.api_unpriced_events, self.credit_unpriced_events)
+
+    def add(self, other: CostTotals) -> None:
+        self.api_dollars += other.api_dollars
+        self.standard_credits += other.standard_credits
+        self.adjusted_credits += other.adjusted_credits
+        self.api_unpriced_events += other.api_unpriced_events
+        self.credit_unpriced_events += other.credit_unpriced_events
+        self.estimated_events += other.estimated_events
+        self.ambiguous_reasoning_events += other.ambiguous_reasoning_events
+        self.local_override_events += other.local_override_events
+
+
+@dataclass
+class TokenTotals:
+    events: int = 0
+    input_tokens: int = 0
+    cached_input_tokens: int = 0
+    output_tokens: int = 0
+    reasoning_output_tokens: int = 0
+    total_tokens: int = 0
+
+    @property
+    def uncached_input_tokens(self) -> int:
+        return max(0, self.input_tokens - self.cached_input_tokens)
+
+    def add_usage(self, usage: Usage) -> None:
+        self.events += 1
+        self.input_tokens += usage.input_tokens
+        self.cached_input_tokens += usage.cached_input_tokens
+        self.output_tokens += usage.output_tokens
+        self.reasoning_output_tokens += usage.reasoning_output_tokens
+        self.total_tokens += usage.total_tokens
+
+
+@dataclass
+class Aggregate:
+    key: str
+    label: str
+    totals: TokenTotals = field(default_factory=TokenTotals)
+    costs: CostTotals = field(default_factory=CostTotals)
+    cache_savings: CostTotals = field(default_factory=CostTotals)
+    models: set[str] = field(default_factory=set)
+    service_tiers: set[str] = field(default_factory=set)
+    plan_types: set[str] = field(default_factory=set)
+    usage_sources: set[str] = field(default_factory=set)
+    model_context_window: int = 0
+    long_context_events: int = 0
+    unknown_model_events: int = 0
+    unknown_tier_events: int = 0
+
+    def add_event(
+        self,
+        event: UsageEvent,
+        costs: CostTotals,
+        cache_savings: CostTotals,
+        long_context: bool,
+        unknown_model: bool,
+        unknown_tier: bool,
+    ) -> None:
+        self.totals.add_usage(event.usage)
+        self.costs.add(costs)
+        self.cache_savings.add(cache_savings)
+        if event.model:
+            self.models.add(event.model)
+        if event.service_tier:
+            self.service_tiers.add(event.service_tier)
+        if event.plan_type:
+            self.plan_types.add(event.plan_type)
+        if event.usage_source:
+            self.usage_sources.add(event.usage_source)
+        self.model_context_window = max(self.model_context_window, event.model_context_window)
+        self.long_context_events += int(long_context)
+        self.unknown_model_events += int(unknown_model)
+        self.unknown_tier_events += int(unknown_tier)
+
+
+@dataclass(frozen=True)
+class LoadResult:
+    events: list[UsageEvent]
+    duplicates: int
+    tier_sources: dict[str, int]
+    plan_types: set[str]
+    credit_samples: list[RateLimitSample]
+    warnings: list[str]

codex_meter/parse_cache.py

@@ -0,0 +1,189 @@
+from __future__ import annotations
+
+import datetime as dt
+import json
+import os
+import sqlite3
+from contextlib import closing
+from dataclasses import asdict, dataclass
+from pathlib import Path
+
+from codex_meter.models import RateLimitSample, ThreadMeta, Usage, UsageEvent
+
+
+def default_cache_path() -> Path:
+    override = os.environ.get("CODEX_METER_CACHE_DIR")
+    if override:
+        return Path(override).expanduser() / "parse_cache.sqlite"
+    xdg = os.environ.get("XDG_CACHE_HOME")
+    if xdg:
+        return Path(xdg).expanduser() / "codex-meter" / "parse_cache.sqlite"
+    return Path.home() / ".cache" / "codex-meter" / "parse_cache.sqlite"
+
+
+@dataclass(frozen=True)
+class CacheStats:
+    path: Path
+    hits: int = 0
+    misses: int = 0
+
+
+class ParseCache:
+    def __init__(self, path: Path | None = None) -> None:
+        self.path = path or default_cache_path()
+        self.hits = 0
+        self.misses = 0
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        with closing(sqlite3.connect(self.path)) as conn, conn:
+            conn.execute(
+                """
+                create table if not exists parsed_sessions (
+                    path text not null,
+                    signature text not null,
+                    mtime_ns integer not null,
+                    size integer not null,
+                    byte_offset integer not null,
+                    payload blob not null,
+                    primary key (path, signature)
+                )
+                """
+            )
+
+    @classmethod
+    def default(cls) -> ParseCache:
+        return cls(default_cache_path())
+
+    def get(self, path: Path, signature: str):
+        stat = path.stat()
+        with closing(sqlite3.connect(self.path)) as conn:
+            row = conn.execute(
+                """
+                select payload from parsed_sessions
+                where path = ? and signature = ? and mtime_ns = ? and size = ? and byte_offset = ?
+                """,
+                (str(path), signature, stat.st_mtime_ns, stat.st_size, stat.st_size),
+            ).fetchone()
+        if row is None:
+            self.misses += 1
+            return None
+        parsed = _decode_payload(row[0])
+        if parsed is None:
+            self.misses += 1
+            return None
+        self.hits += 1
+        return parsed
+
+    def put(self, path: Path, signature: str, parsed) -> None:
+        stat = path.stat()
+        payload = _encode_payload(parsed)
+        with closing(sqlite3.connect(self.path)) as conn, conn:
+            conn.execute(
+                """
+                insert or replace into parsed_sessions
+                    (path, signature, mtime_ns, size, byte_offset, payload)
+                values (?, ?, ?, ?, ?, ?)
+                """,
+                (str(path), signature, stat.st_mtime_ns, stat.st_size, stat.st_size, payload),
+            )
+
+    def stats(self) -> CacheStats:
+        return CacheStats(path=self.path, hits=self.hits, misses=self.misses)
+
+
+def _encode_datetime(value: dt.datetime) -> str:
+    return value.astimezone(dt.UTC).isoformat()
+
+
+def _decode_datetime(value: str) -> dt.datetime:
+    return dt.datetime.fromisoformat(value).astimezone(dt.UTC)
+
+
+def _usage_to_dict(usage: Usage) -> dict:
+    return asdict(usage)
+
+
+def _usage_from_dict(raw: dict) -> Usage:
+    return Usage.from_dict(raw)
+
+
+def _thread_to_dict(thread: ThreadMeta) -> dict:
+    return asdict(thread)
+
+
+def _thread_from_dict(raw: dict) -> ThreadMeta:
+    return ThreadMeta(**raw)
+
+
+def _event_to_dict(event: UsageEvent) -> dict:
+    item = asdict(event)
+    item["timestamp"] = _encode_datetime(event.timestamp)
+    item["path"] = str(event.path)
+    item["usage"] = _usage_to_dict(event.usage)
+    item["thread"] = _thread_to_dict(event.thread)
+    return item
+
+
+def _event_from_dict(raw: dict) -> UsageEvent:
+    item = dict(raw)
+    item["timestamp"] = _decode_datetime(str(item["timestamp"]))
+    item["path"] = Path(str(item["path"]))
+    item["usage"] = _usage_from_dict(item["usage"])
+    item["thread"] = _thread_from_dict(item["thread"])
+    return UsageEvent(**item)
+
+
+def _sample_to_dict(sample: RateLimitSample) -> dict:
+    item = asdict(sample)
+    item["timestamp"] = _encode_datetime(sample.timestamp)
+    item["path"] = str(sample.path)
+    return item
+
+
+def _sample_from_dict(raw: dict) -> RateLimitSample:
+    item = dict(raw)
+    item["timestamp"] = _decode_datetime(str(item["timestamp"]))
+    item["path"] = Path(str(item["path"]))
+    return RateLimitSample(**item)
+
+
+def _encode_payload(parsed) -> bytes:
+    records = []
+    for event, reset, sample in parsed:
+        records.append(
+            {
+                "event": _event_to_dict(event) if event is not None else None,
+                "reset": bool(reset),
+                "sample": _sample_to_dict(sample) if sample is not None else None,
+            }
+        )
+    return json.dumps({"version": 1, "records": records}, separators=(",", ":")).encode("utf-8")
+
+
+def _decode_payload(raw) -> list[tuple[UsageEvent | None, bool, RateLimitSample | None]] | None:
+    try:
+        text = raw.decode("utf-8") if isinstance(raw, bytes) else str(raw)
+        payload = json.loads(text)
+    except (AttributeError, TypeError, UnicodeDecodeError, json.JSONDecodeError):
+        return None
+    if not isinstance(payload, dict) or payload.get("version") != 1:
+        return None
+    records = payload.get("records")
+    if not isinstance(records, list):
+        return None
+    parsed: list[tuple[UsageEvent | None, bool, RateLimitSample | None]] = []
+    try:
+        for record in records:
+            if not isinstance(record, dict):
+                return None
+            event_raw = record.get("event")
+            sample_raw = record.get("sample")
+            parsed.append(
+                (
+                    _event_from_dict(event_raw) if isinstance(event_raw, dict) else None,
+                    bool(record.get("reset")),
+                    _sample_from_dict(sample_raw) if isinstance(sample_raw, dict) else None,
+                )
+            )
+    except (KeyError, TypeError, ValueError):
+        return None
+    return parsed