tokenator 0.1.16__py3-none-any.whl → 0.2.1__py3-none-any.whl

tokenator/__init__.py

@@ -3,11 +3,18 @@
 import logging
 from .openai.client_openai import tokenator_openai
 from .anthropic.client_anthropic import tokenator_anthropic
+from .gemini.client_gemini import tokenator_gemini
 from . import usage
 from .utils import get_default_db_path
 from .usage import TokenUsageService
 
 usage = TokenUsageService()  # noqa: F811
-__all__ = ["tokenator_openai", "tokenator_anthropic", "usage", "get_default_db_path"]
+__all__ = [
+    "tokenator_openai",
+    "tokenator_anthropic",
+    "tokenator_gemini",
+    "usage",
+    "get_default_db_path",
+]
 
 logger = logging.getLogger(__name__)

tokenator/base_wrapper.py

@@ -112,7 +112,10 @@ class BaseWrapper:
             try:
                 self._log_usage_impl(token_usage_stats, session, execution_id)
                 session.commit()
-                logger.debug("Successfully committed token usage for execution_id: %s", execution_id)
+                logger.debug(
+                    "Successfully committed token usage for execution_id: %s",
+                    execution_id,
+                )
             except Exception as e:
                 logger.error("Failed to log token usage: %s", str(e))
                 session.rollback()

tokenator/gemini/__init__.py

@@ -0,0 +1,5 @@
+"""Gemini client wrapper with token usage tracking."""
+
+from .client_gemini import tokenator_gemini
+
+__all__ = ["tokenator_gemini"]

tokenator/gemini/client_gemini.py

