mistralai 0.2.0__tar.gz → 0.4.0__tar.gz

{mistralai-0.2.0 → mistralai-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mistralai
-Version: 0.2.0
+Version: 0.4.0
 Summary: 
 Author: Bam4d
 Author-email: bam4d@mistral.ai
@@ -10,8 +10,8 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: httpx (>=0.25.2,<1)
-Requires-Dist: orjson (>=3.9.10,<4.0.0)
+Requires-Dist: httpx (>=0.25,<0.26)
+Requires-Dist: orjson (>=3.9.10,<3.11)
 Requires-Dist: pydantic (>=2.5.2,<3.0.0)
 Description-Content-Type: text/markdown
 

{mistralai-0.2.0 → mistralai-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "mistralai"
-version = "0.2.0"
+version = "0.4.0"
 description = ""
 authors = ["Bam4d <bam4d@mistral.ai>"]
 readme = "README.md"
@@ -23,10 +23,10 @@ exclude = ["docs", "tests", "examples", "tools", "build"]
 
 
 [tool.poetry.dependencies]
-python = "^3.9"
-orjson = "^3.9.10"
-pydantic = "^2.5.2"
-httpx = ">= 0.25.2, < 1"
+python = "^3.9,<4.0"
+orjson = "^3.9.10,<3.11"
+pydantic = "^2.5.2,<3"
+httpx = "^0.25,<1"
 
 
 [tool.poetry.group.dev.dependencies]

{mistralai-0.2.0 → mistralai-0.4.0}/src/mistralai/async_client.py

@@ -20,6 +20,8 @@ from mistralai.exceptions import (
     MistralConnectionException,
     MistralException,
 )
+from mistralai.files import FilesAsyncClient
+from mistralai.jobs import JobsAsyncClient
 from mistralai.models.chat_completion import (
     ChatCompletionResponse,
     ChatCompletionStreamResponse,
@@ -47,6 +49,8 @@ class MistralAsyncClient(ClientBase):
             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()
@@ -92,19 +96,23 @@ class MistralAsyncClient(ClientBase):
     async def _request(
         self,
         method: str,
-        json: Dict[str, Any],
+        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}",
-            "Content-Type": "application/json",
         }
 
+        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}")
@@ -118,6 +126,8 @@ class MistralAsyncClient(ClientBase):
                     url,
                     headers=headers,
                     json=json,
+                    data=data,
+                    **kwargs,
                 ) as response:
                     await self._check_streaming_response(response)
 
@@ -132,6 +142,8 @@ class MistralAsyncClient(ClientBase):
                     url,
                     headers=headers,
                     json=json,
+                    data=data,
+                    **kwargs,
                 )
 
                 yield await self._check_response(response)
@@ -291,3 +303,74 @@ class MistralAsyncClient(ClientBase):
             return ModelList(**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)

{mistralai-0.2.0 → mistralai-0.4.0}/src/mistralai/client.py

@@ -13,6 +13,8 @@ from mistralai.exceptions import (
     MistralConnectionException,
     MistralException,
 )
+from mistralai.files import FilesClient
+from mistralai.jobs import JobsClient
 from mistralai.models.chat_completion import (
     ChatCompletionResponse,
     ChatCompletionStreamResponse,
@@ -40,6 +42,8 @@ class MistralClient(ClientBase):
         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()
@@ -85,19 +89,23 @@ class MistralClient(ClientBase):
     def _request(
         self,
         method: str,
-        json: Dict[str, Any],
+        json: Optional[Dict[str, Any]],
         path: str,
         stream: bool = False,
         attempt: int = 1,
+        data: Optional[Dict[str, Any]] = 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}",
-            "Content-Type": "application/json",
         }
 
+        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}")
@@ -111,6 +119,8 @@ class MistralClient(ClientBase):
                     url,
                     headers=headers,
                     json=json,
+                    data=data,
+                    **kwargs,
                 ) as response:
                     self._check_streaming_response(response)
 
@@ -125,6 +135,8 @@ class MistralClient(ClientBase):
                     url,
                     headers=headers,
                     json=json,
+                    data=data,
+                    **kwargs,
                 )
 
                 yield self._check_response(response)
@@ -285,3 +297,77 @@ class MistralClient(ClientBase):
             return ModelList(**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)
