mistralai 1.2.3__py3-none-any.whl → 1.2.5__py3-none-any.whl

mistralai_gcp/models/functioncall.py

@@ -3,13 +3,13 @@
 from __future__ import annotations
 from mistralai_gcp.types import BaseModel
 from typing import Any, Dict, Union
-from typing_extensions import TypedDict
+from typing_extensions import TypeAliasType, TypedDict
 
 
-ArgumentsTypedDict = Union[Dict[str, Any], str]
+ArgumentsTypedDict = TypeAliasType("ArgumentsTypedDict", Union[Dict[str, Any], str])
 
 
-Arguments = Union[Dict[str, Any], str]
+Arguments = TypeAliasType("Arguments", Union[Dict[str, Any], str])
 
 
 class FunctionCallTypedDict(TypedDict):

mistralai_gcp/models/referencechunk.py

@@ -2,11 +2,8 @@
 
 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 List, Literal, Optional
-from typing_extensions import Annotated, TypedDict
+from typing_extensions import NotRequired, TypedDict
 
 
 ReferenceChunkType = Literal["reference"]
@@ -14,15 +11,10 @@ ReferenceChunkType = Literal["reference"]
 
 class ReferenceChunkTypedDict(TypedDict):
     reference_ids: List[int]
-    type: ReferenceChunkType
+    type: NotRequired[ReferenceChunkType]
 
 
 class ReferenceChunk(BaseModel):
     reference_ids: List[int]
 
-    TYPE: Annotated[
-        Annotated[
-            Optional[ReferenceChunkType], AfterValidator(validate_const("reference"))
-        ],
-        pydantic.Field(alias="type"),
-    ] = "reference"
+    type: Optional[ReferenceChunkType] = "reference"

mistralai_gcp/models/systemmessage.py

@@ -4,13 +4,17 @@ from __future__ import annotations
 from .textchunk import TextChunk, TextChunkTypedDict
 from mistralai_gcp.types import BaseModel
 from typing import List, Literal, Optional, Union
-from typing_extensions import NotRequired, TypedDict
+from typing_extensions import NotRequired, TypeAliasType, TypedDict
 
 
-SystemMessageContentTypedDict = Union[str, List[TextChunkTypedDict]]
+SystemMessageContentTypedDict = TypeAliasType(
+    "SystemMessageContentTypedDict", Union[str, List[TextChunkTypedDict]]
+)
 
 
-SystemMessageContent = Union[str, List[TextChunk]]
+SystemMessageContent = TypeAliasType(
+    "SystemMessageContent", Union[str, List[TextChunk]]
+)
 
 
 Role = Literal["system"]

mistralai_gcp/models/textchunk.py

@@ -2,11 +2,8 @@
 
 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, TypedDict
+from typing_extensions import NotRequired, TypedDict
 
 
 Type = Literal["text"]
@@ -14,13 +11,10 @@ Type = Literal["text"]
 
 class TextChunkTypedDict(TypedDict):
     text: str
-    type: Type
+    type: NotRequired[Type]
 
 
 class TextChunk(BaseModel):
     text: str
 
-    TYPE: Annotated[
-        Annotated[Optional[Type], AfterValidator(validate_const("text"))],
-        pydantic.Field(alias="type"),
-    ] = "text"
+    type: Optional[Type] = "text"

mistralai_gcp/models/toolmessage.py

@@ -11,13 +11,15 @@ from mistralai_gcp.types import (
 )
 from pydantic import model_serializer
 from typing import List, Literal, Optional, Union
-from typing_extensions import NotRequired, TypedDict
+from typing_extensions import NotRequired, TypeAliasType, TypedDict
 
 
-ToolMessageContentTypedDict = Union[str, List[ContentChunkTypedDict]]
+ToolMessageContentTypedDict = TypeAliasType(
+    "ToolMessageContentTypedDict", Union[str, List[ContentChunkTypedDict]]
+)
 
 
-ToolMessageContent = Union[str, List[ContentChunk]]
+ToolMessageContent = TypeAliasType("ToolMessageContent", Union[str, List[ContentChunk]])
 
 
 ToolMessageRole = Literal["tool"]

mistralai_gcp/models/usermessage.py

@@ -5,13 +5,15 @@ from .contentchunk import ContentChunk, ContentChunkTypedDict
 from mistralai_gcp.types import BaseModel, Nullable, UNSET_SENTINEL
 from pydantic import model_serializer
 from typing import List, Literal, Optional, Union
-from typing_extensions import NotRequired, TypedDict
+from typing_extensions import NotRequired, TypeAliasType, TypedDict
 
 
-UserMessageContentTypedDict = Union[str, List[ContentChunkTypedDict]]
+UserMessageContentTypedDict = TypeAliasType(
+    "UserMessageContentTypedDict", Union[str, List[ContentChunkTypedDict]]
+)
 
 
-UserMessageContent = Union[str, List[ContentChunk]]
+UserMessageContent = TypeAliasType("UserMessageContent", Union[str, List[ContentChunk]])
 
 
 UserMessageRole = Literal["user"]

mistralai_gcp/models/validationerror.py

@@ -3,13 +3,13 @@
 from __future__ import annotations
 from mistralai_gcp.types import BaseModel
 from typing import List, Union
-from typing_extensions import TypedDict
+from typing_extensions import TypeAliasType, TypedDict
 
 
-LocTypedDict = Union[str, int]
+LocTypedDict = TypeAliasType("LocTypedDict", Union[str, int])
 
 
-Loc = Union[str, int]
+Loc = TypeAliasType("Loc", Union[str, int])
 
 
 class ValidationErrorTypedDict(TypedDict):

