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

mistralai_gcp/models/httpvalidationerror.py

@@ -0,0 +1,23 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .validationerror import ValidationError
+from mistralai_gcp import utils
+from mistralai_gcp.types import BaseModel
+from typing import List, Optional
+
+class HTTPValidationErrorData(BaseModel):
+    detail: Optional[List[ValidationError]] = None
+    
+
+
+class HTTPValidationError(Exception):
+    r"""Validation Error"""
+    data: HTTPValidationErrorData
+
+    def __init__(self, data: HTTPValidationErrorData):
+        self.data = data
+
+    def __str__(self) -> str:
+        return utils.marshal_json(self.data, HTTPValidationErrorData)
+

mistralai_gcp/models/responseformat.py

@@ -0,0 +1,18 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from mistralai_gcp.types import BaseModel
+from typing import Literal, Optional, TypedDict
+from typing_extensions import NotRequired
+
+
+ResponseFormats = Literal["text", "json_object"]
+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."""
+
+class ResponseFormatTypedDict(TypedDict):
+    type: NotRequired[ResponseFormats]
+    
+
+class ResponseFormat(BaseModel):
+    type: Optional[ResponseFormats] = "text"
+    

mistralai_gcp/models/sdkerror.py

@@ -0,0 +1,22 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from dataclasses import dataclass
+from typing import Optional
+import httpx
+
+
+@dataclass
+class SDKError(Exception):
+    """Represents an error returned by the API."""
+
+    message: str
+    status_code: int = -1
+    body: str = ""
+    raw_response: Optional[httpx.Response] = None
+
+    def __str__(self):
+        body = ""
+        if len(self.body) > 0:
+            body = f"\n{self.body}"
+
+        return f"{self.message}: Status {self.status_code}{body}"

mistralai_gcp/models/security.py

@@ -0,0 +1,16 @@
+"""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 FieldMetadata, SecurityMetadata
+from typing import TypedDict
+from typing_extensions import Annotated
+
+
+class SecurityTypedDict(TypedDict):
+    api_key: str
+    
+
+class Security(BaseModel):
+    api_key: Annotated[str, FieldMetadata(security=SecurityMetadata(scheme=True, scheme_type="http", sub_type="bearer", field_name="Authorization"))]
+    

mistralai_gcp/models/systemmessage.py

@@ -0,0 +1,26 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .contentchunk import ContentChunk, ContentChunkTypedDict
+from mistralai_gcp.types import BaseModel
+from typing import List, Literal, Optional, TypedDict, Union
+from typing_extensions import NotRequired
+
+
+Role = Literal["system"]
+
+class SystemMessageTypedDict(TypedDict):
+    content: ContentTypedDict
+    role: NotRequired[Role]
+    
+
+class SystemMessage(BaseModel):
+    content: Content
+    role: Optional[Role] = "system"
+    
+
+ContentTypedDict = Union[str, List[ContentChunkTypedDict]]
+
+
+Content = Union[str, List[ContentChunk]]
+

mistralai_gcp/models/textchunk.py

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

mistralai_gcp/models/tool.py

@@ -0,0 +1,18 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .function import Function, FunctionTypedDict
+from mistralai_gcp.types import BaseModel
+import pydantic
+from typing import Final, Optional, TypedDict
+from typing_extensions import Annotated
+
+
+class ToolTypedDict(TypedDict):
+    function: FunctionTypedDict
+    
+
+class Tool(BaseModel):
+    function: Function
+    TYPE: Annotated[Final[Optional[str]], pydantic.Field(alias="type")] = "function" # type: ignore
+    

mistralai_gcp/models/toolcall.py

@@ -0,0 +1,20 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .functioncall import FunctionCall, FunctionCallTypedDict
+from mistralai_gcp.types import BaseModel
+import pydantic
+from typing import Final, Optional, TypedDict
+from typing_extensions import Annotated, NotRequired
+
+
+class ToolCallTypedDict(TypedDict):
+    function: FunctionCallTypedDict
+    id: NotRequired[str]
+    
+
+class ToolCall(BaseModel):
+    function: FunctionCall
+    id: Optional[str] = "null"
+    TYPE: Annotated[Final[Optional[str]], pydantic.Field(alias="type")] = "function" # type: ignore
+    

