claude-usage 0.0.1__py3-none-any.whl

OAuth_credentials.py

@@ -0,0 +1,73 @@
+import os
+import logging
+import subprocess
+import json
+import time
+import requests
+
+from .config import PLATFORM_URL, OAUTH_CLIENT_ID
+
+def read_claude_code_creds() -> dict:
+    result = subprocess.run(
+        ["security", "find-generic-password", "-s", "Claude Code-credentials", "-w"],
+        capture_output=True, text=True,
+    )
+    if result.returncode != 0:
+        raise RuntimeError("Claude Code-credentials not found in keychain. Is Claude Code installed and logged in?")
+    return json.loads(result.stdout.strip())
+
+
+def write_claude_code_creds(creds: dict) -> None:
+    blob = json.dumps(creds)
+    subprocess.run(["security", "delete-generic-password", "-s", "Claude Code-credentials"],
+                   capture_output=True)
+    subprocess.run(
+        ["security", "add-generic-password", "-s", "Claude Code-credentials",
+         "-a", os.environ.get("USER", ""), "-w", blob],
+        capture_output=True, check=True,
+    )
+
+
+def get_valid_token() -> str:
+    """Return a valid access token, refreshing via OAuth if expired."""
+    creds  = read_claude_code_creds()
+    oauth  = creds["claudeAiOauth"]
+
+    expires_at_ms = oauth.get("expiresAt", 0)
+    now_ms        = time.time() * 1000
+
+    if now_ms < expires_at_ms - 60_000:
+        return oauth["accessToken"]
+
+    logging.info("OAuth token expired - refreshing")
+    r = requests.post(
+        f"{PLATFORM_URL}/v1/oauth/token",
+        json={
+            "grant_type":    "refresh_token",
+            "refresh_token": oauth["refreshToken"],
+            "client_id":     OAUTH_CLIENT_ID,
+        },
+        timeout=15,
+    )
+    if not r.ok:
+        raise RuntimeError(f"Token refresh failed: HTTP {r.status_code} {r.text[:200]}")
+
+    new_token = r.json()
+    oauth["accessToken"] = new_token.get("access_token", oauth["accessToken"])
+    if "refresh_token" in new_token:
+        oauth["refreshToken"] = new_token["refresh_token"]
+    if "expires_in" in new_token:
+        oauth["expiresAt"] = int((time.time() + new_token["expires_in"]) * 1000)
+    creds["claudeAiOauth"] = oauth
+    write_claude_code_creds(creds)
+    logging.info("Keychain updated with refreshed token")
+    return oauth["accessToken"]
+
+
+
+def is_logged_in() -> bool:
+    try:
+        read_claude_code_creds()
+        return True
+    except Exception:
+        return False

claude_usage-0.0.1.dist-info/METADATA

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: claude-usage
+Version: 0.0.1
+Summary: macOS menu bar app for Anthropic API usage and cost tracking
+Requires-Python: >=3.11
+Requires-Dist: rumps>=0.4.0
+Requires-Dist: requests>=2.32.3
+Requires-Dist: keyring>=25.6.0
+Requires-Dist: python-dotenv>=1.0.1
+Requires-Dist: pyobjc-framework-quartz>=12.1
+Requires-Dist: pyobjc-framework-coretext>=12.1

claude_usage-0.0.1.dist-info/RECORD

@@ -0,0 +1,11 @@
+OAuth_credentials.py,sha256=va1gyVbq-3_kDswEKNkl_93MPTD-Sn0_D1oQDqmVMjE,2315
+config.py,sha256=vcfM5SZ8lxjhrT-ebOgjWNvxd5CGoUxexLUSF_epyFU,196
+context_menus.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+draw_icon.py,sha256=tBySU3uapOD7L8_Gy4ar2llukrna4GgB4dgBcIL1DOc,3545
+format_util.py,sha256=tKmJfPlTHLjpWlHIxjAQ1EYsfQnSPnP-Rvw9dRwZS8g,446
+logging.py,sha256=tqTYj0aWgxxbmwa2f77_MiRJy04QBBu0Y0Sj6NFu55A,318
+usage_fetch.py,sha256=4dukUXKZ5Id1x4HW4hzTt3m-RN7mcfuZJBAdNvPxhHY,1934
+claude_usage-0.0.1.dist-info/METADATA,sha256=NMqJqImKYbDX2SEqEiXNpx1ZkyNnnjNVHpSQlpga_88,369
+claude_usage-0.0.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+claude_usage-0.0.1.dist-info/top_level.txt,sha256=NL2whnCrYeeYYewsrTUiZ10hpBlNH6Gp9zyMblFbcQI,81
+claude_usage-0.0.1.dist-info/RECORD,,

