payi 0.1.0a83__py3-none-any.whl → 0.1.0a85__py3-none-any.whl

payi/lib/GoogleGenAiInstrumentor.py

@@ -1,12 +1,10 @@
 import json
-import math
 from typing import Any, List, Union, Optional, Sequence
 from typing_extensions import override
 
 from wrapt import wrap_function_wrapper  # type: ignore
 
 from payi.lib.helpers import PayiCategories
-from payi.types.ingest_units_params import Units
 
 from .instrument import _ChunkResult, _IsStreaming, _StreamingType, _ProviderRequest, _PayiInstrumentor
 
@@ -115,18 +113,16 @@ async def agenerate_stream_wrapper(
         kwargs,
     )
 
-def count_chars_skip_spaces(text: str) -> int:
-    return sum(1 for c in text if not c.isspace())
-
 class _GoogleGenAiRequest(_ProviderRequest):
     def __init__(self, instrumentor: _PayiInstrumentor):
         super().__init__(
             instrumentor=instrumentor,
             category=PayiCategories.google_vertex,
             streaming_type=_StreamingType.generator,
+            is_google_vertex_or_genai_client=True,
             )
         self._prompt_character_count = 0
-        self._candiates_character_count = 0
+        self._candidates_character_count = 0
 
     @override
     def process_request(self, instance: Any, extra_headers: 'dict[str, str]', args: Sequence[Any], kwargs: Any) -> bool:
@@ -158,6 +154,8 @@ class _GoogleGenAiRequest(_ProviderRequest):
         if isinstance(value, list):
             items = value # type: ignore
 
+        from .VertexInstrumentor import count_chars_skip_spaces
+
         for item in items: # type: ignore
             text = ""
             if isinstance(item, Part):
@@ -249,6 +247,8 @@ class _GoogleGenAiRequest(_ProviderRequest):
 
     @override
     def process_chunk(self, chunk: Any) -> _ChunkResult:
+        from .VertexInstrumentor import vertex_compute_usage, count_chars_skip_spaces
+
         ingest = False
         response_dict: dict[str, Any] = chunk.to_json_dict()
         if "provider_response_id" not in self._ingest:
@@ -260,22 +260,25 @@ class _GoogleGenAiRequest(_ProviderRequest):
 
         self._ingest["resource"] = "google." + model
 
+
         for candidate in response_dict.get("candidates", []):
             parts = candidate.get("content", {}).get("parts", [])
             for part in parts:
-                self._candiates_character_count += count_chars_skip_spaces(part.get("text", ""))
+                self._candidates_character_count += count_chars_skip_spaces(part.get("text", ""))
 
         usage = response_dict.get("usage_metadata", {})
         if usage and "prompt_token_count" in usage and "candidates_token_count" in usage:
-            self._compute_usage(response_dict, streaming_candidates_characters=self._candiates_character_count)
+            vertex_compute_usage(
+                request=self,
+                model=model,
+                response_dict=response_dict,
+                prompt_character_count=self._prompt_character_count,
+                streaming_candidates_characters=self._candidates_character_count
+                )
             ingest = True
 
         return _ChunkResult(send_chunk_to_caller=True, ingest=ingest)
     
-    @staticmethod
-    def _is_character_billing_model(model: str) -> bool:
-        return model.startswith("gemini-1.")
-    
     @override
     def process_synchronous_response(
         self,
@@ -284,6 +287,8 @@ class _GoogleGenAiRequest(_ProviderRequest):
         kwargs: Any) -> Any:
         response_dict = response.to_json_dict()
 
+        from .VertexInstrumentor import vertex_compute_usage
+
         id: Optional[str] = response_dict.get("response_id", None)
         if id:
             self._ingest["provider_response_id"] = id
@@ -292,105 +297,15 @@ class _GoogleGenAiRequest(_ProviderRequest):
         if model:
             self._ingest["resource"] = "google." + model
 
-        self._compute_usage(response_dict)
-        
+        vertex_compute_usage(
+            request=self,
+            model=model,
+            response_dict=response_dict,
+            prompt_character_count=self._prompt_character_count,
+            streaming_candidates_characters=self._candidates_character_count
+            )
+
         if log_prompt_and_response:
             self._ingest["provider_response_json"] = [json.dumps(response_dict)]
 
