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

mistralai_gcp/utils/serializers.py

@@ -0,0 +1,181 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from decimal import Decimal
+import json
+from typing import Any, Dict, List, Union, get_args
+import httpx
+from typing_extensions import get_origin
+from pydantic import ConfigDict, create_model
+from pydantic_core import from_json
+from typing_inspect import is_optional_type
+
+from ..types.basemodel import BaseModel, Nullable, OptionalNullable
+
+
+def serialize_decimal(as_str: bool):
+    def serialize(d):
+        if is_optional_type(type(d)) and d is None:
+            return None
+
+        if not isinstance(d, Decimal):
+            raise ValueError("Expected Decimal object")
+
+        return str(d) if as_str else float(d)
+
+    return serialize
+
+
+def validate_decimal(d):
+    if d is None:
+        return None
+
+    if isinstance(d, Decimal):
+        return d
+
+    if not isinstance(d, (str, int, float)):
+        raise ValueError("Expected string, int or float")
+
+    return Decimal(str(d))
+
+
+def serialize_float(as_str: bool):
+    def serialize(f):
+        if is_optional_type(type(f)) and f is None:
+            return None
+
+        if not isinstance(f, float):
+            raise ValueError("Expected float")
+
+        return str(f) if as_str else f
+
+    return serialize
+
+
+def validate_float(f):
+    if f is None:
+        return None
+
+    if isinstance(f, float):
+        return f
+
+    if not isinstance(f, str):
+        raise ValueError("Expected string")
+
+    return float(f)
+
+
+def serialize_int(as_str: bool):
+    def serialize(b):
+        if is_optional_type(type(b)) and b is None:
+            return None
+
+        if not isinstance(b, int):
+            raise ValueError("Expected int")
+
+        return str(b) if as_str else b
+
+    return serialize
+
+
+def validate_int(b):
+    if b is None:
+        return None
+
+    if isinstance(b, int):
+        return b
+
+    if not isinstance(b, str):
+        raise ValueError("Expected string")
+
+    return int(b)
+
+
+def validate_open_enum(is_int: bool):
+    def validate(e):
+        if e is None:
+            return None
+
+        if is_int:
+            if not isinstance(e, int):
+                raise ValueError("Expected int")
+        else:
+            if not isinstance(e, str):
+                raise ValueError("Expected string")
+
+        return e
+
+    return validate
+
+
+def unmarshal_json(raw, typ: Any) -> Any:
+    return unmarshal(from_json(raw), typ)
+
+
+def unmarshal(val, typ: Any) -> Any:
+    unmarshaller = create_model(
+        "Unmarshaller",
+        body=(typ, ...),
+        __config__=ConfigDict(populate_by_name=True, arbitrary_types_allowed=True),
+    )
+
+    m = unmarshaller(body=val)
+
+    # pyright: ignore[reportAttributeAccessIssue]
+    return m.body  # type: ignore
+
+
+def marshal_json(val, typ):
+    if is_nullable(typ) and val is None:
+        return "null"
+
+    marshaller = create_model(
+        "Marshaller",
+        body=(typ, ...),
+        __config__=ConfigDict(populate_by_name=True, arbitrary_types_allowed=True),
+    )
+
+    m = marshaller(body=val)
+
+    d = m.model_dump(by_alias=True, mode="json", exclude_none=True)
+
+    if len(d) == 0:
+        return ""
+
+    return json.dumps(d[next(iter(d))], separators=(",", ":"), sort_keys=True)
+
+
+def is_nullable(field):
+    origin = get_origin(field)
+    if origin is Nullable or origin is OptionalNullable:
+        return True
+
+    if not origin is Union or type(None) not in get_args(field):
+        return False
+
+    for arg in get_args(field):
+        if get_origin(arg) is Nullable or get_origin(arg) is OptionalNullable:
+            return True
+
+    return False
+
+
+def stream_to_text(stream: httpx.Response) -> str:
+    return "".join(stream.iter_text())
+
+
+def get_pydantic_model(data: Any, typ: Any) -> Any:
+    if not _contains_pydantic_model(data):
+        return unmarshal(data, typ)
+
+    return data
+
+
+def _contains_pydantic_model(data: Any) -> bool:
+    if isinstance(data, BaseModel):
+        return True
+    if isinstance(data, List):
+        return any(_contains_pydantic_model(item) for item in data)
+    if isinstance(data, Dict):
+        return any(_contains_pydantic_model(value) for value in data.values())
+
+    return False

