payi 0.1.0a124__py3-none-any.whl → 0.1.0a126__py3-none-any.whl

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.124"  # x-release-please-version
+__version__ = "0.1.0-alpha.126"  # x-release-please-version

payi/lib/BedrockInstrumentor.py

@@ -1,13 +1,12 @@
 import os
 import json
-from typing import Any, Optional, Sequence
+from typing import TYPE_CHECKING, Any, Optional, Sequence
 from functools import wraps
 from typing_extensions import override
 
 from wrapt import ObjectProxy, wrap_function_wrapper  # type: ignore
-from tokenizers import Tokenizer  # type: ignore
 
-from payi.lib.helpers import PayiCategories, PayiHeaderNames, payi_aws_bedrock_url
+from payi.lib.helpers import PayiCategories, PayiHeaderNames, PayiPropertyNames, payi_aws_bedrock_url
 from payi.types.ingest_units_params import Units
 from payi.types.pay_i_common_models_api_router_header_info_param import PayICommonModelsAPIRouterHeaderInfoParam
 
@@ -21,9 +20,10 @@ from .instrument import (
 )
 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"
+if TYPE_CHECKING:
+    from tokenizers import Tokenizer  # type: ignore
+else:
+    Tokenizer = None  
 
 GUARDRAIL_SEMANTIC_FAILURE_DESCRIPTION = "Bedrock Guardrails intervened"
 
@@ -118,9 +118,8 @@ def _redirect_to_payi(request: Any, event_name: str, **_: 'dict[str, Any]') -> N
     for key, value in extra_headers.items():
         request.headers[key] = value
 
-
 class InvokeResponseWrapper(ObjectProxy): # type: ignore
-    _cohere_embed_english_v3_tokenizer: Optional[Tokenizer] = None
+    _cohere_embed_english_v3_tokenizer: Optional['Tokenizer'] = None
 
     def __init__(
         self,
@@ -189,15 +188,26 @@ class InvokeResponseWrapper(ObjectProxy): # type: ignore
             if texts and len(texts) > 0:
                 text = " ".join(texts)
 
-                if self._cohere_embed_english_v3_tokenizer is None:
-                    current_dir = os.path.dirname(os.path.abspath(__file__))
-                    tokenizer_path = os.path.join(current_dir, "data", "cohere_embed_english_v3.json")
-                    self._cohere_embed_english_v3_tokenizer = Tokenizer.from_file(tokenizer_path) # type: ignore
+                try:
+                    from tokenizers import Tokenizer  # type: ignore
+
+                    if self._cohere_embed_english_v3_tokenizer is None: # type: ignore
+                        current_dir = os.path.dirname(os.path.abspath(__file__))
+                        tokenizer_path = os.path.join(current_dir, "data", "cohere_embed_english_v3.json")
+                        self._cohere_embed_english_v3_tokenizer = Tokenizer.from_file(tokenizer_path) # type: ignore
+
+                    if self._cohere_embed_english_v3_tokenizer is not None and isinstance(self._cohere_embed_english_v3_tokenizer, Tokenizer): # type: ignore
+                        tokens: list = self._cohere_embed_english_v3_tokenizer.encode(text, add_special_tokens=False).tokens # type: ignore
 
-                tokens: list = self._cohere_embed_english_v3_tokenizer.encode(text, add_special_tokens=False).tokens # type: ignore
+                        if tokens and isinstance(tokens, list):
+                            units["text"] = Units(input=len(tokens), output=0) # type: ignore
 
-                if tokens and isinstance(tokens, list):
-                    units["text"] = Units(input=len(tokens), output=0) # type: ignore
+                except ImportError:
+                    self._request._instrumentor._logger.warning("tokenizers module not found, caller must install the tokenizers module. Cannot record text tokens for Cohere embed english v3")
+                    pass
+                except Exception as e:
+                    self._request._instrumentor._logger.warning(f"Error processing Cohere embed english v3 response: {e}")
+                    pass
 
         if self._log_prompt_and_response:
             ingest["provider_response_json"] = data.decode('utf-8') # type: ignore
@@ -388,11 +398,11 @@ class _BedrockInvokeProviderRequest(_BedrockProviderRequest):
     
         guardrail_id = kwargs.get("guardrailIdentifier", "")
         if guardrail_id:
-            self.add_internal_request_property(GUARDRAIL_ID, guardrail_id)
+            self.add_internal_request_property(PayiPropertyNames.aws_bedrock_guardrail_id, guardrail_id)
 
         guardrail_version = kwargs.get("guardrailVersion", "")
         if guardrail_version:
-            self.add_internal_request_property(GUARDRAIL_VERSION, guardrail_version)
+            self.add_internal_request_property(PayiPropertyNames.aws_bedrock_guardrail_version, guardrail_version)
 
         if guardrail_id and guardrail_version and BedrockInstrumentor._guardrail_trace:
             trace = kwargs.get("trace", None)
@@ -488,9 +498,9 @@ class _BedrockInvokeProviderRequest(_BedrockProviderRequest):
     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)
