latitudesh-python-sdk 2.3.0__py3-none-any.whl

latitudesh_python_sdk/utils/queryparams.py

@@ -0,0 +1,217 @@
+"""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,
+    _is_set,
+    _populate_from_globals,
+    _val_to_string,
+)
+from .forms import _populate_form
+
+
+def get_query_params(
+    query_params: Any,
+    gbls: Optional[Any] = None,
+    allow_empty_value: Optional[List[str]] = None,
+) -> Dict[str, List[str]]:
+    params: Dict[str, List[str]] = {}
+
+    globals_already_populated = _populate_query_params(query_params, gbls, params, [], allow_empty_value)
+    if _is_set(gbls):
+        _populate_query_params(gbls, None, params, globals_already_populated, allow_empty_value)
+
+    return params
+
+
+def _populate_query_params(
+    query_params: Any,
+    gbls: Any,
+    query_param_values: Dict[str, List[str]],
+    skip_fields: List[str],
+    allow_empty_value: Optional[List[str]] = None,
+) -> 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 _is_set(query_params) 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
+
+        allow_empty_set = set(allow_empty_value or [])
+        should_include_empty = f_name in allow_empty_set and (
+            value is None or value == [] or value == ""
+        )
+
+        if should_include_empty:
+            query_param_values[f_name] = [""]
+            continue
+
+        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 not _is_set(obj):
+        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 not _is_set(obj) or 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 not _is_set(obj_param_metadata):
+            continue
+
+        obj_val = getattr(obj, name)
+        if not _is_set(obj_val):
+            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 not _is_set(value):
+        return
+
+    for key, val in value.items():
+        if not _is_set(val):
+            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 not _is_set(value):
+        return
+
+    for val in value:
+        if not _is_set(val):
+            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,
+    )

latitudesh_python_sdk/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: Optional[str] = None
+    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

latitudesh_python_sdk/utils/retries.py

@@ -0,0 +1,281 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+import asyncio
+import random
+import time
+from datetime import datetime
+from email.utils import parsedate_to_datetime
+from typing import List, Optional
+
+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
+    retry_after: Optional[int]
+
+    def __init__(self, response: httpx.Response):
+        self.response = response
+        self.retry_after = _parse_retry_after_header(response)
+
+
+class PermanentError(Exception):
+    inner: Exception
+
+    def __init__(self, inner: Exception):
+        self.inner = inner
+
+
+def _parse_retry_after_header(response: httpx.Response) -> Optional[int]:
+    """Parse Retry-After header from response.
+
+    Returns:
+        Retry interval in milliseconds, or None if header is missing or invalid.
+    """
+    retry_after_header = response.headers.get("retry-after")
+    if not retry_after_header:
+        return None
+
+    try:
+        seconds = float(retry_after_header)
+        return round(seconds * 1000)
+    except ValueError:
+        pass
+
+    try:
+        retry_date = parsedate_to_datetime(retry_after_header)
+        delta = (retry_date - datetime.now(retry_date.tzinfo)).total_seconds()
+        return round(max(0, delta) * 1000)
+    except (ValueError, TypeError):
+        pass
+
+    return None
+
+
+def _get_sleep_interval(
+    exception: Exception,
+    initial_interval: int,
+    max_interval: int,
+    exponent: float,
+    retries: int,
+) -> float:
+    """Get sleep interval for retry with exponential backoff.
+
+    Args:
+        exception: The exception that triggered the retry.
+        initial_interval: Initial retry interval in milliseconds.
+        max_interval: Maximum retry interval in milliseconds.
+        exponent: Base for exponential backoff calculation.
+        retries: Current retry attempt count.
+
+    Returns:
+        Sleep interval in seconds.
+    """
+    if (
+        isinstance(exception, TemporaryError)
+        and exception.retry_after is not None
+        and exception.retry_after > 0
+    ):
+        return exception.retry_after / 1000
+
+    sleep = (initial_interval / 1000) * exponent**retries + random.uniform(0, 1)
+    return min(sleep, max_interval / 1000)
+
+
+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 code_range <= 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 code_range <= 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 = _get_sleep_interval(
+                exception, initial_interval, max_interval, exponent, retries
+            )
+            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 = _get_sleep_interval(
+                exception, initial_interval, max_interval, exponent, retries
+            )
+            await asyncio.sleep(sleep)
+            retries += 1