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

mistralai/async_client.py

@@ -1,423 +1,15 @@
-import asyncio
-import posixpath
-from json import JSONDecodeError
-from typing import Any, AsyncGenerator, Callable, 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,
-        check_model_deprecation_headers_callback: Optional[Callable] = 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:
-                    if check_model_deprecation_headers_callback:
-                        check_model_deprecation_headers_callback(response.headers)
-                    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,
-                )
-                if check_model_deprecation_headers_callback:
-                    check_model_deprecation_headers_callback(response.headers)
-                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",
-            check_model_deprecation_headers_callback=self._check_model_deprecation_header_callback_factory(model),
-        )
-
-        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,
-            check_model_deprecation_headers_callback=self._check_model_deprecation_header_callback_factory(model),
-        )
-
-        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",
-            check_model_deprecation_headers_callback=self._check_model_deprecation_header_callback_factory(model),
-        )
-
-        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",
-            check_model_deprecation_headers_callback=self._check_model_deprecation_header_callback_factory(model),
-        )
-
-        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,
-            check_model_deprecation_headers_callback=self._check_model_deprecation_header_callback_factory(model),
-        )
-
-        async for json_response in async_response:
-            yield ChatCompletionStreamResponse(**json_response)
+        raise NotImplementedError(MIGRATION_MESSAGE)

mistralai/basesdk.py

