mistralai 0.4.2__py3-none-any.whl → 1.0.0__py3-none-any.whl

mistralai/models/checkpointout.py

@@ -0,0 +1,25 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .metricout import MetricOut, MetricOutTypedDict
+from mistralai.types import BaseModel
+from typing import TypedDict
+
+
+class CheckpointOutTypedDict(TypedDict):
+    metrics: MetricOutTypedDict
+    r"""Metrics at the step number during the fine-tuning job. Use these metrics to assess if the training is going smoothly (loss should decrease, token accuracy should increase)."""
+    step_number: int
+    r"""The step number that the checkpoint was created at."""
+    created_at: int
+    r"""The UNIX timestamp (in seconds) for when the checkpoint was created."""
+    
+
+class CheckpointOut(BaseModel):
+    metrics: MetricOut
+    r"""Metrics at the step number during the fine-tuning job. Use these metrics to assess if the training is going smoothly (loss should decrease, token accuracy should increase)."""
+    step_number: int
+    r"""The step number that the checkpoint was created at."""
+    created_at: int
+    r"""The UNIX timestamp (in seconds) for when the checkpoint was created."""
+    

mistralai/models/completionchunk.py

@@ -0,0 +1,27 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .completionresponsestreamchoice import CompletionResponseStreamChoice, CompletionResponseStreamChoiceTypedDict
+from .usageinfo import UsageInfo, UsageInfoTypedDict
+from mistralai.types import BaseModel
+from typing import List, Optional, TypedDict
+from typing_extensions import NotRequired
+
+
+class CompletionChunkTypedDict(TypedDict):
+    id: str
+    model: str
+    choices: List[CompletionResponseStreamChoiceTypedDict]
+    object: NotRequired[str]
+    created: NotRequired[int]
+    usage: NotRequired[UsageInfoTypedDict]
+    
+
+class CompletionChunk(BaseModel):
+    id: str
+    model: str
+    choices: List[CompletionResponseStreamChoice]
+    object: Optional[str] = None
+    created: Optional[int] = None
+    usage: Optional[UsageInfo] = None
+    

mistralai/models/completionevent.py

@@ -0,0 +1,15 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .completionchunk import CompletionChunk, CompletionChunkTypedDict
+from mistralai.types import BaseModel
+from typing import TypedDict
+
+
+class CompletionEventTypedDict(TypedDict):
+    data: CompletionChunkTypedDict
+    
+
+class CompletionEvent(BaseModel):
+    data: CompletionChunk
+    

mistralai/models/completionresponsestreamchoice.py

