render 1.0.1__py3-none-any.whl

render/public_api/models/zero_downtime_redeploy_ended.py

@@ -0,0 +1,44 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="ZeroDowntimeRedeployEnded")
+
+
+@_attrs_define
+class ZeroDowntimeRedeployEnded:
+    """ """
+
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        zero_downtime_redeploy_ended = cls()
+
+        zero_downtime_redeploy_ended.additional_properties = d
+        return zero_downtime_redeploy_ended
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

render/public_api/models/zero_downtime_redeploy_started.py

@@ -0,0 +1,59 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="ZeroDowntimeRedeployStarted")
+
+
+@_attrs_define
+class ZeroDowntimeRedeployStarted:
+    """
+    Attributes:
+        trigger (str):
+    """
+
+    trigger: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        trigger = self.trigger
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "trigger": trigger,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        trigger = d.pop("trigger")
+
+        zero_downtime_redeploy_started = cls(
+            trigger=trigger,
+        )
+
+        zero_downtime_redeploy_started.additional_properties = d
+        return zero_downtime_redeploy_started
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

render/public_api/py.typed

@@ -0,0 +1 @@
+# Marker file for PEP 561

render/public_api/types.py

@@ -0,0 +1,54 @@
+"""Contains some shared types for properties"""
+
+from collections.abc import Mapping, MutableMapping
+from http import HTTPStatus
+from typing import IO, BinaryIO, Generic, Literal, Optional, TypeVar, Union
+
+from attrs import define
+
+
+class Unset:
+    def __bool__(self) -> Literal[False]:
+        return False
+
+
+UNSET: Unset = Unset()
+
+# The types that `httpx.Client(files=)` can accept, copied from that library.
+FileContent = Union[IO[bytes], bytes, str]
+FileTypes = Union[
+    # (filename, file (or bytes), content_type)
+    tuple[Optional[str], FileContent, Optional[str]],
+    # (filename, file (or bytes), content_type, headers)
+    tuple[Optional[str], FileContent, Optional[str], Mapping[str, str]],
+]
+RequestFiles = list[tuple[str, FileTypes]]
+
+
+@define
+class File:
+    """Contains information for file uploads"""
+
+    payload: BinaryIO
+    file_name: Optional[str] = None
+    mime_type: Optional[str] = None
+
+    def to_tuple(self) -> FileTypes:
+        """Return a tuple representation that httpx will accept for multipart/form-data"""
+        return self.file_name, self.payload, self.mime_type
+
+
+T = TypeVar("T")
+
+
+@define
+class Response(Generic[T]):
+    """A response from an endpoint"""
+
+    status_code: HTTPStatus
+    content: bytes
+    headers: MutableMapping[str, str]
+    parsed: Optional[T]
+
+
+__all__ = ["UNSET", "File", "FileTypes", "RequestFiles", "Response", "Unset"]

render/render.py

