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

mistralai/__init__.py

@@ -0,0 +1,5 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from .sdk import *
+from .sdkconfiguration import *
+from .models import *

mistralai/_hooks/__init__.py

@@ -0,0 +1,5 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from .sdkhooks import *
+from .types import *
+from .registration import *

mistralai/_hooks/custom_user_agent.py

@@ -0,0 +1,16 @@
+# MAKE SURE YOU UPDATE THE COPIES OF THIS FILES IN THE PROVIDERS'S PACKAGES WHEN YOU MAKE CHANGES HERE
+from typing import Union
+
+import httpx
+
+from .types import BeforeRequestContext, BeforeRequestHook
+
+
+class CustomUserAgentHook(BeforeRequestHook):
+    def before_request(
+        self, hook_ctx: BeforeRequestContext, request: httpx.Request
+    ) -> Union[httpx.Request, Exception]:
+        request.headers["user-agent"] = (
+            "mistral-client-python/" + request.headers["user-agent"].split(" ")[1]
+        )
+        return request

mistralai/_hooks/deprecation_warning.py

@@ -0,0 +1,26 @@
+import logging
+from typing import Union
+
+import httpx
+
+from .types import AfterSuccessContext, AfterSuccessHook
+
+logger = logging.getLogger(__name__)
+
+HEADER_MODEL_DEPRECATION_TIMESTAMP = "x-model-deprecation-timestamp"
+
+
+class DeprecationWarningHook(AfterSuccessHook):
+
+    def after_success(
+        self, hook_ctx: AfterSuccessContext, response: httpx.Response
+    ) -> Union[httpx.Response, Exception]:
+        if HEADER_MODEL_DEPRECATION_TIMESTAMP in response.headers:
+            model = response.json()["model"]
+            # pylint: disable=logging-fstring-interpolation
+            logger.warning(
+                "WARNING: The model %s is deprecated and will be removed on %s. Please refer to https://docs.mistral.ai/getting-started/models/#api-versioning for more information.",
+                model,
+                response.headers[HEADER_MODEL_DEPRECATION_TIMESTAMP],
+            )
+        return response

mistralai/_hooks/registration.py

@@ -0,0 +1,17 @@
+from .custom_user_agent import CustomUserAgentHook
+from .deprecation_warning import DeprecationWarningHook
+from .types import Hooks
+
+# This file is only ever generated once on the first generation and then is free to be modified.
+# Any hooks you wish to add should be registered in the init_hooks function. Feel free to define them
+# in this file or in separate files in the hooks folder.
+
+
+def init_hooks(hooks: Hooks):
+    # pylint: disable=unused-argument
+    """Add hooks by calling hooks.register{sdk_init/before_request/after_success/after_error}Hook
+    with an instance of a hook that implements that specific Hook interface
+    Hooks are registered per SDK instance, and are valid for the lifetime of the SDK instance
+    """
+    hooks.register_before_request_hook(CustomUserAgentHook())
+    hooks.register_after_success_hook(DeprecationWarningHook())

mistralai/_hooks/sdkhooks.py

@@ -0,0 +1,57 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+import httpx
+from .types import SDKInitHook, BeforeRequestContext, BeforeRequestHook, AfterSuccessContext, AfterSuccessHook, AfterErrorContext, AfterErrorHook, Hooks
+from .registration import init_hooks
+from typing import List, Optional, Tuple
+from mistralai.httpclient import HttpClient
+
+class SDKHooks(Hooks):
+    def __init__(self) -> None:
+        self.sdk_init_hooks: List[SDKInitHook] = []
+        self.before_request_hooks: List[BeforeRequestHook] = []
+        self.after_success_hooks: List[AfterSuccessHook] = []
+        self.after_error_hooks: List[AfterErrorHook] = []
+        init_hooks(self)
+
+    def register_sdk_init_hook(self, hook: SDKInitHook) -> None:
+        self.sdk_init_hooks.append(hook)
+
+    def register_before_request_hook(self, hook: BeforeRequestHook) -> None:
+        self.before_request_hooks.append(hook)
+
+    def register_after_success_hook(self, hook: AfterSuccessHook) -> None:
+        self.after_success_hooks.append(hook)
+
+    def register_after_error_hook(self, hook: AfterErrorHook) -> None:
+        self.after_error_hooks.append(hook)
+
+    def sdk_init(self, base_url: str, client: HttpClient) -> Tuple[str, HttpClient]:
+        for hook in self.sdk_init_hooks:
+            base_url, client = hook.sdk_init(base_url, client)
+        return base_url, client
+
+    def before_request(self, hook_ctx: BeforeRequestContext, request: httpx.Request) -> httpx.Request:
+        for hook in self.before_request_hooks:
+            out = hook.before_request(hook_ctx, request)
+            if isinstance(out, Exception):
+                raise out
+            request = out
+
+        return request
+
+    def after_success(self, hook_ctx: AfterSuccessContext, response: httpx.Response) -> httpx.Response:
+        for hook in self.after_success_hooks:
+            out = hook.after_success(hook_ctx, response)
+            if isinstance(out, Exception):
+                raise out
+            response = out
+        return response
+
+    def after_error(self, hook_ctx: AfterErrorContext, response: Optional[httpx.Response], error: Optional[Exception]) -> Tuple[Optional[httpx.Response], Optional[Exception]]:
+        for hook in self.after_error_hooks:
+            result = hook.after_error(hook_ctx, response, error)
+            if isinstance(result, Exception):
+                raise result
+            response, error = result
+        return response, error

