mistralai 1.10.0__py3-none-any.whl → 1.11.1__py3-none-any.whl

mistralai_azure/utils/enums.py

@@ -2,6 +2,10 @@
 
 import enum
 import sys
+from typing import Any
+
+from pydantic_core import core_schema
+
 
 class OpenEnumMeta(enum.EnumMeta):
     # The __call__ method `boundary` kwarg was added in 3.11 and must be present
@@ -72,3 +76,59 @@ class OpenEnumMeta(enum.EnumMeta):
                 )
             except ValueError:
                 return value
+
+    def __new__(mcs, name, bases, namespace, **kwargs):
+        cls = super().__new__(mcs, name, bases, namespace, **kwargs)
+
+        # Add __get_pydantic_core_schema__ to make open enums work correctly
+        # in union discrimination. In strict mode (used by Pydantic for unions),
+        # only known enum values match. In lax mode, unknown values are accepted.
+        def __get_pydantic_core_schema__(
+            cls_inner: Any, _source_type: Any, _handler: Any
+        ) -> core_schema.CoreSchema:
+            # Create a validator that only accepts known enum values (for strict mode)
+            def validate_strict(v: Any) -> Any:
+                if isinstance(v, cls_inner):
+                    return v
+                # Use the parent EnumMeta's __call__ which raises ValueError for unknown values
+                return enum.EnumMeta.__call__(cls_inner, v)
+
+            # Create a lax validator that accepts unknown values
+            def validate_lax(v: Any) -> Any:
+                if isinstance(v, cls_inner):
+                    return v
+                try:
+                    return enum.EnumMeta.__call__(cls_inner, v)
+                except ValueError:
+                    # Return the raw value for unknown enum values
+                    return v
+
+            # Determine the base type schema (str or int)
+            is_int_enum = False
+            for base in cls_inner.__mro__:
+                if base is int:
+                    is_int_enum = True
+                    break
+                if base is str:
+                    break
+
+            base_schema = (
+                core_schema.int_schema()
+                if is_int_enum
+                else core_schema.str_schema()
+            )
+
+            # Use lax_or_strict_schema:
+            # - strict mode: only known enum values match (raises ValueError for unknown)
+            # - lax mode: accept any value, return enum member or raw value
+            return core_schema.lax_or_strict_schema(
+                lax_schema=core_schema.chain_schema(
+                    [base_schema, core_schema.no_info_plain_validator_function(validate_lax)]
+                ),
+                strict_schema=core_schema.chain_schema(
+                    [base_schema, core_schema.no_info_plain_validator_function(validate_strict)]
+                ),
+            )
+
+        setattr(cls, "__get_pydantic_core_schema__", classmethod(__get_pydantic_core_schema__))
+        return cls

mistralai_azure/utils/eventstreaming.py

@@ -17,6 +17,9 @@ T = TypeVar("T")
 
 
 class EventStream(Generic[T]):
+    # Holds a reference to the SDK client to avoid it being garbage collected
+    # and cause termination of the underlying httpx client.
+    client_ref: Optional[object]
     response: httpx.Response
     generator: Generator[T, None, None]
 
@@ -25,9 +28,11 @@ class EventStream(Generic[T]):
         response: httpx.Response,
         decoder: Callable[[str], T],
         sentinel: Optional[str] = None,
+        client_ref: Optional[object] = None,
     ):
         self.response = response
         self.generator = stream_events(response, decoder, sentinel)
+        self.client_ref = client_ref
 
     def __iter__(self):
         return self
@@ -43,6 +48,9 @@ class EventStream(Generic[T]):
 
 
 class EventStreamAsync(Generic[T]):
+    # Holds a reference to the SDK client to avoid it being garbage collected
+    # and cause termination of the underlying httpx client.
+    client_ref: Optional[object]
     response: httpx.Response
     generator: AsyncGenerator[T, None]
 
@@ -51,9 +59,11 @@ class EventStreamAsync(Generic[T]):
         response: httpx.Response,
         decoder: Callable[[str], T],
         sentinel: Optional[str] = None,
