moovio_sdk 0.3.8__py3-none-any.whl

moovio_sdk/utils/__init__.py

@@ -0,0 +1,101 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from .annotations import get_discriminator
+from .enums import OpenEnumMeta
+from .headers import get_headers, get_response_headers
+from .metadata import (
+    FieldMetadata,
+    find_metadata,
+    FormMetadata,
+    HeaderMetadata,
+    MultipartFormMetadata,
+    PathParamMetadata,
+    QueryParamMetadata,
+    RequestMetadata,
+    SecurityMetadata,
+)
+from .queryparams import get_query_params
+from .retries import BackoffStrategy, Retries, retry, retry_async, RetryConfig
+from .requestbodies import serialize_request_body, SerializedRequestBody
+from .security import get_security, get_security_from_env
+
+from .serializers import (
+    get_pydantic_model,
+    marshal_json,
+    unmarshal,
+    unmarshal_json,
+    serialize_decimal,
+    serialize_float,
+    serialize_int,
+    stream_to_text,
+    stream_to_text_async,
+    stream_to_bytes,
+    stream_to_bytes_async,
+    validate_const,
+    validate_decimal,
+    validate_float,
+    validate_int,
+    validate_open_enum,
+)
+from .url import generate_url, template_url, remove_suffix
+from .values import (
+    get_global_from_env,
+    match_content_type,
+    match_status_codes,
+    match_response,
+    cast_partial,
+)
+from .logger import Logger, get_body_content, get_default_logger
+
+__all__ = [
+    "BackoffStrategy",
+    "FieldMetadata",
+    "find_metadata",
+    "FormMetadata",
+    "generate_url",
+    "get_body_content",
+    "get_default_logger",
+    "get_discriminator",
+    "get_global_from_env",
+    "get_headers",
+    "get_pydantic_model",
+    "get_query_params",
+    "get_response_headers",
+    "get_security",
+    "get_security_from_env",
+    "HeaderMetadata",
+    "Logger",
+    "marshal_json",
+    "match_content_type",
+    "match_status_codes",
+    "match_response",
+    "MultipartFormMetadata",
+    "OpenEnumMeta",
+    "PathParamMetadata",
+    "QueryParamMetadata",
+    "remove_suffix",
+    "Retries",
+    "retry",
+    "retry_async",
+    "RetryConfig",
+    "RequestMetadata",
+    "SecurityMetadata",
+    "serialize_decimal",
+    "serialize_float",
+    "serialize_int",
+    "serialize_request_body",
+    "SerializedRequestBody",
+    "stream_to_text",
+    "stream_to_text_async",
+    "stream_to_bytes",
+    "stream_to_bytes_async",
+    "template_url",
+    "unmarshal",
+    "unmarshal_json",
+    "validate_decimal",
+    "validate_const",
+    "validate_float",
+    "validate_int",
+    "validate_open_enum",
+    "cast_partial",
+]

moovio_sdk/utils/annotations.py

@@ -0,0 +1,55 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from enum import Enum
+from typing import Any, Optional
+
+def get_discriminator(model: Any, fieldname: str, key: str) -> str:
+    """
+    Recursively search for the discriminator attribute in a model.
+
+    Args:
+        model (Any): The model to search within.
+        fieldname (str): The name of the field to search for.
+        key (str): The key to search for in dictionaries.
+
+    Returns:
+        str: The name of the discriminator attribute.
+
+    Raises:
+        ValueError: If the discriminator attribute is not found.
+    """
+    upper_fieldname = fieldname.upper()
+
+    def get_field_discriminator(field: Any) -> Optional[str]:
+        """Search for the discriminator attribute in a given field."""
+
+        if isinstance(field, dict):
+            if key in field:
+                return f'{field[key]}'
+
+        if hasattr(field, fieldname):
+            attr = getattr(field, fieldname)
+            if isinstance(attr, Enum):
+                return f'{attr.value}'
+            return f'{attr}'
+
+        if hasattr(field, upper_fieldname):
+            attr = getattr(field, upper_fieldname)
+            if isinstance(attr, Enum):
+                return f'{attr.value}'
+            return f'{attr}'
+
+        return None
+
+
+    if isinstance(model, list):
+        for field in model:
+            discriminator = get_field_discriminator(field)
+            if discriminator is not None:
+                return discriminator
+
+    discriminator = get_field_discriminator(model)
+    if discriminator is not None:
+        return discriminator
+
+    raise ValueError(f'Could not find discriminator field {fieldname} in {model}')

