costtracker 0.1.0__tar.gz

costtracker-0.1.0/LICENSE

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

costtracker-0.1.0/PKG-INFO

@@ -0,0 +1,121 @@
+Metadata-Version: 2.4
+Name: costtracker
+Version: 0.1.0
+Summary: Simple and lightweight Python package to track LLM API cost
+Author: Vishal Verma
+License: MIT
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: python-dotenv
+Requires-Dist: google-genai
+Dynamic: license-file
+
+# 🚀 costtracker
+
+<p align="center">
+  <b>Track your LLM API cost in real time — with one line of code.</b>
+</p>
+
+<p align="center">
+  <img src="https://img.shields.io/badge/python-3.11+-blue.svg" />
+  <img src="https://img.shields.io/badge/status-active-success.svg" />
+  <img src="https://img.shields.io/badge/license-MIT-green.svg" />
+  <img src="https://img.shields.io/badge/built%20with-GenAI-purple.svg" />
+</p>
+
+---
+
+## ✨ Why costtracker?
+
+Building with LLMs is easy.  
+**Tracking cost isn’t.**
+
+costtracker solves this by giving you:
+
+> ⚡ Instant cost visibility for every API call
+
+No dashboards. No setup. No complexity.
+
+---
+
+## 🔥 Features
+
+- 📊 Real-time token + cost tracking  
+- ⚡ One-line integration (`track(response)`)  
+- 🧠 Works with OpenAI-compatible APIs for now (Gemini included)  
+- 🪶 Lightweight & zero-config  
+- 🧱 Built for developers  
+
+---
+
+## ⚡ Quick Demo
+
+```python
+from costtracker import track
+
+track(response)
+```
+
+## ⚡ Output
+```
+Model: gemini-2.5-flash-lite
+Tokens: 13 (input: 4, output: 9)
+Cost: $0.000011
+```
+
+## 📦 Installation
+```
+pip install -e .
+```
+
+## ⚙️ Setup
+
+Create a .env file in your root directory:
+```.env
+GEMINI_API_KEY=your_api_key_here
+```
+
+## 🧪 Usage
+```python
+import os
+from dotenv import load_dotenv
+from openai import OpenAI
+from costtracker import track
+
+load_dotenv()
+
+client = OpenAI(
+    api_key=os.getenv("GEMINI_API_KEY"),
+    base_url="https://generativelanguage.googleapis.com/v1beta/openai/"
+)
+
+response = client.chat.completions.create(
+    model="gemini-2.5-flash-lite",
+    messages=[
+        {"role": "user", "content": "Hello there!"}
+    ]
+)
+
+track(response)
+```
+
+## 💡 Use Cases
+
+- 🧑‍💻 AI app developers tracking API usage
+- 🚀 Startup teams controlling LLM costs
+- 📊 Experimentation with prompt optimization
+- 🧪 GenAI project building
+
+## 🤝 Contributing
+
+- Contributions are welcome!
+- Feel free to open issues or submit PRs.
+
+## ⭐ If you like this project
+
+**Give it a star**
+
+## 📄 License
+
+MIT License

costtracker-0.1.0/README.md

