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

mistralai_gcp/utils/metadata.py

@@ -0,0 +1,118 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from typing import Optional, Type, TypeVar, Union
+from dataclasses import dataclass
+from pydantic.fields import FieldInfo
+
+
+T = TypeVar("T")
+
+
+@dataclass
+class SecurityMetadata:
+    option: bool = False
+    scheme: bool = False
+    scheme_type: Optional[str] = None
+    sub_type: Optional[str] = None
+    field_name: Optional[str] = None
+
+    def get_field_name(self, default: str) -> str:
+        return self.field_name or default
+
+
+@dataclass
+class ParamMetadata:
+    serialization: Optional[str] = None
+    style: str = "simple"
+    explode: bool = False
+
+
+@dataclass
+class PathParamMetadata(ParamMetadata):
+    pass
+
+
+@dataclass
+class QueryParamMetadata(ParamMetadata):
+    style: str = "form"
+    explode: bool = True
+
+
+@dataclass
+class HeaderMetadata(ParamMetadata):
+    pass
+
+
+@dataclass
+class RequestMetadata:
+    media_type: str = "application/octet-stream"
+
+
+@dataclass
+class MultipartFormMetadata:
+    file: bool = False
+    content: bool = False
+    json: bool = False
+
+
+@dataclass
+class FormMetadata:
+    json: bool = False
+    style: str = "form"
+    explode: bool = True
+
+
+class FieldMetadata:
+    security: Optional[SecurityMetadata] = None
+    path: Optional[PathParamMetadata] = None
+    query: Optional[QueryParamMetadata] = None
+    header: Optional[HeaderMetadata] = None
+    request: Optional[RequestMetadata] = None
+    form: Optional[FormMetadata] = None
+    multipart: Optional[MultipartFormMetadata] = None
+
+    def __init__(
+        self,
+        security: Optional[SecurityMetadata] = None,
+        path: Optional[Union[PathParamMetadata, bool]] = None,
+        query: Optional[Union[QueryParamMetadata, bool]] = None,
+        header: Optional[Union[HeaderMetadata, bool]] = None,
+        request: Optional[Union[RequestMetadata, bool]] = None,
+        form: Optional[Union[FormMetadata, bool]] = None,
+        multipart: Optional[Union[MultipartFormMetadata, bool]] = None,
+    ):
+        self.security = security
+        self.path = PathParamMetadata() if isinstance(path, bool) else path
+        self.query = QueryParamMetadata() if isinstance(query, bool) else query
+        self.header = HeaderMetadata() if isinstance(header, bool) else header
+        self.request = RequestMetadata() if isinstance(request, bool) else request
+        self.form = FormMetadata() if isinstance(form, bool) else form
+        self.multipart = (
+            MultipartFormMetadata() if isinstance(multipart, bool) else multipart
+        )
+
+
+def find_field_metadata(field_info: FieldInfo, metadata_type: Type[T]) -> Optional[T]:
+    metadata = find_metadata(field_info, FieldMetadata)
+    if not metadata:
+        return None
+
+    fields = metadata.__dict__
+
+    for field in fields:
+        if isinstance(fields[field], metadata_type):
+            return fields[field]
+
+    return None
+
+
+def find_metadata(field_info: FieldInfo, metadata_type: Type[T]) -> Optional[T]:
+    metadata = field_info.metadata
+    if not metadata:
+        return None
+
+    for md in metadata:
+        if isinstance(md, metadata_type):
+            return md
+
+    return None

mistralai_gcp/utils/queryparams.py

