stepfunction 0.0.1__tar.gz → 0.0.3__tar.gz

{stepfunction-0.0.1 → stepfunction-0.0.3}/LICENSE

@@ -18,4 +18,4 @@ 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.
+SOFTWARE.

{stepfunction-0.0.1/src/StepFunction.egg-info → stepfunction-0.0.3}/PKG-INFO

@@ -1,22 +1,23 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: stepfunction
-Version: 0.0.1
+Version: 0.0.3
 Summary: Step Function Workflow Orchestration Library
 Author: Vineeth Penugonda
+License-Expression: MIT
 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: Programming Language :: Python :: 3.9
 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
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: graphviz===0.20.3
+Dynamic: license-file
 
 # StepFunction
 
@@ -64,4 +65,3 @@ This project is licensed under the MIT License - see the LICENSE file for detail
 
 ## Author
 Created and maintained by **Vineeth Penugonda**.
-

{stepfunction-0.0.1 → stepfunction-0.0.3}/README.md

@@ -44,4 +44,3 @@ This project is licensed under the MIT License - see the LICENSE file for detail
 
 ## Author
 Created and maintained by **Vineeth Penugonda**.
-

{stepfunction-0.0.1 → stepfunction-0.0.3}/pyproject.toml

@@ -1,18 +1,18 @@
 [project]
 name = "stepfunction"
-version = "0.0.1"
+version = "0.0.3"
 authors = [{ name = "Vineeth Penugonda" }]
 description = "Step Function Workflow Orchestration Library"
 readme = "README.md"
 keywords = ["StepFunction", "Workflow", "Orchestration", "Library"]
-requires-python = ">=3.12"
+requires-python = ">=3.9"
 dependencies = ["graphviz === 0.20.3"]
+license = "MIT"
 classifiers = [
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.9",
     "Operating System :: OS Independent",
     "Development Status :: 3 - Alpha",
-    "License :: OSI Approved :: MIT License",
     "Topic :: Software Development :: Libraries"
 ]
 
@@ -20,6 +20,10 @@ classifiers = [
 requires = ["setuptools>=61.0"]
 build-backend = "setuptools.build_meta"
 
+[tool.ruff.lint]
+select = ["E", "F", "I"]
+ignore = ["E501"]
+
 [tool.setuptools.packages.find]
 where = ["src"]
 include = ["stepfunction.*"]

{stepfunction-0.0.1 → stepfunction-0.0.3/src/StepFunction.egg-info}/PKG-INFO

@@ -1,22 +1,23 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: stepfunction
-Version: 0.0.1
+Version: 0.0.3
 Summary: Step Function Workflow Orchestration Library
 Author: Vineeth Penugonda
+License-Expression: MIT
 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: Programming Language :: Python :: 3.9
 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
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: graphviz===0.20.3
+Dynamic: license-file
 
 # StepFunction
 
@@ -64,4 +65,3 @@ This project is licensed under the MIT License - see the LICENSE file for detail
 
 ## Author
 Created and maintained by **Vineeth Penugonda**.
-

{stepfunction-0.0.1 → stepfunction-0.0.3}/src/stepfunction/constants/visualizer.py

@@ -44,4 +44,4 @@ 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."""
+""" str: The default node style for sub-step functions in the visualizer."""

{stepfunction-0.0.1 → stepfunction-0.0.3}/src/stepfunction/core/step_function/__init__.py

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

{stepfunction-0.0.1 → stepfunction-0.0.3}/src/stepfunction/core/step_function/step_function.py

@@ -1,17 +1,18 @@
-""" Module to define the StepFunction class. 
+"""Module to define the StepFunction class.
 
-    Author: Vineeth Penugonda
+Author: Vineeth Penugonda
 """
 
-
+from asyncio import run as asyncio_run
 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.exceptions.step_errors import (
+    ParallelStepExecutionError,
+    StepExecutionError,
+)
 from stepfunction.types.step_types import StepParams
 from stepfunction.utils.logger import setup_logger
 
@@ -91,7 +92,7 @@ class StepFunction:
     Parallel Example:
         step_function.add_step("Step1", func1, parallel=True)
         step_function.add_step("ParallelStep", {
-            "task1": func2, 
+            "task1": func2,
             "task2": func3
         }, next_step="Step2", parallel=True)
 
@@ -103,7 +104,7 @@ class StepFunction:
 
     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
@@ -120,7 +121,8 @@ class StepFunction:
         self.__logger = setup_logger(__name__)
 
         self.__logger.debug(
-            f"StepFunction - {self.__name} - Status - {self.__status.value}")
+            f"StepFunction - {self.__name} - Status - {self.__status.value}"
+        )
 
     def add_step(
         self,
@@ -146,7 +148,13 @@ class StepFunction:
             "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):
+    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:
@@ -168,7 +176,7 @@ class StepFunction:
             "branch": None,
             "parallel": False,
             "stop_on_failure": False,
-            "is_sub_step_function": True
+            "is_sub_step_function": True,
         }
 
     def set_start_step(self, name: str):