-        return None
-
-    def add_units(self, key: str, input: Optional[int] = None, output: Optional[int] = None) -> None:
-        if key not in self._ingest["units"]:
-            self._ingest["units"][key] = {}
-        if input is not None:
-            self._ingest["units"][key]["input"] = input
-        if output is not None:
-            self._ingest["units"][key]["output"] = output
-
-    def _compute_usage(self, response_dict: 'dict[str, Any]', streaming_candidates_characters: Optional[int] = None) -> None:
-        usage = response_dict.get("usage_metadata", {})
-        input = usage.get("prompt_token_count", 0)
-
-        prompt_tokens_details: list[dict[str, Any]] = usage.get("prompt_tokens_details", [])
-        candidates_tokens_details: list[dict[str, Any]] = usage.get("candidates_tokens_details", [])
-
-        model: str = response_dict.get("model_version", "")
-        
-        # for character billing only
-        large_context = "" if input < 128000 else "_large_context"
-
-        if self._is_character_billing_model(model):
-            for details in prompt_tokens_details:
-                modality = details.get("modality", "")
-                if not modality:
-                    continue
-
-                modality_token_count = details.get("token_count", 0)
-                if modality == "TEXT":
-                    input = self._prompt_character_count
-                    if input == 0:
-                        # back up calc if nothing was calculated from the prompt
-                        input = response_dict["usage_metadata"]["prompt_token_count"] * 4
-
-                    output = 0
-                    if streaming_candidates_characters is None:
-                        for candidate in response_dict.get("candidates", []):
-                            parts = candidate.get("content", {}).get("parts", [])
-                            for part in parts:
-                                output += count_chars_skip_spaces(part.get("text", ""))
-
-                        if output == 0:
-                            # back up calc if no parts
-                            output = response_dict["usage_metadata"]["candidates_token_count"] * 4
-                    else:
-                        output = streaming_candidates_characters
-
-                    self._ingest["units"]["text"+large_context] = Units(input=input, output=output)
-
-                elif modality == "IMAGE":
-                    num_images = math.ceil(modality_token_count / 258)
-                    self.add_units("vision"+large_context, input=num_images)
-
-                elif modality == "VIDEO":
-                    video_seconds = math.ceil(modality_token_count / 285)
-                    self.add_units("video"+large_context, input=video_seconds)
-
-                elif modality == "AUDIO":
-                    audio_seconds = math.ceil(modality_token_count / 25)
-                    self.add_units("audio"+large_context, input=audio_seconds)
-
-        else:
-            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":
-                    self.add_units("vision", input=modality_token_count)
-                elif modality in ("VIDEO", "AUDIO", "TEXT"):
-                    self.add_units(modality.lower(), 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"):
-                    self.add_units(modality.lower(), output=modality_token_count)
-
-        if not self._ingest["units"]:
-            input = usage.get("prompt_token_count", 0)
-            output = usage.get("candidates_token_count", 0) * 4
-            
-            if self._is_character_billing_model(model):
-                if self._prompt_character_count > 0:
-                    input = self._prompt_character_count
-                else:
-                    input *= 4
-
-                # if no units were added, add a default unit and assume 4 characters per token
-                self._ingest["units"]["text"+large_context] = Units(input=input, output=output)
-            else:
-                # if no units were added, add a default unit
-                self._ingest["units"]["text"] = Units(input=input, output=output)
+        return None

payi/lib/VertexInstrumentor.py

@@ -94,9 +94,10 @@ class _GoogleVertexRequest(_ProviderRequest):
             instrumentor=instrumentor,
             category=PayiCategories.google_vertex,
             streaming_type=_StreamingType.generator,
+            is_google_vertex_or_genai_client=True,
             )
         self._prompt_character_count = 0
-        self._candiates_character_count = 0
+        self._candidates_character_count = 0
         self._model_name: Optional[str] = None
 
     @override
@@ -227,19 +228,21 @@ class _GoogleVertexRequest(_ProviderRequest):
         for candidate in response_dict.get("candidates", []):
             parts = candidate.get("content", {}).get("parts", [])
             for part in parts:
-                self._candiates_character_count += count_chars_skip_spaces(part.get("text", ""))
+                self._candidates_character_count += count_chars_skip_spaces(part.get("text", ""))
 
         usage = response_dict.get("usage_metadata", {})
         if usage and "prompt_token_count" in usage and "candidates_token_count" in usage:
-            self._compute_usage(response_dict, streaming_candidates_characters=self._candiates_character_count)
+            vertex_compute_usage(
+                request=self,
+                model=self._get_model_name(response_dict),
+                response_dict=response_dict,
+                prompt_character_count=self._prompt_character_count,
+                streaming_candidates_characters=self._candidates_character_count,
+            )
             ingest = True
 
         return _ChunkResult(send_chunk_to_caller=True, ingest=ingest)
     
-    @staticmethod
-    def _is_character_billing_model(model: str) -> bool:
-        return model.startswith("gemini-1.")
-    
     @override
     def process_synchronous_response(
         self,
@@ -256,108 +259,139 @@ class _GoogleVertexRequest(_ProviderRequest):
         if model:
             self._ingest["resource"] = "google." + model
 
-        self._compute_usage(response_dict)
+        vertex_compute_usage(
+            request=self,
+            model=model,
+            response_dict=response_dict,
+            prompt_character_count=self._prompt_character_count,
+            streaming_candidates_characters=self._candidates_character_count
+            )
         
         if log_prompt_and_response:
             self._ingest["provider_response_json"] = [json.dumps(response_dict)]
 
         return None
 
-    def add_units(self, key: str, input: Optional[int] = None, output: Optional[int] = None) -> None:
-        if key not in self._ingest["units"]:
-            self._ingest["units"][key] = {}
+def vertex_compute_usage(
+    request: _ProviderRequest,
+    model: Optional[str],
+    response_dict: 'dict[str, Any]',
+    prompt_character_count: int = 0,
+    streaming_candidates_characters: Optional[int] = None) -> None:
+
+    def is_character_billing_model(model: str) -> bool:
+        return model.startswith("gemini-1.")
+
+    def is_large_context_token_model(model: str, input_tokens: int) -> bool:
+        return model.startswith("gemini-2.5-pro") and input_tokens > 200_000
+
+    def add_units(request: _ProviderRequest, key: str, input: Optional[int] = None, output: Optional[int] = None) -> None:
+        if key not in request._ingest["units"]:
+            request._ingest["units"][key] = {}
         if input is not None:
-            self._ingest["units"][key]["input"] = input
+            request._ingest["units"][key]["input"] = input
         if output is not None:
-            self._ingest["units"][key]["output"] = output
-
-    def _compute_usage(self, response_dict: 'dict[str, Any]', streaming_candidates_characters: Optional[int] = None) -> None:
-        usage = response_dict.get("usage_metadata", {})
-        input = usage.get("prompt_token_count", 0)
+            request._ingest["units"][key]["output"] = output
 
-        prompt_tokens_details: list[dict[str, Any]] = usage.get("prompt_tokens_details", [])
-        candidates_tokens_details: list[dict[str, Any]] = usage.get("candidates_tokens_details", [])
+    usage = response_dict.get("usage_metadata", {})
+    input = usage.get("prompt_token_count", 0)
 
-        model: Optional[str] = self._get_model_name(response_dict)
-        if not model:
-            model = ""
-        
-        # for character billing only
-        large_context = "" if input < 128000 else "_large_context"
-
-        if self._is_character_billing_model(model):
-            # gemini 1.0 and 1.5 units are reported in characters, per second, per image, etc...
-            for details in prompt_tokens_details:
-                modality = details.get("modality", "")
-                if not modality:
-                    continue
-
-                modality_token_count = details.get("token_count", 0)
-                if modality == "TEXT":
-                    input = self._prompt_character_count
-                    if input == 0:
-                        # back up calc if nothing was calculated from the prompt
-                        input = response_dict["usage_metadata"]["prompt_token_count"] * 4
-
-                    output = 0
-                    if streaming_candidates_characters is None:
-                        for candidate in response_dict.get("candidates", []):
-                            parts = candidate.get("content", {}).get("parts", [])
-                            for part in parts:
-                                output += count_chars_skip_spaces(part.get("text", ""))
-
-                        if output == 0:
-                            # back up calc if no parts
-                            output = response_dict["usage_metadata"]["candidates_token_count"] * 4
-                    else:
-                        output = streaming_candidates_characters
-
-                    self._ingest["units"]["text"+large_context] = Units(input=input, output=output)
-
-                elif modality == "IMAGE":
-                    num_images = math.ceil(modality_token_count / 258)
-                    self.add_units("vision"+large_context, input=num_images)
-
-                elif modality == "VIDEO":
-                    video_seconds = math.ceil(modality_token_count / 285)
-                    self.add_units("video"+large_context, input=video_seconds)
-
-                elif modality == "AUDIO":
-                    audio_seconds = math.ceil(modality_token_count / 25)
-                    self.add_units("audio"+large_context, input=audio_seconds)
+    prompt_tokens_details: list[dict[str, Any]] = usage.get("prompt_tokens_details", [])
+    candidates_tokens_details: list[dict[str, Any]] = usage.get("candidates_tokens_details", [])
 
-        else:
-            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":
-                    self.add_units("vision", input=modality_token_count)
-                elif modality in ("VIDEO", "AUDIO", "TEXT"):
-                    self.add_units(modality.lower(), 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"):
-                    self.add_units(modality.lower(), output=modality_token_count)
-
-        if not self._ingest["units"]:
-            input = usage.get("prompt_token_count", 0)
-            output = usage.get("candidates_token_count", 0) * 4
-            
-            if self._is_character_billing_model(model):
-                if self._prompt_character_count > 0:
-                    input = self._prompt_character_count
+    if not model:
+        model = ""
+    
+    large_context = ""
+
+    if is_character_billing_model(model):
+        if input > 128000: 
+            large_context = "_large_context"
+
+        # gemini 1.0 and 1.5 units are reported in characters, per second, per image, etc...
+        for details in prompt_tokens_details:
+            modality = details.get("modality", "")
+            if not modality:
+                continue
+
+            modality_token_count = details.get("token_count", 0)
+            if modality == "TEXT":
+                input = prompt_character_count
+                if input == 0:
+                    # back up calc if nothing was calculated from the prompt
+                    input = response_dict["usage_metadata"]["prompt_token_count"] * 4
+
+                output = 0
+                if streaming_candidates_characters is None:
+                    for candidate in response_dict.get("candidates", []):
+                        parts = candidate.get("content", {}).get("parts", [])
+                        for part in parts:
+                            output += count_chars_skip_spaces(part.get("text", ""))
+
+                    if output == 0:
+                        # back up calc if no parts
+                        output = response_dict["usage_metadata"]["candidates_token_count"] * 4
                 else:
-                    input *= 4
+                    output = streaming_candidates_characters
 
-                # if no units were added, add a default unit and assume 4 characters per token
-                self._ingest["units"]["text"+large_context] = Units(input=input, output=output)
+                request._ingest["units"]["text"+large_context] = Units(input=input, output=output)
+
+            elif modality == "IMAGE":
+                num_images = math.ceil(modality_token_count / 258)
+                add_units(request, "vision"+large_context, input=num_images)
+
+            elif modality == "VIDEO":
+                video_seconds = math.ceil(modality_token_count / 285)
+                add_units(request, "video"+large_context, input=video_seconds)
+
+            elif modality == "AUDIO":
+                audio_seconds = math.ceil(modality_token_count / 25)
+                add_units(request, "audio"+large_context, input=audio_seconds)
+
+        # No need to gover the candidates_tokens_details as all the character based 1.x models only output TEXT
+        # for details in candidates_tokens_details:
+
+    else:
+        # thinking tokens introduced in 2.5 after the transition to token based billing
+        thinking_token_count = usage.get("thoughts_token_count", 0)
+
+        if is_large_context_token_model(model, input):
+            large_context = "_large_context"
+
+        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(request, "vision"+large_context, input=modality_token_count)
+            elif modality in ("VIDEO", "AUDIO", "TEXT"):
+                add_units(request, 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(request, modality.lower()+large_context, output=modality_token_count)
+
+        if thinking_token_count > 0:
+            add_units(request, "reasoning"+large_context, output=thinking_token_count)
+
+    if not request._ingest["units"]:
+        input = usage.get("prompt_token_count", 0)
+        output = usage.get("candidates_token_count", 0) * 4
+        
+        if is_character_billing_model(model):
+            if prompt_character_count > 0:
+                input = prompt_character_count
             else:
-                # if no units were added, add a default unit
-                self._ingest["units"]["text"] = Units(input=input, output=output)
+                input *= 4
+
+            # if no units were added, add a default unit and assume 4 characters per token
+            request._ingest["units"]["text"+large_context] = Units(input=input, output=output)
+        else:
+            # if no units were added, add a default unit
+            request._ingest["units"]["text"] = Units(input=input, output=output)

payi/lib/instrument.py

@@ -35,12 +35,20 @@ class _ChunkResult:
     ingest: bool = False
     
 class _ProviderRequest:
-    def __init__(self, instrumentor: '_PayiInstrumentor', category: str, streaming_type: '_StreamingType'):
+    def __init__(
+            self, instrumentor: '_PayiInstrumentor',
+            category: str,
+            streaming_type: '_StreamingType',
+            is_aws_client: Optional[bool] = None,
+            is_google_vertex_or_genai_client: Optional[bool] = None,
+            ) -> None:
         self._instrumentor: '_PayiInstrumentor' = instrumentor
         self._estimated_prompt_tokens: Optional[int] = None
         self._category: str = category
         self._ingest: IngestUnitsParams = { "category": category, "units": {} } # type: ignore
         self._streaming_type: '_StreamingType' = streaming_type
+        self._is_aws_client: Optional[bool] = is_aws_client
+        self._is_google_vertex_or_genai_client: Optional[bool] = is_google_vertex_or_genai_client
 
     def process_chunk(self, _chunk: Any) -> _ChunkResult:
         return _ChunkResult(send_chunk_to_caller=True)
@@ -55,16 +63,25 @@ class _ProviderRequest:
     def process_request_prompt(self, prompt: 'dict[str, Any]', args: Sequence[Any], kwargs: 'dict[str, Any]') -> None:
         ...
     
-    def is_bedrock(self) -> bool:
-        return self._category == PayiCategories.aws_bedrock
+    def process_initial_stream_response(self, response: Any) -> None:
+        pass
+
+    @property
+    def is_aws_client(self) -> bool:
+        return self._is_aws_client if self._is_aws_client is not None else False
+
+    @property
+    def is_google_vertex_or_genai_client(self) -> bool:
+        return self._is_google_vertex_or_genai_client if self._is_google_vertex_or_genai_client is not None else False
 
-    def is_vertex(self) -> bool:
-        return self._category == PayiCategories.google_vertex 
-       
     def process_exception(self, exception: Exception, kwargs: Any, ) -> bool: # noqa: ARG002
         self.exception_to_semantic_failure(exception)
         return True
     
+    @property
+    def supports_extra_headers(self) -> bool:
+        return not self.is_aws_client and not self.is_google_vertex_or_genai_client
+    
     @property
     def streaming_type(self) -> '_StreamingType':
         return self._streaming_type
@@ -277,6 +294,22 @@ class _PayiInstrumentor:
         except Exception as e:
             self._logger.error(f"Error instrumenting Google GenAi: {e}")
 
+    @staticmethod
+    def _create_logged_ingest_units(
+        ingest_units: IngestUnitsParams,
+    ) -> IngestUnitsParams:
+        # remove large and potentially sensitive data from the log
+        log_ingest_units: IngestUnitsParams = ingest_units.copy()
+        
+        log_ingest_units.pop('provider_request_json', None)
+        log_ingest_units.pop('provider_response_json', None)
+
+        # Pop system.stack_trace from properties if it exists
+        if 'properties' in log_ingest_units and isinstance(log_ingest_units['properties'], dict):
+            log_ingest_units['properties'].pop('system.stack_trace', None)
+
+        return log_ingest_units
+        
     def _process_ingest_units(self, ingest_units: IngestUnitsParams, log_data: 'dict[str, str]') -> bool:
         if int(ingest_units.get("http_status_code") or 0) < 400:
             units = ingest_units.get("units", {})
@@ -327,6 +360,9 @@ class _PayiInstrumentor:
             return None
 
         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)
             elif self._payi:
@@ -399,6 +435,9 @@ class _PayiInstrumentor:
 
         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)
                 self._logger.debug(f"_ingest_units: success ({ingest_response})")
 
@@ -806,8 +845,7 @@ class _PayiInstrumentor:
         context = self.get_context()
 
         if not context:
-            if request.is_bedrock():
-                # boto3 doesn't allow extra_headers
+            if not request.supports_extra_headers:
                 kwargs.pop("extra_headers", None)
 
             self._logger.debug(f"invoke_wrapper: no instrumentation context, exit early")
@@ -822,8 +860,7 @@ class _PayiInstrumentor:
         self._update_extra_headers(context, extra_headers)
 
         if context.get("proxy", self._proxy_default):
-            if request.is_bedrock():
-                # boto3 doesn't allow extra_headers
+            if not request.supports_extra_headers:
                 kwargs.pop("extra_headers", None)
             elif "extra_headers" not in kwargs and extra_headers:
                 # assumes anthropic and openai clients
@@ -899,7 +936,7 @@ class _PayiInstrumentor:
                     request=request,
                 )
 