@@ -0,0 +1,230 @@
+"""Gemini client wrapper with token usage tracking."""
+
+from typing import Any, Optional, Iterator, AsyncIterator
+import logging
+
+from google import genai
+from google.genai.types import GenerateContentResponse
+
+from ..models import (
+    TokenMetrics,
+    TokenUsageStats,
+)
+from ..base_wrapper import BaseWrapper, ResponseType
+from .stream_interceptors import (
+    GeminiAsyncStreamInterceptor,
+    GeminiSyncStreamInterceptor,
+)
+from ..state import is_tokenator_enabled
+
+logger = logging.getLogger(__name__)
+
+
+def _create_usage_callback(execution_id, log_usage_fn):
+    """Creates a callback function for processing usage statistics from stream chunks."""
+
+    def usage_callback(chunks):
+        if not chunks:
+            return
+
+        # Skip if tokenator is disabled
+        if not is_tokenator_enabled:
+            logger.debug("Tokenator is disabled - skipping stream usage logging")
+            return
+
+        logger.debug("Processing stream usage for execution_id: %s", execution_id)
+
+        # Build usage_data from the first chunk's model
+        usage_data = TokenUsageStats(
+            model=chunks[0].model_version,
+            usage=TokenMetrics(),
+        )
+
+        # Only take usage from the last chunk as it contains complete usage info
+        last_chunk = chunks[-1]
+        if last_chunk.usage_metadata:
+            usage_data.usage.prompt_tokens = (
+                last_chunk.usage_metadata.prompt_token_count
+            )
+            usage_data.usage.completion_tokens = (
+                last_chunk.usage_metadata.candidates_token_count or 0
+            )
+            usage_data.usage.total_tokens = last_chunk.usage_metadata.total_token_count
+            log_usage_fn(usage_data, execution_id=execution_id)
+
+    return usage_callback
+
+
+class BaseGeminiWrapper(BaseWrapper):
+    def __init__(self, client, db_path=None, provider: str = "gemini"):
+        super().__init__(client, db_path)
+        self.provider = provider
+        self._async_wrapper = None
+
+    def _process_response_usage(
+        self, response: ResponseType
+    ) -> Optional[TokenUsageStats]:
+        """Process and log usage statistics from a response."""
+        try:
+            if isinstance(response, GenerateContentResponse):
+                if response.usage_metadata is None:
+                    return None
+                usage = TokenMetrics(
+                    prompt_tokens=response.usage_metadata.prompt_token_count,
+                    completion_tokens=response.usage_metadata.candidates_token_count,
+                    total_tokens=response.usage_metadata.total_token_count,
+                )
+                return TokenUsageStats(model=response.model_version, usage=usage)
+
+            elif isinstance(response, dict):
+                usage_dict = response.get("usage_metadata")
+                if not usage_dict:
+                    return None
+                usage = TokenMetrics(
+                    prompt_tokens=usage_dict.get("prompt_token_count", 0),
+                    completion_tokens=usage_dict.get("candidates_token_count", 0),
+                    total_tokens=usage_dict.get("total_token_count", 0),
+                )
+                return TokenUsageStats(
+                    model=response.get("model", "unknown"), usage=usage
+                )
+        except Exception as e:
+            logger.warning("Failed to process usage stats: %s", str(e))
+            return None
+        return None
+
+    @property
+    def chat(self):
+        return self
+
+    @property
+    def chats(self):
+        return self
+
+    @property
+    def models(self):
+        return self
+
+    @property
+    def aio(self):
+        if self._async_wrapper is None:
+            self._async_wrapper = AsyncGeminiWrapper(self)
+        return self._async_wrapper
+
+    def count_tokens(self, *args: Any, **kwargs: Any):
+        return self.client.models.count_tokens(*args, **kwargs)
+
+
+class AsyncGeminiWrapper:
+    """Async wrapper for Gemini client to match the official SDK structure."""
+
+    def __init__(self, wrapper: BaseGeminiWrapper):
+        self.wrapper = wrapper
+        self._models = None
+
+    @property
+    def models(self):
+        if self._models is None:
+            self._models = AsyncModelsWrapper(self.wrapper)
+        return self._models
+
+
+class AsyncModelsWrapper:
+    """Async wrapper for models to match the official SDK structure."""
+
+    def __init__(self, wrapper: BaseGeminiWrapper):
+        self.wrapper = wrapper
+
+    async def generate_content(
+        self, *args: Any, **kwargs: Any
+    ) -> GenerateContentResponse:
+        """Async method for generate_content."""
+        execution_id = kwargs.pop("execution_id", None)
+        return await self.wrapper.generate_content_async(
+            *args, execution_id=execution_id, **kwargs
+        )
+
+    async def generate_content_stream(
+        self, *args: Any, **kwargs: Any
+    ) -> AsyncIterator[GenerateContentResponse]:
+        """Async method for generate_content_stream."""
+        execution_id = kwargs.pop("execution_id", None)
+        return await self.wrapper.generate_content_stream_async(
+            *args, execution_id=execution_id, **kwargs
+        )
+
+
+class GeminiWrapper(BaseGeminiWrapper):
+    def generate_content(
+        self, *args: Any, execution_id: Optional[str] = None, **kwargs: Any
+    ) -> GenerateContentResponse:
+        """Generate content and log token usage."""
+        logger.debug("Generating content with args: %s, kwargs: %s", args, kwargs)
+
+        response = self.client.models.generate_content(*args, **kwargs)
+        usage_data = self._process_response_usage(response)
+        if usage_data:
+            self._log_usage(usage_data, execution_id=execution_id)
+
+        return response
+
+    def generate_content_stream(
+        self, *args: Any, execution_id: Optional[str] = None, **kwargs: Any
+    ) -> Iterator[GenerateContentResponse]:
+        """Generate content with streaming and log token usage."""
+        logger.debug(
+            "Generating content stream with args: %s, kwargs: %s", args, kwargs
+        )
+
+        base_stream = self.client.models.generate_content_stream(*args, **kwargs)
+        return GeminiSyncStreamInterceptor(
+            base_stream=base_stream,
+            usage_callback=_create_usage_callback(execution_id, self._log_usage),
+        )
+
+    async def generate_content_async(
+        self, *args: Any, execution_id: Optional[str] = None, **kwargs: Any
+    ) -> GenerateContentResponse:
+        """Generate content asynchronously and log token usage."""
+        logger.debug("Generating content async with args: %s, kwargs: %s", args, kwargs)
+
+        response = await self.client.aio.models.generate_content(*args, **kwargs)
+        usage_data = self._process_response_usage(response)
+        if usage_data:
+            self._log_usage(usage_data, execution_id=execution_id)
+
+        return response
+
+    async def generate_content_stream_async(
+        self, *args: Any, execution_id: Optional[str] = None, **kwargs: Any
+    ) -> AsyncIterator[GenerateContentResponse]:
+        """Generate content with async streaming and log token usage."""
+        logger.debug(
+            "Generating content stream async with args: %s, kwargs: %s", args, kwargs
+        )
+
+        base_stream = await self.client.aio.models.generate_content_stream(
+            *args, **kwargs
+        )
+        return GeminiAsyncStreamInterceptor(
+            base_stream=base_stream,
+            usage_callback=_create_usage_callback(execution_id, self._log_usage),
+        )
+
+
+def tokenator_gemini(
+    client: genai.Client,
+    db_path: Optional[str] = None,
+    provider: str = "gemini",
+) -> GeminiWrapper:
+    """Create a token-tracking wrapper for a Gemini client.
+
+    Args:
+        client: Gemini client instance
+        db_path: Optional path to SQLite database for token tracking
+        provider: Provider name, defaults to "gemini"
+    """
+    if not isinstance(client, genai.Client):
+        raise ValueError("Client must be an instance of genai.Client")
+
+    return GeminiWrapper(client=client, db_path=db_path, provider=provider)

