promptpricer 0.1.0__tar.gz

promptpricer-0.1.0/.gitignore

@@ -0,0 +1,8 @@
+__pycache__/
+*.pyc
+*.egg-info/
+dist/
+build/
+.venv/
+venv/
+.env

promptpricer-0.1.0/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: promptpricer
+Version: 0.1.0
+Summary: Instant token count and cost estimate across all major LLMs
+Project-URL: Homepage, https://github.com/Sreechandh22/Prompt-cost
+Project-URL: Repository, https://github.com/Sreechandh22/Prompt-cost
+Author: Sreechandh
+License: MIT
+Keywords: anthropic,cost,gemini,llm,openai,pricing,tokens
+Classifier: Environment :: Console
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Requires-Dist: pyperclip
+Requires-Dist: rich
+Requires-Dist: tiktoken

promptpricer-0.1.0/README.md

@@ -0,0 +1,77 @@
+# promptpricer
+
+Token count and cost estimate across all major LLMs. One command, no API keys.
+
+```
+$ promptpricer "You are a helpful assistant. Summarize this document in detail."
+
+Prompt: 12 tokens   Expected output: 500 tokens
+
+ Model              Input tokens   Output tokens   Input cost   Output cost      Total
+ ──────────────────────────────────────────────────────────────────────────────────────
+ gpt-4.1-nano                 12             500   <$0.0001      $0.0002        $0.0002
+ gemini-2.0-flash             12             500   <$0.0001      $0.0002        $0.0002
+ gpt-4o-mini                  12             500   <$0.0001      $0.0003        $0.0003
+ gpt-4.1-mini                 12             500   <$0.0001      $0.0008        $0.0008
+ gemini-2.5-flash             12             500   <$0.0001      $0.0013        $0.0013
+ o4-mini                      12             500   <$0.0001      $0.0022        $0.0022
+ claude-haiku-4               12             500   <$0.0001      $0.0025        $0.0025
+ gpt-4o                       12             500   <$0.0001      $0.0050        $0.0051
+ claude-sonnet-4              12             500   <$0.0001      $0.0075        $0.0075
+ claude-opus-4                12             500    $0.0002      $0.0375        $0.0377
+```
+
+Prices are fetched from [LiteLLM](https://github.com/BerriAI/litellm) and cached locally for 24 hours.
+
+## Install
+
+```bash
+pip install promptpricer
+
+```
+
+Or from source:
+
+```bash
+git clone https://github.com/Sreechandh22/Prompt-cost
+cd Prompt-cost
+pip install -e .
+```
+
+## Usage
+
+```bash
+# pass a prompt directly
+promptpricer "your prompt here"
+
+# specify expected output tokens (default: 500)
+promptpricer "your prompt" --output 1000
+
+# read from a file
+promptpricer --file prompt.txt
+
+# read from clipboard
+promptpricer
+
+# filter by provider
+promptpricer "your prompt" --filter anthropic
+promptpricer "your prompt" --filter openai
+promptpricer "your prompt" --filter google
+
+# show only the N cheapest models
+promptpricer "your prompt" --top 3
+
+# output as JSON (pipe into other tools)
+promptpricer "your prompt" --json
+
+# force refresh pricing cache
+promptpricer --update
+```
+
+## Providers
+
+| Provider  | Models |
+|-----------|--------|
+| OpenAI    | gpt-4o, gpt-4o-mini, gpt-4.1, gpt-4.1-mini, gpt-4.1-nano, o3, o4-mini |
+| Anthropic | claude-opus-4, claude-sonnet-4, claude-haiku-4 |
+| Google    | gemini-2.5-pro, gemini-2.5-flash, gemini-2.0-flash |

promptpricer-0.1.0/llm_cost/cli.py

@@ -0,0 +1,129 @@
+import argparse
+import json
+import sys
+import tiktoken
+from rich.console import Console
+from rich.table import Table
+from rich import box
+from llm_cost.fetch import load_prices
+
+console = Console()
+
+PROVIDER_ALIASES = {
+    "openai":    "openai",
+    "oai":       "openai",
+    "anthropic": "anthropic",
+    "claude":    "anthropic",
+    "google":    "google",
+    "gemini":    "google",
+}
+
+
+def count_tokens(text: str) -> int:
+    enc = tiktoken.get_encoding("cl100k_base")
+    return len(enc.encode(text))
+
+
+def format_cost(usd: float) -> str:
+    if usd < 0.0001:
+        return "<$0.0001"
+    return f"${usd:.4f}"
+
+
+def build_rows(input_tokens: int, output_tokens: int, provider: str = None) -> list:
+    models = load_prices()
+    rows = []
+    for m in models:
+        if provider and PROVIDER_ALIASES.get(provider.lower()) != m["provider"]:
+            continue
+        in_cost  = (input_tokens  / 1_000_000) * m["in_price"]
+        out_cost = (output_tokens / 1_000_000) * m["out_price"]
+        total    = in_cost + out_cost
+        rows.append({
+            "model":         m["name"],
+            "input_tokens":  input_tokens,
+            "output_tokens": output_tokens,
+            "input_cost":    in_cost,
+            "output_cost":   out_cost,
+            "total":         total,
+        })
+    rows.sort(key=lambda r: r["total"])
+    return rows
+
+
+def run(prompt: str, output_tokens: int, as_json: bool = False,
+        provider: str = None, top: int = None) -> None:
+    input_tokens = count_tokens(prompt)
+    rows = build_rows(input_tokens, output_tokens, provider)
+    if top:
+        rows = rows[:top]
+
+    if as_json:
+        print(json.dumps(rows, indent=2))
+        return
+
+    table = Table(box=box.SIMPLE_HEAD, show_footer=False)
+    table.add_column("Model", style="bold white", no_wrap=True)
+    table.add_column("Input tokens", justify="right", style="dim")
+    table.add_column("Output tokens", justify="right", style="dim")
+    table.add_column("Input cost", justify="right")
+    table.add_column("Output cost", justify="right")
+    table.add_column("Total", justify="right", style="bold green")
+
+    for r in rows:
+        table.add_row(
+            r["model"],
+            f"{r['input_tokens']:,}",
+            f"{r['output_tokens']:,}",
+            format_cost(r["input_cost"]),
+            format_cost(r["output_cost"]),
+            format_cost(r["total"]),
+        )
+
+    console.print(f"\n[dim]Prompt:[/dim] {input_tokens:,} tokens   [dim]Expected output:[/dim] {output_tokens:,} tokens\n")
+    console.print(table)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog="llm-cost",
+        description="Token count and cost estimate across major LLMs.",
+    )
+    parser.add_argument("prompt", nargs="?", help="Prompt text (omit to read from clipboard)")
+    parser.add_argument("-o", "--output", type=int, default=500, metavar="N",
+                        help="Expected output tokens (default: 500)")
+    parser.add_argument("-f", "--file", metavar="FILE", help="Read prompt from file")
+    parser.add_argument("--json", action="store_true", help="Output as JSON")
+    parser.add_argument("--filter", metavar="PROVIDER", help="Filter by provider: openai, anthropic, google")
+    parser.add_argument("--top", type=int, metavar="N", help="Show only the N cheapest models")
+    parser.add_argument("--update", action="store_true", help="Force refresh pricing from remote")
+    args = parser.parse_args()
+
+    if args.update:
+        load_prices(force_update=True)
+        console.print("[green]Pricing cache updated.[/green]")
+        if not args.prompt and not args.file:
+            return
+
+    if args.file:
+        with open(args.file) as f:
+            prompt = f.read()
+    elif args.prompt:
+        prompt = args.prompt
+    else:
+        try:
+            import pyperclip
+            prompt = pyperclip.paste()
+            if not prompt.strip():
+                console.print("[red]Clipboard is empty. Pass a prompt or use --file.[/red]")
+                sys.exit(1)
+            console.print("[dim]Reading from clipboard...[/dim]")
+        except Exception:
+            console.print("[red]No prompt given and clipboard read failed.[/red]")
+            sys.exit(1)
+
+    run(prompt, args.output, as_json=args.json, provider=args.filter, top=args.top)
+
+
+if __name__ == "__main__":
+    main()

