mistralai 0.4.2__py3-none-any.whl → 0.5.5a50__py3-none-any.whl

mistralai_azure/models/toolmessage.py

@@ -0,0 +1,55 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from mistralai_azure.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)
+
+            if val is not None and val != UNSET_SENTINEL:
+                m[k] = val
+            elif val != UNSET_SENTINEL and (
+                not k in optional_fields
+                or (
+                    k in optional_fields
+                    and k in nullable_fields
+                    and (
+                        self.__pydantic_fields_set__.intersection({n})
+                        or k in null_default_fields
+                    )  # pylint: disable=no-member
+                )
+            ):
+                m[k] = val
+
+        return m
+        

mistralai_azure/models/usageinfo.py

@@ -0,0 +1,18 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from mistralai_azure.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_azure/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_azure.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_azure/models/validationerror.py

@@ -0,0 +1,24 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from mistralai_azure.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_azure/py.typed

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

mistralai_azure/sdk.py

@@ -0,0 +1,102 @@
+"""Code generated by Speakeasy (https://speakeasyapi.dev). DO NOT EDIT."""
+
+from typing import Any, Callable, Dict, Optional, Union
+
+import httpx
+import mistralai_azure.utils as utils
+from mistralai_azure import models
+from mistralai_azure._hooks import SDKHooks
+from mistralai_azure.chat import Chat
+from mistralai_azure.types import Nullable
+
+from .basesdk import BaseSDK
+from .httpclient import AsyncHttpClient, HttpClient
+from .sdkconfiguration import SDKConfiguration
+from .utils.retries import RetryConfig
+
+
+class MistralAzure(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
+    r"""Chat Completion API"""
+
+    def __init__(
+        self,
+        azure_api_key: Union[str, Callable[[], str]],
+        azure_endpoint: str,
+        url_params: Optional[Dict[str, str]] = None,
+        client: Optional[HttpClient] = None,
+        async_client: Optional[AsyncHttpClient] = None,
+        retry_config: Optional[Nullable[RetryConfig]] = None,
+    ) -> None:
+        r"""Instantiates the SDK configuring it with the provided parameters.
+
+        :param azure_api_key: The azure_api_key required for authentication
+        :param azure_endpoint: The Azure AI endpoint URL to use for all methods
+        :param url_params: Parameters to optionally template the server URL with
+        :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
+        """
+        # if azure_endpoint doesn't end with `/v1` add it
+        if not azure_endpoint.endswith("/"):
+            azure_endpoint += "/"
+        if not azure_endpoint.endswith("v1/"):
+            azure_endpoint += "v1/"
+        server_url = azure_endpoint
+
+        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()
+
+        assert issubclass(
+            type(async_client), AsyncHttpClient
+        ), "The provided async_client must implement the AsyncHttpClient protocol."
+
+        security: Any = None
+        if callable(azure_api_key):
+            security = lambda: models.Security(  # pylint: disable=unnecessary-lambda-assignment
+                api_key=azure_api_key()
+            )
+        else:
+            security = models.Security(api_key=azure_api_key)
+
+        if server_url is not None:
+            if url_params is not None:
+                server_url = utils.template_url(server_url, url_params)
+
+        BaseSDK.__init__(
+            self,
+            SDKConfiguration(
+                client=client,
+                async_client=async_client,
+                security=security,
+                server_url=server_url,
+                server=None,
+                retry_config=retry_config,
+            ),
+        )
+
+        hooks = SDKHooks()
+
+        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)

mistralai_azure/sdkconfiguration.py

@@ -0,0 +1,53 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+
+from ._hooks import SDKHooks
+from .httpclient import AsyncHttpClient, HttpClient
+from .utils import RetryConfig, remove_suffix
+from dataclasses import dataclass
+from mistralai_azure import models
+from mistralai_azure.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
+    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 = "0.5.5-alpha.54"
+    gen_version: str = "2.382.1"
+    user_agent: str = "speakeasy-sdk/python 0.5.5-alpha.54 2.382.1 0.0.2 mistralai_azure"
+    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_azure/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_azure/types/basemodel.py

@@ -0,0 +1,35 @@
+"""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 Literal, Optional, TypeVar, Union, NewType
+from typing_extensions import TypeAliasType
+
+
+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")
+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_azure/utils/__init__.py

@@ -0,0 +1,80 @@
+"""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
+
+__all__ = [
+    "BackoffStrategy",
+    "FieldMetadata",
+    "find_metadata",
+    "FormMetadata",
+    "generate_url",
+    "get_discriminator",
+    "get_global_from_env",
+    "get_headers",
+    "get_pydantic_model",
+    "get_query_params",
+    "get_response_headers",
+    "get_security",
+    "HeaderMetadata",
+    "marshal_json",
+    "match_content_type",
+    "match_status_codes",
+    "match_response",
+    "MultipartFormMetadata",
+    "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",
+]

mistralai_azure/utils/annotations.py

@@ -0,0 +1,19 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from typing import Any
+
+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
+
+    if hasattr(model, fieldname):
+        return f'{getattr(model, fieldname)}'
+
+    fieldname = fieldname.upper()
+    if hasattr(model, fieldname):
+        return f'{getattr(model, fieldname)}'
+
+    raise ValueError(f'Could not find discriminator field {fieldname} in {model}')

mistralai_azure/utils/enums.py

