mistralai 1.9.11__py3-none-any.whl → 1.10.1__py3-none-any.whl

mistralai/models/sharingdelete.py

@@ -2,25 +2,56 @@
 
 from __future__ import annotations
 from .entitytype import EntityType
-from mistralai.types import BaseModel
+from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
 from mistralai.utils import validate_open_enum
+from pydantic import model_serializer
 from pydantic.functional_validators import PlainValidator
-from typing_extensions import Annotated, TypedDict
+from typing_extensions import Annotated, NotRequired, TypedDict
 
 
 class SharingDeleteTypedDict(TypedDict):
-    org_id: str
     share_with_uuid: str
     r"""The id of the entity (user, workspace or organization) to share with"""
     share_with_type: EntityType
     r"""The type of entity, used to share a library."""
+    org_id: NotRequired[Nullable[str]]
 
 
 class SharingDelete(BaseModel):
-    org_id: str
-
     share_with_uuid: str
     r"""The id of the entity (user, workspace or organization) to share with"""
 
     share_with_type: Annotated[EntityType, PlainValidator(validate_open_enum(False))]
     r"""The type of entity, used to share a library."""
+
+    org_id: OptionalNullable[str] = UNSET
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["org_id"]
+        nullable_fields = ["org_id"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in type(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/models/sharingin.py

@@ -3,24 +3,23 @@
 from __future__ import annotations
 from .entitytype import EntityType
 from .shareenum import ShareEnum
-from mistralai.types import BaseModel
+from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
 from mistralai.utils import validate_open_enum
+from pydantic import model_serializer
 from pydantic.functional_validators import PlainValidator
-from typing_extensions import Annotated, TypedDict
+from typing_extensions import Annotated, NotRequired, TypedDict
 
 
 class SharingInTypedDict(TypedDict):
-    org_id: str
     level: ShareEnum
     share_with_uuid: str
     r"""The id of the entity (user, workspace or organization) to share with"""
     share_with_type: EntityType
     r"""The type of entity, used to share a library."""
+    org_id: NotRequired[Nullable[str]]
 
 
 class SharingIn(BaseModel):
-    org_id: str
-
     level: Annotated[ShareEnum, PlainValidator(validate_open_enum(False))]
 
     share_with_uuid: str
@@ -28,3 +27,35 @@ class SharingIn(BaseModel):
 
     share_with_type: Annotated[EntityType, PlainValidator(validate_open_enum(False))]
     r"""The type of entity, used to share a library."""
+
+    org_id: OptionalNullable[str] = UNSET
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["org_id"]
+        nullable_fields = ["org_id"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in type(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/models/sharingout.py

@@ -11,7 +11,7 @@ class SharingOutTypedDict(TypedDict):
     org_id: str
     role: str
     share_with_type: str
-    share_with_uuid: str
+    share_with_uuid: Nullable[str]
     user_id: NotRequired[Nullable[str]]
 
 
@@ -24,14 +24,14 @@ class SharingOut(BaseModel):
 
     share_with_type: str
 
-    share_with_uuid: str
+    share_with_uuid: Nullable[str]
 
     user_id: OptionalNullable[str] = UNSET
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
         optional_fields = ["user_id"]
-        nullable_fields = ["user_id"]
+        nullable_fields = ["user_id", "share_with_uuid"]
         null_default_fields = []
 
         serialized = handler(self)

mistralai/models/toolexecutiondeltaevent.py

@@ -4,16 +4,25 @@ from __future__ import annotations
 from .builtinconnectors import BuiltInConnectors
 from datetime import datetime
 from mistralai.types import BaseModel
-from typing import Literal, Optional
-from typing_extensions import NotRequired, TypedDict
+from typing import Literal, Optional, Union
+from typing_extensions import NotRequired, TypeAliasType, TypedDict
 
 
 ToolExecutionDeltaEventType = Literal["tool.execution.delta"]
 
+ToolExecutionDeltaEventNameTypedDict = TypeAliasType(
+    "ToolExecutionDeltaEventNameTypedDict", Union[BuiltInConnectors, str]
+)
+
+
+ToolExecutionDeltaEventName = TypeAliasType(
+    "ToolExecutionDeltaEventName", Union[BuiltInConnectors, str]
+)
+
 
 class ToolExecutionDeltaEventTypedDict(TypedDict):
     id: str
-    name: BuiltInConnectors
+    name: ToolExecutionDeltaEventNameTypedDict
     arguments: str
     type: NotRequired[ToolExecutionDeltaEventType]
     created_at: NotRequired[datetime]
@@ -23,7 +32,7 @@ class ToolExecutionDeltaEventTypedDict(TypedDict):
 class ToolExecutionDeltaEvent(BaseModel):
     id: str
 
-    name: BuiltInConnectors
+    name: ToolExecutionDeltaEventName
 
     arguments: str
 

mistralai/models/toolexecutiondoneevent.py

@@ -4,16 +4,25 @@ from __future__ import annotations
 from .builtinconnectors import BuiltInConnectors
 from datetime import datetime
 from mistralai.types import BaseModel
-from typing import Any, Dict, Literal, Optional
-from typing_extensions import NotRequired, TypedDict
+from typing import Any, Dict, Literal, Optional, Union
+from typing_extensions import NotRequired, TypeAliasType, TypedDict
 
 
 ToolExecutionDoneEventType = Literal["tool.execution.done"]
 
+ToolExecutionDoneEventNameTypedDict = TypeAliasType(
+    "ToolExecutionDoneEventNameTypedDict", Union[BuiltInConnectors, str]
+)
+
+
+ToolExecutionDoneEventName = TypeAliasType(
+    "ToolExecutionDoneEventName", Union[BuiltInConnectors, str]
+)
+
 
 class ToolExecutionDoneEventTypedDict(TypedDict):
     id: str
-    name: BuiltInConnectors
+    name: ToolExecutionDoneEventNameTypedDict
     type: NotRequired[ToolExecutionDoneEventType]
     created_at: NotRequired[datetime]
     output_index: NotRequired[int]
@@ -23,7 +32,7 @@ class ToolExecutionDoneEventTypedDict(TypedDict):
 class ToolExecutionDoneEvent(BaseModel):
     id: str
 
-    name: BuiltInConnectors
+    name: ToolExecutionDoneEventName
 
     type: Optional[ToolExecutionDoneEventType] = "tool.execution.done"
 

mistralai/models/toolexecutionentry.py

@@ -5,17 +5,22 @@ from .builtinconnectors import BuiltInConnectors
 from datetime import datetime
 from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
 from pydantic import model_serializer
-from typing import Any, Dict, Literal, Optional
-from typing_extensions import NotRequired, TypedDict
+from typing import Any, Dict, Literal, Optional, Union
+from typing_extensions import NotRequired, TypeAliasType, TypedDict
 
 
 ToolExecutionEntryObject = Literal["entry"]
 
 ToolExecutionEntryType = Literal["tool.execution"]
 
+NameTypedDict = TypeAliasType("NameTypedDict", Union[BuiltInConnectors, str])
+
+
+Name = TypeAliasType("Name", Union[BuiltInConnectors, str])
+
 
 class ToolExecutionEntryTypedDict(TypedDict):
-    name: BuiltInConnectors
+    name: NameTypedDict
     arguments: str
     object: NotRequired[ToolExecutionEntryObject]
     type: NotRequired[ToolExecutionEntryType]
@@ -26,7 +31,7 @@ class ToolExecutionEntryTypedDict(TypedDict):
 
 
 class ToolExecutionEntry(BaseModel):
-    name: BuiltInConnectors
+    name: Name
 
     arguments: str
 

mistralai/models/toolexecutionstartedevent.py

@@ -4,16 +4,25 @@ from __future__ import annotations
 from .builtinconnectors import BuiltInConnectors
 from datetime import datetime
 from mistralai.types import BaseModel
-from typing import Literal, Optional
-from typing_extensions import NotRequired, TypedDict
+from typing import Literal, Optional, Union
+from typing_extensions import NotRequired, TypeAliasType, TypedDict
 
 
 ToolExecutionStartedEventType = Literal["tool.execution.started"]
 
+ToolExecutionStartedEventNameTypedDict = TypeAliasType(
+    "ToolExecutionStartedEventNameTypedDict", Union[BuiltInConnectors, str]
+)
+
+
+ToolExecutionStartedEventName = TypeAliasType(
+    "ToolExecutionStartedEventName", Union[BuiltInConnectors, str]
+)
+
 
 class ToolExecutionStartedEventTypedDict(TypedDict):
     id: str
-    name: BuiltInConnectors
+    name: ToolExecutionStartedEventNameTypedDict
     arguments: str
     type: NotRequired[ToolExecutionStartedEventType]
     created_at: NotRequired[datetime]
@@ -23,7 +32,7 @@ class ToolExecutionStartedEventTypedDict(TypedDict):
 class ToolExecutionStartedEvent(BaseModel):
     id: str
 
-    name: BuiltInConnectors
+    name: ToolExecutionStartedEventName
 
     arguments: str
 

mistralai/models/toolfilechunk.py

@@ -4,15 +4,22 @@ from __future__ import annotations
 from .builtinconnectors import BuiltInConnectors
 from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
 from pydantic import model_serializer
-from typing import Literal, Optional
-from typing_extensions import NotRequired, TypedDict
+from typing import Literal, Optional, Union
+from typing_extensions import NotRequired, TypeAliasType, TypedDict
 
 
 ToolFileChunkType = Literal["tool_file"]
 
+ToolFileChunkToolTypedDict = TypeAliasType(
+    "ToolFileChunkToolTypedDict", Union[BuiltInConnectors, str]
+)
+
+
+ToolFileChunkTool = TypeAliasType("ToolFileChunkTool", Union[BuiltInConnectors, str])
+
 
 class ToolFileChunkTypedDict(TypedDict):
-    tool: BuiltInConnectors
+    tool: ToolFileChunkToolTypedDict
     file_id: str
     type: NotRequired[ToolFileChunkType]
     file_name: NotRequired[Nullable[str]]
@@ -20,7 +27,7 @@ class ToolFileChunkTypedDict(TypedDict):
 
 
 class ToolFileChunk(BaseModel):
-    tool: BuiltInConnectors
+    tool: ToolFileChunkTool
 
     file_id: str
 

mistralai/models/toolreferencechunk.py

@@ -4,15 +4,24 @@ from __future__ import annotations
 from .builtinconnectors import BuiltInConnectors
 from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
 from pydantic import model_serializer
-from typing import Literal, Optional
-from typing_extensions import NotRequired, TypedDict
+from typing import Literal, Optional, Union
+from typing_extensions import NotRequired, TypeAliasType, TypedDict
 
 
 ToolReferenceChunkType = Literal["tool_reference"]
 
+ToolReferenceChunkToolTypedDict = TypeAliasType(
+    "ToolReferenceChunkToolTypedDict", Union[BuiltInConnectors, str]
+)
+
+
+ToolReferenceChunkTool = TypeAliasType(
+    "ToolReferenceChunkTool", Union[BuiltInConnectors, str]
+)
+
 
 class ToolReferenceChunkTypedDict(TypedDict):
-    tool: BuiltInConnectors
+    tool: ToolReferenceChunkToolTypedDict
     title: str
     type: NotRequired[ToolReferenceChunkType]
     url: NotRequired[Nullable[str]]
@@ -21,7 +30,7 @@ class ToolReferenceChunkTypedDict(TypedDict):
 
 
 class ToolReferenceChunk(BaseModel):
-    tool: BuiltInConnectors
+    tool: ToolReferenceChunkTool
 
     title: str
 

mistralai/models_.py

@@ -73,18 +73,12 @@ class Models(BaseSDK):
                 ),
             ),
             request=req,
-            error_status_codes=["422", "4XX", "5XX"],
+            error_status_codes=["4XX", "5XX"],
             retry_config=retry_config,
         )
 
-        response_data: Any = None
         if utils.match_response(http_res, "200", "application/json"):
             return unmarshal_json_response(models.ModelList, http_res)
-        if utils.match_response(http_res, "422", "application/json"):
-            response_data = unmarshal_json_response(
-                models.HTTPValidationErrorData, http_res
-            )
-            raise models.HTTPValidationError(response_data, http_res)
         if utils.match_response(http_res, "4XX", "*"):
             http_res_text = utils.stream_to_text(http_res)
             raise models.SDKError("API error occurred", http_res, http_res_text)
@@ -155,18 +149,12 @@ class Models(BaseSDK):
                 ),
             ),
             request=req,