+            self.add_internal_request_property(PayiPropertyNames.failure, action)
+            self.add_internal_request_property(PayiPropertyNames.failure_description, GUARDRAIL_SEMANTIC_FAILURE_DESCRIPTION)
+            self.add_internal_request_property(PayiPropertyNames.aws_bedrock_guardrail_action, action)
 
     @override
     def remove_inline_data(self, prompt: 'dict[str, Any]') -> bool:# noqa: ARG002
@@ -519,11 +529,11 @@ class _BedrockConverseProviderRequest(_BedrockProviderRequest):
         if guardrail_config:
             guardrailIdentifier = guardrail_config.get("guardrailIdentifier", "")
             if guardrailIdentifier:
-                self.add_internal_request_property(GUARDRAIL_ID, guardrailIdentifier)
+                self.add_internal_request_property(PayiPropertyNames.aws_bedrock_guardrail_id, guardrailIdentifier)
 
             guardrailVersion = guardrail_config.get("guardrailVersion", "")
             if guardrailVersion:
-                self.add_internal_request_property(GUARDRAIL_VERSION, guardrailVersion)
+                self.add_internal_request_property(PayiPropertyNames.aws_bedrock_guardrail_version, guardrailVersion)
 
             if guardrailIdentifier and guardrailVersion and BedrockInstrumentor._guardrail_trace:
                 trace = guardrail_config.get("trace", None)
@@ -597,9 +607,9 @@ class _BedrockConverseProviderRequest(_BedrockProviderRequest):
     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)
+            self.add_internal_request_property(PayiPropertyNames.failure, reason)
+            self.add_internal_request_property(PayiPropertyNames.failure_description, GUARDRAIL_SEMANTIC_FAILURE_DESCRIPTION)
+            self.add_internal_request_property(PayiPropertyNames.aws_bedrock_guardrail_action, reason)
 
 def bedrock_converse_process_streaming_for_function_call(request: _ProviderRequest, chunk: 'dict[str, Any]') -> None:  
     contentBlockStart = chunk.get("contentBlockStart", {})

payi/lib/helpers.py

@@ -25,6 +25,18 @@ class PayiCategories:
     aws_bedrock:str = "system.aws.bedrock"
     google_vertex:str = "system.google.vertex"
 
+class PayiPropertyNames:
+    failure:str = "system.failure"
+    failure_description:str = "system.failure.description"
+
+    account_name:str = "system.account_name"
+    use_case_step:str = "system.use_case_step"
+    user_id:str = "system.user_id"
+
+    aws_bedrock_guardrail_id:str = "system.aws.bedrock.guardrail.id"
+    aws_bedrock_guardrail_version:str = "system.aws.bedrock.guardrail.version"
+    aws_bedrock_guardrail_action:str = "system.aws.bedrock.guardrail.action"
+
 def create_limit_header_from_ids(*, limit_ids: List[str]) -> Dict[str, str]:
     if not isinstance(limit_ids, list):  # type: ignore
         raise TypeError("limit_ids must be a list")

payi/lib/instrument.py

@@ -2,13 +2,14 @@ import os
 import json
 import time
 import uuid
+import atexit
 import asyncio
 import inspect
 import logging
 import traceback
 from abc import abstractmethod
 from enum import Enum
-from typing import Any, Set, Union, Callable, Optional, Sequence, TypedDict
+from typing import Any, Set, Union, Optional, Sequence, TypedDict
 from datetime import datetime, timezone
 from dataclasses import dataclass
 
@@ -17,7 +18,7 @@ from wrapt import ObjectProxy  # type: ignore
 
 from payi import Payi, AsyncPayi, APIStatusError, APIConnectionError, __version__ as _payi_version
 from payi.types import IngestUnitsParams
-from payi.lib.helpers import PayiHeaderNames
+from payi.lib.helpers import PayiHeaderNames, PayiPropertyNames
 from payi.types.shared import XproxyResult
 from payi.types.ingest_response import IngestResponse
 from payi.types.ingest_units_params import Units, ProviderResponseFunctionCall
@@ -117,10 +118,10 @@ class _ProviderRequest:
                 except Exception as _ex:
                     pass
  
-        self.add_internal_request_property('system.failure', exception_str)
+        self.add_internal_request_property(PayiPropertyNames.failure, exception_str)
         if fields:
             failure_description = ",".join(fields)