+
+        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)
+
+        for json_streamed_response in response:
+            yield ChatCompletionStreamResponse(**json_streamed_response)

{mistralai-0.2.0 → mistralai-0.4.0}/src/mistralai/client_base.py

@@ -10,7 +10,7 @@ from mistralai.exceptions import (
 )
 from mistralai.models.chat_completion import ChatMessage, Function, ResponseFormat, ToolChoice
 
-CLIENT_VERSION = "0.2.0"
+CLIENT_VERSION = "0.4.0"
 
 
 class ClientBase(ABC):
@@ -73,6 +73,63 @@ class ClientBase(ABC):
 
         return parsed_messages
 
+    def _make_completion_request(
+        self,
+        prompt: str,
+        model: Optional[str] = None,
+        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,
+        stream: Optional[bool] = False,
+    ) -> Dict[str, Any]:
+        request_data: Dict[str, Any] = {
+            "prompt": prompt,
+            "suffix": suffix,
+            "model": model,
+            "stream": stream,
+        }
+
+        if stop is not None:
+            request_data["stop"] = stop
+
+        if model is not None:
+            request_data["model"] = model
+        else:
+            if self._default_model is None:
+                raise MistralException(message="model must be provided")
+            request_data["model"] = self._default_model
+
+        request_data.update(
+            self._build_sampling_params(
+                temperature=temperature, max_tokens=max_tokens, top_p=top_p, random_seed=random_seed
+            )
+        )
+
+        self._logger.debug(f"Completion request: {request_data}")
+
+        return request_data
+
+    def _build_sampling_params(
+        self,
+        max_tokens: Optional[int],
+        random_seed: Optional[int],
+        temperature: Optional[float],
+        top_p: Optional[float],
+    ) -> Dict[str, Any]:
+        params = {}
+        if temperature is not None:
+            params["temperature"] = temperature
+        if max_tokens is not None:
+            params["max_tokens"] = max_tokens
+        if top_p is not None:
+            params["top_p"] = top_p
+        if random_seed is not None:
+            params["random_seed"] = random_seed
+        return params
+
     def _make_chat_request(
         self,
         messages: List[Any],
@@ -89,7 +146,6 @@ class ClientBase(ABC):
     ) -> Dict[str, Any]:
         request_data: Dict[str, Any] = {
             "messages": self._parse_messages(messages),
-            "safe_prompt": safe_prompt,
         }
 
         if model is not None:
@@ -99,16 +155,16 @@ class ClientBase(ABC):
                 raise MistralException(message="model must be provided")
             request_data["model"] = self._default_model
 
+        request_data.update(
+            self._build_sampling_params(
+                temperature=temperature, max_tokens=max_tokens, top_p=top_p, random_seed=random_seed
+            )
+        )
+
+        if safe_prompt:
+            request_data["safe_prompt"] = safe_prompt
         if tools is not None:
             request_data["tools"] = self._parse_tools(tools)
-        if temperature is not None:
-            request_data["temperature"] = temperature
-        if max_tokens is not None:
-            request_data["max_tokens"] = max_tokens
-        if top_p is not None:
-            request_data["top_p"] = top_p
-        if random_seed is not None:
-            request_data["random_seed"] = random_seed
         if stream is not None:
             request_data["stream"] = stream
 

mistralai-0.4.0/src/mistralai/files.py

