llm-tracker 0.2.0__py3-none-any.whl

llm_tracker/__init__.py

@@ -0,0 +1,24 @@
+from dotenv import load_dotenv
+
+# Load .env before any submodule reads os.environ at import time, regardless
+# of whether/when the consuming application calls load_dotenv() itself.
+load_dotenv()
+
+from .client import (
+    TrackedAsyncAzureOpenAI,
+    TrackedAsyncOpenAI,
+    TrackedAzureOpenAI,
+    TrackedOpenAI,
+    request_ctx,
+)
+
+__version__ = "0.2.0"
+
+__all__ = [
+    "TrackedAzureOpenAI",
+    "TrackedOpenAI",
+    "TrackedAsyncAzureOpenAI",
+    "TrackedAsyncOpenAI",
+    "request_ctx",
+    "__version__",
+]

llm_tracker/client.py

@@ -0,0 +1,173 @@
+import logging
+import os
+import time
+import contextvars
+from openai import AsyncAzureOpenAI, AsyncOpenAI, AzureOpenAI, OpenAI
+from .pricing import get_cost
+from .logger import log_usage
+
+logger = logging.getLogger("llm_tracker")
+
+# Holds per-request metadata (api_name, environment, user_id, request_id).
+# Set automatically by middleware.py for FastAPI routes, or left as default
+# for manual/test scripts. `default=None` (rather than a mutable {}) avoids
+# every unset context sharing — and potentially mutating — the same dict.
+request_ctx = contextvars.ContextVar("request_ctx", default=None)
+
+
+def _get_ctx():
+    return request_ctx.get() or {}
+
+
+# Default environment label when nothing is set via middleware or ctx.
+# Individual devs running local test scripts should set:
+#   export LLM_TRACKER_DEFAULT_ENV=test
+DEFAULT_ENVIRONMENT = os.getenv("LLM_TRACKER_DEFAULT_ENV", "test")
+
+
+def _build_record(deployment, usage, latency_ms):
+    ctx = _get_ctx()
+    prompt_tokens = getattr(usage, "prompt_tokens", None)
+    completion_tokens = getattr(usage, "completion_tokens", None)
+    total_tokens = getattr(usage, "total_tokens", None)
+    cost = get_cost(deployment, prompt_tokens, completion_tokens)
+
+    return {
+        "api_name": ctx.get("api_name", "manual_script"),
+        "endpoint": ctx.get("endpoint"),
+        "environment": ctx.get("environment", DEFAULT_ENVIRONMENT),
+        "user_id": ctx.get("user_id"),
+        "request_id": ctx.get("request_id"),
+        "deployment": deployment,
+        "prompt_tokens": prompt_tokens,
+        "completion_tokens": completion_tokens,
+        "total_tokens": total_tokens,
+        "cost_usd": cost,
+        "latency_ms": latency_ms,
+    }
+
+
+def _track_response(deployment, response, start):
+    latency_ms = int((time.time() - start) * 1000)
+    usage = getattr(response, "usage", None)
+    if usage is None:
+        logger.debug("no usage info on response for model=%s, skipping cost tracking", deployment)
+        return
+    log_usage(_build_record(deployment, usage, latency_ms))
+
+
+class TrackedAzureOpenAI:
+    """
+    Drop-in replacement for openai.AzureOpenAI.
+    Usage is identical to the original SDK — only the import changes.
+
+        from llm_tracker import TrackedAzureOpenAI
+        client = TrackedAzureOpenAI(
+            api_key=os.getenv("AZURE_OPENAI_API_KEY"),
+            azure_endpoint=os.getenv("AZURE_OPENAI_ENDPOINT"),
+            api_version=os.getenv("AZURE_OPENAI_API_VERSION"),
+        )
+        response = client.chat.completions.create(model="gpt-4o-mini", messages=[...])
+    """
+
+    def __init__(self, **kwargs):
+        self._client = AzureOpenAI(**kwargs)
+        self.chat = _TrackedChat(self._client)
+
+    def __getattr__(self, name):
+        return getattr(self._client, name)
+
+
+class TrackedOpenAI:
+    """
+    Drop-in replacement for openai.OpenAI.
+    Usage is identical to the original SDK — only the import changes.
+
+        from llm_tracker import TrackedOpenAI
+        client = TrackedOpenAI(
+            api_key=os.getenv("OPENAI_API_KEY"),
+            base_url=os.getenv("AZURE_OPENAI_ENDPOINT"),  # optional, for Azure routing
+        )
+        response = client.chat.completions.create(model="gpt-4o", messages=[...])
+    """
+
+    def __init__(self, **kwargs):
+        self._client = OpenAI(**kwargs)
+        self.chat = _TrackedChat(self._client)
+
+    def __getattr__(self, name):
+        return getattr(self._client, name)
+
+
+class _TrackedChat:
+    def __init__(self, client):
+        self.completions = _TrackedCompletions(client)
+
+
+class _TrackedCompletions:
+    def __init__(self, client):
+        self._client = client
+
+    def create(self, **kwargs):
+        deployment = kwargs.get("model", "unknown")
+        start = time.time()
+        response = self._client.chat.completions.create(**kwargs)
+        _track_response(deployment, response, start)
+        return response
+
+
+class TrackedAsyncAzureOpenAI:
+    """
+    Drop-in replacement for openai.AsyncAzureOpenAI.
+    Usage is identical to the original SDK — only the import changes.
+
+        from llm_tracker import TrackedAsyncAzureOpenAI
+        client = TrackedAsyncAzureOpenAI(
+            api_key=os.getenv("AZURE_OPENAI_API_KEY"),
+            azure_endpoint=os.getenv("AZURE_OPENAI_ENDPOINT"),
+            api_version=os.getenv("AZURE_OPENAI_API_VERSION"),
+        )
+        response = await client.chat.completions.create(model="gpt-4o-mini", messages=[...])
+    """
+
+    def __init__(self, **kwargs):
+        self._client = AsyncAzureOpenAI(**kwargs)
+        self.chat = _TrackedAsyncChat(self._client)
+
+    def __getattr__(self, name):
+        return getattr(self._client, name)
+
+
+class TrackedAsyncOpenAI:
+    """
+    Drop-in replacement for openai.AsyncOpenAI.
+    Usage is identical to the original SDK — only the import changes.
+
+        from llm_tracker import TrackedAsyncOpenAI
+        client = TrackedAsyncOpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+        response = await client.chat.completions.create(model="gpt-4o", messages=[...])
+    """
+
+    def __init__(self, **kwargs):
+        self._client = AsyncOpenAI(**kwargs)
+        self.chat = _TrackedAsyncChat(self._client)
+
+    def __getattr__(self, name):
+        return getattr(self._client, name)
+
+
+class _TrackedAsyncChat:
+    def __init__(self, client):
+        self.completions = _TrackedAsyncCompletions(client)
+
+
+class _TrackedAsyncCompletions:
+    def __init__(self, client):
+        self._client = client
+
+    async def create(self, **kwargs):
+        deployment = kwargs.get("model", "unknown")
+        start = time.time()
+        response = await self._client.chat.completions.create(**kwargs)
+        _track_response(deployment, response, start)
+        return response

