ccmeter 0.0.1__tar.gz

ccmeter-0.0.1/.gitignore

@@ -0,0 +1,16 @@
+__pycache__/
+*.py[cod]
+build/
+dist/
+*.egg-info/
+
+.env
+.venv/
+venv/
+
+.coverage
+.pytest_cache/
+.ruff_cache/
+
+.DS_Store
+*.db

ccmeter-0.0.1/.python-version

@@ -0,0 +1 @@
+3.12

ccmeter-0.0.1/CLAUDE.md

@@ -0,0 +1,51 @@
+# ccmeter
+
+Measure what Anthropic won't tell you: what Claude subscription limits actually mean in tokens.
+
+## Architecture
+
+```
+ccmeter/
+  auth.py    — reads OAuth creds from OS keychain (macOS Keychain, Linux libsecret)
+  cli.py     — fncli entry point: poll, report, history, status, install, uninstall
+  db.py      — sqlite schema (~/.ccmeter/meter.db)
+  poll.py    — usage API poller with change detection and exponential backoff
+  scan.py    — JSONL scanner: reads per-message token counts from ~/.claude/projects/
+  report.py  — cross-references usage ticks against token windows to derive tokens-per-percent
+  history.py — display raw usage samples
+  status.py  — collection health
+  daemon.py  — launchd (macOS) / systemd (Linux) install/uninstall
+docs/
+  evidence.md — sourced incidents of opaque limit changes
+```
+
+Zero external deps beyond `fncli`. stdlib `urllib` for HTTP.
+
+## Key facts
+
+- Usage API: `api.anthropic.com/api/oauth/usage` with header `anthropic-beta: oauth-2025-04-20`
+- macOS keychain: `security find-generic-password -a $USER -s "Claude Code-credentials" -w`
+- Credential blob: `{claudeAiOauth: {accessToken, refreshToken, expiresAt, subscriptionType, rateLimitTier}}`
+- Known buckets: `five_hour`, `seven_day`, `seven_day_sonnet`, `seven_day_opus`, `seven_day_cowork`, `extra_usage`
+- `extra_usage` uses `used_credits` instead of `utilization`
+- Null buckets (e.g. `iguana_necktie`) are feature flags — we capture everything the API returns
+- JSONL location: `~/.claude/projects/<project>/<session_id>.jsonl`
+- JSONL assistant messages contain `.message.usage` with `input_tokens`, `output_tokens`, `cache_read_input_tokens`, `cache_creation_input_tokens`
+- Session metadata: `~/.claude/usage-data/session-meta/<session_id>.json` (token counts in thousands)
+
+## Conventions
+
+- fncli for CLI (not click/argparse)
+- stdlib over deps
+- sqlite for local storage
+- print() for output
+- Deferred imports in CLI handlers
+- `just format` / `just lint`
+
+## Roadmap
+
+- [ ] Confidence intervals on calibration (need more data)
+- [ ] Anonymous contribution: `ccmeter export` dumps standardized JSON for community sharing
+- [ ] Community dataset repo for aggregated calibration data
+- [ ] Windows support (Windows Credential Manager)
+- [ ] PyPI publish

ccmeter-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tyson Chan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ccmeter-0.0.1/PKG-INFO

