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

mistralai/client_base.py

@@ -1,211 +0,0 @@
-import logging
-import os
-from abc import ABC
-from typing import Any, Callable, Dict, List, Optional, Union
-
-import orjson
-from httpx import Headers
-
-from mistralai.constants import HEADER_MODEL_DEPRECATION_TIMESTAMP
-from mistralai.exceptions import MistralException
-from mistralai.models.chat_completion import (
-    ChatMessage,
-    Function,
-    ResponseFormat,
-    ToolChoice,
-)
-
-CLIENT_VERSION = "0.4.2"
-
-
-class ClientBase(ABC):
-    def __init__(
-        self,
-        endpoint: str,
-        api_key: Optional[str] = None,
-        max_retries: int = 5,
-        timeout: int = 120,
-    ):
-        self._max_retries = max_retries
-        self._timeout = timeout
-
-        if api_key is None:
-            api_key = os.environ.get("MISTRAL_API_KEY")
-        if api_key is None:
-            raise MistralException(message="API key not provided. Please set MISTRAL_API_KEY environment variable.")
-        self._api_key = api_key
-        self._endpoint = endpoint
-        self._logger = logging.getLogger(__name__)
-
-        # For azure endpoints, we default to the mistral model
-        if "inference.azure.com" in self._endpoint:
-            self._default_model = "mistral"
-
-        self._version = CLIENT_VERSION
-
-    def _get_model(self, model: Optional[str] = None) -> str:
-        if model is not None:
-            return model
-        else:
-            if self._default_model is None:
-                raise MistralException(message="model must be provided")
-            return self._default_model
-
-    def _parse_tools(self, tools: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
-        parsed_tools: List[Dict[str, Any]] = []
-        for tool in tools:
-            if tool["type"] == "function":
-                parsed_function = {}
-                parsed_function["type"] = tool["type"]
-                if isinstance(tool["function"], Function):
-                    parsed_function["function"] = tool["function"].model_dump(exclude_none=True)
-                else:
-                    parsed_function["function"] = tool["function"]
-
-                parsed_tools.append(parsed_function)
-
-        return parsed_tools
-
-    def _parse_tool_choice(self, tool_choice: Union[str, ToolChoice]) -> str:
-        if isinstance(tool_choice, ToolChoice):
-            return tool_choice.value
-        return tool_choice
-
-    def _parse_response_format(self, response_format: Union[Dict[str, Any], ResponseFormat]) -> Dict[str, Any]:
-        if isinstance(response_format, ResponseFormat):
-            return response_format.model_dump(exclude_none=True)
-        return response_format
-
-    def _parse_messages(self, messages: List[Any]) -> List[Dict[str, Any]]:
-        parsed_messages: List[Dict[str, Any]] = []
-        for message in messages:
-            if isinstance(message, ChatMessage):
-                parsed_messages.append(message.model_dump(exclude_none=True))
-            else:
-                parsed_messages.append(message)
-
-        return parsed_messages
-
-    def _check_model_deprecation_header_callback_factory(self, model: Optional[str] = None) -> Callable:
-        model = self._get_model(model)
-
-        def _check_model_deprecation_header_callback(
-            headers: Headers,
-        ) -> None:
-            if HEADER_MODEL_DEPRECATION_TIMESTAMP in headers:
-                self._logger.warning(
-                    f"WARNING: The model {model} is deprecated "
-                    f"and will be removed on {headers[HEADER_MODEL_DEPRECATION_TIMESTAMP]}. "
-                    "Please refer to https://docs.mistral.ai/getting-started/models/#api-versioning "
-                    "for more information."
-                )
-
-        return _check_model_deprecation_header_callback
-
-    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
-
-        request_data["model"] = self._get_model(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],
-        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,
-        stream: Optional[bool] = None,
-        safe_prompt: Optional[bool] = False,
-        tool_choice: Optional[Union[str, ToolChoice]] = None,
-        response_format: Optional[Union[Dict[str, str], ResponseFormat]] = None,
-    ) -> Dict[str, Any]:
-        request_data: Dict[str, Any] = {
-            "messages": self._parse_messages(messages),
-        }
-
-        request_data["model"] = self._get_model(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 stream is not None:
-            request_data["stream"] = stream
-
-        if tool_choice is not None:
-            request_data["tool_choice"] = self._parse_tool_choice(tool_choice)
-        if response_format is not None:
-            request_data["response_format"] = self._parse_response_format(response_format)
-
-        self._logger.debug(f"Chat request: {request_data}")
-
-        return request_data
-
-    def _process_line(self, line: str) -> Optional[Dict[str, Any]]:
-        if line.startswith("data: "):
-            line = line[6:].strip()
-            if line != "[DONE]":
-                json_streamed_response: Dict[str, Any] = orjson.loads(line)
-                return json_streamed_response
-        return None

mistralai/constants.py

@@ -1,5 +0,0 @@
-RETRY_STATUS_CODES = {429, 500, 502, 503, 504}
-
-ENDPOINT = "https://api.mistral.ai"
-
-HEADER_MODEL_DEPRECATION_TIMESTAMP = "x-model-deprecation-timestamp"

mistralai/exceptions.py

@@ -1,54 +0,0 @@
-from __future__ import annotations
-
-from typing import Any, Dict, Optional
-
-from httpx import Response
-
-
-class MistralException(Exception):
-    """Base Exception class, returned when nothing more specific applies"""
-
-    def __init__(self, message: Optional[str] = None) -> None:
-        super(MistralException, self).__init__(message)
-
-        self.message = message
-
-    def __str__(self) -> str:
-        msg = self.message or "<empty message>"
-        return msg
-
-    def __repr__(self) -> str:
-        return f"{self.__class__.__name__}(message={str(self)})"
-
-
-class MistralAPIException(MistralException):
-    """Returned when the API responds with an error message"""
-
-    def __init__(
-        self,
-        message: Optional[str] = None,
-        http_status: Optional[int] = None,
-        headers: Optional[Dict[str, Any]] = None,
-    ) -> None:
-        super().__init__(message)
-        self.http_status = http_status
-        self.headers = headers or {}
-
-    @classmethod
-    def from_response(cls, response: Response, message: Optional[str] = None) -> MistralAPIException:
-        return cls(
-            message=message or response.text,
-            http_status=response.status_code,
-            headers=dict(response.headers),
-        )
-
-    def __repr__(self) -> str:
-        return f"{self.__class__.__name__}(message={str(self)}, http_status={self.http_status})"
-
-
-class MistralAPIStatusException(MistralAPIException):
-    """Returned when we receive a non-200 response from the API that we should retry"""
-
-
-class MistralConnectionException(MistralException):
-    """Returned when the SDK can not reach the API server for any reason"""

mistralai/jobs.py

@@ -1,172 +0,0 @@
-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/models/chat_completion.py

@@ -1,93 +0,0 @@
-from enum import Enum
-from typing import List, Optional
-
-from pydantic import BaseModel
-
-from mistralai.models.common import UsageInfo
-
-
-class Function(BaseModel):
-    name: str
-    description: str
-    parameters: dict
-
-
-class ToolType(str, Enum):
-    function = "function"
-
-
-class FunctionCall(BaseModel):
-    name: str
-    arguments: str
-
-
-class ToolCall(BaseModel):
-    id: str = "null"
-    type: ToolType = ToolType.function
-    function: FunctionCall
-
-
-class ResponseFormats(str, Enum):
-    text: str = "text"
-    json_object: str = "json_object"
-
-
-class ToolChoice(str, Enum):
-    auto: str = "auto"
-    any: str = "any"
-    none: str = "none"
-
-
-class ResponseFormat(BaseModel):
-    type: ResponseFormats = ResponseFormats.text
-
-
-class ChatMessage(BaseModel):
-    role: str
-    content: str
-    name: Optional[str] = None
-    tool_calls: Optional[List[ToolCall]] = None
-    tool_call_id: Optional[str] = None
-
-
-class DeltaMessage(BaseModel):
-    role: Optional[str] = None
-    content: Optional[str] = None
-    tool_calls: Optional[List[ToolCall]] = None
-
-
-class FinishReason(str, Enum):
-    stop = "stop"
-    length = "length"
-    error = "error"
-    tool_calls = "tool_calls"
-
-
-class ChatCompletionResponseStreamChoice(BaseModel):
-    index: int
-    delta: DeltaMessage
-    finish_reason: Optional[FinishReason]
-
-
-class ChatCompletionStreamResponse(BaseModel):
-    id: str
-    model: str
-    choices: List[ChatCompletionResponseStreamChoice]
-    created: Optional[int] = None
-    object: Optional[str] = None
-    usage: Optional[UsageInfo] = None
-
-
-class ChatCompletionResponseChoice(BaseModel):
-    index: int
-    message: ChatMessage
-    finish_reason: Optional[FinishReason]
-
-
-class ChatCompletionResponse(BaseModel):
-    id: str
-    object: str
-    created: int
-    model: str
-    choices: List[ChatCompletionResponseChoice]
-    usage: UsageInfo

mistralai/models/common.py

@@ -1,9 +0,0 @@
-from typing import Optional
-
-from pydantic import BaseModel
-
-
-class UsageInfo(BaseModel):
-    prompt_tokens: int
-    total_tokens: int
-    completion_tokens: Optional[int]

mistralai/models/embeddings.py

@@ -1,19 +0,0 @@
-from typing import List
-
-from pydantic import BaseModel
-
-from mistralai.models.common import UsageInfo
-
-
-class EmbeddingObject(BaseModel):
-    object: str
-    embedding: List[float]
-    index: int
-
-
-class EmbeddingResponse(BaseModel):
-    id: str
-    object: str
-    data: List[EmbeddingObject]
-    model: str
-    usage: UsageInfo

mistralai/models/files.py

@@ -1,23 +0,0 @@
-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/models/jobs.py

@@ -1,100 +0,0 @@
-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]
-    cost: Optional[float] = None
-    cost_currency: Optional[str] = None
-
-
-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"]