llmapi-tracker 1.0.0__py3-none-any.whl

api_tracker/__init__.py

@@ -0,0 +1,5 @@
+from .client import APITracker
+from .providers.gemini import GeminiTracker
+from .providers.openai import OpenAITracker
+
+__all__ = ["APITracker", "OpenAITracker", "GeminiTracker"]

api_tracker/client.py

@@ -0,0 +1,49 @@
+from .providers.openai import (
+    OpenAITracker,
+)
+
+from .providers.gemini import (
+    GeminiTracker,
+)
+
+
+class APITracker:
+
+    def __init__(
+        self,
+        project: str,
+        backend_url:
+            str = "http://localhost:8000",
+        openai_api_key: str = None,
+        gemini_api_key: str = None,
+    ):
+
+        self.project = project
+
+        self.backend_url = backend_url
+
+        self.openai = None
+
+        self.gemini = None
+
+        if openai_api_key:
+
+            self.openai = OpenAITracker(
+
+                api_key=openai_api_key,
+
+                project=project,
+
+                backend_url=backend_url,
+            )
+
+        if gemini_api_key:
+
+            self.gemini = GeminiTracker(
+
+                api_key=gemini_api_key,
+
+                project=project,
+
+                backend_url=backend_url,
+            )

api_tracker/models.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Optional
+
+
+@dataclass
+class UsageData:
+    project: str
+    provider: str
+    model: str
+    internal_request_id: str
+    provider_request_id: Optional[str] = None
+    input_tokens: int = 0
+    output_tokens: int = 0
+    thinking_tokens: int = 0
+    cached_tokens: int = 0
+    total_tokens: int = 0
+    audio_seconds: float = 0.0
+    characters: int = 0
+    request_count: int = 1
+    latency_ms: float = 0.0
+    status: str = "success"
+    http_status_code: Optional[int] = None
+    error_type: Optional[str] = None
+    metadata: dict[str, Any] = field(default_factory=dict)
+    capture_content: bool = False
+
+    def to_dict(self) -> dict[str, Any]:
+        return self.__dict__.copy()

api_tracker/pricing.py

@@ -0,0 +1,79 @@
+PRICING = {
+
+    "openai": {
+
+        "gpt-5": {
+            "input": 0.0,
+            "output": 0.0,
+            "thinking": 0.0,
+            "cached": 0.0,
+        },
+
+    },
+
+    "gemini": {
+
+        "gemini-2.5-flash": {
+            "input": 0.0,
+            "output": 0.0,
+            "thinking": 0.0,
+            "cached": 0.0,
+        },
+
+    },
+}
+
+
+def calculate_cost(
+    provider: str,
+    model: str,
+    input_tokens: int = 0,
+    output_tokens: int = 0,
+    thinking_tokens: int = 0,
+    cached_tokens: int = 0,
+):
+    provider_data = PRICING.get(
+        provider.lower(),
+        {},
+    )
+
+    model_data = provider_data.get(
+        model,
+        {
+            "input": 0.0,
+            "output": 0.0,
+            "thinking": 0.0,
+            "cached": 0.0,
+        },
+    )
+
+    input_cost = (
+        input_tokens / 1_000_000
+    ) * model_data["input"]
+
+    output_cost = (
+        output_tokens / 1_000_000
+    ) * model_data["output"]
+
+    thinking_cost = (
+        thinking_tokens / 1_000_000
+    ) * model_data["thinking"]
+
+    cached_cost = (
+        cached_tokens / 1_000_000
+    ) * model_data["cached"]
+
+    total_cost = (
+        input_cost
+        + output_cost
+        + thinking_cost
+        + cached_cost
+    )
+
+    return {
+        "input_cost": input_cost,
+        "output_cost": output_cost,
+        "thinking_cost": thinking_cost,
+        "cached_cost": cached_cost,
+        "total_cost": total_cost,
+    }

api_tracker/providers/__init__.py

@@ -0,0 +1,8 @@
+from .openai import OpenAITracker
+from .gemini import GeminiTracker
+
+
+__all__ = [
+    "OpenAITracker",
+    "GeminiTracker",
+]