@@ -0,0 +1,103 @@
+Metadata-Version: 2.4
+Name: ccmeter
+Version: 0.0.1
+Summary: Reverse-engineer Anthropic's opaque Claude subscription limits into hard numbers
+Project-URL: Repository, https://github.com/iteebz/ccmeter
+Project-URL: Issues, https://github.com/iteebz/ccmeter/issues
+Author-email: Tyson Chan <tyson.chan@proton.me>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: anthropic,claude,limits,metering,transparency,usage
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: System :: Monitoring
+Requires-Python: >=3.12
+Requires-Dist: fncli
+Description-Content-Type: text/markdown
+
+# ccmeter
+
+Measure what Anthropic won't tell you: what your Claude subscription limits actually mean in tokens.
+
+## Why
+
+Anthropic charges $20-$200/month for Claude but doesn't publish what the usage limits actually are. The API reports utilization as a percentage — but a percentage of what? Nobody knows.
+
+Three times in four months, Anthropic has run the same play: announce a temporary usage boost, silently tighten baseline limits during or after, then attribute complaints to "contrast effect." See [docs/evidence.md](docs/evidence.md) for the receipts.
+
+ccmeter is a local instrument that figures out the actual numbers.
+
+## How it works
+
+1. Polls Anthropic's OAuth usage API every 2 minutes — records utilization percentages per bucket (`five_hour`, `seven_day`, `seven_day_sonnet`, etc.)
+2. Scans Claude Code's local JSONL files for per-message token counts with timestamps
+3. When utilization ticks from 15% to 16% and you used N tokens in that window: 1% = N tokens
+
+That's the whole trick. Track that number over time. If it shrinks, the cap shrank.
+
+## Install
+
+```bash
+pip install ccmeter
+```
+
+Or clone and run directly:
+
+```bash
+git clone https://github.com/iteebz/ccmeter && cd ccmeter && uv sync
+```
+
+Requires Python 3.12+, Claude Code installed and signed in. macOS and Linux. Zero dependencies beyond [fncli](https://pypi.org/project/fncli/).
+
+## Usage
+
+```bash
+# Install as background daemon (survives restarts)
+ccmeter install
+
+# Or run in foreground
+ccmeter poll
+
+# What does 1% actually cost?
+ccmeter report
+
+# Structured output for sharing
+ccmeter report --json
+
+# Raw usage tick history
+ccmeter history
+
+# Collection health
+ccmeter status
+
+# Remove daemon
+ccmeter uninstall
+```
+
+## What it collects
+
+**From Anthropic's API** (polled every 2 min, recorded on change):
+- Utilization percentage per bucket
+- Reset timestamps
+- Your subscription tier (detected automatically from credentials)
+
+**From Claude Code's local JSONL files** (scanned on `report`):
+- Per-message token counts: input, output, cache_read, cache_create
+- Timestamps, model, Claude Code version, session ID
+
+**Everything stays local** in `~/.ccmeter/meter.db`. Your OAuth token is only sent to Anthropic's own API — the same call Claude Code already makes.
+
+## Known confounds
+
+- **Multi-surface usage**: claude.ai, Claude Code, and Cowork share limits but only Claude Code has local token logs. If you use multiple surfaces simultaneously, token counts will be inflated relative to the utilization tick.
+- **1% granularity**: The API reports whole percentages only. More samples over longer periods = better accuracy.
+- **Bucket overlap**: Some buckets may share underlying quotas in ways the API doesn't surface.
+
+## License
+
+MIT

ccmeter-0.0.1/README.md

@@ -0,0 +1,81 @@
+# ccmeter
+
+Measure what Anthropic won't tell you: what your Claude subscription limits actually mean in tokens.
+
+## Why
+
+Anthropic charges $20-$200/month for Claude but doesn't publish what the usage limits actually are. The API reports utilization as a percentage — but a percentage of what? Nobody knows.
+
+Three times in four months, Anthropic has run the same play: announce a temporary usage boost, silently tighten baseline limits during or after, then attribute complaints to "contrast effect." See [docs/evidence.md](docs/evidence.md) for the receipts.
+
+ccmeter is a local instrument that figures out the actual numbers.
+
+## How it works
+
+1. Polls Anthropic's OAuth usage API every 2 minutes — records utilization percentages per bucket (`five_hour`, `seven_day`, `seven_day_sonnet`, etc.)
+2. Scans Claude Code's local JSONL files for per-message token counts with timestamps
+3. When utilization ticks from 15% to 16% and you used N tokens in that window: 1% = N tokens
+
+That's the whole trick. Track that number over time. If it shrinks, the cap shrank.
+
+## Install
+
+```bash
+pip install ccmeter
+```
+
+Or clone and run directly:
+
+```bash
+git clone https://github.com/iteebz/ccmeter && cd ccmeter && uv sync
+```
+
+Requires Python 3.12+, Claude Code installed and signed in. macOS and Linux. Zero dependencies beyond [fncli](https://pypi.org/project/fncli/).
+
+## Usage
+
+```bash
+# Install as background daemon (survives restarts)
+ccmeter install
+
+# Or run in foreground
+ccmeter poll
+
+# What does 1% actually cost?
+ccmeter report
+
+# Structured output for sharing
+ccmeter report --json
+
+# Raw usage tick history
+ccmeter history
+
+# Collection health
+ccmeter status
+
+# Remove daemon
+ccmeter uninstall
+```
+
+## What it collects
+
+**From Anthropic's API** (polled every 2 min, recorded on change):
+- Utilization percentage per bucket
+- Reset timestamps
+- Your subscription tier (detected automatically from credentials)
+
+**From Claude Code's local JSONL files** (scanned on `report`):
+- Per-message token counts: input, output, cache_read, cache_create
+- Timestamps, model, Claude Code version, session ID
+
+**Everything stays local** in `~/.ccmeter/meter.db`. Your OAuth token is only sent to Anthropic's own API — the same call Claude Code already makes.
+
+## Known confounds
+
+- **Multi-surface usage**: claude.ai, Claude Code, and Cowork share limits but only Claude Code has local token logs. If you use multiple surfaces simultaneously, token counts will be inflated relative to the utilization tick.
+- **1% granularity**: The API reports whole percentages only. More samples over longer periods = better accuracy.
+- **Bucket overlap**: Some buckets may share underlying quotas in ways the API doesn't surface.
+
+## License
+
+MIT

ccmeter-0.0.1/ccmeter/__init__.py

@@ -0,0 +1,3 @@
+"""cc-meter: Reverse-engineer Anthropic's opaque Claude subscription limits into hard numbers."""
+
+__version__ = "0.0.1"

ccmeter-0.0.1/ccmeter/auth.py

@@ -0,0 +1,65 @@
+"""Read Claude Code OAuth credentials from OS keychain."""
+
+import json
+import subprocess
+import sys
+from dataclasses import dataclass
+
+
+@dataclass
+class Credentials:
+    access_token: str
+    refresh_token: str | None
+    expires_at: str | None
+    subscription_type: str | None
+    rate_limit_tier: str | None
+
+
+def get_credentials() -> Credentials | None:
+    """Extract OAuth credentials Claude Code stores in the OS credential store."""
+    if sys.platform == "darwin":
+        return _macos_keychain()
+    if sys.platform == "linux":
+        return _linux_secret()
+    return None
+
+
+def _parse_credentials(raw: str) -> Credentials | None:
+    try:
+        data = json.loads(raw)
+    except json.JSONDecodeError:
+        return None
+    oauth = data.get("claudeAiOauth")
+    if not oauth or not isinstance(oauth, dict):
+        return None
+    token = oauth.get("accessToken")
+    if not token:
+        return None
+    return Credentials(
+        access_token=token,
+        refresh_token=oauth.get("refreshToken"),
+        expires_at=oauth.get("expiresAt"),
+        subscription_type=oauth.get("subscriptionType"),
+        rate_limit_tier=oauth.get("rateLimitTier"),
+    )
+
+
+def _run_keychain(args: list[str]) -> Credentials | None:
+    try:
+        result = subprocess.run(args, capture_output=True, text=True, timeout=5)
+        if result.returncode != 0:
+            return None
+        return _parse_credentials(result.stdout.strip())
+    except (subprocess.TimeoutExpired, FileNotFoundError):
+        return None
+
+
+def _macos_keychain() -> Credentials | None:
+    import os
+
+    user = os.environ.get("USER", "")
+    return _run_keychain(["security", "find-generic-password", "-a", user, "-s", "Claude Code-credentials", "-w"])
+
+
+def _linux_secret() -> Credentials | None:
+    return _run_keychain(["secret-tool", "lookup", "service", "Claude Code-credentials"])

ccmeter-0.0.1/ccmeter/cli.py

@@ -0,0 +1,65 @@
+"""ccmeter CLI."""
+
+import sys
+
+import fncli
+
+from ccmeter import __version__
+
+
+@fncli.cli()
+def version():
+    """print version"""
+    print(__version__)
+
+
+@fncli.cli("ccmeter")
+def poll(interval: int = 120, once: bool = False):
+    """poll usage API and record samples to local sqlite"""
+    from ccmeter.poll import run_poll
+
+    run_poll(interval=interval, once=once)
+
+
+@fncli.cli("ccmeter")
+def report(days: int = 30, json: bool = False):
+    """show calibration report: what does 1% actually cost in tokens"""
+    from ccmeter.report import run_report
+
+    run_report(days=days, json_output=json)
+
+
+@fncli.cli("ccmeter")
+def history(days: int = 7, json: bool = False):
+    """show raw usage sample history"""
+    from ccmeter.history import show_history
+
+    show_history(days=days, json_output=json)
+
+
+@fncli.cli("ccmeter")
+def status():
+    """show current usage and collection stats"""
+    from ccmeter.status import show_status
+
+    show_status()
+
+
+@fncli.cli("ccmeter")
+def install():
+    """install ccmeter as a background daemon (survives restarts)"""
+    from ccmeter.daemon import install as do_install
+
+    raise SystemExit(do_install())
+
+
+@fncli.cli("ccmeter")
+def uninstall():
+    """stop and remove the background daemon"""
+    from ccmeter.daemon import uninstall as do_uninstall
+
+    raise SystemExit(do_uninstall())
+
+
+def main():
+    raise SystemExit(fncli.dispatch(["ccmeter", *sys.argv[1:]]))

ccmeter-0.0.1/ccmeter/daemon.py

@@ -0,0 +1,138 @@
+"""Install/uninstall ccmeter as a background daemon that survives restarts."""
+
+import shutil
+import subprocess
+import sys
+import textwrap
+from pathlib import Path
+
+LAUNCHD_LABEL = "com.ccmeter.poll"
+LAUNCHD_PLIST = Path.home() / "Library" / "LaunchAgents" / f"{LAUNCHD_LABEL}.plist"
+
+SYSTEMD_UNIT = Path.home() / ".config" / "systemd" / "user" / "ccmeter.service"
+
+
+def install():
+    """Install ccmeter as a background daemon."""
+    ccmeter_bin = shutil.which("ccmeter")
+    if not ccmeter_bin:
+        print("error: ccmeter not found in PATH", file=sys.stderr)
+        print("install first: pip install ccmeter", file=sys.stderr)
+        return 1
+
+    if sys.platform == "darwin":
+        return _install_launchd(ccmeter_bin)
+    if sys.platform == "linux":
+        return _install_systemd(ccmeter_bin)
+
+    print(f"error: unsupported platform {sys.platform}", file=sys.stderr)
+    return 1
+
+
+def uninstall():
+    """Remove ccmeter background daemon."""
+    if sys.platform == "darwin":
+        return _uninstall_launchd()
+    if sys.platform == "linux":
+        return _uninstall_systemd()
+
+    print(f"error: unsupported platform {sys.platform}", file=sys.stderr)
+    return 1
+
+
+def _install_launchd(ccmeter_bin: str) -> int:
+    plist = textwrap.dedent(f"""\
+        <?xml version="1.0" encoding="UTF-8"?>
+        <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+        <plist version="1.0">
+        <dict>
+            <key>Label</key>
+            <string>{LAUNCHD_LABEL}</string>
+            <key>ProgramArguments</key>
+            <array>
+                <string>{ccmeter_bin}</string>
+                <string>poll</string>
+            </array>
+            <key>RunAtLoad</key>
+            <true/>
+            <key>KeepAlive</key>
+            <true/>
+            <key>StandardOutPath</key>
+            <string>{Path.home()}/.ccmeter/poll.log</string>
+            <key>StandardErrorPath</key>
+            <string>{Path.home()}/.ccmeter/poll.err</string>
+        </dict>
+        </plist>
+    """)
+
+    LAUNCHD_PLIST.parent.mkdir(parents=True, exist_ok=True)
+    LAUNCHD_PLIST.write_text(plist)
+
+    # unload first if already loaded
+    subprocess.run(["launchctl", "unload", str(LAUNCHD_PLIST)], capture_output=True)
+    result = subprocess.run(["launchctl", "load", str(LAUNCHD_PLIST)], capture_output=True, text=True)
+
+    if result.returncode != 0:
+        print(f"error loading launchd plist: {result.stderr}", file=sys.stderr)
+        return 1
+
+    print("ccmeter daemon installed and running")
+    print(f"  plist: {LAUNCHD_PLIST}")
+    print("  log:   ~/.ccmeter/poll.log")
+    print("  stop:  ccmeter uninstall")
+    return 0
+
+
+def _uninstall_launchd() -> int:
+    if not LAUNCHD_PLIST.exists():
+        print("ccmeter daemon not installed")
+        return 0
+
+    subprocess.run(["launchctl", "unload", str(LAUNCHD_PLIST)], capture_output=True)
+    LAUNCHD_PLIST.unlink()
+    print("ccmeter daemon stopped and removed")
+    return 0
+
+
+def _install_systemd(ccmeter_bin: str) -> int:
+    unit = textwrap.dedent(f"""\
+        [Unit]
+        Description=ccmeter usage polling daemon
+        After=network.target
+
+        [Service]
+        ExecStart={ccmeter_bin} poll
+        Restart=always
+        RestartSec=30
+
+        [Install]
+        WantedBy=default.target
+    """)
+
+    SYSTEMD_UNIT.parent.mkdir(parents=True, exist_ok=True)
+    SYSTEMD_UNIT.write_text(unit)
+
+    subprocess.run(["systemctl", "--user", "daemon-reload"], capture_output=True)
+    result = subprocess.run(["systemctl", "--user", "enable", "--now", "ccmeter"], capture_output=True, text=True)
+
+    if result.returncode != 0:
+        print(f"error enabling systemd unit: {result.stderr}", file=sys.stderr)
+        return 1
+
+    print("ccmeter daemon installed and running")
+    print(f"  unit:   {SYSTEMD_UNIT}")
+    print("  status: systemctl --user status ccmeter")
+    print("  stop:   ccmeter uninstall")
+    return 0
+
+
+def _uninstall_systemd() -> int:
+    if not SYSTEMD_UNIT.exists():
+        print("ccmeter daemon not installed")
+        return 0
+
+    subprocess.run(["systemctl", "--user", "disable", "--now", "ccmeter"], capture_output=True)
+    SYSTEMD_UNIT.unlink()
+    subprocess.run(["systemctl", "--user", "daemon-reload"], capture_output=True)
+    print("ccmeter daemon stopped and removed")
+    return 0

ccmeter-0.0.1/ccmeter/db.py

@@ -0,0 +1,41 @@
+"""Local sqlite storage for usage samples."""
+
+import sqlite3
+from pathlib import Path
+
+DB_PATH = Path.home() / ".ccmeter" / "meter.db"
+
+SCHEMA = """
+CREATE TABLE IF NOT EXISTS usage_samples (
+    id          INTEGER PRIMARY KEY AUTOINCREMENT,
+    ts          TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+    bucket      TEXT NOT NULL,
+    utilization REAL NOT NULL,
+    resets_at   TEXT,
+    tier        TEXT,
+    raw         JSON
+);
+
+CREATE INDEX IF NOT EXISTS idx_usage_ts ON usage_samples(ts);
+CREATE INDEX IF NOT EXISTS idx_usage_bucket_ts ON usage_samples(bucket, ts);
+
+CREATE TABLE IF NOT EXISTS sessions (
+    id          INTEGER PRIMARY KEY AUTOINCREMENT,
+    session_id  TEXT NOT NULL UNIQUE,
+    project     TEXT,
+    started_at  TEXT,
+    last_seen   TEXT,
+    total_input_tokens  INTEGER DEFAULT 0,
+    total_output_tokens INTEGER DEFAULT 0
+);
+
+CREATE INDEX IF NOT EXISTS idx_sessions_id ON sessions(session_id);
+"""
+
+
+def connect() -> sqlite3.Connection:
+    DB_PATH.parent.mkdir(parents=True, exist_ok=True)
+    conn = sqlite3.connect(str(DB_PATH))
+    conn.row_factory = sqlite3.Row
+    conn.executescript(SCHEMA)
+    return conn

ccmeter-0.0.1/ccmeter/history.py

@@ -0,0 +1,30 @@
+"""Display usage sample history."""
+
+import json
+
+from ccmeter.db import connect
+
+
+def show_history(days: int = 7, json_output: bool = False):
+    conn = connect()
+    rows = conn.execute(
+        "SELECT ts, bucket, utilization, resets_at FROM usage_samples "
+        "WHERE ts > datetime('now', ? || ' days') ORDER BY ts DESC",
+        (f"-{days}",),
+    ).fetchall()
+    conn.close()
+
+    if not rows:
+        print(f"no samples in the last {days} days. run: ccmeter poll")
+        return
+
+    if json_output:
+        print(json.dumps([dict(r) for r in rows], indent=2))
+        return
+
+    print(f"{'timestamp':<28} {'bucket':<20} {'utilization':>6}")
+    print("-" * 58)
+    for r in rows:
+        print(f"{r['ts']:<28} {r['bucket']:<20} {r['utilization']:>5.0f}%")
+
+    print(f"\n{len(rows)} samples over {days} days")

ccmeter-0.0.1/ccmeter/poll.py

@@ -0,0 +1,127 @@
+"""Poll Anthropic usage API and record samples."""
+
+import json
+import signal
+import sys
+import time
+import urllib.error
+import urllib.request
+
+from ccmeter.auth import Credentials, get_credentials
+from ccmeter.db import connect
+
+USAGE_URL = "https://api.anthropic.com/api/oauth/usage"
+BETA_HEADER = "oauth-2025-04-20"
+
+BUCKETS = ("five_hour", "seven_day", "seven_day_sonnet", "seven_day_opus", "seven_day_cowork", "extra_usage")
+
+_running = True
+
+
+def _handle_signal(sig, frame):
+    global _running
+    _running = False
+    print("\nshutting down...")
+
+
+def fetch_usage(creds: Credentials) -> dict | None:
+    """Fetch current usage from Anthropic's OAuth endpoint."""
+    req = urllib.request.Request(
+        USAGE_URL,
+        headers={
+            "Authorization": f"Bearer {creds.access_token}",
+            "anthropic-beta": BETA_HEADER,
+        },
+    )
+    try:
+        resp = urllib.request.urlopen(req, timeout=10)
+        return json.loads(resp.read().decode())
+    except (urllib.error.URLError, json.JSONDecodeError, OSError) as e:
+        print(f"usage API error: {e}", file=sys.stderr)
+        return None
+
+
+def record_samples(data: dict, last_seen: dict, conn, tier: str | None = None) -> dict:
+    """Write rows for any bucket that changed. Returns updated last_seen."""
+    for key, value in data.items():
+        if not isinstance(value, dict):
+            continue
+
+        utilization = value.get("utilization")
+        if utilization is None and key == "extra_usage":
+            utilization = value.get("used_credits")
+        if utilization is None:
+            continue
+
+        prev = last_seen.get(key)
+        if prev is not None and prev == utilization:
+            continue
+
+        resets_at = value.get("resets_at")
+        conn.execute(
+            "INSERT INTO usage_samples (bucket, utilization, resets_at, tier, raw) VALUES (?, ?, ?, ?, ?)",
+            (key, float(utilization), resets_at, tier, json.dumps(value)),
+        )
+        conn.commit()
+
+        direction = ""
+        if prev is not None:
+            direction = f" (was {prev}%)"
+        print(f"  {key}: {utilization}%{direction}")
+
+        last_seen[key] = utilization
+
+    return last_seen
+
+
+def seed_last_seen(conn) -> dict:
+    """Load most recent utilization per bucket from DB to avoid duplicate rows on restart."""
+    last_seen = {}
+    rows = conn.execute(
+        "SELECT bucket, utilization FROM usage_samples WHERE id IN (SELECT MAX(id) FROM usage_samples GROUP BY bucket)"
+    ).fetchall()
+    for row in rows:
+        last_seen[row["bucket"]] = row["utilization"]
+    return last_seen
+
+
+def run_poll(interval: int = 120, once: bool = False):
+    """Main poll loop."""
+    creds = get_credentials()
+    if not creds:
+        print("error: could not find Claude Code OAuth token in OS keychain", file=sys.stderr)
+        print(file=sys.stderr)
+        print("ccmeter reads the same credential Claude Code uses.", file=sys.stderr)
+        print("make sure Claude Code is installed and you've signed in.", file=sys.stderr)
+        sys.exit(1)
+
+    tier = creds.subscription_type or creds.rate_limit_tier
+    conn = connect()
+    last_seen = seed_last_seen(conn)
+
+    signal.signal(signal.SIGINT, _handle_signal)
+    signal.signal(signal.SIGTERM, _handle_signal)
+
+    print(f"ccmeter polling every {interval}s")
+    if tier:
+        print(f"  tier: {tier}")
+    if last_seen:
+        print(f"  resumed with {len(last_seen)} cached bucket(s)")
+
+    backoff = interval
+    while _running:
+        data = fetch_usage(creds)
+        if data:
+            last_seen = record_samples(data, last_seen, conn, tier=tier)
+            backoff = interval
+        else:
+            backoff = min(backoff * 2, 600)
+            print(f"  backing off to {backoff}s", file=sys.stderr)
+
+        if once:
+            break
+
+        time.sleep(backoff)
+
+    conn.close()
+    print("stopped.")

ccmeter-0.0.1/ccmeter/report.py

@@ -0,0 +1,151 @@
+"""Generate calibration report by cross-referencing usage ticks against JSONL token data."""
+
+import json
+
+from ccmeter.auth import get_credentials
+from ccmeter.db import connect
+from ccmeter.scan import scan
+
+
+def tokens_in_window(events, t0: str, t1: str) -> dict:
+    """Sum token counts for events between two timestamps."""
+    totals = {"input": 0, "output": 0, "cache_read": 0, "cache_create": 0}
+    for e in events:
+        if t0 <= e.ts <= t1:
+            totals["input"] += e.input_tokens
+            totals["output"] += e.output_tokens
+            totals["cache_read"] += e.cache_read
+            totals["cache_create"] += e.cache_create
+    return totals
+
+
+def calibrate_bucket(bucket: str, events, conn) -> list[dict]:
+    """Find utilization ticks and calculate tokens per percent for a bucket."""
+    rows = conn.execute(
+        """
+        SELECT s1.ts as t0, s2.ts as t1,
+               s1.utilization as u0, s2.utilization as u1,
+               s2.utilization - s1.utilization as delta_pct
+        FROM usage_samples s1
+        JOIN usage_samples s2
+            ON s2.bucket = s1.bucket
+            AND s2.id = (SELECT MIN(id) FROM usage_samples
+                         WHERE bucket = s1.bucket AND id > s1.id)
+        WHERE s1.bucket = ?
+            AND s2.utilization > s1.utilization
+        ORDER BY s1.ts
+        """,
+        (bucket,),
+    ).fetchall()
+
+    calibrations = []
+    for r in rows:
+        t0, t1, delta = r["t0"], r["t1"], r["delta_pct"]
+        tokens = tokens_in_window(events, t0, t1)
+        total = tokens["input"] + tokens["output"] + tokens["cache_read"] + tokens["cache_create"]
+        if total == 0:
+            continue
+        calibrations.append(
+            {
+                "t0": t0,
+                "t1": t1,
+                "delta_pct": delta,
+                "tokens": tokens,
+                "tokens_per_pct": {k: int(v / delta) for k, v in tokens.items()},
+                "total_per_pct": int(total / delta),
+            }
+        )
+    return calibrations
+
+
+def run_report(days: int = 30, json_output: bool = False):
+    """Generate and display calibration report."""
+    creds = get_credentials()
+    tier = "unknown"
+    rate_tier = "unknown"
+    if creds:
+        tier = creds.subscription_type or "unknown"
+        rate_tier = creds.rate_limit_tier or "unknown"
+
+    print("scanning JSONL files...")
+    result = scan(days=days)
+
+    if not result.events:
+        print(f"no token events found in the last {days} days.")
+        print("make sure Claude Code has been used and JSONL logs exist in ~/.claude/projects/")
+        return
+
+    conn = connect()
+    sample_count = conn.execute("SELECT COUNT(*) as n FROM usage_samples").fetchone()["n"]
+
+    if sample_count == 0:
+        print("no usage samples collected yet. run: ccmeter poll")
+        conn.close()
+        return
+
+    buckets = ["five_hour", "seven_day", "seven_day_sonnet"]
+    report_data = {
+        "tier": tier,
+        "rate_limit_tier": rate_tier,
+        "os": result.os,
+        "cc_versions": sorted(result.cc_versions),
+        "models": sorted(result.models),
+        "sessions": result.sessions,
+        "token_events": len(result.events),
+        "usage_samples": sample_count,
+        "lookback_days": days,
+        "buckets": {},
+    }
+
+    for bucket in buckets:
+        cals = calibrate_bucket(bucket, result.events, conn)
+        if cals:
+            avg_per_pct = {}
+            for key in ("input", "output", "cache_read", "cache_create"):
+                vals = [c["tokens_per_pct"][key] for c in cals]
+                avg_per_pct[key] = int(sum(vals) / len(vals))
+            avg_total = sum(avg_per_pct.values())
+
+            report_data["buckets"][bucket] = {
+                "ticks": len(cals),
+                "avg_tokens_per_pct": avg_per_pct,
+                "avg_total_per_pct": avg_total,
+            }
+
+    conn.close()
+
+    if json_output:
+        print(json.dumps(report_data, indent=2))
+        return
+
+    _print_report(report_data)
+
+
+def _print_report(data: dict):
+    print()
+    print(f"tier:        {data['tier']} ({data['rate_limit_tier']})")
+    print(f"os:          {data['os']}")
+    print(f"cc versions: {', '.join(data['cc_versions']) or 'unknown'}")
+    print(f"models:      {', '.join(data['models']) or 'unknown'}")
+    print(f"sessions:    {data['sessions']}")
+    print(f"events:      {data['token_events']} token events over {data['lookback_days']}d")
+    print(f"samples:     {data['usage_samples']} usage ticks")
+
+    if not data["buckets"]:
+        print()
+        print("no calibration data yet — need usage ticks that overlap with JSONL session data.")
+        print("keep ccmeter poll running while you use Claude Code.")
+        return
+
+    print()
+    for bucket, cal in data["buckets"].items():
+        tpp = cal["avg_tokens_per_pct"]
+        print(f"{bucket} ({cal['ticks']} ticks):")
+        print(f"  1% ≈ {cal['avg_total_per_pct']:,} tokens total")
+        print(
+            f"       {tpp['input']:,} input / {tpp['output']:,} output / {tpp['cache_read']:,} cache_read / {tpp['cache_create']:,} cache_create"
+        )
+        print()
+
+    print("⚠  if you use claude.ai alongside Claude Code, token counts may be inflated")
+    print("   (the API tracks combined usage but we can only see Claude Code's tokens)")

ccmeter-0.0.1/ccmeter/scan.py

@@ -0,0 +1,92 @@
+"""Scan Claude Code JSONL files for per-message token usage."""
+
+import json
+import platform
+from dataclasses import dataclass, field
+from datetime import UTC, datetime, timedelta
+from pathlib import Path
+
+CLAUDE_DIR = Path.home() / ".claude" / "projects"
+
+
+@dataclass
+class TokenEvent:
+    ts: str
+    input_tokens: int
+    output_tokens: int
+    cache_read: int
+    cache_create: int
+    model: str
+    session_id: str
+    cc_version: str
+
+
+@dataclass
+class ScanResult:
+    events: list[TokenEvent] = field(default_factory=list)
+    cc_versions: set[str] = field(default_factory=set)
+    models: set[str] = field(default_factory=set)
+    sessions: int = 0
+    os: str = field(default_factory=lambda: platform.system().lower())
+
+
+def scan(days: int = 30) -> ScanResult:
+    """Scan all JSONL files for token events within the lookback window."""
+    cutoff = (datetime.now(tz=UTC) - timedelta(days=days)).isoformat()
+    result = ScanResult()
+    seen_sessions = set()
+
+    if not CLAUDE_DIR.exists():
+        return result
+
+    for jsonl in CLAUDE_DIR.glob("*/*.jsonl"):
+        _scan_file(jsonl, cutoff, result, seen_sessions)
+
+    result.sessions = len(seen_sessions)
+    result.events.sort(key=lambda e: e.ts)
+    return result
+
+
+def _scan_file(path: Path, cutoff: str, result: ScanResult, seen_sessions: set):
+    try:
+        with path.open() as f:
+            for line in f:
+                try:
+                    d = json.loads(line)
+                except json.JSONDecodeError:
+                    continue
+
+                msg = d.get("message")
+                if not isinstance(msg, dict) or "usage" not in msg:
+                    continue
+
+                ts = d.get("timestamp", "")
+                if ts < cutoff:
+                    continue
+
+                usage = msg["usage"]
+                session_id = d.get("sessionId", "")
+                cc_version = d.get("version", "")
+                model = msg.get("model", "")
+
+                if session_id:
+                    seen_sessions.add(session_id)
+                if cc_version:
+                    result.cc_versions.add(cc_version)
+                if model:
+                    result.models.add(model)
+
+                result.events.append(
+                    TokenEvent(
+                        ts=ts,
+                        input_tokens=usage.get("input_tokens", 0),
+                        output_tokens=usage.get("output_tokens", 0),
+                        cache_read=usage.get("cache_read_input_tokens", 0),
+                        cache_create=usage.get("cache_creation_input_tokens", 0),
+                        model=model,
+                        session_id=session_id,
+                        cc_version=cc_version,
+                    )
+                )
+    except OSError:
+        pass

ccmeter-0.0.1/ccmeter/status.py

@@ -0,0 +1,25 @@
+"""Show current collection status."""
+
+from ccmeter.db import DB_PATH, connect
+
+
+def show_status():
+    if not DB_PATH.exists():
+        print("no data collected yet. run: ccmeter poll")
+        return
+
+    conn = connect()
+
+    total = conn.execute("SELECT COUNT(*) as n FROM usage_samples").fetchone()["n"]
+    buckets = conn.execute("SELECT DISTINCT bucket FROM usage_samples ORDER BY bucket").fetchall()
+    latest = conn.execute("SELECT ts FROM usage_samples ORDER BY ts DESC LIMIT 1").fetchone()
+    oldest = conn.execute("SELECT ts FROM usage_samples ORDER BY ts ASC LIMIT 1").fetchone()
+
+    conn.close()
+
+    print("ccmeter status")
+    print(f"  db: {DB_PATH}")
+    print(f"  samples: {total}")
+    print(f"  buckets: {', '.join(r['bucket'] for r in buckets)}")
+    if oldest and latest:
+        print(f"  range: {oldest['ts'][:16]} → {latest['ts'][:16]}")

ccmeter-0.0.1/docs/evidence.md

@@ -0,0 +1,43 @@
+# Evidence: Anthropic's pattern of opaque limit changes
+
+## Incident 1: Christmas 2x promo → post-holiday nerf (Dec 25, 2025 – Jan 5, 2026)
+
+Anthropic ran a 2x usage promotion from December 25 at 00:00 UTC through December 31, covering Pro and Max subscribers across claude.ai, Claude Code, and Claude in Chrome.
+
+When it expired, limits felt tighter than pre-promotion baseline. A Claude Code user provided The Register with screenshots showing roughly 60% reduction in token usage limits based on token-level analysis of Claude Code logs. Anthropic's response: users are "reacting to the withdrawal of bonus usage awarded over the holidays."
+
+A Max plan subscriber who'd rarely hit limits filed a GitHub bug report on January 4 — hitting rate limits within an hour of normal usage since January 1st, theorizing limits reverted to a tighter fall baseline rather than the pre-promotion level.
+
+On forums, Reddit, and the Claude Developers Discord, developers reported token consumption suddenly increasing, with accounts reaching maximum within minutes or hours on tasks that previously worked fine.
+
+## Incident 2: Third-party tool crackdown (January 9, 2026)
+
+On January 9 at 02:20 UTC, Anthropic deployed safeguards blocking third-party tools using subscription OAuth tokens. No warning. No migration path.
+
+Tools like OpenCode had been using subscription tokens to access Claude at flat rates rather than metered API pricing. The economic gap: a month of heavy Claude Code usage can easily exceed $1,000 via API.
+
+DHH called the move "very customer hostile." Some users reported being banned within 20 minutes of starting a task on the $200/month Max plan. Anthropic later reversed erroneous bans.
+
+## Incident 3: March 2x off-peak promo → simultaneous silent nerf (Mar 13–28, 2026)
+
+From March 13 through March 28, five-hour usage was doubled during off-peak hours (outside 8 AM–2 PM ET on weekdays). Framed as a thank-you for growth after a competitor boycott drove Claude to #1 on the App Store.
+
+During the same promotional period, Anthropic silently tightened peak-hour session limits. Reports started around March 23, with a $200 Max subscriber posting screenshots showing session usage climbing from 52% to 68% to 91% within minutes of a five-hour window.
+
+The explanation came days later — not as a blog post, but a tweet thread from Thariq, one engineer. About 7% of users would now hit limits they wouldn't have before. Pro subscribers most affected.
+
+## The pattern
+
+Same structure every time:
+
+1. Announce generous temporary promotion
+2. Silently tighten baseline limits during or immediately after the promotion window
+3. Attribute complaints to "contrast effect" or "return to normal"
+
+Meanwhile: Anthropic does not publish token budgets, does not version cap announcements, and does not provide a changelog when limits change. The usage API reports percentages at 1% granularity — a percentage of an undisclosed number.
+
+## Why this matters
+
+This isn't about the limits being too low. It's about the opacity.
+
+If you're paying $200/month for Max 20x, you should be able to answer: "20x what?" Anthropic doesn't say. The only way to find out is to measure it yourself — which is what ccmeter does.

ccmeter-0.0.1/justfile

@@ -0,0 +1,16 @@
+default:
+    @just --list
+
+install:
+    uv sync
+
+format:
+    uv run ruff format . && uv run ruff check --fix . || true
+
+lint:
+    uv run ruff check .
+
+test:
+    uv run pytest tests/ -q
+
+ci: lint test

ccmeter-0.0.1/pyproject.toml

@@ -0,0 +1,43 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "ccmeter"
+version = "0.0.1"
+description = "Reverse-engineer Anthropic's opaque Claude subscription limits into hard numbers"
+authors = [{name = "Tyson Chan", email = "tyson.chan@proton.me"}]
+keywords = ["claude", "anthropic", "usage", "limits", "transparency", "metering"]
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.12"
+classifiers = [
+    "Development Status :: 2 - Pre-Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: System :: Monitoring",
+]
+
+dependencies = [
+    "fncli",
+]
+
+[project.scripts]
+ccmeter = "ccmeter.cli:main"
+
+[project.urls]
+Repository = "https://github.com/iteebz/ccmeter"
+Issues = "https://github.com/iteebz/ccmeter/issues"
+
+[dependency-groups]
+dev = [
+    "ruff>=0.13.0",
+    "pytest>=8.4.0",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["ccmeter"]

ccmeter-0.0.1/ruff.toml

@@ -0,0 +1,43 @@
+line-length = 120
+target-version = "py312"
+
+[format]
+quote-style = "double"
+indent-style = "space"
+
+[lint]
+select = [
+    "E",      # pycodestyle errors
+    "W",      # pycodestyle warnings
+    "F",      # pyflakes
+    "I",      # isort
+    "N",      # pep8-naming
+    "UP",     # pyupgrade
+    "B",      # flake8-bugbear
+    "C4",     # flake8-comprehensions
+    "SIM",    # flake8-simplify
+    "RET",    # flake8-return
+    "S",      # flake8-bandit (security)
+    "PTH",    # flake8-use-pathlib
+    "PERF",   # perflint
+    "RUF",    # ruff-specific
+    "TID",    # tidy imports
+    "PIE",    # misc lints
+    "T20",    # flake8-print
+    "FLY",    # flynt (f-strings)
+    "FURB",   # refurb (modern python)
+    "PLC",    # pylint conventions
+]
+ignore = [
+    "SIM108",   # ternary not always clearer
+    "E501",     # line length (formatter handles)
+    "S104",     # binding to all interfaces
+    "S603",     # subprocess calls intentional
+    "S607",     # partial executable path
+    "T201",     # print() is the CLI output primitive
+    "PLC0415",  # deferred imports for fast CLI startup
+]
+
+[lint.per-file-ignores]
+"tests/**/*.py" = ["S101", "S105"]
+"ccmeter/poll.py" = ["S310"]

ccmeter-0.0.1/uv.lock

@@ -0,0 +1,121 @@
+version = 1
+revision = 3
+requires-python = ">=3.12"
+
+[[package]]
+name = "ccmeter"
+version = "0.0.1"
+source = { editable = "." }
+dependencies = [
+    { name = "fncli" },
+]
+
+[package.dev-dependencies]
+dev = [
+    { name = "pytest" },
+    { name = "ruff" },
+]
+
+[package.metadata]
+requires-dist = [{ name = "fncli" }]
+
+[package.metadata.requires-dev]
+dev = [
+    { name = "pytest", specifier = ">=8.4.0" },
+    { name = "ruff", specifier = ">=0.13.0" },
+]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "fncli"
+version = "0.0.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/74/97/55543a2f0854571a6d3ca9c87e1c0986c7599bc4d7490026ba7b156d15ba/fncli-0.0.1.tar.gz", hash = "sha256:1408b7e3031a2b0637d4a6c1f0f852a6169432d29a09e41a97d448a5c2cd20bb", size = 2230, upload-time = "2026-02-22T08:27:49.453Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8f/81/300be30b0492b0a8d7bd7a59c01bb902d1b47863af4ea72cd174652ed21a/fncli-0.0.1-py3-none-any.whl", hash = "sha256:99493151288c1c7fde464a23c4645d2c330f2bb968c35489b02cafd907c30328", size = 2659, upload-time = "2026-02-22T08:27:48.397Z" },
+]
+
+[[package]]
+name = "iniconfig"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
+]
+
+[[package]]
+name = "packaging"
+version = "26.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/65/ee/299d360cdc32edc7d2cf530f3accf79c4fca01e96ffc950d8a52213bd8e4/packaging-26.0.tar.gz", hash = "sha256:00243ae351a257117b6a241061796684b084ed1c516a08c48a3f7e147a9d80b4", size = 143416, upload-time = "2026-01-21T20:50:39.064Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b7/b9/c538f279a4e237a006a2c98387d081e9eb060d203d8ed34467cc0f0b9b53/packaging-26.0-py3-none-any.whl", hash = "sha256:b36f1fef9334a5588b4166f8bcd26a14e521f2b55e6b9de3aaa80d3ff7a37529", size = 74366, upload-time = "2026-01-21T20:50:37.788Z" },
+]
+
+[[package]]
+name = "pluggy"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
+]
+
+[[package]]
+name = "pygments"
+version = "2.20.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c3/b2/bc9c9196916376152d655522fdcebac55e66de6603a76a02bca1b6414f6c/pygments-2.20.0.tar.gz", hash = "sha256:6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f", size = 4955991, upload-time = "2026-03-29T13:29:33.898Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", hash = "sha256:81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176", size = 1231151, upload-time = "2026-03-29T13:29:30.038Z" },
+]
+
+[[package]]
+name = "pytest"
+version = "9.0.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "iniconfig" },
+    { name = "packaging" },
+    { name = "pluggy" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d1/db/7ef3487e0fb0049ddb5ce41d3a49c235bf9ad299b6a25d5780a89f19230f/pytest-9.0.2.tar.gz", hash = "sha256:75186651a92bd89611d1d9fc20f0b4345fd827c41ccd5c299a868a05d70edf11", size = 1568901, upload-time = "2025-12-06T21:30:51.014Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3b/ab/b3226f0bd7cdcf710fbede2b3548584366da3b19b5021e74f5bde2a8fa3f/pytest-9.0.2-py3-none-any.whl", hash = "sha256:711ffd45bf766d5264d487b917733b453d917afd2b0ad65223959f59089f875b", size = 374801, upload-time = "2025-12-06T21:30:49.154Z" },
+]
+
+[[package]]
+name = "ruff"
+version = "0.15.8"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/14/b0/73cf7550861e2b4824950b8b52eebdcc5adc792a00c514406556c5b80817/ruff-0.15.8.tar.gz", hash = "sha256:995f11f63597ee362130d1d5a327a87cb6f3f5eae3094c620bcc632329a4d26e", size = 4610921, upload-time = "2026-03-26T18:39:38.675Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4a/92/c445b0cd6da6e7ae51e954939cb69f97e008dbe750cfca89b8cedc081be7/ruff-0.15.8-py3-none-linux_armv6l.whl", hash = "sha256:cbe05adeba76d58162762d6b239c9056f1a15a55bd4b346cfd21e26cd6ad7bc7", size = 10527394, upload-time = "2026-03-26T18:39:41.566Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/92/f1c662784d149ad1414cae450b082cf736430c12ca78367f20f5ed569d65/ruff-0.15.8-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:d3e3d0b6ba8dca1b7ef9ab80a28e840a20070c4b62e56d675c24f366ef330570", size = 10905693, upload-time = "2026-03-26T18:39:30.364Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/f2/7a631a8af6d88bcef997eb1bf87cc3da158294c57044aafd3e17030613de/ruff-0.15.8-py3-none-macosx_11_0_arm64.whl", hash = "sha256:6ee3ae5c65a42f273f126686353f2e08ff29927b7b7e203b711514370d500de3", size = 10323044, upload-time = "2026-03-26T18:39:33.37Z" },
+    { url = "https://files.pythonhosted.org/packages/67/18/1bf38e20914a05e72ef3b9569b1d5c70a7ef26cd188d69e9ca8ef588d5bf/ruff-0.15.8-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fdce027ada77baa448077ccc6ebb2fa9c3c62fd110d8659d601cf2f475858d94", size = 10629135, upload-time = "2026-03-26T18:39:44.142Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/e9/138c150ff9af60556121623d41aba18b7b57d95ac032e177b6a53789d279/ruff-0.15.8-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:12e617fc01a95e5821648a6df341d80456bd627bfab8a829f7cfc26a14a4b4a3", size = 10348041, upload-time = "2026-03-26T18:39:52.178Z" },
+    { url = "https://files.pythonhosted.org/packages/02/f1/5bfb9298d9c323f842c5ddeb85f1f10ef51516ac7a34ba446c9347d898df/ruff-0.15.8-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:432701303b26416d22ba696c39f2c6f12499b89093b61360abc34bcc9bf07762", size = 11121987, upload-time = "2026-03-26T18:39:55.195Z" },
+    { url = "https://files.pythonhosted.org/packages/10/11/6da2e538704e753c04e8d86b1fc55712fdbdcc266af1a1ece7a51fff0d10/ruff-0.15.8-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d910ae974b7a06a33a057cb87d2a10792a3b2b3b35e33d2699fdf63ec8f6b17a", size = 11951057, upload-time = "2026-03-26T18:39:19.18Z" },
+    { url = "https://files.pythonhosted.org/packages/83/f0/c9208c5fd5101bf87002fed774ff25a96eea313d305f1e5d5744698dc314/ruff-0.15.8-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2033f963c43949d51e6fdccd3946633c6b37c484f5f98c3035f49c27395a8ab8", size = 11464613, upload-time = "2026-03-26T18:40:06.301Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/22/d7f2fabdba4fae9f3b570e5605d5eb4500dcb7b770d3217dca4428484b17/ruff-0.15.8-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0f29b989a55572fb885b77464cf24af05500806ab4edf9a0fd8977f9759d85b1", size = 11257557, upload-time = "2026-03-26T18:39:57.972Z" },
+    { url = "https://files.pythonhosted.org/packages/71/8c/382a9620038cf6906446b23ce8632ab8c0811b8f9d3e764f58bedd0c9a6f/ruff-0.15.8-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:ac51d486bf457cdc985a412fb1801b2dfd1bd8838372fc55de64b1510eff4bec", size = 11169440, upload-time = "2026-03-26T18:39:22.205Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/0d/0994c802a7eaaf99380085e4e40c845f8e32a562e20a38ec06174b52ef24/ruff-0.15.8-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:c9861eb959edab053c10ad62c278835ee69ca527b6dcd72b47d5c1e5648964f6", size = 10605963, upload-time = "2026-03-26T18:39:46.682Z" },
+    { url = "https://files.pythonhosted.org/packages/19/aa/d624b86f5b0aad7cef6bbf9cd47a6a02dfdc4f72c92a337d724e39c9d14b/ruff-0.15.8-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:8d9a5b8ea13f26ae90838afc33f91b547e61b794865374f114f349e9036835fb", size = 10357484, upload-time = "2026-03-26T18:39:49.176Z" },
+    { url = "https://files.pythonhosted.org/packages/35/c3/e0b7835d23001f7d999f3895c6b569927c4d39912286897f625736e1fd04/ruff-0.15.8-py3-none-musllinux_1_2_i686.whl", hash = "sha256:c2a33a529fb3cbc23a7124b5c6ff121e4d6228029cba374777bd7649cc8598b8", size = 10830426, upload-time = "2026-03-26T18:40:03.702Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/51/ab20b322f637b369383adc341d761eaaa0f0203d6b9a7421cd6e783d81b9/ruff-0.15.8-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:75e5cd06b1cf3f47a3996cfc999226b19aa92e7cce682dcd62f80d7035f98f49", size = 11345125, upload-time = "2026-03-26T18:39:27.799Z" },
+    { url = "https://files.pythonhosted.org/packages/37/e6/90b2b33419f59d0f2c4c8a48a4b74b460709a557e8e0064cf33ad894f983/ruff-0.15.8-py3-none-win32.whl", hash = "sha256:bc1f0a51254ba21767bfa9a8b5013ca8149dcf38092e6a9eb704d876de94dc34", size = 10571959, upload-time = "2026-03-26T18:39:36.117Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/a2/ef467cb77099062317154c63f234b8a7baf7cb690b99af760c5b68b9ee7f/ruff-0.15.8-py3-none-win_amd64.whl", hash = "sha256:04f79eff02a72db209d47d665ba7ebcad609d8918a134f86cb13dd132159fc89", size = 11743893, upload-time = "2026-03-26T18:39:25.01Z" },
+    { url = "https://files.pythonhosted.org/packages/15/e2/77be4fff062fa78d9b2a4dea85d14785dac5f1d0c1fb58ed52331f0ebe28/ruff-0.15.8-py3-none-win_arm64.whl", hash = "sha256:cf891fa8e3bb430c0e7fac93851a5978fc99c8fa2c053b57b118972866f8e5f2", size = 11048175, upload-time = "2026-03-26T18:40:01.06Z" },
+]