-            self.add_internal_request_property("system.failure.description", failure_description)
+            self.add_internal_request_property(PayiPropertyNames.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
@@ -148,6 +149,9 @@ class _ProviderRequest:
 class PayiInstrumentAwsBedrockConfig(TypedDict, total=False):
     guardrail_trace: bool
 
+class PayiInstrumentOfflineInstrumentationConfig(TypedDict, total=False):
+    file_name: str
+
 class PayiInstrumentConfig(TypedDict, total=False):
     proxy: bool
     global_instrumentation: bool
@@ -163,6 +167,7 @@ class PayiInstrumentConfig(TypedDict, total=False):
     request_tags: Optional["list[str]"]
     request_properties: Optional["dict[str, str]"]
     aws_config: Optional[PayiInstrumentAwsBedrockConfig]
+    offline_instrumentation: Optional[PayiInstrumentOfflineInstrumentationConfig]
 
 class PayiContext(TypedDict, total=False):
     use_case_name: Optional[str]
@@ -190,7 +195,6 @@ class _Context(TypedDict, total=False):
     limit_ids: Optional['list[str]']
     user_id: Optional[str]
     account_name: Optional[str]
-    request_tags: Optional["list[str]"]
     request_properties: Optional["dict[str, str]"]
     price_as_category: Optional[str]
     price_as_resource: Optional[str]
@@ -236,9 +240,6 @@ class _PayiInstrumentor:
         instruments: Union[Set[str], None] = None,
         log_prompt_and_response: bool = True,
         logger: Optional[logging.Logger] = None,
-        prompt_and_response_logger: Optional[
-            Callable[[str, "dict[str, str]"], None]
-        ] = None,  # (request id, dict of data to store) -> None
         global_config: PayiInstrumentConfig = {},
         caller_filename: str = ""
     ):
@@ -257,7 +258,6 @@ class _PayiInstrumentor:
 
         self._context_stack: list[_Context] = []  # Stack of context dictionaries
         self._log_prompt_and_response: bool = log_prompt_and_response
-        self._prompt_and_response_logger: Optional[Callable[[str, dict[str, str]], None]] = prompt_and_response_logger
 
         self._blocked_limits: set[str] = set()
         self._exceeded_limits: set[str] = set()
@@ -275,6 +275,17 @@ class _PayiInstrumentor:
 
         self._last_result: Optional[Union[XproxyResult, XproxyError]] = None
 
+        self._offline_instrumentation = global_config.pop("offline_instrumentation", None)
+        self._offline_ingest_packets: list[IngestUnitsParams] = []
+        self._offline_instrumentation_file_name: Optional[str] = None
+        
+        if self._offline_instrumentation is not None:
+            timestamp = datetime.now().strftime("%Y-%m-%d-%H-%M-%S")
+            self._offline_instrumentation_file_name = self._offline_instrumentation.get("file_name", f"payi_instrumentation_{timestamp}.json")
+            
+            # Register exit handler to write packets when process exits
+            atexit.register(lambda: self._write_offline_ingest_packets())
+
         global_instrumentation = global_config.pop("global_instrumentation", True)
 
         if instruments is None or "*" in instruments:
@@ -287,9 +298,7 @@ class _PayiInstrumentor:
                 global_config["proxy"] = self._proxy_default
 
             # Use default clients if not provided for global ingest instrumentation
-            if not self._payi and not self._apayi:
-                self._payi = Payi()
-                self._apayi = AsyncPayi()
+            self._ensure_payi_clients()
 
             if "use_case_name" not in global_config and caller_filename:
                 description = f"Default use case for {caller_filename}.py"
@@ -298,6 +307,9 @@ class _PayiInstrumentor:
                         self._payi.use_cases.definitions.create(name=caller_filename, description=description)
                     elif self._apayi:
                         self._call_async_use_case_definition_create(use_case_name=caller_filename, use_case_description=description)
+                    else:
+                        # in the case of _local_instrumentation is not None
+                        pass
                     global_config["use_case_name"] = caller_filename
                 except Exception as e:
                     self._logger.error(f"Error creating default use case definition based on file name {caller_filename}: {e}")
@@ -315,6 +327,14 @@ class _PayiInstrumentor:
 
             self._init_current_context(**context) 
 
+    def _ensure_payi_clients(self) -> None:
+        if self._offline_instrumentation is not None:
+            return
+
+        if not self._payi and not self._apayi:
+            self._payi = Payi()
+            self._apayi = AsyncPayi()
+
     def _instrument_all(self, global_config: PayiInstrumentConfig) -> None:
         self._instrument_openai()
         self._instrument_anthropic()
@@ -378,6 +398,30 @@ class _PayiInstrumentor:
         except Exception as e:
             self._logger.error(f"Error instrumenting Google GenAi: {e}")
 