mistralai/_hooks/types.py

@@ -0,0 +1,76 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+
+from abc import ABC, abstractmethod
+import httpx
+from mistralai.httpclient import HttpClient
+from typing import Any, Callable, List, Optional, Tuple, Union
+
+
+class HookContext:
+    operation_id: str
+    oauth2_scopes: Optional[List[str]] = None
+    security_source: Optional[Union[Any, Callable[[], Any]]] = None
+
+    def __init__(self, operation_id: str, oauth2_scopes: Optional[List[str]], security_source: Optional[Union[Any, Callable[[], Any]]]):
+        self.operation_id = operation_id
+        self.oauth2_scopes = oauth2_scopes
+        self.security_source = security_source
+
+
+class BeforeRequestContext(HookContext):
+    def __init__(self, hook_ctx: HookContext):
+        super().__init__(hook_ctx.operation_id, hook_ctx.oauth2_scopes, hook_ctx.security_source)
+
+
+class AfterSuccessContext(HookContext):
+    def __init__(self, hook_ctx: HookContext):
+        super().__init__(hook_ctx.operation_id, hook_ctx.oauth2_scopes, hook_ctx.security_source)
+    
+
+
+class AfterErrorContext(HookContext):
+    def __init__(self, hook_ctx: HookContext):
+        super().__init__(hook_ctx.operation_id, hook_ctx.oauth2_scopes, hook_ctx.security_source)
+
+
+class SDKInitHook(ABC):
+    @abstractmethod
+    def sdk_init(self, base_url: str, client: HttpClient) -> Tuple[str, HttpClient]:
+        pass
+
+
+class BeforeRequestHook(ABC):
+    @abstractmethod
+    def before_request(self, hook_ctx: BeforeRequestContext, request: httpx.Request) -> Union[httpx.Request, Exception]:
+        pass
+
+
+class AfterSuccessHook(ABC):
+    @abstractmethod
+    def after_success(self, hook_ctx: AfterSuccessContext, response: httpx.Response) -> Union[httpx.Response, Exception]:
+        pass
+
+
+class AfterErrorHook(ABC):
+    @abstractmethod
+    def after_error(self, hook_ctx: AfterErrorContext, response: Optional[httpx.Response], error: Optional[Exception]) -> Union[Tuple[Optional[httpx.Response], Optional[Exception]], Exception]:
+        pass
+
+
+class Hooks(ABC):
+    @abstractmethod
+    def register_sdk_init_hook(self, hook: SDKInitHook):
+        pass
+
+    @abstractmethod
+    def register_before_request_hook(self, hook: BeforeRequestHook):
+        pass
+
+    @abstractmethod
+    def register_after_success_hook(self, hook: AfterSuccessHook):
+        pass
+
+    @abstractmethod
+    def register_after_error_hook(self, hook: AfterErrorHook):
+        pass

mistralai/async_client.py

@@ -1,384 +1,15 @@
-import asyncio
-import posixpath
-from json import JSONDecodeError
-from typing import Any, AsyncGenerator, Dict, List, Optional, Union
+from typing import Optional
 
-from httpx import (
-    AsyncClient,
-    AsyncHTTPTransport,
-    ConnectError,
-    Limits,
-    RequestError,
-    Response,
-)
+from .client import MIGRATION_MESSAGE
 
-from mistralai.client_base import ClientBase
-from mistralai.constants import ENDPOINT, RETRY_STATUS_CODES
-from mistralai.exceptions import (
-    MistralAPIException,
-    MistralAPIStatusException,
-    MistralConnectionException,
-    MistralException,
-)
-from mistralai.files import FilesAsyncClient
-from mistralai.jobs import JobsAsyncClient
-from mistralai.models.chat_completion import (
-    ChatCompletionResponse,
-    ChatCompletionStreamResponse,
-    ResponseFormat,
-    ToolChoice,
-)
-from mistralai.models.embeddings import EmbeddingResponse
-from mistralai.models.models import ModelDeleted, ModelList
 
