stepfunction 0.0.1__py3-none-any.whl

stepfunction/constants/enums.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+
+class StepFunctionStatus(Enum):
+    INITIALIZED = "INITIALIZED"
+    RUNNING = "IN_PROGRESS"
+    COMPLETED = "COMPLETED"
+    FAILED = "FAILED"

stepfunction/constants/visualizer.py

@@ -0,0 +1,47 @@
+# Visualizer
+
+# Render Configuration
+
+DEFAULT_VISUALIZER_EXTENSION = "gv"
+"""str: The default extension for the visualizer renderer."""
+
+DEFAULT_VISUALIZER_FORMAT = "png"
+"""str: The default format for the visualizer renderer."""
+
+DEFAULT_VISUALIZER_RENDERER = "cairo"
+"""str: The default renderer for the visualizer."""
+
+DEFAULT_VISUALIZER_FOLDER = "workflow_renders"
+"""str: The default folder where visualizer renders are stored."""
+
+DEFAULT_VISUALIZER_STRING_ENCODING = "utf-8"
+"""str: The default encoding for visualizer strings."""
+
+# Edge labels and colors
+
+DEFAULT_VISUALIZER_SUCCESS_EDGE_LABEL = "Success"
+"""str: The default edge label for success transitions in the visualizer."""
+
+DEFAULT_VISUALIZER_SUCCESS_EDGE_COLOR = "black"
+"""str: The default edge color for success transitions in the visualizer."""
+
+DEFAULT_VISUALIZER_FAILURE_EDGE_LABEL = "Failure"
+"""str: The default edge label for failure transitions in the visualizer."""
+
+DEFAULT_VISUALIZER_FAILURE_EDGE_COLOR = "black"
+"""str: The default edge color for failure transitions in the visualizer."""
+
+DEFAULT_VISUALIZER_STOP_ON_FAILURE_EDGE_LABEL = "Stop on Failure"
+"""str: The default edge label for stop on failure transitions in the visualizer."""
+
+DEFAULT_VISUALIZER_STOP_ON_FAILURE_EDGE_COLOR = "red"
+"""str: The default edge color for stop on failure transitions in the visualizer."""
+
+DEFAULT_VISUALIZER_PARALLEL_STEP_EDGE_STYLE = "dashed"
+"""str: The default edge style for parallel steps in the visualizer."""
+
+DEFAULT_VISUALIZER_SUB_STEP_FUNCTION_NODE_SHAPE = "boxed"
+"""str: The default node shape for sub-step functions in the visualizer."""
+
+DEFAULT_VISUALIZER_SUB_STEP_FUNCTION_NODE_STYLE = "dotted"
+""" str: The default node style for sub-step functions in the visualizer."""

stepfunction/core/step_function/__init__.py

@@ -0,0 +1,3 @@
+from .step_function import StepFunction
+
+__all__ = ["StepFunction"]

stepfunction/core/step_function/step_function.py