mistralai_gcp/models/toolmessage.py

@@ -0,0 +1,50 @@
+"""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
+from pydantic import model_serializer
+from typing import Literal, Optional, TypedDict
+from typing_extensions import NotRequired
+
+
+ToolMessageRole = Literal["tool"]
+
+class ToolMessageTypedDict(TypedDict):
+    content: str
+    tool_call_id: NotRequired[Nullable[str]]
+    name: NotRequired[Nullable[str]]
+    role: NotRequired[ToolMessageRole]
+    
+
+class ToolMessage(BaseModel):
+    content: str
+    tool_call_id: OptionalNullable[str] = UNSET
+    name: OptionalNullable[str] = UNSET
+    role: Optional[ToolMessageRole] = "tool"
+    
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["tool_call_id", "name", "role"]
+        nullable_fields = ["tool_call_id", "name"]
+        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_gcp/models/usageinfo.py

@@ -0,0 +1,18 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from mistralai_gcp.types import BaseModel
+from typing import TypedDict
+
+
+class UsageInfoTypedDict(TypedDict):
+    prompt_tokens: int
+    completion_tokens: int
+    total_tokens: int
+    
+
+class UsageInfo(BaseModel):
+    prompt_tokens: int
+    completion_tokens: int
+    total_tokens: int
+    

mistralai_gcp/models/usermessage.py

@@ -0,0 +1,26 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .textchunk import TextChunk, TextChunkTypedDict
+from mistralai_gcp.types import BaseModel
+from typing import List, Literal, Optional, TypedDict, Union
+from typing_extensions import NotRequired
+
+
+UserMessageRole = Literal["user"]
+
+class UserMessageTypedDict(TypedDict):
+    content: UserMessageContentTypedDict
+    role: NotRequired[UserMessageRole]
+    
+
+class UserMessage(BaseModel):
+    content: UserMessageContent
+    role: Optional[UserMessageRole] = "user"
+    
+
+UserMessageContentTypedDict = Union[str, List[TextChunkTypedDict]]
+
+
+UserMessageContent = Union[str, List[TextChunk]]
+

mistralai_gcp/models/validationerror.py

@@ -0,0 +1,24 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from mistralai_gcp.types import BaseModel
+from typing import List, TypedDict, Union
+
+
+class ValidationErrorTypedDict(TypedDict):
+    loc: List[LocTypedDict]
+    msg: str
+    type: str
+    
+
+class ValidationError(BaseModel):
+    loc: List[Loc]
+    msg: str
+    type: str
+    
+
+LocTypedDict = Union[str, int]
+
+
+Loc = Union[str, int]
+

mistralai_gcp/py.typed

@@ -0,0 +1 @@
+# Marker file for PEP 561. The package enables type hints.

mistralai_gcp/sdk.py

@@ -0,0 +1,174 @@
+"""Code generated by Speakeasy (https://speakeasyapi.dev). DO NOT EDIT."""
+
+import json
+from typing import Optional, Union
+
+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 .basesdk import BaseSDK
+from .httpclient import AsyncHttpClient, HttpClient
+from .sdkconfiguration import SDKConfiguration
+from .utils.logger import Logger, NoOpLogger
+from .utils.retries import RetryConfig
+
+
+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
+    fim: Fim
+    r"""Chat Completion API"""
+
+    def __init__(
+        self,
+        region: str = "europe-west4",
+        project_id: Optional[str] = None,
+        client: Optional[HttpClient] = None,
+        async_client: Optional[AsyncHttpClient] = None,
+        retry_config: Optional[Nullable[RetryConfig]] = 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 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
+        """
+
+        credentials, loaded_project_id = google.auth.default(
+            scopes=["https://www.googleapis.com/auth/cloud-platform"],
+        )
+
+        if not isinstance(credentials, google.auth.credentials.Credentials):
+            raise models.SDKError(
+                "credentials must be an instance of google.auth.credentials.Credentials"
+            )
+
+        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 credentials.expired:
+                credentials.refresh(google.auth.transport.requests.Request())
+            token = credentials.token
+            if not token:
+                raise models.SDKError("Failed to get token from credentials")
+            return token
+
+        if client is None:
+            client = httpx.Client()
+
+        assert issubclass(
+            type(client), HttpClient
+        ), "The provided client must implement the HttpClient protocol."
+
+        if async_client is None:
+            async_client = httpx.AsyncClient()
+
+        if debug_logger is None:
+            debug_logger = NoOpLogger()
+
+        assert issubclass(
+            type(async_client), AsyncHttpClient
+        ), "The provided async_client must implement the AsyncHttpClient protocol."
+
+        security = None
+        if callable(auth_token):
+            security = lambda: models.Security(  # pylint: disable=unnecessary-lambda-assignment
+                api_key=auth_token()
+            )
+        else:
+            security = models.Security(api_key=auth_token)
+
+        BaseSDK.__init__(
+            self,
+            SDKConfiguration(
+                client=client,
+                async_client=async_client,
+                security=security,
+                server_url=f"https://{region}-aiplatform.googleapis.com",
+                server=None,
+                retry_config=retry_config,
+                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
+        )
+        if current_server_url != server_url:
+            self.sdk_configuration.server_url = server_url
+
+        # pylint: disable=protected-access
+        self.sdk_configuration.__dict__["_hooks"] = hooks
+
+        self._init_sdks()
+
+    def _init_sdks(self):
+        self.chat = Chat(self.sdk_configuration)
+        self.fim = Fim(self.sdk_configuration)
+
+
+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]:
+        # The goal of this function is to template in the region, project, model, and model_version into the URL path
+        # We do this here so that the API remains more user-friendly
+        model = None
+        model_version = None
+        new_content = None
+        if request.content:
+            parsed = json.loads(request.content.decode("utf-8"))
+            model_raw = parsed.get("model")
+            model = "-".join(model_raw.split("-")[:-1])
+            model_version = model_raw.split("-")[-1]
+            parsed["model"] = model
+            new_content = json.dumps(parsed).encode("utf-8")
+
+        if model == "":
+            raise models.SDKError("model must be provided")
+
+        if model_version is None:
+            raise models.SDKError("model_version 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}@{model_version}:{specifier}"
+
+        headers = dict(request.headers)
+        # Delete content-length header as it will need to be recalculated
+        headers.pop("content-length", None)
+
+        next_request = httpx.Request(
+            method=request.method,
+            url=request.url.copy_with(path=url),
+            headers=headers,
+            content=new_content,
+            stream=None,
+        )
+
+        return next_request

mistralai_gcp/sdkconfiguration.py

@@ -0,0 +1,54 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+
+from ._hooks import SDKHooks
+from .httpclient import AsyncHttpClient, HttpClient
+from .utils import Logger, RetryConfig, remove_suffix
+from dataclasses import dataclass
+from mistralai_gcp import models
+from mistralai_gcp.types import OptionalNullable, UNSET
+from pydantic import Field
+from typing import Callable, Dict, Optional, Tuple, Union
+
+
+SERVER_PROD = "prod"
+r"""Production server"""
+SERVERS = {
+	SERVER_PROD: "https://api.mistral.ai",
+}
+"""Contains the list of servers available to the SDK"""
+
+
+@dataclass
+class SDKConfiguration:
+    client: HttpClient
+    async_client: AsyncHttpClient
+    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.0.0-rc.2"
+    gen_version: str = "2.388.1"
+    user_agent: str = "speakeasy-sdk/python 1.0.0-rc.2 2.388.1 0.0.2 mistralai-gcp"
+    retry_config: OptionalNullable[RetryConfig] = Field(default_factory=lambda: UNSET)
+    timeout_ms: Optional[int] = None
+
+    def __post_init__(self):
+        self._hooks = SDKHooks()
+
+    def get_server_details(self) -> Tuple[str, Dict[str, str]]:
+        if self.server_url is not None and self.server_url:
+            return remove_suffix(self.server_url, "/"), {}
+        if not self.server:
+            self.server = SERVER_PROD
+
+        if self.server not in SERVERS:
+            raise ValueError(f"Invalid server \"{self.server}\"")
+
+        return SERVERS[self.server], {}
+
+
+    def get_hooks(self) -> SDKHooks:
+        return self._hooks

mistralai_gcp/types/__init__.py

@@ -0,0 +1,21 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from .basemodel import (
+    BaseModel,
+    Nullable,
+    OptionalNullable,
+    UnrecognizedInt,
+    UnrecognizedStr,
+    UNSET,
+    UNSET_SENTINEL,
+)
+
+__all__ = [
+    "BaseModel",
+    "Nullable",
+    "OptionalNullable",
+    "UnrecognizedInt",
+    "UnrecognizedStr",
+    "UNSET",
+    "UNSET_SENTINEL",
+]

mistralai_gcp/types/basemodel.py

@@ -0,0 +1,39 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from pydantic import ConfigDict, model_serializer
+from pydantic import BaseModel as PydanticBaseModel
+from typing import TYPE_CHECKING, Literal, Optional, TypeVar, Union, NewType
+from typing_extensions import TypeAliasType, TypeAlias
+
+
+class BaseModel(PydanticBaseModel):
+    model_config = ConfigDict(
+        populate_by_name=True, arbitrary_types_allowed=True, protected_namespaces=()
+    )
+
+
+class Unset(BaseModel):
+    @model_serializer(mode="plain")
+    def serialize_model(self):
+        return UNSET_SENTINEL
+
+    def __bool__(self) -> Literal[False]:
+        return False
+
+
+UNSET = Unset()
+UNSET_SENTINEL = "~?~unset~?~sentinel~?~"
+
+
+T = TypeVar("T")
+if TYPE_CHECKING:
+    Nullable: TypeAlias = Union[T, None]
+    OptionalNullable: TypeAlias = Union[Optional[Nullable[T]], Unset]
+else:
+    Nullable = TypeAliasType("Nullable", Union[T, None], type_params=(T,))
+    OptionalNullable = TypeAliasType(
+        "OptionalNullable", Union[Optional[Nullable[T]], Unset], type_params=(T,)
+    )
+
+UnrecognizedInt = NewType("UnrecognizedInt", int)
+UnrecognizedStr = NewType("UnrecognizedStr", str)

mistralai_gcp/utils/__init__.py

@@ -0,0 +1,84 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from .annotations import get_discriminator
+from .enums import OpenEnumMeta
+from .headers import get_headers, get_response_headers
+from .metadata import (
+    FieldMetadata,
+    find_metadata,
+    FormMetadata,
+    HeaderMetadata,
+    MultipartFormMetadata,
+    PathParamMetadata,
+    QueryParamMetadata,
+    RequestMetadata,
+    SecurityMetadata,
+)
+from .queryparams import get_query_params
+from .retries import BackoffStrategy, Retries, retry, retry_async, RetryConfig
+from .requestbodies import serialize_request_body, SerializedRequestBody
+from .security import get_security
+from .serializers import (
+    get_pydantic_model,
+    marshal_json,
+    unmarshal,
+    unmarshal_json,
+    serialize_decimal,
+    serialize_float,
+    serialize_int,
+    stream_to_text,
+    validate_decimal,
+    validate_float,
+    validate_int,
+    validate_open_enum,
+)
+from .url import generate_url, template_url, remove_suffix
+from .values import get_global_from_env, match_content_type, match_status_codes, match_response
+from .logger import Logger, get_body_content, NoOpLogger
+
+__all__ = [
+    "BackoffStrategy",
+    "FieldMetadata",
+    "find_metadata",
+    "FormMetadata",
+    "generate_url",
+    "get_body_content",
+    "get_discriminator",
+    "get_global_from_env",
+    "get_headers",
+    "get_pydantic_model",
+    "get_query_params",
+    "get_response_headers",
+    "get_security",
+    "HeaderMetadata",
+    "Logger",
+    "marshal_json",
+    "match_content_type",
+    "match_status_codes",
+    "match_response",
+    "MultipartFormMetadata",
+    "NoOpLogger",
+    "OpenEnumMeta",
+    "PathParamMetadata",
+    "QueryParamMetadata",
+    "remove_suffix",
+    "Retries",
+    "retry",
+    "retry_async",
+    "RetryConfig",
+    "RequestMetadata",
+    "SecurityMetadata",
+    "serialize_decimal",
+    "serialize_float",
+    "serialize_int",
+    "serialize_request_body",
+    "SerializedRequestBody",
+    "stream_to_text",
+    "template_url",
+    "unmarshal",
+    "unmarshal_json",
+    "validate_decimal",
+    "validate_float",
+    "validate_int",
+    "validate_open_enum",
+]