render_sdk 0.1.2__py3-none-any.whl → 0.2.0__py3-none-any.whl

render_sdk/__init__.py

@@ -1,8 +1,45 @@
 """Render Python SDK
 
-This package provides:
-1. Workflow SDK (render_sdk.workflows) for defining and running tasks
-2. REST API Client (render_sdk.client) for interacting with Render's API
+Task definition (for workers):
+
+    from render_sdk import Workflows, Retry
+
+    app = Workflows(auto_start=True)
+
+    @app.task
+    def my_task(x: int) -> int:
+        return x * 2
+
+REST API access (for clients):
+
+    from render_sdk import Render
+
+    render = Render()
+    result = await render.workflows.run_task("my-workflow/my_task", [5])
 """
 
-__version__ = "0.1.2"
+__version__ = "0.2.0"
+
+# Primary user-facing APIs
+from render_sdk.render import Render
+from render_sdk.workflows import Options, Retry, Workflows, start, task
+
+__all__ = [
+    "__version__",
+    # Primary APIs
+    "Render",  # REST API client
+    "Workflows",  # Task definition
+    # Configuration
+    "Options",
+    "Retry",
+    # Deprecated: use Workflows.task and Workflows.start() instead
+    "start",
+    "task",
+]
+
+# Direct client access available via:
+#   render.client  # Access from existing Render instance
+#   from render_sdk.client import Client  # Or import directly
+#
+# Raw API access available via:
+#   from render_sdk.public_api import AuthenticatedClient

render_sdk/client/__init__.py

@@ -16,6 +16,19 @@ from render_sdk.client.types import (
     TaskRunStatus,
 )
 from render_sdk.client.workflows import WorkflowsService