moovio_sdk/utils/enums.py

@@ -0,0 +1,34 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+import enum
+
+
+class OpenEnumMeta(enum.EnumMeta):
+    def __call__(
+        cls, value, names=None, *, module=None, qualname=None, type=None, start=1
+    ):
+        # The `type` kwarg also happens to be a built-in that pylint flags as
+        # redeclared. Safe to ignore this lint rule with this scope.
+        # pylint: disable=redefined-builtin
+
+        if names is not None:
+            return super().__call__(
+                value,
+                names=names,
+                module=module,
+                qualname=qualname,
+                type=type,
+                start=start,
+            )
+
+        try:
+            return super().__call__(
+                value,
+                names=names,  # pyright: ignore[reportArgumentType]
+                module=module,
+                qualname=qualname,
+                type=type,
+                start=start,
+            )
+        except ValueError:
+            return value

moovio_sdk/utils/eventstreaming.py

@@ -0,0 +1,238 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+import re
+import json
+from typing import (
+    Callable,
+    Generic,
+    TypeVar,
+    Optional,
+    Generator,
+    AsyncGenerator,
+    Tuple,
+)
+import httpx
+
+T = TypeVar("T")
+
+
+class EventStream(Generic[T]):
+    response: httpx.Response
+    generator: Generator[T, None, None]
+
+    def __init__(
+        self,
+        response: httpx.Response,
+        decoder: Callable[[str], T],
+        sentinel: Optional[str] = None,
+    ):
+        self.response = response
+        self.generator = stream_events(response, decoder, sentinel)
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        return next(self.generator)
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.response.close()
+
+
+class EventStreamAsync(Generic[T]):
+    response: httpx.Response
+    generator: AsyncGenerator[T, None]
+
+    def __init__(
+        self,
+        response: httpx.Response,
+        decoder: Callable[[str], T],
+        sentinel: Optional[str] = None,
+    ):
+        self.response = response
+        self.generator = stream_events_async(response, decoder, sentinel)
+
+    def __aiter__(self):
+        return self
+
+    async def __anext__(self):
+        return await self.generator.__anext__()
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.response.aclose()
+
+
+class ServerEvent:
+    id: Optional[str] = None
+    event: Optional[str] = None
+    data: Optional[str] = None
+    retry: Optional[int] = None
+
+
+MESSAGE_BOUNDARIES = [
+    b"\r\n\r\n",
+    b"\n\n",
+    b"\r\r",
+]
+
+
+async def stream_events_async(
+    response: httpx.Response,
+    decoder: Callable[[str], T],
+    sentinel: Optional[str] = None,
+) -> AsyncGenerator[T, None]:
+    buffer = bytearray()
+    position = 0
+    discard = False
+    async for chunk in response.aiter_bytes():
+        # We've encountered the sentinel value and should no longer process
+        # incoming data. Instead we throw new data away until the server closes
+        # the connection.
+        if discard:
+            continue
+
+        buffer += chunk
+        for i in range(position, len(buffer)):
+            char = buffer[i : i + 1]
+            seq: Optional[bytes] = None
+            if char in [b"\r", b"\n"]:
+                for boundary in MESSAGE_BOUNDARIES:
+                    seq = _peek_sequence(i, buffer, boundary)
+                    if seq is not None:
+                        break
+            if seq is None:
+                continue
+
+            block = buffer[position:i]
+            position = i + len(seq)
+            event, discard = _parse_event(block, decoder, sentinel)
+            if event is not None:
+                yield event
+
+        if position > 0:
+            buffer = buffer[position:]
+            position = 0
+
+    event, discard = _parse_event(buffer, decoder, sentinel)
+    if event is not None:
+        yield event
+
+
+def stream_events(
+    response: httpx.Response,
+    decoder: Callable[[str], T],
+    sentinel: Optional[str] = None,
+) -> Generator[T, None, None]:
+    buffer = bytearray()
+    position = 0
+    discard = False
+    for chunk in response.iter_bytes():
+        # We've encountered the sentinel value and should no longer process
+        # incoming data. Instead we throw new data away until the server closes
+        # the connection.
+        if discard:
+            continue
+
+        buffer += chunk
+        for i in range(position, len(buffer)):
+            char = buffer[i : i + 1]
+            seq: Optional[bytes] = None
+            if char in [b"\r", b"\n"]:
+                for boundary in MESSAGE_BOUNDARIES:
+                    seq = _peek_sequence(i, buffer, boundary)
+                    if seq is not None:
+                        break
+            if seq is None:
+                continue
+
+            block = buffer[position:i]
+            position = i + len(seq)
+            event, discard = _parse_event(block, decoder, sentinel)
+            if event is not None:
+                yield event
+
+        if position > 0:
+            buffer = buffer[position:]
+            position = 0
+
+    event, discard = _parse_event(buffer, decoder, sentinel)
+    if event is not None:
+        yield event
+
+
+def _parse_event(
+    raw: bytearray, decoder: Callable[[str], T], sentinel: Optional[str] = None
+) -> Tuple[Optional[T], bool]:
+    block = raw.decode()
+    lines = re.split(r"\r?\n|\r", block)
+    publish = False
+    event = ServerEvent()
+    data = ""
+    for line in lines:
+        if not line:
+            continue
+
+        delim = line.find(":")
+        if delim <= 0:
+            continue
+
+        field = line[0:delim]
+        value = line[delim + 1 :] if delim < len(line) - 1 else ""
+        if len(value) and value[0] == " ":
+            value = value[1:]
+
+        if field == "event":
+            event.event = value
+            publish = True
+        elif field == "data":
+            data += value + "\n"
+            publish = True
+        elif field == "id":
+            event.id = value
+            publish = True
+        elif field == "retry":
+            event.retry = int(value) if value.isdigit() else None
+            publish = True
+
+    if sentinel and data == f"{sentinel}\n":
+        return None, True
+
+    if data:
+        data = data[:-1]
+        event.data = data
+
+        data_is_primitive = (
+            data.isnumeric() or data == "true" or data == "false" or data == "null"
+        )
+        data_is_json = (
+            data.startswith("{") or data.startswith("[") or data.startswith('"')
+        )
+
+        if data_is_primitive or data_is_json:
+            try:
+                event.data = json.loads(data)
+            except Exception:
+                pass
+
+    out = None
+    if publish:
+        out = decoder(json.dumps(event.__dict__))
+
+    return out, False
+
+
+def _peek_sequence(position: int, buffer: bytearray, sequence: bytes):
+    if len(sequence) > (len(buffer) - position):
+        return None
+
+    for i, seq in enumerate(sequence):
+        if buffer[position + i] != seq:
+            return None
+
+    return sequence