@@ -0,0 +1,108 @@
+# 🚀 costtracker
+
+<p align="center">
+  <b>Track your LLM API cost in real time — with one line of code.</b>
+</p>
+
+<p align="center">
+  <img src="https://img.shields.io/badge/python-3.11+-blue.svg" />
+  <img src="https://img.shields.io/badge/status-active-success.svg" />
+  <img src="https://img.shields.io/badge/license-MIT-green.svg" />
+  <img src="https://img.shields.io/badge/built%20with-GenAI-purple.svg" />
+</p>
+
+---
+
+## ✨ Why costtracker?
+
+Building with LLMs is easy.  
+**Tracking cost isn’t.**
+
+costtracker solves this by giving you:
+
+> ⚡ Instant cost visibility for every API call
+
+No dashboards. No setup. No complexity.
+
+---
+
+## 🔥 Features
+
+- 📊 Real-time token + cost tracking  
+- ⚡ One-line integration (`track(response)`)  
+- 🧠 Works with OpenAI-compatible APIs for now (Gemini included)  
+- 🪶 Lightweight & zero-config  
+- 🧱 Built for developers  
+
+---
+
+## ⚡ Quick Demo
+
+```python
+from costtracker import track
+
+track(response)
+```
+
+## ⚡ Output
+```
+Model: gemini-2.5-flash-lite
+Tokens: 13 (input: 4, output: 9)
+Cost: $0.000011
+```
+
+## 📦 Installation
+```
+pip install -e .
+```
+
+## ⚙️ Setup
+
+Create a .env file in your root directory:
+```.env
+GEMINI_API_KEY=your_api_key_here
+```
+
+## 🧪 Usage
+```python
+import os
+from dotenv import load_dotenv
+from openai import OpenAI
+from costtracker import track
+
+load_dotenv()
+
+client = OpenAI(
+    api_key=os.getenv("GEMINI_API_KEY"),
+    base_url="https://generativelanguage.googleapis.com/v1beta/openai/"
+)
+
+response = client.chat.completions.create(
+    model="gemini-2.5-flash-lite",
+    messages=[
+        {"role": "user", "content": "Hello there!"}
+    ]
+)
+
+track(response)
+```
+
+## 💡 Use Cases
+
+- 🧑‍💻 AI app developers tracking API usage
+- 🚀 Startup teams controlling LLM costs
+- 📊 Experimentation with prompt optimization
+- 🧪 GenAI project building
+
+## 🤝 Contributing
+
+- Contributions are welcome!
+- Feel free to open issues or submit PRs.
+
+## ⭐ If you like this project
+
+**Give it a star**
+
+## 📄 License
+
+MIT License

costtracker-0.1.0/costtracker/__init__.py

@@ -0,0 +1 @@
+from .tracker import track

costtracker-0.1.0/costtracker/calculator.py

@@ -0,0 +1,10 @@
+def calculate_cost(input_tokens:int, output_tokens:int, pricing:dict)->dict:
+    input_cost=input_tokens*pricing["input"]
+    output_cost=output_tokens*pricing["output"]
+    total_cost=input_cost+output_cost
+
+    return {
+        "input_cost": input_cost,
+        "output_cost": output_cost,
+        "total_cost": total_cost
+    }

costtracker-0.1.0/costtracker/cli.py

@@ -0,0 +1,75 @@
+import click
+import runpy
+
+from .state import reset_state, get_state, set_budget, get_budget
+from .logger import set_log_file, log_output
+from .config import load_config
+
+@click.group()
+def cli():
+    """
+    costtracker CLI tool
+    """
+    pass
+
+@cli.command()
+@click.argument("script")
+@click.option("--budget", type=float, default=None, help="Set budget limit")
+@click.option("--log-file", type=str, default=None, help="Logs output to file")
+@click.option("--provider", type=str, default=None, help="Sets the provider to calculate cost")
+def run(script, budget, log_file, provider):
+    """
+    Run a Python script with cost tracking enabled.
+    """
+
+    # Load config file
+    config=load_config()
+
+    # Merge values (priority: CLI > config > default)
+    final_budget=budget if budget is not None else config.get("budget")
+    final_log_file=log_file if log_file is not None else config.get("log_file")
+    final_provider=provider if provider is not None else config.get("provider")
+
+    # Reset previous state
+    reset_state()
+
+    # Apply config
+    if final_budget is not None:
+        set_budget(final_budget)
+
+    if final_log_file:
+        set_log_file(final_log_file)
+
+    # Set budget if provided
+    if budget is not None:
+        set_budget(budget)
+
+    # Set log file
+    if log_file:
+        set_log_file(log_file)
+
+    # Inform user
+    log_output(f"\nRunning {script}\n")
+
+    # Execute script
+    runpy.run_path(script, run_name="__main__")
+
+    # Get final state
+    state=get_state()
+
+    # Print per-call breakdown
+    log_output("\n------------------------------------")
+    for i, cost in enumerate(state["calls"], start=1):
+        log_output(f"Call {i} -> ${cost:.6f}")
+
+    # Print summary
+    log_output("\n------------------------------------")
+    log_output(f"Total Calls: {state['total_calls']}")
+    log_output(f"Total Cost: ${state['total_cost']:.6f}")
+    log_output("------------------------------------\n")
+
+    # Budget check
+    budget_value=get_budget()
+    if budget_value is not None and state['total_cost'] > budget_value:
+        log_output(f"\n⚠️ Budget exceeded! Limit: ${budget_value:.6f} | Current: ${state['total_cost']:.6f}")
+        log_output("------------------------------------\n")