+    def _write_offline_ingest_packets(self) -> None:
+        if not self._offline_instrumentation_file_name or not self._offline_ingest_packets:
+            return
+            
+        try:
+            # Convert datetime objects to ISO strings for JSON serialization
+            serializable_packets: list[IngestUnitsParams] = []
+            for packet in self._offline_ingest_packets:
+                serializable_packet = packet.copy()
+                
+                # Convert datetime fields to ISO format strings
+                if 'event_timestamp' in serializable_packet and isinstance(serializable_packet['event_timestamp'], datetime):
+                    serializable_packet['event_timestamp'] = serializable_packet['event_timestamp'].isoformat()
+                    
+                serializable_packets.append(serializable_packet)
+            
+            with open(self._offline_instrumentation_file_name, 'w', encoding='utf-8') as f:
+                json.dump(serializable_packets, f)
+                
+            self._logger.debug(f"Written {len(self._offline_ingest_packets)} ingest packets to {self._offline_instrumentation_file_name}")
+            
+        except Exception as e:
+            self._logger.error(f"Error writing offline ingest packets to {self._offline_instrumentation_file_name}: {e}")
+
     @staticmethod
     def _create_logged_ingest_units(
         ingest_units: IngestUnitsParams,
@@ -397,7 +441,6 @@ class _PayiInstrumentor:
     def _process_ingest_units(
         self,
         request: _ProviderRequest,
-        log_data: 'dict[str, str]',
         extra_headers: 'dict[str, str]') -> None:
         ingest_units = request._ingest
 
@@ -408,6 +451,9 @@ class _PayiInstrumentor:
             # convert the function call builder to a list of function calls
             ingest_units["provider_response_function_calls"] = list(request._function_call_builder.values())
 
+        if "provider_response_id" not in ingest_units or not ingest_units["provider_response_id"]:
+            ingest_units["provider_response_id"] = f"payi_{uuid.uuid4()}"
+
         if 'resource' not in ingest_units or ingest_units['resource'] == '':
             ingest_units['resource'] = "system.unknown_model"
 
@@ -435,19 +481,6 @@ class _PayiInstrumentor:
             if not units or all(unit.get("input", 0) == 0 and unit.get("output", 0) == 0 for unit in units.values()):
                 self._logger.info('ingesting with no token counts')
 
-        if self._log_prompt_and_response and self._prompt_and_response_logger:
-            response_json = ingest_units.pop("provider_response_json", None)
-            request_json = ingest_units.pop("provider_request_json", None)
-            stack_trace = ingest_units.get("properties", {}).pop("system.stack_trace", None)  # type: ignore
-
-            if response_json is not None:
-                # response_json is a list of strings, convert a single json string
-                log_data["provider_response_json"] = json.dumps(response_json)
-            if request_json is not None:
-                log_data["provider_request_json"] = request_json
-            if stack_trace is not None:
-                log_data["stack_trace"] = stack_trace
-
     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():
@@ -490,11 +523,8 @@ class _PayiInstrumentor:
 
         self._logger.debug(f"_aingest_units")
 
-        # return early if there are no units to ingest and on a successul ingest request
-        log_data: 'dict[str,str]' = {}
         extra_headers: 'dict[str, str]' = {}
-
-        self._process_ingest_units(request, log_data=log_data, extra_headers=extra_headers)
+        self._process_ingest_units(request, extra_headers=extra_headers)
 
         try:
             if self._logger.isEnabledFor(logging.DEBUG):
@@ -504,6 +534,18 @@ class _PayiInstrumentor:
                 ingest_response = await self._apayi.ingest.units(**ingest_units, extra_headers=extra_headers)
             elif self._payi:
                 ingest_response = self._payi.ingest.units(**ingest_units, extra_headers=extra_headers)
+            elif self._offline_instrumentation is not None:
+                self._offline_ingest_packets.append(ingest_units.copy())
+
+                # simulate a successful ingest for local instrumentation
+                now=datetime.now(timezone.utc)
+                ingest_response = IngestResponse(
+                    event_timestamp=now,
+                    ingest_timestamp=now,
+                    request_id="local_instrumentation",
+                    xproxy_result=XproxyResult(request_id="local_instrumentation"))
+                pass
+                
             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")
@@ -513,10 +555,6 @@ class _PayiInstrumentor:
             if ingest_response:
                 self._process_ingest_units_response(ingest_response)
 
-                if ingest_response and self._log_prompt_and_response and self._prompt_and_response_logger:
-                    request_id = ingest_response.xproxy_result.request_id
-                    self._prompt_and_response_logger(request_id, log_data)  # type: ignore
-
             return ingest_response.xproxy_result
 
         except APIConnectionError as api_ex:
@@ -609,10 +647,8 @@ class _PayiInstrumentor:
 
         self._logger.debug(f"_ingest_units")
 
-        # return early if there are no units to ingest and on a successul ingest request
-        log_data: 'dict[str,str]' = {}
         extra_headers: 'dict[str, str]' = {}
-        self._process_ingest_units(request, log_data=log_data, extra_headers=extra_headers)
+        self._process_ingest_units(request, extra_headers=extra_headers)
 
         try:
             if self._payi:
@@ -624,16 +660,18 @@ class _PayiInstrumentor:
 
                 self._process_ingest_units_response(ingest_response)
 
-                if self._log_prompt_and_response and self._prompt_and_response_logger:
-                    request_id = ingest_response.xproxy_result.request_id
-                    self._prompt_and_response_logger(request_id, log_data)  # type: ignore
-
                 return ingest_response.xproxy_result
             elif self._apayi:
                 # task runs async. aingest_units will invoke the callback and post process
                 sync_response = self._call_aingest_sync(request)
                 self._logger.debug(f"_ingest_units: apayi success ({sync_response})")
                 return sync_response
+            elif self._offline_instrumentation is not None:
+                self._offline_ingest_packets.append(ingest_units.copy())
+
+                # simulate a successful ingest for local instrumentation
+                return XproxyResult(request_id="local_instrumentation")
+
             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")
@@ -661,6 +699,31 @@ class _PayiInstrumentor:
 
         return {}
 
+    @staticmethod
+    def _valid_str_or_none(value: Optional[str], default: Optional[str] = None) -> Optional[str]:
+        if value is None:
+            return default
+        elif len(value) == 0:
+            # an empty string explicitly blocks the default value
+            return None
+        else:
+            return value
+        
+    @staticmethod
+    def _valid_properties_or_none(value: Optional["dict[str, str]"], default: Optional["dict[str, str]"] = None) -> Optional["dict[str, str]"]:
+        if value is None:
+            return default.copy() if default else None
+        elif len(value) == 0:
+            # an empty dictionary explicitly blocks the default value
+            return None
+        elif default:
+            # merge dictionaries, child overrides parent keys
+            merged = default.copy()
+            merged.update(value)
+            return merged
+        else:
+            return value.copy()
+
     def _init_current_context(
         self,
         proxy: Optional[bool] = None,
@@ -671,7 +734,6 @@ class _PayiInstrumentor:
         use_case_step: Optional[str]= None,
         user_id: Optional[str]= None,
         account_name: Optional[str]= None,
-        request_tags: Optional["list[str]"] = None,
         request_properties: Optional["dict[str, str]"] = None,
         use_case_properties: Optional["dict[str, str]"] = None,
         price_as_category: Optional[str] = None,
@@ -689,7 +751,6 @@ class _PayiInstrumentor:
         parent_use_case_name = parent_context.get("use_case_name", None)
         parent_use_case_id = parent_context.get("use_case_id", None)
         parent_use_case_version = parent_context.get("use_case_version", None)
-        parent_use_case_step = parent_context.get("use_case_step", None)
 
         assign_use_case_values = False
 
@@ -721,26 +782,12 @@ class _PayiInstrumentor:
             assign_use_case_values = True
 
         if assign_use_case_values:
-            context["use_case_id"] = use_case_id if use_case_id else parent_use_case_id
-            context["use_case_version"] = use_case_version if use_case_version else parent_use_case_version
-            context["use_case_step"] = use_case_step if use_case_step else parent_use_case_step
+            context["use_case_version"] = use_case_version if use_case_version is not None else parent_use_case_version
+            context["use_case_id"] =  self._valid_str_or_none(use_case_id, parent_use_case_id)
+            context["use_case_step"] = self._valid_str_or_none(use_case_step, None)
 
             parent_use_case_properties = parent_context.get("use_case_properties", None)
-            if use_case_properties is not None:
-                if not use_case_properties:
-                    # an empty dictionary explicitly blocks inheriting from the parent state
-                    context["use_case_properties"] = None
-                else:
-                    if parent_use_case_properties:
-                        # merge dictionaries, child overrides parent keys
-                        merged = parent_use_case_properties.copy()
-                        merged.update(use_case_properties)
-                        context["use_case_properties"] = merged
-                    else:
-                        context["use_case_properties"] = use_case_properties.copy()
-            elif parent_use_case_properties:
-                # use the parent use_case_properties if it exists
-                context["use_case_properties"] = parent_use_case_properties.copy()
+            context["use_case_properties"] = self._valid_properties_or_none(use_case_properties, parent_use_case_properties)
 
         parent_limit_ids = parent_context.get("limit_ids", None)
         if limit_ids is None:
@@ -754,56 +801,13 @@ class _PayiInstrumentor:
             context["limit_ids"] = list(set(limit_ids) | set(parent_limit_ids)) if parent_limit_ids else limit_ids.copy()
 
         parent_user_id = parent_context.get("user_id", None)
-        if user_id is None:
-            # use the parent user_id if it exists
-            context["user_id"] = parent_user_id
-        elif len(user_id) == 0:
-            # caller passing an empty string explicitly blocks inheriting from the parent state
-            context["user_id"] = None
-        else:
-            context["user_id"] = user_id
+        context["user_id"] = self._valid_str_or_none(user_id, parent_user_id)
 
         parent_account_name = parent_context.get("account_name", None)
-        if account_name is None:
-            # use the parent account_name if it exists
-            context["account_name"] = parent_account_name
-        elif len(account_name) == 0:
-            # caller passing an empty string explicitly blocks inheriting from the parent state
-            context["account_name"] = None
-        else:
-            context["account_name"] = account_name
-
-        parent_request_tags = parent_context.get("request_tags", None)
-        if request_tags is not None:
-            if len(request_tags) == 0:
-                # caller passing an empty list explicitly blocks inheriting from the parent state
-                context["request_tags"] = None
-            else:
-                if parent_request_tags:
-                    # union of new and parent lists if the parent context contains request tags
-                    context["request_tags"] = list(set(request_tags) | set(parent_request_tags))
-                else:
-                    context["request_tags"] = request_tags.copy()
-        elif parent_request_tags:
-            # use the parent request_tags if it exists
-            context["request_tags"] = parent_request_tags.copy()
+        context["account_name"] = self._valid_str_or_none(account_name, parent_account_name)
 
         parent_request_properties = parent_context.get("request_properties", None)
-        if request_properties is not None:
-            if not request_properties:
-                # an empty dictionary explicitly blocks inheriting from the parent state
-                context["request_properties"] = None
-            else:
-                if parent_request_properties:
-                    # merge dictionaries, child overrides parent keys
-                    merged = parent_request_properties.copy()
-                    merged.update(request_properties)
-                    context["request_properties"] = merged
-                else:
-                    context["request_properties"] = request_properties.copy()
-        elif parent_request_properties:
-            # use the parent request_properties if it exists
-            context["request_properties"] = parent_request_properties.copy()
+        context["request_properties"] = self._valid_properties_or_none(request_properties, parent_request_properties)
 
         if price_as_category:
             context["price_as_category"] = price_as_category
@@ -822,7 +826,6 @@ class _PayiInstrumentor:
         use_case_version: Optional[int],        
         user_id: Optional[str],
         account_name: Optional[str],
-        request_tags: Optional["list[str]"] = None,
         request_properties: Optional["dict[str, str]"] = None,
         use_case_properties: Optional["dict[str, str]"] = None,
         *args: Any,
@@ -837,7 +840,6 @@ class _PayiInstrumentor:
                 use_case_version=use_case_version,
                 user_id=user_id,
                 account_name=account_name,
-                request_tags=request_tags,
                 request_properties=request_properties,
                 use_case_properties=use_case_properties
             )
@@ -853,7 +855,6 @@ class _PayiInstrumentor:
         use_case_version: Optional[int],        
         user_id: Optional[str],
         account_name: Optional[str],
-        request_tags: Optional["list[str]"] = None,
         request_properties: Optional["dict[str, str]"] = None,
         use_case_properties: Optional["dict[str, str]"] = None,
         *args: Any,
@@ -868,7 +869,6 @@ class _PayiInstrumentor:
                 use_case_version=use_case_version,
                 user_id=user_id,
                 account_name=account_name,
-                request_tags=request_tags,
                 request_properties=request_properties,
                 use_case_properties=use_case_properties)
             return func(*args, **kwargs)
