Flowfile 0.5.1__py3-none-any.whl → 0.5.3__py3-none-any.whl

flowfile_core/flowfile/flow_node/models.py

@@ -1,15 +1,15 @@
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Literal
 
 import pyarrow as pa
-from typing import List, Union, Callable, Optional, Literal
-from dataclasses import dataclass
 
 # Forward declaration for type hints to avoid circular imports
 if False:
     from flowfile_core.flowfile.flow_node.flow_node import FlowNode
 
-from flowfile_core.flowfile.flow_data_engine.flow_file_column.main import FlowfileColumn
 from flowfile_core.flowfile.flow_data_engine.flow_data_engine import FlowDataEngine
-from flowfile_core.schemas import schemas
+from flowfile_core.flowfile.flow_data_engine.flow_file_column.main import FlowfileColumn
 
 
 @dataclass
@@ -27,30 +27,35 @@ class NodeStepPromise:
         right_input: The ID of the node connected to the right input port.
         depends_on: A list of node IDs that this node depends on for main inputs.
     """
-    node_id: Union[str, int]
+
+    node_id: str | int
     name: str
     is_start: bool
-    leads_to_id: Optional[List[Union[str, int]]] = None
-    left_input: Optional[Union[str, int]] = None
-    right_input: Optional[Union[str, int]] = None
-    depends_on: Optional[List[Union[str, int]]] = None
+    leads_to_id: list[str | int] | None = None
+    left_input: str | int | None = None
+    right_input: str | int | None = None
+    depends_on: list[str | int] | None = None
 
 
 class NodeStepStats:
     """
     Tracks the execution status and statistics of a `FlowNode`.
     """
+
     error: str = None
     _has_run_with_current_setup: bool = False
     has_completed_last_run: bool = False
     active: bool = True
     is_canceled: bool = False
 
-    def __init__(self, error: str = None,
-                 has_run_with_current_setup: bool = False,
-                 has_completed_last_run: bool = False,
-                 active: bool = True,
-                 is_canceled: bool = False):
+    def __init__(
+        self,
+        error: str = None,
+        has_run_with_current_setup: bool = False,
+        has_completed_last_run: bool = False,
+        active: bool = True,
+        is_canceled: bool = False,
+    ):
         """
         Initializes the node's statistics.
 
@@ -71,9 +76,11 @@ class NodeStepStats:
         Provides a string representation of the node's stats.
         :return: A string detailing the current stats.
         """
-        return (f"NodeStepStats(error={self.error}, has_run_with_current_setup={self.has_run_with_current_setup}, "
-                f"has_completed_last_run={self.has_completed_last_run}, "
-                f"active={self.active}, is_canceled={self.is_canceled})")
+        return (
+            f"NodeStepStats(error={self.error}, has_run_with_current_setup={self.has_run_with_current_setup}, "
+            f"has_completed_last_run={self.has_completed_last_run}, "
+            f"active={self.active}, is_canceled={self.is_canceled})"
+        )
 
     @property
     def has_run_with_current_setup(self) -> bool:
@@ -109,6 +116,7 @@ class NodeStepSettings:
         setup_errors: If True, indicates a non-blocking error occurred during setup.
         breaking_setup_errors: If True, indicates an error occurred that prevents execution.
     """
+
     cache_results: bool = False
     renew_schema: bool = True
     streamable: bool = True
@@ -125,12 +133,13 @@ class NodeStepInputs:
         right_input: The `FlowNode` connected to the right input port.
         main_inputs: A list of `FlowNode` objects connected to the main input port(s).
     """
+
     left_input: "FlowNode" = None
     right_input: "FlowNode" = None
-    main_inputs: List["FlowNode"] = None
+    main_inputs: list["FlowNode"] = None
 
     @property
-    def input_ids(self) -> List[int]:
+    def input_ids(self) -> list[int]:
         """
         Gets the IDs of all connected input nodes.
         :return: A list of integer node IDs.
@@ -139,7 +148,7 @@ class NodeStepInputs:
             return [node_input.node_information.id for node_input in self.get_all_inputs()]
         return []
 