api_tracker/providers/gemini.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+import time
+
+from google import genai
+
+from ..tracker import Tracker
+
+
+class GeminiTracker:
+    def __init__(self, api_key: str, project: str, backend_url: str = "http://localhost:8000"):
+        self.client = genai.Client(api_key=api_key)
+        self.tracker = Tracker(project=project, provider="gemini", backend_url=backend_url)
+
+    def generate(self, model: str, contents, **kwargs):
+        start = time.perf_counter()
+        try:
+            response = self.client.models.generate_content(model=model, contents=contents, **kwargs)
+            latency_ms = (time.perf_counter() - start) * 1000
+            usage = getattr(response, "usage_metadata", None)
+            self.tracker.record(
+                model=model,
+                input_tokens=getattr(usage, "prompt_token_count", 0) if usage else 0,
+                output_tokens=getattr(usage, "candidates_token_count", 0) if usage else 0,
+                thinking_tokens=getattr(usage, "thoughts_token_count", 0) if usage else 0,
+                cached_tokens=getattr(usage, "cached_content_token_count", 0) if usage else 0,
+                total_tokens=getattr(usage, "total_token_count", 0) if usage else 0,
+                provider_request_id=getattr(response, "response_id", None),
+                latency_ms=latency_ms,
+                status="success",
+            )
+            return response
+        except Exception as exc:
+            latency_ms = (time.perf_counter() - start) * 1000
+            self.tracker.record(model=model, latency_ms=latency_ms, status="error", error_type=type(exc).__name__)
+            raise

api_tracker/providers/openai.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+import time
+
+from openai import OpenAI
+
+from ..tracker import Tracker
+
+
+class OpenAITracker:
+    def __init__(self, api_key: str, project: str, backend_url: str = "http://localhost:8000"):
+        self.client = OpenAI(api_key=api_key)
+        self.tracker = Tracker(project=project, provider="openai", backend_url=backend_url)
+
+    def chat(self, model: str, messages: list, **kwargs):
+        start = time.perf_counter()
+        try:
+            response = self.client.chat.completions.create(model=model, messages=messages, **kwargs)
+            latency_ms = (time.perf_counter() - start) * 1000
+            usage = getattr(response, "usage", None)
+            self.tracker.record(
+                model=model,
+                input_tokens=getattr(usage, "prompt_tokens", 0) if usage else 0,
+                output_tokens=getattr(usage, "completion_tokens", 0) if usage else 0,
+                thinking_tokens=getattr(usage, "reasoning_tokens", 0) if usage else 0,
+                cached_tokens=getattr(usage, "cached_tokens", 0) if usage else 0,
+                total_tokens=getattr(usage, "total_tokens", 0) if usage else 0,
+                provider_request_id=getattr(response, "_request_id", None),
+                latency_ms=latency_ms,
+                status="success",
+            )
+            return response
+        except Exception as exc:
+            latency_ms = (time.perf_counter() - start) * 1000
+            self.tracker.record(model=model, latency_ms=latency_ms, status="error", error_type=type(exc).__name__)
+            raise

api_tracker/py.typed

@@ -0,0 +1 @@
+

