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

mistralai/py.typed

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

mistralai/sdk.py

@@ -0,0 +1,111 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from .basesdk import BaseSDK
+from .httpclient import AsyncHttpClient, HttpClient
+from .sdkconfiguration import SDKConfiguration
+from .utils.retries import RetryConfig
+import httpx
+from mistralai import models
+from mistralai._hooks import SDKHooks
+from mistralai.chat import Chat
+from mistralai.embeddings import Embeddings
+from mistralai.files import Files
+from mistralai.fim import Fim
+from mistralai.fine_tuning import FineTuning
+from mistralai.models_ import Models
+from mistralai.types import OptionalNullable, UNSET
+import mistralai.utils as utils
+from typing import Any, Callable, Dict, Optional, Union
+
+class Mistral(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."""
+    models: Models
+    r"""Model Management API"""
+    files: Files
+    r"""Files API"""
+    fine_tuning: FineTuning
+    r"""Fine-tuning API"""
+    chat: Chat
+    r"""Chat Completion API."""
+    fim: Fim
+    r"""Fill-in-the-middle API."""
+    embeddings: Embeddings
+    r"""Embeddings API."""
+    def __init__(
+        self,
+        api_key: Union[str, Callable[[], str]],
+        server: Optional[str] = None,
+        server_url: Optional[str] = None,
+        url_params: Optional[Dict[str, str]] = None,
+        client: Optional[HttpClient] = None,
+        async_client: Optional[AsyncHttpClient] = None,
+        retry_config: OptionalNullable[RetryConfig] = UNSET,
+        timeout_ms: Optional[int] = None
+    ) -> None:
+        r"""Instantiates the SDK configuring it with the provided parameters.
+
+        :param api_key: The api_key required for authentication
+        :param server: The server by name to use for all methods
+        :param server_url: The server 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
+        :param timeout_ms: Optional request timeout applied to each operation in milliseconds
+        """
+        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(api_key):
+            security = lambda: models.Security(api_key = api_key()) # pylint: disable=unnecessary-lambda-assignment
+        else:
+            security = models.Security(api_key = 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=server,
+            retry_config=retry_config,
+            timeout_ms=timeout_ms
+        ))
+
+        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.models = Models(self.sdk_configuration)
+        self.files = Files(self.sdk_configuration)
+        self.fine_tuning = FineTuning(self.sdk_configuration)
+        self.chat = Chat(self.sdk_configuration)
+        self.fim = Fim(self.sdk_configuration)
+        self.embeddings = Embeddings(self.sdk_configuration)
+    

mistralai/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 import models
+from mistralai.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 = "1.0.0rc0"
+    gen_version: str = "2.382.1"
+    user_agent: str = "speakeasy-sdk/python 1.0.0rc0 2.382.1 0.0.2 mistralai"
+    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/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/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/utils/__init__.py

@@ -0,0 +1,82 @@
+"""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, get_security_from_env
+
+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",
+    "get_security_from_env",
+    "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/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/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/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