-
-class MistralAsyncClient(ClientBase):
+class MistralAsyncClient:
     def __init__(
         self,
         api_key: Optional[str] = None,
-        endpoint: str = ENDPOINT,
+        endpoint: str = "",
         max_retries: int = 5,
         timeout: int = 120,
         max_concurrent_requests: int = 64,
     ):
-        super().__init__(endpoint, api_key, max_retries, timeout)
-
-        self._client = AsyncClient(
-            follow_redirects=True,
-            timeout=timeout,
-            limits=Limits(max_connections=max_concurrent_requests),
-            transport=AsyncHTTPTransport(retries=max_retries),
-        )
-        self.files = FilesAsyncClient(self)
-        self.jobs = JobsAsyncClient(self)
-
-    async def close(self) -> None:
-        await self._client.aclose()
-
-    async def _check_response_status_codes(self, response: Response) -> None:
-        if response.status_code in RETRY_STATUS_CODES:
-            raise MistralAPIStatusException.from_response(
-                response,
-                message=f"Status: {response.status_code}. Message: {response.text}",
-            )
-        elif 400 <= response.status_code < 500:
-            if response.stream:
-                await response.aread()
-            raise MistralAPIException.from_response(
-                response,
-                message=f"Status: {response.status_code}. Message: {response.text}",
-            )
-        elif response.status_code >= 500:
-            if response.stream:
-                await response.aread()
-            raise MistralException(
-                message=f"Status: {response.status_code}. Message: {response.text}",
-            )
-
-    async def _check_streaming_response(self, response: Response) -> None:
-        await self._check_response_status_codes(response)
-
-    async def _check_response(self, response: Response) -> Dict[str, Any]:
-        await self._check_response_status_codes(response)
-
-        json_response: Dict[str, Any] = response.json()
-
-        if "object" not in json_response:
-            raise MistralException(message=f"Unexpected response: {json_response}")
-        if "error" == json_response["object"]:  # has errors
-            raise MistralAPIException.from_response(
-                response,
-                message=json_response["message"],
-            )
-
-        return json_response
-
-    async def _request(
-        self,
-        method: str,
-        json: Optional[Dict[str, Any]],
-        path: str,
-        stream: bool = False,
-        attempt: int = 1,
-        data: Optional[Dict[str, Any]] = None,
-        **kwargs: Any,
-    ) -> AsyncGenerator[Dict[str, Any], None]:
-        accept_header = "text/event-stream" if stream else "application/json"
-        headers = {
-            "Accept": accept_header,
-            "User-Agent": f"mistral-client-python/{self._version}",
-            "Authorization": f"Bearer {self._api_key}",
-        }
-
-        if json is not None:
-            headers["Content-Type"] = "application/json"
-
-        url = posixpath.join(self._endpoint, path)
-
-        self._logger.debug(f"Sending request: {method} {url} {json}")
-
-        response: Response
-
-        try:
-            if stream:
-                async with self._client.stream(
-                    method,
-                    url,
-                    headers=headers,
-                    json=json,
-                    data=data,
-                    **kwargs,
-                ) as response:
-                    await self._check_streaming_response(response)
-
-                    async for line in response.aiter_lines():
-                        json_streamed_response = self._process_line(line)
-                        if json_streamed_response:
-                            yield json_streamed_response
-
-            else:
-                response = await self._client.request(
-                    method,
-                    url,
-                    headers=headers,
-                    json=json,
-                    data=data,
-                    **kwargs,
-                )
-
-                yield await self._check_response(response)
-
-        except ConnectError as e:
-            raise MistralConnectionException(str(e)) from e
-        except RequestError as e:
-            raise MistralException(f"Unexpected exception ({e.__class__.__name__}): {e}") from e
-        except JSONDecodeError as e:
-            raise MistralAPIException.from_response(
-                response,
-                message=f"Failed to decode json body: {response.text}",
-            ) from e
-        except MistralAPIStatusException as e:
-            attempt += 1
-            if attempt > self._max_retries:
-                raise MistralAPIStatusException.from_response(response, message=str(e)) from e
-            backoff = 2.0**attempt  # exponential backoff
-            await asyncio.sleep(backoff)
-
-            # Retry as a generator
-            async for r in self._request(method, json, path, stream=stream, attempt=attempt):
-                yield r
-
-    async def chat(
-        self,
-        messages: List[Any],
-        model: Optional[str] = None,
-        tools: Optional[List[Dict[str, Any]]] = None,
-        temperature: Optional[float] = None,
-        max_tokens: Optional[int] = None,
-        top_p: Optional[float] = None,
-        random_seed: Optional[int] = None,
-        safe_mode: bool = False,
-        safe_prompt: bool = False,
-        tool_choice: Optional[Union[str, ToolChoice]] = None,
-        response_format: Optional[Union[Dict[str, str], ResponseFormat]] = None,
-    ) -> ChatCompletionResponse:
-        """A asynchronous chat endpoint that returns a single response.
-
-        Args:
-            model (str): model the name of the model to chat with, e.g. mistral-tiny
-            messages (List[Any]): messages an array of messages to chat with, e.g.
-                [{role: 'user', content: 'What is the best French cheese?'}]
-            temperature (Optional[float], optional): temperature the temperature to use for sampling, e.g. 0.5.
-            max_tokens (Optional[int], optional): the maximum number of tokens to generate, e.g. 100. Defaults to None.
-            top_p (Optional[float], optional): the cumulative probability of tokens to generate, e.g. 0.9.
-            Defaults to None.
-            random_seed (Optional[int], optional): the random seed to use for sampling, e.g. 42. Defaults to None.
-            safe_mode (bool, optional): deprecated, use safe_prompt instead. Defaults to False.
-            safe_prompt (bool, optional): whether to use safe prompt, e.g. true. Defaults to False.
-
-        Returns:
-            ChatCompletionResponse: a response object containing the generated text.
-        """
-        request = self._make_chat_request(
-            messages,
-            model,
-            tools=tools,
-            temperature=temperature,
-            max_tokens=max_tokens,
-            top_p=top_p,
-            random_seed=random_seed,
-            stream=False,
-            safe_prompt=safe_mode or safe_prompt,
-            tool_choice=tool_choice,
-            response_format=response_format,
-        )
-
-        single_response = self._request("post", request, "v1/chat/completions")
-
-        async for response in single_response:
-            return ChatCompletionResponse(**response)
-
-        raise MistralException("No response received")
-
-    async def chat_stream(
-        self,
-        messages: List[Any],
-        model: Optional[str] = None,
-        tools: Optional[List[Dict[str, Any]]] = None,
-        temperature: Optional[float] = None,
-        max_tokens: Optional[int] = None,
-        top_p: Optional[float] = None,
-        random_seed: Optional[int] = None,
-        safe_mode: bool = False,
-        safe_prompt: bool = False,
-        tool_choice: Optional[Union[str, ToolChoice]] = None,
-        response_format: Optional[Union[Dict[str, str], ResponseFormat]] = None,
-    ) -> AsyncGenerator[ChatCompletionStreamResponse, None]:
-        """An Asynchronous chat endpoint that streams responses.
-
-        Args:
-            model (str): model the name of the model to chat with, e.g. mistral-tiny
-            messages (List[Any]): messages an array of messages to chat with, e.g.
-                [{role: 'user', content: 'What is the best French cheese?'}]
-            tools (Optional[List[Function]], optional): a list of tools to use.
-            temperature (Optional[float], optional): temperature the temperature to use for sampling, e.g. 0.5.
-            max_tokens (Optional[int], optional): the maximum number of tokens to generate, e.g. 100. Defaults to None.
-            top_p (Optional[float], optional): the cumulative probability of tokens to generate, e.g. 0.9.
-            Defaults to None.
-            random_seed (Optional[int], optional): the random seed to use for sampling, e.g. 42. Defaults to None.
-            safe_mode (bool, optional): deprecated, use safe_prompt instead. Defaults to False.
-            safe_prompt (bool, optional): whether to use safe prompt, e.g. true. Defaults to False.
-
-        Returns:
-            AsyncGenerator[ChatCompletionStreamResponse, None]:
-                An async generator that yields ChatCompletionStreamResponse objects.
-        """
-
-        request = self._make_chat_request(
-            messages,
-            model,
-            tools=tools,
-            temperature=temperature,
-            max_tokens=max_tokens,
-            top_p=top_p,
-            random_seed=random_seed,
-            stream=True,
-            safe_prompt=safe_mode or safe_prompt,
-            tool_choice=tool_choice,
-            response_format=response_format,
-        )
-        async_response = self._request("post", request, "v1/chat/completions", stream=True)
-
-        async for json_response in async_response:
-            yield ChatCompletionStreamResponse(**json_response)
-
-    async def embeddings(self, model: str, input: Union[str, List[str]]) -> EmbeddingResponse:
-        """An asynchronous embeddings endpoint that returns embeddings for a single, or batch of inputs
-
-        Args:
-            model (str): The embedding model to use, e.g. mistral-embed
-            input (Union[str, List[str]]): The input to embed,
-                 e.g. ['What is the best French cheese?']
-
-        Returns:
-            EmbeddingResponse: A response object containing the embeddings.
-        """
-        request = {"model": model, "input": input}
-        single_response = self._request("post", request, "v1/embeddings")
-
-        async for response in single_response:
-            return EmbeddingResponse(**response)
-
-        raise MistralException("No response received")
-
-    async def list_models(self) -> ModelList:
-        """Returns a list of the available models
-
-        Returns:
-            ModelList: A response object containing the list of models.
-        """
-        single_response = self._request("get", {}, "v1/models")
-
-        async for response in single_response:
-            return ModelList(**response)
-
-        raise MistralException("No response received")
-
-    async def delete_model(self, model_id: str) -> ModelDeleted:
-        single_response = self._request("delete", {}, f"v1/models/{model_id}")
-
-        async for response in single_response:
-            return ModelDeleted(**response)
-
-        raise MistralException("No response received")
-
-    async def completion(
-        self,
-        model: str,
-        prompt: str,
-        suffix: Optional[str] = None,
-        temperature: Optional[float] = None,
-        max_tokens: Optional[int] = None,
-        top_p: Optional[float] = None,
-        random_seed: Optional[int] = None,
-        stop: Optional[List[str]] = None,
-    ) -> ChatCompletionResponse:
-        """An asynchronous completion endpoint that returns a single response.
-
-        Args:
-            model (str): model the name of the model to get completions with, e.g. codestral-latest
-            prompt (str): the prompt to complete
-            suffix (Optional[str]): the suffix to append to the prompt for fill-in-the-middle completion
-            temperature (Optional[float], optional): temperature the temperature to use for sampling, e.g. 0.5.
-            max_tokens (Optional[int], optional): the maximum number of tokens to generate, e.g. 100. Defaults to None.
-            top_p (Optional[float], optional): the cumulative probability of tokens to generate, e.g. 0.9.
-            Defaults to None.
-            random_seed (Optional[int], optional): the random seed to use for sampling, e.g. 42. Defaults to None.
-            stop (Optional[List[str]], optional): a list of tokens to stop generation at, e.g. ['/n/n']
-        Returns:
-            Dict[str, Any]: a response object containing the generated text.
-        """
-        request = self._make_completion_request(
-            prompt, model, suffix, temperature, max_tokens, top_p, random_seed, stop
-        )
-        single_response = self._request("post", request, "v1/fim/completions")
-
-        async for response in single_response:
-            return ChatCompletionResponse(**response)
-
-        raise MistralException("No response received")
-
-    async def completion_stream(
-        self,
-        model: str,
-        prompt: str,
-        suffix: Optional[str] = None,
-        temperature: Optional[float] = None,
-        max_tokens: Optional[int] = None,
-        top_p: Optional[float] = None,
-        random_seed: Optional[int] = None,
-        stop: Optional[List[str]] = None,
-    ) -> AsyncGenerator[ChatCompletionStreamResponse, None]:
-        """An asynchronous completion endpoint that returns a streaming response.
-
-        Args:
-            model (str): model the name of the model to get completions with, e.g. codestral-latest
-            prompt (str): the prompt to complete
-            suffix (Optional[str]): the suffix to append to the prompt for fill-in-the-middle completion
-            temperature (Optional[float], optional): temperature the temperature to use for sampling, e.g. 0.5.
-            max_tokens (Optional[int], optional): the maximum number of tokens to generate, e.g. 100. Defaults to None.
-            top_p (Optional[float], optional): the cumulative probability of tokens to generate, e.g. 0.9.
-            Defaults to None.
-            random_seed (Optional[int], optional): the random seed to use for sampling, e.g. 42. Defaults to None.
-            stop (Optional[List[str]], optional): a list of tokens to stop generation at, e.g. ['/n/n']
-
-        Returns:
-            Dict[str, Any]: a response object containing the generated text.
-        """
-        request = self._make_completion_request(
-            prompt, model, suffix, temperature, max_tokens, top_p, random_seed, stop, stream=True
-        )
-        async_response = self._request("post", request, "v1/fim/completions", stream=True)
-
-        async for json_response in async_response:
-            yield ChatCompletionStreamResponse(**json_response)
+        raise NotImplementedError(MIGRATION_MESSAGE)