api_tracker/tracker.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import logging
+import uuid
+
+from .models import UsageData
+from .transport import TrackerTransport
+
+logger = logging.getLogger(__name__)
+
+
+class Tracker:
+    def __init__(self, project: str, provider: str, backend_url: str = "http://localhost:8000"):
+        self.project = project
+        self.provider = provider
+        self.transport = TrackerTransport(backend_url)
+
+    def record(self, model: str, **kwargs):
+        def _int_or_zero(value):
+            return 0 if value is None else int(value)
+
+        usage = UsageData(
+            project=self.project,
+            provider=self.provider,
+            model=model,
+            internal_request_id=kwargs.get("internal_request_id") or str(uuid.uuid4()),
+            provider_request_id=kwargs.get("provider_request_id"),
+            input_tokens=_int_or_zero(kwargs.get("input_tokens", 0)),
+            output_tokens=_int_or_zero(kwargs.get("output_tokens", 0)),
+            thinking_tokens=_int_or_zero(kwargs.get("thinking_tokens", 0)),
+            cached_tokens=_int_or_zero(kwargs.get("cached_tokens", 0)),
+            total_tokens=_int_or_zero(kwargs.get("total_tokens", 0)),
+            audio_seconds=kwargs.get("audio_seconds", 0.0),
+            characters=kwargs.get("characters", 0),
+            request_count=kwargs.get("request_count", 1),
+            latency_ms=kwargs.get("latency_ms", 0.0),
+            status=kwargs.get("status", "success"),
+            http_status_code=kwargs.get("http_status_code"),
+            error_type=kwargs.get("error_type"),
+            metadata=kwargs.get("metadata", {}),
+            capture_content=kwargs.get("capture_content", False),
+        )
+        try:
+            self.transport.send_usage(usage.to_dict())
+        except Exception as exc:
+            logger.exception("Tracking failed: %s", exc)
+        return usage

api_tracker/transport.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+import logging
+
+import requests
+
+logger = logging.getLogger(__name__)
+
+
+class TrackerTransport:
+    def __init__(self, endpoint: str, timeout: float = 2.0):
+        self.endpoint = endpoint.rstrip("/")
+        self.timeout = timeout
+
+    def send_usage(self, usage: dict) -> bool:
+        try:
+            response = requests.post(f"{self.endpoint}/usage", json=usage, timeout=self.timeout)
+            if not response.ok:
+                print("Usage payload:", usage)
+                print("Backend response:", response.status_code, response.text)
+            response.raise_for_status()
+            return True
+        except Exception as exc:
+            logger.exception("API Tracker failed to record usage: %s", exc)
+            return False

backend/__init__.py

@@ -0,0 +1 @@
+

backend/app/__init__.py

@@ -0,0 +1 @@
+

backend/app/database.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+import os
+
+from sqlalchemy import create_engine
+from sqlalchemy.orm import declarative_base, sessionmaker
+
+from .paths import get_database_url
+
+DATABASE_URL = get_database_url()
+
+connect_args = {"check_same_thread": False} if DATABASE_URL.startswith("sqlite") else {}
+
+engine = create_engine(DATABASE_URL, connect_args=connect_args, future=True)
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine, future=True)
+Base = declarative_base()
+
+
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()

backend/app/frontend.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from fastapi import APIRouter
+from fastapi.responses import FileResponse
+from fastapi.staticfiles import StaticFiles
+
+from .paths import get_frontend_dist_dir
+
+
+def mount_frontend(app, prefix: str = "") -> None:
+    static_dir = get_frontend_dist_dir()
+    if static_dir.exists():
+        app.mount(prefix or "/assets", StaticFiles(directory=static_dir / "assets"), name="assets")
+
+
+def register_frontend_routes(router: APIRouter) -> None:
+    static_dir = get_frontend_dist_dir()
+    index_path = static_dir / "index.html"
+
+    if not index_path.exists():
+        return
+
+    @router.get("/{path:path}")
+    @router.get("/")
+    def serve_frontend(path: str = ""):
+        target = static_dir / path
+        if path and target.exists() and target.is_file():
+            return FileResponse(target)
+        return FileResponse(index_path)

backend/app/launcher.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+import os
+import threading
+import webbrowser
+
+import uvicorn
+
+
+def launch_app() -> None:
+    host = os.getenv("API_TRACKER_HOST", "127.0.0.1")
+    port = int(os.getenv("API_TRACKER_PORT", "8000"))
+    open_browser = os.getenv("API_TRACKER_OPEN_BROWSER", "true").lower() not in {"0", "false", "no"}
+    if open_browser:
+        url = f"http://{host}:{port}"
+        threading.Timer(1.0, lambda: webbrowser.open(url)).start()
+    uvicorn.run("backend.app.main:app", host=host, port=port, reload=False)

backend/app/main.py