@@ -0,0 +1,84 @@
+from typing import Any
+
+from mistralai.exceptions import (
+    MistralException,
+)
+from mistralai.models.files import FileDeleted, FileObject, Files
+
+
+class FilesClient:
+    def __init__(self, client: Any):
+        self.client = client
+
+    def create(
+        self,
+        file: bytes,
+        purpose: str = "fine-tune",
+    ) -> FileObject:
+        single_response = self.client._request(
+            "post",
+            None,
+            "v1/files",
+            files={"file": file},
+            data={"purpose": purpose},
+        )
+        for response in single_response:
+            return FileObject(**response)
+        raise MistralException("No response received")
+
+    def retrieve(self, file_id: str) -> FileObject:
+        single_response = self.client._request("get", {}, f"v1/files/{file_id}")
+        for response in single_response:
+            return FileObject(**response)
+        raise MistralException("No response received")
+
+    def list(self) -> Files:
+        single_response = self.client._request("get", {}, "v1/files")
+        for response in single_response:
+            return Files(**response)
+        raise MistralException("No response received")
+
+    def delete(self, file_id: str) -> FileDeleted:
+        single_response = self.client._request("delete", {}, f"v1/files/{file_id}")
+        for response in single_response:
+            return FileDeleted(**response)
+        raise MistralException("No response received")
+
+
+class FilesAsyncClient:
+    def __init__(self, client: Any):
+        self.client = client
+
+    async def create(
+        self,
+        file: bytes,
+        purpose: str = "fine-tune",
+    ) -> FileObject:
+        single_response = self.client._request(
+            "post",
+            None,
+            "v1/files",
+            files={"file": file},
+            data={"purpose": purpose},
+        )
+        async for response in single_response:
+            return FileObject(**response)
+        raise MistralException("No response received")
+
+    async def retrieve(self, file_id: str) -> FileObject:
+        single_response = self.client._request("get", {}, f"v1/files/{file_id}")
+        async for response in single_response:
+            return FileObject(**response)
+        raise MistralException("No response received")
+
+    async def list(self) -> Files:
+        single_response = self.client._request("get", {}, "v1/files")
+        async for response in single_response:
+            return Files(**response)
+        raise MistralException("No response received")
+
+    async def delete(self, file_id: str) -> FileDeleted:
+        single_response = self.client._request("delete", {}, f"v1/files/{file_id}")
+        async for response in single_response:
+            return FileDeleted(**response)
+        raise MistralException("No response received")

mistralai-0.4.0/src/mistralai/jobs.py