promptpricer-0.1.0/llm_cost/fetch.py

@@ -0,0 +1,74 @@
+import json
+import time
+import urllib.request
+from pathlib import Path
+
+PRICES_URL = "https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json"
+CACHE_PATH = Path.home() / ".cache" / "llm-cost" / "prices.json"
+CACHE_TTL  = 86400  # 24 hours
+
+FEATURED = [
+    ("gpt-4o",                   "gpt-4o",                   "openai"),
+    ("gpt-4o-mini",              "gpt-4o-mini",              "openai"),
+    ("gpt-4.1",                  "gpt-4.1",                  "openai"),
+    ("gpt-4.1-mini",             "gpt-4.1-mini",             "openai"),
+    ("gpt-4.1-nano",             "gpt-4.1-nano",             "openai"),
+    ("o3",                       "o3",                       "openai"),
+    ("o4-mini",                  "o4-mini",                  "openai"),
+    ("claude-opus-4",            "claude-opus-4-5",          "anthropic"),
+    ("claude-sonnet-4",          "claude-sonnet-4-5",        "anthropic"),
+    ("claude-haiku-4",           "claude-haiku-4-5",         "anthropic"),
+    ("gemini-2.5-pro",           "gemini/gemini-2.5-pro",    "google"),
+    ("gemini-2.5-flash",         "gemini/gemini-2.5-flash",  "google"),
+    ("gemini-2.0-flash",         "gemini/gemini-2.0-flash",  "google"),
+]
+
+
+def _fetch_remote() -> dict:
+    with urllib.request.urlopen(PRICES_URL, timeout=5) as r:
+        return json.loads(r.read())
+
+
+def _load_cache() -> dict | None:
+    if not CACHE_PATH.exists():
+        return None
+    if time.time() - CACHE_PATH.stat().st_mtime > CACHE_TTL:
+        return None
+    with open(CACHE_PATH) as f:
+        return json.load(f)
+
+
+def _save_cache(data: dict) -> None:
+    CACHE_PATH.parent.mkdir(parents=True, exist_ok=True)
+    with open(CACHE_PATH, "w") as f:
+        json.dump(data, f)
+
+
+def load_prices(force_update: bool = False) -> list[dict]:
+    raw = None
+
+    if not force_update:
+        raw = _load_cache()
+
+    if raw is None:
+        try:
+            raw = _fetch_remote()
+            _save_cache(raw)
+        except Exception:
+            raw = {}
+
+    models = []
+    for display_name, key, provider in FEATURED:
+        entry = raw.get(key, {})
+        in_price  = entry.get("input_cost_per_token",  0) * 1_000_000
+        out_price = entry.get("output_cost_per_token", 0) * 1_000_000
+        if in_price == 0 and out_price == 0:
+            continue
+        models.append({
+            "name":     display_name,
+            "provider": provider,
+            "in_price":  in_price,
+            "out_price": out_price,
+        })
+
+    return models