@@ -0,0 +1,57 @@
+from pathlib import Path
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse
+from fastapi.staticfiles import StaticFiles
+
+from .database import Base, engine
+from .paths import get_frontend_dist_dir
+from .routes import analytics, models, pricing, projects, providers, usage
+
+Base.metadata.create_all(bind=engine)
+
+app = FastAPI(title="API Tracker", version="1.0.0")
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.include_router(projects.router)
+app.include_router(usage.router)
+app.include_router(pricing.router)
+app.include_router(providers.router)
+app.include_router(models.router)
+app.include_router(analytics.router)
+
+frontend_dist = get_frontend_dist_dir()
+index_file = frontend_dist / "index.html"
+assets_dir = frontend_dist / "assets"
+
+if assets_dir.exists():
+    app.mount("/assets", StaticFiles(directory=assets_dir), name="assets")
+
+
+@app.get("/")
+def root():
+    if index_file.exists():
+        return FileResponse(index_file)
+    return {"name": "API Tracker", "status": "running"}
+
+
+@app.get("/{path:path}")
+def frontend_fallback(path: str):
+    target = frontend_dist / path
+    if target.exists() and target.is_file():
+        return FileResponse(target)
+    if index_file.exists():
+        return FileResponse(index_file)
+    return {"detail": "frontend not built"}
+
+
+@app.get("/health")
+def health():
+    return {"status": "healthy"}

backend/app/models.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+from datetime import datetime
+
+from sqlalchemy import (
+    JSON,
+    Boolean,
+    Column,
+    DateTime,
+    Float,
+    ForeignKey,
+    Integer,
+    String,
+    Text,
+    UniqueConstraint,
+)
+from sqlalchemy.orm import relationship
+
+from .database import Base
+
+
+def utcnow() -> datetime:
+    return datetime.utcnow()
+
+
+class Project(Base):
+    __tablename__ = "projects"
+
+    id = Column(Integer, primary_key=True, index=True)
+    name = Column(String(150), unique=True, nullable=False, index=True)
+    description = Column(Text, nullable=True)
+    environment = Column(String(50), default="development", nullable=False)
+    created_at = Column(DateTime, default=utcnow, nullable=False)
+
+    usage = relationship("ApiUsage", back_populates="project")
+
+
+class Provider(Base):
+    __tablename__ = "providers"
+
+    id = Column(Integer, primary_key=True, index=True)
+    name = Column(String(100), unique=True, nullable=False, index=True)
+    created_at = Column(DateTime, default=utcnow, nullable=False)
+
+    models = relationship("Model", back_populates="provider", cascade="all, delete-orphan")
+
+
+class Model(Base):
+    __tablename__ = "models"
+    __table_args__ = (UniqueConstraint("provider_id", "model_name", name="uq_provider_model_name"),)
+
+    id = Column(Integer, primary_key=True, index=True)
+    provider_id = Column(Integer, ForeignKey("providers.id"), nullable=False, index=True)
+    model_name = Column(String(150), nullable=False, index=True)
+    model_type = Column(String(50), default="text", nullable=False)
+    created_at = Column(DateTime, default=utcnow, nullable=False)
+
+    provider = relationship("Provider", back_populates="models")
+    pricing = relationship("ModelPricing", back_populates="model", cascade="all, delete-orphan")
+    usage = relationship("ApiUsage", back_populates="model_ref")
+
+
+class ModelPricing(Base):
+    __tablename__ = "model_pricing"
+    __table_args__ = (
+        UniqueConstraint("model_id", "effective_from", name="uq_model_pricing_version"),
+    )
+
+    id = Column(Integer, primary_key=True, index=True)
+    model_id = Column(Integer, ForeignKey("models.id"), nullable=False, index=True)
+    input_price_per_1m = Column(Float, default=0.0, nullable=False)
+    output_price_per_1m = Column(Float, default=0.0, nullable=False)
+    thinking_price_per_1m = Column(Float, default=0.0, nullable=False)
+    cached_input_price_per_1m = Column(Float, default=0.0, nullable=False)
+    currency = Column(String(10), default="USD", nullable=False)
+    effective_from = Column(DateTime, default=utcnow, nullable=False, index=True)
+    effective_to = Column(DateTime, nullable=True, index=True)
+    created_at = Column(DateTime, default=utcnow, nullable=False)
+    updated_at = Column(DateTime, default=utcnow, onupdate=utcnow, nullable=False)
+
+    model = relationship("Model", back_populates="pricing")
+
+
+class ApiUsage(Base):
+    __tablename__ = "api_usage"
+
+    id = Column(Integer, primary_key=True, index=True)
+    project_id = Column(Integer, ForeignKey("projects.id"), nullable=False, index=True)
+    provider_id = Column(Integer, ForeignKey("providers.id"), nullable=False, index=True)
+    model_id = Column(Integer, ForeignKey("models.id"), nullable=False, index=True)
+    internal_request_id = Column(String(255), nullable=False, unique=True, index=True)
+    provider_request_id = Column(String(255), nullable=True, index=True)
+    timestamp = Column(DateTime, default=utcnow, nullable=False, index=True)
+    input_tokens = Column(Integer, default=0, nullable=False)
+    output_tokens = Column(Integer, default=0, nullable=False)
+    thinking_tokens = Column(Integer, default=0, nullable=False)
+    cached_tokens = Column(Integer, default=0, nullable=False)
+    total_tokens = Column(Integer, default=0, nullable=False)
+    input_cost = Column(Float, default=0.0, nullable=False)
+    output_cost = Column(Float, default=0.0, nullable=False)
+    thinking_cost = Column(Float, default=0.0, nullable=False)
+    cached_cost = Column(Float, default=0.0, nullable=False)
+    total_cost = Column(Float, default=0.0, nullable=False)
+    audio_seconds = Column(Float, default=0.0, nullable=False)
+    characters = Column(Integer, default=0, nullable=False)
+    request_count = Column(Integer, default=1, nullable=False)
+    latency_ms = Column(Float, default=0.0, nullable=False)
+    status = Column(String(30), default="success", nullable=False)
+    http_status_code = Column(Integer, nullable=True)
+    error_type = Column(String(100), nullable=True)
+    metadata_json = Column(JSON, default=dict, nullable=False)
+    capture_content = Column(Boolean, default=False, nullable=False)
+
+    project = relationship("Project", back_populates="usage")
+    provider = relationship("Provider")
+    model_ref = relationship("Model", back_populates="usage")