llm_tracker/db.py

@@ -0,0 +1,93 @@
+import os
+import uuid
+import threading
+from urllib.parse import quote
+from sqlalchemy import create_engine, Column, String, Integer, DECIMAL, DateTime
+from sqlalchemy.orm import sessionmaker, declarative_base
+from datetime import datetime, timezone, timedelta
+
+Base = declarative_base()
+
+_engine = None
+_SessionLocal = None
+_init_lock = threading.Lock()
+
+
+def _build_database_url():
+    db_user = os.getenv("LLM_TRACKER_DB_USER", "root")
+    db_password = os.getenv("LLM_TRACKER_DB_PASSWORD", "")
+    db_host = os.getenv("LLM_TRACKER_DB_HOST", "localhost")
+    db_port = os.getenv("LLM_TRACKER_DB_PORT", "3306")
+    db_name = os.getenv("LLM_TRACKER_DB_NAME", "oneclarity_db")
+
+    # URL-encode password to handle special characters like @ in passwords
+    db_password_encoded = quote(db_password, safe="")
+    return f"mysql+pymysql://{db_user}:{db_password_encoded}@{db_host}:{db_port}/{db_name}"
+
+
+def _build_connect_args():
+    use_ssl = os.getenv("LLM_TRACKER_USE_SSL", "1").lower() in ("1", "true", "yes", "on")
+    ssl_ca = os.getenv("LLM_TRACKER_SSL_CA", "").strip() or None
+
+    # SSL connection args for managed MySQL providers (Azure, AWS RDS, etc.)
+    connect_args = {}
+    if use_ssl:
+        connect_args["ssl"] = {"ssl": True}
+        if ssl_ca:
+            connect_args["ssl"]["ca"] = ssl_ca
+    return connect_args
+
+
+def get_engine():
+    """Lazily build the SQLAlchemy engine on first use, reading env vars at
+    that point rather than at import time — so `load_dotenv()` (called by
+    the caller, or by `llm_tracker/__init__.py`) always runs first."""
+    global _engine
+    if _engine is None:
+        with _init_lock:
+            if _engine is None:
+                _engine = create_engine(
+                    _build_database_url(),
+                    pool_size=5,
+                    pool_recycle=3600,
+                    connect_args=_build_connect_args(),
+                )
+    return _engine
+
+
+def get_sessionmaker():
+    global _SessionLocal
+    if _SessionLocal is None:
+        with _init_lock:
+            if _SessionLocal is None:
+                _SessionLocal = sessionmaker(bind=get_engine())
+    return _SessionLocal
+
+
+def get_ist_time():
+    """Get current time in IST (UTC+5:30)."""
+    ist = timezone(timedelta(hours=5, minutes=30))
+    return datetime.now(ist).replace(tzinfo=None)
+
+
+class UsageLog(Base):
+    __tablename__ = "ai_llm_usage_logs"
+
+    id = Column(String(36), primary_key=True, default=lambda: str(uuid.uuid4()))
+    created_at = Column(DateTime, default=get_ist_time)
+    api_name = Column(String(255), index=True)
+    endpoint = Column(String(255), index=True)
+    environment = Column(String(20), index=True)  # prod / test
+    user_id = Column(String(100))
+    request_id = Column(String(64))
+    deployment = Column(String(100))
+    prompt_tokens = Column(Integer)
+    completion_tokens = Column(Integer)
+    total_tokens = Column(Integer)
+    cost_usd = Column(DECIMAL(10, 6))
+    latency_ms = Column(Integer)
+
+
+def init_db():
+    """Run once to create the table (or run schema.sql manually)."""
+    Base.metadata.create_all(get_engine())

