llm-cost-tracker 0.1.2__tar.gz

llm_cost_tracker-0.1.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Heondeuk Lee
+
+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_cost_tracker-0.1.2/PKG-INFO

@@ -0,0 +1,115 @@
+Metadata-Version: 2.4
+Name: llm-cost-tracker
+Version: 0.1.2
+Summary: LLM API call token usage-based expense tracker
+Home-page: https://github.com/hundredeuk2/tracker
+Author: Heondeuk Lee
+Author-email: leehd1995@gmail.com
+License: MIT
+Classifier: Programming Language :: Python :: 3
+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: PyYAML>=5.1
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# TrackMyLLM(cost)
+
+### 1. Example usage for class method:
+```python
+from tracker.cost_tracker import cost_tracker
+from openai import OpenAI, AsyncOpenAI
+
+class Agent:
+    def __init__(self, model_name, api_key = None):
+        self.model_name = model_name # nessary
+        self.costs: dict[str, list[float]] = {} # nessary
+
+        if api_key:
+            self._initialize_client(api_key)
+            
+    def _initialize_client(self, api_key):
+        self.client = OpenAI(api_key=api_key)
+        self.aclient = AsyncOpenAI(api_key=api_key)
+    
+    # just for compatibility
+    def total_cost(self):
+        return float(round(sum(sum(lst) for lst in self.costs.values()), 6))
+    
+    @cost_tracker.track_cost() 
+    def ask(self, prompt: str):
+        resp = self.client.chat.completions.create(
+            model=self.model_name,
+            messages=[{"role":"user","content":prompt}],
+        )
+        return resp, {"model_response": resp.choices[0].message.content}
+    
+    @cost_tracker.track_cost() 
+    async def aask(self, prompt: str):
+        resp = await self.aclient.ChatCompletion.acreate(
+            model=self.model_name,
+            messages=[{"role":"user","content":prompt}],
+        )
+        return resp, {"model_response": resp.choices[0].message.content}
+
+test_client = Agent(model_name="gpt-4o-mini")
+a, b = test_client.ask("Hello, world!")
+print("Individual costs: ", test_client.costs)
+print("Total cost: ", format(test_client.total_cost(), "f"))
+
+# Individual costs:  defaultdict(<class 'list'>, {'gpt-4o-mini': [8.400000000000001e-06]})
+# Total cost:  0.000008
+
+a, b = await test_client.aask("Hello, world!")
+print("Individual costs: ", test_client.costs)
+print("Total cost: ", format(test_client.total_cost(), "f"))
+
+# Individual costs:  {'gpt-4o-mini': [7.65e-06, 7.65e-06]}
+# Total cost:  0.000015
+```
+
+### 2. Example usage for single function:
+```python
+from openai import OpenAI
+from tracker.cost_tracker import cost_tracker
+
+model_name = "gpt-4o-mini"
+client = OpenAI()
+
+@cost_tracker.track_cost()
+def generate(model_name, prompt):
+    completion = client.chat.completions.create(
+        model = model_name,
+        max_tokens=8192,
+        messages=[
+            {
+                "role":"system",
+                "content":"Your a Great AI"
+            },
+            {
+                "role":"user",
+                "content":prompt
+            }
+        ],
+    )
+    return completion
+
+response = generate(model_name, "Hello, world!")
+print("Individual costs: ", cost_tracker.costs)
+print("Total cost: ", format(cost_tracker.total_cost(), "f"))
+
+# Individual costs:  defaultdict(<class 'list'>, {'gpt-4o-mini': [8.400000000000001e-06]})
+# Total cost:  0.000008
+```

llm_cost_tracker-0.1.2/README.md