claude_usage-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

claude_usage-0.0.1.dist-info/top_level.txt

@@ -0,0 +1,7 @@
+OAuth_credentials
+config
+context_menus
+draw_icon
+format_util
+logging
+usage_fetch

config.py

@@ -0,0 +1,5 @@
+MESSAGES_URL    = "https://api.anthropic.com/v1/messages"
+OAUTH_CLIENT_ID = "9d1c250a-e61b-48ad-a7e6-0b5d4eb16f10"
+PLATFORM_URL    = "https://platform.claude.com"
+POLL_INTERVAL   = 60  # seconds
+

draw_icon.py

@@ -0,0 +1,99 @@
+from AppKit import (
+    NSImage, NSColor, NSBezierPath, NSFont,
+    NSMutableAttributedString, NSAttributedString,
+    NSTextAttachment, NSFontAttributeName,
+    NSForegroundColorAttributeName,
+    NSGraphicsContext,
+)
+from Foundation import NSMakeRect, NSOperationQueue
+from CoreText import (
+    CTLineCreateWithAttributedString,
+    CTLineDraw,
+    CTLineGetTypographicBounds,
+)
+from Quartz.CoreGraphics import (
+    CGContextSetTextMatrix,
+    CGContextSetTextPosition,
+    CGAffineTransformIdentity,
+)
+
+_BAT_W        = 62
+_BAT_H        = 18
+_BAT_BASELINE = -3  # vertical nudge to align battery with menu bar text baseline
+
+def battery_image(fraction: float | None, label: str) -> NSImage:
+    """
+    fraction - 0.0-1.0 fill level (amount used); None = unknown (grey outline only)
+    label    - time-remaining string drawn centred inside the battery body
+    """
+    image = NSImage.alloc().initWithSize_((_BAT_W, _BAT_H))
+    image.lockFocus()
+
+    pad       = 1
+    bump_w    = 4
+    bump_h    = int(_BAT_H * 0.4)
+    body_w    = _BAT_W - bump_w - pad * 2
+    body_h    = _BAT_H - pad * 2
+    bx, by    = float(pad), float(pad)
+    r         = 3.0
+    inner_pad = 2
+
+    NSColor.clearColor().set()
+    NSBezierPath.fillRect_(NSMakeRect(0, 0, _BAT_W, _BAT_H))
+
+    fill_frac = fraction if fraction is not None else 0.0
+    fill_w = max(0.0, (body_w - inner_pad * 2) * min(fill_frac, 1.0))
+    if fill_w > 0:
+        NSColor.whiteColor().colorWithAlphaComponent_(0.6).setFill()
+        NSBezierPath.bezierPathWithRoundedRect_xRadius_yRadius_(
+            NSMakeRect(bx + inner_pad, by + inner_pad, fill_w, body_h - inner_pad * 2),
+            max(1.0, r - 1), max(1.0, r - 1),
+        ).fill()
+
+    outline_color = NSColor.systemOrangeColor()
+
+    outline_path = NSBezierPath.bezierPathWithRoundedRect_xRadius_yRadius_(
+        NSMakeRect(bx, by, float(body_w), float(body_h)), r, r
+    )
+    outline_path.setLineWidth_(1.5)
+    outline_color.setStroke()
+    outline_path.stroke()
+
+    outline_color.setFill()
+    NSBezierPath.fillRect_(NSMakeRect(
+        bx + body_w, by + (body_h - bump_h) / 2, float(bump_w), float(bump_h),
+    ))
+
+    if label:
+        font_size = 8.5
+        font = NSFont.systemFontOfSize_(font_size)
+        text_color = NSColor.systemOrangeColor()
+        attrs = {NSFontAttributeName: font, NSForegroundColorAttributeName: text_color}
+        attr_str = NSAttributedString.alloc().initWithString_attributes_(label, attrs)
+
+        ct_line = CTLineCreateWithAttributedString(attr_str)
+        adv_w = CTLineGetTypographicBounds(ct_line, None, None, None)
+        if not isinstance(adv_w, (int, float)):
+            adv_w = adv_w[0]
+
+        cg_ctx = NSGraphicsContext.currentContext().CGContext()
+        CGContextSetTextMatrix(cg_ctx, CGAffineTransformIdentity)
+
+        ascender  = font.ascender()
+        descender = font.descender()
+        cap_h     = ascender - descender
+        text_x = bx + inner_pad + (body_w - inner_pad * 2 - adv_w) / 2
+        text_y = by + (body_h - cap_h) / 2 - descender
+        CGContextSetTextPosition(cg_ctx, text_x, text_y)
+        CTLineDraw(ct_line, cg_ctx)
+
+    image.unlockFocus()
+    image.setSize_((_BAT_W, _BAT_H))
+    return image
+
+
+def battery_attachment(fraction: float | None, label: str) -> NSAttributedString:
+    attachment = NSTextAttachment.alloc().init()
+    attachment.setImage_(battery_image(fraction, label))
+    attachment.setBounds_(NSMakeRect(0, _BAT_BASELINE, _BAT_W, _BAT_H))
+    return NSAttributedString.attributedStringWithAttachment_(attachment)