llm_tracker/logger.py

@@ -0,0 +1,51 @@
+import asyncio
+import logging
+import queue
+import threading
+from .db import UsageLog, get_sessionmaker
+
+logger = logging.getLogger("llm_tracker")
+
+_log_queue = queue.Queue()
+_worker_started = False
+_worker_lock = threading.Lock()
+
+
+def _worker():
+    while True:
+        record = _log_queue.get()
+        try:
+            with get_sessionmaker()() as session:
+                session.add(UsageLog(**record))
+                session.commit()
+        except Exception:
+            logger.exception("failed to save usage log")
+        finally:
+            _log_queue.task_done()
+
+
+def _ensure_worker_started():
+    global _worker_started
+    if not _worker_started:
+        with _worker_lock:
+            if not _worker_started:
+                threading.Thread(target=_worker, daemon=True, name="llm_tracker_writer").start()
+                _worker_started = True
+
+
+def log_usage(record: dict):
+    """Enqueue a usage record. Never blocks the caller."""
+    _ensure_worker_started()
+    _log_queue.put(record)
+
+
+def flush():
+    """Call at the end of a short-lived script to make sure all queued writes
+    finish before the process exits."""
+    _log_queue.join()
+
+
+async def aflush():
+    """Async-friendly equivalent of flush() — awaits pending writes without
+    blocking the event loop."""
+    await asyncio.to_thread(_log_queue.join)

llm_tracker/middleware.py

