mistralai 1.4.0__py3-none-any.whl → 1.5.1__py3-none-any.whl

mistralai/extra/tests/test_utils.py

@@ -0,0 +1,162 @@
+from ..utils.response_format import (
+    pydantic_model_from_json,
+    response_format_from_pydantic_model,
+    rec_strict_json_schema,
+)
+from pydantic import BaseModel, ValidationError
+
+from ...models import ResponseFormat, JSONSchema
+from ...types.basemodel import Unset
+
+import unittest
+
+
+class Student(BaseModel):
+    name: str
+    age: int
+
+
+class Explanation(BaseModel):
+    explanation: str
+    output: str
+
+
+class MathDemonstration(BaseModel):
+    steps: list[Explanation]
+    final_answer: str
+
+
+mathdemo_schema = {
+    "$defs": {
+        "Explanation": {
+            "properties": {
+                "explanation": {"title": "Explanation", "type": "string"},
+                "output": {"title": "Output", "type": "string"},
+            },
+            "required": ["explanation", "output"],
+            "title": "Explanation",
+            "type": "object",
+        }
+    },
+    "properties": {
+        "steps": {
+            "items": {"$ref": "#/$defs/Explanation"},
+            "title": "Steps",
+            "type": "array",
+        },
+        "final_answer": {"title": "Final Answer", "type": "string"},
+    },
+    "required": ["steps", "final_answer"],
+    "title": "MathDemonstration",
+    "type": "object",
+}
+
+mathdemo_strict_schema = mathdemo_schema.copy()
+mathdemo_strict_schema["$defs"]["Explanation"]["additionalProperties"] = False # type: ignore
+mathdemo_strict_schema["additionalProperties"] = False
+
+mathdemo_response_format = ResponseFormat(
+    type="json_schema",
+    json_schema=JSONSchema(
+        name="MathDemonstration",
+        schema_definition=mathdemo_strict_schema,
+        description=Unset(),
+        strict=True,
+    ),
+)
+
+
+class TestResponseFormat(unittest.TestCase):
+    def test_pydantic_model_from_json(self):
+        missing_json_data = {"name": "Jean Dupont"}
+        good_json_data = {"name": "Jean Dupont", "age": 25}
+        extra_json_data = {
+            "name": "Jean Dupont",
+            "age": 25,
+            "extra_field": "extra_value",
+        }
+        complex_json_data = {
+            "final_answer": "x = -4",
+            "steps": [
+                {
+                    "explanation": "Start with the given equation.",
+                    "output": "8x + 7 = -23",
+                },
+                {
+                    "explanation": "Subtract 7 from both sides to isolate the term with x.",
+                    "output": "8x = -23 - 7",
+                },
+                {
+                    "explanation": "Simplify the right side of the equation.",
+                    "output": "8x = -30",
+                },
+                {
+                    "explanation": "Divide both sides by 8 to solve for x.",
+                    "output": "x = -30 / 8",
+                },
+                {
+                    "explanation": "Simplify the fraction to get the final answer.",
+                    "output": "x = -4",
+                },
+            ],
+        }
+
+        self.assertEqual(
+            pydantic_model_from_json(good_json_data, Student),
+            Student(name="Jean Dupont", age=25),
+        )
+        self.assertEqual(
+            pydantic_model_from_json(extra_json_data, Student),
+            Student(name="Jean Dupont", age=25),
+        )
+        self.assertEqual(
+            pydantic_model_from_json(complex_json_data, MathDemonstration),
+            MathDemonstration(
+                steps=[
+                    Explanation(
+                        explanation="Start with the given equation.",
+                        output="8x + 7 = -23",
+                    ),
+                    Explanation(
+                        explanation="Subtract 7 from both sides to isolate the term with x.",
+                        output="8x = -23 - 7",
+                    ),
+                    Explanation(
+                        explanation="Simplify the right side of the equation.",
+                        output="8x = -30",
+                    ),
+                    Explanation(
+                        explanation="Divide both sides by 8 to solve for x.",
+                        output="x = -30 / 8",
+                    ),
+                    Explanation(
+                        explanation="Simplify the fraction to get the final answer.",
+                        output="x = -4",
+                    ),
+                ],
+                final_answer="x = -4",
+            ),
+        )
+
+        # Check it raises a validation error
+        with self.assertRaises(ValidationError):
+            pydantic_model_from_json(missing_json_data, Student)  # type: ignore
+
+    def test_response_format_from_pydantic_model(self):
+        self.assertEqual(
+            response_format_from_pydantic_model(MathDemonstration),
+            mathdemo_response_format,
+        )
+
+    def test_rec_strict_json_schema(self):
+        invalid_schema = mathdemo_schema | {"wrong_value": 1}
+        self.assertEqual(
+            rec_strict_json_schema(mathdemo_schema), mathdemo_strict_schema
+        )
+
+        with self.assertRaises(ValueError):
+            rec_strict_json_schema(invalid_schema)
+
+
+if __name__ == "__main__":
+    unittest.main()