@@ -0,0 +1,368 @@
+""" Module to define the StepFunction class. 
+
+    Author: Vineeth Penugonda
+"""
+
+
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from inspect import iscoroutinefunction
+from typing import Any, Callable, Dict, Optional, Union
+
+from stepfunction.constants.enums import StepFunctionStatus
+from stepfunction.core.visualizer import Visualizer
+from stepfunction.exceptions.step_errors import (ParallelStepExecutionError,
+                                                 StepExecutionError)
+from stepfunction.types.step_types import StepParams
+from stepfunction.utils.logger import setup_logger
+
+
+class StepFunction:
+    """
+    Class to represent a workflow consisting of multiple steps.
+
+    This class allows for sequential and parallel execution of steps in a workflow. Each step can have a next step to
+    proceed to upon success, an on_failure step to proceed to in case of failure, and optional branching based on the
+    result of a step. Parallel steps can be executed concurrently, with the option to stop all parallel executions
+    if one of them fails. The results of each step, including failures, are stored in the workflow's context, which can
+    be visualized or retrieved for further analysis.
+
+    Attributes:
+        current_step (Optional[str]): The current step being executed.
+        context (Dict[str, Any]): A dictionary that holds the results of each step, including exceptions if any occur.
+
+    Properties:
+        name (str): The name of the step function.
+        steps (StepParams): A dictionary containing the steps of the workflow.
+        last_result (Any): The result of the last step.
+        context (Dict[str, Any]): Stores step names and results, including exceptions if any occur.
+        status (StepFunctionStatus): The current status of the workflow. Possible values are:
+            - StepFunctionStatus.INITIALIZED: The workflow is initialized but not yet started.
+            - StepFunctionStatus.RUNNING: The workflow is currently in progress.
+            - StepFunctionStatus.COMPLETED: The workflow finished successfully.
+            - StepFunctionStatus.FAILED: The workflow encountered an error and went to a failure handler or failed entirely.
+
+    Methods:
+        add_step(name, func, next_step=None, on_failure=None, branch=None, parallel=False, stop_on_failure=False):
+            Add a step to the workflow.
+
+        set_start_step(name):
+            Set the start step of the workflow.
+
+        add_sub_step_function(name, sub_step_function, next_step=None, on_failure=None):
+            Add a sub-step function to be executed as a step.
+
+        execute(initial_input=None):
+            Execute the workflow starting from the specified start step. This will run each step in sequence or in parallel,
+            depending on the step configuration.
+
+        visualize():
+            Visualize the workflow structure and the relationships between steps.
+
+        visualize_to_string():
+            Return a string representation of the workflow for visualization.
+
+    Protected Methods:
+        _execute_step(func, input_value):
+            Execute a single step, handling asynchronous and synchronous functions appropriately.
+
+        _execute_parallel(func_dict, stop_on_failure=False):
+            Execute parallel steps concurrently. Store the results for each step in the context, including exceptions
+            if any step fails. If `stop_on_failure` is True, halt all parallel executions if one of the steps fails.
+
+    Raises:
+        ValueError:
+            Raised if a step with the same name already exists in the workflow or if an undefined step is set as the start step.
+
+        StepExecutionError:
+            Raised when a step fails and no `on_failure` step is defined.
+
+        ParallelStepExecutionError:
+            Raised when one or more parallel steps fail and `stop_on_failure` is set to True.
+
+    Example usage:
+        step_function = StepFunction("MyStepFunction")
+        step_function.add_step("Step1", func1, next_step="Step2")
+        step_function.add_step("Step2", func2, branch={"success": "Step3", "failure": "Step4"})
+        step_function.add_step("Step3", func3, on_failure="Step1")
+        step_function.add_step("Step4", func4)
+        step_function.set_start_step("Step1")
+        await step_function.execute()
+
+    Parallel Example:
+        step_function.add_step("Step1", func1, parallel=True)
+        step_function.add_step("ParallelStep", {
+            "task1": func2, 
+            "task2": func3
+        }, next_step="Step2", parallel=True)
+
+    Sub-step function example:
+        sub_step_function = StepFunction("SubStepFunction")
+        # Define steps for sub_step_function...
+        step_function.add_sub_step_function("SubStep", sub_step_function, next_step="FinalStep")
+        await step_function.execute()
+
+    Status Example:
+        status = step_function.status  # Will be StepFunctionStatus.INITIALIZED, StepFunctionStatus.RUNNING, StepFunctionStatus.COMPLETED, or StepFunctionStatus.FAILED.
+"""
+
+    def __init__(self, name: str):
+        self.__name = name  # Name of the step function
+
+        self.__steps: StepParams = {}  # Steps of the workflow
+        self.__current_step = None  # The current step being executed
+
+        self.__last_result = None  # To hold the result of the last step
+        self.__context = {}  # To hold the step names and results of those steps
+
+        # Status of the step function
+        self.__status: StepFunctionStatus = StepFunctionStatus.INITIALIZED
+
+        self.__logger = setup_logger(__name__)
+
+        self.__logger.debug(
+            f"StepFunction - {self.__name} - Status - {self.__status.value}")
+
+    def add_step(
+        self,
+        name: str,
+        func: Union[Callable[[Any], Any], Dict[str, Callable[[Any], Any]]],
+        next_step: Optional[str] = None,
+        on_failure: Optional[str] = None,
+        branch: Optional[Dict[Any, str]] = None,
+        parallel: bool = False,
+        stop_on_failure: bool = False,
+    ):
+        """Add a step to the workflow."""
+
+        if name in self.__steps:
+            raise ValueError(f"Step '{name}' already exists in steps")
+
+        self.__steps[name] = {
+            "func": func,
+            "next_step": next_step,
+            "on_failure": on_failure,
+            "branch": branch,
+            "parallel": parallel,
+            "stop_on_failure": stop_on_failure,
+        }
+
+    def add_sub_step_function(self, name: str, sub_step_function: "StepFunction", next_step: Optional[str] = None, on_failure: Optional[str] = None):
+        """Add a sub-step function to the workflow."""
+
+        if name in self.__steps:
+            raise ValueError(f"Step '{name}' already exists in steps")
+
+        async def sub_func(last_result):
+            await sub_step_function.execute(initial_input=last_result)
+            self.__context.update(sub_step_function.context)
+
+            if sub_step_function.status == StepFunctionStatus.FAILED:
+                self.__status = StepFunctionStatus.FAILED
+
+            return sub_step_function.last_result
+
+        self.__steps[name] = {
+            "func": sub_func,
+            "next_step": next_step,
+            "on_failure": on_failure,
+            "branch": None,
+            "parallel": False,
+            "stop_on_failure": False,
+            "is_sub_step_function": True
+        }
+
+    def set_start_step(self, name: str):
+        """Set the start step of the workflow."""
+        if name not in self.__steps:
+            raise ValueError(f"Step '{name}' not found in steps")
+
+        self.__current_step = name
+
+    async def execute(self, initial_input: Any = None):
+        """Execute the workflow."""
+
+        self.__status = StepFunctionStatus.RUNNING
+
+        self.__logger.debug(
+            f"StepFunction - {self.__name} - Status - {self.__status.value}")
+
+        self.__last_result = initial_input
+
+        while self.__current_step:
+            step = self.__steps[self.__current_step]
+            try:
+                if step["parallel"]:
+                    results = self._execute_parallel(
+                        step["func"], step["stop_on_failure"])
+
+                    self.__last_result = results
+                    self.__context[self.__current_step] = results
+
+                    self.__logger.info(
+                        f"Parallel step '{
+                            self.__current_step}' succeeded with results: {results}"
+                    )
+                else:
+                    result = await self._execute_step(step["func"], self.__last_result)
+
+                    self.__last_result = result
+                    self.__context[self.__current_step] = result
+
+                    self.__logger.info(
+                        f"Step '{self.__current_step}' succeeded"
+                    )
+
+                if step['branch'] and result in step['branch']:
+                    self.__current_step = step['branch'][result]
+                else:
+                    self.__current_step = step["next_step"]
+
+            except Exception as exc:
+                self.__logger.exception(
+                    f"Step '{self.__current_step}' failed. Exception: {exc}"
+                )
+
+                self.__context[self.__current_step] = exc.args[0]
+
+                if step["on_failure"]:
+                    self.__logger.exception(
+                        f"Executing failure step: {
+                            step['on_failure']} for '{self.__current_step}'"
+                    )
+
+                    self.__current_step = step["on_failure"]
+                    self.__last_result = exc.args[0]
+
+                    self.__status = StepFunctionStatus.FAILED
+
+                    self.__logger.debug(
+                        f"StepFunction - {self.__name} - Status - {self.__status.value}")
+                else:
+                    self.__logger.exception(
+                        f"No failure step defined for '{
+                            self.__current_step}'. Raising Exception."
+                    )
+
+                    self.__status = StepFunctionStatus.FAILED
+
+                    self.__logger.debug(
+                        f"StepFunction - {self.__name} - Status - {self.__status.value}")
+
+                    raise StepExecutionError(exc)
+
+            if not self.__current_step and self.__status != StepFunctionStatus.FAILED:
+                # If no more steps, mark as COMPLETED
+
+                self.__status = StepFunctionStatus.COMPLETED
+
+                self.__logger.debug(
+                    f"StepFunction - {self.__name} - Status - {self.__status.value}")
+
+    async def _execute_step(self, func: Callable, input_value: Any):
+        """ Execute a single step, handling async functions. """
+        if iscoroutinefunction(func):
+            return await func(input_value)
+        else:
+            return func(input_value)
+
+    def _execute_parallel(self, func_dict: Dict[str, Callable[[Any], Any]], stop_on_failure: bool = False):
+        """Execute the steps in parallel."""
+        results = {}
+        errors = []
+        should_stop_execution = False
+
+        with ThreadPoolExecutor() as executor:
+            futures = {executor.submit(
+                func, self.__last_result): step_name for step_name, func in func_dict.items()}
+
+            for future in as_completed(futures):
+                step_name = futures[future]
+
+                if should_stop_execution:
+                    break
+
+                try:
+                    result = future.result()
+                    results[step_name] = result
+                except Exception as exc:
+                    self.__logger.exception(
+                        f"Parallel task '{step_name}' failed: {exc}")
+
+                    results[step_name] = exc.args[0]
+
+                    errors.append((step_name, exc))
+
+                    if stop_on_failure:
+                        should_stop_execution = True
+
+        if errors:
+            self.__logger.error(f"Some parallel tasks failed: {errors}")
+
+            if stop_on_failure:
+                self.__status = StepFunctionStatus.FAILED
+                raise ParallelStepExecutionError(errors)
+
+        return results
+
+    def visualize(self):
+        """Visualize the workflow."""
+        visualizer = Visualizer(self.__name, self.__steps)
+
+        self.__logger.debug("Visualizing the step function")
+
+        visualizer.visualize_step_function()
+
+        self.__logger.debug("Rendering the step function")
+
+        visualizer.render_step_function()
+
+        output_file_name = visualizer.output_file_name
+
+        self.__logger.debug(f"Rendered the step function to file: {
+            output_file_name}")
+
+    def visualize_to_string(self):
+        """Visualize the workflow as a string."""
+        visualizer = Visualizer(self.__name, self.__steps)
+
+        self.__logger.debug("Visualizing the step function")
+
+        visualizer.visualize_step_function()
+
+        return visualizer.render_step_function_to_string()
+
+    @property
+    def name(self):
+        """ Returns the name of the step function. 
+        """
+        return self.__name
+
+    @property
+    def steps(self):
+        """ Returns the steps of the step function. 
+        """
+        return self.__steps
+
+    @property
+    def last_result(self):
+        """ Returns the result of the last step.
+        """
+        return self.__last_result
+
+    @property
+    def context(self):
+        """ Returns the context of the step function.
+        """
+        return self.__context
+
+    @property
+    def status(self):
+        """ Returns the status of the step function.
+        """
+        return self.__status
+
+    def __str__(self):
+        return f"StepFunction(name={self.__name}, NoOfSteps={len(self.__steps)}, CurrentStep={self.__current_step}, Status={self.__status})"
+
+    def __repr__(self):
+        return str(self)

