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

mistralai_azure/utils/requestbodies.py

@@ -0,0 +1,66 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+import io
+from dataclasses import dataclass
+import re
+from typing import (
+    Any,
+    Optional,
+)
+
+from .forms import serialize_form_data, serialize_multipart_form
+
+from .serializers import marshal_json
+
+SERIALIZATION_METHOD_TO_CONTENT_TYPE = {
+    "json": "application/json",
+    "form": "application/x-www-form-urlencoded",
+    "multipart": "multipart/form-data",
+    "raw": "application/octet-stream",
+    "string": "text/plain",
+}
+
+
+@dataclass
+class SerializedRequestBody:
+    media_type: str
+    content: Optional[Any] = None
+    data: Optional[Any] = None
+    files: Optional[Any] = None
+
+
+def serialize_request_body(
+    request_body: Any,
+    nullable: bool,
+    optional: bool,
+    serialization_method: str,
+    request_body_type,
+) -> Optional[SerializedRequestBody]:
+    if request_body is None:
+        if not nullable and optional:
+            return None
+
+    media_type = SERIALIZATION_METHOD_TO_CONTENT_TYPE[serialization_method]
+
+    serialized_request_body = SerializedRequestBody(media_type)
+
+    if re.match(r"(application|text)\/.*?\+*json.*", media_type) is not None:
+        serialized_request_body.content = marshal_json(request_body, request_body_type)
+    elif re.match(r"multipart\/.*", media_type) is not None:
+        (
+            serialized_request_body.media_type,
+            serialized_request_body.data,
+            serialized_request_body.files,
+        ) = serialize_multipart_form(media_type, request_body)
+    elif re.match(r"application\/x-www-form-urlencoded.*", media_type) is not None:
+        serialized_request_body.data = serialize_form_data(request_body)
+    elif isinstance(request_body, (bytes, bytearray, io.BytesIO, io.BufferedReader)):
+        serialized_request_body.content = request_body
+    elif isinstance(request_body, str):
+        serialized_request_body.content = request_body
+    else:
+        raise TypeError(
+            f"invalid request body type {type(request_body)} for mediaType {media_type}"
+        )
+
+    return serialized_request_body

mistralai_azure/utils/retries.py