moovio_sdk/utils/forms.py

@@ -0,0 +1,202 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from typing import (
+    Any,
+    Dict,
+    get_type_hints,
+    List,
+    Tuple,
+)
+from pydantic import BaseModel
+from pydantic.fields import FieldInfo
+
+from .serializers import marshal_json
+
+from .metadata import (
+    FormMetadata,
+    MultipartFormMetadata,
+    find_field_metadata,
+)
+from .values import _is_set, _val_to_string
+
+
+def _populate_form(
+    field_name: str,
+    explode: bool,
+    obj: Any,
+    delimiter: str,
+    form: Dict[str, List[str]],
+):
+    if not _is_set(obj):
+        return form
+
+    if isinstance(obj, BaseModel):
+        items = []
+
+        obj_fields: Dict[str, FieldInfo] = obj.__class__.model_fields
+        for name in obj_fields:
+            obj_field = obj_fields[name]
+            obj_field_name = obj_field.alias if obj_field.alias is not None else name
+            if obj_field_name == "":
+                continue
+
+            val = getattr(obj, name)
+            if not _is_set(val):
+                continue
+
+            if explode:
+                form[obj_field_name] = [_val_to_string(val)]
+            else:
+                items.append(f"{obj_field_name}{delimiter}{_val_to_string(val)}")
+
+        if len(items) > 0:
+            form[field_name] = [delimiter.join(items)]
+    elif isinstance(obj, Dict):
+        items = []
+        for key, value in obj.items():
+            if not _is_set(value):
+                continue
+
+            if explode:
+                form[key] = [_val_to_string(value)]
+            else:
+                items.append(f"{key}{delimiter}{_val_to_string(value)}")
+
+        if len(items) > 0:
+            form[field_name] = [delimiter.join(items)]
+    elif isinstance(obj, List):
+        items = []
+
+        for value in obj:
+            if not _is_set(value):
+                continue
+
+            if explode:
+                if not field_name in form:
+                    form[field_name] = []
+                form[field_name].append(_val_to_string(value))
+            else:
+                items.append(_val_to_string(value))
+
+        if len(items) > 0:
+            form[field_name] = [delimiter.join([str(item) for item in items])]
+    else:
+        form[field_name] = [_val_to_string(obj)]
+
+    return form
+
+
+def serialize_multipart_form(
+    media_type: str, request: Any
+) -> Tuple[str, Dict[str, Any], Dict[str, Any]]:
+    form: Dict[str, Any] = {}
+    files: Dict[str, Any] = {}
+
+    if not isinstance(request, BaseModel):
+        raise TypeError("invalid request body type")
+
+    request_fields: Dict[str, FieldInfo] = request.__class__.model_fields
+    request_field_types = get_type_hints(request.__class__)
+
+    for name in request_fields:
+        field = request_fields[name]
+
+        val = getattr(request, name)
+        if not _is_set(val):
+            continue
+
+        field_metadata = find_field_metadata(field, MultipartFormMetadata)
+        if not field_metadata:
+            continue
+
+        f_name = field.alias if field.alias else name
+
+        if field_metadata.file:
+            file_fields: Dict[str, FieldInfo] = val.__class__.model_fields
+
+            file_name = ""
+            content = None
+            content_type = None
+
+            for file_field_name in file_fields:
+                file_field = file_fields[file_field_name]
+
+                file_metadata = find_field_metadata(file_field, MultipartFormMetadata)
+                if file_metadata is None:
+                    continue
+
+                if file_metadata.content:
+                    content = getattr(val, file_field_name, None)
+                elif file_field_name == "content_type":
+                    content_type = getattr(val, file_field_name, None)
+                else:
+                    file_name = getattr(val, file_field_name)
+
+            if file_name == "" or content is None:
+                raise ValueError("invalid multipart/form-data file")
+
+            if content_type is not None:
+                files[f_name] = (file_name, content, content_type)
+            else:
+                files[f_name] = (file_name, content)
+        elif field_metadata.json:
+            files[f_name] = (
+                None,
+                marshal_json(val, request_field_types[name]),
+                "application/json",
+            )
+        else:
+            if isinstance(val, List):
+                values = []
+
+                for value in val:
+                    if not _is_set(value):
+                        continue
+                    values.append(_val_to_string(value))
+
+                form[f_name + "[]"] = values
+            else:
+                form[f_name] = _val_to_string(val)
+    return media_type, form, files
+
+
+def serialize_form_data(data: Any) -> Dict[str, Any]:
+    form: Dict[str, List[str]] = {}
+
+    if isinstance(data, BaseModel):
+        data_fields: Dict[str, FieldInfo] = data.__class__.model_fields
+        data_field_types = get_type_hints(data.__class__)
+        for name in data_fields:
+            field = data_fields[name]
+
+            val = getattr(data, name)
+            if not _is_set(val):
+                continue
+
+            metadata = find_field_metadata(field, FormMetadata)
+            if metadata is None:
+                continue
+
+            f_name = field.alias if field.alias is not None else name
+
+            if metadata.json:
+                form[f_name] = [marshal_json(val, data_field_types[name])]
+            else:
+                if metadata.style == "form":
+                    _populate_form(
+                        f_name,
+                        metadata.explode,
+                        val,
+                        ",",
+                        form,
+                    )
+                else:
+                    raise ValueError(f"Invalid form style for field {name}")
+    elif isinstance(data, Dict):
+        for key, value in data.items():
+            if _is_set(value):
+                form[key] = [_val_to_string(value)]
+    else:
+        raise TypeError(f"Invalid request body type {type(data)} for form data")
+
+    return form