+        client_ref: Optional[object] = None,
     ):
         self.response = response
         self.generator = stream_events_async(response, decoder, sentinel)
+        self.client_ref = client_ref
 
     def __aiter__(self):
         return self

mistralai_azure/utils/forms.py

@@ -142,16 +142,21 @@ def serialize_multipart_form(
         if field_metadata.file:
             if isinstance(val, List):
                 # Handle array of files
+                array_field_name = f_name + "[]"
                 for file_obj in val:
                     if not _is_set(file_obj):
                         continue
-                        
-                    file_name, content, content_type = _extract_file_properties(file_obj)
+
+                    file_name, content, content_type = _extract_file_properties(
+                        file_obj
+                    )
 
                     if content_type is not None:
-                        files.append((f_name + "[]", (file_name, content, content_type)))
+                        files.append(
+                            (array_field_name, (file_name, content, content_type))
+                        )
                     else:
-                        files.append((f_name + "[]", (file_name, content)))
+                        files.append((array_field_name, (file_name, content)))
             else:
                 # Handle single file
                 file_name, content, content_type = _extract_file_properties(val)
@@ -161,11 +166,16 @@ def serialize_multipart_form(
                 else:
                     files.append((f_name, (file_name, content)))
         elif field_metadata.json:
-            files.append((f_name, (
-                None,
-                marshal_json(val, request_field_types[name]),
-                "application/json",
-            )))
+            files.append(
+                (
+                    f_name,
+                    (
+                        None,
+                        marshal_json(val, request_field_types[name]),
+                        "application/json",
+                    ),
+                )
+            )
         else:
             if isinstance(val, List):
                 values = []
@@ -175,7 +185,8 @@ def serialize_multipart_form(
                         continue
                     values.append(_val_to_string(value))
 
-                form[f_name + "[]"] = values
+                array_field_name = f_name + "[]"
+                form[array_field_name] = values
             else:
                 form[f_name] = _val_to_string(val)
     return media_type, form, files

mistralai_azure/utils/queryparams.py

@@ -27,12 +27,13 @@ from .forms import _populate_form
 def get_query_params(
     query_params: Any,
     gbls: Optional[Any] = None,
+    allow_empty_value: Optional[List[str]] = None,
 ) -> Dict[str, List[str]]:
     params: Dict[str, List[str]] = {}
 
-    globals_already_populated = _populate_query_params(query_params, gbls, params, [])
+    globals_already_populated = _populate_query_params(query_params, gbls, params, [], allow_empty_value)
     if _is_set(gbls):
-        _populate_query_params(gbls, None, params, globals_already_populated)
+        _populate_query_params(gbls, None, params, globals_already_populated, allow_empty_value)
 
     return params
 
@@ -42,6 +43,7 @@ def _populate_query_params(
     gbls: Any,
     query_param_values: Dict[str, List[str]],
     skip_fields: List[str],
+    allow_empty_value: Optional[List[str]] = None,
 ) -> List[str]:
     globals_already_populated: List[str] = []
 
@@ -69,6 +71,16 @@ def _populate_query_params(
             globals_already_populated.append(name)
 
         f_name = field.alias if field.alias is not None else name
+
+        allow_empty_set = set(allow_empty_value or [])
+        should_include_empty = f_name in allow_empty_set and (
+            value is None or value == [] or value == ""
+        )
+
+        if should_include_empty:
+            query_param_values[f_name] = [""]
+            continue
+
         serialization = metadata.serialization
         if serialization is not None:
             serialized_parms = _get_serialized_params(

mistralai_azure/utils/requestbodies.py

@@ -44,15 +44,15 @@ def serialize_request_body(
 
     serialized_request_body = SerializedRequestBody(media_type)
 
-    if re.match(r"(application|text)\/.*?\+*json.*", media_type) is not None:
+    if re.match(r"^(application|text)\/([^+]+\+)*json.*", media_type) is not None:
         serialized_request_body.content = marshal_json(request_body, request_body_type)
-    elif re.match(r"multipart\/.*", media_type) is not None:
+    elif re.match(r"^multipart\/.*", media_type) is not None:
         (
             serialized_request_body.media_type,
             serialized_request_body.data,
             serialized_request_body.files,
         ) = serialize_multipart_form(media_type, request_body)
-    elif re.match(r"application\/x-www-form-urlencoded.*", media_type) is not None:
+    elif re.match(r"^application\/x-www-form-urlencoded.*", media_type) is not None:
         serialized_request_body.data = serialize_form_data(request_body)
     elif isinstance(request_body, (bytes, bytearray, io.BytesIO, io.BufferedReader)):
         serialized_request_body.content = request_body

mistralai_azure/utils/retries.py

@@ -3,7 +3,9 @@
 import asyncio
 import random
 import time
-from typing import List
+from datetime import datetime
+from email.utils import parsedate_to_datetime
+from typing import List, Optional
 
 import httpx
 
@@ -51,9 +53,11 @@ class Retries:
 
 class TemporaryError(Exception):
     response: httpx.Response
+    retry_after: Optional[int]
 
     def __init__(self, response: httpx.Response):
         self.response = response
+        self.retry_after = _parse_retry_after_header(response)
 
 
 class PermanentError(Exception):
@@ -63,6 +67,62 @@ class PermanentError(Exception):
         self.inner = inner
 
 
+def _parse_retry_after_header(response: httpx.Response) -> Optional[int]:
+    """Parse Retry-After header from response.
+
+    Returns:
+        Retry interval in milliseconds, or None if header is missing or invalid.
+    """
+    retry_after_header = response.headers.get("retry-after")
+    if not retry_after_header:
+        return None
+
+    try:
+        seconds = float(retry_after_header)
+        return round(seconds * 1000)
+    except ValueError:
+        pass
+
+    try:
+        retry_date = parsedate_to_datetime(retry_after_header)
+        delta = (retry_date - datetime.now(retry_date.tzinfo)).total_seconds()
+        return round(max(0, delta) * 1000)
+    except (ValueError, TypeError):
+        pass
+
+    return None
+
+
+def _get_sleep_interval(
+    exception: Exception,
+    initial_interval: int,
+    max_interval: int,
+    exponent: float,
+    retries: int,
+) -> float:
+    """Get sleep interval for retry with exponential backoff.
+
+    Args:
+        exception: The exception that triggered the retry.
+        initial_interval: Initial retry interval in milliseconds.
+        max_interval: Maximum retry interval in milliseconds.
+        exponent: Base for exponential backoff calculation.
+        retries: Current retry attempt count.
+
+    Returns:
+        Sleep interval in seconds.
+    """
+    if (
+        isinstance(exception, TemporaryError)
+        and exception.retry_after is not None
+        and exception.retry_after > 0
+    ):
+        return exception.retry_after / 1000
+
+    sleep = (initial_interval / 1000) * exponent**retries + random.uniform(0, 1)
+    return min(sleep, max_interval / 1000)
+
+
 def retry(func, retries: Retries):
     if retries.config.strategy == "backoff":
 
@@ -183,8 +243,10 @@ def retry_with_backoff(
                     return exception.response
 
                 raise
-            sleep = (initial_interval / 1000) * exponent**retries + random.uniform(0, 1)
-            sleep = min(sleep, max_interval / 1000)
+
+            sleep = _get_sleep_interval(
+                exception, initial_interval, max_interval, exponent, retries
+            )
             time.sleep(sleep)
             retries += 1
 
@@ -211,7 +273,9 @@ async def retry_with_backoff_async(
                     return exception.response
 
                 raise
-            sleep = (initial_interval / 1000) * exponent**retries + random.uniform(0, 1)
-            sleep = min(sleep, max_interval / 1000)
+
+            sleep = _get_sleep_interval(
+                exception, initial_interval, max_interval, exponent, retries
+            )
             await asyncio.sleep(sleep)
             retries += 1

mistralai_azure/utils/serializers.py

@@ -102,26 +102,6 @@ def validate_int(b):
     return int(b)
 
 
-def validate_open_enum(is_int: bool):
-    def validate(e):
-        if e is None:
-            return None
-
-        if isinstance(e, Unset):
-            return e
-
-        if is_int:
-            if not isinstance(e, int):
-                raise ValueError("Expected int")
-        else:
-            if not isinstance(e, str):
-                raise ValueError("Expected string")
-
-        return e
-
-    return validate
-
-
 def validate_const(v):
     def validate(c):
         # Optional[T] is a Union[T, None]
@@ -192,7 +172,9 @@ def is_union(obj: object) -> bool:
     """
     Returns True if the given object is a typing.Union or typing_extensions.Union.
     """
-    return any(obj is typing_obj for typing_obj in _get_typing_objects_by_name_of("Union"))
+    return any(
+        obj is typing_obj for typing_obj in _get_typing_objects_by_name_of("Union")
+    )
 
 
 def stream_to_text(stream: httpx.Response) -> str:
@@ -245,4 +227,3 @@ def _get_typing_objects_by_name_of(name: str) -> Tuple[Any, ...]:
             f"Neither typing nor typing_extensions has an object called {name!r}"
         )
     return result
-

mistralai_azure/utils/unmarshal_json_response.py

@@ -0,0 +1,38 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from typing import Any, Optional, Type, TypeVar, overload
+
+import httpx
+
+from .serializers import unmarshal_json
+from mistralai_azure import models
+
+T = TypeVar("T")
+
+
+@overload
+def unmarshal_json_response(
+    typ: Type[T], http_res: httpx.Response, body: Optional[str] = None
+) -> T: ...
+
+
+@overload
+def unmarshal_json_response(
+    typ: Any, http_res: httpx.Response, body: Optional[str] = None
+) -> Any: ...
+
+
+def unmarshal_json_response(
+    typ: Any, http_res: httpx.Response, body: Optional[str] = None
+) -> Any:
+    if body is None:
+        body = http_res.text
+    try:
+        return unmarshal_json(body, typ)
+    except Exception as e:
+        raise models.ResponseValidationError(
+            "Response validation failed",
+            http_res,
+            e,
+            body,
+        ) from e

mistralai_gcp/_hooks/types.py

@@ -3,10 +3,12 @@
 from abc import ABC, abstractmethod
 import httpx
 from mistralai_gcp.httpclient import HttpClient
+from mistralai_gcp.sdkconfiguration import SDKConfiguration
 from typing import Any, Callable, List, Optional, Tuple, Union
 
 
 class HookContext:
+    config: SDKConfiguration
     base_url: str
     operation_id: str
     oauth2_scopes: Optional[List[str]] = None
@@ -14,11 +16,13 @@ class HookContext:
 
     def __init__(
         self,
+        config: SDKConfiguration,
         base_url: str,
         operation_id: str,
         oauth2_scopes: Optional[List[str]],
         security_source: Optional[Union[Any, Callable[[], Any]]],
     ):
+        self.config = config
         self.base_url = base_url
         self.operation_id = operation_id
         self.oauth2_scopes = oauth2_scopes
@@ -28,6 +32,7 @@ class HookContext:
 class BeforeRequestContext(HookContext):
     def __init__(self, hook_ctx: HookContext):
         super().__init__(
+            hook_ctx.config,
             hook_ctx.base_url,
             hook_ctx.operation_id,
             hook_ctx.oauth2_scopes,
@@ -38,6 +43,7 @@ class BeforeRequestContext(HookContext):
 class AfterSuccessContext(HookContext):
     def __init__(self, hook_ctx: HookContext):
         super().__init__(
+            hook_ctx.config,
             hook_ctx.base_url,
             hook_ctx.operation_id,
             hook_ctx.oauth2_scopes,
@@ -48,6 +54,7 @@ class AfterSuccessContext(HookContext):
 class AfterErrorContext(HookContext):
     def __init__(self, hook_ctx: HookContext):
         super().__init__(
+            hook_ctx.config,
             hook_ctx.base_url,
             hook_ctx.operation_id,
             hook_ctx.oauth2_scopes,

mistralai_gcp/_version.py

@@ -3,10 +3,10 @@
 import importlib.metadata
 
 __title__: str = "mistralai-gcp"
-__version__: str = "1.6.0"
-__openapi_doc_version__: str = "0.0.2"
-__gen_version__: str = "2.548.6"
-__user_agent__: str = "speakeasy-sdk/python 1.6.0 2.548.6 0.0.2 mistralai-gcp"
+__version__: str = "1.8.0"
+__openapi_doc_version__: str = "1.0.0"
+__gen_version__: str = "2.794.1"
+__user_agent__: str = "speakeasy-sdk/python 1.8.0 2.794.1 1.0.0 mistralai-gcp"
 
 try:
     if __package__ is not None:

mistralai_gcp/basesdk.py

@@ -15,9 +15,19 @@ from urllib.parse import parse_qs, urlparse
 
 class BaseSDK:
     sdk_configuration: SDKConfiguration
+    parent_ref: Optional[object] = None
+    """
+    Reference to the root SDK instance, if any. This will prevent it from
+    being garbage collected while there are active streams.
+    """
 
-    def __init__(self, sdk_config: SDKConfiguration) -> None:
+    def __init__(
+        self,
+        sdk_config: SDKConfiguration,
+        parent_ref: Optional[object] = None,
+    ) -> None:
         self.sdk_configuration = sdk_config
+        self.parent_ref = parent_ref
 
     def _get_url(self, base_url, url_variables):
         sdk_url, sdk_variables = self.sdk_configuration.get_server_details()
@@ -50,6 +60,7 @@ class BaseSDK:
         ] = None,
         url_override: Optional[str] = None,
         http_headers: Optional[Mapping[str, str]] = None,
+        allow_empty_value: Optional[List[str]] = None,
     ) -> httpx.Request:
         client = self.sdk_configuration.async_client
         return self._build_request_with_client(
@@ -70,6 +81,7 @@ class BaseSDK:
             get_serialized_body,
             url_override,
             http_headers,
+            allow_empty_value,
         )
 
     def _build_request(
@@ -92,6 +104,7 @@ class BaseSDK:
         ] = None,
         url_override: Optional[str] = None,
         http_headers: Optional[Mapping[str, str]] = None,
+        allow_empty_value: Optional[List[str]] = None,
     ) -> httpx.Request:
         client = self.sdk_configuration.client
         return self._build_request_with_client(
@@ -112,6 +125,7 @@ class BaseSDK:
             get_serialized_body,
             url_override,
             http_headers,
+            allow_empty_value,
         )
 
     def _build_request_with_client(
@@ -135,6 +149,7 @@ class BaseSDK:
         ] = None,
         url_override: Optional[str] = None,
         http_headers: Optional[Mapping[str, str]] = None,
+        allow_empty_value: Optional[List[str]] = None,
     ) -> httpx.Request:
         query_params = {}
 
@@ -150,6 +165,7 @@ class BaseSDK:
             query_params = utils.get_query_params(
                 request if request_has_query_params else None,
                 _globals if request_has_query_params else None,
+                allow_empty_value,
             )
         else:
             # Pick up the query parameter from the override so they can be
@@ -218,12 +234,12 @@ class BaseSDK:
         client = self.sdk_configuration.client
         logger = self.sdk_configuration.debug_logger
 
+        hooks = self.sdk_configuration.__dict__["_hooks"]
+
         def do():
             http_res = None
             try:
-                req = self.sdk_configuration.get_hooks().before_request(
-                    BeforeRequestContext(hook_ctx), request
-                )
+                req = hooks.before_request(BeforeRequestContext(hook_ctx), request)
                 logger.debug(
                     "Request:\nMethod: %s\nURL: %s\nHeaders: %s\nBody: %s",
                     req.method,
@@ -237,16 +253,14 @@ class BaseSDK:
 
                 http_res = client.send(req, stream=stream)
             except Exception as e:
-                _, e = self.sdk_configuration.get_hooks().after_error(
-                    AfterErrorContext(hook_ctx), None, e
-                )
+                _, e = hooks.after_error(AfterErrorContext(hook_ctx), None, e)
                 if e is not None:
                     logger.debug("Request Exception", exc_info=True)
                     raise e
 
             if http_res is None:
                 logger.debug("Raising no response SDK error")
-                raise models.SDKError("No response received")
+                raise models.NoResponseError("No response received")
 
             logger.debug(
                 "Response:\nStatus Code: %s\nURL: %s\nHeaders: %s\nBody: %s",
@@ -257,7 +271,7 @@ class BaseSDK:
             )
 
             if utils.match_status_codes(error_status_codes, http_res.status_code):
-                result, err = self.sdk_configuration.get_hooks().after_error(
+                result, err = hooks.after_error(
                     AfterErrorContext(hook_ctx), http_res, None
                 )
                 if err is not None:
@@ -267,7 +281,7 @@ class BaseSDK:
                     http_res = result
                 else:
                     logger.debug("Raising unexpected SDK error")
-                    raise models.SDKError("Unexpected error occurred")
+                    raise models.SDKError("Unexpected error occurred", http_res)
 
             return http_res
 
@@ -277,9 +291,7 @@ class BaseSDK:
             http_res = do()
 
         if not utils.match_status_codes(error_status_codes, http_res.status_code):
-            http_res = self.sdk_configuration.get_hooks().after_success(
-                AfterSuccessContext(hook_ctx), http_res
-            )
+            http_res = hooks.after_success(AfterSuccessContext(hook_ctx), http_res)
 
         return http_res
 
@@ -294,12 +306,12 @@ class BaseSDK:
         client = self.sdk_configuration.async_client
         logger = self.sdk_configuration.debug_logger
 
+        hooks = self.sdk_configuration.__dict__["_hooks"]
+
         async def do():
             http_res = None
             try:
-                req = self.sdk_configuration.get_hooks().before_request(
-                    BeforeRequestContext(hook_ctx), request
-                )
+                req = hooks.before_request(BeforeRequestContext(hook_ctx), request)
                 logger.debug(
                     "Request:\nMethod: %s\nURL: %s\nHeaders: %s\nBody: %s",
                     req.method,
@@ -313,16 +325,14 @@ class BaseSDK:
 
                 http_res = await client.send(req, stream=stream)
             except Exception as e:
-                _, e = self.sdk_configuration.get_hooks().after_error(
-                    AfterErrorContext(hook_ctx), None, e
-                )
+                _, e = hooks.after_error(AfterErrorContext(hook_ctx), None, e)
                 if e is not None:
                     logger.debug("Request Exception", exc_info=True)
                     raise e
 
             if http_res is None:
                 logger.debug("Raising no response SDK error")
-                raise models.SDKError("No response received")
+                raise models.NoResponseError("No response received")
 
             logger.debug(
                 "Response:\nStatus Code: %s\nURL: %s\nHeaders: %s\nBody: %s",
@@ -333,7 +343,7 @@ class BaseSDK:
             )
 
             if utils.match_status_codes(error_status_codes, http_res.status_code):
-                result, err = self.sdk_configuration.get_hooks().after_error(
+                result, err = hooks.after_error(
                     AfterErrorContext(hook_ctx), http_res, None
                 )
                 if err is not None:
@@ -343,7 +353,7 @@ class BaseSDK:
                     http_res = result
                 else:
                     logger.debug("Raising unexpected SDK error")
-                    raise models.SDKError("Unexpected error occurred")
+                    raise models.SDKError("Unexpected error occurred", http_res)
 
             return http_res
 
@@ -355,8 +365,6 @@ class BaseSDK:
             http_res = await do()
 
         if not utils.match_status_codes(error_status_codes, http_res.status_code):
-            http_res = self.sdk_configuration.get_hooks().after_success(
-                AfterSuccessContext(hook_ctx), http_res
-            )
+            http_res = hooks.after_success(AfterSuccessContext(hook_ctx), http_res)
 
         return http_res