costtracker-0.1.0/costtracker/config.py

@@ -0,0 +1,34 @@
+import os
+import tomllib
+
+DEFAULT_CONFIG = {
+    "budget":None,
+    "log_file":None,
+    "provider":"gemini"
+}
+
+def load_config(config_path:str = "costtracker.toml")->dict:
+    """
+    Load configuration from TOML file.
+    If file does not exist or is invalid, return default config.
+    """
+
+    # Default config
+    config=DEFAULT_CONFIG.copy()
+
+    # Check if config file exists
+    if not os.path.exists(config_path):
+        return config
+    
+    try:
+        with open(config_path, "rb") as f:
+            file_config=tomllib.load(f)
+
+        # Merge file config into default config
+        config.update(file_config)
+    
+    except Exception:
+        # Fail silently 
+        pass
+
+    return config

costtracker-0.1.0/costtracker/decorators.py

@@ -0,0 +1,9 @@
+from .tracker import track as track_function
+
+def track(func):
+    def wrapper(*args, **kwargs):
+        response=func(*args, **kwargs)
+        track_function(response)
+        return response
+    
+    return wrapper

costtracker-0.1.0/costtracker/exceptions.py

@@ -0,0 +1,11 @@
+class CostTrackerError(Exception):
+    """Base exception for costtracker"""
+    pass
+
+class UnsupportedModelError(CostTrackerError):
+    """Raised when model pricing is not available"""
+    pass
+
+class InvalidResponseError(CostTrackerError):
+    """Raised when response format is invalid"""
+    pass

costtracker-0.1.0/costtracker/extractor/__init__.py

@@ -0,0 +1,15 @@
+from .openai_extractor import extract_openai
+from .gemini_extractor import extract_gemini
+
+def extract_usage(response, provider:str):
+    """
+    Router extraction based on provider
+    """
+
+    if provider=="openai":
+        return extract_openai(response)
+    elif provider=="gemini":
+        return extract_gemini(response)
+    
+    else:
+        raise ValueError(f"Unsupported provider: {provider}")

costtracker-0.1.0/costtracker/extractor/base.py

@@ -0,0 +1,12 @@
+from typing import Dict
+
+def standardize_output(input_tokens:int, output_tokens:int, model:str) -> Dict:
+    """
+    Ensure all extractors return a consistent format
+    """
+
+    return {
+        "input_tokens":input_tokens,
+        "output_tokens":output_tokens,
+        "model":model
+    }

costtracker-0.1.0/costtracker/extractor/gemini_extractor.py

@@ -0,0 +1,23 @@
+from .base import standardize_output
+
+def extract_gemini(response):
+    """
+    Extract usage from Gemini response
+    """
+    try:
+        model=getattr(response, "model_version", "unknown")
+
+        usage=getattr(response, "usage_metadata", None)
+
+        if usage:
+            input_tokens=getattr(usage, "prompt_token_count", 0)
+            output_tokens=getattr(usage, "candidates_token_count", 0)
+        
+        else:
+            input_tokens=0
+            output_tokens=0
+
+        return standardize_output(input_tokens, output_tokens, model)
+    
+    except Exception:
+        return standardize_output(0,0,"unknown")

costtracker-0.1.0/costtracker/extractor/openai_extractor.py