mistralai_gcp/utils/url.py

@@ -0,0 +1,150 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from decimal import Decimal
+from typing import (
+    Any,
+    Dict,
+    get_type_hints,
+    List,
+    Optional,
+    Union,
+    get_args,
+    get_origin,
+)
+from pydantic import BaseModel
+from pydantic.fields import FieldInfo
+
+from .metadata import (
+    PathParamMetadata,
+    find_field_metadata,
+)
+from .values import _get_serialized_params, _populate_from_globals, _val_to_string
+
+
+def generate_url(
+    server_url: str,
+    path: str,
+    path_params: Any,
+    gbls: Optional[Any] = None,
+) -> str:
+    path_param_values: Dict[str, str] = {}
+
+    globals_already_populated = _populate_path_params(
+        path_params, gbls, path_param_values, []
+    )
+    if gbls is not None:
+        _populate_path_params(gbls, None, path_param_values, globals_already_populated)
+
+    for key, value in path_param_values.items():
+        path = path.replace("{" + key + "}", value, 1)
+
+    return remove_suffix(server_url, "/") + path
+
+
+def _populate_path_params(
+    path_params: Any,
+    gbls: Any,
+    path_param_values: Dict[str, str],
+    skip_fields: List[str],
+) -> List[str]:
+    globals_already_populated: List[str] = []
+
+    if not isinstance(path_params, BaseModel):
+        return globals_already_populated
+
+    path_param_fields: Dict[str, FieldInfo] = path_params.__class__.model_fields
+    path_param_field_types = get_type_hints(path_params.__class__)
+    for name in path_param_fields:
+        if name in skip_fields:
+            continue
+
+        field = path_param_fields[name]
+
+        param_metadata = find_field_metadata(field, PathParamMetadata)
+        if param_metadata is None:
+            continue
+
+        param = getattr(path_params, name) if path_params is not None else None
+        param, global_found = _populate_from_globals(
+            name, param, PathParamMetadata, gbls
+        )
+        if global_found:
+            globals_already_populated.append(name)
+
+        if param is None:
+            continue
+
+        f_name = field.alias if field.alias is not None else name
+        serialization = param_metadata.serialization
+        if serialization is not None:
+            serialized_params = _get_serialized_params(
+                param_metadata, f_name, param, path_param_field_types[name]
+            )
+            for key, value in serialized_params.items():
+                path_param_values[key] = value
+        else:
+            pp_vals: List[str] = []
+            if param_metadata.style == "simple":
+                if isinstance(param, List):
+                    for pp_val in param:
+                        if pp_val is None:
+                            continue
+                        pp_vals.append(_val_to_string(pp_val))
+                    path_param_values[f_name] = ",".join(pp_vals)
+                elif isinstance(param, Dict):
+                    for pp_key in param:
+                        if param[pp_key] is None:
+                            continue
+                        if param_metadata.explode:
+                            pp_vals.append(f"{pp_key}={_val_to_string(param[pp_key])}")
+                        else:
+                            pp_vals.append(f"{pp_key},{_val_to_string(param[pp_key])}")
+                    path_param_values[f_name] = ",".join(pp_vals)
+                elif not isinstance(param, (str, int, float, complex, bool, Decimal)):
+                    param_fields: Dict[str, FieldInfo] = param.__class__.model_fields
+                    for name in param_fields:
+                        param_field = param_fields[name]
+
+                        param_value_metadata = find_field_metadata(
+                            param_field, PathParamMetadata
+                        )
+                        if param_value_metadata is None:
+                            continue
+
+                        param_name = (
+                            param_field.alias if param_field.alias is not None else name
+                        )
+
+                        param_field_val = getattr(param, name)
+                        if param_field_val is None:
+                            continue
+                        if param_metadata.explode:
+                            pp_vals.append(
+                                f"{param_name}={_val_to_string(param_field_val)}"
+                            )
+                        else:
+                            pp_vals.append(
+                                f"{param_name},{_val_to_string(param_field_val)}"
+                            )
+                    path_param_values[f_name] = ",".join(pp_vals)
+                else:
+                    path_param_values[f_name] = _val_to_string(param)
+
+    return globals_already_populated
+
+
+def is_optional(field):
+    return get_origin(field) is Union and type(None) in get_args(field)
+
+
+def template_url(url_with_params: str, params: Dict[str, str]) -> str:
+    for key, value in params.items():
+        url_with_params = url_with_params.replace("{" + key + "}", value)
+
+    return url_with_params
+
+
+def remove_suffix(input_string, suffix):
+    if suffix and input_string.endswith(suffix):
+        return input_string[: -len(suffix)]
+    return input_string