mistralai/extra/utils/__init__.py

@@ -0,0 +1,3 @@
+from .response_format import response_format_from_pydantic_model
+
+__all__ = ["response_format_from_pydantic_model"]

mistralai/extra/utils/_pydantic_helper.py

@@ -0,0 +1,20 @@
+from typing import Any
+
+def rec_strict_json_schema(schema_node: Any) -> Any:
+    """
+    Recursively set the additionalProperties property to False for all objects in the JSON Schema.
+    This makes the JSON Schema strict (i.e. no additional properties are allowed).
+    """
+    if isinstance(schema_node, (str, bool)):
+        return schema_node
+    if isinstance(schema_node, dict):
+        if "type" in schema_node and schema_node["type"] == "object":
+            schema_node["additionalProperties"] = False
+        for key, value in schema_node.items():
+            schema_node[key] = rec_strict_json_schema(value)
+    elif isinstance(schema_node, list):
+        for i, value in enumerate(schema_node):
+            schema_node[i] = rec_strict_json_schema(value)
+    else:
+        raise ValueError(f"Unexpected type: {schema_node}")
+    return schema_node

mistralai/extra/utils/response_format.py

@@ -0,0 +1,24 @@
+from pydantic import BaseModel
+from typing import TypeVar, Any, Type
+from ...models import JSONSchema, ResponseFormat
+from ._pydantic_helper import rec_strict_json_schema
+
+CustomPydanticModel = TypeVar("CustomPydanticModel", bound=BaseModel)
+
+
+def response_format_from_pydantic_model(
+    model: type[CustomPydanticModel],
+) -> ResponseFormat:
+    """Generate a strict JSON schema from a pydantic model."""
+    model_schema = rec_strict_json_schema(model.model_json_schema())
+    json_schema = JSONSchema.model_validate(
+        {"name": model.__name__, "schema": model_schema, "strict": True}
+    )
+    return ResponseFormat(type="json_schema", json_schema=json_schema)
+
+
+def pydantic_model_from_json(
+    json_data: dict[str, Any], pydantic_model: Type[CustomPydanticModel]
+) -> CustomPydanticModel:
+    """Parse a JSON schema into a pydantic model."""
+    return pydantic_model.model_validate(json_data)

mistralai/fim.py

@@ -3,7 +3,7 @@
 from .basesdk import BaseSDK
 from mistralai import models, utils
 from mistralai._hooks import HookContext
-from mistralai.types import Nullable, OptionalNullable, UNSET
+from mistralai.types import OptionalNullable, UNSET
 from mistralai.utils import eventstreaming, get_security_from_env
 from typing import Any, Mapping, Optional, Union
 
