stepfunction 0.0.4__tar.gz → 0.0.5__tar.gz

{stepfunction-0.0.4/src/StepFunction.egg-info → stepfunction-0.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stepfunction
-Version: 0.0.4
+Version: 0.0.5
 Summary: Step Function Workflow Orchestration Library
 Author: Vineeth Penugonda
 License-Expression: MIT

{stepfunction-0.0.4 → stepfunction-0.0.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "stepfunction"
-version = "0.0.4"
+version = "0.0.5"
 authors = [{ name = "Vineeth Penugonda" }]
 description = "Step Function Workflow Orchestration Library"
 readme = "README.md"

{stepfunction-0.0.4 → stepfunction-0.0.5/src/StepFunction.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stepfunction
-Version: 0.0.4
+Version: 0.0.5
 Summary: Step Function Workflow Orchestration Library
 Author: Vineeth Penugonda
 License-Expression: MIT

{stepfunction-0.0.4 → stepfunction-0.0.5}/src/StepFunction.egg-info/SOURCES.txt

@@ -21,9 +21,13 @@ src/stepfunction/core/visualizer/visualizer.py
 src/stepfunction/exceptions/__init__.py
 src/stepfunction/exceptions/step_errors.py
 src/stepfunction/steps/__init__.py
+src/stepfunction/steps/retry_step.py
+src/stepfunction/steps/timeout_step.py
 src/stepfunction/steps/wait_step.py
 src/stepfunction/steps/base/__init__.py
 src/stepfunction/steps/base/base_step.py
+src/stepfunction/steps/exceptions/__init__.py
+src/stepfunction/steps/exceptions/step_exceptions.py
 src/stepfunction/types/__init__.py
 src/stepfunction/types/step_types.py
 src/stepfunction/types/visualizer_types.py

stepfunction-0.0.5/src/stepfunction/steps/__init__.py

@@ -0,0 +1,7 @@
+from .base import BaseStep
+from .exceptions import StepTimeoutError
+from .retry_step import RetryStep
+from .timeout_step import TimeoutStep
+from .wait_step import WaitStep
+
+__all__ = ["BaseStep", "RetryStep", "StepTimeoutError", "TimeoutStep", "WaitStep"]

stepfunction-0.0.5/src/stepfunction/steps/exceptions/__init__.py

@@ -0,0 +1,3 @@
+from .step_exceptions import StepTimeoutError
+
+__all__ = ["StepTimeoutError"]

stepfunction-0.0.5/src/stepfunction/steps/exceptions/step_exceptions.py

@@ -0,0 +1,11 @@
+"""Exceptions for built-in step types.
+
+Author: Vineeth Penugonda
+"""
+
+
+class StepTimeoutError(Exception):
+    """Raised when a step exceeds its allowed execution time."""
+
+    def __init__(self, timeout: float):
+        super().__init__(f"Step exceeded the timeout of {timeout}s")

stepfunction-0.0.5/src/stepfunction/steps/retry_step.py

@@ -0,0 +1,68 @@
+"""RetryStep — a built-in step that retries a callable on failure.
+
+Author: Vineeth Penugonda
+"""
+
+from asyncio import sleep
+from inspect import iscoroutinefunction
+from typing import Any, Callable
+
+from stepfunction.constants.enums import StepType
+from stepfunction.steps.base import BaseStep
+
+
+class RetryStep(BaseStep):
+    """A step that retries a callable on failure with a fixed delay between attempts.
+
+    Executes the wrapped function and retries up to ``max_retries`` times if it
+    raises an exception. Raises the last exception if all attempts fail.
+
+    Args:
+        func (Callable): The function to execute. May be sync or async.
+        max_retries (int): Maximum number of retry attempts after the first failure.
+            A value of 3 means the function is called at most 4 times. Defaults to 3.
+        delay (float): Seconds to wait between retry attempts. Defaults to 1.0.
+
+    Raises:
+        ValueError: If max_retries is negative or delay is negative.
+
+    Example:
+        sf.add_step("fetch", RetryStep(func=call_api, max_retries=3, delay=2.0), next_step="next")
+    """
+
+    step_type: StepType = StepType.INBUILT
+
+    def __init__(
+        self, func: Callable[[Any], Any], max_retries: int = 3, delay: float = 1.0
+    ):
+        if max_retries < 0:
+            raise ValueError("max_retries must be a non-negative integer")
+        if delay < 0:
+            raise ValueError("delay must be a non-negative number")
+
+        self.func = func
+        self.max_retries = max_retries
+        self.delay = delay
+
+    def build(self) -> Callable[[Any], Any]:
+        """Return an async function that retries ``func`` on failure."""
+        func = self.func
+        max_retries = self.max_retries
+        delay = self.delay
+
+        async def run(input_value: Any) -> Any:
+            last_exc: Exception = None
+
+            for attempt in range(max_retries + 1):
+                try:
+                    if iscoroutinefunction(func):
+                        return await func(input_value)
+                    return func(input_value)
+                except Exception as exc:
+                    last_exc = exc
+                    if attempt < max_retries:
+                        await sleep(delay)
+
+            raise last_exc
+
+        return run

stepfunction-0.0.5/src/stepfunction/steps/timeout_step.py

@@ -0,0 +1,61 @@
+"""TimeoutStep — a built-in step that enforces a maximum execution duration.
+
+Author: Vineeth Penugonda
+"""
+
+from asyncio import TimeoutError as AsyncTimeoutError
+from asyncio import get_running_loop, wait_for
+from inspect import iscoroutinefunction
+from typing import Any, Callable
+
+from stepfunction.constants.enums import StepType
+from stepfunction.steps.base import BaseStep
+from stepfunction.steps.exceptions import StepTimeoutError
+
+
+class TimeoutStep(BaseStep):
+    """A step that raises an error if the wrapped callable exceeds a time limit.
+
+    Works with both sync and async functions. Sync functions are executed in a
+    thread pool so the timeout can be enforced without blocking the event loop.
+
+    Args:
+        func (Callable): The function to execute. May be sync or async.
+        timeout (float): Maximum allowed duration in seconds.
+
+    Raises:
+        ValueError: If timeout is not a positive number.
+        StepTimeoutError: If the function does not complete within ``timeout`` seconds.
+
+    Example:
+        sf.add_step("process", TimeoutStep(func=heavy_job, timeout=30.0), next_step="next")
+    """
+
+    step_type: StepType = StepType.INBUILT
+
+    def __init__(self, func: Callable[[Any], Any], timeout: float):
+        if timeout <= 0:
+            raise ValueError("timeout must be a positive number")
+
+        self.func = func
+        self.timeout = timeout
+
+    def build(self) -> Callable[[Any], Any]:
+        """Return an async function that enforces a timeout on ``func``."""
+        func = self.func
+        timeout = self.timeout
+
+        async def run(input_value: Any) -> Any:
+            try:
+                if iscoroutinefunction(func):
+                    return await wait_for(func(input_value), timeout=timeout)
+                else:
+                    loop = get_running_loop()
+                    return await wait_for(
+                        loop.run_in_executor(None, func, input_value),
+                        timeout=timeout,
+                    )
+            except AsyncTimeoutError:
+                raise StepTimeoutError(timeout)
+
+        return run

{stepfunction-0.0.4 → stepfunction-0.0.5}/src/stepfunction/steps/wait_step.py

@@ -3,7 +3,7 @@
 Author: Vineeth Penugonda
 """
 
-import asyncio
+from asyncio import sleep
 from typing import Any, Callable
 
 from stepfunction.constants.enums import StepType
@@ -35,7 +35,7 @@ class WaitStep(BaseStep):
         duration = self.duration
 
         async def wait(input_value: Any) -> Any:
-            await asyncio.sleep(duration)
+            await sleep(duration)
             return input_value
 
         return wait

stepfunction-0.0.4/src/stepfunction/steps/__init__.py

@@ -1,4 +0,0 @@
-from .base import BaseStep
-from .wait_step import WaitStep
-
-__all__ = ["BaseStep", "WaitStep"]