-            error_status_codes=["422", "4XX", "5XX"],
+            error_status_codes=["4XX", "5XX"],
             retry_config=retry_config,
         )
 
-        response_data: Any = None
         if utils.match_response(http_res, "200", "application/json"):
             return unmarshal_json_response(models.ModelList, http_res)
-        if utils.match_response(http_res, "422", "application/json"):
-            response_data = unmarshal_json_response(
-                models.HTTPValidationErrorData, http_res
-            )
-            raise models.HTTPValidationError(response_data, http_res)
         if utils.match_response(http_res, "4XX", "*"):
             http_res_text = await utils.stream_to_text_async(http_res)
             raise models.SDKError("API error occurred", http_res, http_res_text)

mistralai/ocr.py

@@ -28,6 +28,9 @@ class Ocr(BaseSDK):
         document_annotation_format: OptionalNullable[
             Union[models.ResponseFormat, models.ResponseFormatTypedDict]
         ] = UNSET,
+        table_format: OptionalNullable[models.TableFormat] = UNSET,
+        extract_header: Optional[bool] = None,
+        extract_footer: Optional[bool] = None,
         retries: OptionalNullable[utils.RetryConfig] = UNSET,
         server_url: Optional[str] = None,
         timeout_ms: Optional[int] = None,
@@ -44,6 +47,9 @@ class Ocr(BaseSDK):
         :param image_min_size: Minimum height and width of image to extract
         :param bbox_annotation_format: Structured output class for extracting useful information from each extracted bounding box / image from document. Only json_schema is valid for this field
         :param document_annotation_format: Structured output class for extracting useful information from the entire document. Only json_schema is valid for this field
