mistralai 1.5.2__py3-none-any.whl → 1.6.0__py3-none-any.whl

mistralai_gcp/sdk.py

@@ -1,23 +1,25 @@
-"""Code generated by Speakeasy (https://speakeasyapi.dev). DO NOT EDIT."""
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 import json
-from typing import Optional, Tuple, Union
+import weakref
+from typing import Any, Optional, cast
 
 import google.auth
 import google.auth.credentials
 import google.auth.transport
 import google.auth.transport.requests
 import httpx
+
 from mistralai_gcp import models
 from mistralai_gcp._hooks import BeforeRequestHook, SDKHooks
 from mistralai_gcp.chat import Chat
 from mistralai_gcp.fim import Fim
-from mistralai_gcp.types import Nullable
+from mistralai_gcp.types import UNSET, OptionalNullable
 
 from .basesdk import BaseSDK
-from .httpclient import AsyncHttpClient, HttpClient
+from .httpclient import AsyncHttpClient, ClientOwner, HttpClient, close_clients
 from .sdkconfiguration import SDKConfiguration
-from .utils.logger import Logger, NoOpLogger
+from .utils.logger import Logger, get_default_logger
 from .utils.retries import RetryConfig
 
 LEGACY_MODEL_ID_FORMAT = {
@@ -26,20 +28,21 @@ LEGACY_MODEL_ID_FORMAT = {
     "mistral-nemo-2407": "mistral-nemo@2407",
 }
 
-def get_model_info(model: str) -> Tuple[str, str]:
+
+def get_model_info(model: str) -> tuple[str, str]:
     # if the model requiers the legacy fomat, use it, else do nothing.
     if model in LEGACY_MODEL_ID_FORMAT:
         return "-".join(model.split("-")[:-1]), LEGACY_MODEL_ID_FORMAT[model]
     return model, model
 
 
-
 class MistralGoogleCloud(BaseSDK):
     r"""Mistral AI API: Our Chat Completion and Embeddings APIs specification. Create your account on [La Plateforme](https://console.mistral.ai) to get access and read the [docs](https://docs.mistral.ai) to learn how to use it."""
 
     chat: Chat
+    r"""Chat Completion API."""
     fim: Fim
-    r"""Chat Completion API"""
+    r"""Fill-in-the-middle API."""
 
     def __init__(
         self,
@@ -48,16 +51,20 @@ class MistralGoogleCloud(BaseSDK):
         access_token: Optional[str] = None,
         client: Optional[HttpClient] = None,
         async_client: Optional[AsyncHttpClient] = None,
-        retry_config: Optional[Nullable[RetryConfig]] = None,
+        retry_config: OptionalNullable[RetryConfig] = UNSET,
+        timeout_ms: Optional[int] = None,
         debug_logger: Optional[Logger] = None,
     ) -> None:
         r"""Instantiates the SDK configuring it with the provided parameters.
 
-        :param region: The Google Cloud region to use for all methods
-        :param project_id: The project ID to use for all methods
+        :param api_key: The api_key required for authentication
+        :param server: The server by name to use for all methods
+        :param server_url: The server URL to use for all methods
+        :param url_params: Parameters to optionally template the server URL with
         :param client: The HTTP client to use for all synchronous methods
         :param async_client: The Async HTTP client to use for all asynchronous methods
         :param retry_config: The retry configuration to use for all supported methods
+        :param timeout_ms: Optional request timeout applied to each operation in milliseconds
         """
 
         if not access_token:
@@ -72,36 +79,42 @@ class MistralGoogleCloud(BaseSDK):
                 )
 
             project_id = project_id or loaded_project_id
+
         if project_id is None:
             raise models.SDKError("project_id must be provided")
 
         def auth_token() -> str:
             if access_token:
                 return access_token
+
             credentials.refresh(google.auth.transport.requests.Request())
             token = credentials.token
             if not token:
                 raise models.SDKError("Failed to get token from credentials")
             return token
 
+        client_supplied = True
         if client is None:
             client = httpx.Client()
+            client_supplied = False
 
         assert issubclass(
             type(client), HttpClient
         ), "The provided client must implement the HttpClient protocol."
 
+        async_client_supplied = True
         if async_client is None:
             async_client = httpx.AsyncClient()