@@ -0,0 +1,216 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+import random
+import time
+from typing import List
+
+import httpx
+
+
+class BackoffStrategy:
+    initial_interval: int
+    max_interval: int
+    exponent: float
+    max_elapsed_time: int
+
+    def __init__(
+        self,
+        initial_interval: int,
+        max_interval: int,
+        exponent: float,
+        max_elapsed_time: int,
+    ):
+        self.initial_interval = initial_interval
+        self.max_interval = max_interval
+        self.exponent = exponent
+        self.max_elapsed_time = max_elapsed_time
+
+
+class RetryConfig:
+    strategy: str
+    backoff: BackoffStrategy
+    retry_connection_errors: bool
+
+    def __init__(
+        self, strategy: str, backoff: BackoffStrategy, retry_connection_errors: bool
+    ):
+        self.strategy = strategy
+        self.backoff = backoff
+        self.retry_connection_errors = retry_connection_errors
+
+
+class Retries:
+    config: RetryConfig
+    status_codes: List[str]
+
+    def __init__(self, config: RetryConfig, status_codes: List[str]):
+        self.config = config
+        self.status_codes = status_codes
+
+
+class TemporaryError(Exception):
+    response: httpx.Response
+
+    def __init__(self, response: httpx.Response):
+        self.response = response
+
+
+class PermanentError(Exception):
+    inner: Exception
+
+    def __init__(self, inner: Exception):
+        self.inner = inner
+
+
+def retry(func, retries: Retries):
+    if retries.config.strategy == "backoff":
+
+        def do_request() -> httpx.Response:
+            res: httpx.Response
+            try:
+                res = func()
+
+                for code in retries.status_codes:
+                    if "X" in code.upper():
+                        code_range = int(code[0])
+
+                        status_major = res.status_code / 100
+
+                        if status_major >= code_range and status_major < code_range + 1:
+                            raise TemporaryError(res)
+                    else:
+                        parsed_code = int(code)
+
+                        if res.status_code == parsed_code:
+                            raise TemporaryError(res)
+            except httpx.ConnectError as exception:
+                if retries.config.retry_connection_errors:
+                    raise
+
+                raise PermanentError(exception) from exception
+            except httpx.TimeoutException as exception:
+                if retries.config.retry_connection_errors:
+                    raise
+
+                raise PermanentError(exception) from exception
+            except TemporaryError:
+                raise
+            except Exception as exception:
+                raise PermanentError(exception) from exception
+
+            return res
+
+        return retry_with_backoff(
+            do_request,
+            retries.config.backoff.initial_interval,
+            retries.config.backoff.max_interval,
+            retries.config.backoff.exponent,
+            retries.config.backoff.max_elapsed_time,
+        )
+
+    return func()
+
+
+async def retry_async(func, retries: Retries):
+    if retries.config.strategy == "backoff":
+
+        async def do_request() -> httpx.Response:
+            res: httpx.Response
+            try:
+                res = await func()
+
+                for code in retries.status_codes:
+                    if "X" in code.upper():
+                        code_range = int(code[0])
+
+                        status_major = res.status_code / 100
+
+                        if status_major >= code_range and status_major < code_range + 1:
+                            raise TemporaryError(res)
+                    else:
+                        parsed_code = int(code)
+
+                        if res.status_code == parsed_code:
+                            raise TemporaryError(res)
+            except httpx.ConnectError as exception:
+                if retries.config.retry_connection_errors:
+                    raise
+
+                raise PermanentError(exception) from exception
+            except httpx.TimeoutException as exception:
+                if retries.config.retry_connection_errors:
+                    raise
+
+                raise PermanentError(exception) from exception
+            except TemporaryError:
+                raise
+            except Exception as exception:
+                raise PermanentError(exception) from exception
+
+            return res
+
+        return await retry_with_backoff_async(
+            do_request,
+            retries.config.backoff.initial_interval,
+            retries.config.backoff.max_interval,
+            retries.config.backoff.exponent,
+            retries.config.backoff.max_elapsed_time,
+        )
+
+    return await func()
+
+
+def retry_with_backoff(
+    func,
+    initial_interval=500,
+    max_interval=60000,
+    exponent=1.5,
+    max_elapsed_time=3600000,
+):
+    start = round(time.time() * 1000)
+    retries = 0
+
+    while True:
+        try:
+            return func()
+        except PermanentError as exception:
+            raise exception.inner
+        except Exception as exception:  # pylint: disable=broad-exception-caught
+            now = round(time.time() * 1000)
+            if now - start > max_elapsed_time:
+                if isinstance(exception, TemporaryError):
+                    return exception.response
+
+                raise
+            sleep = (initial_interval / 1000) * exponent**retries + random.uniform(0, 1)
+            sleep = min(sleep, max_interval / 1000)
+            time.sleep(sleep)
+            retries += 1
+
+
+async def retry_with_backoff_async(
+    func,
+    initial_interval=500,
+    max_interval=60000,
+    exponent=1.5,
+    max_elapsed_time=3600000,
+):
+    start = round(time.time() * 1000)
+    retries = 0
+
+    while True:
+        try:
+            return await func()
+        except PermanentError as exception:
+            raise exception.inner
+        except Exception as exception:  # pylint: disable=broad-exception-caught
+            now = round(time.time() * 1000)
+            if now - start > max_elapsed_time:
+                if isinstance(exception, TemporaryError):
+                    return exception.response
+
+                raise
+            sleep = (initial_interval / 1000) * exponent**retries + random.uniform(0, 1)
+            sleep = min(sleep, max_interval / 1000)
+            time.sleep(sleep)
+            retries += 1

mistralai_azure/utils/security.py