@@ -0,0 +1,39 @@
+import os
+import uuid
+from starlette.middleware.base import BaseHTTPMiddleware
+from .client import request_ctx
+
+# Default environment for live traffic through the middleware.
+# Devs testing an endpoint can override per-request by sending header: X-Env: test
+DEFAULT_LIVE_ENV = os.getenv("LLM_TRACKER_DEFAULT_ENV", "prod")
+
+# API name identifies the service/repo (e.g., "snapshot", "reporting")
+# Set this in .env as LLM_TRACKER_API_NAME
+API_NAME = os.getenv("LLM_TRACKER_API_NAME", "unknown")
+
+# User ID identifies who built/owns this API service for cost attribution
+# Set this in .env as LLM_TRACKER_USER_ID
+USER_ID = os.getenv("LLM_TRACKER_USER_ID", None)
+
+
+class LLMContextMiddleware(BaseHTTPMiddleware):
+    """
+    Register once in main.py:
+
+        from llm_tracker.middleware import LLMContextMiddleware
+        app.add_middleware(LLMContextMiddleware)
+
+    Automatically tags every LLM call made during a request with the
+    route path, environment, user id, and a unique request id — devs
+    don't need to pass any of this manually.
+    """
+
+    async def dispatch(self, request, call_next):
+        request_ctx.set({
+            "api_name": API_NAME,
+            "endpoint": request.url.path,
+            "environment": request.headers.get("X-Env", DEFAULT_LIVE_ENV),
+            "user_id": USER_ID,
+            "request_id": str(uuid.uuid4()),
+        })
+        return await call_next(request)

llm_tracker/pricing.py

@@ -0,0 +1,41 @@
+import json
+import logging
+import os
+
+logger = logging.getLogger("llm_tracker")
+
+# ── Default pricing (USD per 1K tokens) ──
+# You can override the whole table via env var LLM_TRACKER_PRICING_JSON
+# so pricing updates don't require a code change/deploy.
+# Example env value:
+# LLM_TRACKER_PRICING_JSON='{"gpt-4o-mini":{"input":0.00015,"output":0.0006}}'
+
+DEFAULT_PRICING = {
+    "gpt-4o-mini": {"input": 0.00015, "output": 0.0006},
+    "gpt-4o": {"input": 0.0025, "output": 0.01},
+    "gpt-4.1": {"input": 0.002, "output": 0.008},
+}
+
+
+def _load_pricing():
+    pricing_env = os.getenv("LLM_TRACKER_PRICING_JSON")
+    if not pricing_env:
+        return DEFAULT_PRICING
+    try:
+        return json.loads(pricing_env)
+    except json.JSONDecodeError:
+        logger.warning("LLM_TRACKER_PRICING_JSON is invalid JSON, using defaults")
+        return DEFAULT_PRICING
+
+
+PRICING_PER_1K = _load_pricing()
+
+
+def get_cost(deployment: str, prompt_tokens, completion_tokens) -> float:
+    if prompt_tokens is None or completion_tokens is None:
+        return 0.0
+    rates = PRICING_PER_1K.get(deployment, {"input": 0, "output": 0})
+    return round(
+        (prompt_tokens / 1000) * rates["input"] + (completion_tokens / 1000) * rates["output"],
+        6,
+    )

llm_tracker-0.2.0.dist-info/METADATA

