mistralai 1.5.1__py3-none-any.whl → 1.5.2rc1__py3-none-any.whl

mistralai_gcp/models/chatcompletionrequest.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 from .assistantmessage import AssistantMessage, AssistantMessageTypedDict
+from .prediction import Prediction, PredictionTypedDict
 from .responseformat import ResponseFormat, ResponseFormatTypedDict
 from .systemmessage import SystemMessage, SystemMessageTypedDict
 from .tool import Tool, ToolTypedDict
@@ -68,7 +69,7 @@ ChatCompletionRequestToolChoice = TypeAliasType(
 
 
 class ChatCompletionRequestTypedDict(TypedDict):
-    model: Nullable[str]
+    model: str
     r"""ID of the model to use. You can use the [List Available Models](/api/#tag/models/operation/list_models_v1_models_get) API to see all of your available models, or see our [Model overview](/models) for model descriptions."""
     messages: List[ChatCompletionRequestMessagesTypedDict]
     r"""The prompt(s) to generate completions for, encoded as a list of dict with role and content."""
@@ -93,10 +94,11 @@ class ChatCompletionRequestTypedDict(TypedDict):
     r"""frequency_penalty penalizes the repetition of words based on their frequency in the generated text. A higher frequency penalty discourages the model from repeating words that have already appeared frequently in the output, promoting diversity and reducing repetition."""
     n: NotRequired[Nullable[int]]
     r"""Number of completions to return for each request, input tokens are only billed once."""
+    prediction: NotRequired[PredictionTypedDict]
 
 
 class ChatCompletionRequest(BaseModel):
-    model: Nullable[str]
+    model: str
     r"""ID of the model to use. You can use the [List Available Models](/api/#tag/models/operation/list_models_v1_models_get) API to see all of your available models, or see our [Model overview](/models) for model descriptions."""
 
     messages: List[ChatCompletionRequestMessages]
@@ -135,6 +137,8 @@ class ChatCompletionRequest(BaseModel):
     n: OptionalNullable[int] = UNSET
     r"""Number of completions to return for each request, input tokens are only billed once."""
 
+    prediction: Optional[Prediction] = None
+
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
         optional_fields = [
@@ -150,15 +154,9 @@ class ChatCompletionRequest(BaseModel):
             "presence_penalty",
             "frequency_penalty",
             "n",
+            "prediction",
         ]
-        nullable_fields = [
-            "model",
-            "temperature",
-            "max_tokens",
-            "random_seed",
-            "tools",
-            "n",
-        ]
+        nullable_fields = ["temperature", "max_tokens", "random_seed", "tools", "n"]
         null_default_fields = []
 
         serialized = handler(self)

mistralai_gcp/models/chatcompletionstreamrequest.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 from .assistantmessage import AssistantMessage, AssistantMessageTypedDict
+from .prediction import Prediction, PredictionTypedDict
 from .responseformat import ResponseFormat, ResponseFormatTypedDict
 from .systemmessage import SystemMessage, SystemMessageTypedDict
 from .tool import Tool, ToolTypedDict
@@ -64,7 +65,7 @@ ChatCompletionStreamRequestToolChoice = TypeAliasType(
 
 
 class ChatCompletionStreamRequestTypedDict(TypedDict):
-    model: Nullable[str]
+    model: str
     r"""ID of the model to use. You can use the [List Available Models](/api/#tag/models/operation/list_models_v1_models_get) API to see all of your available models, or see our [Model overview](/models) for model descriptions."""
     messages: List[MessagesTypedDict]
     r"""The prompt(s) to generate completions for, encoded as a list of dict with role and content."""
@@ -88,10 +89,11 @@ class ChatCompletionStreamRequestTypedDict(TypedDict):
     r"""frequency_penalty penalizes the repetition of words based on their frequency in the generated text. A higher frequency penalty discourages the model from repeating words that have already appeared frequently in the output, promoting diversity and reducing repetition."""
     n: NotRequired[Nullable[int]]
     r"""Number of completions to return for each request, input tokens are only billed once."""
+    prediction: NotRequired[PredictionTypedDict]
 
 
 class ChatCompletionStreamRequest(BaseModel):
-    model: Nullable[str]
+    model: str
     r"""ID of the model to use. You can use the [List Available Models](/api/#tag/models/operation/list_models_v1_models_get) API to see all of your available models, or see our [Model overview](/models) for model descriptions."""
 
     messages: List[Messages]
@@ -129,6 +131,8 @@ class ChatCompletionStreamRequest(BaseModel):
     n: OptionalNullable[int] = UNSET
     r"""Number of completions to return for each request, input tokens are only billed once."""
 
+    prediction: Optional[Prediction] = None
+
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
         optional_fields = [
@@ -144,15 +148,9 @@ class ChatCompletionStreamRequest(BaseModel):
             "presence_penalty",
             "frequency_penalty",
             "n",
+            "prediction",
         ]
-        nullable_fields = [
-            "model",
-            "temperature",
-            "max_tokens",
-            "random_seed",
-            "tools",
-            "n",
-        ]
+        nullable_fields = ["temperature", "max_tokens", "random_seed", "tools", "n"]
         null_default_fields = []
 
         serialized = handler(self)

mistralai_gcp/models/fimcompletionrequest.py

@@ -26,7 +26,7 @@ r"""Stop generation if this token is detected. Or if one of these tokens is dete
 
 
 class FIMCompletionRequestTypedDict(TypedDict):
-    model: Nullable[str]
+    model: str
     r"""ID of the model to use. Only compatible for now with:
     - `codestral-2405`
     - `codestral-latest`
@@ -52,7 +52,7 @@ class FIMCompletionRequestTypedDict(TypedDict):
 
 
 class FIMCompletionRequest(BaseModel):
-    model: Nullable[str]
+    model: str
     r"""ID of the model to use. Only compatible for now with:
     - `codestral-2405`
     - `codestral-latest`
@@ -98,7 +98,6 @@ class FIMCompletionRequest(BaseModel):
             "min_tokens",
         ]
         nullable_fields = [
-            "model",
             "temperature",
             "max_tokens",
             "random_seed",

mistralai_gcp/models/fimcompletionstreamrequest.py

@@ -26,7 +26,7 @@ r"""Stop generation if this token is detected. Or if one of these tokens is dete
 
 
 class FIMCompletionStreamRequestTypedDict(TypedDict):
-    model: Nullable[str]
+    model: str
     r"""ID of the model to use. Only compatible for now with:
     - `codestral-2405`
     - `codestral-latest`
@@ -51,7 +51,7 @@ class FIMCompletionStreamRequestTypedDict(TypedDict):
 
 
 class FIMCompletionStreamRequest(BaseModel):
-    model: Nullable[str]
+    model: str
     r"""ID of the model to use. Only compatible for now with:
     - `codestral-2405`
     - `codestral-latest`
@@ -96,7 +96,6 @@ class FIMCompletionStreamRequest(BaseModel):
             "min_tokens",
         ]
         nullable_fields = [
-            "model",
             "temperature",
             "max_tokens",
             "random_seed",

mistralai_gcp/models/function.py

@@ -10,6 +10,7 @@ class FunctionTypedDict(TypedDict):
     name: str
     parameters: Dict[str, Any]
     description: NotRequired[str]
+    strict: NotRequired[bool]
 
 
 class Function(BaseModel):
@@ -18,3 +19,5 @@ class Function(BaseModel):
     parameters: Dict[str, Any]
 
     description: Optional[str] = ""
+
+    strict: Optional[bool] = False

mistralai_gcp/models/jsonschema.py

@@ -0,0 +1,61 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from mistralai_gcp.types import (
+    BaseModel,
+    Nullable,
+    OptionalNullable,
+    UNSET,
+    UNSET_SENTINEL,
+)
+import pydantic
+from pydantic import model_serializer
+from typing import Any, Dict, Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class JSONSchemaTypedDict(TypedDict):
+    name: str
+    schema_definition: Dict[str, Any]
+    description: NotRequired[Nullable[str]]
+    strict: NotRequired[bool]
+
+
+class JSONSchema(BaseModel):
+    name: str
+
+    schema_definition: Annotated[Dict[str, Any], pydantic.Field(alias="schema")]
+
+    description: OptionalNullable[str] = UNSET
+
+    strict: Optional[bool] = False
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["description", "strict"]
+        nullable_fields = ["description"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in self.model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            serialized.pop(k, None)
+
+            optional_nullable = k in optional_fields and k in nullable_fields
+            is_set = (
+                self.__pydantic_fields_set__.intersection({n})
+                or k in null_default_fields
+            )  # pylint: disable=no-member
+
+            if val is not None and val != UNSET_SENTINEL:
+                m[k] = val
+            elif val != UNSET_SENTINEL and (
+                not k in optional_fields or (optional_nullable and is_set)
+            ):
+                m[k] = val
+
+        return m

mistralai_gcp/models/prediction.py

@@ -0,0 +1,25 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from mistralai_gcp.types import BaseModel
+from mistralai_gcp.utils import validate_const
+import pydantic
+from pydantic.functional_validators import AfterValidator
+from typing import Literal, Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class PredictionTypedDict(TypedDict):
+    type: Literal["content"]
+    content: NotRequired[str]
+
+
+class Prediction(BaseModel):
+    TYPE: Annotated[
+        Annotated[
+            Optional[Literal["content"]], AfterValidator(validate_const("content"))
+        ],
+        pydantic.Field(alias="type"),
+    ] = "content"
+
+    content: Optional[str] = ""

mistralai_gcp/models/responseformat.py

@@ -1,8 +1,16 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
+from .jsonschema import JSONSchema, JSONSchemaTypedDict
 from .responseformats import ResponseFormats
-from mistralai_gcp.types import BaseModel
+from mistralai_gcp.types import (
+    BaseModel,
+    Nullable,
+    OptionalNullable,
+    UNSET,
+    UNSET_SENTINEL,
+)
+from pydantic import model_serializer
 from typing import Optional
 from typing_extensions import NotRequired, TypedDict
 
@@ -10,8 +18,41 @@ from typing_extensions import NotRequired, TypedDict
 class ResponseFormatTypedDict(TypedDict):
     type: NotRequired[ResponseFormats]
     r"""An object specifying the format that the model must output. Setting to `{ \"type\": \"json_object\" }` enables JSON mode, which guarantees the message the model generates is in JSON. When using JSON mode you MUST also instruct the model to produce JSON yourself with a system or a user message."""
+    json_schema: NotRequired[Nullable[JSONSchemaTypedDict]]
 
 
 class ResponseFormat(BaseModel):
     type: Optional[ResponseFormats] = None
     r"""An object specifying the format that the model must output. Setting to `{ \"type\": \"json_object\" }` enables JSON mode, which guarantees the message the model generates is in JSON. When using JSON mode you MUST also instruct the model to produce JSON yourself with a system or a user message."""
+
+    json_schema: OptionalNullable[JSONSchema] = UNSET
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["type", "json_schema"]
+        nullable_fields = ["json_schema"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in self.model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            serialized.pop(k, None)
+
+            optional_nullable = k in optional_fields and k in nullable_fields
+            is_set = (
+                self.__pydantic_fields_set__.intersection({n})
+                or k in null_default_fields
+            )  # pylint: disable=no-member
+
+            if val is not None and val != UNSET_SENTINEL:
+                m[k] = val
+            elif val != UNSET_SENTINEL and (
+                not k in optional_fields or (optional_nullable and is_set)
+            ):
+                m[k] = val
+
+        return m

mistralai_gcp/models/responseformats.py

@@ -4,5 +4,5 @@ from __future__ import annotations
 from typing import Literal
 
 
-ResponseFormats = Literal["text", "json_object"]
+ResponseFormats = Literal["text", "json_object", "json_schema"]
 r"""An object specifying the format that the model must output. Setting to `{ \"type\": \"json_object\" }` enables JSON mode, which guarantees the message the model generates is in JSON. When using JSON mode you MUST also instruct the model to produce JSON yourself with a system or a user message."""

mistralai_gcp/models/toolcall.py

@@ -14,6 +14,7 @@ class ToolCallTypedDict(TypedDict):
     function: FunctionCallTypedDict
     id: NotRequired[str]
     type: NotRequired[ToolTypes]
+    index: NotRequired[int]
 
 
 class ToolCall(BaseModel):
@@ -24,3 +25,5 @@ class ToolCall(BaseModel):
     type: Annotated[Optional[ToolTypes], PlainValidator(validate_open_enum(False))] = (
         None
     )
+
+    index: Optional[int] = 0

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):