@@ -14,7 +14,7 @@ class Fim(BaseSDK):
     def complete(
         self,
         *,
-        model: Nullable[str],
+        model: str,
         prompt: str,
         temperature: OptionalNullable[float] = UNSET,
         top_p: Optional[float] = 1,
@@ -143,7 +143,7 @@ class Fim(BaseSDK):
     async def complete_async(
         self,
         *,
-        model: Nullable[str],
+        model: str,
         prompt: str,
         temperature: OptionalNullable[float] = UNSET,
         top_p: Optional[float] = 1,
@@ -272,7 +272,7 @@ class Fim(BaseSDK):
     def stream(
         self,
         *,
-        model: Nullable[str],
+        model: str,
         prompt: str,
         temperature: OptionalNullable[float] = UNSET,
         top_p: Optional[float] = 1,
@@ -407,7 +407,7 @@ class Fim(BaseSDK):
     async def stream_async(
         self,
         *,
-        model: Nullable[str],
+        model: str,
         prompt: str,
         temperature: OptionalNullable[float] = UNSET,
         top_p: Optional[float] = 1,

mistralai/httpclient.py

@@ -1,6 +1,8 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 # pyright: reportReturnType = false
+import asyncio
+from concurrent.futures import ThreadPoolExecutor
 from typing_extensions import Protocol, runtime_checkable
 import httpx
 from typing import Any, Optional, Union
@@ -82,3 +84,51 @@ class AsyncHttpClient(Protocol):
 
     async def aclose(self) -> None:
         pass
+
+
+class ClientOwner(Protocol):
+    client: Union[HttpClient, None]
+    async_client: Union[AsyncHttpClient, None]
+
+
+def close_clients(
+    owner: ClientOwner,
+    sync_client: Union[HttpClient, None],
+    async_client: Union[AsyncHttpClient, None],
+) -> None:
+    """
+    A finalizer function that is meant to be used with weakref.finalize to close
+    httpx clients used by an SDK so that underlying resources can be garbage
+    collected.
+    """
+
+    # Unset the client/async_client properties so there are no more references
+    # to them from the owning SDK instance and they can be reaped.
+    owner.client = None
+    owner.async_client = None
+
+    if sync_client is not None:
+        try:
+            sync_client.close()
+        except Exception:
+            pass
+
+    if async_client is not None:
+        is_async = False
+        try:
+            asyncio.get_running_loop()
+            is_async = True
+        except RuntimeError:
+            pass
+
+        try:
+            # If this function is called in an async loop then start another
+            # loop in a separate thread to close the async http client.
+            if is_async:
+                with ThreadPoolExecutor(max_workers=1) as executor:
+                    future = executor.submit(asyncio.run, async_client.aclose())
+                    future.result()
+            else:
+                asyncio.run(async_client.aclose())
+        except Exception:
+            pass

mistralai/models/__init__.py

@@ -39,16 +39,6 @@ from .batchjobin import BatchJobIn, BatchJobInTypedDict
 from .batchjobout import BatchJobOut, BatchJobOutObject, BatchJobOutTypedDict
 from .batchjobsout import BatchJobsOut, BatchJobsOutObject, BatchJobsOutTypedDict
 from .batchjobstatus import BatchJobStatus
-from .chatclassificationrequest import (
-    ChatClassificationRequest,
-    ChatClassificationRequestInputs,
-    ChatClassificationRequestInputsTypedDict,
-    ChatClassificationRequestTypedDict,
-    One,
-    OneTypedDict,
-    Two,
-    TwoTypedDict,
-)
 from .chatcompletionchoice import (
     ChatCompletionChoice,
     ChatCompletionChoiceTypedDict,
@@ -78,6 +68,16 @@ from .chatcompletionstreamrequest import (
     ChatCompletionStreamRequestToolChoiceTypedDict,
     ChatCompletionStreamRequestTypedDict,
 )
+from .chatmoderationrequest import (
+    ChatModerationRequest,
+    ChatModerationRequestInputs,
+    ChatModerationRequestInputsTypedDict,
+    ChatModerationRequestTypedDict,
+    One,
+    OneTypedDict,
+    Two,
+    TwoTypedDict,
+)
 from .checkpointout import CheckpointOut, CheckpointOutTypedDict
 from .classificationobject import ClassificationObject, ClassificationObjectTypedDict
 from .classificationrequest import (
@@ -115,6 +115,7 @@ from .detailedjobout import (
     DetailedJobOutStatus,
     DetailedJobOutTypedDict,
 )
+from .documenturlchunk import DocumentURLChunk, DocumentURLChunkTypedDict
 from .embeddingrequest import (
     EmbeddingRequest,
     EmbeddingRequestTypedDict,
@@ -264,6 +265,7 @@ from .jobs_api_routes_fine_tuning_update_fine_tuned_modelop import (
     JobsAPIRoutesFineTuningUpdateFineTunedModelRequestTypedDict,
 )
 from .jobsout import JobsOut, JobsOutObject, JobsOutTypedDict
+from .jsonschema import JSONSchema, JSONSchemaTypedDict
 from .legacyjobmetadataout import (
     LegacyJobMetadataOut,
     LegacyJobMetadataOutObject,
@@ -273,7 +275,13 @@ from .listfilesout import ListFilesOut, ListFilesOutTypedDict
 from .metricout import MetricOut, MetricOutTypedDict
 from .modelcapabilities import ModelCapabilities, ModelCapabilitiesTypedDict
 from .modellist import Data, DataTypedDict, ModelList, ModelListTypedDict
-from .prediction import Prediction, PredictionType, PredictionTypedDict
+from .ocrimageobject import OCRImageObject, OCRImageObjectTypedDict
+from .ocrpagedimensions import OCRPageDimensions, OCRPageDimensionsTypedDict
+from .ocrpageobject import OCRPageObject, OCRPageObjectTypedDict
+from .ocrrequest import Document, DocumentTypedDict, OCRRequest, OCRRequestTypedDict
+from .ocrresponse import OCRResponse, OCRResponseTypedDict
+from .ocrusageinfo import OCRUsageInfo, OCRUsageInfoTypedDict
+from .prediction import Prediction, PredictionTypedDict
 from .referencechunk import ReferenceChunk, ReferenceChunkType, ReferenceChunkTypedDict
 from .responseformat import ResponseFormat, ResponseFormatTypedDict
 from .responseformats import ResponseFormats
@@ -385,10 +393,6 @@ __all__ = [
     "BatchJobsOut",
     "BatchJobsOutObject",
     "BatchJobsOutTypedDict",
-    "ChatClassificationRequest",
-    "ChatClassificationRequestInputs",
-    "ChatClassificationRequestInputsTypedDict",
-    "ChatClassificationRequestTypedDict",
     "ChatCompletionChoice",
     "ChatCompletionChoiceTypedDict",
     "ChatCompletionRequest",
@@ -405,6 +409,10 @@ __all__ = [
     "ChatCompletionStreamRequestToolChoice",
     "ChatCompletionStreamRequestToolChoiceTypedDict",
     "ChatCompletionStreamRequestTypedDict",
+    "ChatModerationRequest",
+    "ChatModerationRequestInputs",
+    "ChatModerationRequestInputsTypedDict",
+    "ChatModerationRequestTypedDict",
     "CheckpointOut",
     "CheckpointOutTypedDict",
     "ClassificationObject",
@@ -444,6 +452,10 @@ __all__ = [
     "DetailedJobOutRepositoriesTypedDict",
     "DetailedJobOutStatus",
     "DetailedJobOutTypedDict",
+    "Document",
+    "DocumentTypedDict",
+    "DocumentURLChunk",
+    "DocumentURLChunkTypedDict",
     "EmbeddingRequest",
     "EmbeddingRequestTypedDict",
     "EmbeddingResponse",
@@ -515,6 +527,8 @@ __all__ = [
     "InputsTypedDict",
     "Integrations",
     "IntegrationsTypedDict",
+    "JSONSchema",
+    "JSONSchemaTypedDict",
     "JobIn",
     "JobInIntegrations",
     "JobInIntegrationsTypedDict",
@@ -565,11 +579,22 @@ __all__ = [
     "ModelCapabilitiesTypedDict",
     "ModelList",
     "ModelListTypedDict",
+    "OCRImageObject",
+    "OCRImageObjectTypedDict",
+    "OCRPageDimensions",
+    "OCRPageDimensionsTypedDict",
+    "OCRPageObject",
+    "OCRPageObjectTypedDict",
+    "OCRRequest",
+    "OCRRequestTypedDict",
+    "OCRResponse",
+    "OCRResponseTypedDict",
+    "OCRUsageInfo",
+    "OCRUsageInfoTypedDict",
     "Object",
     "One",
     "OneTypedDict",
     "Prediction",
-    "PredictionType",
     "PredictionTypedDict",
     "QueryParamStatus",
     "ReferenceChunk",

mistralai/models/assistantmessage.py

@@ -26,6 +26,7 @@ class AssistantMessageTypedDict(TypedDict):
     content: NotRequired[Nullable[AssistantMessageContentTypedDict]]
     tool_calls: NotRequired[Nullable[List[ToolCallTypedDict]]]
     prefix: NotRequired[bool]
+    r"""Set this to `true` when adding an assistant message as prefix to condition the model response. The role of the prefix message is to force the model to start its answer by the content of the message."""
     role: NotRequired[AssistantMessageRole]
 
 
@@ -35,6 +36,7 @@ class AssistantMessage(BaseModel):
     tool_calls: OptionalNullable[List[ToolCall]] = UNSET
 
     prefix: Optional[bool] = False
+    r"""Set this to `true` when adding an assistant message as prefix to condition the model response. The role of the prefix message is to force the model to start its answer by the content of the message."""
 
     role: Optional[AssistantMessageRole] = "assistant"
 

mistralai/models/chatcompletionrequest.py

@@ -59,7 +59,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[MessagesTypedDict]
     r"""The prompt(s) to generate completions for, encoded as a list of dict with role and content."""
@@ -90,7 +90,7 @@ class ChatCompletionRequestTypedDict(TypedDict):
 
 
 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[Messages]
@@ -152,14 +152,7 @@ class ChatCompletionRequest(BaseModel):
             "prediction",
             "safe_prompt",
         ]
-        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/models/chatcompletionstreamrequest.py

@@ -63,7 +63,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[ChatCompletionStreamRequestMessagesTypedDict]
     r"""The prompt(s) to generate completions for, encoded as a list of dict with role and content."""
@@ -93,7 +93,7 @@ class ChatCompletionStreamRequestTypedDict(TypedDict):
 
 
 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[ChatCompletionStreamRequestMessages]
@@ -154,14 +154,7 @@ class ChatCompletionStreamRequest(BaseModel):
             "prediction",
             "safe_prompt",
         ]
-        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/models/chatmoderationrequest.py

@@ -0,0 +1,86 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .assistantmessage import AssistantMessage, AssistantMessageTypedDict
+from .systemmessage import SystemMessage, SystemMessageTypedDict
+from .toolmessage import ToolMessage, ToolMessageTypedDict
+from .usermessage import UserMessage, UserMessageTypedDict
+from mistralai.types import BaseModel
+from mistralai.utils import get_discriminator
+import pydantic
+from pydantic import Discriminator, Tag
+from typing import List, Optional, Union
+from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
+
+
+TwoTypedDict = TypeAliasType(
+    "TwoTypedDict",
+    Union[
+        SystemMessageTypedDict,
+        UserMessageTypedDict,
+        AssistantMessageTypedDict,
+        ToolMessageTypedDict,
+    ],
+)
+
+
+Two = Annotated[
+    Union[
+        Annotated[AssistantMessage, Tag("assistant")],
+        Annotated[SystemMessage, Tag("system")],
+        Annotated[ToolMessage, Tag("tool")],
+        Annotated[UserMessage, Tag("user")],
+    ],
+    Discriminator(lambda m: get_discriminator(m, "role", "role")),
+]
+
+
+OneTypedDict = TypeAliasType(
+    "OneTypedDict",
+    Union[
+        SystemMessageTypedDict,
+        UserMessageTypedDict,
+        AssistantMessageTypedDict,
+        ToolMessageTypedDict,
+    ],
+)
+
+
+One = Annotated[
+    Union[
+        Annotated[AssistantMessage, Tag("assistant")],
+        Annotated[SystemMessage, Tag("system")],
+        Annotated[ToolMessage, Tag("tool")],
+        Annotated[UserMessage, Tag("user")],
+    ],
+    Discriminator(lambda m: get_discriminator(m, "role", "role")),
+]
+
+
+ChatModerationRequestInputsTypedDict = TypeAliasType(
+    "ChatModerationRequestInputsTypedDict",
+    Union[List[OneTypedDict], List[List[TwoTypedDict]]],
+)
+r"""Chat to classify"""
+
+
+ChatModerationRequestInputs = TypeAliasType(
+    "ChatModerationRequestInputs", Union[List[One], List[List[Two]]]
+)
+r"""Chat to classify"""
+
+
+class ChatModerationRequestTypedDict(TypedDict):
+    model: str
+    inputs: ChatModerationRequestInputsTypedDict
+    r"""Chat to classify"""
+    truncate_for_context_length: NotRequired[bool]
+
+
+class ChatModerationRequest(BaseModel):
+    model: str
+
+    inputs: Annotated[ChatModerationRequestInputs, pydantic.Field(alias="input")]
+    r"""Chat to classify"""
+
+    truncate_for_context_length: Optional[bool] = False

mistralai/models/classificationrequest.py

@@ -1,11 +1,10 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
-from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+from mistralai.types import BaseModel
 import pydantic
-from pydantic import model_serializer
 from typing import List, Union
-from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
+from typing_extensions import Annotated, TypeAliasType, TypedDict
 
 
 ClassificationRequestInputsTypedDict = TypeAliasType(
@@ -21,43 +20,15 @@ r"""Text to classify."""
 
 
 class ClassificationRequestTypedDict(TypedDict):
+    model: str
+    r"""ID of the model to use."""
     inputs: ClassificationRequestInputsTypedDict
     r"""Text to classify."""
-    model: NotRequired[Nullable[str]]
 
 
 class ClassificationRequest(BaseModel):
+    model: str
+    r"""ID of the model to use."""
+
     inputs: Annotated[ClassificationRequestInputs, pydantic.Field(alias="input")]
     r"""Text to classify."""
-
-    model: OptionalNullable[str] = UNSET
-
-    @model_serializer(mode="wrap")
-    def serialize_model(self, handler):
-        optional_fields = ["model"]
-        nullable_fields = ["model"]
-        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