@@ -0,0 +1,81 @@
+"""Unified REST API client for Render services."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from render.client import Client
+    from render.client.workflows_sync import SyncWorkflowsService
+    from render.experimental.experimental_sync import SyncExperimentalService
+
+
+class Render:
+    """
+    Unified REST API client for all Render services.
+
+    This is the primary entry point for interacting with Render's APIs
+    from synchronous code (Flask, Django, scripts, etc.).
+
+    For async/await support, use the ``RenderAsync`` class instead.
+
+    Example:
+        render = Render()  # Uses RENDER_API_KEY from environment
+
+        # Run a task and wait for the result
+        result = render.workflows.run_task("my-workflow/my_task", [42])
+
+        # Or start a task for fire-and-forget / deferred polling
+        task_run = render.workflows.start_task("my-workflow/my_task", [5])
+        # Later: result = render.workflows.get_task_run(task_run.id)
+    """
+
+    _client: Client
+
+    def __init__(
+        self,
+        *,
+        token: str | None = None,
+        base_url: str = "https://api.render.com",
+        owner_id: str | None = None,
+        region: str | None = None,
+    ) -> None:
+        """
+        Initialize the Render SDK.
+
+        Args:
+            token: API token. If not provided, uses RENDER_API_KEY env var.
+            base_url: API base URL (rarely needed).
+            owner_id: Default owner ID for object storage. If not provided,
+                     uses RENDER_WORKSPACE_ID env var.
+            region: Default region for object storage. If not provided,
+                   uses RENDER_REGION env var.
+        """
+        from render.client import Client
+        from render.client.workflows_sync import SyncWorkflowsService
+        from render.experimental.experimental_sync import SyncExperimentalService
+
+        self._client = Client(
+            token=token, base_url=base_url, owner_id=owner_id, region=region
+        )
+        self._workflows = SyncWorkflowsService(self._client)
+        self._experimental = SyncExperimentalService(self._client)
+
+    @property
+    def client(self) -> Client:
+        """
+        Access to the underlying API client.
+
+        Use this for fine-grained control or advanced use cases.
+        """
+        return self._client
+
+    @property
+    def workflows(self) -> SyncWorkflowsService:
+        """REST API for workflow operations (run tasks, get status)."""
+        return self._workflows
+
+    @property
+    def experimental(self) -> SyncExperimentalService:
+        """Experimental APIs including object storage."""
+        return self._experimental

render/render_async.py

@@ -0,0 +1,80 @@
+"""Unified async REST API client for Render services."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from render.client import Client
+    from render.client.workflows import WorkflowsService
+    from render.experimental import ExperimentalService
+
+
+class RenderAsync:
+    """
+    Async unified REST API client for all Render services.
+
+    This is the async entry point for interacting with Render's APIs.
+    For synchronous code, use the ``Render`` class instead.
+
+    Example:
+        render = RenderAsync()  # Uses RENDER_API_KEY from environment
+
+        # Run a task
+        result = await render.workflows.run_task("my-workflow/my-task", [42])
+
+        # Direct client access for advanced use cases
+        render.client.workflows.run_task(...)
+    """
+
+    _client: Client
+
+    def __init__(
+        self,
+        *,
+        token: str | None = None,
+        base_url: str = "https://api.render.com",
+        owner_id: str | None = None,
+        region: str | None = None,
+    ) -> None:
+        """
+        Initialize the Render SDK.
+
+        Args:
+            token: API token. If not provided, uses RENDER_API_KEY env var.
+            base_url: API base URL (rarely needed).
+            owner_id: Default owner ID for object storage. If not provided,
+                     uses RENDER_WORKSPACE_ID env var.
+            region: Default region for object storage. If not provided,
+                   uses RENDER_REGION env var.
+        """
+        from render.client import Client
+
+        self._client = Client(
+            token=token, base_url=base_url, owner_id=owner_id, region=region
+        )
+
+    @property
+    def client(self) -> Client:
+        """
+        Access to the underlying API client.
+
+        Use this for fine-grained control or advanced use cases.
+
+        Example:
+            render = RenderAsync()
+
+            # Access client directly
+            render.client.workflows.run_task(...)
+        """
+        return self._client
+
+    @property
+    def workflows(self) -> WorkflowsService:
+        """REST API for workflow operations (run tasks, get status)."""
+        return self._client.workflows
+
+    @property
+    def experimental(self) -> ExperimentalService:
+        """Experimental APIs including object storage."""
+        return self._client.experimental

render/version.py

@@ -0,0 +1,27 @@
+"""Version information for the Render SDK."""
+
+import importlib.metadata
+import platform
+
+
+def get_version() -> str:
+    """Get the SDK version from package metadata."""
+    try:
+        return importlib.metadata.version("render")
+    except importlib.metadata.PackageNotFoundError:
+        return "unknown"
+
+
+def get_user_agent() -> str:
+    """Get the User-Agent string for the SDK.
+
+    Returns a string like:
+        render-sdk-python/0.1.3 (cpython/3.11.4; darwin/arm64)
+    """
+    version = get_version()
+    impl = platform.python_implementation().lower()
+    py_version = platform.python_version()
+    os_name = platform.system().lower()
+    arch = platform.machine().lower()
+
+    return f"render-sdk-python/{version} ({impl}/{py_version}; {os_name}/{arch})"

render/workflows/__init__.py

@@ -0,0 +1,25 @@
+"""Render SDK - Durable Workflows Task Definition"""
+
+from render.workflows.app import Workflows
+from render.workflows.context import TaskContext, WorkflowTaskContext
+from render.workflows.runner import start
+from render.workflows.task import (
+    Options,
+    Retry,
+    TaskDefinition,
+    TaskRegistry,
+    task,
+)
+
+__all__ = [
+    "Options",
+    "Retry",
+    "TaskContext",
+    "TaskDefinition",
+    "TaskRegistry",
+    "WorkflowTaskContext",
+    "Workflows",
+    # Deprecated: use Workflows.task and Workflows.start() instead
+    "start",
+    "task",
+]

render/workflows/_callback_models.py