stepfunction/core/visualizer/__init__.py

@@ -0,0 +1,3 @@
+from .visualizer import Visualizer
+
+__all__ = ["Visualizer"]

stepfunction/core/visualizer/visualizer.py

@@ -0,0 +1,129 @@
+""" This module contains the visualizer class for the graph model.
+
+    Author: Vineeth Penugonda
+"""
+
+from os import getcwd
+
+from graphviz import Digraph
+
+from stepfunction.constants.visualizer import (
+    DEFAULT_VISUALIZER_EXTENSION, DEFAULT_VISUALIZER_FAILURE_EDGE_COLOR,
+    DEFAULT_VISUALIZER_FAILURE_EDGE_LABEL, DEFAULT_VISUALIZER_FOLDER,
+    DEFAULT_VISUALIZER_FORMAT, DEFAULT_VISUALIZER_PARALLEL_STEP_EDGE_STYLE,
+    DEFAULT_VISUALIZER_RENDERER, DEFAULT_VISUALIZER_STOP_ON_FAILURE_EDGE_COLOR,
+    DEFAULT_VISUALIZER_STOP_ON_FAILURE_EDGE_LABEL,
+    DEFAULT_VISUALIZER_STRING_ENCODING,
+    DEFAULT_VISUALIZER_SUB_STEP_FUNCTION_NODE_SHAPE,
+    DEFAULT_VISUALIZER_SUB_STEP_FUNCTION_NODE_STYLE,
+    DEFAULT_VISUALIZER_SUCCESS_EDGE_LABEL)
+from stepfunction.types.step_types import StepParams
+from stepfunction.types.visualizer_types import RenderStepFunctionParams
+
+
+class Visualizer:
+    """ This class is responsible for visualizing the graph model.
+    """
+
+    def __init__(self, graph_name: str, steps: StepParams = None):
+        """ Initializes the visualizer."""
+
+        self.graph_name = graph_name
+        self.__steps = steps
+
+        self.__output_file_name = None
+        self.__output_file_path = None
+
+        self.__dot = Digraph(comment=self.graph_name)
+
+    def visualize_step_function(self):
+        """ Visualizes the graph model.
+        """
+
+        if not self.__steps:
+            raise ValueError("No steps found to visualize.")
+
+        for step_name, step_info in self.__steps.items():
+
+            if 'is_sub_step_function' in step_info and step_info['is_sub_step_function']:
+                self.__dot.node(step_name, step_name, shape=DEFAULT_VISUALIZER_SUB_STEP_FUNCTION_NODE_SHAPE,
+                                style=DEFAULT_VISUALIZER_SUB_STEP_FUNCTION_NODE_STYLE)
+            else:
+                self.__dot.node(step_name, step_name)
+
+            if step_info['next_step']:
+                self.__dot.edge(
+                    step_name, step_info['next_step'], label=DEFAULT_VISUALIZER_SUCCESS_EDGE_LABEL)
+
+            if step_info['on_failure']:
+                failure_edge_label = DEFAULT_VISUALIZER_FAILURE_EDGE_LABEL
+                failure_edge_color = DEFAULT_VISUALIZER_FAILURE_EDGE_COLOR
+
+                if step_info.get('stop_on_failure'):
+                    failure_edge_label = DEFAULT_VISUALIZER_STOP_ON_FAILURE_EDGE_LABEL
+                    failure_edge_color = DEFAULT_VISUALIZER_STOP_ON_FAILURE_EDGE_COLOR
+
+                self.__dot.edge(
+                    step_name, step_info['on_failure'], label=failure_edge_label, color=failure_edge_color)
+
+            if step_info['parallel']:
+
+                # func is a dictionary for parallel steps
+                parallel_function_names = step_info['func']
+
+                with self.__dot.subgraph() as s:
+                    s.attr(rank='same')
+
+                    for parallel_step_name, func in parallel_function_names.items():
+                        self.__dot.node(parallel_step_name, parallel_step_name)
+                        self.__dot.edge(
+                            step_name, parallel_step_name, style=DEFAULT_VISUALIZER_PARALLEL_STEP_EDGE_STYLE)
+
+                        if step_info['next_step']:
+                            self.__dot.edge(parallel_step_name,
+                                            step_info['next_step'])
+
+            if step_info.get('branch'):
+                for result, next_step in step_info['branch'].items():
+                    self.__dot.edge(step_name, next_step,
+                                    label=f"Branch: {result}")
+
+    def render_step_function(self, **kwargs: RenderStepFunctionParams):
+        """ Renders the graph model.
+        """
+        current_dir = getcwd()
+
+        format = kwargs.get('format', DEFAULT_VISUALIZER_FORMAT)
+        renderer = kwargs.get('renderer', DEFAULT_VISUALIZER_RENDERER)
+
+        file_path = kwargs.get(
+            'file_path', f"{current_dir}/{DEFAULT_VISUALIZER_FOLDER}")
+        file_name = kwargs.get('file_name', f"{self.graph_name}.{
+                               DEFAULT_VISUALIZER_EXTENSION}")
+
+        self.__output_file_path = file_path
+        self.__output_file_name = file_name
+
+        self.__dot.render(
+            filename=f"{self.__output_file_path}/{self.__output_file_name}", format=format, renderer=renderer)
+
+    def render_step_function_to_string(self, **kwargs: RenderStepFunctionParams):
+        """ Renders the graph model as a string.
+        """
+
+        format = kwargs.get('format', DEFAULT_VISUALIZER_FORMAT)
+        renderer = kwargs.get('renderer', DEFAULT_VISUALIZER_RENDERER)
+
+        return self.__dot.pipe(format=format, renderer=renderer).decode(DEFAULT_VISUALIZER_STRING_ENCODING)
+
+    @property
+    def output_file_name(self):
+        """ Returns the output file name.
+        """
+        return self.__output_file_name
+
+    @property
+    def output_file_path(self):
+        """ Returns the output file path.
+        """
+        return self.__output_file_path

