stepfunction 0.0.4__tar.gz → 0.0.6__tar.gz

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

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

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

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

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

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

{stepfunction-0.0.4 → stepfunction-0.0.6}/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.4 → stepfunction-0.0.6}/src/stepfunction/core/step_function/step_function.py

@@ -131,7 +131,7 @@ class StepFunction:
         func: Union[Callable[[Any], Any], Dict[str, Callable[[Any], Any]], BaseStep],
         next_step: Optional[str] = None,
         on_failure: Optional[str] = None,
-        branch: Optional[Dict[Any, str]] = None,
+        branch: Optional[Union[Dict[Any, str], Callable[[Any], str]]] = None,
         parallel: bool = False,
         stop_on_failure: bool = False,
     ):

stepfunction-0.0.6/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.6/src/stepfunction/steps/exceptions/__init__.py

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

stepfunction-0.0.6/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.6/src/stepfunction/steps/retry_step.py

@@ -0,0 +1,78 @@
+"""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, Optional
+
+from stepfunction.constants.enums import StepType
+from stepfunction.steps.base import BaseStep
+from stepfunction.utils.logger import setup_logger
+
+
+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
+        self.__logger = setup_logger(__name__)
+
+    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:
+            self.__logger.debug(
+                f"RetryStep - executing with max_retries={max_retries}, delay={delay}s"
+            )
+            last_exc: Optional[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
+                    self.__logger.warning(
+                        f"RetryStep - attempt {attempt + 1}/{max_retries + 1} failed: {exc}"
+                    )
+                    if attempt < max_retries:
+                        self.__logger.debug(f"RetryStep - retrying in {delay}s")
+                        await sleep(delay)
+
+            self.__logger.error(f"RetryStep - all {max_retries + 1} attempts exhausted")
+            raise last_exc
+
+        return run

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

@@ -0,0 +1,65 @@
+"""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
+from stepfunction.utils.logger import setup_logger
+
+
+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
+        self.__logger = setup_logger(__name__)
+
+    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:
+            self.__logger.debug(f"TimeoutStep - executing with timeout of {timeout}s")
+            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:
+                self.__logger.error(f"TimeoutStep - exceeded timeout of {timeout}s")
+                raise StepTimeoutError(timeout)
+
+        return run

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

@@ -3,11 +3,12 @@
 Author: Vineeth Penugonda
 """
 
-import asyncio
+from asyncio import sleep
 from typing import Any, Callable
 
 from stepfunction.constants.enums import StepType
 from stepfunction.steps.base import BaseStep
+from stepfunction.utils.logger import setup_logger
 
 
 class WaitStep(BaseStep):
@@ -29,13 +30,16 @@ class WaitStep(BaseStep):
         if duration < 0:
             raise ValueError("duration must be a non-negative number")
         self.duration = duration
+        self.__logger = setup_logger(__name__)
 
     def build(self) -> Callable[[Any], Any]:
         """Return an async function that sleeps for ``duration`` seconds."""
         duration = self.duration
 
         async def wait(input_value: Any) -> Any:
-            await asyncio.sleep(duration)
+            self.__logger.debug(f"WaitStep - sleeping for {duration}s")
+            await sleep(duration)
+            self.__logger.debug(f"WaitStep - resumed after {duration}s")
             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"]