format_util.py

@@ -0,0 +1,15 @@
+from datetime import datetime, timezone
+
+def format_reset_window(reset_at: datetime | None) -> str:
+    if reset_at is None:
+        return "?"
+    delta = reset_at - datetime.now(timezone.utc)
+    total = int(delta.total_seconds())
+    if total <= 0:
+        return "now"
+    days  = total // 86400
+    hours = (total % 86400) // 3600
+    mins  = (total % 3600) // 60
+    if days >= 1:
+        return f"{days}d"
+    return f"{hours}h{mins:02d}m"

logging.py

@@ -0,0 +1,12 @@
+import logging
+from pathlib import Path
+
+LOG_FILE = Path.home() / "Library" / "Logs" / "claude_usage.log"
+LOG_FILE.parent.mkdir(parents=True, exist_ok=True)
+logging.basicConfig(
+    level=logging.DEBUG,
+    format="%(asctime)s %(levelname)s %(message)s",
+    handlers=[
+        logging.FileHandler(LOG_FILE),
+    ],
+)

usage_fetch.py

@@ -0,0 +1,56 @@
+import requests
+import logging
+from datetime import datetime, timezone
+
+from .config import MESSAGES_URL, OAUTH_CLIENT_ID, PLATFORM_URL
+from .OAuth_credentials import get_valid_token, read_claude_code_creds, write_claude_code_creds
+
+def fetch_utilization() -> dict:
+    """
+    Send a minimal 1-token message to api.anthropic.com and read the rate-limit
+    utilization headers that claude.ai subscribers receive.
+
+    Returns:
+        {
+            "five_hour":  {"utilization": 0.19, "reset_at": <datetime>},
+            "seven_day":  {"utilization": 0.94, "reset_at": <datetime>},
+        }
+    """
+    token = get_valid_token()
+    r = requests.post(
+        MESSAGES_URL,
+        headers={
+            "x-api-key":            token,
+            "anthropic-version":    "2023-06-01",
+            "content-type":         "application/json",
+        },
+        json={
+            "model":      "claude-haiku-4-5-20251001",
+            "max_tokens": 1,
+            "messages":   [{"role": "user", "content": "hi"}],
+        },
+        timeout=20,
+    )
+    logging.debug("Messages API %s headers=%s", r.status_code, dict(r.headers))
+    if not r.ok:
+        raise RuntimeError(f"Messages API HTTP {r.status_code}: {r.text[:200]}")
+
+    def _reset_dt(unix_str: str | None) -> datetime | None:
+        if not unix_str:
+            return None
+        try:
+            return datetime.fromtimestamp(int(unix_str), tz=timezone.utc)
+        except Exception:
+            return None
+
+    h = r.headers
+    return {
+        "five_hour": {
+            "utilization": float(h.get("anthropic-ratelimit-unified-5h-utilization", 0)),
+            "reset_at":    _reset_dt(h.get("anthropic-ratelimit-unified-5h-reset")),
+        },
+        "seven_day": {
+            "utilization": float(h.get("anthropic-ratelimit-unified-7d-utilization", 0)),
+            "reset_at":    _reset_dt(h.get("anthropic-ratelimit-unified-7d-reset")),
+        },
+    }