+            async_client_supplied = False
 
         if debug_logger is None:
-            debug_logger = NoOpLogger()
+            debug_logger = get_default_logger()
 
         assert issubclass(
             type(async_client), AsyncHttpClient
         ), "The provided async_client must implement the AsyncHttpClient protocol."
 
-        security = None
+        security: Any = None
         if callable(auth_token):
             security = lambda: models.Security(  # pylint: disable=unnecessary-lambda-assignment
                 api_key=auth_token()
@@ -113,23 +126,24 @@ class MistralGoogleCloud(BaseSDK):
             self,
             SDKConfiguration(
                 client=client,
+                client_supplied=client_supplied,
                 async_client=async_client,
+                async_client_supplied=async_client_supplied,
                 security=security,
                 server_url=f"https://{region}-aiplatform.googleapis.com",
                 server=None,
                 retry_config=retry_config,
+                timeout_ms=timeout_ms,
                 debug_logger=debug_logger,
             ),
         )
 
         hooks = SDKHooks()
-
         hook = GoogleCloudBeforeRequestHook(region, project_id)
         hooks.register_before_request_hook(hook)
-
         current_server_url, *_ = self.sdk_configuration.get_server_details()
         server_url, self.sdk_configuration.client = hooks.sdk_init(
-            current_server_url, self.sdk_configuration.client
+            current_server_url, client
         )
         if current_server_url != server_url:
             self.sdk_configuration.server_url = server_url
@@ -137,22 +151,53 @@ class MistralGoogleCloud(BaseSDK):
         # pylint: disable=protected-access
         self.sdk_configuration.__dict__["_hooks"] = hooks
 
+        weakref.finalize(
+            self,
+            close_clients,
+            cast(ClientOwner, self.sdk_configuration),
+            self.sdk_configuration.client,
+            self.sdk_configuration.client_supplied,
+            self.sdk_configuration.async_client,
+            self.sdk_configuration.async_client_supplied,
+        )
+
         self._init_sdks()
 
     def _init_sdks(self):
         self.chat = Chat(self.sdk_configuration)
         self.fim = Fim(self.sdk_configuration)
 
+    def __enter__(self):
+        return self
 
-class GoogleCloudBeforeRequestHook(BeforeRequestHook):
+    async def __aenter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if (
+            self.sdk_configuration.client is not None
+            and not self.sdk_configuration.client_supplied
+        ):
+            self.sdk_configuration.client.close()
+        self.sdk_configuration.client = None
 
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        if (
+            self.sdk_configuration.async_client is not None
+            and not self.sdk_configuration.async_client_supplied
+        ):
+            await self.sdk_configuration.async_client.aclose()
+        self.sdk_configuration.async_client = None
+
+
+class GoogleCloudBeforeRequestHook(BeforeRequestHook):
     def __init__(self, region: str, project_id: str):
         self.region = region
         self.project_id = project_id
 
     def before_request(
         self, hook_ctx, request: httpx.Request
-    ) -> Union[httpx.Request, Exception]:
+    ) -> httpx.Request | Exception:
         # The goal of this function is to template in the region, project and model into the URL path
         # We do this here so that the API remains more user-friendly
         model_id = None
@@ -167,7 +212,6 @@ class GoogleCloudBeforeRequestHook(BeforeRequestHook):
         if model_id == "":
             raise models.SDKError("model must be provided")
 
-
         stream = "streamRawPredict" in request.url.path
         specifier = "streamRawPredict" if stream else "rawPredict"
         url = f"/v1/projects/{self.project_id}/locations/{self.region}/publishers/mistralai/models/{model_id}:{specifier}"

mistralai_gcp/sdkconfiguration.py

@@ -1,6 +1,12 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from ._hooks import SDKHooks
+from ._version import (
+    __gen_version__,
+    __openapi_doc_version__,
+    __user_agent__,
+    __version__,
+)
 from .httpclient import AsyncHttpClient, HttpClient
 from .utils import Logger, RetryConfig, remove_suffix
 from dataclasses import dataclass