@@ -0,0 +1,168 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+import base64
+from typing import (
+    Any,
+    Dict,
+    List,
+    Tuple,
+)
+from pydantic import BaseModel
+from pydantic.fields import FieldInfo
+
+from .metadata import (
+    SecurityMetadata,
+    find_field_metadata,
+)
+
+
+
+def get_security(security: Any) -> Tuple[Dict[str, str], Dict[str, List[str]]]:
+    headers: Dict[str, str] = {}
+    query_params: Dict[str, List[str]] = {}
+
+    if security is None:
+        return headers, query_params
+
+    if not isinstance(security, BaseModel):
+        raise TypeError("security must be a pydantic model")
+
+    sec_fields: Dict[str, FieldInfo] = security.__class__.model_fields
+    for name in sec_fields:
+        sec_field = sec_fields[name]
+
+        value = getattr(security, name)
+        if value is None:
+            continue
+
+        metadata = find_field_metadata(sec_field, SecurityMetadata)
+        if metadata is None:
+            continue
+        if metadata.option:
+            _parse_security_option(headers, query_params, value)
+            return headers, query_params
+        if metadata.scheme:
+            # Special case for basic auth which could be a flattened model
+            if metadata.sub_type == "basic" and not isinstance(value, BaseModel):
+                _parse_security_scheme(headers, query_params, metadata, name, security)
+            else:
+                _parse_security_scheme(headers, query_params, metadata, name, value)
+
+    return headers, query_params
+
+
+def _parse_security_option(
+    headers: Dict[str, str], query_params: Dict[str, List[str]], option: Any
+):
+    if not isinstance(option, BaseModel):
+        raise TypeError("security option must be a pydantic model")
+
+    opt_fields: Dict[str, FieldInfo] = option.__class__.model_fields
+    for name in opt_fields:
+        opt_field = opt_fields[name]
+
+        metadata = find_field_metadata(opt_field, SecurityMetadata)
+        if metadata is None or not metadata.scheme:
+            continue
+        _parse_security_scheme(
+            headers, query_params, metadata, name, getattr(option, name)
+        )
+
+
+def _parse_security_scheme(
+    headers: Dict[str, str],
+    query_params: Dict[str, List[str]],
+    scheme_metadata: SecurityMetadata,
+    field_name: str,
+    scheme: Any,
+):
+    scheme_type = scheme_metadata.scheme_type
+    sub_type = scheme_metadata.sub_type
+
+    if isinstance(scheme, BaseModel):
+        if scheme_type == "http" and sub_type == "basic":
+            _parse_basic_auth_scheme(headers, scheme)
+            return
+
+        scheme_fields: Dict[str, FieldInfo] = scheme.__class__.model_fields
+        for name in scheme_fields:
+            scheme_field = scheme_fields[name]
+
+            metadata = find_field_metadata(scheme_field, SecurityMetadata)
+            if metadata is None or metadata.field_name is None:
+                continue
+
+            value = getattr(scheme, name)
+
+            _parse_security_scheme_value(
+                headers, query_params, scheme_metadata, metadata, name, value
+            )
+    else:
+        _parse_security_scheme_value(
+            headers, query_params, scheme_metadata, scheme_metadata, field_name, scheme
+        )
+
+
+def _parse_security_scheme_value(
+    headers: Dict[str, str],
+    query_params: Dict[str, List[str]],
+    scheme_metadata: SecurityMetadata,
+    security_metadata: SecurityMetadata,
+    field_name: str,
+    value: Any,
+):
+    scheme_type = scheme_metadata.scheme_type
+    sub_type = scheme_metadata.sub_type
+
+    header_name = security_metadata.get_field_name(field_name)
+
+    if scheme_type == "apiKey":
+        if sub_type == "header":
+            headers[header_name] = value
+        elif sub_type == "query":
+            query_params[header_name] = [value]
+        else:
+            raise ValueError("sub type {sub_type} not supported")
+    elif scheme_type == "openIdConnect":
+        headers[header_name] = _apply_bearer(value)
+    elif scheme_type == "oauth2":
+        if sub_type != "client_credentials":
+            headers[header_name] = _apply_bearer(value)
+    elif scheme_type == "http":
+        if sub_type == "bearer":
+            headers[header_name] = _apply_bearer(value)
+        else:
+            raise ValueError("sub type {sub_type} not supported")
+    else:
+        raise ValueError("scheme type {scheme_type} not supported")
+
+
+def _apply_bearer(token: str) -> str:
+    return token.lower().startswith("bearer ") and token or f"Bearer {token}"
+
+
+def _parse_basic_auth_scheme(headers: Dict[str, str], scheme: Any):
+    username = ""
+    password = ""
+
+    if not isinstance(scheme, BaseModel):
+        raise TypeError("basic auth scheme must be a pydantic model")
+
+    scheme_fields: Dict[str, FieldInfo] = scheme.__class__.model_fields
+    for name in scheme_fields:
+        scheme_field = scheme_fields[name]
+
+        metadata = find_field_metadata(scheme_field, SecurityMetadata)
+        if metadata is None or metadata.field_name is None:
+            continue
+
+        field_name = metadata.field_name
+        value = getattr(scheme, name)
+
+        if field_name == "username":
+            username = value
+        if field_name == "password":
+            password = value
+
+    data = f"{username}:{password}".encode()
+    headers["Authorization"] = f"Basic {base64.b64encode(data).decode()}"

mistralai_azure/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