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

mistralai/client.py

@@ -1,423 +1,14 @@
-import posixpath
-import time
-from json import JSONDecodeError
-from typing import Any, Callable, Dict, Iterable, Iterator, List, Optional, Union
+from typing import Optional
 
-from httpx import Client, ConnectError, HTTPTransport, RequestError, Response
+MIGRATION_MESSAGE = "This client is deprecated. To migrate to the new client, please refer to this guide: https://github.com/mistralai/client-python/blob/main/MIGRATION.md. If you need to use this client anyway, pin your version to 0.4.2."
 
-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 FilesClient
-from mistralai.jobs import JobsClient
-from mistralai.models.chat_completion import (
-    ChatCompletionResponse,
-    ChatCompletionStreamResponse,
-    ResponseFormat,
-    ToolChoice,
-)
-from mistralai.models.embeddings import EmbeddingResponse
-from mistralai.models.models import ModelDeleted, ModelList
-
-
-class MistralClient(ClientBase):
-    """
-    Synchronous wrapper around the async client
-    """
 
+class MistralClient:
     def __init__(
         self,
         api_key: Optional[str] = None,
-        endpoint: str = ENDPOINT,
+        endpoint: str = "",
         max_retries: int = 5,
         timeout: int = 120,
     ):
-        super().__init__(endpoint, api_key, max_retries, timeout)
-
-        self._client = Client(
-            follow_redirects=True,
-            timeout=self._timeout,
-            transport=HTTPTransport(retries=self._max_retries),
-        )
-        self.files = FilesClient(self)
-        self.jobs = JobsClient(self)
-
-    def __del__(self) -> None:
-        self._client.close()
-
-    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:
-                response.read()
-            raise MistralAPIException.from_response(
-                response,
-                message=f"Status: {response.status_code}. Message: {response.text}",
-            )
-        elif response.status_code >= 500:
-            if response.stream:
-                response.read()
-            raise MistralException(
-                message=f"Status: {response.status_code}. Message: {response.text}",
-            )
-
-    def _check_streaming_response(self, response: Response) -> None:
-        self._check_response_status_codes(response)
-
-    def _check_response(self, response: Response) -> Dict[str, Any]:
-        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
-
-    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,
-    ) -> Iterator[Dict[str, Any]]:
-        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:
-                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)
-                    self._check_streaming_response(response)
-
-                    for line in response.iter_lines():
-                        json_streamed_response = self._process_line(line)
-                        if json_streamed_response:
-                            yield json_streamed_response
-
-            else:
-                response = 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 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
-            time.sleep(backoff)
-
-            # Retry as a generator
-            for r in self._request(method, json, path, stream=stream, attempt=attempt):
-                yield r
-
-    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 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?'}]
-            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:
-            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),
-        )
-
-        for response in single_response:
-            return ChatCompletionResponse(**response)
-
-        raise MistralException("No response received")
-
-    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,
-    ) -> Iterable[ChatCompletionStreamResponse]:
-        """A 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:
-             Iterable[ChatCompletionStreamResponse]:
-                A 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,
-        )
-
-        response = self._request(
-            "post",
-            request,
-            "v1/chat/completions",
-            stream=True,
-            check_model_deprecation_headers_callback=self._check_model_deprecation_header_callback_factory(model),
-        )
-
-        for json_streamed_response in response:
-            yield ChatCompletionStreamResponse(**json_streamed_response)
-
-    def embeddings(self, model: str, input: Union[str, List[str]]) -> EmbeddingResponse:
-        """An 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}
-        singleton_response = self._request(
-            "post",
-            request,
-            "v1/embeddings",
-            check_model_deprecation_headers_callback=self._check_model_deprecation_header_callback_factory(model),
-        )
-
-        for response in singleton_response:
-            return EmbeddingResponse(**response)
-
-        raise MistralException("No response received")
-
-    def list_models(self) -> ModelList:
-        """Returns a list of the available models
-
-        Returns:
-            ModelList: A response object containing the list of models.
-        """
-        singleton_response = self._request("get", {}, "v1/models")
-
-        for response in singleton_response:
-            return ModelList(**response)
-
-        raise MistralException("No response received")
-
-    def delete_model(self, model_id: str) -> ModelDeleted:
-        single_response = self._request("delete", {}, f"v1/models/{model_id}")
-
-        for response in single_response:
-            return ModelDeleted(**response)
-
-        raise MistralException("No response received")
-
-    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:
-        """A completion endpoint that returns a single response.
-
-        Args:
-            model (str): model the name of the model to get completion 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",
-            stream=False,
-            check_model_deprecation_headers_callback=self._check_model_deprecation_header_callback_factory(model),
-        )
-
-        for response in single_response:
-            return ChatCompletionResponse(**response)
-
-        raise MistralException("No response received")
-
-    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,
-    ) -> Iterable[ChatCompletionStreamResponse]:
-        """An asynchronous completion endpoint that streams responses.
-
-        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:
-            Iterable[Dict[str, Any]]: a generator that yields response objects containing the generated text.
-        """
-        request = self._make_completion_request(
-            prompt,
-            model,
-            suffix,
-            temperature,
-            max_tokens,
-            top_p,
-            random_seed,
-            stop,
-            stream=True,
-        )
-
-        response = self._request(
-            "post",
-            request,
-            "v1/fim/completions",
-            stream=True,
-            check_model_deprecation_headers_callback=self._check_model_deprecation_header_callback_factory(model),
-        )
-
-        for json_streamed_response in response:
-            yield ChatCompletionStreamResponse(**json_streamed_response)
+        raise NotImplementedError(MIGRATION_MESSAGE)

mistralai/embeddings.py

@@ -0,0 +1,182 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from .basesdk import BaseSDK
+from mistralai import models, utils
+from mistralai._hooks import HookContext
+from mistralai.types import OptionalNullable, UNSET
+from mistralai.utils import get_security_from_env
+from typing import Any, Optional, Union
+
+class Embeddings(BaseSDK):
+    r"""Embeddings API."""
+    
+    
+    def create(
+        self, *,
+        inputs: Union[models.Inputs, models.InputsTypedDict],
+        model: str,
+        encoding_format: OptionalNullable[str] = UNSET,
+        retries: OptionalNullable[utils.RetryConfig] = UNSET,
+        server_url: Optional[str] = None,
+        timeout_ms: Optional[int] = None,
+    ) -> Optional[models.EmbeddingResponse]:
+        r"""Embeddings
+
+        Embeddings
+
+        :param inputs: Text to embed.
+        :param model: ID of the model to use.
+        :param encoding_format: The format to return the embeddings in.
+        :param retries: Override the default retry configuration for this method
+        :param server_url: Override the default server URL for this method
+        :param timeout_ms: Override the default request timeout configuration for this method in milliseconds
+        """
+        base_url = None
+        url_variables = None
+        if timeout_ms is None:
+            timeout_ms = self.sdk_configuration.timeout_ms
+        
+        if server_url is not None:
+            base_url = server_url
+        
+        request = models.EmbeddingRequest(
+            inputs=inputs,
+            model=model,
+            encoding_format=encoding_format,
+        )
+        
+        req = self.build_request(
+            method="POST",
+            path="/v1/embeddings",
+            base_url=base_url,
+            url_variables=url_variables,
+            request=request,
+            request_body_required=True,
+            request_has_path_params=False,
+            request_has_query_params=True,
+            user_agent_header="user-agent",
+            accept_header_value="application/json",
+            security=self.sdk_configuration.security,
+            get_serialized_body=lambda: utils.serialize_request_body(request, False, False, "json", models.EmbeddingRequest),
+            timeout_ms=timeout_ms,
+        )
+        
+        if retries == UNSET:
+            if self.sdk_configuration.retry_config is not UNSET:
+                retries = self.sdk_configuration.retry_config
+
+        retry_config = None
+        if isinstance(retries, utils.RetryConfig):
+            retry_config = (retries, [
+                "429",
+                "500",
+                "502",
+                "503",
+                "504"
+            ])                
+        
+        http_res = self.do_request(
+            hook_ctx=HookContext(operation_id="embeddings_v1_embeddings_post", oauth2_scopes=[], security_source=get_security_from_env(self.sdk_configuration.security, models.Security)),
+            request=req,
+            error_status_codes=["422","4XX","5XX"],
+            retry_config=retry_config
+        )
+        
+        data: Any = None
+        if utils.match_response(http_res, "200", "application/json"):
+            return utils.unmarshal_json(http_res.text, Optional[models.EmbeddingResponse])
+        if utils.match_response(http_res, "422", "application/json"):
+            data = utils.unmarshal_json(http_res.text, models.HTTPValidationErrorData)
+            raise models.HTTPValidationError(data=data)
+        if utils.match_response(http_res, ["4XX","5XX"], "*"):
+            raise models.SDKError("API error occurred", http_res.status_code, http_res.text, http_res)
+        
+        content_type = http_res.headers.get("Content-Type")
+        raise models.SDKError(f"Unexpected response received (code: {http_res.status_code}, type: {content_type})", http_res.status_code, http_res.text, http_res)
+
+    
+    
+    async def create_async(
+        self, *,
+        inputs: Union[models.Inputs, models.InputsTypedDict],
+        model: str,
+        encoding_format: OptionalNullable[str] = UNSET,
+        retries: OptionalNullable[utils.RetryConfig] = UNSET,
+        server_url: Optional[str] = None,
+        timeout_ms: Optional[int] = None,
+    ) -> Optional[models.EmbeddingResponse]:
+        r"""Embeddings
+
+        Embeddings
+
+        :param inputs: Text to embed.
+        :param model: ID of the model to use.
+        :param encoding_format: The format to return the embeddings in.
+        :param retries: Override the default retry configuration for this method
+        :param server_url: Override the default server URL for this method
+        :param timeout_ms: Override the default request timeout configuration for this method in milliseconds
+        """
+        base_url = None
+        url_variables = None
+        if timeout_ms is None:
+            timeout_ms = self.sdk_configuration.timeout_ms
+        
+        if server_url is not None:
+            base_url = server_url
+        
+        request = models.EmbeddingRequest(
+            inputs=inputs,
+            model=model,
+            encoding_format=encoding_format,
+        )
+        
+        req = self.build_request(
+            method="POST",
+            path="/v1/embeddings",
+            base_url=base_url,
+            url_variables=url_variables,
+            request=request,
+            request_body_required=True,
+            request_has_path_params=False,
+            request_has_query_params=True,
+            user_agent_header="user-agent",
+            accept_header_value="application/json",
+            security=self.sdk_configuration.security,
+            get_serialized_body=lambda: utils.serialize_request_body(request, False, False, "json", models.EmbeddingRequest),
+            timeout_ms=timeout_ms,
+        )
+        
+        if retries == UNSET:
+            if self.sdk_configuration.retry_config is not UNSET:
+                retries = self.sdk_configuration.retry_config
+
+        retry_config = None
+        if isinstance(retries, utils.RetryConfig):
+            retry_config = (retries, [
+                "429",
+                "500",
+                "502",
+                "503",
+                "504"
+            ])                
+        
+        http_res = await self.do_request_async(
+            hook_ctx=HookContext(operation_id="embeddings_v1_embeddings_post", oauth2_scopes=[], security_source=get_security_from_env(self.sdk_configuration.security, models.Security)),
+            request=req,
+            error_status_codes=["422","4XX","5XX"],
+            retry_config=retry_config
+        )
+        
+        data: Any = None
+        if utils.match_response(http_res, "200", "application/json"):
+            return utils.unmarshal_json(http_res.text, Optional[models.EmbeddingResponse])
+        if utils.match_response(http_res, "422", "application/json"):
+            data = utils.unmarshal_json(http_res.text, models.HTTPValidationErrorData)
+            raise models.HTTPValidationError(data=data)
+        if utils.match_response(http_res, ["4XX","5XX"], "*"):
+            raise models.SDKError("API error occurred", http_res.status_code, http_res.text, http_res)
+        
+        content_type = http_res.headers.get("Content-Type")
+        raise models.SDKError(f"Unexpected response received (code: {http_res.status_code}, type: {content_type})", http_res.status_code, http_res.text, http_res)
+
+