@@ -20,17 +26,19 @@ SERVERS = {
 
 @dataclass
 class SDKConfiguration:
-    client: HttpClient
-    async_client: AsyncHttpClient
+    client: Union[HttpClient, None]
+    client_supplied: bool
+    async_client: Union[AsyncHttpClient, None]
+    async_client_supplied: bool
     debug_logger: Logger
     security: Optional[Union[models.Security, Callable[[], models.Security]]] = None
     server_url: Optional[str] = ""
     server: Optional[str] = ""
     language: str = "python"
-    openapi_doc_version: str = "0.0.2"
-    sdk_version: str = "1.2.6"
-    gen_version: str = "2.486.1"
-    user_agent: str = "speakeasy-sdk/python 1.2.6 2.486.1 0.0.2 mistralai-gcp"
+    openapi_doc_version: str = __openapi_doc_version__
+    sdk_version: str = __version__
+    gen_version: str = __gen_version__
+    user_agent: str = __user_agent__
     retry_config: OptionalNullable[RetryConfig] = Field(default_factory=lambda: UNSET)
     timeout_ms: Optional[int] = None
 

mistralai_gcp/utils/__init__.py

@@ -42,6 +42,7 @@ from .values import (
     match_content_type,
     match_status_codes,
     match_response,
+    cast_partial,
 )
 from .logger import Logger, get_body_content, get_default_logger
 
@@ -94,4 +95,5 @@ __all__ = [
     "validate_float",
     "validate_int",
     "validate_open_enum",
+    "cast_partial",
 ]

mistralai_gcp/utils/serializers.py

@@ -7,14 +7,15 @@ import httpx
 from typing_extensions import get_origin
 from pydantic import ConfigDict, create_model
 from pydantic_core import from_json
-from typing_inspect import is_optional_type
+from typing_inspection.typing_objects import is_union
 
 from ..types.basemodel import BaseModel, Nullable, OptionalNullable, Unset
 
 
 def serialize_decimal(as_str: bool):
     def serialize(d):
-        if is_optional_type(type(d)) and d is None:
+        # Optional[T] is a Union[T, None]
+        if is_union(type(d)) and type(None) in get_args(type(d)) and d is None:
             return None
         if isinstance(d, Unset):
             return d
@@ -42,7 +43,8 @@ def validate_decimal(d):
 
 def serialize_float(as_str: bool):
     def serialize(f):
-        if is_optional_type(type(f)) and f is None:
+        # Optional[T] is a Union[T, None]
+        if is_union(type(f)) and type(None) in get_args(type(f)) and f is None:
             return None
         if isinstance(f, Unset):
             return f
@@ -70,7 +72,8 @@ def validate_float(f):
 
 def serialize_int(as_str: bool):
     def serialize(i):
-        if is_optional_type(type(i)) and i is None:
+        # Optional[T] is a Union[T, None]
+        if is_union(type(i)) and type(None) in get_args(type(i)) and i is None:
             return None
         if isinstance(i, Unset):
             return i
@@ -118,7 +121,8 @@ def validate_open_enum(is_int: bool):
 
 def validate_const(v):
     def validate(c):
-        if is_optional_type(type(c)) and c is None:
+        # Optional[T] is a Union[T, None]
+        if is_union(type(c)) and type(None) in get_args(type(c)) and c is None:
             return None
 
         if v != c:
@@ -163,7 +167,7 @@ def marshal_json(val, typ):
     if len(d) == 0:
         return ""
 
-    return json.dumps(d[next(iter(d))], separators=(",", ":"), sort_keys=True)
+    return json.dumps(d[next(iter(d))], separators=(",", ":"))
 
 
 def is_nullable(field):

mistralai_gcp/utils/values.py

@@ -3,8 +3,9 @@
 from datetime import datetime
 from enum import Enum
 from email.message import Message
+from functools import partial
 import os
-from typing import Any, Callable, Dict, List, Optional, Tuple, TypeVar, Union
+from typing import Any, Callable, Dict, List, Optional, Tuple, TypeVar, Union, cast
 
 from httpx import Response
 from pydantic import BaseModel
@@ -51,6 +52,8 @@ def match_status_codes(status_codes: List[str], status_code: int) -> bool:
 
 T = TypeVar("T")
 
+def cast_partial(typ):
+    return partial(cast, typ)
 
 def get_global_from_env(
     value: Optional[T], env_key: str, type_cast: Callable[[str], T]