-    def get_all_inputs(self) -> List["FlowNode"]:
+    def get_all_inputs(self) -> list["FlowNode"]:
         """
         Retrieves a single list containing all input nodes (main, left, and right).
         :return: A list of all connected `FlowNode` objects.
@@ -157,8 +166,9 @@ class NodeStepInputs:
         main_inputs_repr = f"Main Inputs: {self.main_inputs}" if self.main_inputs else "Main Inputs: None"
         return f"{self.__class__.__name__}({left_repr}, {right_repr}, {main_inputs_repr})"
 
-    def validate_if_input_connection_exists(self, node_input_id: int,
-                                            connection_name: Literal['main', 'left', 'right']) -> bool:
+    def validate_if_input_connection_exists(
+        self, node_input_id: int, connection_name: Literal["main", "left", "right"]
+    ) -> bool:
         """
         Checks if a connection from a specific node ID exists on a given port.
 
@@ -166,11 +176,11 @@ class NodeStepInputs:
         :param connection_name: The name of the input port ('main', 'left', 'right').
         :return: True if the connection exists, False otherwise.
         """
-        if connection_name == 'main' and self.main_inputs:
+        if connection_name == "main" and self.main_inputs:
             return any(node_input.node_information.id == node_input_id for node_input in self.main_inputs)
-        if connection_name == 'left' and self.left_input:
+        if connection_name == "left" and self.left_input:
             return self.left_input.node_information.id == node_input_id
-        if connection_name == 'right':
+        if connection_name == "right":
             return self.right_input.node_information.id == node_input_id
 
 
@@ -185,25 +195,27 @@ class NodeSchemaInformation:
         drop_columns: A list of column names that will be dropped by the node.
         output_columns: A list of `FlowfileColumn` objects that will be added by the node.
     """
-    result_schema: Optional[List[FlowfileColumn]] = None
-    predicted_schema: Optional[List[FlowfileColumn]] = None
-    input_columns: List[str] = []
-    drop_columns: List[str] = []
-    output_columns: List[FlowfileColumn] = []
+
+    result_schema: list[FlowfileColumn] | None = None
+    predicted_schema: list[FlowfileColumn] | None = None
+    input_columns: list[str] = []
+    drop_columns: list[str] = []
+    output_columns: list[FlowfileColumn] = []
 
 
 class NodeResults:
     """
     Stores the outputs of a `FlowNode`'s execution, including data, errors, and metadata.
     """
-    _resulting_data: Optional[FlowDataEngine] = None
-    example_data: Optional[FlowDataEngine] = None
-    example_data_path: Optional[str] = None
-    example_data_generator: Optional[Callable[[], pa.Table]] = None
+
+    _resulting_data: FlowDataEngine | None = None
+    example_data: FlowDataEngine | None = None
+    example_data_path: str | None = None
+    example_data_generator: Callable[[], pa.Table] | None = None
     run_time: int = -1
-    errors: Optional[str] = None
-    warnings: Optional[str] = None
-    analysis_data_generator: Optional[Callable[[], pa.Table]] = None
+    errors: str | None = None
+    warnings: str | None = None
+    analysis_data_generator: Callable[[], pa.Table] | None = None
 
     def __init__(self):
         self._resulting_data = None
@@ -214,7 +226,7 @@ class NodeResults:
         self.example_data_generator = None
         self.analysis_data_generator = None
 
-    def get_example_data(self) -> Optional[pa.Table]:
+    def get_example_data(self) -> pa.Table | None:
         """
         Executes the generator to fetch a sample of the resulting data.
         :return: A PyArrow Table containing a sample of the data, or None.
@@ -223,7 +235,7 @@ class NodeResults:
             return self.example_data_generator()
 
     @property
-    def resulting_data(self) -> Optional[FlowDataEngine]:
+    def resulting_data(self) -> FlowDataEngine | None:
         """
         Gets the full resulting data from the node's execution.
         :return: A `FlowDataEngine` instance containing the result, or None.
@@ -231,7 +243,7 @@ class NodeResults:
         return self._resulting_data
 
     @resulting_data.setter
-    def resulting_data(self, d: Optional[FlowDataEngine]):
+    def resulting_data(self, d: FlowDataEngine | None):
         """
         Sets the resulting data.
         :param d: The `FlowDataEngine` instance to store.
@@ -241,4 +253,4 @@ class NodeResults:
     def reset(self):
         """Resets all result attributes to their default, empty state."""
         self._resulting_data = None
-        self.run_time = -1
+        self.run_time = -1

flowfile_core/flowfile/flow_node/schema_callback.py

@@ -1,9 +1,11 @@
-from typing import Callable, Any, Optional, Generic, TypeVar
-from concurrent.futures import ThreadPoolExecutor, Future
 import threading
+from collections.abc import Callable
+from concurrent.futures import Future, ThreadPoolExecutor
+from typing import Any, Generic, TypeVar
+
 from flowfile_core.configs import logger
 
-T = TypeVar('T')
+T = TypeVar("T")
 
 
 class SingleExecutionFuture(Generic[T]):
@@ -14,20 +16,16 @@ class SingleExecutionFuture(Generic[T]):
     """
 
     func: Callable[[], T]