tokenator/gemini/stream_interceptors.py

@@ -0,0 +1,77 @@
+"""Stream interceptors for Gemini responses."""
+
+import logging
+from typing import AsyncIterator, Callable, List, Optional, TypeVar, Iterator
+
+
+logger = logging.getLogger(__name__)
+
+_T = TypeVar("_T")  # GenerateContentResponse
+
+
+class GeminiAsyncStreamInterceptor(AsyncIterator[_T]):
+    """
+    A wrapper around Gemini async stream that intercepts each chunk to handle usage or
+    logging logic.
+    """
+
+    def __init__(
+        self,
+        base_stream: AsyncIterator[_T],
+        usage_callback: Optional[Callable[[List[_T]], None]] = None,
+    ):
+        self._base_stream = base_stream
+        self._usage_callback = usage_callback
+        self._chunks: List[_T] = []
+
+    def __aiter__(self) -> AsyncIterator[_T]:
+        """Return self as async iterator."""
+        return self
+
+    async def __anext__(self) -> _T:
+        """Get next chunk and track it."""
+        try:
+            chunk = await self._base_stream.__anext__()
+        except StopAsyncIteration:
+            # Once the base stream is fully consumed, we can do final usage/logging.
+            if self._usage_callback and self._chunks:
+                self._usage_callback(self._chunks)
+            raise
+
+        # Intercept each chunk
+        self._chunks.append(chunk)
+        return chunk
+
+
+class GeminiSyncStreamInterceptor(Iterator[_T]):
+    """
+    A wrapper around Gemini sync stream that intercepts each chunk to handle usage or
+    logging logic.
+    """
+
+    def __init__(
+        self,
+        base_stream: Iterator[_T],
+        usage_callback: Optional[Callable[[List[_T]], None]] = None,
+    ):
+        self._base_stream = base_stream
+        self._usage_callback = usage_callback
+        self._chunks: List[_T] = []
+
+    def __iter__(self) -> Iterator[_T]:
+        """Return self as iterator."""
+        return self
+
+    def __next__(self) -> _T:
+        """Get next chunk and track it."""
+        try:
+            chunk = next(self._base_stream)
+        except StopIteration:
+            # Once the base stream is fully consumed, we can do final usage/logging.
+            if self._usage_callback and self._chunks:
+                self._usage_callback(self._chunks)
+            raise
+
+        # Intercept each chunk
+        self._chunks.append(chunk)
+        return chunk

tokenator/usage.py

@@ -28,7 +28,7 @@ class TokenUsageService:
                 logger.info("Tokenator is disabled. Database access is unavailable.")
             self.MODEL_COSTS = self._get_model_costs()
         except Exception as e:
-            logger.error(f"Error in __init__: {e}")
+            logger.warning(f"Error in __init__: {e}")
             self.MODEL_COSTS = {}
 
     def _get_model_costs(self) -> Dict[str, TokenRate]:
@@ -54,13 +54,14 @@ class TokenUsageService:
                     prompt_audio=info.get("input_cost_per_audio_token"),
                     completion_audio=info.get("output_cost_per_audio_token"),
                     prompt_cached_input=info.get("cache_read_input_token_cost") or 0,
-                    prompt_cached_creation=info.get("cache_read_creation_token_cost") or 0,
+                    prompt_cached_creation=info.get("cache_creation_input_token_cost")
+                    or 0,
                 )
                 model_costs[model] = rate
 
             return model_costs
         except Exception as e:
-            logger.error(f"Error in _get_model_costs: {e}")
+            logger.warning(f"Error in _get_model_costs: {e}")
             return {}
 
     def _calculate_cost(
@@ -96,7 +97,9 @@ class TokenUsageService:
                 elif f"{usage.provider}/{usage.model}" in self.MODEL_COSTS:
                     model_key = f"{usage.provider}/{usage.model}"
                 else:
-                    matched_keys = [k for k in self.MODEL_COSTS.keys() if usage.model in k]
+                    matched_keys = [
+                        k for k in self.MODEL_COSTS.keys() if usage.model in k
+                    ]
                     if matched_keys:
                         model_key = matched_keys[0]
                         logger.warning(
@@ -164,7 +167,9 @@ class TokenUsageService:
                             )
 
                         prompt_cost = prompt_text_tokens * model_rates.prompt
-                        completion_cost = completion_text_tokens * model_rates.completion
+                        completion_cost = (
+                            completion_text_tokens * model_rates.completion
+                        )
                         model_cost += prompt_cost + completion_cost
 
                         # Audio token costs
@@ -355,7 +360,7 @@ class TokenUsageService:
                 },
             )
         except Exception as e:
-            logger.error(f"Error in _calculate_cost: {e}")
+            logger.warning(f"Error in _calculate_cost: {e}")
             return TokenUsageReport()
 
     def _query_usage(
@@ -377,7 +382,7 @@ class TokenUsageService:
                 )
 
                 if provider:
-                    query = query.filter(TokenUsage.provider == provider)
+                    query = query.filter(TokenUsage.provider.ilike(provider))
                 if model:
                     query = query.filter(TokenUsage.model == model)
 
@@ -385,12 +390,12 @@ class TokenUsageService:
 
                 return self._calculate_cost(usages, provider or "all")
             except Exception as e:
-                logger.error(f"Error querying usage: {e}")
+                logger.warning(f"Error querying usage: {e}")
                 return TokenUsageReport()
             finally:
                 session.close()
         except Exception as e:
-            logger.error(f"Unexpected error in _query_usage: {e}")
+            logger.warning(f"Unexpected error in _query_usage: {e}")
             return TokenUsageReport()
 
     def last_hour(
@@ -406,7 +411,7 @@ class TokenUsageService:
             start = end - timedelta(hours=1)
             return self._query_usage(start, end, provider, model)
         except Exception as e:
-            logger.error(f"Error in last_hour: {e}")
+            logger.warning(f"Error in last_hour: {e}")
             return TokenUsageReport()
 
     def last_day(
@@ -422,7 +427,7 @@ class TokenUsageService:
             start = end - timedelta(days=1)
             return self._query_usage(start, end, provider, model)
         except Exception as e:
-            logger.error(f"Error in last_day: {e}")
+            logger.warning(f"Error in last_day: {e}")
             return TokenUsageReport()
 
     def last_week(
@@ -438,7 +443,7 @@ class TokenUsageService:
             start = end - timedelta(weeks=1)
             return self._query_usage(start, end, provider, model)
         except Exception as e:
-            logger.error(f"Error in last_week: {e}")
+            logger.warning(f"Error in last_week: {e}")
             return TokenUsageReport()
 
     def last_month(
@@ -454,7 +459,7 @@ class TokenUsageService:
             start = end - timedelta(days=30)
             return self._query_usage(start, end, provider, model)
         except Exception as e:
-            logger.error(f"Error in last_month: {e}")
+            logger.warning(f"Error in last_month: {e}")
             return TokenUsageReport()
 
     def between(
@@ -499,7 +504,7 @@ class TokenUsageService:
 
             return self._query_usage(start, end, provider, model)
         except Exception as e:
-            logger.error(f"Error in between: {e}")
+            logger.warning(f"Error in between: {e}")
             return TokenUsageReport()
 
     def for_execution(self, execution_id: str) -> TokenUsageReport:
@@ -514,12 +519,12 @@ class TokenUsageService:
                 )
                 return self._calculate_cost(query.all())
             except Exception as e:
-                logger.error(f"Error querying for_execution: {e}")
+                logger.warning(f"Error querying for_execution: {e}")
                 return TokenUsageReport()
             finally:
                 session.close()
         except Exception as e:
-            logger.error(f"Unexpected error in for_execution: {e}")
+            logger.warning(f"Unexpected error in for_execution: {e}")
             return TokenUsageReport()
 
     def last_execution(self) -> TokenUsageReport:
@@ -530,18 +535,20 @@ class TokenUsageService:
             session = get_session()()
             try:
                 query = (
-                    session.query(TokenUsage).order_by(TokenUsage.created_at.desc()).first()
+                    session.query(TokenUsage)
+                    .order_by(TokenUsage.created_at.desc())
+                    .first()
                 )
                 if query:
                     return self.for_execution(query.execution_id)
                 return TokenUsageReport()
             except Exception as e:
-                logger.error(f"Error querying last_execution: {e}")
+                logger.warning(f"Error querying last_execution: {e}")
                 return TokenUsageReport()
             finally:
                 session.close()
         except Exception as e:
-            logger.error(f"Unexpected error in last_execution: {e}")
+            logger.warning(f"Unexpected error in last_execution: {e}")
             return TokenUsageReport()
 
     def all_time(self) -> TokenUsageReport:
@@ -549,22 +556,26 @@ class TokenUsageService:
             if not state.is_tokenator_enabled:
                 return TokenUsageReport()
 
-            logger.warning("Getting cost analysis for all time. This may take a while...")
+            logger.warning(
+                "Getting cost analysis for all time. This may take a while..."
+            )
             session = get_session()()
             try:
                 query = session.query(TokenUsage)
                 return self._calculate_cost(query.all())
             except Exception as e:
-                logger.error(f"Error querying all_time usage: {e}")
+                logger.warning(f"Error querying all_time usage: {e}")
                 return TokenUsageReport()
             finally:
                 session.close()
         except Exception as e:
-            logger.error(f"Unexpected error in all_time: {e}")
+            logger.warning(f"Unexpected error in all_time: {e}")
             return TokenUsageReport()
 
     def wipe(self):
-        logger.warning("All your usage data is about to be wiped, are you sure you want to do this? You have 5 seconds to cancel this operation.")
+        logger.warning(
+            "All your usage data is about to be wiped, are you sure you want to do this? You have 5 seconds to cancel this operation."
+        )
         for i in range(5, 0, -1):
             logger.warning(str(i))
             time.sleep(1)
@@ -574,6 +585,6 @@ class TokenUsageService:
             session.commit()
             logger.warning("All usage data has been deleted.")
         except Exception as e:
-            logger.error(f"Error wiping data: {e}")
+            logger.warning(f"Error wiping data: {e}")
         finally:
             session.close()

tokenator/utils.py

@@ -8,19 +8,22 @@ from pathlib import Path
 
 logger = logging.getLogger(__name__)
 
+
 def is_notebook() -> bool:
     try:
-        from IPython import get_ipython # type: ignore
+        from IPython import get_ipython  # type: ignore
+
         shell = get_ipython().__class__.__name__
-        if shell == 'ZMQInteractiveShell':
-            return True   # Jupyter notebook or qtconsole
-        elif shell == 'TerminalInteractiveShell':
+        if shell == "ZMQInteractiveShell":
+            return True  # Jupyter notebook or qtconsole
+        elif shell == "TerminalInteractiveShell":
             return False  # Terminal running IPython
         else:
             return False  # Other type (?)
     except NameError:
         return False
 
+
 def is_colab() -> bool:
     """Check if running in Google Colab."""
     try:

{tokenator-0.1.16.dist-info → tokenator-0.2.1.dist-info}/METADATA

@@ -1,10 +1,10 @@
 Metadata-Version: 2.3
 Name: tokenator
-Version: 0.1.16
-Summary: Token usage tracking wrapper for LLMs
+Version: 0.2.1
+Summary: Token usage and cost tracking for LLMs
 License: MIT
 Author: Ujjwal Maheshwari
-Author-email: your.email@example.com
+Author-email: ujjwalm29@gmail.com
 Requires-Python: >=3.9,<4.0
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
@@ -15,6 +15,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: alembic (>=1.13.0,<2.0.0)
 Requires-Dist: anthropic (>=0.43.0,<0.44.0)
+Requires-Dist: google-genai (>=1.3.0,<2.0.0)
 Requires-Dist: ipython
 Requires-Dist: openai (>=1.59.0,<2.0.0)
 Requires-Dist: requests (>=2.32.3,<3.0.0)
@@ -33,6 +34,9 @@ Afraid not, tokenator is here! With tokenator's easy to use functions, you can s
 
 Get started with just 3 lines of code!
 
+Tokenator supports the official SDKs from openai, anthropic and google-genai(the new one).
+LLM providers which use the openai SDK like perplexity, deepseek and xAI are also supported.
+
 ## Installation
 
 ```bash
@@ -178,6 +182,54 @@ print(usage.last_execution().model_dump_json(indent=4))
 """
 ```
 
+### Google (Gemini - through AI studio)
+
+```python
+from google import genai
+from tokenator import tokenator_gemini
+
+gemini_client = genai.Client(api_key=os.getenv("GEMINI_API_KEY"))
+
+# Wrap it with Tokenator
+client = tokenator_gemini(gemini_client)
+
+# Use it exactly like the google-genai client
+response = models.generate_content(
+    model="gemini-2.0-flash",
+    contents="hello how are you",
+)
+
+print(response)
+
+print(usage.last_execution().model_dump_json(indent=4))
+"""
+{
+    "total_cost": 0.0001,
+    "total_tokens": 23,
+    "prompt_tokens": 10,
+    "completion_tokens": 13,
+    "providers": [
+        {
+            "total_cost": 0.0001,
+            "total_tokens": 23,
+            "prompt_tokens": 10,
+            "completion_tokens": 13,
+            "provider": "gemini",
+            "models": [
+                {
+                    "total_cost": 0.0004,
+                    "total_tokens": 79,
+                    "prompt_tokens": 52,
+                    "completion_tokens": 27,
+                    "model": "gemini-2.0-flash"
+                }
+            ]
+        }
+    ]
+}
+"""
+```
+
 ### xAI
 
 You can use xAI models through the `openai` SDK and track usage using `provider` parameter in `tokenator`.
@@ -226,7 +278,7 @@ client = tokenator_openai(perplexity_client, db_path=temp_db, provider="perplexi
 
 # Use it exactly like the OpenAI client but with perplexity models
 response = client.chat.completions.create(
-    model="llama-3.1-sonar-small-128k-online",
+    model="sonar",
     messages=[{"role": "user", "content": "Hello!"}]
 )
 

{tokenator-0.1.16.dist-info → tokenator-0.2.1.dist-info}/RECORD

@@ -1,8 +1,11 @@
-tokenator/__init__.py,sha256=AEPE73UGB_TeNLhro3eY0hU8yy6T-_6AyDls8vWApnE,465
+tokenator/__init__.py,sha256=NB2UOm5oDxj4KLabed4PTSGGzkXvEYUSolOo44ei7XQ,559
 tokenator/anthropic/client_anthropic.py,sha256=2oxTLb5-sPK_KL-OumCjE4wPVI8U_eFyRonn9XjGXJw,7196
 tokenator/anthropic/stream_interceptors.py,sha256=4VHC_-WkG3Pa10YizmFLrHcbz0Tm2MR_YB5-uohKp5A,5221
-tokenator/base_wrapper.py,sha256=EQ49xGduEp05-gj1xyZDasrck4RpComaoKslHxQTwuw,4956
+tokenator/base_wrapper.py,sha256=Qhd7efdasNHyatR95uxIzbKKVgouT3OZ72DJ7ZrHcrQ,5015
 tokenator/create_migrations.py,sha256=k9IHiGK21dLTA8MYNsuhO0-kUVIcMSViMFYtY4WU2Rw,730
+tokenator/gemini/__init__.py,sha256=XphFSP33w0j3j7oNn2PSHTwdjnqvAxitQs6qe6URDOY,132
+tokenator/gemini/client_gemini.py,sha256=9dJxOG2HczLzDvqepekrU2hY89oHVMRtOQNrvrgV6sQ,8090
+tokenator/gemini/stream_interceptors.py,sha256=i8DEWAsp1MlZ1xVJZGPzkiCjpX9o6oCJgdkL2k2dung,2266
 tokenator/migrations/env.py,sha256=JoF5MJ4ae0wJW5kdBHuFlG3ZqeCCDvbMcU8fNA_a6hM,1396
 tokenator/migrations/script.py.mako,sha256=nJL-tbLQE0Qy4P9S4r4ntNAcikPtoFUlvXe6xvm9ot8,635
 tokenator/migrations/versions/f028b8155fed_adding_detailed_input_and_output_token_.py,sha256=WIZN5HdNRXlRdfpUJpJFaPD4G1s-SgRdTMQl4WDB-hA,2189
@@ -13,9 +16,9 @@ tokenator/openai/client_openai.py,sha256=pbdJ-aZPuJs-7OT1VEv0DW36cCYbRAVKhSQEprx
 tokenator/openai/stream_interceptors.py,sha256=ez1MnjRZW_rEalv2SIPAvrU9oMD6OJoD9vht-057fDM,5243
 tokenator/schemas.py,sha256=kBmShqgpQ3W-ILAP1NuCaFgqFplQM4OH0MmJteLqrwI,2371
 tokenator/state.py,sha256=xdqDC-rlEA88-VgqQqHnAOXQ5pNTpnHcgOtohDIImPY,262
-tokenator/usage.py,sha256=YnV4fZo0prUC4oPKNZjyN7misn1od6ANwXcLKCuN21Y,24982
-tokenator/utils.py,sha256=djoWmAhqH-O2Su3qIcuY-_3Vj1-qPwMcdzwq9IlwiDc,2435
-tokenator-0.1.16.dist-info/LICENSE,sha256=wdG-B6-ODk8RQ4jq5uXSn0w1UWTzCH_MMyvh7AwtGns,1074
-tokenator-0.1.16.dist-info/METADATA,sha256=B8sy9h8PaDG075-FYjSCz8rMOqoTdy3eOJsUQlxA9Lk,6257
-tokenator-0.1.16.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-tokenator-0.1.16.dist-info/RECORD,,
+tokenator/usage.py,sha256=ZxTRBpmQZysC9x6WWNiQ4aJvCMywF7LnRKGglxLDF_U,25237
+tokenator/utils.py,sha256=sLC3UxnPWxTFoxuQjGROQHT_POcOKJ-32p8-E0B7hwo,2438
+tokenator-0.2.1.dist-info/LICENSE,sha256=wdG-B6-ODk8RQ4jq5uXSn0w1UWTzCH_MMyvh7AwtGns,1074
+tokenator-0.2.1.dist-info/METADATA,sha256=eIRt34a286YLbSMu6iNbWznPIUZw3XxamRTBvOG-QHw,7554
+tokenator-0.2.1.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+tokenator-0.2.1.dist-info/RECORD,,

{tokenator-0.1.16.dist-info → tokenator-0.2.1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.0.1
+Generator: poetry-core 2.1.1
 Root-Is-Purelib: true
 Tag: py3-none-any