@@ -0,0 +1,88 @@
+# TrackMyLLM(cost)
+
+### 1. Example usage for class method:
+```python
+from tracker.cost_tracker import cost_tracker
+from openai import OpenAI, AsyncOpenAI
+
+class Agent:
+    def __init__(self, model_name, api_key = None):
+        self.model_name = model_name # nessary
+        self.costs: dict[str, list[float]] = {} # nessary
+
+        if api_key:
+            self._initialize_client(api_key)
+            
+    def _initialize_client(self, api_key):
+        self.client = OpenAI(api_key=api_key)
+        self.aclient = AsyncOpenAI(api_key=api_key)
+    
+    # just for compatibility
+    def total_cost(self):
+        return float(round(sum(sum(lst) for lst in self.costs.values()), 6))
+    
+    @cost_tracker.track_cost() 
+    def ask(self, prompt: str):
+        resp = self.client.chat.completions.create(
+            model=self.model_name,
+            messages=[{"role":"user","content":prompt}],
+        )
+        return resp, {"model_response": resp.choices[0].message.content}
+    
+    @cost_tracker.track_cost() 
+    async def aask(self, prompt: str):
+        resp = await self.aclient.ChatCompletion.acreate(
+            model=self.model_name,
+            messages=[{"role":"user","content":prompt}],
+        )
+        return resp, {"model_response": resp.choices[0].message.content}
+
+test_client = Agent(model_name="gpt-4o-mini")
+a, b = test_client.ask("Hello, world!")
+print("Individual costs: ", test_client.costs)
+print("Total cost: ", format(test_client.total_cost(), "f"))
+
+# Individual costs:  defaultdict(<class 'list'>, {'gpt-4o-mini': [8.400000000000001e-06]})
+# Total cost:  0.000008
+
+a, b = await test_client.aask("Hello, world!")
+print("Individual costs: ", test_client.costs)
+print("Total cost: ", format(test_client.total_cost(), "f"))
+
+# Individual costs:  {'gpt-4o-mini': [7.65e-06, 7.65e-06]}
+# Total cost:  0.000015
+```
+
+### 2. Example usage for single function:
+```python
+from openai import OpenAI
+from tracker.cost_tracker import cost_tracker
+
+model_name = "gpt-4o-mini"
+client = OpenAI()
+
+@cost_tracker.track_cost()
+def generate(model_name, prompt):
+    completion = client.chat.completions.create(
+        model = model_name,
+        max_tokens=8192,
+        messages=[
+            {
+                "role":"system",
+                "content":"Your a Great AI"
+            },
+            {
+                "role":"user",
+                "content":prompt
+            }
+        ],
+    )
+    return completion
+
+response = generate(model_name, "Hello, world!")
+print("Individual costs: ", cost_tracker.costs)
+print("Total cost: ", format(cost_tracker.total_cost(), "f"))
+
+# Individual costs:  defaultdict(<class 'list'>, {'gpt-4o-mini': [8.400000000000001e-06]})
+# Total cost:  0.000008
+```

llm_cost_tracker-0.1.2/llm_cost_tracker.egg-info/PKG-INFO