-    on_error: Optional[Callable[[Exception], Any]]
+    on_error: Callable[[Exception], Any] | None
     _lock: threading.RLock
-    _executor: Optional[ThreadPoolExecutor]
-    _future: Optional[Future[T]]
-    _result_value: Optional[T]
-    _exception: Optional[Exception]
+    _executor: ThreadPoolExecutor | None
+    _future: Future[T] | None
+    _result_value: T | None
+    _exception: Exception | None
     _has_completed: bool
     _has_started: bool
 
-    def __init__(
-            self,
-            func: Callable[[], T],
-            on_error: Optional[Callable[[Exception], Any]] = None
-    ) -> None:
+    def __init__(self, func: Callable[[], T], on_error: Callable[[Exception], Any] | None = None) -> None:
         """Initialize with function and optional error handler."""
         self.func = func
         self.on_error = on_error
@@ -81,7 +79,7 @@ class SingleExecutionFuture(Generic[T]):
             if self._executor and not self._executor._shutdown:
                 self._executor.shutdown(wait=False)
 
-    def __call__(self) -> Optional[T]:
+    def __call__(self) -> T | None:
         """Execute function if not running and return its result."""
         with self._lock:
             # If already completed, return cached result or raise cached exception
@@ -137,10 +135,7 @@ class SingleExecutionFuture(Generic[T]):
         """Check if the function is currently executing."""
         with self._lock:
             return bool(
-                self._has_started and
-                not self._has_completed and
-                self._future is not None and
-                not self._future.done()
+                self._has_started and not self._has_completed and self._future is not None and not self._future.done()
             )
 
     def is_completed(self) -> bool:
@@ -148,7 +143,7 @@ class SingleExecutionFuture(Generic[T]):
         with self._lock:
             return self._has_completed
 
-    def get_result(self) -> Optional[T]:
+    def get_result(self) -> T | None:
         """Get the cached result without triggering execution."""
         with self._lock:
             if self._exception:

flowfile_core/flowfile/graph_tree/graph_tree.py

@@ -1,7 +1,4 @@
-from pydantic import BaseModel
-
 from flowfile_core.flowfile.flow_node.flow_node import FlowNode
-
 from flowfile_core.flowfile.graph_tree.models import BranchInfo, InputInfo
 
 