@@ -0,0 +1,253 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from .sdkconfiguration import SDKConfiguration
+import httpx
+from mistralai import models, utils
+from mistralai._hooks import AfterErrorContext, AfterSuccessContext, BeforeRequestContext
+from mistralai.utils import RetryConfig, SerializedRequestBody, get_body_content
+from typing import Callable, List, Optional, Tuple
+
+class BaseSDK:
+    sdk_configuration: SDKConfiguration
+
+    def __init__(self, sdk_config: SDKConfiguration) -> None:
+        self.sdk_configuration = sdk_config
+
+    def get_url(self, base_url, url_variables):
+        sdk_url, sdk_variables = self.sdk_configuration.get_server_details()
+
+        if base_url is None:
+            base_url = sdk_url
+
+        if url_variables is None:
+            url_variables = sdk_variables
+
+        return utils.template_url(base_url, url_variables)
+
+    def build_request(
+        self,
+        method,
+        path,
+        base_url,
+        url_variables,
+        request,
+        request_body_required,
+        request_has_path_params,
+        request_has_query_params,
+        user_agent_header,
+        accept_header_value,
+        _globals=None,
+        security=None,
+        timeout_ms: Optional[int] = None,
+        get_serialized_body: Optional[
+            Callable[[], Optional[SerializedRequestBody]]
+        ] = None,
+        url_override: Optional[str] = None,
+    ) -> httpx.Request:
+        client = self.sdk_configuration.client
+
+        query_params = {}
+
+        url = url_override
+        if url is None:
+            url = utils.generate_url(
+                self.get_url(base_url, url_variables),
+                path,
+                request if request_has_path_params else None,
+                _globals if request_has_path_params else None,
+            )
+
+            query_params = utils.get_query_params(
+                request if request_has_query_params else None,
+                _globals if request_has_query_params else None,
+            )
+
+        headers = utils.get_headers(request, _globals)
+        headers["Accept"] = accept_header_value
+        headers[user_agent_header] = self.sdk_configuration.user_agent
+
+        if security is not None:
+            if callable(security):
+                security = security()
+        security = utils.get_security_from_env(security, models.Security)
+        if security is not None:
+            security_headers, security_query_params = utils.get_security(security)
+            headers = {**headers, **security_headers}
+            query_params = {**query_params, **security_query_params}
+
+        serialized_request_body = SerializedRequestBody("application/octet-stream")
+        if get_serialized_body is not None:
+            rb = get_serialized_body()
+            if request_body_required and rb is None:
+                raise ValueError("request body is required")
+
+            if rb is not None:
+                serialized_request_body = rb
+
+        if (
+            serialized_request_body.media_type is not None
+            and serialized_request_body.media_type
+            not in (
+                "multipart/form-data",
+                "multipart/mixed",
+            )
+        ):
+            headers["content-type"] = serialized_request_body.media_type
+
+        timeout = timeout_ms / 1000 if timeout_ms is not None else None
+
+        return client.build_request(
+            method,
+            url,
+            params=query_params,
+            content=serialized_request_body.content,
+            data=serialized_request_body.data,
+            files=serialized_request_body.files,
+            headers=headers,
+            timeout=timeout,
+        )
+
+    def do_request(
+        self,
+        hook_ctx,
+        request,
+        error_status_codes,
+        stream=False,
+        retry_config: Optional[Tuple[RetryConfig, List[str]]] = None,
+    ) -> httpx.Response:
+        client = self.sdk_configuration.client
+        logger = self.sdk_configuration.debug_logger
+
+        def do():
+            http_res = None
+            try:
+                req = self.sdk_configuration.get_hooks().before_request(
+                    BeforeRequestContext(hook_ctx), request
+                )
+                logger.debug(
+                    "Request:\nMethod: %s\nURL: %s\nHeaders: %s\nBody: %s",
+                    req.method,
+                    req.url,
+                    req.headers,
+                    get_body_content(req)
+                )
+                http_res = client.send(req, stream=stream)
+            except Exception as e:
+                _, e = self.sdk_configuration.get_hooks().after_error(
+                    AfterErrorContext(hook_ctx), None, e
+                )
+                if e is not None:
+                    logger.debug("Request Exception", exc_info=True)
+                    raise e
+
+            if http_res is None:
+                logger.debug("Raising no response SDK error")
+                raise models.SDKError("No response received")
+
+            logger.debug(
+                "Response:\nStatus Code: %s\nURL: %s\nHeaders: %s\nBody: %s",
+                http_res.status_code,
+                http_res.url,
+                http_res.headers,
+                "<streaming response>" if stream else http_res.text
+            )
+
+            if utils.match_status_codes(error_status_codes, http_res.status_code):
+                result, err = self.sdk_configuration.get_hooks().after_error(
+                    AfterErrorContext(hook_ctx), http_res, None
+                )
+                if err is not None:
+                    logger.debug("Request Exception", exc_info=True)
+                    raise err
+                if result is not None:
+                    http_res = result
+                else:
+                    logger.debug("Raising unexpected SDK error")
+                    raise models.SDKError("Unexpected error occurred")
+
+            return http_res
+
+        if retry_config is not None:
+            http_res = utils.retry(do, utils.Retries(retry_config[0], retry_config[1]))
+        else:
+            http_res = do()
+
+        if not utils.match_status_codes(error_status_codes, http_res.status_code):
+            http_res = self.sdk_configuration.get_hooks().after_success(
+                AfterSuccessContext(hook_ctx), http_res
+            )
+
+        return http_res
+
+    async def do_request_async(
+        self,
+        hook_ctx,
+        request,
+        error_status_codes,
+        stream=False,
+        retry_config: Optional[Tuple[RetryConfig, List[str]]] = None,
+    ) -> httpx.Response:
+        client = self.sdk_configuration.async_client
+        logger = self.sdk_configuration.debug_logger
+        async def do():
+            http_res = None
+            try:
+                req = self.sdk_configuration.get_hooks().before_request(
+                    BeforeRequestContext(hook_ctx), request
+                )
+                logger.debug(
+                    "Request:\nMethod: %s\nURL: %s\nHeaders: %s\nBody: %s",
+                    req.method,
+                    req.url,
+                    req.headers,
+                    get_body_content(req)
+                )
+                http_res = await client.send(req, stream=stream)
+            except Exception as e:
+                _, e = self.sdk_configuration.get_hooks().after_error(
+                    AfterErrorContext(hook_ctx), None, e
+                )
+                if e is not None:
+                    logger.debug("Request Exception", exc_info=True)
+                    raise e
+
+            if http_res is None:
+                logger.debug("Raising no response SDK error")
+                raise models.SDKError("No response received")
+
+            logger.debug(
+                "Response:\nStatus Code: %s\nURL: %s\nHeaders: %s\nBody: %s",
+                http_res.status_code,
+                http_res.url,
+                http_res.headers,
+                "<streaming response>" if stream else http_res.text
+            )
+
+            if utils.match_status_codes(error_status_codes, http_res.status_code):
+                result, err = self.sdk_configuration.get_hooks().after_error(
+                    AfterErrorContext(hook_ctx), http_res, None
+                )
+                if err is not None:
+                    logger.debug("Request Exception", exc_info=True)
+                    raise err
+                if result is not None:
+                    http_res = result
+                else:
+                    logger.debug("Raising unexpected SDK error")
+                    raise models.SDKError("Unexpected error occurred")
+
+            return http_res
+
+        if retry_config is not None:
+            http_res = await utils.retry_async(
+                do, utils.Retries(retry_config[0], retry_config[1])
+            )
+        else:
+            http_res = await do()
+
+        if not utils.match_status_codes(error_status_codes, http_res.status_code):
+            http_res = self.sdk_configuration.get_hooks().after_success(
+                AfterSuccessContext(hook_ctx), http_res
+            )
+
+        return http_res