@@ -184,7 +192,8 @@ class StepFunction:
         self.__status = StepFunctionStatus.RUNNING
 
         self.__logger.debug(
-            f"StepFunction - {self.__name} - Status - {self.__status.value}")
+            f"StepFunction - {self.__name} - Status - {self.__status.value}"
+        )
 
         self.__last_result = initial_input
 
@@ -193,14 +202,14 @@ class StepFunction:
             try:
                 if step["parallel"]:
                     results = self._execute_parallel(
-                        step["func"], step["stop_on_failure"])
+                        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}"
+                        f"Parallel step '{self.__current_step}' succeeded with results: {results}"
                     )
                 else:
                     result = await self._execute_step(step["func"], self.__last_result)
@@ -208,14 +217,17 @@ class StepFunction:
                     self.__last_result = result
                     self.__context[self.__current_step] = result
 
-                    self.__logger.info(
-                        f"Step '{self.__current_step}' succeeded"
-                    )
+                    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"]
+                next_step = None
+
+                if step["branch"]:
+                    if callable(step["branch"]):
+                        next_step = step["branch"](self.__last_result)
+                    else:
+                        next_step = step["branch"].get(self.__last_result)
+
+                self.__current_step = next_step or step["next_step"]
 
             except Exception as exc:
                 self.__logger.exception(
@@ -226,8 +238,7 @@ class StepFunction:
 
                 if step["on_failure"]:
                     self.__logger.exception(
-                        f"Executing failure step: {
-                            step['on_failure']} for '{self.__current_step}'"
+                        f"Executing failure step: {step['on_failure']} for '{self.__current_step}'"
                     )
 
                     self.__current_step = step["on_failure"]
@@ -236,17 +247,18 @@ class StepFunction:
                     self.__status = StepFunctionStatus.FAILED
 
                     self.__logger.debug(
-                        f"StepFunction - {self.__name} - Status - {self.__status.value}")
+                        f"StepFunction - {self.__name} - Status - {self.__status.value}"
+                    )
                 else:
                     self.__logger.exception(
-                        f"No failure step defined for '{
-                            self.__current_step}'. Raising 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}")
+                        f"StepFunction - {self.__name} - Status - {self.__status.value}"
+                    )
 
                     raise StepExecutionError(exc)
 
@@ -256,24 +268,34 @@ class StepFunction:
                 self.__status = StepFunctionStatus.COMPLETED
 
                 self.__logger.debug(
-                    f"StepFunction - {self.__name} - Status - {self.__status.value}")
+                    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. """
+        """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):
+    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
 
+        def _run(func, arg):
+            if iscoroutinefunction(func):
+                return asyncio_run(func(arg))
+            return func(arg)
+
         with ThreadPoolExecutor() as executor:
-            futures = {executor.submit(
-                func, self.__last_result): step_name for step_name, func in func_dict.items()}
+            futures = {
+                executor.submit(_run, func, self.__last_result): step_name
+                for step_name, func in func_dict.items()
+            }
 
             for future in as_completed(futures):
                 step_name = futures[future]