@@ -0,0 +1,34 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+import enum
+
+
+class OpenEnumMeta(enum.EnumMeta):
+    def __call__(
+        cls, value, names=None, *, module=None, qualname=None, type=None, start=1
+    ):
+        # The `type` kwarg also happens to be a built-in that pylint flags as
+        # redeclared. Safe to ignore this lint rule with this scope.
+        # pylint: disable=redefined-builtin
+
+        if names is not None:
+            return super().__call__(
+                value,
+                names=names,
+                module=module,
+                qualname=qualname,
+                type=type,
+                start=start,
+            )
+
+        try:
+            return super().__call__(
+                value,
+                names=names,  # pyright: ignore[reportArgumentType]
+                module=module,
+                qualname=qualname,
+                type=type,
+                start=start,
+            )
+        except ValueError:
+            return value

mistralai_azure/utils/eventstreaming.py

@@ -0,0 +1,179 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+import re
+import json
+from typing import Callable, TypeVar, Optional, Generator, AsyncGenerator, Tuple
+import httpx
+
+T = TypeVar("T")
+
+
+class ServerEvent:
+    id: Optional[str] = None
+    event: Optional[str] = None
+    data: Optional[str] = None
+    retry: Optional[int] = None
+
+
+MESSAGE_BOUNDARIES = [
+    b"\r\n\r\n",
+    b"\n\n",
+    b"\r\r",
+]
+
+
+async def stream_events_async(
+    response: httpx.Response,
+    decoder: Callable[[str], T],
+    sentinel: Optional[str] = None,
+) -> AsyncGenerator[T, None]:
+    buffer = bytearray()
+    position = 0
+    discard = False
+    async for chunk in response.aiter_bytes():
+        # We've encountered the sentinel value and should no longer process
+        # incoming data. Instead we throw new data away until the server closes
+        # the connection.
+        if discard:
+            continue
+
+        buffer += chunk
+        for i in range(position, len(buffer)):
+            char = buffer[i : i + 1]
+            seq: Optional[bytes] = None
+            if char in [b"\r", b"\n"]:
+                for boundary in MESSAGE_BOUNDARIES:
+                    seq = _peek_sequence(i, buffer, boundary)
+                    if seq is not None:
+                        break
+            if seq is None:
+                continue
+
+            block = buffer[position:i]
+            position = i + len(seq)
+            event, discard = _parse_event(block, decoder, sentinel)
+            if event is not None:
+                yield event
+
+        if position > 0:
+            buffer = buffer[position:]
+            position = 0
+
+    event, discard = _parse_event(buffer, decoder, sentinel)
+    if event is not None:
+        yield event
+
+
+def stream_events(
+    response: httpx.Response,
+    decoder: Callable[[str], T],
+    sentinel: Optional[str] = None,
+) -> Generator[T, None, None]:
+    buffer = bytearray()
+    position = 0
+    discard = False
+    for chunk in response.iter_bytes():
+        # We've encountered the sentinel value and should no longer process
+        # incoming data. Instead we throw new data away until the server closes
+        # the connection.
+        if discard:
+            continue
+
+        buffer += chunk
+        for i in range(position, len(buffer)):
+            char = buffer[i : i + 1]
+            seq: Optional[bytes] = None
+            if char in [b"\r", b"\n"]:
+                for boundary in MESSAGE_BOUNDARIES:
+                    seq = _peek_sequence(i, buffer, boundary)
+                    if seq is not None:
+                        break
+            if seq is None:
+                continue
+
+            block = buffer[position:i]
+            position = i + len(seq)
+            event, discard = _parse_event(block, decoder, sentinel)
+            if event is not None:
+                yield event
+
+        if position > 0:
+            buffer = buffer[position:]
+            position = 0
+
+    event, discard = _parse_event(buffer, decoder, sentinel)
+    if event is not None:
+        yield event
+
+
+def _parse_event(
+    raw: bytearray, decoder: Callable[[str], T], sentinel: Optional[str] = None
+) -> Tuple[Optional[T], bool]:
+    block = raw.decode()
+    lines = re.split(r"\r?\n|\r", block)
+    publish = False
+    event = ServerEvent()
+    data = ""
+    for line in lines:
+        if not line:
+            continue
+
+        delim = line.find(":")
+        if delim <= 0:
+            continue
+
+        field = line[0:delim]
+        value = line[delim + 1 :] if delim < len(line) - 1 else ""
+        if len(value) and value[0] == " ":
+            value = value[1:]
+
+        if field == "event":
+            event.event = value
+            publish = True
+        elif field == "data":
+            data += value + "\n"
+            publish = True
+        elif field == "id":
+            event.id = value
+            publish = True
+        elif field == "retry":
+            event.retry = int(value) if value.isdigit() else None
+            publish = True
+
+    if sentinel and data == f"{sentinel}\n":
+        return None, True
+
+    if data:
+        data = data[:-1]
+        event.data = data
+
+        if (
+            data.isnumeric()
+            or data == "true"
+            or data == "false"
+            or data == "null"
+            or data.startswith("{")
+            or data.startswith("[")
+            or data.startswith('"')
+        ):
+            try:
+                event.data = json.loads(data)
+            except Exception:
+                pass
+
+    out = None
+    if publish:
+        out = decoder(json.dumps(event.__dict__))
+
+    return out, False
+
+
+def _peek_sequence(position: int, buffer: bytearray, sequence: bytes):
+    if len(sequence) > (len(buffer) - position):
+        return None
+
+    for i, seq in enumerate(sequence):
+        if buffer[position + i] != seq:
+            return None
+
+    return sequence