modelcost 0.1.0__tar.gz

modelcost-0.1.0/.gitignore

@@ -0,0 +1,144 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+Pipfile.lock
+
+# poetry
+poetry.lock
+
+# pdm
+.pdm.toml
+
+# PEP 582
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# IDEs
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+.DS_Store

modelcost-0.1.0/HACKING.md

@@ -0,0 +1,17 @@
+# Releasing
+
+## First release
+
+```sh
+# Build (generate dist/*.whl and dist/*.tar.gz)
+uv build
+
+# Publish in TestPyPI first
+uv publish --publish-url https://test.pypi.org/legacy/ --token TU_TOKEN_TESTPYPI
+
+# Verify installation from TestPyPI
+uv pip install --index-url https://test.pypi.org/simple/ modelcost
+
+# Publish in real PyPI
+uv publish --token TU_TOKEN_PYPI
+```

modelcost-0.1.0/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: modelcost
+Version: 0.1.0
+Summary: Calculate LLM API call costs from token usage
+Project-URL: Homepage, https://github.com/rmescandon/modelcost
+Project-URL: Repository, https://github.com/rmescandon/modelcost
+Author-email: Roberto Mier Escandon <rmescandon@gmail.com>
+License: MIT
+Keywords: cost,llm,openai,pricing,tokens
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.11
+Requires-Dist: click>=8.0
+Requires-Dist: httpx>=0.27
+Requires-Dist: tokencost>=0.1.16
+Description-Content-Type: text/markdown
+
+# modelcost
+
+Calculate LLM API call costs from token usage using price catalogs from multiple sources.
+
+Supported pricing sources:
+- `litellm` (default)
+- `openrouter`
+- `tokencost`
+
+## Install
+
+```bash
+python -m pip install modelcost
+```
+
+## CLI
+
+The default command calculates cost, so you can omit the `cost` subcommand.
+
+```bash
+# Default (cost)
+modelcost gpt-4o 1000 500
+
+# Explicit cost (optional)
+modelcost cost gpt-4o 1000 500
+
+# All sources in one run
+modelcost --source all gpt-4o 1000 500
+
+# JSON output
+modelcost --json gpt-4o 1000 500
+```
+
+List available models:
+
+```bash
+modelcost models
+modelcost models --source openrouter
+modelcost models --filter gpt
+modelcost models --json
+```
+
+CLI help:
+
+```bash
+modelcost --help
+modelcost models --help
+```
+
+## Library
+
+```python
+from modelcost.calculator import calculate_cost, list_models
+
+result = calculate_cost("gpt-4o", 1000, 500)
+
+for source in result.available_sources:
+    print(f"{source.source}: ${source.total_cost_usd:.6f}")
+
+litellm_cost = next(s for s in result.sources if s.source == "litellm")
+print(litellm_cost.price_per_million_input, litellm_cost.price_per_million_output)
+
+models = list_models("openrouter")
+```
+
+## Output details
+
+`calculate_cost()` returns a `CostResult` with:
+- `model`, `input_tokens`, `output_tokens`
+- `sources`: list of `SourceCost` objects
+- `available_sources`: only sources with prices found
+
+Each `SourceCost` includes:
+- `source`
+- `total_cost_usd`
+- `price_per_million_input`
+- `price_per_million_output`
+- `error` (when not available)
+
+## Caching
+
+`openrouter` responses are cached in `~/.modelcost_cache.json` for 1 hour.
+
+## Notes
+
+- Prices are fetched at runtime from the upstream catalogs.
+- If a model is missing in a source, that source is marked as unavailable.
+- Network sources are fetched in parallel for the `all` option.

modelcost-0.1.0/README.md

@@ -0,0 +1,88 @@
+# modelcost
+
+Calculate LLM API call costs from token usage using price catalogs from multiple sources.
+
+Supported pricing sources:
+- `litellm` (default)
+- `openrouter`
+- `tokencost`
+
+## Install
+
+```bash
+python -m pip install modelcost
+```
+
+## CLI
+
+The default command calculates cost, so you can omit the `cost` subcommand.
+
+```bash
+# Default (cost)
+modelcost gpt-4o 1000 500
+
+# Explicit cost (optional)
+modelcost cost gpt-4o 1000 500
+
+# All sources in one run
+modelcost --source all gpt-4o 1000 500
+
+# JSON output
+modelcost --json gpt-4o 1000 500
+```
+
+List available models:
+
+```bash
+modelcost models
+modelcost models --source openrouter
+modelcost models --filter gpt
+modelcost models --json
+```
+
+CLI help:
+
+```bash
+modelcost --help
+modelcost models --help
+```
+
+## Library
+
+```python
+from modelcost.calculator import calculate_cost, list_models
+
+result = calculate_cost("gpt-4o", 1000, 500)
+
+for source in result.available_sources:
+    print(f"{source.source}: ${source.total_cost_usd:.6f}")
+
+litellm_cost = next(s for s in result.sources if s.source == "litellm")
+print(litellm_cost.price_per_million_input, litellm_cost.price_per_million_output)
+
+models = list_models("openrouter")
+```
+
+## Output details
+
+`calculate_cost()` returns a `CostResult` with:
+- `model`, `input_tokens`, `output_tokens`
+- `sources`: list of `SourceCost` objects
+- `available_sources`: only sources with prices found
+
+Each `SourceCost` includes:
+- `source`
+- `total_cost_usd`
+- `price_per_million_input`
+- `price_per_million_output`
+- `error` (when not available)
+
+## Caching
+
+`openrouter` responses are cached in `~/.modelcost_cache.json` for 1 hour.
+
+## Notes
+
+- Prices are fetched at runtime from the upstream catalogs.
+- If a model is missing in a source, that source is marked as unavailable.
+- Network sources are fetched in parallel for the `all` option.

modelcost-0.1.0/modelcost/calculator.py

@@ -0,0 +1,148 @@
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from .models import CostResult, SourceCost
+from .providers.openrouter import fetch_openrouter_prices, find_model
+from .providers.litellm import fetch_litellm_prices
+
+VALID_SOURCES = ("litellm", "openrouter", "tokencost", "all")
+
+
+def list_models(source: str = "litellm") -> list[str]:
+    """Return the available models for the given source."""
+    if source not in ("litellm", "openrouter", "tokencost"):
+        raise ValueError(
+            f"Invalid source '{source}'. Valid values: litellm, openrouter, tokencost"
+        )
+
+    if source == "litellm":
+        return sorted(fetch_litellm_prices().keys())
+
+    if source == "openrouter":
+        return sorted(fetch_openrouter_prices().keys())
+
+    if source == "tokencost":
+        from tokencost.constants import TOKEN_COSTS
+
+        return sorted(TOKEN_COSTS.keys())
+
+
+def calculate_cost(
+    model: str,
+    input_tokens: int,
+    output_tokens: int,
+    source: str = "litellm",
+) -> CostResult:
+    if source not in VALID_SOURCES:
+        raise ValueError(f"Invalid source '{source}'. Valid values: {VALID_SOURCES}")
+
+    active = ["litellm", "openrouter", "tokencost"] if source == "all" else [source]
+
+    sources = _fetch_all(model, input_tokens, output_tokens, active)
+
+    return CostResult(
+        model=model,
+        input_tokens=input_tokens,
+        output_tokens=output_tokens,
+        sources=sources,
+        single_source=source != "all",  # output formatting flag
+    )
+
+
+def _fetch_all(
+    model: str, input_tokens: int, output_tokens: int, active: list[str]
+) -> list[SourceCost]:
+    network_tasks = {
+        name: fn
+        for name, fn in {
+            "litellm": fetch_litellm_prices,
+            "openrouter": fetch_openrouter_prices,
+        }.items()
+        if name in active
+    }
+
+    results: dict[str, SourceCost] = {}
+
+    if network_tasks:
+        with ThreadPoolExecutor(max_workers=len(network_tasks)) as executor:
+            futures = {
+                executor.submit(
+                    _compute, name, fn, model, input_tokens, output_tokens
+                ): name
+                for name, fn in network_tasks.items()
+            }
+            for future in as_completed(futures):
+                results[futures[future]] = future.result()
+
+    if "tokencost" in active:
+        results["tokencost"] = _tokencost_source(model, input_tokens, output_tokens)
+
+    # Preserve order: litellm -> openrouter -> tokencost
+    order = ["litellm", "openrouter", "tokencost"]
+    return [results[name] for name in order if name in results]
+
+
+def _compute(
+    source_name: str, fetch_fn, model: str, input_tokens: int, output_tokens: int
+) -> SourceCost:
+    try:
+        prices = fetch_fn()
+        pricing = (
+            find_model(model, prices)
+            if source_name == "openrouter"
+            else prices.get(model)
+        )
+        if pricing is None:
+            return SourceCost(
+                source=source_name,
+                total_cost_usd=None,
+                price_per_million_input=None,
+                price_per_million_output=None,
+                error=f"Model '{model}' not found",
+            )
+        cost = pricing["prompt"] * input_tokens + pricing["completion"] * output_tokens
+        return SourceCost(
+            source=source_name,
+            total_cost_usd=cost,
+            price_per_million_input=pricing["prompt"] * 1_000_000,
+            price_per_million_output=pricing["completion"] * 1_000_000,
+        )
+    except Exception as e:
+        return SourceCost(
+            source=source_name,
+            total_cost_usd=None,
+            price_per_million_input=None,
+            price_per_million_output=None,
+            error=str(e),
+        )
+
+
+def _tokencost_source(model: str, input_tokens: int, output_tokens: int) -> SourceCost:
+    try:
+        from tokencost.costs import calculate_cost_by_tokens
+        from tokencost.constants import TOKEN_COSTS
+
+        input_cost = calculate_cost_by_tokens(input_tokens, model, "input")
+        output_cost = calculate_cost_by_tokens(output_tokens, model, "output")
+        entry = TOKEN_COSTS[model.lower()]
+
+        return SourceCost(
+            source="tokencost",
+            total_cost_usd=float(input_cost + output_cost),
+            price_per_million_input=float(entry["input_cost_per_token"]) * 1_000_000,
+            price_per_million_output=float(entry["output_cost_per_token"]) * 1_000_000,
+        )
+    except KeyError as e:
+        return SourceCost(
+            source="tokencost",
+            total_cost_usd=None,
+            price_per_million_input=None,
+            price_per_million_output=None,
+            error=f"Model not found: {e}",
+        )
+    except Exception as e:
+        return SourceCost(
+            source="tokencost",
+            total_cost_usd=None,
+            price_per_million_input=None,
+            price_per_million_output=None,
+            error=str(e),
+        )