@@ -0,0 +1,172 @@
+from datetime import datetime
+from typing import Any, Optional, Union
+
+from mistralai.exceptions import (
+    MistralException,
+)
+from mistralai.models.jobs import DetailedJob, IntegrationIn, Job, JobMetadata, JobQueryFilter, Jobs, TrainingParameters
+
+
+class JobsClient:
+    def __init__(self, client: Any):
+        self.client = client
+
+    def create(
+        self,
+        model: str,
+        training_files: Union[list[str], None] = None,
+        validation_files: Union[list[str], None] = None,
+        hyperparameters: TrainingParameters = TrainingParameters(
+            training_steps=1800,
+            learning_rate=1.0e-4,
+        ),
+        suffix: Union[str, None] = None,
+        integrations: Union[set[IntegrationIn], None] = None,
+        training_file: Union[str, None] = None,  # Deprecated: Added for compatibility with OpenAI API
+        validation_file: Union[str, None] = None,  # Deprecated: Added for compatibility with OpenAI API
+        dry_run: bool = False,
+    ) -> Union[Job, JobMetadata]:
+        # Handle deprecated arguments
+        if not training_files and training_file:
+            training_files = [training_file]
+        if not validation_files and validation_file:
+            validation_files = [validation_file]
+        single_response = self.client._request(
+            method="post",
+            json={
+                "model": model,
+                "training_files": training_files,
+                "validation_files": validation_files,
+                "hyperparameters": hyperparameters.dict(),
+                "suffix": suffix,
+                "integrations": integrations,
+            },
+            path="v1/fine_tuning/jobs",
+            params={"dry_run": dry_run},
+        )
+        for response in single_response:
+            return Job(**response) if not dry_run else JobMetadata(**response)
+        raise MistralException("No response received")
+
+    def retrieve(self, job_id: str) -> DetailedJob:
+        single_response = self.client._request(method="get", path=f"v1/fine_tuning/jobs/{job_id}", json={})
+        for response in single_response:
+            return DetailedJob(**response)
+        raise MistralException("No response received")
+
+    def list(
+        self,
+        page: int = 0,
+        page_size: int = 10,
+        model: Optional[str] = None,
+        created_after: Optional[datetime] = None,
+        created_by_me: Optional[bool] = None,
+        status: Optional[str] = None,
+        wandb_project: Optional[str] = None,
+        wandb_name: Optional[str] = None,
+        suffix: Optional[str] = None,
+    ) -> Jobs:
+        query_params = JobQueryFilter(
+            page=page,
+            page_size=page_size,
+            model=model,
+            created_after=created_after,
+            created_by_me=created_by_me,
+            status=status,
+            wandb_project=wandb_project,
+            wandb_name=wandb_name,
+            suffix=suffix,
+        ).model_dump(exclude_none=True)
+        single_response = self.client._request(method="get", params=query_params, path="v1/fine_tuning/jobs", json={})
+        for response in single_response:
+            return Jobs(**response)
+        raise MistralException("No response received")
+
+    def cancel(self, job_id: str) -> DetailedJob:
+        single_response = self.client._request(method="post", path=f"v1/fine_tuning/jobs/{job_id}/cancel", json={})
+        for response in single_response:
+            return DetailedJob(**response)
+        raise MistralException("No response received")
+
+
+class JobsAsyncClient:
+    def __init__(self, client: Any):
+        self.client = client
+
+    async def create(
+        self,
+        model: str,
+        training_files: Union[list[str], None] = None,
+        validation_files: Union[list[str], None] = None,
+        hyperparameters: TrainingParameters = TrainingParameters(
+            training_steps=1800,
+            learning_rate=1.0e-4,
+        ),
+        suffix: Union[str, None] = None,
+        integrations: Union[set[IntegrationIn], None] = None,
+        training_file: Union[str, None] = None,  # Deprecated: Added for compatibility with OpenAI API
+        validation_file: Union[str, None] = None,  # Deprecated: Added for compatibility with OpenAI API
+        dry_run: bool = False,
+    ) -> Union[Job, JobMetadata]:
+        # Handle deprecated arguments
+        if not training_files and training_file:
+            training_files = [training_file]
+        if not validation_files and validation_file:
+            validation_files = [validation_file]
+
+        single_response = self.client._request(
+            method="post",
+            json={
+                "model": model,
+                "training_files": training_files,
+                "validation_files": validation_files,
+                "hyperparameters": hyperparameters.dict(),
+                "suffix": suffix,
+                "integrations": integrations,
+            },
+            path="v1/fine_tuning/jobs",
+            params={"dry_run": dry_run},
+        )
+        async for response in single_response:
+            return Job(**response) if not dry_run else JobMetadata(**response)
+        raise MistralException("No response received")
+
+    async def retrieve(self, job_id: str) -> DetailedJob:
+        single_response = self.client._request(method="get", path=f"v1/fine_tuning/jobs/{job_id}", json={})
+        async for response in single_response:
+            return DetailedJob(**response)
+        raise MistralException("No response received")
+
+    async def list(
+        self,
+        page: int = 0,
+        page_size: int = 10,
+        model: Optional[str] = None,
+        created_after: Optional[datetime] = None,
+        created_by_me: Optional[bool] = None,
+        status: Optional[str] = None,
+        wandb_project: Optional[str] = None,
+        wandb_name: Optional[str] = None,
+        suffix: Optional[str] = None,
+    ) -> Jobs:
+        query_params = JobQueryFilter(
+            page=page,
+            page_size=page_size,
+            model=model,
+            created_after=created_after,
+            created_by_me=created_by_me,
+            status=status,
+            wandb_project=wandb_project,
+            wandb_name=wandb_name,
+            suffix=suffix,
+        ).model_dump(exclude_none=True)
+        single_response = self.client._request(method="get", path="v1/fine_tuning/jobs", params=query_params, json={})
+        async for response in single_response:
+            return Jobs(**response)
+        raise MistralException("No response received")
+
+    async def cancel(self, job_id: str) -> DetailedJob:
+        single_response = self.client._request(method="post", path=f"v1/fine_tuning/jobs/{job_id}/cancel", json={})
+        async for response in single_response:
+            return DetailedJob(**response)
+        raise MistralException("No response received")

{mistralai-0.2.0 → mistralai-0.4.0}/src/mistralai/models/chat_completion.py

@@ -1,5 +1,5 @@
 from enum import Enum
-from typing import List, Optional, Union
+from typing import List, Optional
 
 from pydantic import BaseModel
 
@@ -44,7 +44,7 @@ class ResponseFormat(BaseModel):
 
 class ChatMessage(BaseModel):
     role: str
-    content: Union[str, List[str]]
+    content: str
     name: Optional[str] = None
     tool_calls: Optional[List[ToolCall]] = None
     tool_call_id: Optional[str] = None

