render_sdk 0.1.2__tar.gz → 0.1.3__tar.gz

{render_sdk-0.1.2 → render_sdk-0.1.3}/PKG-INFO

@@ -1,7 +1,8 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: render_sdk
-Version: 0.1.2
+Version: 0.1.3
 Summary: Python SDK for Render Workflows
+License-File: LICENSE
 Author: Render
 Author-email: support@render.com
 Requires-Python: >=3.10,<4.0
@@ -15,7 +16,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
-Requires-Dist: aiohttp (>=3.8.0,<4.0.0)
+Requires-Dist: aiohttp (>=3.12.14,<4.0.0)
 Requires-Dist: httpx (>=0.28.1,<0.29.0)
 Requires-Dist: openapi-python-client (>=0.26.1,<0.27.0)
 Description-Content-Type: text/markdown

{render_sdk-0.1.2 → render_sdk-0.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "render_sdk"
-version = "0.1.2"
+version = "0.1.3"
 description = "Python SDK for Render Workflows"
 authors = ["Render <support@render.com>"]
 readme = "README.md"
@@ -24,7 +24,7 @@ classifiers = [
 
 [tool.poetry.dependencies]
 python = "^3.10"
-aiohttp = "^3.8.0"
+aiohttp = "^3.12.14"
 openapi-python-client = "^0.26.1"
 httpx = "^0.28.1"
 

{render_sdk-0.1.2 → render_sdk-0.1.3}/render_sdk/__init__.py

@@ -5,4 +5,4 @@ This package provides:
 2. REST API Client (render_sdk.client) for interacting with Render's API
 """
 
-__version__ = "0.1.2"
+__version__ = "0.1.3"

{render_sdk-0.1.2 → render_sdk-0.1.3}/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-0.1.2 → render_sdk-0.1.3}/render_sdk/client/workflows.py

@@ -125,7 +125,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

{render_sdk-0.1.2 → render_sdk-0.1.3}/render_sdk/public_api/models/run_task.py

@@ -17,7 +17,7 @@ class RunTask:
     """
 
     task: str
-    input_: list[Any]
+    input_: list[Any] | dict[str, Any]
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:

{render_sdk-0.1.2 → render_sdk-0.1.3}/render_sdk/workflows/callback_api/models/__init__.py

@@ -11,6 +11,7 @@ from .task import Task
 from .task_complete import TaskComplete
 from .task_error import TaskError
 from .task_options import TaskOptions
+from .task_parameter import TaskParameter
 from .tasks import Tasks
 
 __all__ = (
@@ -25,5 +26,6 @@ __all__ = (
     "TaskComplete",
     "TaskError",
     "TaskOptions",
+    "TaskParameter",
     "Tasks",
 )

{render_sdk-0.1.2 → render_sdk-0.1.3}/render_sdk/workflows/callback_api/models/task.py

@@ -8,6 +8,7 @@ from ..types import UNSET, Unset
 
 if TYPE_CHECKING:
     from ..models.task_options import TaskOptions
+    from ..models.task_parameter import TaskParameter
 
 
 T = TypeVar("T", bound="Task")
@@ -19,10 +20,12 @@ class Task:
     Attributes:
         name (str):
         options (Union[Unset, TaskOptions]):
+        parameters (Union[Unset, list['TaskParameter']]): Parameter schema extracted from the task function signature
     """
 
     name: str
     options: Union[Unset, "TaskOptions"] = UNSET
+    parameters: Union[Unset, list["TaskParameter"]] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
@@ -32,6 +35,13 @@ class Task:
         if not isinstance(self.options, Unset):
             options = self.options.to_dict()
 
+        parameters: Union[Unset, list[dict[str, Any]]] = UNSET
+        if not isinstance(self.parameters, Unset):
+            parameters = []
+            for parameters_item_data in self.parameters:
+                parameters_item = parameters_item_data.to_dict()
+                parameters.append(parameters_item)
+
         field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
         field_dict.update(
@@ -41,12 +51,15 @@ class Task:
         )
         if options is not UNSET:
             field_dict["options"] = options
+        if parameters is not UNSET:
+            field_dict["parameters"] = parameters
 
         return field_dict
 
     @classmethod
     def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
         from ..models.task_options import TaskOptions
+        from ..models.task_parameter import TaskParameter
 
         d = dict(src_dict)
         name = d.pop("name")
@@ -58,9 +71,17 @@ class Task:
         else:
             options = TaskOptions.from_dict(_options)
 
+        parameters = []
+        _parameters = d.pop("parameters", UNSET)
+        for parameters_item_data in _parameters or []:
+            parameters_item = TaskParameter.from_dict(parameters_item_data)
+
+            parameters.append(parameters_item)
+
         task = cls(
             name=name,
             options=options,
+            parameters=parameters,
         )
 
         task.additional_properties = d

render_sdk-0.1.3/render_sdk/workflows/callback_api/models/task_parameter.py

@@ -0,0 +1,88 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="TaskParameter")
+
+
+@_attrs_define
+class TaskParameter:
+    """Information about a task parameter extracted from function signature
+
+    Attributes:
+        name (str): Parameter name
+        has_default (bool): Whether the parameter has a default value
+        type_ (Union[Unset, str]): String representation of the parameter type hint
+        default_value (Union[Unset, str]): JSON-encoded default value (if has_default is true)
+    """
+
+    name: str
+    has_default: bool
+    type_: Union[Unset, str] = UNSET
+    default_value: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        has_default = self.has_default
+
+        type_ = self.type_
+
+        default_value = self.default_value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "name": name,
+                "has_default": has_default,
+            }
+        )
+        if type_ is not UNSET:
+            field_dict["type"] = type_
+        if default_value is not UNSET:
+            field_dict["default_value"] = default_value
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        name = d.pop("name")
+
+        has_default = d.pop("has_default")
+
+        type_ = d.pop("type", UNSET)
+
+        default_value = d.pop("default_value", UNSET)
+
+        task_parameter = cls(
+            name=name,
+            has_default=has_default,
+            type_=type_,
+            default_value=default_value,
+        )
+
+        task_parameter.additional_properties = d
+        return task_parameter
+
+    @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_sdk-0.1.3/render_sdk/workflows/callback_api/py.typed

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

{render_sdk-0.1.2 → render_sdk-0.1.3}/render_sdk/workflows/client.py

@@ -134,13 +134,17 @@ class UDSClient:
         async with self.get_client() as client:
             return await post_callback.asyncio_detailed(client=client, body=data)
 
-    async def run_subtask(self, task_name: str, input_data: Any = None) -> Any:
+    async def run_subtask(
+        self, task_name: str, input_data: list[Any] | dict[str, Any] | None = None
+    ) -> Any:
         """
         Run a subtask and wait for its completion.
 
         Args:
             task_name: Name of the task to run
-            input_data: Input data to pass to the task
+            input_data: Input data to pass to the task. Can be either:
+                - A list for positional arguments: [arg1, arg2, arg3]
+                - A dict for named parameters: {"param1": value1, "param2": value2}
 
         Returns:
             The result of the subtask execution

{render_sdk-0.1.2 → render_sdk-0.1.3}/render_sdk/workflows/executor.py

@@ -17,7 +17,9 @@ class TaskExecutor:
         self.task_registry = task_registry
         self.client = client
 
-    async def _execute_task(self, task_name: str, input_args: list[Any]) -> Any:
+    async def _execute_task(
+        self, task_name: str, input_data: list[Any] | dict[str, Any]
+    ) -> Any:
         """Execute a task by name with the given input."""
         func = self.task_registry.get_function(task_name)
         if not func:
@@ -28,11 +30,19 @@ class TaskExecutor:
             context = _current_client.set(self.client)
 
             try:
-                # Check if the function is async
-                if inspect.iscoroutinefunction(func):
-                    result = await func(*input_args)
+                # Determine how to call the function based on input type
+                if isinstance(input_data, dict):
+                    # Named parameters: pass as keyword arguments
+                    if inspect.iscoroutinefunction(func):
+                        result = await func(**input_data)
+                    else:
+                        result = func(**input_data)
                 else:
-                    result = func(*input_args)
+                    # Positional parameters: unpack list
+                    if inspect.iscoroutinefunction(func):
+                        result = await func(*input_data)
+                    else:
+                        result = func(*input_data)
 
                 return TaskResult(result=result)
             finally:
@@ -42,7 +52,9 @@ class TaskExecutor:
         except Exception as e:
             return TaskResult(error=e)
 
-    async def execute(self, task_name: str, input_args: list[Any]) -> Any:
+    async def execute(
+        self, task_name: str, input_data: list[Any] | dict[str, Any]
+    ) -> Any:
         """Execute a task by name with the given input."""
         logger.debug(f"Starting execution of task: {task_name}")
 
@@ -50,7 +62,7 @@ class TaskExecutor:
 
         try:
             # Execute the task
-            result = await self._execute_task(task_name, input_args)
+            result = await self._execute_task(task_name, input_data)
             if result.error:
                 # Send error callback and raise the error
                 await self._send_error_callback(task_name, result.error)

{render_sdk-0.1.2 → render_sdk-0.1.3}/render_sdk/workflows/runner.py

@@ -10,11 +10,13 @@ from render_sdk.workflows.callback_api.models import (
     RetryConfig,
     Task,
     TaskOptions,
+    TaskParameter,
     Tasks,
 )
+from render_sdk.workflows.callback_api.types import UNSET, Unset
 from render_sdk.workflows.client import UDSClient
 from render_sdk.workflows.executor import TaskExecutor
-from render_sdk.workflows.task import get_task_registry
+from render_sdk.workflows.task import ParameterInfo, get_task_registry
 
 logger = logging.getLogger(__name__)
 
@@ -90,11 +92,18 @@ async def register_async(socket_path: str) -> None:
                 retry = task_info.options.retry
                 options.retry = RetryConfig(
                     max_retries=retry.max_retries,
-                    wait_duration_ms=retry.wait_duration_ms,
-                    factor=retry.factor,
+                    wait_duration_ms=retry.wait_duration,
+                    factor=retry.backoff_scaling,
                 )
 
-            task_def = Task(name=name, options=options)
+            parameters: list[TaskParameter] | Unset = UNSET
+            if task_info and task_info.parameters:
+                parameters = [
+                    _convert_parameter_info_to_api_model(param)
+                    for param in task_info.parameters
+                ]
+
+            task_def = Task(name=name, options=options, parameters=parameters)
             tasks.append(task_def)
 
         # Register tasks with server
@@ -138,3 +147,22 @@ def start() -> None:
         register(socket_path)
     else:
         raise ValueError(f"Unknown mode: {mode}")
+
+
+def _convert_parameter_info_to_api_model(param_info: ParameterInfo) -> TaskParameter:
+    """Convert internal ParameterInfo to API TaskParameter model."""
+    # JSON-encode the default value if it exists
+    default_value_str = None
+    if param_info.has_default and param_info.default_value is not None:
+        try:
+            default_value_str = json.dumps(param_info.default_value)
+        except (TypeError, ValueError):
+            # If the default can't be serialized, skip it
+            default_value_str = None
+
+    return TaskParameter(
+        name=param_info.name,
+        has_default=param_info.has_default,
+        type_=param_info.type_hint if param_info.type_hint is not None else UNSET,
+        default_value=default_value_str if default_value_str is not None else UNSET,
+    )

{render_sdk-0.1.2 → render_sdk-0.1.3}/render_sdk/workflows/task.py

@@ -3,6 +3,7 @@
 import asyncio
 import contextvars
 import functools
+import inspect
 from abc import ABC, abstractmethod
 from collections.abc import Callable
 from dataclasses import dataclass
@@ -19,8 +20,8 @@ class Retry:
     """Retry configuration for a task."""
 
     max_retries: int
-    wait_duration_ms: int
-    factor: float = 1.5
+    wait_duration: int
+    backoff_scaling: float = 1.5
 
 
 @dataclass
@@ -30,6 +31,19 @@ class Options:
     retry: Retry | None = None
 
 
+@dataclass
+class ParameterInfo:
+    """
+    Information about a task parameter extracted from the task's function
+    signature.
+    """
+
+    name: str
+    type_hint: str | None
+    has_default: bool
+    default_value: Any | None = None
+
+
 class TaskResult:
     """Represents the result of a task execution."""
 
@@ -59,10 +73,17 @@ class TaskContext(ABC):
 class TaskInfo:
     """Information about a registered task."""
 
-    def __init__(self, func: Callable, name: str, options: Options | None = None):
+    def __init__(
+        self,
+        func: Callable,
+        name: str,
+        options: Options | None = None,
+        parameters: list[ParameterInfo] | None = None,
+    ):
         self.func = func
         self.name = name
         self.options = options or Options()
+        self.parameters = parameters
 
 
 class TaskRegistry:
@@ -71,6 +92,35 @@ class TaskRegistry:
     def __init__(self) -> None:
         self._tasks: dict[str, TaskInfo] = {}
 
+    def _extract_parameters(self, func: Callable) -> list[ParameterInfo]:
+        """Extract parameter information from a function signature."""
+        sig = inspect.signature(func)
+        parameters: list[ParameterInfo] = []
+
+        for param_name, param in sig.parameters.items():
+            # Get type hint as string if available
+            type_hint: str | None = None
+            if param.annotation is not inspect.Parameter.empty:
+                if hasattr(param.annotation, "__name__"):
+                    type_hint = param.annotation.__name__
+                else:
+                    type_hint = str(param.annotation)
+
+            # Check if the parameter has a default value
+            has_default = param.default is not inspect.Parameter.empty
+            default_value = param.default if has_default else None
+
+            parameters.append(
+                ParameterInfo(
+                    name=param_name,
+                    type_hint=type_hint,
+                    has_default=has_default,
+                    default_value=default_value,
+                )
+            )
+
+        return parameters
+
     def register(
         self,
         func: Callable,
@@ -80,7 +130,9 @@ class TaskRegistry:
         """Register a task function."""
         task_name = name or func.__name__
 
-        task_info = TaskInfo(func, task_name, options)
+        parameters = self._extract_parameters(func)
+
+        task_info = TaskInfo(func, task_name, options, parameters)
 
         if task_name in self._tasks:
             raise ValueError(f"Task '{task_name}' already registered")
@@ -139,8 +191,26 @@ class TaskCallable:
     def __call__(self, *args, **kwargs):
         # Create a new TaskInstance for each call
         client = _current_client.get()
+
+        # Error on mixed positional and kw args
+        if args and kwargs:
+            raise ValueError(
+                "Cannot mix positional and keyword arguments when calling a task. "
+                "Use either positional arguments (e.g., task(arg1, arg2)) or "
+                "keyword arguments (e.g., task(param1=value1, param2=value2)), "
+                "but not both."
+            )
+
+        # Determine input data type based on how the task was called
+        if kwargs:
+            # Named parameters: pass as dict
+            input_data: dict[str, Any] = kwargs
+        else:
+            # Positional parameters: pass as list
+            input_data = list(args)
+
         # Start execution immediately
-        future = asyncio.create_task(client.run_subtask(self._name, list(args)))
+        future = asyncio.create_task(client.run_subtask(self._name, input_data))
         return TaskInstance(self._name, future)
 
 

{render_sdk-0.1.2 → render_sdk-0.1.3}/render_sdk/workflows/tests/test_end_to_end.py

@@ -70,7 +70,9 @@ def test_task_registration_network_payload(task_registry, task_decorator, mocker
         return f"Hello {msg}"
 
     @task_decorator(
-        options=Options(retry=Retry(max_retries=3, wait_duration_ms=1000, factor=1.5)),
+        options=Options(
+            retry=Retry(max_retries=3, wait_duration=1000, backoff_scaling=1.5)
+        ),
     )
     def retry_task(data: str) -> str:
         return data.upper()

{render_sdk-0.1.2 → render_sdk-0.1.3}/render_sdk/workflows/tests/test_registration.py

@@ -93,7 +93,9 @@ def test_task_registration_with_options_object():
 
     # Task with only retry options
     @task_decorator(
-        options=Options(retry=Retry(max_retries=1, wait_duration_ms=500, factor=1.0)),
+        options=Options(
+            retry=Retry(max_retries=1, wait_duration=500, backoff_scaling=1.0)
+        ),
     )
     def task_with_retry_only(x: int) -> int:
         return x

render_sdk-0.1.2/render_sdk/workflows/callback_api/py.typed

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