+        :param table_format:
+        :param extract_header:
+        :param extract_footer:
         :param retries: Override the default retry configuration for this method
         :param server_url: Override the default server URL for this method
         :param timeout_ms: Override the default request timeout configuration for this method in milliseconds
@@ -73,6 +79,9 @@ class Ocr(BaseSDK):
             document_annotation_format=utils.get_pydantic_model(
                 document_annotation_format, OptionalNullable[models.ResponseFormat]
             ),
+            table_format=table_format,
+            extract_header=extract_header,
+            extract_footer=extract_footer,
         )
 
         req = self._build_request(
@@ -150,6 +159,9 @@ class Ocr(BaseSDK):
         document_annotation_format: OptionalNullable[
             Union[models.ResponseFormat, models.ResponseFormatTypedDict]
         ] = UNSET,
+        table_format: OptionalNullable[models.TableFormat] = UNSET,
+        extract_header: Optional[bool] = None,
+        extract_footer: Optional[bool] = None,
         retries: OptionalNullable[utils.RetryConfig] = UNSET,
         server_url: Optional[str] = None,
         timeout_ms: Optional[int] = None,
@@ -166,6 +178,9 @@ class Ocr(BaseSDK):
         :param image_min_size: Minimum height and width of image to extract
         :param bbox_annotation_format: Structured output class for extracting useful information from each extracted bounding box / image from document. Only json_schema is valid for this field
         :param document_annotation_format: Structured output class for extracting useful information from the entire document. Only json_schema is valid for this field
+        :param table_format:
+        :param extract_header:
+        :param extract_footer:
         :param retries: Override the default retry configuration for this method
         :param server_url: Override the default server URL for this method
         :param timeout_ms: Override the default request timeout configuration for this method in milliseconds
@@ -195,6 +210,9 @@ class Ocr(BaseSDK):
             document_annotation_format=utils.get_pydantic_model(
                 document_annotation_format, OptionalNullable[models.ResponseFormat]
             ),
+            table_format=table_format,
+            extract_header=extract_header,
+            extract_footer=extract_footer,
         )
 
         req = self._build_request_async(

mistralai/transcriptions.py

@@ -29,7 +29,7 @@ class Transcriptions(BaseSDK):
     ) -> models.TranscriptionResponse:
         r"""Create Transcription
 
-        :param model:
+        :param model: ID of the model to be used.
         :param file:
         :param file_url: Url of a file to be transcribed
         :param file_id: ID of a file uploaded to /v1/files
@@ -131,7 +131,7 @@ class Transcriptions(BaseSDK):
     ) -> models.TranscriptionResponse:
         r"""Create Transcription
 
-        :param model:
+        :param model: ID of the model to be used.
         :param file:
         :param file_url: Url of a file to be transcribed
         :param file_id: ID of a file uploaded to /v1/files
@@ -231,7 +231,7 @@ class Transcriptions(BaseSDK):
         timeout_ms: Optional[int] = None,
         http_headers: Optional[Mapping[str, str]] = None,
     ) -> eventstreaming.EventStream[models.TranscriptionStreamEvents]:
-        r"""Create streaming transcription (SSE)
+        r"""Create Streaming Transcription (SSE)
 
         :param model:
         :param file:
@@ -343,7 +343,7 @@ class Transcriptions(BaseSDK):
         timeout_ms: Optional[int] = None,
         http_headers: Optional[Mapping[str, str]] = None,
     ) -> eventstreaming.EventStreamAsync[models.TranscriptionStreamEvents]:
-        r"""Create streaming transcription (SSE)
+        r"""Create Streaming Transcription (SSE)
 
         :param model:
         :param file: