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

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__)
 
@@ -86,15 +88,27 @@ async def register_async(socket_path: str) -> None:
 
             options = TaskOptions()
             # Add options if present
-            if task_info and task_info.options and task_info.options.retry:
-                retry = task_info.options.retry
-                options.retry = RetryConfig(
-                    max_retries=retry.max_retries,
-                    wait_duration_ms=retry.wait_duration_ms,
-                    factor=retry.factor,
-                )
-
-            task_def = Task(name=name, options=options)
+            if task_info and task_info.options:
+                if task_info.options.retry:
+                    retry = task_info.options.retry
+                    options.retry = RetryConfig(
+                        max_retries=retry.max_retries,
+                        wait_duration_ms=retry.wait_duration_ms,
+                        factor=retry.backoff_scaling,
+                    )
+                if task_info.options.timeout_seconds:
+                    options.timeout_seconds = task_info.options.timeout_seconds
+                if task_info.options.plan:
+                    options.plan = task_info.options.plan
+
+            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 +152,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/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
@@ -20,14 +21,36 @@ class Retry:
 
     max_retries: int
     wait_duration_ms: int
-    factor: float = 1.5
+    backoff_scaling: float = 1.5
 
 
 @dataclass
 class Options:
-    """Configuration options for a task."""
+    """Configuration options for a task.
+
+    Attributes:
+        retry: Retry configuration for automatic task retries.
+        timeout_seconds: Task execution timeout in seconds (30-86400).
+        plan: Resource plan for task execution. Options: "starter" (0.5CPU/512MB),
+              "standard" (1CPU/2GB), "pro" (2CPU/4GB). Defaults to "standard".
+    """
 
     retry: Retry | None = None
+    timeout_seconds: int | None = None
+    plan: str | 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:
@@ -59,10 +82,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 +101,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 +139,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 +200,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_app.py