backend/app/paths.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+
+APP_NAME = "API Tracker"
+
+
+def _ensure_dir(path: Path) -> Path:
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def get_data_dir() -> Path:
+    override = os.getenv("API_TRACKER_DATA_DIR")
+    if override:
+        return _ensure_dir(Path(override).expanduser())
+
+    if os.name == "nt":
+        base = os.getenv("LOCALAPPDATA") or Path.home() / "AppData" / "Local"
+        preferred = Path(base) / "APITracker"
+        try:
+            return _ensure_dir(preferred)
+        except PermissionError:
+            return _ensure_dir(Path.cwd() / ".api-tracker-data")
+
+    if os.name == "posix":
+        base = os.getenv("XDG_DATA_HOME")
+        if base:
+            preferred = Path(base) / "APITracker"
+        else:
+            preferred = Path.home() / ".local" / "share" / "APITracker"
+        try:
+            return _ensure_dir(preferred)
+        except PermissionError:
+            return _ensure_dir(Path.cwd() / ".api-tracker-data")
+
+    return _ensure_dir(Path.cwd() / ".api-tracker-data")
+
+
+def get_database_path() -> Path:
+    override = os.getenv("API_TRACKER_DB_PATH")
+    if override:
+        path = Path(override).expanduser()
+    else:
+        path = get_data_dir() / "api_tracker.db"
+    path.parent.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def get_database_url() -> str:
+    override = os.getenv("DATABASE_URL")
+    if override:
+        return override
+    return f"sqlite:///{get_database_path().as_posix()}"
+
+
+def get_frontend_dist_dir() -> Path:
+    return Path(__file__).resolve().parent / "static"

backend/app/routes/__init__.py

@@ -0,0 +1 @@
+from . import analytics, models, pricing, projects, providers, usage