mistralai_gcp/utils/values.py

@@ -0,0 +1,128 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from datetime import datetime
+from enum import Enum
+from email.message import Message
+import os
+from typing import Any, Callable, Dict, List, Optional, Tuple, TypeVar, Union
+
+from httpx import Response
+from pydantic import BaseModel
+from pydantic.fields import FieldInfo
+
+from .serializers import marshal_json
+
+from .metadata import ParamMetadata, find_field_metadata
+
+
+def match_content_type(content_type: str, pattern: str) -> bool:
+    if pattern in (content_type, "*", "*/*"):
+        return True
+
+    msg = Message()
+    msg["content-type"] = content_type
+    media_type = msg.get_content_type()
+
+    if media_type == pattern:
+        return True
+
+    parts = media_type.split("/")
+    if len(parts) == 2:
+        if pattern in (f"{parts[0]}/*", f"*/{parts[1]}"):
+            return True
+
+    return False
+
+
+def match_status_codes(status_codes: List[str], status_code: int) -> bool:
+    if "default" in status_codes:
+        return True
+
+    for code in status_codes:
+        if code == str(status_code):
+            return True
+
+        if code.endswith("XX") and code.startswith(str(status_code)[:1]):
+            return True
+    return False
+
+
+T = TypeVar("T")
+
+
+def get_global_from_env(
+    value: Optional[T], env_key: str, type_cast: Callable[[str], T]
+) -> Optional[T]:
+    if value is not None:
+        return value
+    env_value = os.getenv(env_key)
+    if env_value is not None:
+        try:
+            return type_cast(env_value)
+        except ValueError:
+            pass
+    return None
+
+
+def match_response(
+    response: Response, code: Union[str, List[str]], content_type: str
+) -> bool:
+    codes = code if isinstance(code, list) else [code]
+    return match_status_codes(codes, response.status_code) and match_content_type(
+        response.headers.get("content-type", "application/octet-stream"), content_type
+    )
+
+
+def _populate_from_globals(
+    param_name: str, value: Any, param_metadata_type: type, gbls: Any
+) -> Tuple[Any, bool]:
+    if gbls is None:
+        return value, False
+
+    if not isinstance(gbls, BaseModel):
+        raise TypeError("globals must be a pydantic model")
+
+    global_fields: Dict[str, FieldInfo] = gbls.__class__.model_fields
+    found = False
+    for name in global_fields:
+        field = global_fields[name]
+        if name is not param_name:
+            continue
+
+        found = True
+
+        if value is not None:
+            return value, True
+
+        global_value = getattr(gbls, name)
+
+        param_metadata = find_field_metadata(field, param_metadata_type)
+        if param_metadata is None:
+            return value, True
+
+        return global_value, True
+
+    return value, found
+
+
+def _val_to_string(val) -> str:
+    if isinstance(val, bool):
+        return str(val).lower()
+    if isinstance(val, datetime):
+        return str(val.isoformat().replace("+00:00", "Z"))
+    if isinstance(val, Enum):
+        return str(val.value)
+
+    return str(val)
+
+
+def _get_serialized_params(
+    metadata: ParamMetadata, field_name: str, obj: Any, typ: type
+) -> Dict[str, str]:
+    params: Dict[str, str] = {}
+
+    serialization = metadata.serialization
+    if serialization == "json":
+        params[field_name] = marshal_json(obj, typ)
+
+    return params

py.typed

@@ -0,0 +1 @@
+# Marker file for PEP 561. The package enables type hints.

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"