@@ -0,0 +1,254 @@
+Metadata-Version: 2.4
+Name: llm-tracker
+Version: 0.2.0
+Summary: Track LLM API costs, tokens, and latency to MySQL
+Author-email: OneClarity <dev@oneclarity.ai>
+License: MIT
+Project-URL: Homepage, https://github.com/mentor-oneclarity/AI_LLM_Tracking
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: openai>=1.30.0
+Requires-Dist: sqlalchemy>=2.0.0
+Requires-Dist: pymysql>=1.1.0
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: starlette>=0.37.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23.0; extra == "dev"
+Requires-Dist: black>=22.0; extra == "dev"
+Requires-Dist: flake8>=4.0; extra == "dev"
+Dynamic: license-file
+
+# llm_tracker
+
+Automatically log OpenAI API usage (tokens, cost, latency) to MySQL. Drop-in wrapper that requires only a 1-line import change.
+
+## What It Does
+
+Every call to `client.chat.completions.create()` logs:
+- **Tokens** (prompt, completion, total)
+- **Cost** (calculated from pricing table)
+- **Latency** (milliseconds)
+- **Metadata** (service name, endpoint, environment, user ID, request ID)
+
+All logged to MySQL table `ai_llm_usage_logs` for cost analysis dashboards.
+
+---
+
+## Quick Start (5 minutes)
+
+### 1. Install
+
+```bash
+pip install llm-tracker
+```
+
+### 2. Configure
+
+Copy `.env.example` to `.env` and fill in:
+
+```bash
+# Who you are
+LLM_TRACKER_API_NAME=snapshot          # Your service name
+LLM_TRACKER_USER_ID=your-user-id       # Your personal/team ID
+
+# MySQL connection
+LLM_TRACKER_DB_HOST=mysql.example.com
+LLM_TRACKER_DB_PORT=3306
+LLM_TRACKER_DB_USER=mysqladmin
+LLM_TRACKER_DB_PASSWORD=password
+LLM_TRACKER_DB_NAME=dev_db
+
+# Optional
+LLM_TRACKER_USE_SSL=1                  # SSL enabled (default: 1)
+LLM_TRACKER_DEFAULT_ENV=beta           # test/beta/prod (default: test)
+```
+
+See `.env.example` for all variables with explanations.
+
+### 3. Initialize Database
+
+**First time only:**
+```bash
+python -c "from llm_tracker.db import init_db; init_db()"
+```
+
+This creates the `ai_llm_usage_logs` table.
+
+### 4. Use Tracked Client
+
+**In your code**, change only the import:
+
+```python
+# Before
+from openai import OpenAI
+client = OpenAI(api_key="...", base_url="...")
+
+# After
+from llm_tracker import TrackedOpenAI
+client = TrackedOpenAI(api_key="...", base_url="...")
+
+# Everything else stays the same
+response = client.chat.completions.create(
+    model="gpt-4o",
+    messages=[{"role": "user", "content": "hello"}]
+)
+```
+
+### 5. (FastAPI only) Add Middleware
+
+In your FastAPI app startup:
+
+```python
+from fastapi import FastAPI
+from llm_tracker.middleware import LLMContextMiddleware
+
+app = FastAPI()
+app.add_middleware(LLMContextMiddleware)
+```
+
+This automatically populates:
+- `api_name` — your service name (from env)
+- `endpoint` — the route path (e.g., `/jobs/medium-brain`)
+- `user_id` — your ID (from env)
+- `request_id` — unique per request (auto-generated)
+- `environment` — from env var or `X-Env` header
+
+---
+
+## Environment Variables
+
+### Required
+
+| Variable | Example | Description |
+|----------|---------|-------------|
+| `LLM_TRACKER_API_NAME` | `snapshot` | Your service/repo name |
+| `LLM_TRACKER_USER_ID` | `abc123def` | Your personal/team ID (cost attribution) |
+| `LLM_TRACKER_DB_HOST` | `mysql.example.com` | MySQL hostname |
+| `LLM_TRACKER_DB_USER` | `mysqladmin` | MySQL username |
+| `LLM_TRACKER_DB_PASSWORD` | `password123` | MySQL password |
+| `LLM_TRACKER_DB_NAME` | `dev_db` | MySQL database name |
+
+### Optional
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `LLM_TRACKER_DB_PORT` | `3306` | MySQL port |
+| `LLM_TRACKER_USE_SSL` | `1` | Enable SSL (0=off, 1=on) |
+| `LLM_TRACKER_SSL_CA` | (system) | Path to CA certificate |
+| `LLM_TRACKER_DEFAULT_ENV` | `test` | Environment label: `test`, `beta`, or `prod` |
+| `LLM_TRACKER_PRICING_JSON` | (built-in) | Override pricing table as JSON |
+
+### Special: Per-Request Environment
+
+Send `X-Env` header to override environment for a single request:
+
+```bash
+curl -H "X-Env: test" http://localhost:8088/jobs/medium-brain
+```
+
+---
+
+## What Gets Logged
+
+Table: `ai_llm_usage_logs`
+
+| Column | Example | Notes |
+|--------|---------|-------|
+| `id` | `a1b2c3d4-...` | UUID (auto-generated) |
+| `created_at` | `2026-07-07 12:30:45` | IST timestamp (auto) |
+| `api_name` | `snapshot` | From `LLM_TRACKER_API_NAME` |
+| `endpoint` | `/jobs/medium-brain` | HTTP route (FastAPI only) |
+| `deployment` | `gpt-4o` | Model name |
+| `environment` | `beta` | From `LLM_TRACKER_DEFAULT_ENV` |
+| `user_id` | `abc123def` | From `LLM_TRACKER_USER_ID` |
+| `request_id` | `xyz789abc` | Per-request UUID (FastAPI) |
+| `prompt_tokens` | `150` | Input tokens |
+| `completion_tokens` | `50` | Output tokens |
+| `total_tokens` | `200` | Sum |
+| `cost_usd` | `0.0045` | Calculated cost |
+| `latency_ms` | `1234` | Round-trip time |
+
+### Query Example
+
+```sql
+-- Total cost by endpoint (last 7 days)
+SELECT endpoint, deployment, COUNT(*) as calls, SUM(cost_usd) as total_cost
+FROM ai_llm_usage_logs
+WHERE api_name = 'snapshot' AND created_at > NOW() - INTERVAL 7 DAY
+GROUP BY endpoint, deployment
+ORDER BY total_cost DESC;
+```
+
+---
+
+## For Manual Scripts (No FastAPI)
+
+Load env vars and call `flush()` before exit:
+
+```python
+from dotenv import load_dotenv
+from llm_tracker import TrackedOpenAI
+from llm_tracker.logger import flush
+
+load_dotenv()
+
+client = TrackedOpenAI(api_key="...")
+response = client.chat.completions.create(
+    model="gpt-4o",
+    messages=[...]
+)
+
+flush()  # ensure background writes finish before script exits
+```
+
+---
+
+## Supported Models
+
+Built-in pricing for:
+- `gpt-4o` — $0.0025 input / $0.01 output per 1K tokens
+- `gpt-4o-mini` — $0.00015 input / $0.0006 output per 1K tokens
+- `gpt-4.1` — $0.002 input / $0.008 output per 1K tokens
+
+Unknown models log `$0.00` cost. Override pricing with `LLM_TRACKER_PRICING_JSON`.
+
+---
+
+## Async Support
+
+For async apps, use `TrackedAsyncOpenAI` / `TrackedAsyncAzureOpenAI` — same API, `await` the call:
+
+```python
+from llm_tracker import TrackedAsyncOpenAI
+from llm_tracker.logger import aflush
+
+client = TrackedAsyncOpenAI(api_key="...")
+response = await client.chat.completions.create(
+    model="gpt-4o",
+    messages=[{"role": "user", "content": "hello"}],
+)
+
+await aflush()  # async-friendly equivalent of flush()
+```
+
+## Known Limitations
+
+- ❌ Streaming (`stream=True`) not supported
+- ❌ Embeddings not tracked (by design — cheap)
+- ✓ Sync and async OpenAI/AzureOpenAI clients supported
+
+---
+
+## Support
+
+- **Issues**: GitHub issues
+- **Docs**: See `.env.example` and `schema.sql`
+- **Examples**: `example_usage.py`