modelcost-0.1.0/modelcost/cli.py

@@ -0,0 +1,107 @@
+import sys
+import json as json_mod
+import click
+from .calculator import calculate_cost, list_models, VALID_SOURCES
+
+
+class DefaultCostGroup(click.Group):
+    """A Group that falls back to the 'cost' command when no subcommand is matched."""
+
+    def parse_args(self, ctx: click.Context, args: list[str]) -> list[str]:
+        # If the first non-option token is not a known subcommand, prepend 'cost'
+        for i, arg in enumerate(args):
+            if not arg.startswith("-"):
+                if arg not in self.commands:
+                    args = ["cost"] + args
+                break
+        return super().parse_args(ctx, args)
+
+
+@click.group(cls=DefaultCostGroup)
+def main() -> None:
+    """Calculate LLM API call costs from token usage."""
+
+
+@main.command("cost")
+@click.argument("model")
+@click.argument("input_tokens", type=int)
+@click.argument("output_tokens", type=int)
+@click.option(
+    "--source",
+    default="litellm",
+    show_default=True,
+    type=click.Choice(VALID_SOURCES),
+    help="Pricing source.",
+)
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON.")
+def cost_cmd(
+    model: str, input_tokens: int, output_tokens: int, source: str, as_json: bool
+) -> None:
+    """Calculate the cost for MODEL with INPUT_TOKENS and OUTPUT_TOKENS."""
+    # ── Calculation mode ──────────────────────────────────────────────
+    try:
+        result = calculate_cost(model, input_tokens, output_tokens, source=source)
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+
+    if as_json:
+        click.echo(json_mod.dumps(result.to_dict(), indent=2))
+        return
+
+    if result.single_source:
+        s = result.sources[0]
+        if s.available:
+            click.echo(f"${s.total_cost_usd:.6f}")
+        else:
+            click.echo(f"unavailable — {s.error}", err=True)
+            sys.exit(1)
+    else:
+        click.echo(
+            f"Model: {result.model}  ({result.input_tokens} in / {result.output_tokens} out)\n"
+        )
+        for s in result.sources:
+            if s.available:
+                click.echo(f"  [{s.source:<12}] ${s.total_cost_usd:.6f} USD")
+            else:
+                click.echo(f"  [{s.source:<12}] unavailable — {s.error}")
+
+
+@main.command("models")
+@click.option(
+    "--source",
+    default="litellm",
+    show_default=True,
+    type=click.Choice(("litellm", "openrouter", "tokencost")),
+    help="Pricing source.",
+)
+@click.option(
+    "--filter",
+    "filter_term",
+    default=None,
+    metavar="TERM",
+    help="Filter by substring (e.g. gpt).",
+)
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON.")
+def models_cmd(source: str, filter_term: str | None, as_json: bool) -> None:
+    """List available models for the given source."""
+    # ── List mode ──────────────────────────────────────────────
+    try:
+        models = list_models(source)
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+
+    if filter_term:
+        models = [m for m in models if filter_term.lower() in m.lower()]
+
+    if as_json:
+        click.echo(
+            json_mod.dumps(
+                {"source": source, "count": len(models), "models": models}, indent=2
+            )
+        )
+    else:
+        click.echo(f"Models available in [{source}] ({len(models)} total):\n")
+        for m in models:
+            click.echo(f"  {m}")