@@ -0,0 +1,115 @@
+Metadata-Version: 2.4
+Name: llm-cost-tracker
+Version: 0.1.2
+Summary: LLM API call token usage-based expense tracker
+Home-page: https://github.com/hundredeuk2/tracker
+Author: Heondeuk Lee
+Author-email: leehd1995@gmail.com
+License: MIT
+Classifier: Programming Language :: Python :: 3
+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: PyYAML>=5.1
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# TrackMyLLM(cost)
+
+### 1. Example usage for class method:
+```python
+from tracker.cost_tracker import cost_tracker
+from openai import OpenAI, AsyncOpenAI
+
+class Agent:
+    def __init__(self, model_name, api_key = None):
+        self.model_name = model_name # nessary
+        self.costs: dict[str, list[float]] = {} # nessary
+
+        if api_key:
+            self._initialize_client(api_key)
+            
+    def _initialize_client(self, api_key):
+        self.client = OpenAI(api_key=api_key)
+        self.aclient = AsyncOpenAI(api_key=api_key)
+    
+    # just for compatibility
+    def total_cost(self):
+        return float(round(sum(sum(lst) for lst in self.costs.values()), 6))
+    
+    @cost_tracker.track_cost() 
+    def ask(self, prompt: str):
+        resp = self.client.chat.completions.create(
+            model=self.model_name,
+            messages=[{"role":"user","content":prompt}],
+        )
+        return resp, {"model_response": resp.choices[0].message.content}
+    
+    @cost_tracker.track_cost() 
+    async def aask(self, prompt: str):
+        resp = await self.aclient.ChatCompletion.acreate(
+            model=self.model_name,
+            messages=[{"role":"user","content":prompt}],
+        )
+        return resp, {"model_response": resp.choices[0].message.content}
+
+test_client = Agent(model_name="gpt-4o-mini")
+a, b = test_client.ask("Hello, world!")
+print("Individual costs: ", test_client.costs)
+print("Total cost: ", format(test_client.total_cost(), "f"))
+
+# Individual costs:  defaultdict(<class 'list'>, {'gpt-4o-mini': [8.400000000000001e-06]})
+# Total cost:  0.000008
+
+a, b = await test_client.aask("Hello, world!")
+print("Individual costs: ", test_client.costs)
+print("Total cost: ", format(test_client.total_cost(), "f"))
+
+# Individual costs:  {'gpt-4o-mini': [7.65e-06, 7.65e-06]}
+# Total cost:  0.000015
+```
+
+### 2. Example usage for single function:
+```python
+from openai import OpenAI
+from tracker.cost_tracker import cost_tracker
+
+model_name = "gpt-4o-mini"
+client = OpenAI()
+
+@cost_tracker.track_cost()
+def generate(model_name, prompt):
+    completion = client.chat.completions.create(
+        model = model_name,
+        max_tokens=8192,
+        messages=[
+            {
+                "role":"system",
+                "content":"Your a Great AI"
+            },
+            {
+                "role":"user",
+                "content":prompt
+            }
+        ],
+    )
+    return completion
+
+response = generate(model_name, "Hello, world!")
+print("Individual costs: ", cost_tracker.costs)
+print("Total cost: ", format(cost_tracker.total_cost(), "f"))
+
+# Individual costs:  defaultdict(<class 'list'>, {'gpt-4o-mini': [8.400000000000001e-06]})
+# Total cost:  0.000008
+```

llm_cost_tracker-0.1.2/llm_cost_tracker.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+setup.py
+llm_cost_tracker.egg-info/PKG-INFO
+llm_cost_tracker.egg-info/SOURCES.txt
+llm_cost_tracker.egg-info/dependency_links.txt
+llm_cost_tracker.egg-info/requires.txt
+llm_cost_tracker.egg-info/top_level.txt
+tracker/__init__.py
+tracker/cost_tracker.py
+tracker/pricing.yaml
+tracker/pricing_loader.py

llm_cost_tracker-0.1.2/llm_cost_tracker.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

llm_cost_tracker-0.1.2/llm_cost_tracker.egg-info/requires.txt

@@ -0,0 +1 @@
+PyYAML>=5.1

llm_cost_tracker-0.1.2/llm_cost_tracker.egg-info/top_level.txt

@@ -0,0 +1 @@
+tracker

llm_cost_tracker-0.1.2/setup.cfg

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

llm_cost_tracker-0.1.2/setup.py

@@ -0,0 +1,30 @@
+from setuptools import setup, find_packages
+from pathlib import Path
+
+README = Path(__file__).parent / "README.md"
+
+setup(
+    name="llm-cost-tracker",                            
+    version="0.1.2",
+    description="LLM API call token usage-based expense tracker",
+    long_description=README.read_text(encoding="utf-8"),
+    long_description_content_type="text/markdown",
+    author="Heondeuk Lee",
+    author_email="leehd1995@gmail.com",
+    url="https://github.com/hundredeuk2/tracker",
+    packages=find_packages(exclude=["tutorial", "tests*"]),
+    install_requires=[
+        "PyYAML>=5.1",
+    ],
+    python_requires=">=3.10",
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    include_package_data=True,
+    package_data={
+        "tracker": ["pricing.yaml"],
+    },
+    license="MIT",
+)

llm_cost_tracker-0.1.2/tracker/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.1" 