-                if request.is_bedrock():
+                if request.is_aws_client:
                     if "body" in response:
                         response["body"] = stream_result
                     else:
@@ -1084,9 +1121,10 @@ class _StreamIteratorWrapper(ObjectProxy):  # type: ignore
 
         instrumentor._logger.debug(f"StreamIteratorWrapper: instance {instance}, category {request._category}")
 
+        request.process_initial_stream_response(response)
+
         bedrock_from_stream: bool = False
-        if request.is_bedrock():
-            request._ingest["provider_response_id"] = response["ResponseMetadata"]["RequestId"]
+        if request.is_aws_client:
             stream = response.get("stream", None)
 
             if stream:
@@ -1108,7 +1146,6 @@ class _StreamIteratorWrapper(ObjectProxy):  # type: ignore
         self._request: _ProviderRequest = request
 
         self._first_token: bool = True
-        self._is_bedrock: bool = request.is_bedrock()
         self._bedrock_from_stream: bool = bedrock_from_stream
         self._ingested: bool = False
         self._iter_started: bool = False
@@ -1131,7 +1168,7 @@ class _StreamIteratorWrapper(ObjectProxy):  # type: ignore
 
     def __iter__(self) -> Any:  
         self._iter_started = True
-        if self._is_bedrock:
+        if self._request.is_aws_client:
             # MUST reside in a separate function so that the yield statement (e.g. the generator) doesn't implicitly return its own iterator and overriding self
             self._instrumentor._logger.debug(f"StreamIteratorWrapper: bedrock __iter__")
             return self._iter_bedrock()

