costimizer 0.1.0__tar.gz

costimizer-0.1.0/LICENSE

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

costimizer-0.1.0/PKG-INFO

@@ -0,0 +1,91 @@
+Metadata-Version: 2.4
+Name: costimizer
+Version: 0.1.0
+Summary: Costimizer AI observability SDK for LLM FinOps
+Author-email: Costimizer <itadmin@costimizer.ai>
+License: MIT
+Project-URL: Homepage, https://costimizer.ai
+Project-URL: Documentation, https://costimizer.ai
+Project-URL: Repository, https://gitlab.bigohtech.com/costimizer/finops/finops-ai-sdk
+Project-URL: Issues, https://gitlab.bigohtech.com/costimizer/finops/finops-ai-sdk/-/issues
+Keywords: llm,finops,observability,openai,anthropic,gemini,openrouter,cost-tracking
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.28.0
+Provides-Extra: openai
+Requires-Dist: openai>=1.60.0; extra == "openai"
+Provides-Extra: openrouter
+Requires-Dist: openai>=1.60.0; extra == "openrouter"
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.40.0; extra == "anthropic"
+Provides-Extra: gemini
+Requires-Dist: google-genai>=1.0.0; extra == "gemini"
+Provides-Extra: google
+Requires-Dist: google-genai>=1.0.0; extra == "google"
+Provides-Extra: all
+Requires-Dist: openai>=1.60.0; extra == "all"
+Requires-Dist: anthropic>=0.40.0; extra == "all"
+Requires-Dist: google-genai>=1.0.0; extra == "all"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.3.0; extra == "dev"
+Requires-Dist: build>=1.2.0; extra == "dev"
+Requires-Dist: twine>=5.1.0; extra == "dev"
+Dynamic: license-file
+
+# Costimizer Python SDK
+
+[![PyPI](https://img.shields.io/pypi/v/costimizer.svg)](https://pypi.org/project/costimizer/)
+
+Capture LLM calls and send them to Costimizer FinOps.
+
+Install only the provider client you use — same pattern as PostHog:
+
+```bash
+pip install "costimizer[openai]"
+pip install "costimizer[all]"   # every provider
+```
+
+Core SDK (`httpx` only) installs with:
+
+```bash
+pip install costimizer
+```
+
+## OpenAI
+
+```bash
+pip install "costimizer[openai]"
+```
+
+```python
+from costimizer import Costimizer
+from costimizer.ai.openai import OpenAI
+
+costimizer = Costimizer(
+    project_token="fo_ingest_your_key",
+    host="https://api.costimizer.ai",
+)
+
+client = OpenAI(
+    api_key="sk-...",
+    costimizer_client=costimizer,
+)
+
+response = client.chat.completions.create(
+    model="gpt-4o-mini",
+    messages=[{"role": "user", "content": "Hello"}],
+    costimizer_trace_name="support-chat",
+)
+costimizer.shutdown()
+```

costimizer-0.1.0/README.md

@@ -0,0 +1,46 @@
+# Costimizer Python SDK
+
+[![PyPI](https://img.shields.io/pypi/v/costimizer.svg)](https://pypi.org/project/costimizer/)
+
+Capture LLM calls and send them to Costimizer FinOps.
+
+Install only the provider client you use — same pattern as PostHog:
+
+```bash
+pip install "costimizer[openai]"
+pip install "costimizer[all]"   # every provider
+```
+
+Core SDK (`httpx` only) installs with:
+
+```bash
+pip install costimizer
+```
+
+## OpenAI
+
+```bash
+pip install "costimizer[openai]"
+```
+
+```python
+from costimizer import Costimizer
+from costimizer.ai.openai import OpenAI
+
+costimizer = Costimizer(
+    project_token="fo_ingest_your_key",
+    host="https://api.costimizer.ai",
+)
+
+client = OpenAI(
+    api_key="sk-...",
+    costimizer_client=costimizer,
+)
+
+response = client.chat.completions.create(
+    model="gpt-4o-mini",
+    messages=[{"role": "user", "content": "Hello"}],
+    costimizer_trace_name="support-chat",
+)
+costimizer.shutdown()
+```

costimizer-0.1.0/costimizer/__init__.py

@@ -0,0 +1,5 @@
+from costimizer.client import Costimizer
+
+__version__ = "0.1.0"
+
+__all__ = ["Costimizer", "__version__"]

costimizer-0.1.0/costimizer/ai/__init__.py

@@ -0,0 +1,10 @@
+"""Provider-specific AI wrappers live under costimizer.ai.*.
+
+Install only the provider SDK you need:
+
+    pip install "costimizer[openai]"
+    pip install "costimizer[openrouter]"
+    pip install "costimizer[anthropic]"
+    pip install "costimizer[gemini]"
+    pip install "costimizer[all]"
+"""

costimizer-0.1.0/costimizer/ai/_extras.py

@@ -0,0 +1,8 @@
+from __future__ import annotations
+
+
+def missing_extra_error(*, provider: str, extra: str, package: str) -> ImportError:
+    return ImportError(
+        f'{provider} support requires the "{package}" package. '
+        f'Install it with: pip install "costimizer[{extra}]"'
+    )

costimizer-0.1.0/costimizer/ai/anthropic/__init__.py

@@ -0,0 +1,3 @@
+from costimizer.ai.anthropic.anthropic import Anthropic
+
+__all__ = ["Anthropic"]

costimizer-0.1.0/costimizer/ai/anthropic/anthropic.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from typing import Any
+
+from costimizer.ai.utils import track_llm_call
+from costimizer.client import Costimizer
+
+DEFAULT_BASE_URL = "https://api.anthropic.com"
+
+
+class Anthropic:
+    """Drop-in wrapper around anthropic.Anthropic that reports generations to Costimizer."""
+
+    def __init__(
+        self,
+        api_key: str,
+        costimizer_client: Costimizer,
+        *,
+        privacy_mode: str = "metadata_only",
+    ) -> None:
+        try:
+            from anthropic import Anthropic as AnthropicClient
+        except ImportError as exc:
+            from costimizer.ai._extras import missing_extra_error
+
+            raise missing_extra_error(
+                provider="Anthropic",
+                extra="anthropic",
+                package="anthropic",
+            ) from exc
+
+        self._client = AnthropicClient(api_key=api_key)
+        self._costimizer_client = costimizer_client
+        self._privacy_mode = privacy_mode
+        self.messages = _WrappedMessages(self)
+
+
+class _WrappedMessages:
+    def __init__(self, root: Anthropic) -> None:
+        self._root = root
+
+    def create(
+        self,
+        *,
+        costimizer_distinct_id: str | None = None,
+        costimizer_trace_id: str | None = None,
+        costimizer_trace_name: str | None = None,
+        costimizer_properties: dict[str, Any] | None = None,
+        costimizer_privacy_mode: str | None = None,
+        **kwargs: Any,
+    ) -> Any:
+        root = self._root
+        return track_llm_call(
+            costimizer_client=root._costimizer_client,
+            provider="anthropic",
+            call_fn=root._client.messages.create,
+            trace_id=costimizer_trace_id,
+            trace_name=costimizer_trace_name,
+            distinct_id=costimizer_distinct_id,
+            properties=costimizer_properties,
+            privacy_mode=costimizer_privacy_mode or root._privacy_mode,
+            base_url=DEFAULT_BASE_URL,
+            **kwargs,
+        )

costimizer-0.1.0/costimizer/ai/gemini/__init__.py

@@ -0,0 +1,3 @@
+from costimizer.ai.gemini.gemini import Gemini
+
+__all__ = ["Gemini"]

costimizer-0.1.0/costimizer/ai/gemini/gemini.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from typing import Any
+
+from costimizer.ai.utils import track_llm_call
+from costimizer.client import Costimizer
+
+DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com"
+
+
+class Gemini:
+    """Drop-in wrapper around google.genai.Client that reports generations to Costimizer."""
+
+    def __init__(
+        self,
+        api_key: str,
+        costimizer_client: Costimizer,
+        *,
+        privacy_mode: str = "metadata_only",
+    ) -> None:
+        try:
+            from google import genai
+        except ImportError as exc:
+            from costimizer.ai._extras import missing_extra_error
+
+            raise missing_extra_error(
+                provider="Gemini",
+                extra="gemini",
+                package="google-genai",
+            ) from exc
+
+        self._client = genai.Client(api_key=api_key)
+        self._costimizer_client = costimizer_client
+        self._privacy_mode = privacy_mode
+        self.models = _WrappedModels(self)
+
+
+class _WrappedModels:
+    def __init__(self, root: Gemini) -> None:
+        self._root = root
+
+    def generate_content(
+        self,
+        *,
+        costimizer_distinct_id: str | None = None,
+        costimizer_trace_id: str | None = None,
+        costimizer_trace_name: str | None = None,
+        costimizer_properties: dict[str, Any] | None = None,
+        costimizer_privacy_mode: str | None = None,
+        **kwargs: Any,
+    ) -> Any:
+        root = self._root
+        return track_llm_call(
+            costimizer_client=root._costimizer_client,
+            provider="gemini",
+            call_fn=root._client.models.generate_content,
+            trace_id=costimizer_trace_id,
+            trace_name=costimizer_trace_name,
+            distinct_id=costimizer_distinct_id,
+            properties=costimizer_properties,
+            privacy_mode=costimizer_privacy_mode or root._privacy_mode,
+            base_url=DEFAULT_BASE_URL,
+            **kwargs,
+        )

costimizer-0.1.0/costimizer/ai/openai/__init__.py

@@ -0,0 +1,3 @@
+from costimizer.ai.openai.openai import OpenAI
+
+__all__ = ["OpenAI"]

costimizer-0.1.0/costimizer/ai/openai/openai.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from typing import Any
+
+from costimizer.ai.utils import track_llm_call
+from costimizer.client import Costimizer
+
+
+class OpenAI:
+    """Drop-in wrapper around openai.OpenAI that reports generations to Costimizer."""
+
+    def __init__(
+        self,
+        api_key: str,
+        costimizer_client: Costimizer,
+        *,
+        privacy_mode: str = "full_content",
+    ) -> None:
+        try:
+            from openai import OpenAI as OpenAIClient
+        except ImportError as exc:
+            from costimizer.ai._extras import missing_extra_error
+
+            raise missing_extra_error(
+                provider="OpenAI",
+                extra="openai",
+                package="openai",
+            ) from exc
+
+        self._client = OpenAIClient(api_key=api_key)
+        self._costimizer_client = costimizer_client
+        self._privacy_mode = privacy_mode
+        self.chat = _WrappedChat(self)
+
+
+class _WrappedChat:
+    def __init__(self, root: OpenAI) -> None:
+        self.completions = _WrappedCompletions(root)
+
+
+class _WrappedCompletions:
+    def __init__(self, root: OpenAI) -> None:
+        self._root = root
+
+    def create(
+        self,
+        *,
+        costimizer_distinct_id: str | None = None,
+        costimizer_trace_id: str | None = None,
+        costimizer_trace_name: str | None = None,
+        costimizer_properties: dict[str, Any] | None = None,
+        costimizer_privacy_mode: str | None = None,
+        **kwargs: Any,
+    ) -> Any:
+        root = self._root
+        return track_llm_call(
+            costimizer_client=root._costimizer_client,
+            provider="openai",
+            call_fn=root._client.chat.completions.create,
+            trace_id=costimizer_trace_id,
+            trace_name=costimizer_trace_name,
+            distinct_id=costimizer_distinct_id,
+            properties=costimizer_properties,
+            privacy_mode=costimizer_privacy_mode or root._privacy_mode,
+            base_url=str(root._client.base_url),
+            **kwargs,
+        )

costimizer-0.1.0/costimizer/ai/openrouter/__init__.py

@@ -0,0 +1,3 @@
+from costimizer.ai.openrouter.openrouter import OpenRouter
+
+__all__ = ["OpenRouter"]

costimizer-0.1.0/costimizer/ai/openrouter/openrouter.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+from typing import Any
+
+from costimizer.ai.utils import track_llm_call
+from costimizer.client import Costimizer
+
+DEFAULT_BASE_URL = "https://openrouter.ai/api/v1"
+
+
+class OpenRouter:
+    """Drop-in wrapper around the OpenAI SDK pointed at OpenRouter."""
+
+    def __init__(
+        self,
+        api_key: str,
+        costimizer_client: Costimizer,
+        *,
+        base_url: str = DEFAULT_BASE_URL,
+        privacy_mode: str = "metadata_only",
+    ) -> None:
+        try:
+            from openai import OpenAI as OpenAIClient
+        except ImportError as exc:
+            from costimizer.ai._extras import missing_extra_error
+
+            raise missing_extra_error(
+                provider="OpenRouter",
+                extra="openrouter",
+                package="openai",
+            ) from exc
+
+        self._client = OpenAIClient(api_key=api_key, base_url=base_url)
+        self._costimizer_client = costimizer_client
+        self._privacy_mode = privacy_mode
+        self.chat = _WrappedChat(self)
+
+
+class _WrappedChat:
+    def __init__(self, root: OpenRouter) -> None:
+        self.completions = _WrappedCompletions(root)
+
+
+class _WrappedCompletions:
+    def __init__(self, root: OpenRouter) -> None:
+        self._root = root
+
+    def create(
+        self,
+        *,
+        costimizer_distinct_id: str | None = None,
+        costimizer_trace_id: str | None = None,
+        costimizer_trace_name: str | None = None,
+        costimizer_properties: dict[str, Any] | None = None,
+        costimizer_privacy_mode: str | None = None,
+        **kwargs: Any,
+    ) -> Any:
+        root = self._root
+        return track_llm_call(
+            costimizer_client=root._costimizer_client,
+            provider="openrouter",
+            call_fn=root._client.chat.completions.create,
+            trace_id=costimizer_trace_id,
+            trace_name=costimizer_trace_name,
+            distinct_id=costimizer_distinct_id,
+            properties=costimizer_properties,
+            privacy_mode=costimizer_privacy_mode or root._privacy_mode,
+            base_url=str(root._client.base_url),
+            **kwargs,
+        )

costimizer-0.1.0/costimizer/ai/utils.py

@@ -0,0 +1,156 @@
+from __future__ import annotations
+
+import time
+import uuid
+from collections.abc import Callable
+from typing import Any, Literal
+
+
+def _coerce_int(value: Any) -> int:
+    if value is None:
+        return 0
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return 0
+
+
+def extract_usage(provider: str, response: Any, kwargs: dict[str, Any]) -> tuple[str, int, int]:
+    model = str(kwargs.get("model", "unknown"))
+    input_tokens = 0
+    output_tokens = 0
+
+    if response is None:
+        return model, input_tokens, output_tokens
+
+    if provider in {"openai", "openrouter"}:
+        model = str(getattr(response, "model", model) or model)
+        usage = getattr(response, "usage", None)
+        if usage is not None:
+            input_tokens = _coerce_int(getattr(usage, "prompt_tokens", 0))
+            output_tokens = _coerce_int(getattr(usage, "completion_tokens", 0))
+    elif provider == "anthropic":
+        model = str(getattr(response, "model", model) or model)
+        usage = getattr(response, "usage", None)
+        if usage is not None:
+            input_tokens = _coerce_int(getattr(usage, "input_tokens", 0))
+            output_tokens = _coerce_int(getattr(usage, "output_tokens", 0))
+    elif provider in {"gemini", "google"}:
+        model = str(getattr(response, "model", model) or model)
+        usage = getattr(response, "usage_metadata", None)
+        if usage is not None:
+            input_tokens = _coerce_int(getattr(usage, "prompt_token_count", 0))
+            output_tokens = _coerce_int(getattr(usage, "candidates_token_count", 0))
+
+    return model, input_tokens, output_tokens
+
+
+def _json_safe(value: Any) -> Any:
+    if value is None or isinstance(value, (str, int, float, bool)):
+        return value
+    if isinstance(value, dict):
+        return {str(k): _json_safe(v) for k, v in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [_json_safe(item) for item in value]
+    if hasattr(value, "model_dump"):
+        return _json_safe(value.model_dump())
+    if hasattr(value, "to_dict"):
+        return _json_safe(value.to_dict())
+    if hasattr(value, "__dict__"):
+        return _json_safe(
+            {k: v for k, v in vars(value).items() if not k.startswith("_")}
+        )
+    return str(value)
+
+
+def extract_content(
+    provider: str,
+    response: Any,
+    kwargs: dict[str, Any],
+) -> tuple[Any, list[dict[str, Any]] | None]:
+    if provider in {"openai", "openrouter"}:
+        input_content = kwargs.get("messages")
+        output_messages = None
+        choices = getattr(response, "choices", None)
+        if choices:
+            message = choices[0].message
+            output_messages = [
+                {"role": "assistant", "content": getattr(message, "content", None)}
+            ]
+        return input_content, output_messages
+
+    if provider == "anthropic":
+        input_content = kwargs.get("messages")
+        output_messages = None
+        content = getattr(response, "content", None)
+        if content:
+            text = getattr(content[0], "text", None)
+            output_messages = [{"role": "assistant", "content": text}]
+        return input_content, output_messages
+
+    if provider in {"gemini", "google"}:
+        input_content = kwargs.get("contents")
+        text = getattr(response, "text", None)
+        output_messages = [{"role": "assistant", "content": text}] if text else None
+        return input_content, output_messages
+
+    return None, None
+
+
+def track_llm_call(
+    *,
+    costimizer_client: Any,
+    provider: str,
+    call_fn: Callable[..., Any],
+    trace_id: str | None,
+    trace_name: str | None,
+    distinct_id: str | None,
+    properties: dict[str, Any] | None,
+    privacy_mode: Literal["metadata_only", "full_content"] = "full_content",
+    base_url: str,
+    **kwargs: Any,
+) -> Any:
+    started = time.perf_counter()
+    response = None
+    error: Exception | None = None
+
+    try:
+        response = call_fn(**kwargs)
+    except Exception as exc:
+        error = exc
+    finally:
+        latency_ms = (time.perf_counter() - started) * 1000
+        resolved_trace_id = trace_id or str(uuid.uuid4())
+        model, input_tokens, output_tokens = extract_usage(provider, response, kwargs)
+
+        event: dict[str, Any] = {
+            "type": "generation",
+            "trace_id": resolved_trace_id,
+            "trace_name": trace_name,
+            "provider": provider,
+            "model": model,
+            "latency_ms": round(latency_ms, 2),
+            "input_tokens": input_tokens,
+            "output_tokens": output_tokens,
+            "is_error": error is not None,
+            "distinct_id": distinct_id,
+            "base_url": base_url,
+            "properties": properties or {},
+            "privacy_mode": privacy_mode,
+        }
+
+        if error is not None:
+            event["error_message"] = str(error)
+
+        if privacy_mode == "full_content" and response is not None:
+            input_content, output_messages = extract_content(provider, response, kwargs)
+            event["input_messages"] = _json_safe(input_content)
+            if output_messages is not None:
+                event["output_messages"] = _json_safe(output_messages)
+
+        costimizer_client.enqueue(event)
+
+    if error is not None:
+        raise error
+
+    return response

costimizer-0.1.0/costimizer/client.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+import atexit
+import threading
+import time
+from typing import Any
+
+import httpx
+
+
+class Costimizer:
+    """Sends AI observability events to the Costimizer FinOps API."""
+
+    def __init__(
+        self,
+        project_token: str,
+        host: str = "https://api.costimizer.ai",
+        *,
+        flush_interval_seconds: float = 2.0,
+        max_batch_size: int = 50,
+    ) -> None:
+        self._project_token = project_token
+        self._host = host.rstrip("/")
+        self._flush_interval_seconds = flush_interval_seconds
+        self._max_batch_size = max_batch_size
+        self._queue: list[dict[str, Any]] = []
+        self._lock = threading.Lock()
+        self._http = httpx.Client(timeout=10.0)
+        self._stop = threading.Event()
+        self._worker = threading.Thread(target=self._flush_loop, daemon=True)
+        self._worker.start()
+        atexit.register(self.shutdown)
+
+    @property
+    def ingest_url(self) -> str:
+        return f"{self._host}/api/v1/observability/events"
+
+    def enqueue(self, event: dict[str, Any]) -> None:
+        with self._lock:
+            self._queue.append(event)
+            if len(self._queue) >= self._max_batch_size:
+                self._flush_locked()
+
+    def shutdown(self) -> None:
+        self._stop.set()
+        self._worker.join(timeout=5.0)
+        with self._lock:
+            self._flush_locked()
+        self._http.close()
+
+    def _flush_loop(self) -> None:
+        while not self._stop.wait(self._flush_interval_seconds):
+            with self._lock:
+                self._flush_locked()
+
+    def _flush_locked(self) -> None:
+        if not self._queue:
+            return
+        batch = self._queue[:]
+        self._queue.clear()
+        try:
+            self._http.post(
+                self.ingest_url,
+                json={"events": batch},
+                headers={"Authorization": f"Bearer {self._project_token}"},
+            )
+        except httpx.HTTPError:
+            # MVP: drop on failure so LLM calls are never blocked.
+            pass

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

@@ -0,0 +1,91 @@
+Metadata-Version: 2.4
+Name: costimizer
+Version: 0.1.0
+Summary: Costimizer AI observability SDK for LLM FinOps
+Author-email: Costimizer <itadmin@costimizer.ai>
+License: MIT
+Project-URL: Homepage, https://costimizer.ai
+Project-URL: Documentation, https://costimizer.ai
+Project-URL: Repository, https://gitlab.bigohtech.com/costimizer/finops/finops-ai-sdk
+Project-URL: Issues, https://gitlab.bigohtech.com/costimizer/finops/finops-ai-sdk/-/issues
+Keywords: llm,finops,observability,openai,anthropic,gemini,openrouter,cost-tracking
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.28.0
+Provides-Extra: openai
+Requires-Dist: openai>=1.60.0; extra == "openai"
+Provides-Extra: openrouter
+Requires-Dist: openai>=1.60.0; extra == "openrouter"
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.40.0; extra == "anthropic"
+Provides-Extra: gemini
+Requires-Dist: google-genai>=1.0.0; extra == "gemini"
+Provides-Extra: google
+Requires-Dist: google-genai>=1.0.0; extra == "google"
+Provides-Extra: all
+Requires-Dist: openai>=1.60.0; extra == "all"
+Requires-Dist: anthropic>=0.40.0; extra == "all"
+Requires-Dist: google-genai>=1.0.0; extra == "all"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.3.0; extra == "dev"
+Requires-Dist: build>=1.2.0; extra == "dev"
+Requires-Dist: twine>=5.1.0; extra == "dev"
+Dynamic: license-file
+
+# Costimizer Python SDK
+
+[![PyPI](https://img.shields.io/pypi/v/costimizer.svg)](https://pypi.org/project/costimizer/)
+
+Capture LLM calls and send them to Costimizer FinOps.
+
+Install only the provider client you use — same pattern as PostHog:
+
+```bash
+pip install "costimizer[openai]"
+pip install "costimizer[all]"   # every provider
+```
+
+Core SDK (`httpx` only) installs with:
+
+```bash
+pip install costimizer
+```
+
+## OpenAI
+
+```bash
+pip install "costimizer[openai]"
+```
+
+```python
+from costimizer import Costimizer
+from costimizer.ai.openai import OpenAI
+
+costimizer = Costimizer(
+    project_token="fo_ingest_your_key",
+    host="https://api.costimizer.ai",
+)
+
+client = OpenAI(
+    api_key="sk-...",
+    costimizer_client=costimizer,
+)
+
+response = client.chat.completions.create(
+    model="gpt-4o-mini",
+    messages=[{"role": "user", "content": "Hello"}],
+    costimizer_trace_name="support-chat",
+)
+costimizer.shutdown()
+```

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

@@ -0,0 +1,21 @@
+LICENSE
+README.md
+pyproject.toml
+costimizer/__init__.py
+costimizer/client.py
+costimizer.egg-info/PKG-INFO
+costimizer.egg-info/SOURCES.txt
+costimizer.egg-info/dependency_links.txt
+costimizer.egg-info/requires.txt
+costimizer.egg-info/top_level.txt
+costimizer/ai/__init__.py
+costimizer/ai/_extras.py
+costimizer/ai/utils.py
+costimizer/ai/anthropic/__init__.py
+costimizer/ai/anthropic/anthropic.py
+costimizer/ai/gemini/__init__.py
+costimizer/ai/gemini/gemini.py
+costimizer/ai/openai/__init__.py
+costimizer/ai/openai/openai.py
+costimizer/ai/openrouter/__init__.py
+costimizer/ai/openrouter/openrouter.py

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,26 @@
+httpx>=0.28.0
+
+[all]
+openai>=1.60.0
+anthropic>=0.40.0
+google-genai>=1.0.0
+
+[anthropic]
+anthropic>=0.40.0
+
+[dev]
+pytest>=8.3.0
+build>=1.2.0
+twine>=5.1.0
+
+[gemini]
+google-genai>=1.0.0
+
+[google]
+google-genai>=1.0.0
+
+[openai]
+openai>=1.60.0
+
+[openrouter]
+openai>=1.60.0

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

@@ -0,0 +1 @@
+costimizer

costimizer-0.1.0/pyproject.toml

@@ -0,0 +1,66 @@
+[project]
+name = "costimizer"
+version = "0.1.0"
+description = "Costimizer AI observability SDK for LLM FinOps"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [
+    { name = "Costimizer", email = "itadmin@costimizer.ai" },
+]
+keywords = [
+    "llm",
+    "finops",
+    "observability",
+    "openai",
+    "anthropic",
+    "gemini",
+    "openrouter",
+    "cost-tracking",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+    "httpx>=0.28.0",
+]
+
+[project.urls]
+Homepage = "https://costimizer.ai"
+Documentation = "https://costimizer.ai"
+Repository = "https://gitlab.bigohtech.com/costimizer/finops/finops-ai-sdk"
+Issues = "https://gitlab.bigohtech.com/costimizer/finops/finops-ai-sdk/-/issues"
+
+[project.optional-dependencies]
+openai = ["openai>=1.60.0"]
+openrouter = ["openai>=1.60.0"]
+anthropic = ["anthropic>=0.40.0"]
+gemini = ["google-genai>=1.0.0"]
+google = ["google-genai>=1.0.0"]
+all = [
+    "openai>=1.60.0",
+    "anthropic>=0.40.0",
+    "google-genai>=1.0.0",
+]
+dev = [
+    "pytest>=8.3.0",
+    "build>=1.2.0",
+    "twine>=5.1.0",
+]
+
+[build-system]
+requires = ["setuptools>=68.0"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["costimizer*"]

costimizer-0.1.0/setup.cfg

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