@@ -13,35 +10,39 @@ def calculate_depth(node_id: int, node_info: dict[int, BranchInfo], visited: set
     if node_id in visited:
         return node_info[node_id].depth
     visited.add(node_id)
-    
+
     max_input_depth = -1
     inputs = node_info[node_id].inputs
-    
+
     for main_id in inputs.main:
         max_input_depth = max(max_input_depth, calculate_depth(main_id, node_info, visited))
     if inputs.left:
         max_input_depth = max(max_input_depth, calculate_depth(inputs.left, node_info, visited))
     if inputs.right:
         max_input_depth = max(max_input_depth, calculate_depth(inputs.right, node_info, visited))
-    
+
     node_info[node_id].depth = max_input_depth + 1
     return node_info[node_id].depth
 
 
 # Trace paths from each root
-def trace_path(node_id: int, node_info: dict[int, BranchInfo], merge_points: dict[int, list[int]],
-               current_path: list[int] | None = None):
+def trace_path(
+    node_id: int,
+    node_info: dict[int, BranchInfo],
+    merge_points: dict[int, list[int]],
+    current_path: list[int] | None = None,
+):
     """Define the trace of each node path"""
     if current_path is None:
         current_path = []
-    
+
     current_path = current_path + [node_id]
     outputs = node_info[node_id].outputs
-    
+
     if not outputs:
         # End of path
         return [current_path]
-    
+
     # If this node has multiple outputs or connects to a merge point, branch
     all_paths = []
     for output_id in outputs:
@@ -64,7 +65,7 @@ def build_node_info(nodes: list[FlowNode]) -> dict[int, BranchInfo]:
         # Get node label
         operation = node.node_type.replace("_", " ").title() if node.node_type else "Unknown"
         label = f"{operation} (id={node_id})"
-        if hasattr(node, 'setting_input') and hasattr(node.setting_input, 'description'):
+        if hasattr(node, "setting_input") and hasattr(node.setting_input, "description"):
             if node.setting_input.description:
                 desc = node.setting_input.description
                 if len(desc) > 20:  # Truncate long descriptions
@@ -75,18 +76,14 @@ def build_node_info(nodes: list[FlowNode]) -> dict[int, BranchInfo]:
         inputs = InputInfo(
             main=[n.node_id for n in (node.node_inputs.main_inputs or [])],
             left=node.node_inputs.left_input.node_id if node.node_inputs.left_input else None,
-            right=node.node_inputs.right_input.node_id if node.node_inputs.right_input else None
+            right=node.node_inputs.right_input.node_id if node.node_inputs.right_input else None,
         )
         outputs = [n.node_id for n in node.leads_to_nodes]
 
         node_info[node_id] = BranchInfo(
-            label=label,
-            short_label=f"{operation} ({node_id})",
-            inputs=inputs,
-            outputs=outputs,
-            depth=0
+            label=label, short_label=f"{operation} ({node_id})", inputs=inputs, outputs=outputs, depth=0
         )
-    
+
     return node_info
 
 
@@ -112,19 +109,20 @@ def define_node_connections(node_info: dict[int, BranchInfo]) -> dict[int, list[
             if output_id not in merge_points:
                 merge_points[output_id] = []
             merge_points[output_id].append(node_id)
-    
+
     return merge_points
 
 
-def build_flow_paths(node_info: dict[int, BranchInfo], flow_starts: list[FlowNode],
-                     merge_points: dict[int, list[int]]):
+def build_flow_paths(node_info: dict[int, BranchInfo], flow_starts: list[FlowNode], merge_points: dict[int, list[int]]):
     """Build the flow paths to be drawn"""
 
-
     # Find all root nodes (no inputs)
-    root_nodes = [nid for nid, info in node_info.items()
-                  if not info.inputs.main and not info.inputs.left and not info.inputs.right]
-    
+    root_nodes = [
+        nid
+        for nid, info in node_info.items()
+        if not info.inputs.main and not info.inputs.left and not info.inputs.right
+    ]
+
     if not root_nodes and flow_starts:
         root_nodes = [n.node_id for n in flow_starts]
     paths = []  # List of paths through the graph
@@ -136,7 +134,7 @@ def build_flow_paths(node_info: dict[int, BranchInfo], flow_starts: list[FlowNod
     return paths
 
 
-def group_paths(paths:list, merge_points:dict):
+def group_paths(paths: list, merge_points: dict):
     """Groups each node path."""
     paths_by_merge = {}
     standalone_paths = []
@@ -152,12 +150,14 @@ def group_paths(paths:list, merge_points:dict):
     return paths_by_merge, standalone_paths
 
 
-def draw_merged_paths(node_info: dict[int, BranchInfo],
-                      merge_points: dict[int, list[int]],
-                      paths_by_merge: dict[int, list[list[int]]],
-                      merge_drawn: set,
-                      drawn_nodes: set,
-                      lines: list[str]):
+def draw_merged_paths(
+    node_info: dict[int, BranchInfo],
+    merge_points: dict[int, list[int]],
+    paths_by_merge: dict[int, list[list[int]]],
+    merge_drawn: set,
+    drawn_nodes: set,
+    lines: list[str],
+):
     """Draws paths for each node that merges."""
     for merge_id, merge_paths in paths_by_merge.items():
         if merge_id in merge_drawn:
@@ -171,8 +171,7 @@ def draw_merged_paths(node_info: dict[int, BranchInfo],
             source_path = None
             for path in merge_paths:
                 if source_id in path:
-
-                    source_path = path[:path.index(source_id) + 1]
+                    source_path = path[: path.index(source_id) + 1]
                     break
 
             if source_path:
@@ -215,14 +214,15 @@ def draw_merged_paths(node_info: dict[int, BranchInfo],
     return paths_by_merge
 
 
-def draw_standalone_paths(drawn_nodes: set[int], standalone_paths: list[list[int]], lines: list[str],
-                          node_info: dict[int, BranchInfo]):
-    """ Draws paths that do not merge."""
+def draw_standalone_paths(
+    drawn_nodes: set[int], standalone_paths: list[list[int]], lines: list[str], node_info: dict[int, BranchInfo]
+):
+    """Draws paths that do not merge."""
     # Draw standalone paths
     for path in standalone_paths:
         if all(nid in drawn_nodes for nid in path):
             continue
-        
+
         line_parts = []
         for i, node_id in enumerate(path):
             if node_id not in drawn_nodes:
@@ -231,12 +231,12 @@ def draw_standalone_paths(drawn_nodes: set[int], standalone_paths: list[list[int
                 else:
                     line_parts.append(f" ──> {node_info[node_id].short_label}")
                 drawn_nodes.add(node_id)
-        
+
         if line_parts:
             lines.append("".join(line_parts))
 
 
-def add_un_drawn_nodes(drawn_nodes: set[int], node_info: dict[int, BranchInfo],  lines: list[str]):
+def add_un_drawn_nodes(drawn_nodes: set[int], node_info: dict[int, BranchInfo], lines: list[str]):
     """Adds isolated nodes if exists."""
     # Add any remaining undrawn nodes
 

flowfile_core/flowfile/handler.py

@@ -1,14 +1,12 @@
-
-from dataclasses import dataclass
-from typing import Dict, List
 import os
-from pathlib import Path
+from dataclasses import dataclass
 from datetime import datetime
+from pathlib import Path
 
-from flowfile_core.flowfile.manage.io_flowfile import open_flow
 from flowfile_core.flowfile.flow_graph import FlowGraph
-from flowfile_core.schemas.schemas import FlowSettings
+from flowfile_core.flowfile.manage.io_flowfile import open_flow
 from flowfile_core.flowfile.utils import create_unique_id
+from flowfile_core.schemas.schemas import FlowSettings
 from shared.storage_config import storage
 
 
@@ -21,62 +19,111 @@ def get_flow_save_location(flow_name: str) -> Path:
 
 def create_flow_name() -> str:
     """Creates a unique flow name"""
-    return datetime.now().strftime("%Y%m%d_%H_%M_%S")+"_flow.yaml"
+    return datetime.now().strftime("%Y%m%d_%H_%M_%S") + "_flow.yaml"
 
 
 @dataclass
 class FlowfileHandler:
-    _flows: Dict[int, FlowGraph]
+    _flows: dict[int, FlowGraph]
+    _user_sessions: dict[int, set[int]]  # Maps user_id -> set of flow_ids
 
     def __init__(self):
         self._flows = {}
+        self._user_sessions = {}
 
     @property
-    def flowfile_flows(self) -> List[FlowGraph]:
+    def flowfile_flows(self) -> list[FlowGraph]:
         return list(self._flows.values())
 
+    def _register_user_session(self, user_id: int | None, flow_id: int):
+        """Register a flow as belonging to a user's session."""
+        if user_id is not None:
+            if user_id not in self._user_sessions:
+                self._user_sessions[user_id] = set()
+            self._user_sessions[user_id].add(flow_id)
+
+    def _unregister_user_session(self, user_id: int | None, flow_id: int):
+        """Remove a flow from a user's session."""
+        if user_id is not None and user_id in self._user_sessions:
+            self._user_sessions[user_id].discard(flow_id)
+
+    def get_user_flows(self, user_id: int | None) -> list[FlowGraph]:
+        """Get all flows belonging to a specific user's session."""
+        if user_id is None:
+            return self.flowfile_flows
+        user_flow_ids = self._user_sessions.get(user_id, set())
+        return [f for f in self._flows.values() if f.flow_id in user_flow_ids]
+
+    def user_has_flow(self, user_id: int | None, flow_id: int) -> bool:
+        """Check if a user has access to a specific flow."""
+        if user_id is None:
+            return flow_id in self._flows
+        return flow_id in self._user_sessions.get(user_id, set())
+
     def __add__(self, other: FlowGraph) -> int:
         self._flows[other.flow_id] = other
         return other.flow_id
 
-    def import_flow(self, flow_path: Path | str) -> int:
+    def import_flow(self, flow_path: Path | str, user_id: int | None = None) -> int:
         if isinstance(flow_path, str):
             flow_path = Path(flow_path)
         imported_flow = open_flow(flow_path)
         self._flows[imported_flow.flow_id] = imported_flow
         imported_flow.flow_settings = self.get_flow_info(imported_flow.flow_id)
         imported_flow.flow_settings.is_running = False
+        self._register_user_session(user_id, imported_flow.flow_id)
         return imported_flow.flow_id
 
-    def register_flow(self, flow_settings: FlowSettings):
+    def register_flow(self, flow_settings: FlowSettings, user_id: int | None = None) -> FlowGraph:
+        """Register a flow with the handler and associate it with a user session."""
         if flow_settings.flow_id in self._flows:
             self.delete_flow(flow_settings.flow_id)
-            raise 'flow already registered'
-        else:
-            name = flow_settings.name if flow_settings.name else flow_settings.flow_id
-            self._flows[flow_settings.flow_id] = FlowGraph(name=name, flow_settings=flow_settings)
+            raise ValueError("Flow already registered")
+        name = flow_settings.name if flow_settings.name else str(flow_settings.flow_id)
+        self._flows[flow_settings.flow_id] = FlowGraph(name=name, flow_settings=flow_settings)
+        self._register_user_session(user_id, flow_settings.flow_id)
         return self.get_flow(flow_settings.flow_id)
 
-    def get_flow(self, flow_id: int) -> FlowGraph | None:
-        return self._flows.get(flow_id, None)
-
-    def delete_flow(self, flow_id: int):
-        flow = self._flows.pop(flow_id)
-        del flow
+    def get_flow(self, flow_id: int, user_id: int | None = None) -> FlowGraph | None:
+        """Get a flow by ID, optionally checking user access."""
+        flow = self._flows.get(flow_id, None)
+        if flow and user_id is not None:
+            # Only return the flow if user has access
+            if not self.user_has_flow(user_id, flow_id):
+                return None
+        return flow
+
+    def delete_flow(self, flow_id: int, user_id: int | None = None):
+        """Remove flow from user's session. Flow data remains until all users close it."""
+        if user_id is not None:
+            if not self.user_has_flow(user_id, flow_id):
+                raise Exception(f"Flow {flow_id} not found in user's session")
+            self._unregister_user_session(user_id, flow_id)
+            # Check if any user still has this flow open
+            flow_still_open = any(flow_id in flows for flows in self._user_sessions.values())
+            if not flow_still_open and flow_id in self._flows:
+                flow = self._flows.pop(flow_id)
+                del flow
+        else:
+            # No user context - delete directly
+            if flow_id in self._flows:
+                flow = self._flows.pop(flow_id)
+                del flow
 
-    def save_flow(self, flow_id: int, flow_path: str):
-        flow = self.get_flow(flow_id)
+    def save_flow(self, flow_id: int, flow_path: str, user_id: int | None = None):
+        flow = self.get_flow(flow_id, user_id)
         if flow:
             flow.save_flow(flow_path)
         else:
-            raise Exception('Flow not found')
+            raise Exception("Flow not found or not accessible by user")
 
-    def add_flow(self, name: str = None, flow_path: str = None) -> int:
+    def add_flow(self, name: str = None, flow_path: str = None, user_id: int | None = None) -> int:
         """
         Creates a new flow with a reference to the flow path
         Args:
             name (str): The name of the flow
             flow_path (str): The path to the flow file
+            user_id (int): The ID of the user creating the flow
 
         Returns:
             int: The flow id
@@ -87,15 +134,18 @@ class FlowfileHandler:
             name = create_flow_name()
         if not flow_path:
             flow_path = get_flow_save_location(name)
-        flow_info = FlowSettings(name=name, flow_id=next_id, save_location=str(flow_path), path=str(flow_path))
-        flow = self.register_flow(flow_info)
+        flow_info = FlowSettings(
+            name=name, flow_id=next_id, save_location=str(flow_path),
+            path=str(flow_path)
+        )
+        flow = self.register_flow(flow_info, user_id=user_id)
         flow.save_flow(flow.flow_settings.path)
         return next_id
 
     def get_flow_info(self, flow_id: int) -> FlowSettings:
         flow = self.get_flow(flow_id)
         if not flow:
-            raise Exception(f'Flow {flow_id} not found')
+            raise Exception(f"Flow {flow_id} not found")
         flow_exists = os.path.exists(flow.flow_settings.path)
         last_modified_ts = os.path.getmtime(flow.flow_settings.path) if flow_exists else -1
         flow.flow_settings.modified_on = last_modified_ts
@@ -104,8 +154,8 @@ class FlowfileHandler:
     def get_node(self, flow_id: int, node_id: int):
         flow = self.get_flow(flow_id)
         if not flow:
-            raise Exception(f'Flow {flow_id} not found')
+            raise Exception(f"Flow {flow_id} not found")
         node = flow.get_node(node_id)
         if not node:
-            raise Exception(f'Node {node_id} not found in flow {flow_id}')
+            raise Exception(f"Node {node_id} not found in flow {flow_id}")
         return node