payi/resources/categories/__init__.py

@@ -16,6 +16,14 @@ from .categories import (
     CategoriesResourceWithStreamingResponse,
     AsyncCategoriesResourceWithStreamingResponse,
 )
+from .fixed_cost_resources import (
+    FixedCostResourcesResource,
+    AsyncFixedCostResourcesResource,
+    FixedCostResourcesResourceWithRawResponse,
+    AsyncFixedCostResourcesResourceWithRawResponse,
+    FixedCostResourcesResourceWithStreamingResponse,
+    AsyncFixedCostResourcesResourceWithStreamingResponse,
+)
 
 __all__ = [
     "ResourcesResource",
@@ -24,6 +32,12 @@ __all__ = [
     "AsyncResourcesResourceWithRawResponse",
     "ResourcesResourceWithStreamingResponse",
     "AsyncResourcesResourceWithStreamingResponse",
+    "FixedCostResourcesResource",
+    "AsyncFixedCostResourcesResource",
+    "FixedCostResourcesResourceWithRawResponse",
+    "AsyncFixedCostResourcesResourceWithRawResponse",
+    "FixedCostResourcesResourceWithStreamingResponse",
+    "AsyncFixedCostResourcesResourceWithStreamingResponse",
     "CategoriesResource",
     "AsyncCategoriesResource",
     "CategoriesResourceWithRawResponse",