+from render_sdk.experimental import (
+    DownloadResponse,
+    ExperimentalService,
+    ObjectApi,
+    ObjectClient,
+    ObjectData,
+    OwnerID,
+    PutObjectResult,
+    Region,
+    ScopedObjectClient,
+    StorageService,
+    UploadResponse,
+)
 
 __all__ = [
     "Client",
@@ -29,4 +42,16 @@ __all__ = [
     "LimitParam",
     "CursorParam",
     "OwnerIDParam",
+    # Experimental exports
+    "ExperimentalService",
+    "StorageService",
+    "ObjectApi",
+    "ObjectClient",
+    "ScopedObjectClient",
+    "DownloadResponse",
+    "ObjectData",
+    "OwnerID",
+    "PutObjectResult",
+    "Region",
+    "UploadResponse",
 ]

render_sdk/client/client.py

@@ -7,7 +7,9 @@ import os
 
 from render_sdk.client.sse import SSEClient
 from render_sdk.client.workflows import WorkflowsService
+from render_sdk.experimental.experimental import ExperimentalService
 from render_sdk.public_api.client import AuthenticatedClient
+from render_sdk.version import get_user_agent
 
 
 class Client:
@@ -21,6 +23,7 @@ class Client:
         token: The authentication token
         base_url: The API base URL
         workflows: Service client for workflow operations
+        experimental: Service client for experimental features
     """
 
     token: str
@@ -71,8 +74,10 @@ class Client:
         self.internal = AuthenticatedClient(
             base_url=api_base,
             token=self.token,
+            headers={"User-Agent": get_user_agent()},
         )
 
         # Initialize service clients
         self.workflows = WorkflowsService(self)
         self.sse = SSEClient(self)
+        self.experimental = ExperimentalService(self)

render_sdk/client/sse.py

@@ -12,7 +12,10 @@ import httpx
 
 from render_sdk.client.types import TaskRunDetails
 from render_sdk.client.util import handle_http_error, handle_httpx_exception
-from render_sdk.public_api.api.workflows.stream_task_runs_events import _get_kwargs
+from render_sdk.public_api.api.workflow_tasks_ea.stream_task_runs_events import (
+    _get_kwargs,
+)
+from render_sdk.version import get_user_agent
 
 if TYPE_CHECKING:
     from render_sdk.client.client import Client
@@ -58,6 +61,7 @@ class SSEClient:
                     "Accept": "text/event-stream",
                     "Cache-Control": "no-cache",
                     "Authorization": f"Bearer {self.client.token}",
+                    "User-Agent": get_user_agent(),
                 }
             )
 

render_sdk/client/tests/test_client.py

@@ -25,6 +25,7 @@ def mock_task_run(mocker):
         parent_task_run_id=None,
         root_task_run_id=None,
         retries=0,
+        attempts=[],
         started_at=None,
         task_id=None,
     )
@@ -42,6 +43,7 @@ def mock_task_run_details(mocker):
         parent_task_run_id=None,
         root_task_run_id=None,
         retries=0,
+        attempts=[],
         started_at=None,
         task_id=None,
     )
@@ -74,28 +76,28 @@ def workflows_service(client):
 @pytest.fixture
 def mock_cancel_task_run_asyncio(mocker):
     return mocker.patch(
-        "render_sdk.public_api.api.workflows.cancel_task_run.asyncio_detailed"
+        "render_sdk.public_api.api.workflow_tasks_ea.cancel_task_run.asyncio_detailed"
     )
 
 
 @pytest.fixture
 def mock_list_task_runs_asyncio(mocker):
     return mocker.patch(
-        "render_sdk.public_api.api.workflows.list_task_runs.asyncio_detailed"
+        "render_sdk.public_api.api.workflow_tasks_ea.list_task_runs.asyncio_detailed"
     )
 
 
 @pytest.fixture
 def mock_create_task_asyncio(mocker):
     return mocker.patch(
-        "render_sdk.public_api.api.workflows.create_task.asyncio_detailed"
+        "render_sdk.public_api.api.workflow_tasks_ea.create_task.asyncio_detailed"
     )
 
 
 @pytest.fixture
 def mock_get_task_run_asyncio(mocker):
     return mocker.patch(
-        "render_sdk.public_api.api.workflows.get_task_run.asyncio_detailed"
+        "render_sdk.public_api.api.workflow_tasks_ea.get_task_run.asyncio_detailed"
     )
 
 

render_sdk/client/tests/test_sse.py

@@ -38,6 +38,7 @@ async def test_parse_stream_completed():
         parent_task_run_id="trn-test123",
         root_task_run_id="trn-test123",
         retries=0,
+        attempts=[],
     )
     sse_data = [
         b"event: task.completed\ndata: "

render_sdk/client/types.py

@@ -11,7 +11,8 @@ from render_sdk.public_api.models.task_run_status import TaskRunStatus as _TaskR
 
 # Type aliases to match Go client interface
 TaskIdentifier = str
-TaskData = list[Any]
+# TaskData can be either positional (list) or named (dict) parameters
+TaskData = list[Any] | dict[str, Any]
 
 # Re-export model classes with cleaner names
 TaskRun = _TaskRun

render_sdk/client/workflows.py

@@ -15,7 +15,7 @@ from render_sdk.client.types import (
     TaskRunStatusValues,
 )
 from render_sdk.client.util import handle_http_errors, retry_with_backoff
-from render_sdk.public_api.api.workflows import (
+from render_sdk.public_api.api.workflow_tasks_ea import (
     cancel_task_run,
     create_task,
     get_task_run,
@@ -23,6 +23,7 @@ from render_sdk.public_api.api.workflows import (
 )
 from render_sdk.public_api.models.error import Error
 from render_sdk.public_api.models.run_task import RunTask
+from render_sdk.public_api.models.task_data_type_1 import TaskDataType1
 from render_sdk.public_api.types import UNSET, Response
 
 if TYPE_CHECKING:
@@ -125,7 +126,9 @@ class WorkflowsService:
 
         Args:
             task_identifier: The identifier of the task to run
-            input_data: The input data for the task
+            input_data: The input data for the task. Can be either:
+                - A list for positional arguments: [arg1, arg2, arg3]
+                - A dict for named parameters: {"param1": value1, "param2": value2}
 
         Returns:
             AwaitableTaskRun: An awaitable task run object
@@ -147,10 +150,17 @@ class WorkflowsService:
         self, task_identifier: TaskIdentifier, input_data: TaskData
     ) -> Response[Error | TaskRun]:
         """Internal method to make the create task API call."""
+        # Convert dict to TaskDataType1 for named parameters
+        task_data_input: TaskDataType1 | list[Any]
+        if isinstance(input_data, dict):
+            task_data_input = TaskDataType1.from_dict(input_data)
+        else:
+            task_data_input = input_data
+
         # Create the request body
         run_task = RunTask(
             task=task_identifier,
-            input_=input_data,
+            input_=task_data_input,
         )
 
         # Make the API call

render_sdk/experimental/__init__.py

@@ -0,0 +1,31 @@
+"""Experimental API exports."""
+
+from render_sdk.experimental.experimental import ExperimentalService, StorageService
+from render_sdk.experimental.object import (
+    DownloadResponse,
+    ObjectApi,
+    ObjectClient,
+    ObjectData,
+    OwnerID,
+    PutObjectResult,
+    Region,
+    ScopedObjectClient,
+    UploadResponse,
+)
+
+__all__ = [
+    # Experimental Service
+    "ExperimentalService",
+    "StorageService",
+    # Object API classes
+    "ObjectApi",
+    "ObjectClient",
+    "ScopedObjectClient",
+    # Object types
+    "DownloadResponse",
+    "ObjectData",
+    "OwnerID",
+    "PutObjectResult",
+    "Region",
+    "UploadResponse",
+]

render_sdk/experimental/experimental.py

@@ -0,0 +1,71 @@
+"""Experimental Service
+
+This module provides the ExperimentalService class that exposes experimental features
+from the Render SDK.
+"""
+
+from typing import TYPE_CHECKING
+
+from render_sdk.experimental.object.client import ObjectClient
+
+if TYPE_CHECKING:
+    from render_sdk.client.client import Client
+
+
+class StorageService:
+    """Storage Service
+
+    Provides access to experimental storage features.
+
+    Example:
+        ```python
+        # Access object storage
+        await client.experimental.storage.objects.put(
+            owner_id="tea-xxxxx",
+            region="oregon",
+            key="file.png",
+            data=b"content"
+        )
+        ```
+    """
+
+    def __init__(self, client: "Client"):
+        """Initialize the storage service.
+
+        Args:
+            client: The Render client instance
+        """
+        self.objects = ObjectClient(client.internal)
+
+
+class ExperimentalService:
+    """Experimental Service
+
+    Provides access to experimental Render SDK features.
+
+    Features in this namespace may change or be removed without a migration plan.
+    When a feature stabilizes, it will be promoted to the main SDK namespace.
+
+    Example:
+        ```python
+        from render_sdk.client import Client
+
+        client = Client()
+
+        # Access experimental object storage
+        await client.experimental.storage.objects.put(
+            owner_id="tea-xxxxx",
+            region="oregon",
+            key="file.png",
+            data=b"content"
+        )
+        ```
+    """
+
+    def __init__(self, client: "Client"):
+        """Initialize the experimental service.
+
+        Args:
+            client: The Render client instance
+        """
+        self.storage = StorageService(client)

render_sdk/experimental/object/__init__.py

@@ -0,0 +1,30 @@
+"""Object storage API exports."""
+
+from render_sdk.experimental.object.api import ObjectApi
+from render_sdk.experimental.object.client import ObjectClient, ScopedObjectClient
+from render_sdk.experimental.object.types import (
+    DownloadResponse,
+    ListObjectsResponse,
+    ObjectData,
+    ObjectMetadata,
+    OwnerID,
+    PutObjectResult,
+    Region,
+    UploadResponse,
+)
+
+__all__ = [
+    # API classes
+    "ObjectApi",
+    "ObjectClient",
+    "ScopedObjectClient",
+    # Types
+    "DownloadResponse",
+    "ListObjectsResponse",
+    "ObjectData",
+    "ObjectMetadata",
+    "OwnerID",
+    "PutObjectResult",
+    "Region",
+    "UploadResponse",
+]

render_sdk/experimental/object/api.py

@@ -0,0 +1,260 @@
+"""Layer 2: Typed Object API Client
+
+Provides idiomatic Python wrapper around the raw OpenAPI client.
+Handles presigned URL flow but still exposes the two-step nature
+(get URL, then upload/download). Useful for advanced use cases
+requiring fine-grained control.
+"""
+
+import builtins
+from typing import TYPE_CHECKING
+
+from render_sdk.client.errors import RenderError
+from render_sdk.client.util import handle_http_errors
+from render_sdk.experimental.object.types import (
+    DownloadResponse,
+    ListObjectsResponse,
+    ObjectMetadata,
+    UploadResponse,
+)
+from render_sdk.public_api.api.blob_storage import (
+    delete_blob,
+    get_blob,
+    list_blobs,
+    put_blob,
+)
+from render_sdk.public_api.models.blob_with_cursor import BlobWithCursor
+from render_sdk.public_api.models.error import Error
+from render_sdk.public_api.models.get_blob_output import GetBlobOutput
+from render_sdk.public_api.models.put_blob_input import (
+    PutBlobInput as PutBlobInputModel,
+)
+from render_sdk.public_api.models.put_blob_output import PutBlobOutput
+from render_sdk.public_api.models.region import Region
+from render_sdk.public_api.types import UNSET, Response
+
+if TYPE_CHECKING:
+    from render_sdk.public_api.client import AuthenticatedClient
+
+
+class ObjectApi:
+    """Layer 2: Typed Object API Client
+
+    Provides idiomatic Python wrapper around the raw OpenAPI client.
+    Handles presigned URL flow but still exposes the two-step nature.
+    """
+
+    def __init__(self, client: "AuthenticatedClient"):
+        self.client = client
+
+    async def get_upload_url(
+        self,
+        owner_id: str,
+        region: Region | str,
+        key: str,
+        size_bytes: int,
+    ) -> UploadResponse:
+        """Get a presigned URL for uploading an object.
+
+        Args:
+            owner_id: Owner ID (workspace team ID)
+            region: Storage region
+            key: Object key (path)
+            size_bytes: Size of the object in bytes
+
+        Returns:
+            UploadResponse: Upload URL with expiration and size limit
+
+        Raises:
+            ClientError: For 4xx client errors
+            ServerError: For 5xx server errors
+            TimeoutError: If the request times out
+        """
+        response = await self._get_upload_url_api_call(
+            owner_id, region, key, size_bytes
+        )
+
+        if not isinstance(response.parsed, PutBlobOutput):
+            raise RenderError("Failed to get upload URL: unexpected response type")
+
+        return UploadResponse(
+            url=response.parsed.url,
+            expires_at=response.parsed.expires_at,
+            max_size_bytes=response.parsed.max_size_bytes,
+        )
+
+    @handle_http_errors("get upload URL")
+    async def _get_upload_url_api_call(
+        self,
+        owner_id: str,
+        region: Region | str,
+        key: str,
+        size_bytes: int,
+    ) -> Response[Error | PutBlobOutput]:
+        """Internal method to make the get upload URL API call."""
+        # Convert region to Region enum if it's a string
+        if isinstance(region, str):
+            region = Region(region)
+
+        body = PutBlobInputModel(size_bytes=size_bytes)
+
+        return await put_blob.asyncio_detailed(
+            owner_id=owner_id,
+            region=region,
+            key=key,
+            client=self.client,
+            body=body,
+        )
+
+    async def get_download_url(
+        self,
+        owner_id: str,
+        region: Region | str,
+        key: str,
+    ) -> DownloadResponse:
+        """Get a presigned URL for downloading an object.
+
+        Args:
+            owner_id: Owner ID (workspace team ID)
+            region: Storage region
+            key: Object key (path)
+
+        Returns:
+            DownloadResponse: Download URL with expiration
+
+        Raises:
+            ClientError: For 4xx client errors
+            ServerError: For 5xx server errors
+            TimeoutError: If the request times out
+        """
+        response = await self._get_download_url_api_call(owner_id, region, key)
+
+        if not isinstance(response.parsed, GetBlobOutput):
+            raise RenderError("Failed to get download URL: unexpected response type")
+
+        return DownloadResponse(
+            url=response.parsed.url,
+            expires_at=response.parsed.expires_at,
+        )
+
+    @handle_http_errors("get download URL")
+    async def _get_download_url_api_call(
+        self,
+        owner_id: str,
+        region: Region | str,
+        key: str,
+    ) -> Response[Error | GetBlobOutput]:
+        """Internal method to make the get download URL API call."""
+        # Convert region to Region enum if it's a string
+        if isinstance(region, str):
+            region = Region(region)
+
+        return await get_blob.asyncio_detailed(
+            owner_id=owner_id,
+            region=region,
+            key=key,
+            client=self.client,
+        )
+
+    async def delete(
+        self,
+        owner_id: str,
+        region: Region | str,
+        key: str,
+    ) -> None:
+        """Delete an object.
+
+        Args:
+            owner_id: Owner ID (workspace team ID)
+            region: Storage region
+            key: Object key (path)
+
+        Raises:
+            ClientError: For 4xx client errors
+            ServerError: For 5xx server errors
+            TimeoutError: If the request times out
+        """
+        await self._delete_api_call(owner_id, region, key)
+
+    @handle_http_errors("delete object")
+    async def _delete_api_call(
+        self,
+        owner_id: str,
+        region: Region | str,
+        key: str,
+    ) -> Response[Error | None]:
+        """Internal method to make the delete object API call."""
+        # Convert region to Region enum if it's a string
+        if isinstance(region, str):
+            region = Region(region)
+
+        return await delete_blob.asyncio_detailed(
+            owner_id=owner_id,
+            region=region,
+            key=key,
+            client=self.client,
+        )
+
+    async def list_objects(
+        self,
+        owner_id: str,
+        region: Region | str,
+        cursor: str | None = None,
+        limit: int | None = None,
+    ) -> ListObjectsResponse:
+        """List objects in storage.
+
+        Args:
+            owner_id: Owner ID (workspace team ID)
+            region: Storage region
+            cursor: Pagination cursor from previous response
+            limit: Maximum number of objects to return (default 20)
+
+        Returns:
+            ListObjectsResponse: List of object metadata with optional next cursor
+
+        Raises:
+            ClientError: For 4xx client errors
+            ServerError: For 5xx server errors
+            TimeoutError: If the request times out
+        """
+        response = await self._list_objects_api_call(owner_id, region, cursor, limit)
+
+        if not isinstance(response.parsed, builtins.list):
+            raise RenderError("Failed to list objects: unexpected response type")
+
+        objects = [
+            ObjectMetadata(
+                key=item.blob.key,
+                size=item.blob.size_bytes,
+                last_modified=item.blob.last_modified,
+                content_type=item.blob.content_type,
+            )
+            for item in response.parsed
+        ]
+
+        # The cursor for the next page is the cursor of the last item
+        next_cursor = response.parsed[-1].cursor if response.parsed else None
+
+        return ListObjectsResponse(objects=objects, next_cursor=next_cursor)
+
+    @handle_http_errors("list objects")
+    async def _list_objects_api_call(
+        self,
+        owner_id: str,
+        region: Region | str,
+        cursor: str | None,
+        limit: int | None,
+    ) -> Response[Error | builtins.list[BlobWithCursor]]:
+        """Internal method to make the list objects API call."""
+        # Convert region to Region enum if it's a string
+        if isinstance(region, str):
+            region = Region(region)
+
+        return await list_blobs.asyncio_detailed(
+            owner_id=owner_id,
+            region=region,
+            cursor=cursor if cursor is not None else UNSET,
+            limit=limit if limit is not None else UNSET,
+            client=self.client,
+        )