render_sdk 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

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.1"
+__version__ = "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/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/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/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/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/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/workflows/callback_api/py.typed

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

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/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,15 +52,17 @@ 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.info(f"Starting execution of task: {task_name}")
+        logger.debug(f"Starting execution of task: {task_name}")
 
         sent_error = False
 
         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/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__)
 
@@ -25,18 +27,16 @@ async def run_async(socket_path: str) -> None:
 
     It gets the input from the server, executes the task, and sends the result back.
     """
-    logger.info("Starting task runner")
+    logger.debug("Starting task runner")
 
     # Create client
     client = UDSClient(socket_path)
 
     try:
         # Get input from server
-        logger.info("Getting input from server")
+        logger.debug("Getting task input")
         input_response = await client.get_input()
 
-        logger.info(f"Input response: {input_response}")
-
         task_name = input_response.task_name
         raw_input = input_response.input_
 
@@ -50,18 +50,13 @@ async def run_async(socket_path: str) -> None:
         else:
             input_data = []
 
-        logger.info(f"Received input - task: {task_name}, input: {input_data}")
-
         # Create executor and execute task
         task_registry = get_task_registry()
         executor = TaskExecutor(task_registry, client)
 
-        result = await executor.execute(task_name, input_data)
-
-        logger.info(f"Task executed successfully with result: {result}")
-
-    except Exception as e:
-        logger.error(f"Task execution failed: {e}")
+        logger.debug(f"Executing task: {task_name}")
+        await executor.execute(task_name, input_data)
+    except Exception:
         raise
 
 
@@ -76,7 +71,7 @@ async def register_async(socket_path: str) -> None:
     """
     Register all tasks with the server asynchronously.
     """
-    logger.info("Registering tasks")
+    logger.debug("Registering tasks")
 
     # Create client
     client = UDSClient(socket_path)
@@ -97,18 +92,25 @@ 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
-        logger.info(f"Registering {len(tasks)} tasks: {[t.name for t in tasks]}")
+        logger.debug(f"Registering {len(tasks)} tasks: {[t.name for t in tasks]}")
         await client.register_tasks(Tasks(tasks=tasks))
 
-        logger.info("Tasks registered successfully")
+        logger.debug("Tasks registered successfully")
 
     except Exception as e:
         logger.error(f"Task registration failed: {e}")
@@ -139,11 +141,28 @@ def start() -> None:
     if not socket_path:
         raise ValueError("RENDER_SDK_SOCKET_PATH environment variable is required")
 
-    logger.info(f"Starting in mode: {mode}")
-
     if mode == "run":
         run(socket_path)
     elif mode == "register":
         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/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/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/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.1.dist-info → render_sdk-0.1.3.dist-info}/METADATA

@@ -1,7 +1,8 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: render_sdk
-Version: 0.1.1
+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.1.dist-info → render_sdk-0.1.3.dist-info}/RECORD

@@ -1,4 +1,4 @@
-render_sdk/__init__.py,sha256=kV9V_Bg9B3ilP_iA9fvDmUhQVUz3uou0oW-W9-8GIyc,215
+render_sdk/__init__.py,sha256=fIELMyLq9HWX2veiJzLXZekFCIDc-aNuvGfO2pbks30,215
 render_sdk/client/__init__.py,sha256=OtkFIaTnPhU6_1yveJwZFRzL3TemdEjZcRvtoYCVhTE,630
 render_sdk/client/client.py,sha256=Relr4rc8qVbEkROBom6VvACKA8AalTZkYby3DPc2-vE,2486
 render_sdk/client/errors.py,sha256=Y1WZV_AOpqvf0_HT5XBQ1JD5jNiEjHrgSiyq8wBfM5U,758
@@ -7,9 +7,9 @@ render_sdk/client/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG
 render_sdk/client/tests/test_client.py,sha256=6BmCSj0peE_CqYqYF5KaoCWIl5mLp7rvNEWvvMmiDgc,8144
 render_sdk/client/tests/test_sse.py,sha256=-RpzXaQXgH3nTK2J73sZKrT0lqCP0q8qrx3IjJTgstw,1554
 render_sdk/client/tests/test_util.py,sha256=Ap30o4XQd8VUzH6RS0AhfN5nAgud2SnfWAi4gvBuGOM,3801
-render_sdk/client/types.py,sha256=JQUAZJN_VCpNFZ7pLqks7opHNSgQdpVuwkW8R8PC8O0,1252
+render_sdk/client/types.py,sha256=NfR25T0w8li0h6y-mN0ik62xY9Kpz79j9ENAX3pIuDQ,1339
 render_sdk/client/util.py,sha256=CKi7pKc8JsVHaj_dDHJarm1amc5yCXd48z_MZmJE1nU,6108
-render_sdk/client/workflows.py,sha256=qkA6v8wOpV7TAjx7CQv3GscUl-bL_53q4fFnRk7D_7Y,8466
+render_sdk/client/workflows.py,sha256=tb74nAHEjeZy9swx62DtbSyyW-ooYFQgX7jDjJ4PFqk,8636
 render_sdk/public_api/__init__.py,sha256=nUgpPUbIzZHvvG1MhZppIBnRlI0gHQ0TRjKNrBKMELk,160
 render_sdk/public_api/api/__init__.py,sha256=zTSiG_ujSjAqWPyc435YXaX9XTlpMjiJWBbV-f-YtdA,45
 render_sdk/public_api/api/blueprints/__init__.py,sha256=5vd9uJWAjRqa9xzxzYkLD1yoZ12Ld_bAaNB5WX4fbE8,56
@@ -470,7 +470,7 @@ render_sdk/public_api/models/route_post.py,sha256=gMHyooNM52XEEcnggG0L8OVr7A4UO-
 render_sdk/public_api/models/route_put.py,sha256=pmistR0mLC5O5bOi811aRiHprgwtyCe1FPqgxaJ31zc,1920
 render_sdk/public_api/models/route_type.py,sha256=j7vWAQkoYzQGuvjlIfKcFlr6DagyV7dD91AYRehIIIw,164
 render_sdk/public_api/models/route_with_cursor.py,sha256=fV_yxMU_jZXz77HA1Iul5JzUpFSpZQeIqrugWjXGcLY,1780
-render_sdk/public_api/models/run_task.py,sha256=7uHAQPbukwcvobohHAZSarOP6vsoVLAlqHfN4LtH7Xk,1773
+render_sdk/public_api/models/run_task.py,sha256=0aTb3DfzynAcVin4nMAEje8ekjgBGO_FF9dVHDwpzoo,1790
 render_sdk/public_api/models/runtime.py,sha256=tKW8by0zb_JR_eOz3A3Al_S1wXCmY-wMK-XEqF91YlM,206
 render_sdk/public_api/models/scale_service_body.py,sha256=G0HuTlbOAh9FcscEIS1qbyY8NO_7U6TQ8LZ6Aub6m48,1566
 render_sdk/public_api/models/schemas_user.py,sha256=GkJ38jc0EkhUstnMfSZQljQsS9tA3z35LOl6rRDdh7s,1600
@@ -545,7 +545,7 @@ render_sdk/workflows/callback_api/api/default/post_register_tasks.py,sha256=k3ci
 render_sdk/workflows/callback_api/api/default/post_run_subtask.py,sha256=i6epkJTyjynrFr0qiny63RIlJLlnt87HCbcRSVR5-3g,4180
 render_sdk/workflows/callback_api/client.py,sha256=o_mdLqyBCQstu5tS1WZFwqIEbGwkvWQ7eQjuCJw_5VY,12419
 render_sdk/workflows/callback_api/errors.py,sha256=gO8GBmKqmSNgAg-E5oT-oOyxztvp7V_6XG7OUTT15q0,546
-render_sdk/workflows/callback_api/models/__init__.py,sha256=A0BRSQ-HrFwCBr7JGQBGLnpjOo2zXTHaVmy7Gy7HsNI,832
+render_sdk/workflows/callback_api/models/__init__.py,sha256=uRwBSHP4JKkVFPpK_W7x9_yzAIGKb4CjCl8M1E2pFw0,895
 render_sdk/workflows/callback_api/models/callback_request.py,sha256=U2WnaGLWaIaeVrvEp4THtJoYhjgvYSH2-a6EPPt25nw,2680
 render_sdk/workflows/callback_api/models/input_response.py,sha256=BduvQTvIr3Wo8P1gCaegn4i2p7I4SnRjlo6FvWDOLqY,1658
 render_sdk/workflows/callback_api/models/retry_config.py,sha256=3cNk_kYWqpGZ7gJHzH_ExD0pvN14KpkYUk8XRu9Xo4U,2333
@@ -553,22 +553,23 @@ render_sdk/workflows/callback_api/models/run_subtask_request.py,sha256=Ln8FxEMzS
 render_sdk/workflows/callback_api/models/run_subtask_response.py,sha256=ALjpEFczMcyNd-8O0hS_G0rbrDWPpSUME7xdiSCigwg,1545
 render_sdk/workflows/callback_api/models/subtask_result_request.py,sha256=n9c4m5AwK96Nj6vSqKo_nCcdIv0yXgv1DzhtP5OR75I,1555
 render_sdk/workflows/callback_api/models/subtask_result_response.py,sha256=yctQ4RcR66P0bHRmbku4y4FPgn14P6dwk_uX90WV_GE,2983
-render_sdk/workflows/callback_api/models/task.py,sha256=YD9cUfMgTA_baFd0QkJIFUWhHQwiughlipJ7k6-QTco,2151
+render_sdk/workflows/callback_api/models/task.py,sha256=XOKRkHnljQvkBKOuvXwMTABDWEInKVoMNBUtLZP3zfY,3131
 render_sdk/workflows/callback_api/models/task_complete.py,sha256=Ndszhd7ymt7E-SEdtdLtKqraCh3gDnOq1qPOk03uIpE,1462
 render_sdk/workflows/callback_api/models/task_error.py,sha256=8-AdDCq8_3FIemWBXLbpA-O_VNrI18tThZtwdDSqHuQ,1799
 render_sdk/workflows/callback_api/models/task_options.py,sha256=FQLzMVNGDUHYhKWokV6FbD2RKit5rGIGlSun_ibbhv0,1975
+render_sdk/workflows/callback_api/models/task_parameter.py,sha256=SNWODy1hTnPdK-kyIOJXsdVYlj_r9V-P72dXIadoOcA,2486
 render_sdk/workflows/callback_api/models/tasks.py,sha256=mb3M6wKIb47y3tzl2uompmt3QvDe3qhaYstg1b9aKzc,1819
-render_sdk/workflows/callback_api/py.typed,sha256=8PjyZ1aVoQpRVvt71muvuq5qE-jTFZkK-GLHkhdebmc,26
+render_sdk/workflows/callback_api/py.typed,sha256=8ZJUsxZiuOy1oJeVhsTWQhTG_6pTVHVXk5hJL79ebTk,25
 render_sdk/workflows/callback_api/types.py,sha256=AX4orxQZQJat3vZrgjJ-TYb2sNBL8kNo9yqYDT-n8y8,1391
-render_sdk/workflows/client.py,sha256=P-2RRJydCrQopiVrms1Qoi_mS2z4L1HjDELgjgyZNSI,8448
-render_sdk/workflows/executor.py,sha256=3EevvPeTbYGqmjcJztZUzq85-7EHGErwK91ChnRZj54,3027
-render_sdk/workflows/runner.py,sha256=vJV1vK6sW1zffmCSEBIb1Pg_HwngIZD3TUC1CRoHB6w,4230
-render_sdk/workflows/task.py,sha256=Wh742_vC5JxvY8ifb8cWzefeEioGwgUGjB_bbplUGSA,5315
+render_sdk/workflows/client.py,sha256=a1bhCpdSAQ1M3JdmuN1ThOjIR2WX6xLzv5QzA69RaPQ,8662
+render_sdk/workflows/executor.py,sha256=KralE5cwnVngzjxK6ovn1c2YshB1YfBnewPyHJUGftY,3518
+render_sdk/workflows/runner.py,sha256=MhrU86Iru-SC-ybSpMAXekist_tSy-yiUVh2-ORpE_k,5161
+render_sdk/workflows/task.py,sha256=ivT35hkP_c9Xyg1O3hrZty9H4Gsduh4raJgH6hOLkEA,7576
 render_sdk/workflows/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-render_sdk/workflows/tests/test_end_to_end.py,sha256=eEasR0oCcZWgxZC8H0566I3HP501uK4nzawoEoRVFso,5183
+render_sdk/workflows/tests/test_end_to_end.py,sha256=QFsbcdAJHP9rnuoSfSIZxPJ8sPk49G4cNKbJbpgnyg0,5211
 render_sdk/workflows/tests/test_executor.py,sha256=8l5RtrAJKB3ZiWUr7aE6tVWJgCWWEHfadPvtqc3uvzs,4685
-render_sdk/workflows/tests/test_registration.py,sha256=l0_xUnknCEaE-oO55HYlsbaXQIe9KfUo8DbmJQ7fssw,4004
-render_sdk-0.1.1.dist-info/LICENSE,sha256=YQ01omJ4YGRAeEslBDXIx9tgO1VbIFYsusdCjQwjwW4,11336
-render_sdk-0.1.1.dist-info/METADATA,sha256=JN8Y8V3d0XeltypRfTlwq4JnAeMbVxB8o7UA9vi1ssM,2707
-render_sdk-0.1.1.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
-render_sdk-0.1.1.dist-info/RECORD,,
+render_sdk/workflows/tests/test_registration.py,sha256=mc3VIu1uvx3QvhBjJheolCxuBW9u4lQdygOKzQOYOlA,4032
+render_sdk-0.1.3.dist-info/METADATA,sha256=6NqlMZDfcmVdZSaPVj-sOCxXC3ADvT27kbha-6RNKtc,2731
+render_sdk-0.1.3.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+render_sdk-0.1.3.dist-info/licenses/LICENSE,sha256=YQ01omJ4YGRAeEslBDXIx9tgO1VbIFYsusdCjQwjwW4,11336
+render_sdk-0.1.3.dist-info/RECORD,,

{render_sdk-0.1.1.dist-info → render_sdk-0.1.3.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.1.2
+Generator: poetry-core 2.2.1
 Root-Is-Purelib: true
 Tag: py3-none-any