@@ -901,7 +901,8 @@ class _PayiInstrumentor:
     ) -> None:
 
         limit_ids = ingest_extra_headers.pop(PayiHeaderNames.limit_ids, None)
-        request_tags = ingest_extra_headers.pop(PayiHeaderNames.request_tags, None)
+        # pop and ignore the request tags header since it is no longer processed
+        ingest_extra_headers.pop(PayiHeaderNames.request_tags, None)
 
         use_case_name = ingest_extra_headers.pop(PayiHeaderNames.use_case_name, None)
         use_case_id = ingest_extra_headers.pop(PayiHeaderNames.use_case_id, None)
@@ -913,8 +914,6 @@ class _PayiInstrumentor:
 
         if limit_ids:
             request._ingest["limit_ids"] = limit_ids.split(",")
-        if request_tags:
-            request._ingest["request_tags"] = request_tags.split(",")
         if use_case_name:
             request._ingest["use_case_name"] = use_case_name
         if use_case_id:
@@ -1259,7 +1258,6 @@ class _PayiInstrumentor:
 
         context_user_id: Optional[str] = context.get("user_id")
         context_account_name: Optional[str] = context.get("account_name")
-        context_request_tags: Optional[list[str]] = context.get("request_tags")
 
         context_price_as_category: Optional[str] = context.get("price_as_category")
         context_price_as_resource: Optional[str] = context.get("price_as_resource")