stepfunction/exceptions/step_errors.py

@@ -0,0 +1,14 @@
+class StepExecutionError(Exception):
+    """Error raised when a step fails."""
+
+    def __init__(self, exc: Exception):
+        self.message = f"Step generated an exception: {exc}"
+        super().__init__(self.message)
+
+
+class ParallelStepExecutionError(Exception):
+    """Error raised when a parallel step fails."""
+
+    def __init__(self, exc: Exception):
+        self.message = f"Parallel step generated an exception: {exc}"
+        super().__init__(self.message)

stepfunction/types/step_types.py

@@ -0,0 +1,12 @@
+from typing import Any, Callable, Dict, Optional, TypedDict
+
+
+class StepParams(TypedDict, total=False):
+
+    func: Callable[[Any], Any]
+    next_step: Optional[str]
+    on_failure: Optional[str]
+    branch: Optional[Dict[Any, str]]
+    parallel: bool
+    stop_on_failure: bool
+    is_sub_step_function: bool

stepfunction/types/visualizer_types.py

@@ -0,0 +1,7 @@
+from typing import TypedDict, Optional
+
+class RenderStepFunctionParams(TypedDict, total=False):
+    file_path: Optional[str]
+    file_name: Optional[str]
+    format: str
+    renderer: str

stepfunction/utils/constants.py