@@ -0,0 +1,412 @@
+"""Tests for the Workflows application class."""
+
+import warnings
+
+import pytest
+
+from render_sdk.workflows.app import Workflows
+from render_sdk.workflows.task import Retry
+
+
+# Reset global state before each test
+@pytest.fixture(autouse=True)
+def reset_auto_start_state():
+    """Reset the global auto_start tracking state before each test."""
+    import render_sdk.workflows.app as app_module
+
+    app_module._auto_start_app_registered = False
+    yield
+    app_module._auto_start_app_registered = False
+
+
+class TestFromWorkflows:
+    """Tests for Workflows.from_workflows() composition."""
+
+    def test_combines_tasks_from_multiple_apps(self):
+        """Test that from_workflows combines tasks from multiple apps."""
+        app_a = Workflows()
+        app_b = Workflows()
+
+        @app_a.task
+        def task_a(x: int) -> int:
+            return x + 1
+
+        @app_b.task
+        def task_b(x: int) -> int:
+            return x + 2
+
+        combined = Workflows.from_workflows(app_a, app_b)
+
+        # Verify both tasks are in the combined app
+        task_names = combined._registry.get_task_names()
+        assert "task_a" in task_names
+        assert "task_b" in task_names
+        assert len(task_names) == 2
+
+    def test_raises_on_duplicate_task_names(self):
+        """Test that from_workflows raises ValueError on duplicate task names."""
+        app_a = Workflows()
+        app_b = Workflows()
+
+        @app_a.task
+        def duplicate_task(x: int) -> int:
+            return x + 1
+
+        @app_b.task
+        def duplicate_task(x: int) -> int:  # noqa: F811
+            return x + 2
+
+        with pytest.raises(
+            ValueError, match="Task 'duplicate_task' is defined in multiple apps"
+        ):
+            Workflows.from_workflows(app_a, app_b)
+
+    def test_combined_app_uses_its_own_defaults(self):
+        """Test that the combined app uses its own defaults, not source app defaults."""
+        source_retry = Retry(max_retries=5, wait_duration_ms=500, backoff_scaling=1.0)
+        app_a = Workflows(default_retry=source_retry, default_timeout=100)
+
+        @app_a.task
+        def task_a(x: int) -> int:
+            return x
+
+        # Combined app has different defaults
+        combined_retry = Retry(
+            max_retries=10, wait_duration_ms=1000, backoff_scaling=2.0
+        )
+        combined = Workflows.from_workflows(
+            app_a,
+            default_retry=combined_retry,
+            default_timeout=300,
+            default_plan="premium",
+        )
+
+        # Verify the combined app stored its own defaults
+        assert combined._default_retry == combined_retry
+        assert combined._default_timeout == 300
+        assert combined._default_plan == "premium"
+
+    def test_combined_app_can_define_new_tasks(self):
+        """Test that new tasks can be added to the combined app."""
+        app_a = Workflows()
+
+        @app_a.task
+        def task_a(x: int) -> int:
+            return x
+
+        combined = Workflows.from_workflows(app_a)
+
+        @combined.task
+        def task_b(x: int) -> int:
+            return x * 2
+
+        task_names = combined._registry.get_task_names()
+        assert "task_a" in task_names
+        assert "task_b" in task_names
+        assert len(task_names) == 2
+
+    def test_works_with_zero_apps(self):
+        """Test that from_workflows works with no input apps."""
+        combined = Workflows.from_workflows()
+
+        assert combined._registry.get_task_names() == []
+
+    def test_works_with_single_app(self):
+        """Test that from_workflows works with a single app."""
+        app = Workflows()
+
+        @app.task
+        def my_task(x: int) -> int:
+            return x
+
+        combined = Workflows.from_workflows(app)
+
+        assert "my_task" in combined._registry.get_task_names()
+        assert len(combined._registry.get_task_names()) == 1
+
+    def test_preserves_task_options(self):
+        """Test that task options are preserved when combining apps."""
+        retry = Retry(max_retries=3, wait_duration_ms=1000, backoff_scaling=2.0)
+        app = Workflows()
+
+        @app.task(retry=retry, timeout=60, plan="starter")
+        def configured_task(x: int) -> int:
+            return x
+
+        combined = Workflows.from_workflows(app)
+
+        task_info = combined._registry.get_task("configured_task")
+        assert task_info is not None
+        assert task_info.options.retry.max_retries == 3
+        assert task_info.options.timeout_seconds == 60
+        assert task_info.options.plan == "starter"
+
+    def test_combines_three_or_more_apps(self):
+        """Test that from_workflows works with many apps."""
+        app1 = Workflows()
+        app2 = Workflows()
+        app3 = Workflows()
+
+        @app1.task
+        def task_1(x: int) -> int:
+            return x + 1
+
+        @app2.task
+        def task_2(x: int) -> int:
+            return x + 2
+
+        @app3.task
+        def task_3(x: int) -> int:
+            return x + 3
+
+        combined = Workflows.from_workflows(app1, app2, app3)
+
+        task_names = combined._registry.get_task_names()
+        assert len(task_names) == 3
+        assert "task_1" in task_names
+        assert "task_2" in task_names
+        assert "task_3" in task_names
+
+
+class TestWorkflowsInit:
+    """Tests for Workflows initialization."""
+
+    def test_stores_default_retry(self):
+        """Test that default_retry is stored correctly."""
+        retry = Retry(max_retries=5, wait_duration_ms=1000, backoff_scaling=2.0)
+        app = Workflows(default_retry=retry)
+
+        assert app._default_retry == retry
+
+    def test_stores_default_timeout(self):
+        """Test that default_timeout is stored correctly."""
+        app = Workflows(default_timeout=300)
+
+        assert app._default_timeout == 300
+
+    def test_stores_default_plan(self):
+        """Test that default_plan is stored correctly."""
+        app = Workflows(default_plan="premium")
+
+        assert app._default_plan == "premium"
+
+    def test_auto_start_false_by_default(self):
+        """Test that auto_start is False by default."""
+        app = Workflows()
+
+        assert app._auto_start is False
+
+    def test_started_false_initially(self):
+        """Test that _started is False initially."""
+        app = Workflows()
+
+        assert app._started is False
+
+
+class TestWorkflowsTaskDecorator:
+    """Tests for the @app.task decorator."""
+
+    def test_task_uses_app_defaults(self):
+        """Test that tasks use app-level defaults when not overridden."""
+        retry = Retry(max_retries=3, wait_duration_ms=1000, backoff_scaling=2.0)
+        app = Workflows(
+            default_retry=retry,
+            default_timeout=120,
+            default_plan="standard",
+        )
+
+        @app.task
+        def my_task(x: int) -> int:
+            return x
+
+        task_info = app._registry.get_task("my_task")
+        assert task_info.options.retry == retry
+        assert task_info.options.timeout_seconds == 120
+        assert task_info.options.plan == "standard"
+
+    def test_task_overrides_app_defaults(self):
+        """Test that task-level options override app defaults."""
+        app_retry = Retry(max_retries=3, wait_duration_ms=1000, backoff_scaling=2.0)
+        task_retry = Retry(max_retries=10, wait_duration_ms=5000, backoff_scaling=3.0)
+
+        app = Workflows(
+            default_retry=app_retry,
+            default_timeout=120,
+            default_plan="standard",
+        )
+
+        @app.task(retry=task_retry, timeout=60, plan="starter")
+        def my_task(x: int) -> int:
+            return x
+
+        task_info = app._registry.get_task("my_task")
+        assert task_info.options.retry == task_retry
+        assert task_info.options.timeout_seconds == 60
+        assert task_info.options.plan == "starter"
+
+    def test_task_partial_override(self):
+        """Test that tasks can partially override app defaults."""
+        app_retry = Retry(max_retries=3, wait_duration_ms=1000, backoff_scaling=2.0)
+
+        app = Workflows(
+            default_retry=app_retry,
+            default_timeout=120,
+            default_plan="standard",
+        )
+
+        # Only override timeout, keep retry and plan from defaults
+        @app.task(timeout=60)
+        def my_task(x: int) -> int:
+            return x
+
+        task_info = app._registry.get_task("my_task")
+        assert task_info.options.retry == app_retry  # From app default
+        assert task_info.options.timeout_seconds == 60  # Overridden
+        assert task_info.options.plan == "standard"  # From app default
+
+    def test_task_with_custom_name(self):
+        """Test that tasks can have custom names."""
+        app = Workflows()
+
+        @app.task(name="custom_task_name")
+        def my_function(x: int) -> int:
+            return x
+
+        task_names = app._registry.get_task_names()
+        assert "custom_task_name" in task_names
+        assert "my_function" not in task_names
+
+    def test_task_decorator_without_parentheses(self):
+        """Test that @app.task works without parentheses."""
+        app = Workflows()
+
+        @app.task
+        def my_task(x: int) -> int:
+            return x
+
+        assert "my_task" in app._registry.get_task_names()
+
+    def test_task_decorator_with_empty_parentheses(self):
+        """Test that @app.task() works with empty parentheses."""
+        app = Workflows()
+
+        @app.task()
+        def my_task(x: int) -> int:
+            return x
+
+        assert "my_task" in app._registry.get_task_names()
+
+
+class TestWorkflowsStart:
+    """Tests for Workflows.start() method."""
+
+    def test_raises_when_mode_not_set(self, monkeypatch):
+        """Test that start() raises ValueError when RENDER_SDK_MODE is not set."""
+        monkeypatch.delenv("RENDER_SDK_MODE", raising=False)
+        monkeypatch.delenv("RENDER_SDK_SOCKET_PATH", raising=False)
+
+        app = Workflows()
+
+        with pytest.raises(
+            ValueError, match="RENDER_SDK_MODE environment variable is required"
+        ):
+            app.start()
+
+    def test_raises_when_socket_path_not_set(self, monkeypatch):
+        """
+        Test that start() raises ValueError when RENDER_SDK_SOCKET_PATH is not set.
+        """
+        monkeypatch.setenv("RENDER_SDK_MODE", "run")
+        monkeypatch.delenv("RENDER_SDK_SOCKET_PATH", raising=False)
+
+        app = Workflows()
+
+        with pytest.raises(
+            ValueError, match="RENDER_SDK_SOCKET_PATH environment variable is required"
+        ):
+            app.start()
+
+    def test_raises_for_unknown_mode(self, monkeypatch):
+        """Test that start() raises ValueError for unknown mode."""
+        monkeypatch.setenv("RENDER_SDK_MODE", "invalid_mode")
+        monkeypatch.setenv("RENDER_SDK_SOCKET_PATH", "/tmp/test.sock")  # noqa: S108
+
+        app = Workflows()
+
+        with pytest.raises(ValueError, match="Unknown mode: invalid_mode"):
+            app.start()
+
+    def test_started_not_set_on_validation_failure(self, monkeypatch):
+        """Test that _started remains False when validation fails."""
+        monkeypatch.delenv("RENDER_SDK_MODE", raising=False)
+
+        app = Workflows()
+        assert app._started is False
+
+        with pytest.raises(ValueError):
+            app.start()
+
+        # _started should still be False since validation failed
+        assert app._started is False
+
+    def test_copies_tasks_to_global_registry(self, monkeypatch):
+        """Test that start() copies tasks to the global registry."""
+        monkeypatch.setenv("RENDER_SDK_MODE", "register")
+        monkeypatch.setenv("RENDER_SDK_SOCKET_PATH", "/tmp/test.sock")  # noqa: S108
+
+        from render_sdk.workflows.task import _global_registry
+
+        # Clear global registry
+        _global_registry._tasks.clear()
+
+        app = Workflows()
+
+        @app.task
+        def my_task(x: int) -> int:
+            return x
+
+        # Mock the register function to avoid actual socket operations
+        import render_sdk.workflows.app as app_module
+
+        original_register = app_module.register
+        app_module.register = lambda _: None
+
+        try:
+            app.start()
+
+            # Task should be in global registry
+            assert "my_task" in _global_registry._tasks
+        finally:
+            app_module.register = original_register
+            _global_registry._tasks.clear()
+
+
+class TestAutoStartWarning:
+    """Tests for auto_start warning behavior."""
+
+    def test_warns_on_multiple_auto_start_apps(self):
+        """Test that creating multiple apps with auto_start=True warns."""
+        # First app should not warn
+        _app1 = Workflows(auto_start=True)
+
+        # Second app should warn
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            _app2 = Workflows(auto_start=True)
+
+            assert len(w) == 1
+            warning_msg = str(w[0].message)
+            assert "Multiple Workflows instances with auto_start=True" in warning_msg
+            assert issubclass(w[0].category, UserWarning)
+
+    def test_no_warning_for_auto_start_false(self):
+        """Test that auto_start=False apps don't trigger warnings."""
+        _app1 = Workflows(auto_start=True)
+
+        # auto_start=False should not warn
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            _app2 = Workflows(auto_start=False)
+            _app3 = Workflows()  # Default is False
+
+            assert len(w) == 0