@@ -1320,10 +1318,7 @@ class _PayiInstrumentor:
             if context_use_case_version is not None:
                 extra_headers[PayiHeaderNames.use_case_version] = str(context_use_case_version)
             if context_use_case_step is not None:
-                extra_headers[PayiHeaderNames.use_case_step] = str(context_use_case_step)
-
-        if PayiHeaderNames.request_tags not in extra_headers and context_request_tags:
-            extra_headers[PayiHeaderNames.request_tags] = ",".join(context_request_tags)
+                extra_headers[PayiHeaderNames.use_case_step] = context_use_case_step
 
         if PayiHeaderNames.price_as_category not in extra_headers and context_price_as_category:
             extra_headers[PayiHeaderNames.price_as_category] = context_price_as_category
@@ -1730,7 +1725,6 @@ def payi_instrument(
     payi: Optional[Union[Payi, AsyncPayi, 'list[Union[Payi, AsyncPayi]]']] = None,
     instruments: Optional[Set[str]] = None,
     log_prompt_and_response: bool = True,
-    prompt_and_response_logger: Optional[Callable[[str, "dict[str, str]"], None]] = None,
     config: Optional[PayiInstrumentConfig] = None,
     logger: Optional[logging.Logger] = None,
 ) -> None:
@@ -1763,7 +1757,6 @@ def payi_instrument(
         instruments=instruments,
         log_prompt_and_response=log_prompt_and_response,
         logger=logger,
-        prompt_and_response_logger=prompt_and_response_logger,
         global_config=config if config else PayiInstrumentConfig(),
         caller_filename=caller_filename
     )