@@ -0,0 +1,12 @@
+""" Constants for the project. """
+
+# Logging
+DEFAULT_LOG_LEVEL = "INFO"
+"""str: The default logging level for the project."""
+
+DEFAULT_LOGGING_FORMAT = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+"""str: The default logging format for the project."""
+
+# Environment variables
+ENVIRONMENT_VARIABLE_LOG_LEVEL = "LOG_LEVEL"
+""" str: The environment variable for the logging level."""

stepfunction/utils/logger.py

@@ -0,0 +1,61 @@
+""" Module for setting up loggers. """
+
+import logging
+import logging.config
+
+from stepfunction.utils.constants import (DEFAULT_LOG_LEVEL,
+                                          DEFAULT_LOGGING_FORMAT,
+                                          ENVIRONMENT_VARIABLE_LOG_LEVEL)
+from stepfunction.utils.utils import get_environment_variable
+
+
+def setup_logger(name: str | None = None, log_format: str = DEFAULT_LOGGING_FORMAT) -> logging.Logger:
+    """
+    Set up and return a logger with the given name.
+    If no name is provided, return the root logger.
+    """
+
+    LOG_LEVEL = get_environment_variable(
+        ENVIRONMENT_VARIABLE_LOG_LEVEL, DEFAULT_LOG_LEVEL)
+
+    logging_config = {
+        "version": 1,
+        "disable_existing_loggers": False,
+        "formatters": {
+            "default": {
+                "format": log_format,
+            },
+        },
+        "handlers": {
+            "console": {
+                "class": "logging.StreamHandler",
+                "formatter": "default",
+            }
+        },
+        "root": {
+            "level": LOG_LEVEL,
+            "handlers": ["console"],
+        },
+        "loggers": {
+            "filecentral": {
+                "level": LOG_LEVEL,
+                "handlers": ["console"],
+                "propagate": False,
+            },
+
+            "botocore": {
+                "level": "WARNING",  # Set level to WARNING to ignore DEBUG logs
+                "handlers": ["console"],
+                "propagate": False,
+            },
+            "urllib3.connectionpool": {
+                "level": "ERROR",  # Only log errors and above to reduce noise
+                "handlers": ["console"],
+                "propagate": False,
+            },
+        },
+    }
+
+    logging.config.dictConfig(logging_config)
+
+    return logging.getLogger(name)