@@ -0,0 +1,17 @@
+from .base import standardize_output
+
+def extract_openai(response):
+    """
+    Extract usage from OpenAI-style response
+    """
+
+    usage=getattr(response, "usage", None)
+
+    if not usage:
+        return standardize_output(0,0,getattr(response, "model", "unknown"))
+    
+    input_tokens=getattr(usage, "prompt_tokens", 0)
+    output_tokens=getattr(usage, "completion_tokens", 0)
+    model=getattr(response, "model", "unknown")
+
+    return standardize_output(input_tokens,output_tokens,model)

costtracker-0.1.0/costtracker/formatter.py

@@ -0,0 +1,7 @@
+def format_output(data:dict)->str:
+    return (
+        f"\nModel: {data['model']}\n"
+        f"Tokens: {data['total_tokens']} "
+        f"(input: {data['input_tokens']}, output: {data['output_tokens']})\n"
+        f"Cost: ${data['total_cost']:.6f}\n"
+    )

costtracker-0.1.0/costtracker/logger.py

@@ -0,0 +1,22 @@
+LOG_FILE=None
+
+def set_log_file(file_path:str):
+    """
+    Set log file path
+    """
+
+    global LOG_FILE
+    LOG_FILE=file_path
+
+
+def log_output(message:str):
+    """
+    Print to console + optionally write to file
+    """
+
+    print(message)
+
+    # If logging is enabled then write to file
+    if LOG_FILE:
+        with open(LOG_FILE, "a") as f:
+            f.write(message + "\n")

costtracker-0.1.0/costtracker/pricing.py

@@ -0,0 +1,16 @@
+from .pricing_loader import fetch_remote_pricing
+
+def get_pricing(model:str):
+    """
+    Get pricing for a given model from remote source
+    """
+
+    pricing_data=fetch_remote_pricing()
+
+    if not pricing_data:
+        raise ValueError("Pricing service unavailable")
+    if model not in pricing_data:
+        raise ValueError(f"Pricing not found for model: {model}")
+    
+    return pricing_data[model]
+    

costtracker-0.1.0/costtracker/pricing_loader.py

@@ -0,0 +1,25 @@
+import json
+import urllib.request
+
+PRICING_URL = "https://raw.githubusercontent.com/viishalvermaa/costtrack-pricing-remote/refs/heads/main/pricing.json"
+
+_cached_pricing = None
+
+def fetch_remote_pricing():
+    """
+    Fetch price from remote source with caching
+    """
+
+    global _cached_pricing
+
+    # Return cached if available
+    if _cached_pricing is not None:
+        return _cached_pricing
+    
+    try:
+        with urllib.request.urlopen(PRICING_URL) as response:
+            data=response.read()
+            _cached_pricing=json.loads(data)
+            return _cached_pricing
+    except Exception:
+        return {}

costtracker-0.1.0/costtracker/state.py

@@ -0,0 +1,50 @@
+# Global state (shared across entire script execution)
+
+TOTAL_COST=0.0
+TOTAL_CALLS=0
+CALL_LOGS=[]
+BUDGET=None
+
+def set_budget(value:float):
+    """
+    Set budget for the session
+    """
+
+    global BUDGET
+    BUDGET=value
+
+def get_budget():
+    return BUDGET
+
+def update_state(cost: float):
+    """
+    Update total cost and call count
+    """
+
+    global TOTAL_COST, TOTAL_CALLS, CALL_LOGS
+
+    TOTAL_COST+=cost
+    TOTAL_CALLS+=1
+    CALL_LOGS.append(cost)
+
+def get_state():
+    """
+    Get current tracking state
+    """
+
+    return {
+        "total_cost": TOTAL_COST,
+        "total_calls": TOTAL_CALLS,
+        "calls": CALL_LOGS
+    }
+
+def reset_state():
+    """
+    Reset state before running a new script
+    """
+
+    global TOTAL_COST, TOTAL_CALLS, CALL_LOGS
+
+    TOTAL_COST=0.0
+    TOTAL_CALLS=0
+    CALL_LOGS=[]

costtracker-0.1.0/costtracker/tracker.py

