payi 0.1.0a96__py3-none-any.whl → 0.1.0a98__py3-none-any.whl

payi/_models.py

@@ -2,9 +2,10 @@ from __future__ import annotations
 
 import os
 import inspect
-from typing import TYPE_CHECKING, Any, Type, Union, Generic, TypeVar, Callable, cast
+from typing import TYPE_CHECKING, Any, Type, Union, Generic, TypeVar, Callable, Optional, cast
 from datetime import date, datetime
 from typing_extensions import (
+    List,
     Unpack,
     Literal,
     ClassVar,
@@ -366,7 +367,7 @@ def _construct_field(value: object, field: FieldInfo, key: str) -> object:
     if type_ is None:
         raise RuntimeError(f"Unexpected field type is None for {key}")
 
-    return construct_type(value=value, type_=type_)
+    return construct_type(value=value, type_=type_, metadata=getattr(field, "metadata", None))
 
 
 def is_basemodel(type_: type) -> bool:
@@ -420,7 +421,7 @@ def construct_type_unchecked(*, value: object, type_: type[_T]) -> _T:
     return cast(_T, construct_type(value=value, type_=type_))
 
 
-def construct_type(*, value: object, type_: object) -> object:
+def construct_type(*, value: object, type_: object, metadata: Optional[List[Any]] = None) -> object:
     """Loose coercion to the expected type with construction of nested values.
 
     If the given value does not match the expected type then it is returned as-is.
@@ -438,8 +439,10 @@ def construct_type(*, value: object, type_: object) -> object:
         type_ = type_.__value__  # type: ignore[unreachable]
 
     # unwrap `Annotated[T, ...]` -> `T`
-    if is_annotated_type(type_):
-        meta: tuple[Any, ...] = get_args(type_)[1:]
+    if metadata is not None:
+        meta: tuple[Any, ...] = tuple(metadata)
+    elif is_annotated_type(type_):
+        meta = get_args(type_)[1:]
         type_ = extract_type_arg(type_, 0)
     else:
         meta = tuple()

payi/_version.py

@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "payi"
-__version__ = "0.1.0-alpha.96"  # x-release-please-version
+__version__ = "0.1.0-alpha.98"  # x-release-please-version

payi/lib/AnthropicInstrumentor.py

@@ -9,9 +9,13 @@ from payi.lib.helpers import PayiCategories
 from payi.types.ingest_units_params import Units
 
 from .instrument import _ChunkResult, _IsStreaming, _StreamingType, _ProviderRequest, _PayiInstrumentor
+from .version_helper import get_version_helper
 
 
 class AnthropicInstrumentor:
+    _module_name: str = "anthropic"
+    _module_version: str = ""
+
     @staticmethod
     def is_vertex(instance: Any) -> bool:
         from anthropic import AnthropicVertex, AsyncAnthropicVertex  # type: ignore # noqa: I001
@@ -27,7 +31,7 @@ class AnthropicInstrumentor:
     @staticmethod
     def instrument(instrumentor: _PayiInstrumentor) -> None:
         try:
-            import anthropic  # type: ignore #  noqa: F401  I001
+            AnthropicInstrumentor._module_version = get_version_helper(AnthropicInstrumentor._module_name)
 
             wrap_function_wrapper(
                 "anthropic.resources.messages",
@@ -149,6 +153,8 @@ class _AnthropicProviderRequest(_ProviderRequest):
             instrumentor=instrumentor,
             category=category,
             streaming_type=streaming_type,
+            module_name=AnthropicInstrumentor._module_name,
+            module_version=AnthropicInstrumentor._module_version,
             )
 
     @override

payi/lib/BedrockInstrumentor.py

@@ -11,15 +11,21 @@ from payi.types.ingest_units_params import Units
 from payi.types.pay_i_common_models_api_router_header_info_param import PayICommonModelsAPIRouterHeaderInfoParam
 
 from .instrument import _ChunkResult, _IsStreaming, _StreamingType, _ProviderRequest, _PayiInstrumentor
+from .version_helper import get_version_helper
 
 
 class BedrockInstrumentor:
+    _module_name: str = "boto3"
+    _module_version: str = ""
+
     _instrumentor: _PayiInstrumentor
 
     @staticmethod
     def instrument(instrumentor: _PayiInstrumentor) -> None:
         BedrockInstrumentor._instrumentor = instrumentor
 
+        BedrockInstrumentor._module_version = get_version_helper(BedrockInstrumentor._module_name)
+
         try:
             wrap_function_wrapper(
                 "botocore.client",
@@ -234,6 +240,8 @@ class _BedrockProviderRequest(_ProviderRequest):
             instrumentor=instrumentor,
             category=PayiCategories.aws_bedrock,
             streaming_type=_StreamingType.iterator,
+            module_name=BedrockInstrumentor._module_name,
+            module_version=BedrockInstrumentor._module_version,
             is_aws_client=True,
             )
 

payi/lib/GoogleGenAiInstrumentor.py

@@ -5,12 +5,18 @@ from wrapt import wrap_function_wrapper  # type: ignore
 
 from .instrument import _ChunkResult, _IsStreaming, _PayiInstrumentor
 from .VertexRequest import _VertexRequest
+from .version_helper import get_version_helper
 
 
 class GoogleGenAiInstrumentor:
+    _module_name: str = "google-genai"
+    _module_version: str = ""
+
     @staticmethod
     def instrument(instrumentor: _PayiInstrumentor) -> None:
         try:
+            GoogleGenAiInstrumentor._module_version = get_version_helper(GoogleGenAiInstrumentor._module_name)
+
             wrap_function_wrapper(
                 "google.genai.models",
                 "Models.generate_content",
@@ -115,6 +121,8 @@ class _GoogleGenAiRequest(_VertexRequest):
     def __init__(self, instrumentor: _PayiInstrumentor):
         super().__init__(
             instrumentor=instrumentor,
+            module_name=GoogleGenAiInstrumentor._module_name,
+            module_version=GoogleGenAiInstrumentor._module_version,
             )
         self._prompt_character_count = 0
         self._candidates_character_count = 0

payi/lib/OpenAIInstrumentor.py

@@ -10,9 +10,13 @@ from payi.lib.helpers import PayiCategories, PayiHeaderNames
 from payi.types.ingest_units_params import Units
 
 from .instrument import _ChunkResult, _IsStreaming, _StreamingType, _ProviderRequest, _PayiInstrumentor
+from .version_helper import get_version_helper
 
 
 class OpenAiInstrumentor:
+    _module_name: str = "openai"
+    _module_version: str = ""
+
     @staticmethod
     def is_azure(instance: Any) -> bool:
         from openai import AzureOpenAI, AsyncAzureOpenAI # type: ignore # noqa: I001
@@ -22,6 +26,8 @@ class OpenAiInstrumentor:
     @staticmethod
     def instrument(instrumentor: _PayiInstrumentor) -> None:
         try:
+            OpenAiInstrumentor._module_version = get_version_helper(OpenAiInstrumentor._module_name)
+
             wrap_function_wrapper(
                 "openai.resources.chat.completions",
                 "Completions.create",
@@ -187,6 +193,8 @@ class _OpenAiProviderRequest(_ProviderRequest):
             instrumentor=instrumentor,
             category=PayiCategories.openai,
             streaming_type=_StreamingType.iterator,
+            module_name=OpenAiInstrumentor._module_name,
+            module_version=OpenAiInstrumentor._module_version,
             )
         self._input_tokens_key = input_tokens_key
         self._output_tokens_key = output_tokens_key

payi/lib/VertexInstrumentor.py

@@ -5,12 +5,18 @@ from wrapt import wrap_function_wrapper  # type: ignore
 
 from .instrument import _ChunkResult, _IsStreaming, _PayiInstrumentor
 from .VertexRequest import _VertexRequest
+from .version_helper import get_version_helper
 
 
 class VertexInstrumentor:
+    _module_name: str = "google-cloud-aiplatform"
+    _module_version: str = ""
+
     @staticmethod
     def instrument(instrumentor: _PayiInstrumentor) -> None:
         try:
+            VertexInstrumentor._module_version = get_version_helper(VertexInstrumentor._module_name)
+
             wrap_function_wrapper(
                 "vertexai.generative_models",
                 "GenerativeModel.generate_content",
@@ -85,6 +91,8 @@ class _GoogleVertexRequest(_VertexRequest):
     def __init__(self, instrumentor: _PayiInstrumentor):
         super().__init__(
             instrumentor=instrumentor,
+            module_name=VertexInstrumentor._module_name,
+            module_version=VertexInstrumentor._module_version,
             )
         self._prompt_character_count = 0
         self._candidates_character_count = 0

payi/lib/VertexRequest.py

@@ -10,11 +10,20 @@ from .instrument import _ChunkResult, _StreamingType, _ProviderRequest, _PayiIns
 
 
 class _VertexRequest(_ProviderRequest): # type: ignore
-    def __init__(self, instrumentor: _PayiInstrumentor):
+    KNOWN_MODALITIES = ("VIDEO", "AUDIO", "TEXT", "VISION", "IMAGE")
+
+    def __init__(
+            self,
+            instrumentor: _PayiInstrumentor,
+            module_name: str,
+            module_version: str
+            ) -> None:
         super().__init__(
             instrumentor=instrumentor,
             category=PayiCategories.google_vertex,
             streaming_type=_StreamingType.generator,
+            module_name=module_name,
+            module_version=module_version,
             is_google_vertex_or_genai_client=True,
             )
         self._prompt_character_count = 0
@@ -154,6 +163,7 @@ class _VertexRequest(_ProviderRequest): # type: ignore
 
         prompt_tokens_details: list[dict[str, Any]] = usage.get("prompt_tokens_details", [])
         candidates_tokens_details: list[dict[str, Any]] = usage.get("candidates_tokens_details", [])
+        cache_tokens_details: list[dict[str, Any]] = usage.get("cache_tokens_details", [])
 
         if not model:
             model = ""
@@ -214,27 +224,50 @@ class _VertexRequest(_ProviderRequest): # type: ignore
             if is_large_context_token_model(model, input):
                 large_context = "_large_context"
 
+            cache_details: dict[str, int] = {}
+
+            for details in cache_tokens_details:
+                modality = details.get("modality", "")
+                if not modality:
+                    continue
+
+                modality_token_count = details.get("token_count", 0)
+                
+                if modality == "IMAGE":
+                    modality = "VISION"
+
+                if modality in _VertexRequest.KNOWN_MODALITIES:
+                    cache_details[modality] = modality_token_count
+                    add_units(self, modality.lower() + "_cache_read" + large_context, input=modality_token_count)
+
             for details in prompt_tokens_details:
                 modality = details.get("modality", "")
                 if not modality:
                     continue
 
                 modality_token_count = details.get("token_count", 0)
+
                 if modality == "IMAGE":
-                    add_units(self, "vision"+large_context, input=modality_token_count)
-                elif modality in ("VIDEO", "AUDIO", "TEXT"):
-                    add_units(self, modality.lower()+large_context, input=modality_token_count)
+                    modality = "VISION"
+
+                if modality in _VertexRequest.KNOWN_MODALITIES:
+                    # Subtract cache_details value if modality is present, floor at zero
+                    if modality in cache_details:
+                        modality_token_count = max(0, modality_token_count - cache_details[modality])
+
+                    add_units(self, modality.lower() + large_context, input=modality_token_count)
+
             for details in candidates_tokens_details:
                 modality = details.get("modality", "")
                 if not modality:
                     continue
 
                 modality_token_count = details.get("token_count", 0)
-                if modality in ("VIDEO", "AUDIO", "TEXT", "IMAGE"):
-                    add_units(self, modality.lower()+large_context, output=modality_token_count)
+                if modality in _VertexRequest.KNOWN_MODALITIES:
+                    add_units(self, modality.lower() + large_context, output=modality_token_count)
 
             if thinking_token_count > 0:
-                add_units(self, "reasoning"+large_context, output=thinking_token_count)
+                add_units(self, "reasoning" + large_context, output=thinking_token_count)
 
         if not self._ingest["units"]:
             input = usage.get("prompt_token_count", 0)

payi/lib/instrument.py

@@ -15,11 +15,13 @@ from dataclasses import dataclass
 import nest_asyncio  # type: ignore
 from wrapt import ObjectProxy  # type: ignore
 
-from payi import Payi, AsyncPayi, APIConnectionError, __version__ as _payi_version
+from payi import Payi, AsyncPayi, APIStatusError, APIConnectionError, __version__ as _payi_version
 from payi.types import IngestUnitsParams
 from payi.lib.helpers import PayiHeaderNames
+from payi.types.shared import XproxyResult
 from payi.types.ingest_response import IngestResponse
 from payi.types.ingest_units_params import Units, ProviderResponseFunctionCall
+from payi.types.shared.xproxy_error import XproxyError
 from payi.types.pay_i_common_models_api_router_header_info_param import PayICommonModelsAPIRouterHeaderInfoParam
 
 from .helpers import PayiCategories
@@ -35,13 +37,18 @@ class _ChunkResult:
     
 class _ProviderRequest:
     def __init__(
-            self, instrumentor: '_PayiInstrumentor',
+            self, 
+            instrumentor: '_PayiInstrumentor',
             category: str,
             streaming_type: '_StreamingType',
+            module_name: str,
+            module_version: str,
             is_aws_client: Optional[bool] = None,
             is_google_vertex_or_genai_client: Optional[bool] = None,
             ) -> None:
         self._instrumentor: '_PayiInstrumentor' = instrumentor
+        self._module_name: str = module_name
+        self._module_version: str = module_version  
         self._estimated_prompt_tokens: Optional[int] = None
         self._category: str = category
         self._ingest: IngestUnitsParams = { "category": category, "units": {} } # type: ignore
@@ -146,6 +153,19 @@ class PayiInstrumentConfig(TypedDict, total=False):
     user_id: Optional[str]
     request_tags: Optional["list[str]"]
 
+class PayiContext(TypedDict, total=False):
+    use_case_name: Optional[str]
+    use_case_id: Optional[str]
+    use_case_version: Optional[int]
+    use_case_step: Optional[str]
+    limit_ids: Optional['list[str]']
+    user_id: Optional[str]
+    request_tags: Optional["list[str]"]
+    price_as_category: Optional[str]
+    price_as_resource: Optional[str]
+    resource_scope: Optional[str]
+    last_result: Optional[Union[XproxyResult, XproxyError]]
+
 class _Context(TypedDict, total=False):
     proxy: Optional[bool]
     use_case_name: Optional[str]
@@ -169,7 +189,7 @@ class _StreamingType(Enum):
     iterator = 1
     stream_manager = 2
 
-class _TrackContext:
+class _InternalTrackContext:
     def __init__(
         self,
         context: _Context,
@@ -190,6 +210,7 @@ class _TrackContext:
 
 class _PayiInstrumentor:
     _not_instrumented: str = "<not_instrumented>"
+    _instrumented_module_header_name: str = "xProxy-Instrumented-Module"
 
     def __init__(
         self,
@@ -235,6 +256,8 @@ class _PayiInstrumentor:
 
         self._instrument_inline_data: bool = global_config.get("instrument_inline_data", False)
 
+        self._last_result: Optional[Union[XproxyResult, XproxyError]] = None
+
         global_instrumentation = global_config.pop("global_instrumentation", True)
 
         if instruments is None or "*" in instruments:
@@ -354,9 +377,15 @@ class _PayiInstrumentor:
 
         return log_ingest_units
         
-    def _process_ingest_units(self, request: _ProviderRequest, log_data: 'dict[str, str]') -> bool:
+    def _process_ingest_units(
+            self,
+            request: _ProviderRequest, log_data: 'dict[str, str]',
+            extra_headers: 'dict[str, str]') -> None:
         ingest_units = request._ingest
 
+        if request._module_version:
+            extra_headers[_PayiInstrumentor._instrumented_module_header_name] = f'{request._module_name}/{request._module_version}'
+
         if request._function_call_builder:
             # convert the function call builder to a list of function calls
             ingest_units["provider_response_function_calls"] = list(request._function_call_builder.values())
@@ -394,8 +423,6 @@ class _PayiInstrumentor:
             if stack_trace is not None:
                 log_data["stack_trace"] = stack_trace
 
-        return True
-
     def _process_ingest_units_response(self, ingest_response: IngestResponse) -> None:
         if ingest_response.xproxy_result.limits:
             for limit_id, state in ingest_response.xproxy_result.limits.items():
@@ -413,7 +440,7 @@ class _PayiInstrumentor:
                 if removeBlockedId:
                     self._blocked_limits.discard(limit_id)
 
-    def _process_ingest_connection_error(self, e: APIConnectionError, ingest_units: IngestUnitsParams) -> None:
+    def _process_ingest_connection_error(self, e: APIConnectionError, ingest_units: IngestUnitsParams) -> XproxyError:
         now = time.time()
 
         if (now - self._api_connection_error_last_log_time) > self._api_connection_error_window:
@@ -430,7 +457,9 @@ class _PayiInstrumentor:
             # Suppress and count
             self._api_connection_error_count += 1
 
-    async def _aingest_units(self, request: _ProviderRequest) -> Optional[IngestResponse]:
+        return XproxyError(code="api_connection_error", message=str(e))
+
+    async def _aingest_units_worker(self, request: _ProviderRequest) -> Optional[Union[XproxyResult, XproxyError]]:
         ingest_response: Optional[IngestResponse] = None
         ingest_units = request._ingest
 
@@ -438,21 +467,21 @@ class _PayiInstrumentor:
 
         # return early if there are no units to ingest and on a successul ingest request
         log_data: 'dict[str,str]' = {}
-        if not self._process_ingest_units(request, log_data):
-            self._logger.debug(f"_aingest_units: exit early")
-            return None
+        extra_headers: 'dict[str, str]' = {}
+
+        self._process_ingest_units(request, log_data=log_data, extra_headers=extra_headers)
 
         try:
             if self._logger.isEnabledFor(logging.DEBUG):
                 self._logger.debug(f"_aingest_units: sending ({self._create_logged_ingest_units(ingest_units)})")
 
             if self._apayi:    
-                ingest_response = await self._apayi.ingest.units(**ingest_units)
+                ingest_response = await self._apayi.ingest.units(**ingest_units, extra_headers=extra_headers)
             elif self._payi:
-                ingest_response = self._payi.ingest.units(**ingest_units)
+                ingest_response = self._payi.ingest.units(**ingest_units, extra_headers=extra_headers)
             else:
                 self._logger.error("No payi instance to ingest units")
-                return None         
+                return XproxyError(code="configuration_error", message="No Payi or AsyncPayi instance configured for ingesting units")
 
             self._logger.debug(f"_aingest_units: success ({ingest_response})")
 
@@ -463,15 +492,21 @@ class _PayiInstrumentor:
                     request_id = ingest_response.xproxy_result.request_id
                     self._prompt_and_response_logger(request_id, log_data)  # type: ignore
 
-            return ingest_response
-        except Exception as e:
-            if isinstance(e, APIConnectionError) and self._api_connection_error_window > 0:
-                self._process_ingest_connection_error(e, ingest_units)
-            else:
-                self._logger.error(f"Error Pay-i async ingesting: exception {e}, request {ingest_units}")
-    
-        return None         
+            return ingest_response.xproxy_result
+
+        except APIConnectionError as api_ex:
+            return self._process_ingest_connection_error(api_ex, ingest_units)
+
+        except APIStatusError as api_status_ex:
+            return self._process_api_status_error(api_status_ex)      
+
+        except Exception as ex:
+            self._logger.error(f"Error Pay-i async ingesting: exception {ex}, request {ingest_units}")
+            return XproxyError(code="unknown_error", message=str(ex))
     
+    async def _aingest_units(self, request: _ProviderRequest) -> Optional[Union[XproxyResult, XproxyError]]:
+        return self.set_xproxy_result(await self._aingest_units_worker(request))
+
     def _call_async_use_case_definition_create(self, use_case_name: str, use_case_description: str) -> None:
         if not self._apayi:
             return
@@ -491,7 +526,7 @@ class _PayiInstrumentor:
         except Exception as e:
             self._logger.error(f"Error calling async use_cases.definitions.create synchronously: {e}")
 
-    def _call_aingest_sync(self, request: _ProviderRequest) -> Optional[IngestResponse]:
+    def _call_aingest_sync(self, request: _ProviderRequest) -> Optional[Union[XproxyResult, XproxyError]]:
         try:
             loop = asyncio.get_running_loop()
         except RuntimeError:
@@ -500,7 +535,7 @@ class _PayiInstrumentor:
         try:
             if loop and loop.is_running():
                 nest_asyncio.apply(loop) # type: ignore
-                return asyncio.run(self._aingest_units(request))                
+                return asyncio.run(self._aingest_units(request))
             else:
                 # When there's no running loop, create a new one
                 return asyncio.run(self._aingest_units(request))
@@ -508,7 +543,41 @@ class _PayiInstrumentor:
             self._logger.error(f"Error calling aingest_units synchronously: {e}")
         return None
         
-    def _ingest_units(self, request: _ProviderRequest) -> Optional[IngestResponse]:
+    def _process_api_status_error(self, e: APIStatusError) -> Optional[XproxyError]:
+        try:
+            body_dict: dict[str, Any] = {}
+
+            # Try to get the response body as JSON
+            body = e.body
+            if body is None:
+                self._logger.error("APIStatusError response has no body attribute")
+                return XproxyError(code="unknown_error", message=str(e))
+
+            # If body is bytes, decode to string
+            if isinstance(body, bytes):
+                body = body.decode("utf-8")
+            if isinstance(body, dict):
+                body_dict = body # type: ignore
+            else:
+                body = str(body)
+
+            if not body_dict:
+                try:
+                    body_dict = json.loads(body)  # type: ignore
+                except Exception as json_ex:
+                    self._logger.error(f"Failed to parse response body as JSON: {json_ex}")
+                    return XproxyError(code="invalid_json", message=str(e))
+
+            xproxy_error = body_dict.get("xproxy_error", {})
+            code = xproxy_error.get("code", "unknown_error")
+            message = xproxy_error.get("message", str(e))
+            return XproxyError(code=code, message=message)
+
+        except Exception as ex:
+            self._logger.error(f"Exception in _process_api_status_error: {ex}")
+            return XproxyError(code="exception", message=str(ex))
+
+    def _ingest_units_worker(self, request: _ProviderRequest) -> Optional[Union[XproxyResult, XproxyError]]:
         ingest_response: Optional[IngestResponse] = None
         ingest_units = request._ingest
 
@@ -516,16 +585,15 @@ class _PayiInstrumentor:
 
         # return early if there are no units to ingest and on a successul ingest request
         log_data: 'dict[str,str]' = {}
-        if not self._process_ingest_units(request, log_data):
-            self._logger.debug(f"_ingest_units: exit early")
-            return None
+        extra_headers: 'dict[str, str]' = {}
+        self._process_ingest_units(request, log_data=log_data, extra_headers=extra_headers)
 
         try:
             if self._payi:
                 if self._logger.isEnabledFor(logging.DEBUG):
                     self._logger.debug(f"_ingest_units: sending ({self._create_logged_ingest_units(ingest_units)})")
 
-                ingest_response = self._payi.ingest.units(**ingest_units)
+                ingest_response = self._payi.ingest.units(**ingest_units, extra_headers=extra_headers)
                 self._logger.debug(f"_ingest_units: success ({ingest_response})")
 
                 self._process_ingest_units_response(ingest_response)
@@ -534,22 +602,28 @@ class _PayiInstrumentor:
                     request_id = ingest_response.xproxy_result.request_id
                     self._prompt_and_response_logger(request_id, log_data)  # type: ignore
 
-                return ingest_response
+                return ingest_response.xproxy_result
             elif self._apayi:
                 # task runs async. aingest_units will invoke the callback and post process
-                ingest_response = self._call_aingest_sync(request)
-                self._logger.debug(f"_ingest_units: apayi success ({ingest_response})")
-                return ingest_response
+                sync_response = self._call_aingest_sync(request)
+                self._logger.debug(f"_ingest_units: apayi success ({sync_response})")
+                return sync_response
             else:
                 self._logger.error("No payi instance to ingest units")
+                return XproxyError(code="configuration_error", message="No Payi or AsyncPayi instance configured for ingesting units")
 
-        except Exception as e:
-            if isinstance(e, APIConnectionError) and self._api_connection_error_window > 0:
-                self._process_ingest_connection_error(e, ingest_units)
-            else:
-                self._logger.error(f"Error Pay-i ingesting: exception {e}, request {ingest_units}")
+        except APIConnectionError as api_ex:
+            return self._process_ingest_connection_error(api_ex, ingest_units)
+
+        except APIStatusError as api_status_ex:
+            return self._process_api_status_error(api_status_ex)      
+
+        except Exception as ex:
+            self._logger.error(f"Error Pay-i async ingesting: exception {ex}, request {ingest_units}")
+            return XproxyError(code="unknown_error", message=str(ex))
         
-        return None
+    def _ingest_units(self, request: _ProviderRequest) -> Optional[Union[XproxyResult, XproxyError]]:
+        return self.set_xproxy_result(self._ingest_units_worker(request))
 
     def _setup_call_func(
         self
@@ -1040,6 +1114,10 @@ class _PayiInstrumentor:
 
         return extra_headers
 
+    def set_xproxy_result(self, response: Optional[Union[XproxyResult, XproxyError]]) -> Optional[Union[XproxyResult, XproxyError]]:
+        self._last_result = response
+        return response
+
     @staticmethod
     def _update_extra_headers(
         context: _Context,
@@ -1617,7 +1695,7 @@ def track_context(
     price_as_resource: Optional[str] = None,
     resource_scope: Optional[str] = None,
     proxy: Optional[bool] = None,
-) -> _TrackContext:
+) -> _InternalTrackContext:
     # Create a new context for tracking
     context: _Context = {}
 
@@ -1637,4 +1715,22 @@ def track_context(
     context["price_as_resource"] = price_as_resource
     context["resource_scope"] = resource_scope
 
-    return _TrackContext(context)
+    return _InternalTrackContext(context)
+
+def get_context() -> PayiContext:
+    """
+    Returns the current tracking context from calls to @track and with track_context().
+    If no context is active, returns an empty context.
+    """
+    if not _instrumentor:
+        return PayiContext()
+    internal_context = _instrumentor.get_context() or {}
+
+    context_dict = {
+        key: value
+        for key, value in internal_context.items()
+        if key in PayiContext.__annotations__ and value is not None
+    }
+    if _instrumentor._last_result:
+        context_dict["last_result"] = _instrumentor._last_result
+    return PayiContext(**dict(context_dict))  # type: ignore

payi/lib/version_helper.py

@@ -0,0 +1,21 @@
+from importlib.metadata import version
+
+
+def get_version_helper(module:str) -> str:
+    """
+    Get the version of the specified module.
+    
+    Args:
+        module (str): The name of the module to query.
+    
+    Returns:
+        str: The version of the module, or an empty string if not found.
+    """
+    try:
+        return version(module)
+    except Exception:
+        try:
+            imported_module = __import__(module)
+            return getattr(imported_module, "__version__", "")
+        except Exception:
+            return ""

{payi-0.1.0a96.dist-info → payi-0.1.0a98.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: payi
-Version: 0.1.0a96
+Version: 0.1.0a98
 Summary: The official Python library for the payi API
 Project-URL: Homepage, https://github.com/Pay-i/pay-i-python
 Project-URL: Repository, https://github.com/Pay-i/pay-i-python
@@ -18,6 +18,7 @@ Classifier: Programming Language :: Python :: 3.9
 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
 Classifier: Typing :: Typed
 Requires-Python: >=3.8
@@ -37,7 +38,8 @@ Description-Content-Type: text/markdown
 
 # Payi Python API library
 
-[![PyPI version](https://github.com/Pay-i/pay-i-python/tree/main/<https://img.shields.io/pypi/v/payi.svg?label=pypi%20(stable)>)](https://pypi.org/project/payi/)
+<!-- prettier-ignore -->
+[![PyPI version](https://img.shields.io/pypi/v/payi.svg?label=pypi%20(stable))](https://pypi.org/project/payi/)
 
 The Payi Python library provides convenient access to the Payi REST API from any Python 3.8+
 application. The library includes type definitions for all request params and response fields,

{payi-0.1.0a96.dist-info → payi-0.1.0a98.dist-info}/RECORD

@@ -5,13 +5,13 @@ payi/_compat.py,sha256=VWemUKbj6DDkQ-O4baSpHVLJafotzeXmCQGJugfVTIw,6580
 payi/_constants.py,sha256=S14PFzyN9-I31wiV7SmIlL5Ga0MLHxdvegInGdXH7tM,462
 payi/_exceptions.py,sha256=ItygKNrNXIVY0H6LsGVZvFuAHB3Vtm_VZXmWzCnpHy0,3216
 payi/_files.py,sha256=mf4dOgL4b0ryyZlbqLhggD3GVgDf6XxdGFAgce01ugE,3549
-payi/_models.py,sha256=G1vczEodX0vUySeVKbF-mbzlaObNL1oVAYH4c65agRk,29131
+payi/_models.py,sha256=viD5E6aDMhxslcFHDYvkHaKzE8YLcNmsPsMe8STixvs,29294
 payi/_qs.py,sha256=AOkSz4rHtK4YI3ZU_kzea-zpwBUgEY8WniGmTPyEimc,4846
 payi/_resource.py,sha256=j2jIkTr8OIC8sU6-05nxSaCyj4MaFlbZrwlyg4_xJos,1088
 payi/_response.py,sha256=rh9oJAvCKcPwQFm4iqH_iVrmK8bNx--YP_A2a4kN1OU,28776
 payi/_streaming.py,sha256=Z_wIyo206T6Jqh2rolFg2VXZgX24PahLmpURp0-NssU,10092
 payi/_types.py,sha256=7jE5MoQQFVoVxw5vVzvZ2Ao0kcjfNOGsBgyJfLBEnMo,6195
-payi/_version.py,sha256=HrUZ97eXJDQhDfJm78BH6NvNVuDnKXoia2Jj2xHrnm0,165
+payi/_version.py,sha256=38kV-DSbhe__PIX2CraSgjbmWYlEpux8E-hfcRDYeKE,165
 payi/pagination.py,sha256=k2356QGPOUSjRF2vHpwLBdF6P-2vnQzFfRIJQAHGQ7A,1258
 payi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 payi/_utils/__init__.py,sha256=PNZ_QJuzZEgyYXqkO1HVhGkj5IU9bglVUcw7H-Knjzw,2062
@@ -25,15 +25,16 @@ payi/_utils/_transform.py,sha256=n7kskEWz6o__aoNvhFoGVyDoalNe6mJwp-g7BWkdj88,156
 payi/_utils/_typing.py,sha256=D0DbbNu8GnYQTSICnTSHDGsYXj8TcAKyhejb0XcnjtY,4602
 payi/_utils/_utils.py,sha256=ts4CiiuNpFiGB6YMdkQRh2SZvYvsl7mAF-JWHCcLDf4,12312
 payi/lib/.keep,sha256=wuNrz-5SXo3jJaJOJgz4vFHM41YH_g20F5cRQo0vLes,224
-payi/lib/AnthropicInstrumentor.py,sha256=ahYEPqQ5r7K_K5Zt6Q7rLl8jThFthRo3sc15l9o2VPs,14123
-payi/lib/BedrockInstrumentor.py,sha256=3f79Av7reWENDcX7_9D5YBwH0Zd-RDVgrZ8vh051yIY,17594
-payi/lib/GoogleGenAiInstrumentor.py,sha256=DLbmlwmyOwooe7FuBkEAO_Z3xjPKpvQyO4VwLBeZnn4,8477
-payi/lib/OpenAIInstrumentor.py,sha256=6HENrdN6kLMUwC00wNSdeGeK4fUDBWo2dCbVC9koi0c,22581
+payi/lib/AnthropicInstrumentor.py,sha256=jL9GG56lebZF2b9a5uM4F0cYjTRpxa9tTa8rX3az_po,14405
+payi/lib/BedrockInstrumentor.py,sha256=dMelEiVq5lV1vYh0K7YfXimtFWfZO_zQ3Mhu3y4bjlM,17926
+payi/lib/GoogleGenAiInstrumentor.py,sha256=LHiEZ7G5IhCcDlpVzQlXW9Ok96MHLeq7emEhFzPBTm0,8836
+payi/lib/OpenAIInstrumentor.py,sha256=_ULwIli11XP1yZK_pMGXuaSmHZ5pozuEt_v5DfhNuGw,22914
 payi/lib/Stopwatch.py,sha256=7OJlxvr2Jyb6Zr1LYCYKczRB7rDVKkIR7gc4YoleNdE,764
-payi/lib/VertexInstrumentor.py,sha256=q-oYr3YuwPc95xYn6KhjvKs5ZweGRg6mOIkxSTz-lic,7081
-payi/lib/VertexRequest.py,sha256=NNH6S86nCHaU54Rb1rxai-b3UiJvatmzKkDKBmqMeKY,10530
+payi/lib/VertexInstrumentor.py,sha256=OWuMPiW4LdLhj6DSAAy5qZiosVo8DSAuFWGxYpEucoE,7431
+payi/lib/VertexRequest.py,sha256=edv14HR5QtKaf07gmOqzWdhoJGdWCos85uCZASwsGL4,11710
 payi/lib/helpers.py,sha256=FPzNSSHGf9bgD6CanB7yVx_U8t4lm2c0jlZKrsziYlc,4242
-payi/lib/instrument.py,sha256=VEyEyjM0GGIdFqv9ogwBwyWQ8kRJgJWUxlWcQc6798Q,64801
+payi/lib/instrument.py,sha256=R3NSYXtoZX5nCvPtSWxREF_qlMkjkDQCF2RIxlO2E_s,69224
+payi/lib/version_helper.py,sha256=v0lC3kuaXn6PBDolE3mkmwJiA8Ot3z4RkVR7wlBuZCs,540
 payi/resources/__init__.py,sha256=B2bn1ZfCf6TbHlzZvy5TpFPtALnFcBRPYVKQH3S5qfQ,2457
 payi/resources/ingest.py,sha256=awE7xDdKOUL2Yhcrhcc11hSNycBlj8QRlahptjana5Q,23040
 payi/resources/categories/__init__.py,sha256=WeotN_d-0Ri8ohsrNPbve7RyViD9_N0NA9DrV3WYg3w,1701
@@ -132,7 +133,7 @@ payi/types/use_cases/definitions/kpi_retrieve_response.py,sha256=uQXliSvS3k-yDYw
 payi/types/use_cases/definitions/kpi_update_params.py,sha256=jbawdWAdMnsTWVH0qfQGb8W7_TXe3lq4zjSRu44d8p8,373
 payi/types/use_cases/definitions/kpi_update_response.py,sha256=zLyEoT0S8d7XHsnXZYT8tM7yDw0Aze0Mk-_Z6QeMtc8,459
 payi/types/use_cases/definitions/limit_config_create_params.py,sha256=pzQza_16N3z8cFNEKr6gPbFvuGFrwNuGxAYb--Kbo2M,449
-payi-0.1.0a96.dist-info/METADATA,sha256=VVawI7dTiqYjzxZQOhcwSagnNaBhaseMbtBybj4HUeY,16333
-payi-0.1.0a96.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
-payi-0.1.0a96.dist-info/licenses/LICENSE,sha256=CQt03aM-P4a3Yg5qBg3JSLVoQS3smMyvx7tYg_6V7Gk,11334
-payi-0.1.0a96.dist-info/RECORD,,
+payi-0.1.0a98.dist-info/METADATA,sha256=MX8Kgs_X43l0QT3wWsLL-SQdW3Am4j5SZJNZf0djYGY,16359
+payi-0.1.0a98.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+payi-0.1.0a98.dist-info/licenses/LICENSE,sha256=CQt03aM-P4a3Yg5qBg3JSLVoQS3smMyvx7tYg_6V7Gk,11334
+payi-0.1.0a98.dist-info/RECORD,,