@@ -286,7 +308,8 @@ class StepFunction:
                     results[step_name] = result
                 except Exception as exc:
                     self.__logger.exception(
-                        f"Parallel task '{step_name}' failed: {exc}")
+                        f"Parallel task '{step_name}' failed: {exc}"
+                    )
 
                     results[step_name] = exc.args[0]
 
@@ -294,6 +317,8 @@ class StepFunction:
 
                     if stop_on_failure:
                         should_stop_execution = True
+                        for f in futures:
+                            f.cancel()
 
         if errors:
             self.__logger.error(f"Some parallel tasks failed: {errors}")
@@ -306,6 +331,8 @@ class StepFunction:
 
     def visualize(self):
         """Visualize the workflow."""
+        from stepfunction.core.visualizer import Visualizer
+
         visualizer = Visualizer(self.__name, self.__steps)
 
         self.__logger.debug("Visualizing the step function")
@@ -318,11 +345,12 @@ class StepFunction:
 
         output_file_name = visualizer.output_file_name
 
-        self.__logger.debug(f"Rendered the step function to file: {
-            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."""
+        from stepfunction.core.visualizer import Visualizer
+
         visualizer = Visualizer(self.__name, self.__steps)
 
         self.__logger.debug("Visualizing the step function")
@@ -333,32 +361,27 @@ class StepFunction:
 
     @property
     def name(self):
-        """ Returns the name of the step function. 
-        """
+        """Returns the name of the step function."""
         return self.__name
 
     @property
     def steps(self):
-        """ Returns the steps of the step function. 
-        """
+        """Returns the steps of the step function."""
         return self.__steps
 
     @property
     def last_result(self):
-        """ Returns the result of the last step.
-        """
+        """Returns the result of the last step."""
         return self.__last_result
 
     @property
     def context(self):
-        """ Returns the context of the step function.
-        """
+        """Returns the context of the step function."""
         return self.__context
 
     @property
     def status(self):
-        """ Returns the status of the step function.
-        """
+        """Returns the status of the step function."""
         return self.__status
 
     def __str__(self):

{stepfunction-0.0.1 → stepfunction-0.0.3}/src/stepfunction/core/visualizer/__init__.py

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

stepfunction-0.0.3/src/stepfunction/core/visualizer/visualizer.py

@@ -0,0 +1,148 @@
+"""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-0.0.1 → stepfunction-0.0.3}/src/stepfunction/types/step_types.py

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

{stepfunction-0.0.1 → stepfunction-0.0.3}/src/stepfunction/types/visualizer_types.py

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

{stepfunction-0.0.1 → stepfunction-0.0.3}/src/stepfunction/utils/constants.py

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

{stepfunction-0.0.1 → stepfunction-0.0.3}/src/stepfunction/utils/logger.py

@@ -1,22 +1,28 @@
-""" Module for setting up loggers. """
+"""Module for setting up loggers."""
 
 import logging
 import logging.config
+from typing import Optional
 
-from stepfunction.utils.constants import (DEFAULT_LOG_LEVEL,
-                                          DEFAULT_LOGGING_FORMAT,
-                                          ENVIRONMENT_VARIABLE_LOG_LEVEL)
+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:
+def setup_logger(
+    name: Optional[str] = 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)
+        ENVIRONMENT_VARIABLE_LOG_LEVEL, DEFAULT_LOG_LEVEL
+    )
 
     logging_config = {
         "version": 1,
@@ -42,7 +48,6 @@ def setup_logger(name: str | None = None, log_format: str = DEFAULT_LOGGING_FORM
                 "handlers": ["console"],
                 "propagate": False,
             },
-
             "botocore": {
                 "level": "WARNING",  # Set level to WARNING to ignore DEBUG logs
                 "handlers": ["console"],

stepfunction-0.0.3/src/stepfunction/utils/utils.py

@@ -0,0 +1,18 @@
+"""This module contains utility functions for the stepfunction package."""
+
+from os import getenv
+from typing import Optional
+
+
+def get_environment_variable(name: str, default: Optional[str] = None) -> Optional[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/src/stepfunction/core/visualizer/visualizer.py

@@ -1,129 +0,0 @@
-""" 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-0.0.1/src/stepfunction/utils/utils.py

@@ -1,17 +0,0 @@
-""" 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)