stepfunction/utils/utils.py

@@ -0,0 +1,17 @@
+""" This module contains utility functions for the stepfunction package. """
+
+from os import getenv
+
+
+def get_environment_variable(name: str, default: str = None) -> str:
+    """
+        Returns the value of the environment variable with the given name.
+
+        Args:
+            name (str): The name of the environment variable.
+            default (str): The default value to return if the environment variable is not set.
+
+        Returns:
+            str: The value of the environment variable.
+    """
+    return getenv(name, default)

stepfunction-0.0.1.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Vineeth Penugonda
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

stepfunction-0.0.1.dist-info/METADATA

@@ -0,0 +1,67 @@
+Metadata-Version: 2.1
+Name: stepfunction
+Version: 0.0.1
+Summary: Step Function Workflow Orchestration Library
+Author: Vineeth Penugonda
+Project-URL: Homepage, https://github.com/vinecodes/stepfunction
+Project-URL: Issues, https://github.com/vinecodes/stepfunction/issues
+Project-URL: Blog_Post, https://blog.vineethp.com/posts/introducingstepfunction/
+Keywords: StepFunction,Workflow,Orchestration,Library
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: graphviz ===0.20.3
+
+# StepFunction
+
+![License](https://img.shields.io/badge/License-MIT-blue.svg)
+![Python](https://img.shields.io/badge/Python-3.12%2B-brightgreen.svg)
+![Status](https://img.shields.io/badge/Status-Alpha-red.svg)
+
+`StepFunction` is a Python library for orchestrating complex workflows through a step-by-step process. It allows for easy management of sequential and parallel tasks with robust error handling and branching. The library is inspired by AWS Step Functions but implemented as a Python-native solution to orchestrate workflows across any environment.
+
+## Features
+
+- **Sequential and Parallel Execution**: Run steps one after another or in parallel.
+- **Error Handling**: Define failure paths and handle exceptions gracefully.
+- **Branching Logic**: Direct workflows based on conditions.
+- **Sub-Step Functions**: Modularize workflows by embedding sub-step functions.
+- **Visualization**: Integrated support for visualizing the workflow graph.
+
+## Installation
+
+You can install the `StepFunction` package using `pip`:
+
+```bash
+pip install stepfunction
+```
+
+## Documentation and Further Reading
+
+For more detailed usage examples and advanced use cases, please read the [blog post](https://blog.vineethp.com/posts/introducingstepfunction/) that explains the design and usage of the library in-depth. This blog post covers advanced concepts like error handling, sub-step functions, and visualizing workflows in a real-world context.
+
+## Dependencies
+
+The StepFunction package requires the following dependencies:
+
+- `graphviz == 0.20.3`
+
+These will be automatically installed when you install the package via pip.
+
+## Contributing
+
+If you'd like to contribute to StepFunction, feel free to submit issues or pull requests. Contributions are welcome!
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+## Author
+Created and maintained by **Vineeth Penugonda**.
+

stepfunction-0.0.1.dist-info/RECORD

@@ -0,0 +1,21 @@
+stepfunction/constants/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+stepfunction/constants/enums.py,sha256=NnJ_388IDnKQhjk_692TjL5O-KFVOA3b_PMhggyKGpA,166
+stepfunction/constants/visualizer.py,sha256=99isL2AnwQln_Rc_-asIu3PCDEscipCf5HMlWLU7PWw,1763
+stepfunction/core/step_function/__init__.py,sha256=AGg68Zm_9qud_2JORuQ2fdb1hJkc-t9J3iMXTOnbUJk,67
+stepfunction/core/step_function/step_function.py,sha256=W9d3BKojyt0T7E6Ue2-fsJUSrz-_eGD_Qw139IIz46o,13867
+stepfunction/core/visualizer/__init__.py,sha256=sZWiVnJKdgm_yv-G9nLeGHhNdYbbuCh72SwcJ6kgYBQ,60
+stepfunction/core/visualizer/visualizer.py,sha256=RyaR8rFRJ8JJNpGe6C_FEfx67D0OBJ5c0RFUibBkQNc,5013
+stepfunction/exceptions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+stepfunction/exceptions/step_errors.py,sha256=9CQGL18IfnXvRLTnBmESuW6p_1yzMB3Jx1PrqWoQfPQ,468
+stepfunction/types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+stepfunction/types/step_types.py,sha256=IdxcIM9WDVozQPUFwTUuhZUikz2LAq-o_6zxqBp4ePQ,308
+stepfunction/types/visualizer_types.py,sha256=kAytibRU7eTm2MI02zJLYH-ZkRa4kosGfDjggCAFR94,187
+stepfunction/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+stepfunction/utils/constants.py,sha256=cCeOZUJdoaSoBV5lM5ZOGg7d5sh1oFTum26nNOopKeo,392
+stepfunction/utils/logger.py,sha256=5beoM6rxSKbv_4nWOfwGJ93V4nR9ewXAnRjTwQsIO3U,1819
+stepfunction/utils/utils.py,sha256=tIAgd6HEGJn8MMSkgrmyKVvBzHrFRyZF4jY1uP55BZ8,541
+stepfunction-0.0.1.dist-info/LICENSE,sha256=8YO69WbB5N-EJjk-po0P7LiWUmnxdsycwqEqgG5F4JY,1073
+stepfunction-0.0.1.dist-info/METADATA,sha256=b1t1Ey-51t4vHjYoeXAJI7ylD9N1cRSIvy5o6JXcrbM,2733
+stepfunction-0.0.1.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+stepfunction-0.0.1.dist-info/top_level.txt,sha256=XqLJSUeYSmzTNMiPj-IESxp1om-LdZjefT4Un2orQD4,13
+stepfunction-0.0.1.dist-info/RECORD,,

stepfunction-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.1.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

stepfunction-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+stepfunction