promptpricer-0.1.0/llm_cost/pricing.py

@@ -0,0 +1,16 @@
+# Prices in USD per 1M tokens. Update as providers change rates.
+# (name, input $/1M, output $/1M, tokenizer, provider)
+MODELS = [
+    ("gpt-4o",              2.50,  10.00, "cl100k_base", "openai"),
+    ("gpt-4o-mini",         0.15,   0.60, "cl100k_base", "openai"),
+    ("gpt-4.1",             2.00,   8.00, "cl100k_base", "openai"),
+    ("gpt-4.1-mini",        0.40,   1.60, "cl100k_base", "openai"),
+    ("o3",                 10.00,  40.00, "cl100k_base", "openai"),
+    ("o4-mini",             1.10,   4.40, "cl100k_base", "openai"),
+    ("claude-opus-4",      15.00,  75.00, "cl100k_base", "anthropic"),
+    ("claude-sonnet-4",     3.00,  15.00, "cl100k_base", "anthropic"),
+    ("claude-haiku-3.5",    0.80,   4.00, "cl100k_base", "anthropic"),
+    ("gemini-2.0-flash",    0.10,   0.40, "cl100k_base", "google"),
+    ("gemini-1.5-pro",      1.25,   5.00, "cl100k_base", "google"),
+    ("gemini-1.5-flash",    0.075,  0.30, "cl100k_base", "google"),
+]

promptpricer-0.1.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "promptpricer"
+version = "0.1.0"
+description = "Instant token count and cost estimate across all major LLMs"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "Sreechandh" }]
+keywords = ["llm", "cost", "pricing", "tokens", "openai", "anthropic", "gemini"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Environment :: Console",
+    "Topic :: Utilities",
+]
+dependencies = ["tiktoken", "rich", "pyperclip"]
+
+[project.urls]
+Homepage = "https://github.com/Sreechandh22/Prompt-cost"
+Repository = "https://github.com/Sreechandh22/Prompt-cost"
+
+[project.scripts]
+promptpricer = "llm_cost.cli:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["llm_cost"]