llm_tracker-0.2.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+llm_tracker/__init__.py,sha256=XMW12PhrpJHb526R7pHKR68AJRoFv09Yl8C75g6FHXY,513
+llm_tracker/client.py,sha256=ooj9oAnQLAfxSbmCpAb7OjoU4ktgFICNmqQZEvxp1WU,5737
+llm_tracker/db.py,sha256=u3P5cxng16xadoon-4Pj_TTqf1A0OXY6GN1cFLyYKAo,3104
+llm_tracker/logger.py,sha256=yJPvVwmBdbn7astWdn3JKRw-RK9SihQbsPjS8ymeUmU,1340
+llm_tracker/middleware.py,sha256=tQHF3uO1Aj73bENS64bmPNQrygRDXOBLStDr-y6Cv18,1411
+llm_tracker/pricing.py,sha256=4_u-_iFThjbAwe-Psp9EnrShmM71BWUHYg1HFfc03wY,1260
+llm_tracker-0.2.0.dist-info/licenses/LICENSE,sha256=ectiFxIC9TyCUgN-KAjsF6Ie9oxomimDzQQxzh-5Seg,1067
+llm_tracker-0.2.0.dist-info/METADATA,sha256=1VoJ-Dt2RB-5BTBzpG30EAKTTngnJQ-9xPzg-eip57g,6933
+llm_tracker-0.2.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+llm_tracker-0.2.0.dist-info/top_level.txt,sha256=X5UoJG5Oo5TOz2KOtiqof1iunmOoubUPSKoMQTypjGE,12
+llm_tracker-0.2.0.dist-info/RECORD,,

llm_tracker-0.2.0.dist-info/WHEEL

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

llm_tracker-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 OneClarity
+
+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.

llm_tracker-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+llm_tracker