llm_cost_tracker-0.1.2/tracker/cost_tracker.py

@@ -0,0 +1,94 @@
+import inspect
+from functools import wraps
+from collections import defaultdict
+from typing import Any, Callable
+from .pricing_loader import load_pricing_yaml
+
+class CostTracker:
+    def __init__(self, 
+                pricing: dict[str, dict[str, float]] = None, 
+                pricing_path: str = "pricing.yaml"):
+        self.pricing = pricing or load_pricing_yaml(pricing_path)
+        self.costs: dict[str, list[float]] = defaultdict(list)
+
+    def total_cost(self, instance: Any = None) -> float:
+        if instance is not None and hasattr(instance, "costs"):
+            data = instance.costs.values()
+        else:
+            data = self.costs.values()
+        return round(sum(sum(lst) for lst in data), 6)
+
+    def track_cost(self, response_index: int = 0):
+        def decorator(fn: Callable):
+            is_async = inspect.iscoroutinefunction(fn)
+
+            def _calc_cost(resp, pricing):
+                usage = getattr(resp, "usage", None)
+                pt = next((getattr(usage, attr) for attr in ("prompt_tokens", "input_tokens") if hasattr(usage, attr)), 0)
+                ct = next((getattr(usage, attr) for attr in ("completion_tokens", "output_tokens") if hasattr(usage, attr)), 0)
+                return pt * pricing.get("prompt", 0.0) + ct * pricing.get("completion", 0.0)
+
+            if is_async:
+                @wraps(fn)
+                async def async_wrapper(*args, **kwargs):
+                    result = await fn(*args, **kwargs)
+                    resp = (result[response_index]
+                            if isinstance(result, (tuple, list)) else result)
+                    inst = args[0] if args else None
+
+                    # 모델 이름 추출 로직은 기존과 동일
+                    if hasattr(inst, "model_name"):
+                        model_name = inst.model_name
+                    elif args:
+                        model_name = args[0]
+                    else:
+                        model_name = None
+
+                    self.check_company(model_name)
+
+                    cost = _calc_cost(resp, self.price_detail[model_name])
+                    if hasattr(inst, "costs"):
+                        inst.costs.setdefault(model_name, []).append(cost)
+                    else:
+                        self.costs.setdefault(model_name, []).append(cost)
+                    return result
+                return async_wrapper
+
+            else:
+                @wraps(fn)
+                def sync_wrapper(*args, **kwargs):
+                    result = fn(*args, **kwargs)
+                    resp = (result[response_index]
+                            if isinstance(result, (tuple, list)) else result)
+                    inst = args[0] if args else None
+
+                    if hasattr(inst, "model_name"):
+                        model_name = inst.model_name
+                    elif args:
+                        model_name = args[0]
+                    else:
+                        model_name = None
+
+                    self.check_company(model_name)
+
+                    cost = _calc_cost(resp, self.price_detail[model_name])
+                    if hasattr(inst, "costs"):
+                        inst.costs.setdefault(model_name, []).append(cost)
+                    else:
+                        self.costs.setdefault(model_name, []).append(cost)
+                    return result
+                return sync_wrapper
+
+        return decorator
+
+    def check_company(self, model_name):
+        if "gpt" in model_name or "o1" in model_name or "o3" in model_name or "o4" in model_name :
+            self.price_detail = self.pricing["openai"]
+        
+        elif "claude" in model_name:
+            self.price_detail = self.pricing["antrophic"]
+
+        else:
+            raise ValueError(f"Unsurppot Model: {model_name}")
+
+cost_tracker = CostTracker()

llm_cost_tracker-0.1.2/tracker/pricing.yaml