@@ -0,0 +1,203 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from typing import (
+    Any,
+    Dict,
+    get_type_hints,
+    List,
+    Optional,
+)
+
+from pydantic import BaseModel
+from pydantic.fields import FieldInfo
+
+from .metadata import (
+    QueryParamMetadata,
+    find_field_metadata,
+)
+from .values import _get_serialized_params, _populate_from_globals, _val_to_string
+from .forms import _populate_form
+
+
+def get_query_params(
+    query_params: Any,
+    gbls: Optional[Any] = None,
+) -> Dict[str, List[str]]:
+    params: Dict[str, List[str]] = {}
+
+    globals_already_populated = _populate_query_params(query_params, gbls, params, [])
+    if gbls is not None:
+        _populate_query_params(gbls, None, params, globals_already_populated)
+
+    return params
+
+
+def _populate_query_params(
+    query_params: Any,
+    gbls: Any,
+    query_param_values: Dict[str, List[str]],
+    skip_fields: List[str],
+) -> List[str]:
+    globals_already_populated: List[str] = []
+
+    if not isinstance(query_params, BaseModel):
+        return globals_already_populated
+
+    param_fields: Dict[str, FieldInfo] = query_params.__class__.model_fields
+    param_field_types = get_type_hints(query_params.__class__)
+    for name in param_fields:
+        if name in skip_fields:
+            continue
+
+        field = param_fields[name]
+
+        metadata = find_field_metadata(field, QueryParamMetadata)
+        if not metadata:
+            continue
+
+        value = getattr(query_params, name) if query_params is not None else None
+
+        value, global_found = _populate_from_globals(
+            name, value, QueryParamMetadata, gbls
+        )
+        if global_found:
+            globals_already_populated.append(name)
+
+        f_name = field.alias if field.alias is not None else name
+        serialization = metadata.serialization
+        if serialization is not None:
+            serialized_parms = _get_serialized_params(
+                metadata, f_name, value, param_field_types[name]
+            )
+            for key, value in serialized_parms.items():
+                if key in query_param_values:
+                    query_param_values[key].extend(value)
+                else:
+                    query_param_values[key] = [value]
+        else:
+            style = metadata.style
+            if style == "deepObject":
+                _populate_deep_object_query_params(f_name, value, query_param_values)
+            elif style == "form":
+                _populate_delimited_query_params(
+                    metadata, f_name, value, ",", query_param_values
+                )
+            elif style == "pipeDelimited":
+                _populate_delimited_query_params(
+                    metadata, f_name, value, "|", query_param_values
+                )
+            else:
+                raise NotImplementedError(
+                    f"query param style {style} not yet supported"
+                )
+
+    return globals_already_populated
+
+
+def _populate_deep_object_query_params(
+    field_name: str,
+    obj: Any,
+    params: Dict[str, List[str]],
+):
+    if obj is None:
+        return
+
+    if isinstance(obj, BaseModel):
+        _populate_deep_object_query_params_basemodel(field_name, obj, params)
+    elif isinstance(obj, Dict):
+        _populate_deep_object_query_params_dict(field_name, obj, params)
+
+
+def _populate_deep_object_query_params_basemodel(
+    prior_params_key: str,
+    obj: Any,
+    params: Dict[str, List[str]],
+):
+    if obj is None:
+        return
+
+    if not isinstance(obj, BaseModel):
+        return
+
+    obj_fields: Dict[str, FieldInfo] = obj.__class__.model_fields
+    for name in obj_fields:
+        obj_field = obj_fields[name]
+
+        f_name = obj_field.alias if obj_field.alias is not None else name
+
+        params_key = f"{prior_params_key}[{f_name}]"
+
+        obj_param_metadata = find_field_metadata(obj_field, QueryParamMetadata)
+        if obj_param_metadata is None:
+            continue
+
+        obj_val = getattr(obj, name)
+        if obj_val is None:
+            continue
+
+        if isinstance(obj_val, BaseModel):
+            _populate_deep_object_query_params_basemodel(params_key, obj_val, params)
+        elif isinstance(obj_val, Dict):
+            _populate_deep_object_query_params_dict(params_key, obj_val, params)
+        elif isinstance(obj_val, List):
+            _populate_deep_object_query_params_list(params_key, obj_val, params)
+        else:
+            params[params_key] = [_val_to_string(obj_val)]
+
+
+def _populate_deep_object_query_params_dict(
+    prior_params_key: str,
+    value: Dict,
+    params: Dict[str, List[str]],
+):
+    if value is None:
+        return
+
+    for key, val in value.items():
+        if val is None:
+            continue
+
+        params_key = f"{prior_params_key}[{key}]"
+
+        if isinstance(val, BaseModel):
+            _populate_deep_object_query_params_basemodel(params_key, val, params)
+        elif isinstance(val, Dict):
+            _populate_deep_object_query_params_dict(params_key, val, params)
+        elif isinstance(val, List):
+            _populate_deep_object_query_params_list(params_key, val, params)
+        else:
+            params[params_key] = [_val_to_string(val)]
+
+
+def _populate_deep_object_query_params_list(
+    params_key: str,
+    value: List,
+    params: Dict[str, List[str]],
+):
+    if value is None:
+        return
+
+    for val in value:
+        if val is None:
+            continue
+
+        if params.get(params_key) is None:
+            params[params_key] = []
+
+        params[params_key].append(_val_to_string(val))
+
+
+def _populate_delimited_query_params(
+    metadata: QueryParamMetadata,
+    field_name: str,
+    obj: Any,
+    delimiter: str,
+    query_param_values: Dict[str, List[str]],
+):
+    _populate_form(
+        field_name,
+        metadata.explode,
+        obj,
+        delimiter,
+        query_param_values,
+    )

mistralai_gcp/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_gcp/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