@@ -0,0 +1,194 @@
+"""Data models for the workflow callback API.
+
+Only the fields the runner actually exchanges with the SDK server are
+modelled here. Serialization is handled by the generic :func:`_wire`
+helper and the :class:`_Wire` mixin, so each model is just a dataclass
+declaration with no per-class ``to_dict`` body. ``from_dict`` is
+explicit on the three classes the runner parses off the wire.
+
+The module depends only on the standard library so it can sit on the
+worker hot path — defining or running a task does not pull in
+``httpx`` or ``attrs``.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field, fields, is_dataclass
+from typing import Any, cast
+
+
+class _Unset:
+    """Sentinel for fields that were not provided on the wire.
+
+    Mirrors the auto-generated ``Unset`` so callers can keep doing
+    ``isinstance(value, Unset)`` checks. A single shared instance is used
+    so identity comparisons (``is UNSET``) also work.
+    """
+
+    _instance: _Unset | None = None
+
+    def __new__(cls) -> _Unset:
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def __bool__(self) -> bool:
+        return False
+
+    def __repr__(self) -> str:
+        return "UNSET"
+
+
+Unset = _Unset
+UNSET: _Unset = _Unset()
+
+
+def _wire(obj: Any) -> Any:
+    """Recursively convert a dataclass tree to wire-format dicts.
+
+    Fields whose value is ``UNSET`` are dropped, matching the
+    auto-generated ``to_dict`` behavior. Field names can be remapped for
+    the wire via ``field(metadata={"wire_name": "..."})`` — used so the
+    Python-keyword renames (``input_`` → ``input``, ``type_`` → ``type``)
+    stay correct in JSON output.
+    """
+    if is_dataclass(obj):
+        d: dict[str, Any] = {}
+        for f in fields(obj):
+            value = getattr(obj, f.name)
+            if isinstance(value, _Unset):
+                continue
+            d[f.metadata.get("wire_name", f.name)] = _wire(value)
+        return d
+    if isinstance(obj, list):
+        return [_wire(v) for v in obj]
+    return obj
+
+
+class _Wire:
+    """Mixin providing the generic ``to_dict`` for every wire model below."""
+
+    def to_dict(self) -> dict[str, Any]:
+        # `_wire` on a dataclass instance always returns a dict — the cast
+        # documents that invariant for the type checker without a runtime hit.
+        return cast("dict[str, Any]", _wire(self))
+
+
+@dataclass
+class InputResponse(_Wire):
+    task_name: str
+    input_: str = field(metadata={"wire_name": "input"})
+
+    @classmethod
+    def from_dict(cls, d: dict[str, Any]) -> InputResponse:
+        return cls(task_name=d["task_name"], input_=d.get("input", ""))
+
+
+@dataclass
+class TaskComplete(_Wire):
+    output: str
+
+    @classmethod
+    def from_dict(cls, d: dict[str, Any]) -> TaskComplete:
+        return cls(output=d["output"])
+
+
+@dataclass
+class TaskError(_Wire):
+    details: str
+    stack_trace: str | _Unset = UNSET
+
+    @classmethod
+    def from_dict(cls, d: dict[str, Any]) -> TaskError:
+        return cls(details=d["details"], stack_trace=d.get("stack_trace", UNSET))
+
+
+@dataclass
+class CallbackRequest(_Wire):
+    error: TaskError | _Unset = UNSET
+    complete: TaskComplete | _Unset = UNSET
+
+
+@dataclass
+class RunSubtaskRequest(_Wire):
+    task_name: str
+    input_: str | _Unset = field(default=UNSET, metadata={"wire_name": "input"})
+    # Deduplicates subtask creation across retries. Generated once per logical
+    # subtask call and resent on every retry, so the scheduler resolves a
+    # retried submission to the original subtask instead of creating a duplicate.
+    #
+    # This key should uniquely identify the task run within a workflow version.
+    # The SDK uses a UUID v4.
+    idempotency_key: str | _Unset = UNSET
+    # Caller-pinned creation time (RFC 3339). Must be stable across retries: the
+    # scheduler deduplicates on (idempotency_key, created_at).
+    created_at: str | _Unset = UNSET
+
+
+@dataclass
+class RunSubtaskResponse(_Wire):
+    task_run_id: str
+
+    @classmethod
+    def from_dict(cls, d: dict[str, Any]) -> RunSubtaskResponse:
+        return cls(task_run_id=d["task_run_id"])
+
+
+@dataclass
+class SubtaskResultRequest(_Wire):
+    task_run_id: str
+
+
+@dataclass
+class SubtaskResultResponse(_Wire):
+    still_running: bool
+    error: TaskError | _Unset = UNSET
+    complete: TaskComplete | _Unset = UNSET
+
+    @classmethod
+    def from_dict(cls, d: dict[str, Any]) -> SubtaskResultResponse:
+        error: TaskError | _Unset = UNSET
+        if d.get("error") is not None:
+            error = TaskError.from_dict(d["error"])
+        complete: TaskComplete | _Unset = UNSET
+        if d.get("complete") is not None:
+            complete = TaskComplete.from_dict(d["complete"])
+        return cls(
+            still_running=bool(d["still_running"]),
+            error=error,
+            complete=complete,
+        )
+
+
+@dataclass
+class RetryConfig(_Wire):
+    max_retries: int | _Unset = UNSET
+    wait_duration_ms: int | _Unset = UNSET
+    factor: float | _Unset = UNSET
+
+
+@dataclass
+class TaskOptions(_Wire):
+    retry: RetryConfig | _Unset = UNSET
+    timeout_seconds: int | _Unset = UNSET
+    plan: str | _Unset = UNSET
+
+
+@dataclass
+class TaskParameter(_Wire):
+    name: str
+    has_default: bool
+    type_: str | _Unset = field(default=UNSET, metadata={"wire_name": "type"})
+    default_value: str | _Unset = UNSET
+
+
+@dataclass
+class Task(_Wire):
+    name: str
+    options: TaskOptions | _Unset = UNSET
+    parameters: list[TaskParameter] | _Unset = UNSET
+
+
+@dataclass
+class Tasks(_Wire):
+    tasks: list[Task]

render/workflows/_uds_http.py

@@ -0,0 +1,128 @@
+"""Minimal HTTP/1.1 over Unix Domain Socket client.
+
+Built on :class:`http.client.HTTPConnection` so request construction,
+header formatting, Content-Length handling, and response parsing
+(including chunked, content-length, and connection-close framing) are
+all delegated to the standard library. The only custom piece is the
+UDS connector: a subclass that overrides ``connect()`` to dial an
+``AF_UNIX`` socket instead of TCP.
+
+``http.client`` is sync, so each request runs on the asyncio
+threadpool via :func:`asyncio.to_thread`. The thread context switch is
+in the microseconds — imperceptible next to the actual UDS round trip
+— and keeps the event loop free for the workflow runner.
+
+This module raises only stdlib exceptions and :class:`HttpStatusError`.
+Translation to ``render.client.errors`` types happens at the call
+site in ``client.py`` via the ``_translate_errors`` decorator, so the
+transport stays unaware of domain-level error vocabulary or operation
+labels.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import http.client
+import json
+import logging
+import socket
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+class HttpStatusError(Exception):
+    """Raised when an HTTP request completes with a 4xx or 5xx status.
+
+    Carries the status code and raw response body so the caller can
+    translate the failure into the appropriate domain-level error.
+    """
+
+    def __init__(self, status: int, body: bytes) -> None:
+        self.status = status
+        self.body = body
+        super().__init__(f"HTTP {status}")
+
+
+class _UnixHTTPConnection(http.client.HTTPConnection):
+    """HTTPConnection that dials a Unix Domain Socket instead of TCP."""
+
+    def __init__(self, socket_path: str, timeout: float) -> None:
+        super().__init__("localhost", timeout=timeout)
+        self._socket_path = socket_path
+
+    def connect(self) -> None:
+        sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        sock.settimeout(self.timeout)
+        sock.connect(self._socket_path)
+        self.sock = sock
+
+
+def _request_sync(
+    socket_path: str,
+    method: str,
+    path: str,
+    *,
+    body: bytes | None,
+    content_type: str | None,
+    user_agent: str,
+    timeout: float,
+) -> tuple[int, bytes]:
+    conn = _UnixHTTPConnection(socket_path, timeout)
+    try:
+        headers: dict[str, str] = {
+            "Connection": "close",
+            "User-Agent": user_agent,
+            "Accept": "application/json",
+        }
+        if content_type is not None:
+            headers["Content-Type"] = content_type
+        conn.request(method, path, body=body, headers=headers)
+        resp = conn.getresponse()
+        return resp.status, resp.read()
+    finally:
+        conn.close()
+
+
+async def request_json(
+    socket_path: str,
+    method: str,
+    path: str,
+    *,
+    body: dict[str, Any] | None,
+    user_agent: str,
+    timeout: float,
+) -> Any:
+    """Make a JSON HTTP request over UDS and return the parsed body.
+
+    Returns ``None`` if the response has an empty body. HTTP error
+    statuses (4xx, 5xx) raise :class:`HttpStatusError`; all other
+    transport failures propagate as their stdlib exception types
+    (``TimeoutError``, ``ConnectionError``, ``OSError``,
+    ``http.client.HTTPException``, ``json.JSONDecodeError``).
+    """
+    body_bytes: bytes | None = None
+    content_type: str | None = None
+    if body is not None:
+        body_bytes = json.dumps(body).encode("utf-8")
+        content_type = "application/json"
+
+    status_code, content = await asyncio.to_thread(
+        _request_sync,
+        socket_path,
+        method,
+        path,
+        body=body_bytes,
+        content_type=content_type,
+        user_agent=user_agent,
+        timeout=timeout,
+    )
+
+    if status_code >= 400:
+        raise HttpStatusError(status_code, content)
+
+    if not content:
+        return None
+    # JSONDecodeError intentionally propagates — the call-site decorator
+    # turns it into a typed RenderError with operation context.
+    return json.loads(content)