@@ -0,0 +1,134 @@
+openai:
+  "gpt-4.1":
+    prompt:     0.000002
+    completion: 0.000008
+
+  "gpt-4.1-mini":
+    prompt:     0.0000004
+    completion: 0.0000016
+
+  "gpt-4.1-nano":
+    prompt:     0.0000001
+    completion: 0.0000004
+
+  "gpt-4.5-preview":
+    prompt:     0.000075
+    completion: 0.000150
+
+  "gpt-4o":
+    prompt:     0.0000025
+    completion: 0.0000100
+
+  "gpt-4o-audio-preview":
+    prompt:     0.0000025
+    completion: 0.0000100
+
+  "gpt-4o-realtime-preview":
+    prompt:     0.0000050
+    completion: 0.0000200
+
+  "gpt-4o-mini":
+    prompt:     0.00000015
+    completion: 0.00000060
+
+  "gpt-4o-mini-audio-preview":
+    prompt:     0.00000015
+    completion: 0.00000060
+
+  "gpt-4o-mini-realtime-preview":
+    prompt:     0.00000060
+    completion: 0.00000240
+
+  "o1":
+    prompt:     0.0000150
+    completion: 0.0000600
+
+  "o1-pro":
+    prompt:     0.0001500
+    completion: 0.0006000
+
+  "o3":
+    prompt:     0.0000100
+    completion: 0.0000400
+
+  "o4-mini":
+    prompt:     0.0000011
+    completion: 0.0000044
+
+  "o3-mini":
+    prompt:     0.0000011
+    completion: 0.0000044
+
+  "o1-mini":
+    prompt:     0.0000011
+    completion: 0.0000044
+
+  "gpt-4o-mini-search-preview":
+    prompt:     0.00000015
+    completion: 0.00000060
+
+  "gpt-4o-search-preview":
+    prompt:     0.0000025
+    completion: 0.0000100
+
+  "computer-use-preview":
+    prompt:     0.0000030
+    completion: 0.0000120
+
+  "gpt-image-1":
+    prompt:     0.0000050
+
+antrophic:
+  "claude-3-7-sonnet-20250219":
+    prompt: 0.000003
+    cache_writes:        0.00000375
+    cache_hits:          0.00000030
+    completion:       0.000015
+
+  "claude-3-7-sonnet-latest":
+    prompt: 0.000003
+    cache_writes:        0.00000375
+    cache_hits:          0.00000030
+    completion:       0.000015
+
+  "claude-3-5-sonnet-20241022":
+    prompt: 0.000003
+    cache_writes:        0.00000375
+    cache_hits:          0.00000030
+    completion:       0.000015
+
+  "claude-3-5-sonnet-latest":
+    prompt: 0.000003
+    cache_writes:        0.00000375
+    cache_hits:          0.00000030
+    completion:       0.000015
+
+  "claude-3-5-haiku-20241022":
+    prompt: 0.00000080
+    cache_writes:        0.00000100
+    cache_hits:          0.00000008
+    completion:       0.000004
+
+  "claude-3-5-haiku-latest":
+    prompt: 0.00000080
+    cache_writes:        0.00000100
+    cache_hits:          0.00000008
+    completion:       0.000004
+
+  "claude-3-opus-20240229":
+    prompt: 0.000015
+    cache_writes:        0.00001875
+    cache_hits:          0.00000150
+    completion:       0.000075
+
+  "claude-3-opus-latest":
+    prompt: 0.000015
+    cache_writes:        0.00001875
+    cache_hits:          0.00000150
+    completion:       0.000075
+
+  "claude-3-haiku-20240307":
+    prompt: 0.00000025
+    cache_writes:        0.00000030
+    cache_hits:          0.00000003
+    completion:       0.00000125

llm_cost_tracker-0.1.2/tracker/pricing_loader.py

@@ -0,0 +1,14 @@
+import yaml
+from pathlib import Path
+from typing import Dict
+
+BASE_DIR = Path(__file__).parent
+DEFAULT_PRICING_FILE = BASE_DIR / "pricing.yaml"
+
+def load_pricing_yaml(path: str | Path | None = None) -> Dict[str, Dict[str, float]]:
+    yaml_path = Path(path) if path else DEFAULT_PRICING_FILE
+    if not yaml_path.is_absolute():
+        yaml_path = BASE_DIR / yaml_path
+    with open(yaml_path, encoding="utf-8") as f:
+        data = yaml.safe_load(f)
+    return data