stepfunction 0.0.7__py3-none-any.whl → 0.1.0__py3-none-any.whl

stepfunction/constants/visualizer.py

@@ -2,14 +2,11 @@
 
 # Render Configuration
 
-DEFAULT_VISUALIZER_EXTENSION = "gv"
-"""str: The default extension for the visualizer renderer."""
+DEFAULT_VISUALIZER_DIRECTION = "TD"
+"""str: The default flowchart direction for the Mermaid visualizer (e.g. TD, LR)."""
 
-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_EXTENSION = "mmd"
+"""str: The default file extension for the visualizer renderer output."""
 
 DEFAULT_VISUALIZER_FOLDER = "workflow_renders"
 """str: The default folder where visualizer renders are stored."""
@@ -22,26 +19,30 @@ DEFAULT_VISUALIZER_STRING_ENCODING = "utf-8"
 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_BRANCH_EDGE_LABEL_PREFIX = "Branch"
+"""str: The default edge label prefix for branch transitions in the visualizer."""
+
+DEFAULT_VISUALIZER_BRANCH_DEFAULT_LABEL = "else"
+"""str: The label used for an unconditional (fallback) branch return."""
+
+DEFAULT_VISUALIZER_MAX_BRANCH_LABEL_LENGTH = 60
+"""int: The maximum length of a branch condition label before it's truncated."""
+
+# Node styling (Mermaid classDef names)
 
-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_CLASS = "subStepFunction"
+"""str: The Mermaid classDef name applied to sub-step function nodes."""
 
-DEFAULT_VISUALIZER_SUB_STEP_FUNCTION_NODE_STYLE = "dotted"
-""" str: The default node style for sub-step functions in the visualizer."""
+DEFAULT_VISUALIZER_SUB_STEP_FUNCTION_CLASS_STYLE = (
+    "fill:#f5f5f5,stroke:#333,stroke-dasharray: 5 5"
+)
+"""str: The Mermaid classDef style applied to sub-step function nodes."""

stepfunction/core/step_function/step_function.py

@@ -5,7 +5,7 @@ Author: Vineeth Penugonda
 
 from asyncio import gather, get_running_loop
 from inspect import iscoroutinefunction
-from typing import Any, Callable, Dict, Optional, Union, cast
+from typing import Any, Callable, Dict, List, Optional, Union, cast
 
 from stepfunction.constants.enums import StepFunctionStatus
 from stepfunction.exceptions.step_errors import (
@@ -165,6 +165,7 @@ class StepFunction:
             "stop_on_failure": stop_on_failure,
             "is_sub_step_function": False,
             "step_type": step_type,
+            "sub_step_function": None,
         }
 
     def add_sub_step_function(
@@ -197,6 +198,7 @@ class StepFunction:
             "stop_on_failure": False,
             "is_sub_step_function": True,
             "step_type": None,
+            "sub_step_function": sub_step_function,
         }
 
     def set_start_step(self, name: str):
@@ -208,24 +210,46 @@ class StepFunction:
 
     def validate(self):
         """Validate the workflow configuration before execution."""
+        self._validate(path=[self.__name])
+
+    def _validate(self, path: List[str]):
+        """Validate this step function, recursing into sub-step functions.
+
+        ``path`` tracks the chain of step-function names from the outermost
+        workflow down to this one, so a failure several sub-step functions
+        deep is reported as a single readable breadcrumb (e.g.
+        "FLOW -> SUB_FLOW_3 -> SUB_FLOW_4") instead of a wall of nested
+        "invalid sub-step function" messages.
+        """
+
+        def _fail(message: str) -> None:
+            location = " -> ".join(path)
+            raise ValueError(f"[{location}] {message}")
 
         if self.__current_step is None:
-            raise ValueError(
+            _fail(
                 "No start step set. Call set_start_step() before executing the workflow."
             )
 
         for step_name, step in self.__steps.items():
             if step["next_step"] is not None and step["next_step"] not in self.__steps:
-                raise ValueError(
+                _fail(
                     f"Step '{step_name}' has unknown next_step '{step['next_step']}'."
                 )
             if (
                 step["on_failure"] is not None
                 and step["on_failure"] not in self.__steps
             ):
-                raise ValueError(
+                _fail(
                     f"Step '{step_name}' has unknown on_failure '{step['on_failure']}'."
                 )
+            if step["is_sub_step_function"]:
+                sub_step_function = cast("StepFunction", step["sub_step_function"])
+                sub_step_function._validate(
+                    path=path + [f"{step_name} ({sub_step_function.name})"]
+                    if step_name != sub_step_function.name
+                    else path + [step_name]
+                )
 
     async def execute(self, initial_input: Any = None):
         """Execute the workflow."""
@@ -376,6 +400,8 @@ class StepFunction:
         """Visualize the workflow."""
         from stepfunction.core.visualizer import Visualizer
 
+        self.validate()
+
         visualizer = Visualizer(self.__name, self.__steps)
 
         self.__logger.debug("Visualizing the step function")
@@ -394,6 +420,8 @@ class StepFunction:
         """Visualize the workflow as a string."""
         from stepfunction.core.visualizer import Visualizer
 
+        self.validate()
+
         visualizer = Visualizer(self.__name, self.__steps)
 
         self.__logger.debug("Visualizing the step function")

stepfunction/core/visualizer/visualizer.py

@@ -3,32 +3,166 @@
 Author: Vineeth Penugonda
 """
 
-from os import getcwd
-from typing import Dict, Optional
-
-from graphviz import Digraph
+from ast import (
+    AST,
+    AsyncFunctionDef,
+    Constant,
+    FunctionDef,
+    If,
+    Lambda,
+    Return,
+    iter_child_nodes,
+    parse,
+    unparse,
+    walk,
+)
+from inspect import getsource
+from os import getcwd, makedirs
+from re import sub as re_sub
+from textwrap import dedent
+from typing import Any, Callable, Dict, List, Mapping, Optional, Set, Tuple, cast
 
 from stepfunction.constants.visualizer import (
+    DEFAULT_VISUALIZER_BRANCH_DEFAULT_LABEL,
+    DEFAULT_VISUALIZER_BRANCH_EDGE_LABEL_PREFIX,
+    DEFAULT_VISUALIZER_DIRECTION,
     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_MAX_BRANCH_LABEL_LENGTH,
     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_SUB_STEP_FUNCTION_CLASS,
+    DEFAULT_VISUALIZER_SUB_STEP_FUNCTION_CLASS_STYLE,
     DEFAULT_VISUALIZER_SUCCESS_EDGE_LABEL,
 )
 from stepfunction.types.step_types import StepParams
-from stepfunction.types.visualizer_types import RenderStepFunctionParams
+
+_INVALID_NODE_ID_CHARS = r"[^0-9A-Za-z_]"
+
+
+def _quote(label: str) -> str:
+    """Escape and quote a string for use as a Mermaid edge label."""
+
+    escaped = label.replace('"', "'").replace("|", "/")
+    return f'"{escaped}"'
+
+
+def _truncate(
+    label: str, max_length: int = DEFAULT_VISUALIZER_MAX_BRANCH_LABEL_LENGTH
+) -> str:
+    """Truncate a label to a maximum length, preserving readability."""
+
+    if len(label) <= max_length:
+        return label
+
+    return f"{label[: max_length - 3]}..."
+
+
+def _extract_callable_branch_edges(
+    branch_func: Callable[[Any], Optional[str]], known_steps: Set[str]
+) -> List[Tuple[str, Optional[str]]]:
+    """Statically inspects a branch callable's source for ``return "<step_name>"``
+    statements, pairing each target with the nearest enclosing ``if``/``else``
+    condition.
+
+    Router callables in this library are plain functions that inspect the prior
+    step's result and return the name of the next step. Since the callable isn't
+    executed at visualization time, the runtime outcome can't be known - but most
+    routers are simple if/elif/return chains, so a light AST scan recovers a
+    faithful approximation of the possible branches without executing the
+    callable. Falls back to no edges if the source isn't available or isn't a
+    recognizable if/return shape, rather than guessing.
+
+    Returns a list of ``(target_step, condition_label)`` tuples, where
+    ``condition_label`` is ``None`` for an unconditional/fallback return.
+    """
+
+    try:
+        source = dedent(getsource(branch_func))
+        tree = parse(source)
+    except (OSError, TypeError, SyntaxError):
+        return []
+
+    func_node = next(
+        (
+            node
+            for node in walk(tree)
+            if isinstance(node, (FunctionDef, AsyncFunctionDef))
+        ),
+        None,
+    )
+    if func_node is None:
+        return []
+
+    # Map each node in the function body to the nearest enclosing `if` *and*
+    # which side of it the node is on (the `test` body vs. the `else`/`elif`
+    # body) - a plain `if/else` shares one `If` node for both branches, so
+    # without tracking the side, a return in the `else` would be mislabeled
+    # with the same (un-negated) condition as the `if` branch.
+    branch_context: Dict[AST, Optional[Tuple[If, bool]]] = {}
+
+    def _walk(node: AST, current_branch: Optional[Tuple[If, bool]]) -> None:
+        if isinstance(node, If):
+            branch_context[node] = current_branch
+
+            for child in node.body:
+                branch_context[child] = (node, True)
+                _walk(child, (node, True))
+
+            for child in node.orelse:
+                branch_context[child] = (node, False)
+                _walk(child, (node, False))
+
+            return
+
+        for child in iter_child_nodes(node):
+            if isinstance(child, (FunctionDef, AsyncFunctionDef, Lambda)):
+                continue
+
+            branch_context[child] = current_branch
+            _walk(child, current_branch)
+
+    _walk(func_node, None)
+
+    edges: List[Tuple[str, Optional[str]]] = []
+    seen: Set[Tuple[str, Optional[str]]] = set()
+
+    for node in walk(func_node):
+        if not isinstance(node, Return) or node.value is None:
+            continue
+
+        value = node.value
+        if not (isinstance(value, Constant) and isinstance(value.value, str)):
+            continue
+
+        target = value.value
+        if target not in known_steps:
+            continue
+
+        context = branch_context.get(node)
+        label = None
+        if context is not None:
+            enclosing_if, is_true_branch = context
+            try:
+                condition = unparse(enclosing_if.test)
+                label = condition if is_true_branch else f"not ({condition})"
+            except Exception:
+                label = None
+
+        key = (target, label)
+        if key in seen:
+            continue
+
+        seen.add(key)
+        edges.append((target, label))
+
+    return edges
 
 
 class Visualizer:
-    """This class is responsible for visualizing the graph model."""
+    """This class is responsible for visualizing the graph model as a Mermaid flowchart."""
 
     def __init__(self, graph_name: str, steps: Optional[Dict[str, StepParams]] = None):
         """Initializes the visualizer."""
@@ -39,101 +173,192 @@ class Visualizer:
         self.__output_file_name = None
         self.__output_file_path = None
 
-        self.__dot = Digraph(comment=self.graph_name)
+        self.__node_lines: List[str] = []
+        self.__edge_lines: List[str] = []
+        self.__link_styles: List[str] = []
+        self.__sub_step_function_nodes: Set[str] = set()
+        self.__node_ids: Dict[str, str] = {}
 
     def visualize_step_function(self):
-        """Visualizes the graph model."""
+        """Builds the Mermaid flowchart definition from the step function's steps."""
 
         if not self.__steps:
             raise ValueError("No steps found to visualize.")
 
+        known_steps = set(self.__steps.keys())
+
         for step_name, step_info in self.__steps.items():
-            if 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)
+            self.__add_node(step_name, step_info)
 
             if step_info["next_step"]:
-                self.__dot.edge(
+                self.__add_edge(
                     step_name,
                     step_info["next_step"],
-                    label=DEFAULT_VISUALIZER_SUCCESS_EDGE_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,
-                )
+                    self.__add_edge(
+                        step_name,
+                        step_info["on_failure"],
+                        DEFAULT_VISUALIZER_STOP_ON_FAILURE_EDGE_LABEL,
+                        dashed=True,
+                        color=DEFAULT_VISUALIZER_STOP_ON_FAILURE_EDGE_COLOR,
+                    )
+                else:
+                    self.__add_edge(
+                        step_name,
+                        step_info["on_failure"],
+                        DEFAULT_VISUALIZER_FAILURE_EDGE_LABEL,
+                        dashed=True,
+                    )
 
             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"])
+                parallel_function_names = cast(
+                    Dict[str, Callable[[Any], Any]], step_info["func"]
+                )
 
-            if isinstance(step_info["branch"], dict):
-                for result, next_step in step_info["branch"].items():
-                    self.__dot.edge(step_name, next_step, label=f"Branch: {result}")
+                for parallel_step_name in parallel_function_names:
+                    self.__add_node(parallel_step_name, {})
+                    self.__add_edge(step_name, parallel_step_name, dashed=True)
+
+                    if step_info["next_step"]:
+                        self.__add_edge(parallel_step_name, step_info["next_step"])
+
+            branch = step_info["branch"]
+            if isinstance(branch, dict):
+                for result, next_step in branch.items():
+                    self.__add_edge(
+                        step_name,
+                        next_step,
+                        f"{DEFAULT_VISUALIZER_BRANCH_EDGE_LABEL_PREFIX}: {result}",
+                    )
+            elif callable(branch):
+                for target, condition in _extract_callable_branch_edges(
+                    branch, known_steps
+                ):
+                    label_suffix = condition or DEFAULT_VISUALIZER_BRANCH_DEFAULT_LABEL
+                    label = (
+                        f"{DEFAULT_VISUALIZER_BRANCH_EDGE_LABEL_PREFIX}: "
+                        f"{_truncate(label_suffix)}"
+                    )
+                    self.__add_edge(step_name, target, label)
+
+    def __node_id(self, step_name: str) -> str:
+        """Maps a step name to a Mermaid-safe node ID.
+
+        Step names are free text and may contain spaces or other characters
+        that Mermaid doesn't allow in a bare node ID (only the bracketed label
+        accepts arbitrary text). The original name is preserved as the node's
+        label; this only affects the identifier used to reference the node in
+        edges. Cached so the same step name always resolves to the same ID,
+        and disambiguated on collision (e.g. "First Step" and "First_Step"
+        would otherwise both sanitize to "First_Step").
+        """
+
+        if step_name in self.__node_ids:
+            return self.__node_ids[step_name]
+
+        sanitized = re_sub(_INVALID_NODE_ID_CHARS, "_", step_name) or "step"
+        if sanitized[0].isdigit():
+            sanitized = f"_{sanitized}"
+
+        existing_ids = set(self.__node_ids.values())
+        candidate = sanitized
+        suffix = 2
+        while candidate in existing_ids:
+            candidate = f"{sanitized}_{suffix}"
+            suffix += 1
+
+        self.__node_ids[step_name] = candidate
+        return candidate
+
+    def __add_node(self, step_name: str, step_info: Mapping[str, Any]) -> None:
+        node_id = self.__node_id(step_name)
+
+        if step_info.get("is_sub_step_function"):
+            self.__node_lines.append(f"{node_id}([{_quote(step_name)}])")
+            self.__sub_step_function_nodes.add(node_id)
+        else:
+            self.__node_lines.append(f"{node_id}[{_quote(step_name)}]")
+
+    def __add_edge(
+        self,
+        source: str,
+        target: str,
+        label: Optional[str] = None,
+        dashed: bool = False,
+        color: Optional[str] = None,
+    ) -> None:
+        arrow = "-.->" if dashed else "-->"
+        source_id = self.__node_id(source)
+        target_id = self.__node_id(target)
+
+        if label:
+            self.__edge_lines.append(
+                f"{source_id} {arrow}|{_quote(label)}| {target_id}"
+            )
+        else:
+            self.__edge_lines.append(f"{source_id} {arrow} {target_id}")
+
+        if color:
+            edge_index = len(self.__edge_lines) - 1
+            self.__link_styles.append(f"linkStyle {edge_index} stroke:{color}")
+
+    def __build_mermaid(self, direction: str) -> str:
+        lines = [f"flowchart {direction}"]
+
+        lines.extend(f"    {line}" for line in self.__node_lines)
+        lines.extend(f"    {line}" for line in self.__edge_lines)
+        lines.extend(f"    {line}" for line in self.__link_styles)
+
+        if self.__sub_step_function_nodes:
+            lines.append(
+                f"    classDef {DEFAULT_VISUALIZER_SUB_STEP_FUNCTION_CLASS} "
+                f"{DEFAULT_VISUALIZER_SUB_STEP_FUNCTION_CLASS_STYLE}"
+            )
+            node_list = ",".join(sorted(self.__sub_step_function_nodes))
+            lines.append(
+                f"    class {node_list} {DEFAULT_VISUALIZER_SUB_STEP_FUNCTION_CLASS}"
+            )
+
+        return "\n".join(lines) + "\n"
+
+    def render_step_function(
+        self,
+        *,
+        file_path: Optional[str] = None,
+        file_name: Optional[str] = None,
+        direction: str = DEFAULT_VISUALIZER_DIRECTION,
+    ) -> None:
+        """Writes the Mermaid flowchart definition to a .mmd file."""
 
-    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}"
+        resolved_file_path = file_path or f"{current_dir}/{DEFAULT_VISUALIZER_FOLDER}"
+        resolved_file_name = (
+            file_name or f"{self.graph_name}.{DEFAULT_VISUALIZER_EXTENSION}"
         )
 
-        self.__output_file_path = file_path
-        self.__output_file_name = file_name
+        self.__output_file_path = resolved_file_path
+        self.__output_file_name = resolved_file_name
 
-        self.__dot.render(
-            filename=f"{self.__output_file_path}/{self.__output_file_name}",
-            format=format,
-            renderer=renderer,
-        )
+        makedirs(resolved_file_path, exist_ok=True)
 
-    def render_step_function_to_string(self, **kwargs: RenderStepFunctionParams):
-        """Renders the graph model as a string."""
+        output_file = f"{resolved_file_path}/{resolved_file_name}"
+        with open(
+            output_file, "w", encoding=DEFAULT_VISUALIZER_STRING_ENCODING
+        ) as handle:
+            handle.write(self.__build_mermaid(direction))
 
-        format = kwargs.get("format", DEFAULT_VISUALIZER_FORMAT)
-        renderer = kwargs.get("renderer", DEFAULT_VISUALIZER_RENDERER)
+    def render_step_function_to_string(
+        self, *, direction: str = DEFAULT_VISUALIZER_DIRECTION
+    ) -> str:
+        """Renders the Mermaid flowchart definition as a string."""
 
-        return self.__dot.pipe(format=format, renderer=renderer).decode(
-            DEFAULT_VISUALIZER_STRING_ENCODING
-        )
+        return self.__build_mermaid(direction)
 
     @property
     def output_file_name(self):

stepfunction/types/step_types.py

@@ -1,7 +1,10 @@
-from typing import Any, Callable, Dict, Optional, TypedDict, Union
+from typing import TYPE_CHECKING, Any, Callable, Dict, Optional, TypedDict, Union
 
 from stepfunction.constants.enums import StepType
 
+if TYPE_CHECKING:
+    from stepfunction.core.step_function.step_function import StepFunction
+
 
 class StepParams(TypedDict):
     func: Union[Callable[[Any], Any], Dict[str, Callable[[Any], Any]]]
@@ -12,3 +15,4 @@ class StepParams(TypedDict):
     stop_on_failure: bool
     is_sub_step_function: bool
     step_type: Optional[StepType]
+    sub_step_function: Optional["StepFunction"]

{stepfunction-0.0.7.dist-info → stepfunction-0.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stepfunction
-Version: 0.0.7
+Version: 0.1.0
 Summary: Step Function Workflow Orchestration Library
 Author: Vineeth Penugonda
 License-Expression: MIT
@@ -16,7 +16,6 @@ Classifier: Topic :: Software Development :: Libraries
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: graphviz===0.20.3
 Dynamic: license-file
 
 # StepFunction
@@ -33,7 +32,7 @@ Dynamic: license-file
 - **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.
+- **Visualization**: Integrated support for visualizing the workflow graph as a Mermaid flowchart.
 
 ## Installation
 
@@ -49,11 +48,7 @@ For more detailed usage examples and advanced use cases, please read the [blog p
 
 ## Dependencies
 
-The StepFunction package requires the following dependencies:
-
-- `graphviz == 0.20.3`
-
-These will be automatically installed when you install the package via pip.
+The StepFunction package has no required runtime dependencies. Workflow visualization renders directly to [Mermaid](https://mermaid.js.org/) flowchart syntax (`.mmd`), which can be previewed in VS Code, GitHub/Bitbucket markdown, or https://mermaid.live without any additional tooling.
 
 ## Contributing
 

{stepfunction-0.0.7.dist-info → stepfunction-0.1.0.dist-info}/RECORD

@@ -1,10 +1,10 @@
 stepfunction/constants/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 stepfunction/constants/enums.py,sha256=K4_xKGa0NApw6Ai4VkfGW1Sc5fEqwFPpuyezy6YexzY,240
-stepfunction/constants/visualizer.py,sha256=9KEtxlwGuFI9NGxM6jNb9NMqnhSYUwsomspQNtl-C0M,1764
+stepfunction/constants/visualizer.py,sha256=impswU0JpqgpzTu4_a26FVLK4tII4ptbUaopFb2ZObM,1815
 stepfunction/core/step_function/__init__.py,sha256=4L5ufP13A7hXBDBYrD45pfEsV9bsa6zbSkSnHpi-tyM,68
-stepfunction/core/step_function/step_function.py,sha256=eWCe-aocFShuXrYahQP5K0K9AAC6OHX0NRztCt4TX4M,16536
+stepfunction/core/step_function/step_function.py,sha256=qPfHSEP1LFLR6_hRVxxD6duALaDcTkIRWO_HrdYAg7s,17666
 stepfunction/core/visualizer/__init__.py,sha256=pgNI6LPnY9Pm9e_YhMn-5CVmUzp8mvoytbDZ_b3McSw,61
-stepfunction/core/visualizer/visualizer.py,sha256=u2oUZdImZBg91U5GiP3h2kZzY9XGs_o2xxq2eYQgc98,5256
+stepfunction/core/visualizer/visualizer.py,sha256=XM-kSoIPha-rYM2T-ZYYoo6-ttcnodn-832MX9Gg6d0,12892
 stepfunction/exceptions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 stepfunction/exceptions/step_errors.py,sha256=yNJt6tiO8LkiSxeHoSZBpaKA7qkqdsXPnOd3AMt3C8A,486
 stepfunction/steps/__init__.py,sha256=DvzYMJiMY-5O2tWhCa82LSbqIa80VXfUuLgFYyAOdi8,256
@@ -16,14 +16,13 @@ stepfunction/steps/base/base_step.py,sha256=Gf4NHE63n-zQigK5xATH7DEcm_pBRxivxkT0
 stepfunction/steps/exceptions/__init__.py,sha256=s72aRyWdZjdSiTj4wq5rpoCIpzgQprN9uMgehK5D01U,78
 stepfunction/steps/exceptions/step_exceptions.py,sha256=oulQdYDOLltImzfSLsZa14jLImBjwJecGpT7Q9sxgYk,282
 stepfunction/types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-stepfunction/types/step_types.py,sha256=j4XqT5sXM7VIDwT9H6gFXBLn7jJ5CqPIE_P68dUo_nA,465
-stepfunction/types/visualizer_types.py,sha256=vkL25eWSTFJ89DbnowraZ_7IJIEuM1y7_udYFu29fYU,189
+stepfunction/types/step_types.py,sha256=pMA8xY_a3yNmpDul8BBqa-0_Fpp3QNIMFpxAgn_tUAA,622
 stepfunction/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 stepfunction/utils/constants.py,sha256=VZefE-OhNXOyg28wPu62VZPvReublyqWS515-TbYWo0,391
 stepfunction/utils/logger.py,sha256=0L8F8oO5HiYNqcuV8G8UD4cTdCpmObQYrkvwvrF1S-8,1789
 stepfunction/utils/utils.py,sha256=Zw9-sKE2LOghxyiKImqGWSv4nHZ9nI8yEptp1xaYfHk,563
-stepfunction-0.0.7.dist-info/licenses/LICENSE,sha256=sLQZUABreUtT56S4w592eAmWiFONtLKZG-KZWf-_dvg,1074
-stepfunction-0.0.7.dist-info/METADATA,sha256=rqge2fKFh9fa-PHg3MdiV9l0ixzucqcH4AlICpDrrS8,2723
-stepfunction-0.0.7.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-stepfunction-0.0.7.dist-info/top_level.txt,sha256=XqLJSUeYSmzTNMiPj-IESxp1om-LdZjefT4Un2orQD4,13
-stepfunction-0.0.7.dist-info/RECORD,,
+stepfunction-0.1.0.dist-info/licenses/LICENSE,sha256=sLQZUABreUtT56S4w592eAmWiFONtLKZG-KZWf-_dvg,1074
+stepfunction-0.1.0.dist-info/METADATA,sha256=QG6O4Dkz66awYt9zyBhTBKwYbBFWmQQ4VWBuQyrr3rw,2836
+stepfunction-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+stepfunction-0.1.0.dist-info/top_level.txt,sha256=XqLJSUeYSmzTNMiPj-IESxp1om-LdZjefT4Un2orQD4,13
+stepfunction-0.1.0.dist-info/RECORD,,

stepfunction/types/visualizer_types.py

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