@@ -0,0 +1,115 @@
+from .extractor import extract_usage
+from .pricing import get_pricing
+from .calculator import calculate_cost
+from .formatter import format_output
+from .logger import log_output
+from .exceptions import CostTrackerError
+from .state import update_state
+from .config import load_config
+from .utils.provider_detector import detect_provider
+
+def track(response, provider=None):
+    """
+    Track cost of a response.
+    Provider can be passed explicitly or resolved via config/default
+    """
+
+    try:
+        config=load_config()
+
+        # explicit provider
+        if provider:
+            final_provider=provider
+        
+        # auto-detect first
+        else:
+            detected=detect_provider(response)
+
+            if detected:
+                final_provider=detected
+
+            # fallback to config(future release)
+            elif config.get("provider"):
+                final_provider=config.get("provider")
+            
+            else:
+                log_output("⚠️ Could not detect provider. Skipping cost tracking.")
+                return None
+
+
+        # Extract usage
+        try:
+            usage_data=extract_usage(response, final_provider)
+        except Exception:
+            log_output("⚠️ Failed to extract usage data. Skipping.")
+            return None
+
+        input_tokens=usage_data.get("input_tokens", 0)
+        output_tokens=usage_data.get("output_tokens", 0)
+        model=usage_data.get("model", "unknown")
+
+        if model == "unknown":
+            log_output("⚠️ Model not detected. Skipping cost calculation.")
+
+            update_state(0)
+
+            return {
+                "model":model,
+                "input_tokens":input_tokens,
+                "output_tokens":output_tokens,
+                "total_tokens": input_tokens+output_tokens,
+                "total_cost": 0
+            }
+
+
+        # Get pricing
+        try:
+            pricing=get_pricing(model)
+        except Exception:
+            log_output(f"⚠️ Pricing not found for model: {model}. Skipping cost.")
+
+            update_state(0)
+
+            return {
+                "model":model,
+                "input_tokens":input_tokens,
+                "output_tokens":output_tokens,
+                "total_tokens": input_tokens+output_tokens,
+                "total_cost": 0
+            }
+
+
+        # Calculate cost
+        try:
+            cost_data=calculate_cost(input_tokens, output_tokens, pricing)
+            total_cost=cost_data.get("total_cost", 0)
+        except Exception:
+            log_output("⚠️ Cost calculation failed.  Setting cost to 0.")
+            total_cost=0
+        
+
+        update_state(total_cost)
+
+        # Final data
+        final_data={
+            "model":model,
+            "input_tokens":input_tokens,
+            "output_tokens":output_tokens,
+            "total_tokens": input_tokens+output_tokens,
+            "total_cost": total_cost
+        }
+
+        # Format output
+        try:
+            output=format_output(final_data)
+        except Exception:
+            log_output(f"Tracked: {final_data}")
+
+        # Log output
+        # log_output(output)
+
+        return final_data
+    
+    except Exception as e:
+        log_output(f"[Unexpected Error] {str(e)}")
+        return None

costtracker-0.1.0/costtracker/utils/provider_detector.py

@@ -0,0 +1,15 @@
+def detect_provider(response):
+    """
+    Detect provider based on response structure
+    """
+
+    # Gemini
+    if hasattr(response, "model_version"):
+        return "gemini"
+
+    # OpenAI
+    if hasattr(response, "usage"):
+        return "openai"
+    
+    # Unknown provider
+    return None

costtracker-0.1.0/costtracker.egg-info/PKG-INFO

