paygent-sdk 1.0.0__py3-none-any.whl → 3.0.0__py3-none-any.whl

paygent_sdk/wrappers/mistral_wrapper.py

@@ -0,0 +1,128 @@
+"""
+Mistral wrapper for automatic usage tracking with Paygent.
+This wrapper intercepts Mistral API calls and automatically sends usage data to Paygent.
+"""
+
+import json
+from typing import Any
+
+try:
+    from mistralai import Mistral
+except ImportError:
+    raise ImportError(
+        "mistralai package is a peer-dependency. To use the Paygent wrapper around mistralai "
+        "you're assumed to already have mistralai package installed."
+    )
+
+from ..client import Client
+from ..models import UsageData, UsageDataWithStrings
+
+
+class PaygentMistral:
+    """Main wrapper class for Mistral that provides automatic usage tracking."""
+
+    def __init__(self, mistral_client: Mistral, paygent_client: Client):
+        """
+        Create a new PaygentMistral wrapper.
+        
+        Args:
+            mistral_client: The Mistral client instance
+            paygent_client: The Paygent client instance for usage tracking
+        """
+        self.mistral = mistral_client
+        self.paygent_client = paygent_client
+
+    @property
+    def chat(self) -> 'ChatWrapper':
+        """Access to chat API with automatic usage tracking."""
+        return ChatWrapper(self.mistral, self.paygent_client)
+
+
+class ChatWrapper:
+    """Wrapper for Mistral chat API."""
+
+    def __init__(self, mistral_client: Mistral, paygent_client: Client):
+        self.mistral = mistral_client
+        self.paygent_client = paygent_client
+
+    def complete(
+        self,
+        *,
+        model: str,
+        messages: list,
+        indicator: str,
+        external_agent_id: str,
+        external_customer_id: str,
+        **kwargs
+    ) -> Any:
+        """
+        Create a chat completion with automatic usage tracking.
+        Note: Streaming is not supported with automatic tracking.
+        
+        Args:
+            model: The model to use
+            messages: The messages to send
+            indicator: Indicator for the usage event
+            external_agent_id: External agent identifier
+            external_customer_id: External customer identifier
+            **kwargs: Additional Mistral parameters
+            
+        Returns:
+            The chat completion response from Mistral
+        """
+        # Make the Mistral API call
+        response = self.mistral.chat.complete(
+            model=model,
+            messages=messages,
+            **kwargs
+        )
+
+        # Extract usage data from response with robust fallback mechanism
+        has_valid_usage = (
+            hasattr(response, 'usage') and
+            response.usage and
+            response.usage.prompt_tokens > 0 and
+            response.usage.completion_tokens > 0
+        )
+
+        if has_valid_usage:
+            # Primary path: Use usage data from API response
+            usage_data = UsageData(
+                service_provider=model,
+                model=model,
+                prompt_tokens=response.usage.prompt_tokens,
+                completion_tokens=response.usage.completion_tokens,
+                total_tokens=response.usage.total_tokens
+            )
+
+            self.paygent_client.send_usage(
+                external_agent_id,
+                external_customer_id,
+                indicator,
+                usage_data
+            )
+        else:
+            # Fallback path: Calculate tokens from actual strings
+            prompt_string = json.dumps(messages)
+            output_string = ''
+            if hasattr(response, 'choices') and response.choices:
+                if len(response.choices) > 0:
+                    choice = response.choices[0]
+                    if hasattr(choice, 'message') and hasattr(choice.message, 'content'):
+                        output_string = choice.message.content or ''
+
+            usage_data_with_strings = UsageDataWithStrings(
+                service_provider=model,
+                model=model,
+                prompt_string=prompt_string,
+                output_string=output_string
+            )
+
+            self.paygent_client.send_usage_with_token_string(
+                external_agent_id,
+                external_customer_id,
+                indicator,
+                usage_data_with_strings
+            )
+
+        return response

paygent_sdk/wrappers/openai_wrapper.py

@@ -0,0 +1,316 @@
+"""
+OpenAI wrapper for automatic usage tracking with Paygent.
+This wrapper intercepts OpenAI API calls and automatically sends usage data to Paygent.
+"""
+
+import json
+from typing import Any, Optional
+
+try:
+    from openai import OpenAI
+except ImportError:
+    raise ImportError(
+        "openai package is a peer-dependency. To use the Paygent wrapper around openai "
+        "you're assumed to already have openai package installed."
+    )
+
+from ..client import Client
+from ..models import UsageData, UsageDataWithStrings
+
+
+class PaygentOpenAI:
+    """Main wrapper class for OpenAI that provides automatic usage tracking."""
+
+    def __init__(self, openai_client: OpenAI, paygent_client: Client):
+        """
+        Create a new PaygentOpenAI wrapper.
+        
+        Args:
+            openai_client: The OpenAI client instance
+            paygent_client: The Paygent client instance for usage tracking
+        """
+        self.openai = openai_client
+        self.paygent_client = paygent_client
+
+    @property
+    def chat(self) -> 'ChatWrapper':
+        """Access to chat API with automatic usage tracking."""
+        return ChatWrapper(self.openai, self.paygent_client)
+
+    @property
+    def embeddings(self) -> 'EmbeddingsWrapper':
+        """Access to embeddings API with automatic usage tracking."""
+        return EmbeddingsWrapper(self.openai, self.paygent_client)
+
+    @property
+    def images(self) -> 'ImagesWrapper':
+        """Access to images API with automatic usage tracking."""
+        return ImagesWrapper(self.openai, self.paygent_client)
+
+
+class ChatWrapper:
+    """Wrapper for OpenAI chat API."""
+
+    def __init__(self, openai_client: OpenAI, paygent_client: Client):
+        self.openai = openai_client
+        self.paygent_client = paygent_client
+
+    @property
+    def completions(self) -> 'ChatCompletionsWrapper':
+        """Access to chat completions API with automatic usage tracking."""
+        return ChatCompletionsWrapper(self.openai, self.paygent_client)
+
+
+class ChatCompletionsWrapper:
+    """Wrapper for OpenAI chat completions API."""
+
+    def __init__(self, openai_client: OpenAI, paygent_client: Client):
+        self.openai = openai_client
+        self.paygent_client = paygent_client
+
+    def create(
+        self,
+        *,
+        model: str,
+        messages: list,
+        indicator: str,
+        external_agent_id: str,
+        external_customer_id: str,
+        **kwargs
+    ) -> Any:
+        """
+        Create a chat completion with automatic usage tracking.
+        Note: Streaming is not supported with automatic tracking.
+        
+        Args:
+            model: The model to use
+            messages: The messages to send
+            indicator: Indicator for the usage event
+            external_agent_id: External agent identifier
+            external_customer_id: External customer identifier
+            **kwargs: Additional OpenAI parameters
+            
+        Returns:
+            The chat completion response from OpenAI
+        """
+        # Ensure streaming is disabled for automatic tracking
+        kwargs['stream'] = False
+
+        # Make the OpenAI API call (non-streaming)
+        response = self.openai.chat.completions.create(
+            model=model,
+            messages=messages,
+            **kwargs
+        )
+
+        # Extract usage data from response with robust fallback mechanism
+        has_valid_usage = (
+            hasattr(response, 'usage') and
+            response.usage and
+            response.usage.prompt_tokens > 0 and
+            response.usage.completion_tokens > 0
+        )
+
+        if has_valid_usage:
+            # Primary path: Use usage data from API response
+            # Extract cached tokens if available (OpenAI prompt caching feature)
+            cached_tokens = 0
+            if hasattr(response.usage, 'prompt_tokens_details'):
+                prompt_details = response.usage.prompt_tokens_details
+                if hasattr(prompt_details, 'cached_tokens') and prompt_details.cached_tokens:
+                    cached_tokens = prompt_details.cached_tokens
+            
+            usage_data = UsageData(
+                service_provider=model,
+                model=model,
+                prompt_tokens=response.usage.prompt_tokens,
+                completion_tokens=response.usage.completion_tokens,
+                total_tokens=response.usage.total_tokens,
+                cached_tokens=cached_tokens
+            )
+
+            self.paygent_client.send_usage(
+                external_agent_id,
+                external_customer_id,
+                indicator,
+                usage_data
+            )
+        else:
+            # Fallback path: Calculate tokens from actual strings
+            # This ensures we never lose billing data even if API response format changes
+            prompt_string = json.dumps(messages)
+            output_string = ''
+            if hasattr(response, 'choices') and response.choices:
+                if hasattr(response.choices[0], 'message') and hasattr(response.choices[0].message, 'content'):
+                    output_string = response.choices[0].message.content or ''
+
+            usage_data_with_strings = UsageDataWithStrings(
+                service_provider=model,
+                model=model,
+                prompt_string=prompt_string,
+                output_string=output_string
+            )
+
+            self.paygent_client.send_usage_with_token_string(
+                external_agent_id,
+                external_customer_id,
+                indicator,
+                usage_data_with_strings
+            )
+
+        return response
+
+
+class EmbeddingsWrapper:
+    """Wrapper for OpenAI embeddings API."""
+
+    def __init__(self, openai_client: OpenAI, paygent_client: Client):
+        self.openai = openai_client
+        self.paygent_client = paygent_client
+
+    def create(
+        self,
+        *,
+        model: str,
+        input: Any,
+        indicator: str,
+        external_agent_id: str,
+        external_customer_id: str,
+        **kwargs
+    ) -> Any:
+        """
+        Create embeddings with automatic usage tracking.
+        
+        Args:
+            model: The model to use
+            input: The input text(s) to embed
+            indicator: Indicator for the usage event
+            external_agent_id: External agent identifier
+            external_customer_id: External customer identifier
+            **kwargs: Additional OpenAI parameters
+            
+        Returns:
+            The embeddings response from OpenAI
+        """
+        # Make the OpenAI API call
+        response = self.openai.embeddings.create(
+            model=model,
+            input=input,
+            **kwargs
+        )
+
+        # Extract usage data from response with robust fallback mechanism
+        has_valid_usage = (
+            hasattr(response, 'usage') and
+            response.usage and
+            response.usage.prompt_tokens > 0
+        )
+
+        if has_valid_usage:
+            # Primary path: Use usage data from API response
+            usage_data = UsageData(
+                service_provider=model,
+                model=model,
+                prompt_tokens=response.usage.prompt_tokens,
+                completion_tokens=response.usage.prompt_tokens,  # Embeddings don't have completion tokens
+                total_tokens=response.usage.total_tokens
+            )
+
+            self.paygent_client.send_usage(
+                external_agent_id,
+                external_customer_id,
+                indicator,
+                usage_data
+            )
+        else:
+            # Fallback path: Calculate tokens from input text
+            input_text = input
+            if isinstance(input, list):
+                input_text = ' '.join(str(i) for i in input)
+            else:
+                input_text = str(input)
+
+            usage_data_with_strings = UsageDataWithStrings(
+                service_provider=model,
+                model=model,
+                prompt_string=input_text,
+                output_string=''  # Embeddings don't have output
+            )
+
+            self.paygent_client.send_usage_with_token_string(
+                external_agent_id,
+                external_customer_id,
+                indicator,
+                usage_data_with_strings
+            )
+
+        return response
+
+
+class ImagesWrapper:
+    """Wrapper for OpenAI images API."""
+
+    def __init__(self, openai_client: OpenAI, paygent_client: Client):
+        self.openai = openai_client
+        self.paygent_client = paygent_client
+
+    def generate(
+        self,
+        *,
+        model: Optional[str] = None,
+        prompt: str,
+        indicator: str,
+        external_agent_id: str,
+        external_customer_id: str,
+        **kwargs
+    ) -> Any:
+        """
+        Generate images with automatic usage tracking.
+        Note: OpenAI's image generation API doesn't return token usage,
+        so we track the request parameters instead.
+        
+        Args:
+            model: The model to use (optional, defaults to dall-e-2)
+            prompt: The prompt for image generation
+            indicator: Indicator for the usage event
+            external_agent_id: External agent identifier
+            external_customer_id: External customer identifier
+            **kwargs: Additional OpenAI parameters
+            
+        Returns:
+            The images response from OpenAI
+        """
+        # Make the OpenAI API call
+        if model:
+            response = self.openai.images.generate(
+                model=model,
+                prompt=prompt,
+                **kwargs
+            )
+        else:
+            response = self.openai.images.generate(
+                prompt=prompt,
+                **kwargs
+            )
+            model = 'dall-e-2'  # Default model
+
+        # For image generation, we'll use a simplified usage tracking
+        # since OpenAI doesn't provide token counts for images
+        usage_data = UsageData(
+            service_provider=model,
+            model=model,
+            prompt_tokens=0,  # Images don't use traditional tokens
+            completion_tokens=0,
+            total_tokens=0
+        )
+
+        # Send usage data to Paygent
+        # Note: Cost calculation for images should be handled by the pricing module
+        self.paygent_client.send_usage(
+            external_agent_id,
+            external_customer_id,
+            indicator,
+            usage_data
+        )
+
+        return response

{paygent_sdk-1.0.0.dist-info → paygent_sdk-3.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: paygent-sdk
-Version: 1.0.0
+Version: 3.0.0
 Summary: Official Python SDK for Paygent - Track AI usage and costs across multiple providers (OpenAI, Anthropic, Google, DeepSeek, etc.)
 Home-page: https://github.com/paygent/paygent-sdk-python
 Author: Paygent

paygent_sdk-3.0.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+examples/__init__.py,sha256=rkdmhcIN-xvRIaDWOWpUGQcdWZLopvjiK-4A2n40wQI,19
+examples/advanced_usage.py,sha256=a8GlGg2mlbi0KccOJMXZihfJKJsZvOcjAa0vutoCTHQ,3619
+examples/basic_usage.py,sha256=FvFR7t5Xs1eeV1-C6aAVQx2mhY8S8nJGGaJQd_Es0vg,1039
+examples/constants_usage.py,sha256=fdmgbdAnVDlvdxuWIfpGX49NxuMGK3dwQ780D10ltmQ,4490
+paygent_sdk/__init__.py,sha256=5dt2ogSTbPyM_JZ8lvafO9Fn0WsCnJgC1bCLtafzVEk,3064
+paygent_sdk/client.py,sha256=PeusEcT8j8-bVWuCV_aJIdieNW1lQVTCT7jaxxIDVSw,16427
+paygent_sdk/constants.py,sha256=ohvaHRfDcJ00DwBitHrYWH96k6FodO_uMvRYnOBZdJ8,10208
+paygent_sdk/models.py,sha256=qlTSdogopr0TIdolkDHqn6MsNEJznPl4ie146fUbSRI,22666
+paygent_sdk/voice_client.py,sha256=nGx2w2h7hW9cxi1oIDJNQMdLXdJPmHYlk3K8rNkwYTY,12680
+paygent_sdk/wrappers/__init__.py,sha256=IPDrQZH9GmUlBCJp5UZfSgX8SJyh2Y09z2N811vcaKk,1542
+paygent_sdk/wrappers/anthropic_wrapper.py,sha256=qw26SFCc0Nfsb7O9kqld9cV6D0DCFQjjVgfDHmUYEd8,4370
+paygent_sdk/wrappers/gemini_wrapper.py,sha256=F6ZEfGwAXGyMisvPEh2M_5zTSFm2FiQvZKWRGS0y1Tg,11391
+paygent_sdk/wrappers/langchain_wrapper.py,sha256=7GZs_7SjH6CRipc8EmqeZez2EPCie-IH9OyPSaBk7DQ,9674
+paygent_sdk/wrappers/mistral_wrapper.py,sha256=TiXB5nGmk3O4PqfTqCa6aDX5ow0X07ol41N4bC-7kbE,4174
+paygent_sdk/wrappers/openai_wrapper.py,sha256=eGwbiLcv3EFJQgGnU98JU-jfMxGxo7ziVZP4SPyfRp4,10439
+paygent_sdk-3.0.0.dist-info/licenses/LICENSE,sha256=HXncQw9T-dF8ItNiDu_T-Mv_A3Fl73Is7a8K8ZDXgZI,1064
+tests/__init__.py,sha256=Wk73Io62J15BtlLVIzxmASDWaaJkQLevS4BLK5LDAQg,16
+tests/test_client.py,sha256=63es9cOeWyclR9yM0SLcV8rSfOtlqr6YRjWG4sCTbMg,10500
+paygent_sdk-3.0.0.dist-info/METADATA,sha256=e_rkY8hz9WIUDT1_XeDvPgm40qNyy-UPvrrM4_W4_UI,12493
+paygent_sdk-3.0.0.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+paygent_sdk-3.0.0.dist-info/top_level.txt,sha256=tWbxCRKTt8EeYPhYm8mE6QukqT6EVfai6RMaT9GnVkk,27
+paygent_sdk-3.0.0.dist-info/RECORD,,

{paygent_sdk-1.0.0.dist-info → paygent_sdk-3.0.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

paygent_sdk-1.0.0.dist-info/RECORD

@@ -1,15 +0,0 @@
-examples/__init__.py,sha256=rkdmhcIN-xvRIaDWOWpUGQcdWZLopvjiK-4A2n40wQI,19
-examples/advanced_usage.py,sha256=a8GlGg2mlbi0KccOJMXZihfJKJsZvOcjAa0vutoCTHQ,3619
-examples/basic_usage.py,sha256=FvFR7t5Xs1eeV1-C6aAVQx2mhY8S8nJGGaJQd_Es0vg,1039
-examples/constants_usage.py,sha256=fdmgbdAnVDlvdxuWIfpGX49NxuMGK3dwQ780D10ltmQ,4490
-paygent_sdk/__init__.py,sha256=HUhtOr2BAyY16isDoVuNjUIv8Q-9dkmUT4hN-udWX2U,991
-paygent_sdk/client.py,sha256=ypaKKrKNvDb-OW9bh5ex2C1YEiZ0_QYcGQKszd0tpSo,15819
-paygent_sdk/constants.py,sha256=kTfLex00p8z8w7jBTfwMCYTks1BGYlmcWWGbPkXILc4,6355
-paygent_sdk/models.py,sha256=RMa0SKj1U8mFXNFpD9d7EVWB4PXx9qj4KLZe-qlMAtw,20237
-paygent_sdk-1.0.0.dist-info/licenses/LICENSE,sha256=HXncQw9T-dF8ItNiDu_T-Mv_A3Fl73Is7a8K8ZDXgZI,1064
-tests/__init__.py,sha256=Wk73Io62J15BtlLVIzxmASDWaaJkQLevS4BLK5LDAQg,16
-tests/test_client.py,sha256=63es9cOeWyclR9yM0SLcV8rSfOtlqr6YRjWG4sCTbMg,10500
-paygent_sdk-1.0.0.dist-info/METADATA,sha256=C3a9o9DoKGHXz0tojaTwjphQtGK2UqDSoq2wEC8yu8g,12493
-paygent_sdk-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-paygent_sdk-1.0.0.dist-info/top_level.txt,sha256=tWbxCRKTt8EeYPhYm8mE6QukqT6EVfai6RMaT9GnVkk,27
-paygent_sdk-1.0.0.dist-info/RECORD,,