mistralai-0.4.0/src/mistralai/models/files.py

@@ -0,0 +1,23 @@
+from typing import Literal, Optional
+
+from pydantic import BaseModel
+
+
+class FileObject(BaseModel):
+    id: str
+    object: str
+    bytes: int
+    created_at: int
+    filename: str
+    purpose: Optional[Literal["fine-tune"]] = "fine-tune"
+
+
+class FileDeleted(BaseModel):
+    id: str
+    object: str
+    deleted: bool
+
+
+class Files(BaseModel):
+    data: list[FileObject]
+    object: Literal["list"]

mistralai-0.4.0/src/mistralai/models/jobs.py

@@ -0,0 +1,98 @@
+from datetime import datetime
+from typing import Annotated, List, Literal, Optional, Union
+
+from pydantic import BaseModel, Field
+
+
+class TrainingParameters(BaseModel):
+    training_steps: int = Field(1800, le=10000, ge=1)
+    learning_rate: float = Field(1.0e-4, le=1, ge=1.0e-8)
+
+
+class WandbIntegration(BaseModel):
+    type: Literal["wandb"] = "wandb"
+    project: str
+    name: Union[str, None] = None
+    run_name: Union[str, None] = None
+
+
+class WandbIntegrationIn(WandbIntegration):
+    api_key: str
+
+
+Integration = Annotated[Union[WandbIntegration], Field(discriminator="type")]
+IntegrationIn = Annotated[Union[WandbIntegrationIn], Field(discriminator="type")]
+
+
+class JobMetadata(BaseModel):
+    object: Literal["job.metadata"] = "job.metadata"
+    training_steps: int
+    train_tokens_per_step: int
+    data_tokens: int
+    train_tokens: int
+    epochs: float
+    expected_duration_seconds: Optional[int]
+
+
+class Job(BaseModel):
+    id: str
+    hyperparameters: TrainingParameters
+    fine_tuned_model: Union[str, None]
+    model: str
+    status: Literal[
+        "QUEUED",
+        "STARTED",
+        "RUNNING",
+        "FAILED",
+        "SUCCESS",
+        "CANCELLED",
+        "CANCELLATION_REQUESTED",
+    ]
+    job_type: str
+    created_at: int
+    modified_at: int
+    training_files: list[str]
+    validation_files: Union[list[str], None] = []
+    object: Literal["job"]
+    integrations: List[Integration] = []
+
+
+class Event(BaseModel):
+    name: str
+    data: Union[dict, None] = None
+    created_at: int
+
+
+class Metric(BaseModel):
+    train_loss: Union[float, None] = None
+    valid_loss: Union[float, None] = None
+    valid_mean_token_accuracy: Union[float, None] = None
+
+
+class Checkpoint(BaseModel):
+    metrics: Metric
+    step_number: int
+    created_at: int
+
+
+class JobQueryFilter(BaseModel):
+    page: int = 0
+    page_size: int = 100
+    model: Optional[str] = None
+    created_after: Optional[datetime] = None
+    created_by_me: Optional[bool] = None
+    status: Optional[str] = None
+    wandb_project: Optional[str] = None
+    wandb_name: Optional[str] = None
+    suffix: Optional[str] = None
+
+
+class DetailedJob(Job):
+    events: list[Event] = []
+    checkpoints: list[Checkpoint] = []
+    estimated_start_time: Optional[int] = None
+
+
+class Jobs(BaseModel):
+    data: list[Job] = []
+    object: Literal["list"]

{mistralai-0.2.0 → mistralai-0.4.0}/src/mistralai/models/models.py

@@ -7,15 +7,15 @@ class ModelPermission(BaseModel):
     id: str
     object: str
     created: int
-    allow_create_engine: bool = False
+    allow_create_engine: Optional[bool] = False
     allow_sampling: bool = True
     allow_logprobs: bool = True
-    allow_search_indices: bool = False
+    allow_search_indices: Optional[bool] = False
     allow_view: bool = True
     allow_fine_tuning: bool = False
     organization: str = "*"
     group: Optional[str] = None
-    is_blocking: bool = False
+    is_blocking: Optional[bool] = False
 
 
 class ModelCard(BaseModel):