@@ -0,0 +1,121 @@
+Metadata-Version: 2.4
+Name: costtracker
+Version: 0.1.0
+Summary: Simple and lightweight Python package to track LLM API cost
+Author: Vishal Verma
+License: MIT
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: python-dotenv
+Requires-Dist: google-genai
+Dynamic: license-file
+
+# 🚀 costtracker
+
+<p align="center">
+  <b>Track your LLM API cost in real time — with one line of code.</b>
+</p>
+
+<p align="center">
+  <img src="https://img.shields.io/badge/python-3.11+-blue.svg" />
+  <img src="https://img.shields.io/badge/status-active-success.svg" />
+  <img src="https://img.shields.io/badge/license-MIT-green.svg" />
+  <img src="https://img.shields.io/badge/built%20with-GenAI-purple.svg" />
+</p>
+
+---
+
+## ✨ Why costtracker?
+
+Building with LLMs is easy.  
+**Tracking cost isn’t.**
+
+costtracker solves this by giving you:
+
+> ⚡ Instant cost visibility for every API call
+
+No dashboards. No setup. No complexity.
+
+---
+
+## 🔥 Features
+
+- 📊 Real-time token + cost tracking  
+- ⚡ One-line integration (`track(response)`)  
+- 🧠 Works with OpenAI-compatible APIs for now (Gemini included)  
+- 🪶 Lightweight & zero-config  
+- 🧱 Built for developers  
+
+---
+
+## ⚡ Quick Demo
+
+```python
+from costtracker import track
+
+track(response)
+```
+
+## ⚡ Output
+```
+Model: gemini-2.5-flash-lite
+Tokens: 13 (input: 4, output: 9)
+Cost: $0.000011
+```
+
+## 📦 Installation
+```
+pip install -e .
+```
+
+## ⚙️ Setup
+
+Create a .env file in your root directory:
+```.env
+GEMINI_API_KEY=your_api_key_here
+```
+
+## 🧪 Usage
+```python
+import os
+from dotenv import load_dotenv
+from openai import OpenAI
+from costtracker import track
+
+load_dotenv()
+
+client = OpenAI(
+    api_key=os.getenv("GEMINI_API_KEY"),
+    base_url="https://generativelanguage.googleapis.com/v1beta/openai/"
+)
+
+response = client.chat.completions.create(
+    model="gemini-2.5-flash-lite",
+    messages=[
+        {"role": "user", "content": "Hello there!"}
+    ]
+)
+
+track(response)
+```
+
+## 💡 Use Cases
+
+- 🧑‍💻 AI app developers tracking API usage
+- 🚀 Startup teams controlling LLM costs
+- 📊 Experimentation with prompt optimization
+- 🧪 GenAI project building
+
+## 🤝 Contributing
+
+- Contributions are welcome!
+- Feel free to open issues or submit PRs.
+
+## ⭐ If you like this project
+
+**Give it a star**
+
+## 📄 License
+
+MIT License

costtracker-0.1.0/costtracker.egg-info/SOURCES.txt

@@ -0,0 +1,26 @@
+LICENSE
+README.md
+pyproject.toml
+costtracker/__init__.py
+costtracker/calculator.py
+costtracker/cli.py
+costtracker/config.py
+costtracker/decorators.py
+costtracker/exceptions.py
+costtracker/formatter.py
+costtracker/logger.py
+costtracker/pricing.py
+costtracker/pricing_loader.py
+costtracker/state.py
+costtracker/tracker.py
+costtracker.egg-info/PKG-INFO
+costtracker.egg-info/SOURCES.txt
+costtracker.egg-info/dependency_links.txt
+costtracker.egg-info/entry_points.txt
+costtracker.egg-info/requires.txt
+costtracker.egg-info/top_level.txt
+costtracker/extractor/__init__.py
+costtracker/extractor/base.py
+costtracker/extractor/gemini_extractor.py
+costtracker/extractor/openai_extractor.py
+costtracker/utils/provider_detector.py

costtracker-0.1.0/costtracker.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

costtracker-0.1.0/costtracker.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+costtracker = costtracker.cli:cli

costtracker-0.1.0/costtracker.egg-info/requires.txt

@@ -0,0 +1,2 @@
+python-dotenv
+google-genai

costtracker-0.1.0/costtracker.egg-info/top_level.txt

@@ -0,0 +1 @@
+costtracker

costtracker-0.1.0/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "costtracker"
+version = "0.1.0"
+description = "Simple and lightweight Python package to track LLM API cost"
+authors = [
+    {name="Vishal Verma"}
+]
+readme = "README.md"
+requires-python = ">=3.11"
+license = {text = "MIT"}
+
+dependencies = [
+    "python-dotenv",
+    "google-genai"
+]
+
+[project.scripts]
+costtracker="costtracker.cli:cli"

costtracker-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+