@@ -0,0 +1,48 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .deltamessage import DeltaMessage, DeltaMessageTypedDict
+from mistralai.types import BaseModel, Nullable, UNSET_SENTINEL
+from pydantic import model_serializer
+from typing import Literal, TypedDict
+
+
+CompletionResponseStreamChoiceFinishReason = Literal["stop", "length", "error", "tool_calls"]
+
+class CompletionResponseStreamChoiceTypedDict(TypedDict):
+    index: int
+    delta: DeltaMessageTypedDict
+    finish_reason: Nullable[CompletionResponseStreamChoiceFinishReason]
+    
+
+class CompletionResponseStreamChoice(BaseModel):
+    index: int
+    delta: DeltaMessage
+    finish_reason: Nullable[CompletionResponseStreamChoiceFinishReason]
+    
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = []
+        nullable_fields = ["finish_reason"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in self.model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            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/models/contentchunk.py

@@ -0,0 +1,17 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from mistralai.types import BaseModel
+import pydantic
+from typing import Final, Optional, TypedDict
+from typing_extensions import Annotated
+
+
+class ContentChunkTypedDict(TypedDict):
+    text: str
+    
+
+class ContentChunk(BaseModel):
+    text: str
+    TYPE: Annotated[Final[Optional[str]], pydantic.Field(alias="type")] = "text" # type: ignore
+    

mistralai/models/delete_model_v1_models_model_id_deleteop.py

@@ -0,0 +1,18 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from mistralai.types import BaseModel
+from mistralai.utils import FieldMetadata, PathParamMetadata
+from typing import TypedDict
+from typing_extensions import Annotated
+
+
+class DeleteModelV1ModelsModelIDDeleteRequestTypedDict(TypedDict):
+    model_id: str
+    r"""The ID of the model to delete."""
+    
+
+class DeleteModelV1ModelsModelIDDeleteRequest(BaseModel):
+    model_id: Annotated[str, FieldMetadata(path=PathParamMetadata(style="simple", explode=False))]
+    r"""The ID of the model to delete."""
+    

mistralai/models/deletefileout.py

@@ -0,0 +1,24 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from mistralai.types import BaseModel
+from typing import TypedDict
+
+
+class DeleteFileOutTypedDict(TypedDict):
+    id: str
+    r"""The ID of the deleted file."""
+    object: str
+    r"""The object type that was deleted"""
+    deleted: bool
+    r"""The deletion status."""
+    
+
+class DeleteFileOut(BaseModel):
+    id: str
+    r"""The ID of the deleted file."""
+    object: str
+    r"""The object type that was deleted"""
+    deleted: bool
+    r"""The deletion status."""
+    

mistralai/models/deletemodelout.py

@@ -0,0 +1,25 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from mistralai.types import BaseModel
+from typing import Optional, TypedDict
+from typing_extensions import NotRequired
+
+
+class DeleteModelOutTypedDict(TypedDict):
+    id: str
+    r"""The ID of the deleted model."""
+    object: NotRequired[str]
+    r"""The object type that was deleted"""
+    deleted: NotRequired[bool]
+    r"""The deletion status"""
+    
+
+class DeleteModelOut(BaseModel):
+    id: str
+    r"""The ID of the deleted model."""
+    object: Optional[str] = "model"
+    r"""The object type that was deleted"""
+    deleted: Optional[bool] = True
+    r"""The deletion status"""
+    

mistralai/models/deltamessage.py

@@ -0,0 +1,47 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .toolcall import ToolCall, ToolCallTypedDict
+from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+from pydantic import model_serializer
+from typing import Optional, TypedDict
+from typing_extensions import NotRequired
+
+
+class DeltaMessageTypedDict(TypedDict):
+    role: NotRequired[str]
+    content: NotRequired[str]
+    tool_calls: NotRequired[Nullable[ToolCallTypedDict]]
+    
+
+class DeltaMessage(BaseModel):
+    role: Optional[str] = None
+    content: Optional[str] = None
+    tool_calls: OptionalNullable[ToolCall] = UNSET
+    
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["role", "content", "tool_calls"]
+        nullable_fields = ["tool_calls"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in self.model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            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/models/detailedjobout.py

@@ -0,0 +1,91 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .checkpointout import CheckpointOut, CheckpointOutTypedDict
+from .eventout import EventOut, EventOutTypedDict
+from .finetuneablemodel import FineTuneableModel
+from .githubrepositoryout import GithubRepositoryOut, GithubRepositoryOutTypedDict
+from .jobmetadataout import JobMetadataOut, JobMetadataOutTypedDict
+from .trainingparameters import TrainingParameters, TrainingParametersTypedDict
+from .wandbintegrationout import WandbIntegrationOut, WandbIntegrationOutTypedDict
+from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+import pydantic
+from pydantic import model_serializer
+from typing import Final, List, Literal, Optional, TypedDict
+from typing_extensions import Annotated, NotRequired
+
+
+DetailedJobOutStatus = Literal["QUEUED", "STARTED", "VALIDATING", "VALIDATED", "RUNNING", "FAILED_VALIDATION", "FAILED", "SUCCESS", "CANCELLED", "CANCELLATION_REQUESTED"]
+
+class DetailedJobOutTypedDict(TypedDict):
+    id: str
+    auto_start: bool
+    hyperparameters: TrainingParametersTypedDict
+    model: FineTuneableModel
+    r"""The name of the model to fine-tune."""
+    status: DetailedJobOutStatus
+    job_type: str
+    created_at: int
+    modified_at: int
+    training_files: List[str]
+    validation_files: NotRequired[Nullable[List[str]]]
+    fine_tuned_model: NotRequired[Nullable[str]]
+    suffix: NotRequired[Nullable[str]]
+    integrations: NotRequired[Nullable[List[WandbIntegrationOutTypedDict]]]
+    trained_tokens: NotRequired[Nullable[int]]
+    repositories: NotRequired[List[GithubRepositoryOutTypedDict]]
+    metadata: NotRequired[Nullable[JobMetadataOutTypedDict]]
+    events: NotRequired[List[EventOutTypedDict]]
+    r"""Event items are created every time the status of a fine-tuning job changes. The timestamped list of all events is accessible here."""
+    checkpoints: NotRequired[List[CheckpointOutTypedDict]]
+    
+
+class DetailedJobOut(BaseModel):
+    id: str
+    auto_start: bool
+    hyperparameters: TrainingParameters
+    model: FineTuneableModel
+    r"""The name of the model to fine-tune."""
+    status: DetailedJobOutStatus
+    job_type: str
+    created_at: int
+    modified_at: int
+    training_files: List[str]
+    validation_files: OptionalNullable[List[str]] = UNSET
+    OBJECT: Annotated[Final[Optional[str]], pydantic.Field(alias="object")] = "job" # type: ignore
+    fine_tuned_model: OptionalNullable[str] = UNSET
+    suffix: OptionalNullable[str] = UNSET
+    integrations: OptionalNullable[List[WandbIntegrationOut]] = UNSET
+    trained_tokens: OptionalNullable[int] = UNSET
+    repositories: Optional[List[GithubRepositoryOut]] = None
+    metadata: OptionalNullable[JobMetadataOut] = UNSET
+    events: Optional[List[EventOut]] = None
+    r"""Event items are created every time the status of a fine-tuning job changes. The timestamped list of all events is accessible here."""
+    checkpoints: Optional[List[CheckpointOut]] = None
+    
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["validation_files", "object", "fine_tuned_model", "suffix", "integrations", "trained_tokens", "repositories", "metadata", "events", "checkpoints"]
+        nullable_fields = ["validation_files", "fine_tuned_model", "suffix", "integrations", "trained_tokens", "metadata"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in self.model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            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/models/embeddingrequest.py

@@ -0,0 +1,61 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+import pydantic
+from pydantic import model_serializer
+from typing import List, TypedDict, Union
+from typing_extensions import Annotated, NotRequired
+
+
+class EmbeddingRequestTypedDict(TypedDict):
+    inputs: InputsTypedDict
+    r"""Text to embed."""
+    model: str
+    r"""ID of the model to use."""
+    encoding_format: NotRequired[Nullable[str]]
+    r"""The format to return the embeddings in."""
+    
+
+class EmbeddingRequest(BaseModel):
+    inputs: Annotated[Inputs, pydantic.Field(alias="input")]
+    r"""Text to embed."""
+    model: str
+    r"""ID of the model to use."""
+    encoding_format: OptionalNullable[str] = UNSET
+    r"""The format to return the embeddings in."""
+    
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["encoding_format"]
+        nullable_fields = ["encoding_format"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in self.model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            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
+        
+
+InputsTypedDict = Union[str, List[str]]
+r"""Text to embed."""
+
+
+Inputs = Union[str, List[str]]
+r"""Text to embed."""
+

mistralai/models/embeddingresponse.py

@@ -0,0 +1,24 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .embeddingresponsedata import EmbeddingResponseData, EmbeddingResponseDataTypedDict
+from .usageinfo import UsageInfo, UsageInfoTypedDict
+from mistralai.types import BaseModel
+from typing import List, TypedDict
+
+
+class EmbeddingResponseTypedDict(TypedDict):
+    id: str
+    object: str
+    model: str
+    usage: UsageInfoTypedDict
+    data: List[EmbeddingResponseDataTypedDict]
+    
+
+class EmbeddingResponse(BaseModel):
+    id: str
+    object: str
+    model: str
+    usage: UsageInfo
+    data: List[EmbeddingResponseData]
+    

mistralai/models/embeddingresponsedata.py

@@ -0,0 +1,19 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from mistralai.types import BaseModel
+from typing import List, Optional, TypedDict
+from typing_extensions import NotRequired
+
+
+class EmbeddingResponseDataTypedDict(TypedDict):
+    object: NotRequired[str]
+    embedding: NotRequired[List[float]]
+    index: NotRequired[int]
+    
+
+class EmbeddingResponseData(BaseModel):
+    object: Optional[str] = None
+    embedding: Optional[List[float]] = None
+    index: Optional[int] = None
+    

mistralai/models/eventout.py

@@ -0,0 +1,50 @@
+"""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 pydantic import model_serializer
+from typing import Any, Dict, TypedDict
+from typing_extensions import NotRequired
+
+
+class EventOutTypedDict(TypedDict):
+    name: str
+    r"""The name of the event."""
+    created_at: int
+    r"""The UNIX timestamp (in seconds) of the event."""
+    data: NotRequired[Nullable[Dict[str, Any]]]
+    
+
+class EventOut(BaseModel):
+    name: str
+    r"""The name of the event."""
+    created_at: int
+    r"""The UNIX timestamp (in seconds) of the event."""
+    data: OptionalNullable[Dict[str, Any]] = UNSET
+    
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["data"]
+        nullable_fields = ["data"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in self.model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            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/models/files_api_routes_delete_fileop.py

@@ -0,0 +1,16 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from mistralai.types import BaseModel
+from mistralai.utils import FieldMetadata, PathParamMetadata
+from typing import TypedDict
+from typing_extensions import Annotated
+
+
+class FilesAPIRoutesDeleteFileRequestTypedDict(TypedDict):
+    file_id: str
+    
+
+class FilesAPIRoutesDeleteFileRequest(BaseModel):
+    file_id: Annotated[str, FieldMetadata(path=PathParamMetadata(style="simple", explode=False))]
+    

mistralai/models/files_api_routes_retrieve_fileop.py

@@ -0,0 +1,16 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from mistralai.types import BaseModel
+from mistralai.utils import FieldMetadata, PathParamMetadata
+from typing import TypedDict
+from typing_extensions import Annotated
+
+
+class FilesAPIRoutesRetrieveFileRequestTypedDict(TypedDict):
+    file_id: str
+    
+
+class FilesAPIRoutesRetrieveFileRequest(BaseModel):
+    file_id: Annotated[str, FieldMetadata(path=PathParamMetadata(style="simple", explode=False))]
+    

mistralai/models/files_api_routes_upload_fileop.py

@@ -0,0 +1,51 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+import io
+from mistralai.types import BaseModel
+from mistralai.utils import FieldMetadata, MultipartFormMetadata
+import pydantic
+from typing import Final, IO, Optional, TypedDict, Union
+from typing_extensions import Annotated, NotRequired
+
+
+class FileTypedDict(TypedDict):
+    file_name: str
+    content: Union[bytes, IO[bytes], io.BufferedReader]
+    content_type: NotRequired[str]
+    
+
+class File(BaseModel):
+    file_name: Annotated[str, pydantic.Field(alias="file"), FieldMetadata(multipart=True)]
+    content: Annotated[Union[bytes, IO[bytes], io.BufferedReader], pydantic.Field(alias=""), FieldMetadata(multipart=MultipartFormMetadata(content=True))]
+    content_type: Annotated[Optional[str], pydantic.Field(alias="Content-Type"), FieldMetadata(multipart=True)] = None
+    
+
+class FilesAPIRoutesUploadFileMultiPartBodyParamsTypedDict(TypedDict):
+    file: FileTypedDict
+    r"""The File object (not file name) to be uploaded.
+    To upload a file and specify a custom file name you should format your request as such:
+    ```bash
+    file=@path/to/your/file.jsonl;filename=custom_name.jsonl
+    ```
+    Otherwise, you can just keep the original file name:
+    ```bash
+    file=@path/to/your/file.jsonl
+    ```
+    """
+    
+
+class FilesAPIRoutesUploadFileMultiPartBodyParams(BaseModel):
+    file: Annotated[File, pydantic.Field(alias=""), FieldMetadata(multipart=MultipartFormMetadata(file=True))]
+    r"""The File object (not file name) to be uploaded.
+    To upload a file and specify a custom file name you should format your request as such:
+    ```bash
+    file=@path/to/your/file.jsonl;filename=custom_name.jsonl
+    ```
+    Otherwise, you can just keep the original file name:
+    ```bash
+    file=@path/to/your/file.jsonl
+    ```
+    """
+    PURPOSE: Annotated[Final[Optional[str]], pydantic.Field(alias="purpose"), FieldMetadata(multipart=True)] = "fine-tune" # type: ignore
+    

mistralai/models/fileschema.py

@@ -0,0 +1,71 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .sampletype import SampleType
+from .source import Source
+from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+import pydantic
+from pydantic import model_serializer
+from typing import Final, TypedDict
+from typing_extensions import Annotated, NotRequired
+
+
+class FileSchemaTypedDict(TypedDict):
+    id: str
+    r"""The unique identifier of the file."""
+    object: str
+    r"""The object type, which is always \"file\"."""
+    bytes: int
+    r"""The size of the file, in bytes."""
+    created_at: int
+    r"""The UNIX timestamp (in seconds) of the event."""
+    filename: str
+    r"""The name of the uploaded file."""
+    sample_type: SampleType
+    source: Source
+    num_lines: NotRequired[Nullable[int]]
+    
+
+class FileSchema(BaseModel):
+    id: str
+    r"""The unique identifier of the file."""
+    object: str
+    r"""The object type, which is always \"file\"."""
+    bytes: int
+    r"""The size of the file, in bytes."""
+    created_at: int
+    r"""The UNIX timestamp (in seconds) of the event."""
+    filename: str
+    r"""The name of the uploaded file."""
+    sample_type: SampleType
+    source: Source
+    PURPOSE: Annotated[Final[str], pydantic.Field(alias="purpose")] = "fine-tune" # type: ignore
+    r"""The intended purpose of the uploaded file. Only accepts fine-tuning (`fine-tune`) for now."""
+    num_lines: OptionalNullable[int] = UNSET
+    
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["num_lines"]
+        nullable_fields = ["num_lines"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in self.model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            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
+