modelcost-0.1.0/modelcost/models.py

@@ -0,0 +1,44 @@
+from dataclasses import dataclass, field
+
+
+@dataclass
+class SourceCost:
+    source: str
+    total_cost_usd: float | None
+    price_per_million_input: float | None
+    price_per_million_output: float | None
+    error: str | None = None
+
+    @property
+    def available(self) -> bool:
+        return self.total_cost_usd is not None
+
+
+@dataclass
+class CostResult:
+    model: str
+    input_tokens: int
+    output_tokens: int
+    sources: list[SourceCost]
+    single_source: bool = True  # False when source="all"
+
+    @property
+    def available_sources(self) -> list[SourceCost]:
+        return [s for s in self.sources if s.available]
+
+    def to_dict(self) -> dict:
+        return {
+            "model": self.model,
+            "input_tokens": self.input_tokens,
+            "output_tokens": self.output_tokens,
+            "costs": [
+                {
+                    "source": s.source,
+                    "total_cost_usd": s.total_cost_usd,
+                    "price_per_million_input": s.price_per_million_input,
+                    "price_per_million_output": s.price_per_million_output,
+                    "error": s.error,
+                }
+                for s in self.sources
+            ],
+        }

modelcost-0.1.0/modelcost/providers/cache.py

@@ -0,0 +1,24 @@
+import json
+import time
+from pathlib import Path
+
+CACHE_FILE = Path.home() / ".modelcost_cache.json"
+CACHE_TTL = 3600
+
+
+def load_cache(namespace: str) -> dict:
+    if not CACHE_FILE.exists():
+        return {}
+    data = json.loads(CACHE_FILE.read_text())
+    entry = data.get(namespace, {})
+    if time.time() - entry.get("_ts", 0) > CACHE_TTL:
+        return {}
+    return entry.get("models", {})
+
+
+def save_cache(namespace: str, models: dict) -> None:
+    data = {}
+    if CACHE_FILE.exists():
+        data = json.loads(CACHE_FILE.read_text())
+    data[namespace] = {"_ts": time.time(), "models": models}
+    CACHE_FILE.write_text(json.dumps(data))

modelcost-0.1.0/modelcost/providers/litellm.py

@@ -0,0 +1,18 @@
+import httpx
+
+LITELLM_URL = (
+    "https://raw.githubusercontent.com/BerriAI/litellm/main/"
+    "model_prices_and_context_window.json"
+)
+
+def fetch_litellm_prices() -> dict:
+    resp = httpx.get(LITELLM_URL, timeout=10)
+    resp.raise_for_status()
+    return {
+        model: {
+            "prompt": info["input_cost_per_token"],
+            "completion": info["output_cost_per_token"],
+        }
+        for model, info in resp.json().items()
+        if "input_cost_per_token" in info and "output_cost_per_token" in info
+    }