mistralai_gcp/sdk.py

@@ -26,11 +26,12 @@ 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.
-    model_id = LEGACY_MODEL_ID_FORMAT.get(model, model)
-    model = "-".join(model.split("-")[:-1])
-    return model, model_id
+    if model in LEGACY_MODEL_ID_FORMAT:
+        return "-".join(model.split("-")[:-1]), LEGACY_MODEL_ID_FORMAT[model]
+    else:
+        return model, model
 
 
 

mistralai_gcp/sdkconfiguration.py

@@ -29,8 +29,8 @@ class SDKConfiguration:
     language: str = "python"
     openapi_doc_version: str = "0.0.2"
     sdk_version: str = "1.2.3"
-    gen_version: str = "2.460.1"
-    user_agent: str = "speakeasy-sdk/python 1.2.3 2.460.1 0.0.2 mistralai-gcp"
+    gen_version: str = "2.470.1"
+    user_agent: str = "speakeasy-sdk/python 1.2.3 2.470.1 0.0.2 mistralai-gcp"
     retry_config: OptionalNullable[RetryConfig] = Field(default_factory=lambda: UNSET)
     timeout_ms: Optional[int] = None
 

mistralai_gcp/utils/annotations.py

@@ -1,30 +1,55 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from enum import Enum
-from typing import Any
+from typing import Any, Optional
 
 def get_discriminator(model: Any, fieldname: str, key: str) -> str:
-    if isinstance(model, dict):
-        try:
-            return f'{model.get(key)}'
-        except AttributeError as e:
-            raise ValueError(f'Could not find discriminator key {key} in {model}') from e
+    """
+    Recursively search for the discriminator attribute in a model.
 
-    if hasattr(model, fieldname):
-        attr = getattr(model, fieldname)
+    Args:
+        model (Any): The model to search within.
+        fieldname (str): The name of the field to search for.
+        key (str): The key to search for in dictionaries.
 
-        if isinstance(attr, Enum):
-            return f'{attr.value}'
+    Returns:
+        str: The name of the discriminator attribute.
 
-        return f'{attr}'
+    Raises:
+        ValueError: If the discriminator attribute is not found.
+    """
+    upper_fieldname = fieldname.upper()
 
-    fieldname = fieldname.upper()
-    if hasattr(model, fieldname):
-        attr = getattr(model, fieldname)
+    def get_field_discriminator(field: Any) -> Optional[str]:
+        """Search for the discriminator attribute in a given field."""
 
-        if isinstance(attr, Enum):
-            return f'{attr.value}'
+        if isinstance(field, dict):
+            if key in field:
+                return f'{field[key]}'
 
-        return f'{attr}'
+        if hasattr(field, fieldname):
+            attr = getattr(field, fieldname)
+            if isinstance(attr, Enum):
+                return f'{attr.value}'
+            return f'{attr}'
+
+        if hasattr(field, upper_fieldname):
+            attr = getattr(field, upper_fieldname)
+            if isinstance(attr, Enum):
+                return f'{attr.value}'
+            return f'{attr}'
+
+        return None
+
+
+    if isinstance(model, list):
+        for field in model:
+            discriminator = get_field_discriminator(field)
+            if discriminator is not None:
+                return discriminator
+
+    discriminator = get_field_discriminator(model)
+    if discriminator is not None:
+        return discriminator
 
     raise ValueError(f'Could not find discriminator field {fieldname} in {model}')

mistralai_gcp/utils/eventstreaming.py

@@ -2,12 +2,72 @@
 
 import re
 import json
-from typing import Callable, TypeVar, Optional, Generator, AsyncGenerator, Tuple
+from typing import (
+    Callable,
+    Generic,
+    TypeVar,
+    Optional,
+    Generator,
+    AsyncGenerator,
+    Tuple,
+)
 import httpx
 
 T = TypeVar("T")
 
 
+class EventStream(Generic[T]):
+    response: httpx.Response
+    generator: Generator[T, None, None]
+
+    def __init__(
+        self,
+        response: httpx.Response,
+        decoder: Callable[[str], T],
+        sentinel: Optional[str] = None,
+    ):
+        self.response = response
+        self.generator = stream_events(response, decoder, sentinel)
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        return next(self.generator)
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.response.close()
+
+
+class EventStreamAsync(Generic[T]):
+    response: httpx.Response
+    generator: AsyncGenerator[T, None]
+
+    def __init__(
+        self,
+        response: httpx.Response,
+        decoder: Callable[[str], T],
+        sentinel: Optional[str] = None,
+    ):
+        self.response = response
+        self.generator = stream_events_async(response, decoder, sentinel)
+
+    def __aiter__(self):
+        return self
+
+    async def __anext__(self):
+        return await self.generator.__anext__()
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.response.aclose()
+
+
 class ServerEvent:
     id: Optional[str] = None
     event: Optional[str] = None

mistralai/models/finetuneablemodel.py

@@ -1,14 +0,0 @@
-"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
-
-from __future__ import annotations
-from typing import Literal
-
-
-FineTuneableModel = Literal[
-    "open-mistral-7b",
-    "mistral-small-latest",
-    "codestral-latest",
-    "mistral-large-latest",
-    "open-mistral-nemo",
-]
-r"""The name of the model to fine-tune."""