payi 0.1.0a115__tar.gz → 0.1.0a117__tar.gz

payi-0.1.0a117/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.1.0-alpha.117"
+}

{payi-0.1.0a115 → payi-0.1.0a117}/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## 0.1.0-alpha.117 (2025-09-16)
+
+Full Changelog: [v0.1.0-alpha.116...v0.1.0-alpha.117](https://github.com/Pay-i/pay-i-python/compare/v0.1.0-alpha.116...v0.1.0-alpha.117)
+
+### Chores
+
+* **tests:** simplify `get_platform` test ([9aeaba6](https://github.com/Pay-i/pay-i-python/commit/9aeaba6c83b4cdcd6bb348609a9e22ad86b14b7a))
+
+## 0.1.0-alpha.116 (2025-09-06)
+
+Full Changelog: [v0.1.0-alpha.115...v0.1.0-alpha.116](https://github.com/Pay-i/pay-i-python/compare/v0.1.0-alpha.115...v0.1.0-alpha.116)
+
+### Features
+
+* aws bedrock guardians ([#363](https://github.com/Pay-i/pay-i-python/issues/363)) ([08d74c8](https://github.com/Pay-i/pay-i-python/commit/08d74c8d49368cc0e8ae0b8d0f9a94458e7be0fa))
+
 ## 0.1.0-alpha.115 (2025-09-05)
 
 Full Changelog: [v0.1.0-alpha.114...v0.1.0-alpha.115](https://github.com/Pay-i/pay-i-python/compare/v0.1.0-alpha.114...v0.1.0-alpha.115)

{payi-0.1.0a115 → payi-0.1.0a117}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: payi
-Version: 0.1.0a115
+Version: 0.1.0a117
 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

{payi-0.1.0a115 → payi-0.1.0a117}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "payi"
-version = "0.1.0-alpha.115"
+version = "0.1.0-alpha.117"
 description = "The official Python library for the payi API"
 dynamic = ["readme"]
 license = "Apache-2.0"
@@ -60,7 +60,6 @@ dev-dependencies = [
     "dirty-equals>=0.6.0",
     "importlib-metadata>=6.7.0",
     "rich>=13.7.1",
-    "nest_asyncio==1.6.0",
     "pytest-xdist>=3.6.1",
     "wrapt",
 ]

{payi-0.1.0a115 → payi-0.1.0a117}/src/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.115"  # x-release-please-version
+__version__ = "0.1.0-alpha.117"  # x-release-please-version

{payi-0.1.0a115 → payi-0.1.0a117}/src/payi/lib/AnthropicInstrumentor.py

@@ -253,7 +253,7 @@ def anthropic_process_compute_input_cost(request: _ProviderRequest, usage: 'dict
 
     total_input_tokens = input + cache_creation_input_tokens + cache_read_input_tokens
 
-    request._is_large_context = total_input_tokens > 200000
+    request._is_large_context = total_input_tokens >= 200000
     large_context = "_large_context" if request._is_large_context else ""
 
     cache_creation: dict[str, int] = usage.get("cache_creation", {})

{payi-0.1.0a115 → payi-0.1.0a117}/src/payi/lib/BedrockInstrumentor.py

@@ -11,9 +11,21 @@ from payi.lib.helpers import PayiCategories, PayiHeaderNames, payi_aws_bedrock_u
 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 .instrument import (
+    PayiInstrumentAwsBedrockConfig,
+    _ChunkResult,
+    _IsStreaming,
+    _StreamingType,
+    _ProviderRequest,
+    _PayiInstrumentor,
+)
 from .version_helper import get_version_helper
 
+GUARDRAIL_ID = "system.aws.bedrock.guardrail.id"
+GUARDRAIL_VERSION = "system.aws.bedrock.guardrail.version"
+GUARDRAIL_ACTION = "system.aws.bedrock.guardrail.action"
+
+GUARDRAIL_SEMANTIC_FAILURE_DESCRIPTION = "Bedrock Guardrails intervened"
 
 class BedrockInstrumentor:
     _module_name: str = "boto3"
@@ -21,8 +33,10 @@ class BedrockInstrumentor:
 
     _instrumentor: _PayiInstrumentor
 
+    _guardrail_trace: bool = True
+
     @staticmethod
-    def instrument(instrumentor: _PayiInstrumentor) -> None:
+    def instrument(instrumentor: _PayiInstrumentor, aws_config: Optional[PayiInstrumentAwsBedrockConfig]) -> None:
         BedrockInstrumentor._instrumentor = instrumentor
 
         BedrockInstrumentor._module_version = get_version_helper(BedrockInstrumentor._module_name)
@@ -44,6 +58,9 @@ class BedrockInstrumentor:
             instrumentor._logger.debug(f"Error instrumenting bedrock: {e}")
             return
 
+        if aws_config:
+            BedrockInstrumentor._guardrail_trace = aws_config.get("guardrail_trace", True)
+
 @_PayiInstrumentor.payi_wrapper
 def create_client_wrapper(instrumentor: _PayiInstrumentor, wrapped: Any, instance: Any, *args: Any, **kwargs: Any) -> Any: #  noqa: ARG001
     if kwargs.get("service_name") != "bedrock-runtime":
@@ -184,7 +201,12 @@ class InvokeResponseWrapper(ObjectProxy): # type: ignore
 
         if self._log_prompt_and_response:
             ingest["provider_response_json"] = data.decode('utf-8') # type: ignore
-            
+
+        guardrails = response.get("amazon-bedrock-trace", {}).get("guardrail", {}).get("input", {})
+        self._request.process_guardrails(guardrails)
+
+        self._request.process_stop_action(response.get("amazon-bedrock-guardrailAction", ""))
+
         self._request._instrumentor._ingest_units(self._request)
 
         return data # type: ignore
@@ -257,6 +279,7 @@ def wrap_converse_stream(instrumentor: _PayiInstrumentor, wrapped: Any) -> Any:
     return invoke_wrapper
 
 class _BedrockProviderRequest(_ProviderRequest):
+
     def __init__(self, instrumentor: _PayiInstrumentor):
         super().__init__(
             instrumentor=instrumentor,
@@ -303,6 +326,51 @@ class _BedrockProviderRequest(_ProviderRequest):
             self._instrumentor._logger.debug(f"Error processing exception: {e}")
             return False
 
+    def process_guardrails(self, guardrails: 'dict[str, Any]') -> None:
+        units = self._ingest["units"]
+
+        # while we iterate over the entire dict, only one guardrail is expected and supported
+        for _, value in guardrails.items():
+            # _ (key) is the guardrail id
+            if not isinstance(value, dict):
+                continue
+
+            usage: dict[str, int] = value.get("invocationMetrics", {}).get("usage", {}) # type: ignore
+            if not usage:
+                continue
+
+            topicPolicyUnits: int  = usage.get("topicPolicyUnits", 0) # type: ignore
+            if topicPolicyUnits > 0:
+                units["guardrail_topic"] = Units(input=topicPolicyUnits, output=0) # type: ignore
+
+            contentPolicyUnits = usage.get("contentPolicyUnits", 0) # type: ignore
+            if contentPolicyUnits > 0:
+                units["guardrail_content"] = Units(input=contentPolicyUnits, output=0) # type: ignore
+
+            wordPolicyUnits = usage.get("wordPolicyUnits", 0) # type: ignore    
+            if wordPolicyUnits > 0:
+                units["guardrail_word_free"] = Units(input=wordPolicyUnits, output=0) # type: ignore
+
+            automatedReasoningPolicyUnits = usage.get("automatedReasoningPolicyUnits", 0) # type: ignore
+            if automatedReasoningPolicyUnits > 0:
+                units["guardrail_automated_reasoning"] = Units(input=automatedReasoningPolicyUnits, output=0) # type: ignore
+
+            sensitiveInformationPolicyUnits = usage.get("sensitiveInformationPolicyUnits", 0) # type: ignore
+            if sensitiveInformationPolicyUnits > 0:
+                units["guardrail_sensitive_information"] = Units(input=sensitiveInformationPolicyUnits, output=0) # type: ignore
+
+            sensitiveInformationPolicyFreeUnits = usage.get("sensitiveInformationPolicyFreeUnits", 0) # type: ignore
+            if sensitiveInformationPolicyFreeUnits > 0:
+                units["guardrail_sensitive_information_free"] = Units(input=sensitiveInformationPolicyFreeUnits, output=0) # type: ignore
+
+            contextualGroundingPolicyUnits = usage.get("contextualGroundingPolicyUnits", 0) # type: ignore
+            if contextualGroundingPolicyUnits > 0:
+                units["guardrail_contextual_grounding"] = Units(input=contextualGroundingPolicyUnits, output=0) # type: ignore
+
+            contentPolicyImageUnits = usage.get("contentPolicyImageUnits", 0) # type: ignore
+            if contentPolicyImageUnits > 0:
+                units["guardrail_content_image"] = Units(input=contentPolicyImageUnits, output=0) # type: ignore
+
 class _BedrockInvokeProviderRequest(_BedrockProviderRequest):
     def __init__(self, instrumentor: _PayiInstrumentor, model_id: str):
         super().__init__(instrumentor=instrumentor)
@@ -318,9 +386,22 @@ class _BedrockInvokeProviderRequest(_BedrockProviderRequest):
 
         super().process_request(instance, extra_headers, args, kwargs)
     
+        guardrail_id = kwargs.get("guardrailIdentifier", "")
+        if guardrail_id:
+            self.add_internal_request_property(GUARDRAIL_ID, guardrail_id)
+
+        guardrail_version = kwargs.get("guardrailVersion", "")
+        if guardrail_version:
+            self.add_internal_request_property(GUARDRAIL_VERSION, guardrail_version)
+
+        if guardrail_id and guardrail_version and BedrockInstrumentor._guardrail_trace:
+            trace = kwargs.get("trace", None)
+            if not trace:
+                kwargs["trace"] = "ENABLED"
+
         if self._is_anthropic:
             try:
-                body = json.loads( kwargs.get("body", ""))
+                body = json.loads(kwargs.get("body", ""))
                 messages = body.get("messages", {})
                 if messages:
                     anthropic_has_image_and_get_texts(self, messages)
@@ -328,7 +409,7 @@ class _BedrockInvokeProviderRequest(_BedrockProviderRequest):
                 self._instrumentor._logger.debug(f"Bedrock invoke error processing request body: {e}")
         elif self._is_cohere_embed_english_v3:
             try:
-                body = json.loads( kwargs.get("body", ""))
+                body = json.loads(kwargs.get("body", ""))
                 input_type = body.get("input_type", "")
                 if input_type == 'image':
                     images = body.get("images", [])
@@ -343,6 +424,12 @@ class _BedrockInvokeProviderRequest(_BedrockProviderRequest):
     def process_chunk(self, chunk: Any) -> _ChunkResult:
         chunk_dict = json.loads(chunk)
 
+        guardrails = chunk_dict.get("amazon-bedrock-trace", {}).get("guardrail", {}).get("input", {})
+        if guardrails:
+            self.process_guardrails(guardrails)
+    
+        self.process_stop_action(chunk_dict.get("amazon-bedrock-guardrailAction", ""))
+
         if self._is_anthropic:
             from .AnthropicInstrumentor import anthropic_process_chunk
             return anthropic_process_chunk(self, chunk_dict, assign_id=False)
@@ -398,6 +485,13 @@ class _BedrockInvokeProviderRequest(_BedrockProviderRequest):
 
         return response
 
+    def process_stop_action(self, action: str) -> None:
+        # record both as a semantic failure and guardrail action so it is discoverable through both properties
+        if action == "INTERVENED":
+            self.add_internal_request_property('system.failure', action)
+            self.add_internal_request_property('system.failure.description', GUARDRAIL_SEMANTIC_FAILURE_DESCRIPTION)
+            self.add_internal_request_property(GUARDRAIL_ACTION, action)
+
     @override
     def remove_inline_data(self, prompt: 'dict[str, Any]') -> bool:# noqa: ARG002
         if not self._is_anthropic:
@@ -417,6 +511,25 @@ class _BedrockInvokeProviderRequest(_BedrockProviderRequest):
         return False
 
 class _BedrockConverseProviderRequest(_BedrockProviderRequest):
+    @override
+    def process_request(self, instance: Any, extra_headers: 'dict[str, str]', args: Sequence[Any], kwargs: Any) -> bool:
+        guardrail_config = kwargs.get("guardrailConfig", {})
+        if guardrail_config:
+            guardrailIdentifier = guardrail_config.get("guardrailIdentifier", "")
+            if guardrailIdentifier:
+                self.add_internal_request_property(GUARDRAIL_ID, guardrailIdentifier)
+
+            guardrailVersion = guardrail_config.get("guardrailVersion", "")
+            if guardrailVersion:
+                self.add_internal_request_property(GUARDRAIL_VERSION, guardrailVersion)
+
+            if guardrailIdentifier and guardrailVersion and BedrockInstrumentor._guardrail_trace:
+                trace = guardrail_config.get("trace", None)
+                if not trace:
+                    guardrail_config["trace"] = "enabled"
+
+        return True
+
     @override
     def process_synchronous_response(
         self,
@@ -448,6 +561,12 @@ class _BedrockConverseProviderRequest(_BedrockProviderRequest):
 
         bedrock_converse_process_synchronous_function_call(self, response)
 
+        guardrails = response.get("trace", {}).get("guardrail", {}).get("inputAssessment", {})
+        if guardrails:
+            self.process_guardrails(guardrails)
+
+        self.process_stop_reason(response.get("stopReason", ""))
+
         return None
 
     @override
@@ -461,12 +580,25 @@ class _BedrockConverseProviderRequest(_BedrockProviderRequest):
             output = usage.get("outputTokens", 0)
             self._ingest["units"]["text"] = Units(input=input, output=output)
 
+            guardrail = metadata.get("trace", {}).get("guardrail", {}).get("inputAssessment", {})
+            if guardrail:
+                self.process_guardrails(guardrail)
+
             ingest = True
 
+        self.process_stop_reason(chunk.get("messageStop", {}).get("stopReason", ""))
+
         bedrock_converse_process_streaming_for_function_call(self, chunk)
 
         return _ChunkResult(send_chunk_to_caller=True, ingest=ingest)
 
+    def process_stop_reason(self, reason: str) -> None:
+        if reason == "guardrail_intervened":
+            # record both as a semantic failure and guardrail action so it is discoverable through both properties
+            self.add_internal_request_property('system.failure', reason)
+            self.add_internal_request_property('system.failure.description', GUARDRAIL_SEMANTIC_FAILURE_DESCRIPTION)
+            self.add_internal_request_property(GUARDRAIL_ACTION, reason)
+
 def bedrock_converse_process_streaming_for_function_call(request: _ProviderRequest, chunk: 'dict[str, Any]') -> None:  
     contentBlockStart = chunk.get("contentBlockStart", {})
     tool_use = contentBlockStart.get("start", {}).get("toolUse", {})

{payi-0.1.0a115 → payi-0.1.0a117}/src/payi/lib/instrument.py

@@ -59,6 +59,7 @@ class _ProviderRequest:
         self._building_function_response: bool = False
         self._function_calls: Optional[list[ProviderResponseFunctionCall]] = None
         self._is_large_context: bool = False
+        self._internal_request_properties: dict[str, str] = {}
 
     def process_chunk(self, _chunk: Any) -> _ChunkResult:
         return _ChunkResult(send_chunk_to_caller=True)
@@ -99,6 +100,9 @@ class _ProviderRequest:
     def streaming_type(self) -> '_StreamingType':
         return self._streaming_type
 
+    def add_internal_request_property(self, key: str, value: str) -> None:
+        self._internal_request_properties[key] = value
+
     def exception_to_semantic_failure(self, e: Exception) -> None:
         exception_str = f"{type(e).__name__}"
     
@@ -113,16 +117,10 @@ class _ProviderRequest:
                 except Exception as _ex:
                     pass
  
-        existing_properties = self._ingest.get("properties", None)
-        if not existing_properties:
-            existing_properties = {}
-
-        existing_properties['system.failure'] = exception_str
+        self.add_internal_request_property('system.failure', exception_str)
         if fields:
             failure_description = ",".join(fields)
-            existing_properties["system.failure.description"] = failure_description[:128]
-
-        self._ingest["properties"] = existing_properties
+            self.add_internal_request_property("system.failure.description", failure_description)
 
         if "http_status_code" not in self._ingest:
             # use a non existent http status code so when presented to the user, the origin is clear
@@ -147,6 +145,9 @@ class _ProviderRequest:
             self._ingest["provider_response_function_calls"] = self._function_calls
         self._function_calls.append(ProviderResponseFunctionCall(name=name, arguments=arguments))
 
+class PayiInstrumentAwsBedrockConfig(TypedDict, total=False):
+    guardrail_trace: bool
+
 class PayiInstrumentConfig(TypedDict, total=False):
     proxy: bool
     global_instrumentation: bool
@@ -161,6 +162,7 @@ class PayiInstrumentConfig(TypedDict, total=False):
     account_name: Optional[str]
     request_tags: Optional["list[str]"]
     request_properties: Optional["dict[str, str]"]
+    aws_config: Optional[PayiInstrumentAwsBedrockConfig]
 
 class PayiContext(TypedDict, total=False):
     use_case_name: Optional[str]
@@ -276,9 +278,9 @@ class _PayiInstrumentor:
         global_instrumentation = global_config.pop("global_instrumentation", True)
 
         if instruments is None or "*" in instruments:
-            self._instrument_all()
+            self._instrument_all(global_config=global_config)
         else:
-            self._instrument_specific(instruments)
+            self._instrument_specific(instruments=instruments, global_config=global_config)
 
         if global_instrumentation:
             if "proxy" not in global_config:
@@ -313,20 +315,20 @@ class _PayiInstrumentor:
 
             self._init_current_context(**context) 
 
-    def _instrument_all(self) -> None:
+    def _instrument_all(self, global_config: PayiInstrumentConfig) -> None:
         self._instrument_openai()
         self._instrument_anthropic()
-        self._instrument_aws_bedrock()
+        self._instrument_aws_bedrock(global_config.get("aws_config", None))
         self._instrument_google_vertex()
         self._instrument_google_genai()
 
-    def _instrument_specific(self, instruments: Set[str]) -> None:
+    def _instrument_specific(self, instruments: Set[str], global_config: PayiInstrumentConfig) -> None:
         if PayiCategories.openai in instruments or PayiCategories.azure_openai in instruments:
             self._instrument_openai()
         if PayiCategories.anthropic in instruments:
             self._instrument_anthropic()
         if PayiCategories.aws_bedrock in instruments:
-            self._instrument_aws_bedrock()
+            self._instrument_aws_bedrock(global_config.get("aws_config", None))
         if PayiCategories.google_vertex in instruments:
             self._instrument_google_vertex()
             self._instrument_google_genai()
@@ -349,11 +351,11 @@ class _PayiInstrumentor:
         except Exception as e:
             self._logger.error(f"Error instrumenting Anthropic: {e}")
 
-    def _instrument_aws_bedrock(self) -> None:
+    def _instrument_aws_bedrock(self, aws_config: Optional[PayiInstrumentAwsBedrockConfig]) -> None:
         from .BedrockInstrumentor import BedrockInstrumentor
 
         try:
-            BedrockInstrumentor.instrument(self)
+            BedrockInstrumentor.instrument(self, aws_config=aws_config)
 
         except Exception as e:
             self._logger.error(f"Error instrumenting AWS bedrock: {e}")
@@ -393,9 +395,10 @@ class _PayiInstrumentor:
         return log_ingest_units
         
     def _process_ingest_units(
-            self,
-            request: _ProviderRequest, log_data: 'dict[str, str]',
-            extra_headers: 'dict[str, str]') -> None:
+        self,
+        request: _ProviderRequest,
+        log_data: 'dict[str, str]',
+        extra_headers: 'dict[str, str]') -> None:
         ingest_units = request._ingest
 
         if request._module_version:
@@ -408,6 +411,9 @@ class _PayiInstrumentor:
         if 'resource' not in ingest_units or ingest_units['resource'] == '':
             ingest_units['resource'] = "system.unknown_model"
 
+        if request._internal_request_properties:
+            ingest_units["properties"] = request._internal_request_properties
+
         request_json = ingest_units.get('provider_request_json', "")
         if request_json and self._instrument_inline_data is False:
             try:
@@ -925,6 +931,15 @@ class _PayiInstrumentor:
         if use_case_properties:
             request._ingest["use_case_properties"] = use_case_properties
 
+        if request._internal_request_properties:
+            if "properties" in request._ingest and request._ingest["properties"] is not None:
+                # Merge internal request properties, but don't override existing keys
+                for key, value in request._internal_request_properties.items():
+                    if key not in request._ingest["properties"]:
+                        request._ingest["properties"][key] = value
+            else:
+                request._ingest["properties"] = request._internal_request_properties # Assign
+
         if len(ingest_extra_headers) > 0:
             request._ingest["provider_request_headers"] = [PayICommonModelsAPIRouterHeaderInfoParam(name=k, value=v) for k, v in ingest_extra_headers.items()]
 

{payi-0.1.0a115 → payi-0.1.0a117}/tests/test_client.py

@@ -6,13 +6,10 @@ import gc
 import os
 import sys
 import json
-import time
 import asyncio
 import inspect
-import subprocess
 import tracemalloc
 from typing import Any, Union, cast
-from textwrap import dedent
 from unittest import mock
 from typing_extensions import Literal
 
@@ -23,14 +20,17 @@ from pydantic import ValidationError
 
 from payi import Payi, AsyncPayi, APIResponseValidationError
 from payi._types import Omit
+from payi._utils import asyncify
 from payi._models import BaseModel, FinalRequestOptions
 from payi._exceptions import PayiError, APIStatusError, APITimeoutError, APIResponseValidationError
 from payi._base_client import (
     DEFAULT_TIMEOUT,
     HTTPX_DEFAULT_TIMEOUT,
     BaseClient,
+    OtherPlatform,
     DefaultHttpxClient,
     DefaultAsyncHttpxClient,
+    get_platform,
     make_request_options,
 )
 
@@ -1617,50 +1617,9 @@ class TestAsyncPayi:
 
         assert response.http_request.headers.get("x-stainless-retry-count") == "42"
 
-    def test_get_platform(self) -> None:
-        # A previous implementation of asyncify could leave threads unterminated when
-        # used with nest_asyncio.
-        #
-        # Since nest_asyncio.apply() is global and cannot be un-applied, this
-        # test is run in a separate process to avoid affecting other tests.
-        test_code = dedent("""
-        import asyncio
-        import nest_asyncio
-        import threading
-
-        from payi._utils import asyncify
-        from payi._base_client import get_platform
-
-        async def test_main() -> None:
-            result = await asyncify(get_platform)()
-            print(result)
-            for thread in threading.enumerate():
-                print(thread.name)
-
-        nest_asyncio.apply()
-        asyncio.run(test_main())
-        """)
-        with subprocess.Popen(
-            [sys.executable, "-c", test_code],
-            text=True,
-        ) as process:
-            timeout = 10  # seconds
-
-            start_time = time.monotonic()
-            while True:
-                return_code = process.poll()
-                if return_code is not None:
-                    if return_code != 0:
-                        raise AssertionError("calling get_platform using asyncify resulted in a non-zero exit code")
-
-                    # success
-                    break
-
-                if time.monotonic() - start_time > timeout:
-                    process.kill()
-                    raise AssertionError("calling get_platform using asyncify resulted in a hung process")
-
-                time.sleep(0.1)
+    async def test_get_platform(self) -> None:
+        platform = await asyncify(get_platform)()
+        assert isinstance(platform, (str, OtherPlatform))
 
     async def test_proxy_environment_variables(self, monkeypatch: pytest.MonkeyPatch) -> None:
         # Test that the proxy environment variables are set correctly

payi-0.1.0a115/.release-please-manifest.json

@@ -1,3 +0,0 @@
-{
-  ".": "0.1.0-alpha.115"
-}