@@ -1781,6 +1774,7 @@ def track(
     use_case_properties: Optional["dict[str, str]"] = None,
     proxy: Optional[bool] = None,
 ) -> Any:
+    _ = request_tags
 
     def _track(func: Any) -> Any:
         import asyncio
@@ -1801,7 +1795,6 @@ def track(
                     use_case_version,
                     user_id,
                     account_name,
-                    request_tags,
                     request_properties,
                     use_case_properties,
                     *args,
@@ -1825,7 +1818,6 @@ def track(
                     use_case_version,
                     user_id,
                     account_name,
-                    request_tags,
                     request_properties,
                     use_case_properties,
                     *args,
@@ -1865,7 +1857,6 @@ def track_context(
 
     context["user_id"] = user_id
     context["account_name"] = account_name
-    context["request_tags"] = request_tags
 
     context["price_as_category"] = price_as_category
     context["price_as_resource"] = price_as_resource
@@ -1874,6 +1865,8 @@ def track_context(
     context["request_properties"] = request_properties
     context["use_case_properties"] = use_case_properties
 
+    _ = request_tags
+
     return _InternalTrackContext(context)
 
 def get_context() -> PayiContext:

payi/resources/ingest.py

@@ -210,7 +210,7 @@ class IngestResource(SyncAPIResource):
                     "xProxy-UseCase-Step": use_case_step,
                     "xProxy-UseCase-Version": use_case_version_str
                     if is_given(use_case_version)
-                    else omit,
+                    else not_given,
                     "xProxy-User-ID": user_id,
                     "xProxy-Resource-Scope": resource_scope,
                     "xProxy-Account-Name": account_name,
@@ -431,7 +431,7 @@ class AsyncIngestResource(AsyncAPIResource):
                     "xProxy-UseCase-Step": use_case_step,
                     "xProxy-UseCase-Version": use_case_version_str
                     if is_given(use_case_version)
-                    else omit,
+                    else not_given,
                     "xProxy-User-ID": user_id,
                     "xProxy-Resource-Scope": resource_scope,
                 }

{payi-0.1.0a124.dist-info → payi-0.1.0a126.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: payi
-Version: 0.1.0a124
+Version: 0.1.0a126
 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.0a124.dist-info → payi-0.1.0a126.dist-info}/RECORD

@@ -11,7 +11,7 @@ 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=d6xrZDG6rG6opphTN7UVYdEOis3977LrQQgpNtklXZE,7234
-payi/_version.py,sha256=T-Ikoep55l7ywzzFBRHv1OaeOponJgPrlInl-Z5Fm4U,166
+payi/_version.py,sha256=Q_d5ojHOSTeTtbTlwPmPpab5qD4yxOTyShC1FSrNwdk,166
 payi/pagination.py,sha256=k2356QGPOUSjRF2vHpwLBdF6P-2vnQzFfRIJQAHGQ7A,1258
 payi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 payi/_utils/__init__.py,sha256=7fch0GT9zpNnErbciSpUNa-SjTxxjY6kxHxKMOM4AGs,2305
@@ -28,18 +28,18 @@ payi/_utils/_typing.py,sha256=N_5PPuFNsaygbtA_npZd98SVN1LQQvFTKL6bkWPBZGU,4786
 payi/_utils/_utils.py,sha256=0dDqauUbVZEXV0NVl7Bwu904Wwo5eyFCZpQThhFNhyA,12253
 payi/lib/.keep,sha256=wuNrz-5SXo3jJaJOJgz4vFHM41YH_g20F5cRQo0vLes,224
 payi/lib/AnthropicInstrumentor.py,sha256=SI6nzU-eVufHbxV5gxgrZDhx3TewRVnsvtwDuwEG6WU,16484
-payi/lib/BedrockInstrumentor.py,sha256=sbjq5GKBOjjId1cj4x0vHQIGc_JBxewSE08cgvyAD3E,26441
+payi/lib/BedrockInstrumentor.py,sha256=-dF3mk2nsCOrYxeV75eBORxYEJ7Nd1nIJWsy4-2LEHk,27324
 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=OWuMPiW4LdLhj6DSAAy5qZiosVo8DSAuFWGxYpEucoE,7431
 payi/lib/VertexRequest.py,sha256=42F7xCRYY6h3EMUZD1x4-_cwyAcVhnzT9M5zl4KwtE0,11801
-payi/lib/helpers.py,sha256=jcMyxsuWmyPymDCYmDbQAb6IgbkmkiiNUaxeEPkCKZs,4457
-payi/lib/instrument.py,sha256=LX6EqfEGGzIBJKUm0tQDh7ianXzKkbicZltYkHyqTUk,77590
+payi/lib/helpers.py,sha256=6c0RFMS0AYVIxU6q8ak1CDwMTwldIN7N2O2XkxTO7ag,4931
+payi/lib/instrument.py,sha256=eaDtiBx3cuCOB4Pxd1svEOEk6MykB_Dn3JaCJKl8Z6w,76473
 payi/lib/version_helper.py,sha256=v0lC3kuaXn6PBDolE3mkmwJiA8Ot3z4RkVR7wlBuZCs,540
 payi/lib/data/cohere_embed_english_v3.json,sha256=YEWwjml3_i16cdsOx_7UKe6xpVFnxTEhP8T1n54R6gY,718306
 payi/resources/__init__.py,sha256=B2bn1ZfCf6TbHlzZvy5TpFPtALnFcBRPYVKQH3S5qfQ,2457
-payi/resources/ingest.py,sha256=1uniV6wcgkSPmEblAu-pBSjlmPSrzSDNUuffB5cQw18,21284
+payi/resources/ingest.py,sha256=Z8ZWZQW-4v-oGpHLZWRVHDMyyChchh-Hl-lJsn9CDZs,21294
 payi/resources/categories/__init__.py,sha256=WeotN_d-0Ri8ohsrNPbve7RyViD9_N0NA9DrV3WYg3w,1701
 payi/resources/categories/categories.py,sha256=H3Ld1gbb_L39HHHc65-MW7Ocn4hIw0O-jnOLtQVhtlo,20557
 payi/resources/categories/fixed_cost_resources.py,sha256=D0FCR20LDwSFc8eS5kU82j4v1ZhRDiNfU_3XQsMWFY8,7830
@@ -142,7 +142,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=sodtLT84tBmuO_0d-h0CZWCh4vWojJMtUbMjBmEN3IE,492
-payi-0.1.0a124.dist-info/METADATA,sha256=M3cMTfZGJMv8_mVgoa4ZpQyrAqDjPKZgYj3M5M4Z-o8,16324
-payi-0.1.0a124.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
-payi-0.1.0a124.dist-info/licenses/LICENSE,sha256=CQt03aM-P4a3Yg5qBg3JSLVoQS3smMyvx7tYg_6V7Gk,11334
-payi-0.1.0a124.dist-info/RECORD,,
+payi-0.1.0a126.dist-info/METADATA,sha256=HMMB7v-Q7WLRb5x3j2T4MUUB-dI5WtH6Ne0_J1w0ukQ,16324
+payi-0.1.0a126.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+payi-0.1.0a126.dist-info/licenses/LICENSE,sha256=CQt03aM-P4a3Yg5qBg3JSLVoQS3smMyvx7tYg_6V7Gk,11334
+payi-0.1.0a126.dist-info/RECORD,,