Flowfile 0.3.9__py3-none-any.whl → 0.3.10__py3-none-any.whl

flowfile_core/flowfile/flow_graph.py

@@ -1,11 +1,15 @@
 import datetime
 import pickle
+
+import os
+
 import polars as pl
+
 import fastexcel
 from fastapi.exceptions import HTTPException
 from time import time
 from functools import partial
-from typing import List, Dict, Union, Callable, Any, Optional, Tuple
+from typing import List, Dict, Union, Callable, Any, Optional, Tuple, Literal
 from uuid import uuid1
 from copy import deepcopy
 from pyarrow.parquet import ParquetFile
@@ -175,11 +179,9 @@ class FlowGraph:
     schema: Optional[List[FlowfileColumn]] = None
     has_over_row_function: bool = False
     _flow_starts: List[Union[int, str]] = None
-    node_results: List[NodeResult] = None
     latest_run_info: Optional[RunInformation] = None
     start_datetime: datetime = None
     end_datetime: datetime = None
-    nodes_completed: int = 0
     _flow_settings: schemas.FlowSettings = None
     flow_logger: FlowLogger
 
@@ -206,11 +208,9 @@ class FlowGraph:
 
         self._flow_settings = flow_settings
         self.uuid = str(uuid1())
-        self.nodes_completed = 0
         self.start_datetime = None
         self.end_datetime = None
         self.latest_run_info = None
-        self.node_results = []
         self._flow_id = flow_settings.flow_id
         self.flow_logger = FlowLogger(flow_settings.flow_id)
         self._flow_starts: List[FlowNode] = []
@@ -814,11 +814,11 @@ class FlowGraph:
         def _func(main: FlowDataEngine, right: FlowDataEngine) -> FlowDataEngine:
             node = self.get_node(node_id=fuzzy_settings.node_id)
             if self.execution_location == "local":
-                return main.fuzzy_join(fuzzy_match_input=fuzzy_settings.join_input,
+                return main.fuzzy_join(fuzzy_match_input=deepcopy(fuzzy_settings.join_input),
                                        other=right,
                                        node_logger=self.flow_logger.get_node_logger(fuzzy_settings.node_id))
 
-            f = main.start_fuzzy_join(fuzzy_match_input=fuzzy_settings.join_input, other=right, file_ref=node.hash,
+            f = main.start_fuzzy_join(fuzzy_match_input=deepcopy(fuzzy_settings.join_input), other=right, file_ref=node.hash,
                                       flow_id=self.flow_id, node_id=fuzzy_settings.node_id)
             logger.info("Started the fuzzy match action")
             node._fetch_cached_df = f  # Add to the node so it can be cancelled and fetch later if needed
@@ -1599,6 +1599,66 @@ class FlowGraph:
             self.reset()
         self.flow_settings.execution_location = execution_location
 
+    def validate_if_node_can_be_fetched(self, node_id: int) -> None:
+        flow_node = self._node_db.get(node_id)
+        if not flow_node:
+            raise Exception("Node not found found")
+        skip_nodes, execution_order = compute_execution_plan(
+            nodes=self.nodes, flow_starts=self._flow_starts+self.get_implicit_starter_nodes()
+        )
+        if flow_node.node_id in [skip_node.node_id for skip_node in skip_nodes]:
+            raise Exception("Node can not be executed because it does not have it's inputs")
+
+    def create_initial_run_information(self, number_of_nodes: int,
+                                       run_type: Literal["fetch_one", "full_run"]):
+        return RunInformation(
+            flow_id=self.flow_id, start_time=datetime.datetime.now(), end_time=None,
+            success=None, number_of_nodes=number_of_nodes, node_step_result=[],
+            run_type=run_type
+        )
+
+    def trigger_fetch_node(self, node_id: int) -> RunInformation | None:
+        """Executes a specific node in the graph by its ID."""
+        if self.flow_settings.is_running:
+            raise Exception("Flow is already running")
+        flow_node = self.get_node(node_id)
+        self.flow_settings.is_running = True
+        self.flow_settings.is_canceled = False
+        self.flow_logger.clear_log_file()
+        self.latest_run_info = self.create_initial_run_information(1, "fetch_one")
+        node_logger = self.flow_logger.get_node_logger(flow_node.node_id)
+        node_result = NodeResult(node_id=flow_node.node_id, node_name=flow_node.name)
+        logger.info(f'Starting to run: node {flow_node.node_id}, start time: {node_result.start_timestamp}')
+        try:
+            self.latest_run_info.node_step_result.append(node_result)
+            flow_node.execute_node(run_location=self.flow_settings.execution_location,
+                                   performance_mode=False,
+                                   node_logger=node_logger,
+                                   optimize_for_downstream=False,
+                                   reset_cache=True)
+            node_result.error = str(flow_node.results.errors)
+            if self.flow_settings.is_canceled:
+                node_result.success = None
+                node_result.success = None
+                node_result.is_running = False
+            node_result.success = flow_node.results.errors is None
+            node_result.end_timestamp = time()
+            node_result.run_time = int(node_result.end_timestamp - node_result.start_timestamp)
+            node_result.is_running = False
+            self.latest_run_info.nodes_completed += 1
+            self.latest_run_info.end_time = datetime.datetime.now()
+            self.flow_settings.is_running = False
+            return self.get_run_info()
+        except Exception as e:
+            node_result.error = 'Node did not run'
+            node_result.success = False
+            node_result.end_timestamp = time()
+            node_result.run_time = int(node_result.end_timestamp - node_result.start_timestamp)
+            node_result.is_running = False
+            node_logger.error(f'Error in node {flow_node.node_id}: {e}')
+        finally:
+            self.flow_settings.is_running = False
+
     def run_graph(self) -> RunInformation | None:
         """Executes the entire data flow graph from start to finish.
 
@@ -1614,20 +1674,23 @@ class FlowGraph:
         if self.flow_settings.is_running:
             raise Exception('Flow is already running')
         try:
+
             self.flow_settings.is_running = True
             self.flow_settings.is_canceled = False
             self.flow_logger.clear_log_file()
-            self.nodes_completed = 0
-            self.node_results = []
-            self.start_datetime = datetime.datetime.now()
-            self.end_datetime = None
-            self.latest_run_info = None
             self.flow_logger.info('Starting to run flowfile flow...')
-            skip_nodes, execution_order = compute_execution_plan(nodes=self.nodes, flow_starts=self._flow_starts+self.get_implicit_starter_nodes())
+
+            skip_nodes, execution_order = compute_execution_plan(
+                nodes=self.nodes,
+                flow_starts=self._flow_starts+self.get_implicit_starter_nodes()
+            )
+
+            self.latest_run_info = self.create_initial_run_information(len(execution_order), "full_run")
 
             skip_node_message(self.flow_logger, skip_nodes)
             execution_order_message(self.flow_logger, execution_order)
             performance_mode = self.flow_settings.execution_mode == 'Performance'
+
             for node in execution_order:
                 node_logger = self.flow_logger.get_node_logger(node.node_id)
                 if self.flow_settings.is_canceled:
@@ -1637,7 +1700,7 @@ class FlowGraph:
                     node_logger.info(f'Skipping node {node.node_id}')
                     continue
                 node_result = NodeResult(node_id=node.node_id, node_name=node.name)
-                self.node_results.append(node_result)
+                self.latest_run_info.node_step_result.append(node_result)
                 logger.info(f'Starting to run: node {node.node_id}, start time: {node_result.start_timestamp}')
                 node.execute_node(run_location=self.flow_settings.execution_location,
                                   performance_mode=performance_mode,
@@ -1663,7 +1726,7 @@ class FlowGraph:
                 if not node_result.success:
                     skip_nodes.extend(list(node.get_all_dependent_nodes()))
                 node_logger.info(f'Completed node with success: {node_result.success}')
-                self.nodes_completed += 1
+                self.latest_run_info.nodes_completed += 1
             self.flow_logger.info('Flow completed!')
             self.end_datetime = datetime.datetime.now()
             self.flow_settings.is_running = False
@@ -1675,28 +1738,23 @@ class FlowGraph:
         finally:
             self.flow_settings.is_running = False
 
-    def get_run_info(self) -> RunInformation:
+    def get_run_info(self) -> RunInformation | None:
         """Gets a summary of the most recent graph execution.
 
         Returns:
             A RunInformation object with details about the last run.
         """
+        is_running = self.flow_settings.is_running
         if self.latest_run_info is None:
-            node_results = self.node_results
-            success = all(nr.success for nr in node_results)
-            self.latest_run_info = RunInformation(start_time=self.start_datetime, end_time=self.end_datetime,
-                                                  success=success,
-                                                  node_step_result=node_results, flow_id=self.flow_id,
-                                                  nodes_completed=self.nodes_completed,
-                                                  number_of_nodes=len(self.nodes))
-        elif self.latest_run_info.nodes_completed != self.nodes_completed:
-            node_results = self.node_results
-            self.latest_run_info = RunInformation(start_time=self.start_datetime, end_time=self.end_datetime,
-                                                  success=all(nr.success for nr in node_results),
-                                                  node_step_result=node_results, flow_id=self.flow_id,
-                                                  nodes_completed=self.nodes_completed,
-                                                  number_of_nodes=len(self.nodes))
-        return self.latest_run_info
+            return
+
+        elif not is_running and self.latest_run_info.success is not None:
+            return self.latest_run_info
+
+        run_info = self.latest_run_info
+        if not is_running:
+            run_info.success = all(nr.success for nr in run_info.node_step_result)
+        return run_info
 
     @property
     def node_connections(self) -> List[Tuple[int, int]]:
@@ -1767,8 +1825,14 @@ class FlowGraph:
         Args:
             flow_path: The path where the flow file will be saved.
         """
-        with open(flow_path, 'wb') as f:
-            pickle.dump(self.get_node_storage(), f)
+        logger.info("Saving flow to %s", flow_path)
+        os.makedirs(os.path.dirname(flow_path), exist_ok=True)
+        try:
+            with open(flow_path, 'wb') as f:
+                pickle.dump(self.get_node_storage(), f)
+        except Exception as e:
+            logger.error(f"Error saving flow: {e}")
+
         self.flow_settings.path = flow_path
 
     def get_frontend_data(self) -> dict:

flowfile_core/flowfile/flow_node/flow_node.py

@@ -12,7 +12,7 @@ from flowfile_core.configs.node_store import nodes as node_interface
 from flowfile_core.flowfile.setting_generator import setting_generator, setting_updator
 from time import sleep
 from flowfile_core.flowfile.flow_data_engine.subprocess_operations import (
-    ExternalDfFetcher, ExternalSampler, results_exists, get_external_df_result,
+    ExternalDfFetcher, ExternalSampler, clear_task_from_worker, results_exists, get_external_df_result,
     ExternalDatabaseFetcher, ExternalDatabaseWriter, ExternalCloudWriter)
 from flowfile_core.flowfile.flow_node.models import (NodeStepSettings, NodeStepInputs, NodeSchemaInformation,
                                                      NodeStepStats, NodeResults)
@@ -678,9 +678,10 @@ class FlowNode:
 
         if results_exists(self.hash):
             logger.warning('Not implemented')
+            clear_task_from_worker(self.hash)
 
     def needs_run(self, performance_mode: bool, node_logger: NodeLogger = None,
-                  execution_location: schemas.ExecutionLocationsLiteral = "worker") -> bool:
+                  execution_location: schemas.ExecutionLocationsLiteral = "remote") -> bool:
         """Determines if the node needs to be executed.
 
         The decision is based on its run state, caching settings, and execution mode.
@@ -723,6 +724,8 @@ class FlowNode:
         Raises:
             Exception: Propagates exceptions from the execution.
         """
+        self.clear_table_example()
+
         def example_data_generator():
             example_data = None
 
@@ -735,6 +738,7 @@ class FlowNode:
         resulting_data = self.get_resulting_data()
 
         if not performance_mode:
+            self.node_stats.has_run_with_current_setup = True
             self.results.example_data_generator = example_data_generator()
             self.node_schema.result_schema = self.results.resulting_data.schema
             self.node_stats.has_completed_last_run = True
@@ -854,8 +858,12 @@ class FlowNode:
             logger.warning('No external process to cancel')
         self.node_stats.is_canceled = True
 
-    def execute_node(self, run_location: schemas.ExecutionLocationsLiteral, reset_cache: bool = False,
-                     performance_mode: bool = False, retry: bool = True, node_logger: NodeLogger = None):
+    def execute_node(self, run_location: schemas.ExecutionLocationsLiteral,
+                     reset_cache: bool = False,
+                     performance_mode: bool = False,
+                     retry: bool = True,
+                     node_logger: NodeLogger = None,
+                     optimize_for_downstream: bool = True):
         """Orchestrates the execution, handling location, caching, and retries.
 
         Args:
@@ -864,25 +872,33 @@ class FlowNode:
             performance_mode: If True, optimizes for speed over diagnostics.
             retry: If True, allows retrying execution on recoverable errors.
             node_logger: The logger for this node execution.
+            optimize_for_downstream: If true, operations that shuffle the order of rows are fully cached and provided as
+            input to downstream steps
 
         Raises:
             Exception: If the node_logger is not defined.
         """
         if node_logger is None:
             raise Exception('Flow logger is not defined')
-        # node_logger = flow_logger.get_node_logger(self.node_id)
+        #  TODO: Simplify which route is being picked there are many duplicate checks
+
         if reset_cache:
             self.remove_cache()
             self.node_stats.has_run_with_current_setup = False
             self.node_stats.has_completed_last_run = False
+
         if self.is_setup:
             node_logger.info(f'Starting to run {self.__name__}')
             if (self.needs_run(performance_mode, node_logger, run_location) or self.node_template.node_group == "output"
                     and not (run_location == 'local')):
+                self.clear_table_example()
                 self.prepare_before_run()
+                self.reset()
                 try:
-                    if ((run_location == 'remote' or (self.node_default.transform_type == 'wide')
-                            and not run_location == 'local')) or self.node_settings.cache_results:
+                    if (((run_location == 'remote' or
+                         (self.node_default.transform_type == 'wide' and optimize_for_downstream) and
+                         not run_location == 'local'))
+                            or self.node_settings.cache_results):
                         node_logger.info('Running the node remotely')
                         if self.node_settings.cache_results:
                             performance_mode = False
@@ -924,7 +940,7 @@ class FlowNode:
                     node_logger.error(f'Error with running the node: {e}')
                     self.node_stats.error = str(e)
                     self.node_stats.has_completed_last_run = False
-                self.node_stats.has_run_with_current_setup = True
+
             else:
                 node_logger.info('Node has already run, not running the node')
         else:
@@ -1108,6 +1124,17 @@ class FlowNode:
         if self.singular_input:
             return self.all_inputs[0]
 
+    def clear_table_example(self) -> None:
+        """
+        Clear the table example in the results so that it clears the existing results
+        Returns:
+            None
+        """
+
+        self.results.example_data = None
+        self.results.example_data_generator = None
+        self.results.example_data_path = None
+
     def get_table_example(self, include_data: bool = False) -> TableExample | None:
         """Generates a `TableExample` model summarizing the node's output.
 
@@ -1136,10 +1163,15 @@ class FlowNode:
                 data = []
             schema = [FileColumn.model_validate(c.get_column_repr()) for c in self.schema]
             fl = self.get_resulting_data()
+            has_example_data = self.results.example_data_generator is not None
+
             return TableExample(node_id=self.node_id,
                                 name=str(self.node_id), number_of_records=999,
                                 number_of_columns=fl.number_of_fields,
-                                table_schema=schema, columns=fl.columns, data=data)
+                                table_schema=schema, columns=fl.columns, data=data,
+                                has_example_data=has_example_data,
+                                has_run_with_current_setup=self.node_stats.has_run_with_current_setup
+                                )
         else:
             logger.warning('getting the table example but the node has not run')
             try:

flowfile_core/flowfile/handler.py

@@ -3,11 +3,25 @@ from dataclasses import dataclass
 from typing import Dict, List
 import os
 from pathlib import Path
+from datetime import datetime
 
 from flowfile_core.flowfile.manage.open_flowfile import open_flow
 from flowfile_core.flowfile.flow_graph import FlowGraph
 from flowfile_core.schemas.schemas import FlowSettings
 from flowfile_core.flowfile.utils import create_unique_id
+from shared.storage_config import storage
+
+
+def get_flow_save_location(flow_name: str) -> Path:
+    """Gets the initial save location for flow files"""
+    if ".flowfile" not in flow_name:
+        flow_name += ".flowfile"
+    return storage.temp_directory_for_flows / flow_name
+
+
+def create_flow_name() -> str:
+    """Creates a unique flow name"""
+    return datetime.now().strftime("%Y%m%d_%H_%M_%S")+"_flow.flowfile"
 
 
 @dataclass
@@ -57,7 +71,7 @@ class FlowfileHandler:
         else:
             raise Exception('Flow not found')
 
-    def add_flow(self, name: str, flow_path: str) -> int:
+    def add_flow(self, name: str = None, flow_path: str = None) -> int:
         """
         Creates a new flow with a reference to the flow path
         Args:
@@ -69,8 +83,13 @@ class FlowfileHandler:
 
         """
         next_id = create_unique_id()
-        flow_info = FlowSettings(name=name, flow_id=next_id, save_location='', path=flow_path)
-        _ = self.register_flow(flow_info)
+        if not name:
+            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.save_flow(flow.flow_settings.path)
         return next_id
 
     def get_flow_info(self, flow_id: int) -> FlowSettings:

flowfile_core/flowfile/schema_callbacks.py

@@ -61,21 +61,25 @@ def calculate_fuzzy_match_schema(fm_input: transform_schema.FuzzyMatchInput,
                                           join_inputs=fm_input.left_select)
     _order_join_inputs_based_on_col_order(col_order=[col.column_name for col in right_schema],
                                           join_inputs=fm_input.right_select)
+    for column in fm_input.left_select.renames:
+        if column.join_key:
+            column.keep = True
+    for column in fm_input.right_select.renames:
+        if column.join_key:
+            column.keep = True
     left_schema_dict, right_schema_dict = ({ls.name: ls for ls in left_schema}, {rs.name: rs for rs in right_schema})
     fm_input.auto_rename()
-
     right_renames = {column.old_name: column.new_name for column in fm_input.right_select.renames}
     new_join_mapping = rename_fuzzy_right_mapping(fm_input.join_mapping, right_renames)
-
     output_schema = []
     for column in fm_input.left_select.renames:
         column_schema = left_schema_dict.get(column.old_name)
-        if column_schema and column.keep:
+        if column_schema and (column.keep or column.join_key):
             output_schema.append(FlowfileColumn.from_input(column.new_name, column_schema.data_type,
                                                            example_values=column_schema.example_values))
     for column in fm_input.right_select.renames:
         column_schema = right_schema_dict.get(column.old_name)
-        if column_schema and column.keep:
+        if column_schema and (column.keep or column.join_key):
             output_schema.append(FlowfileColumn.from_input(column.new_name, column_schema.data_type,
                                                            example_values=column_schema.example_values))
     set_name_in_fuzzy_mappings(new_join_mapping)

flowfile_core/flowfile/setting_generator/settings.py

@@ -56,7 +56,6 @@ def cross_join(node_data: "NodeData") -> NodeData:
         ji = transform_schema.CrossJoinInput(left_select=node_data.main_input.columns,
                                              right_select=node_data.right_input.columns)
         ji.auto_rename()
-        print(ji)
         node_data.setting_input = input_schema.NodeCrossJoin(flow_id=node_data.flow_id,
                                                              node_id=node_data.node_id,
                                                              cross_join_input=ji)

flowfile_core/main.py

@@ -7,6 +7,8 @@ import uvicorn
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 
+from shared.storage_config import storage
+
 from flowfile_core import ServerRun
 from flowfile_core.configs.settings import (SERVER_HOST, SERVER_PORT, WORKER_HOST, WORKER_PORT, WORKER_URL,)
 
@@ -18,13 +20,13 @@ from flowfile_core.routes.logs import router as logs_router
 from flowfile_core.routes.cloud_connections import router as cloud_connections_router
 
 from flowfile_core.configs.flow_logger import clear_all_flow_logs
+storage.cleanup_directories()
 
 os.environ["FLOWFILE_MODE"] = "electron"
 
 should_exit = False
 server_instance = None
 
-
 @asynccontextmanager
 async def shutdown_handler(app: FastAPI):
     """Handles the graceful startup and shutdown of the FastAPI application.
@@ -79,6 +81,7 @@ app.include_router(secrets_router, prefix="/secrets", tags=["secrets"])
 app.include_router(cloud_connections_router, prefix="/cloud_connections", tags=["cloud_connections"])
 
 
+
 @app.post("/shutdown")
 async def shutdown():
     """An API endpoint to gracefully shut down the server.

flowfile_core/routes/routes.py

@@ -26,7 +26,7 @@ from flowfile_core.configs.node_store import nodes
 from flowfile_core.configs.settings import IS_RUNNING_IN_DOCKER
 # File handling
 from flowfile_core.fileExplorer.funcs import (
-    FileExplorer,
+    SecureFileExplorer,
     FileInfo,
     get_files_from_directory
 )
@@ -39,9 +39,11 @@ from flowfile_core.flowfile.extensions import get_instant_func_results
 from flowfile_core.flowfile.sources.external_sources.sql_source.sql_source import create_sql_source_from_db_settings
 from flowfile_core.run_lock import get_flow_run_lock
 # Schema and models
+
+from shared.storage_config import storage
 from flowfile_core.schemas import input_schema, schemas, output_model
 from flowfile_core.utils import excel_file_manager
-from flowfile_core.utils.fileManager import create_dir, remove_paths
+from flowfile_core.utils.fileManager import create_dir
 from flowfile_core.utils.utils import camel_case_to_snake_case
 from flowfile_core import flow_file_handler
 from flowfile_core.flowfile.database_connection_manager.db_connections import (store_database_connection,
@@ -54,7 +56,10 @@ from flowfile_core.database.connection import get_db
 router = APIRouter(dependencies=[Depends(get_current_active_user)])
 
 # Initialize services
-file_explorer = FileExplorer('/app/shared' if IS_RUNNING_IN_DOCKER else None)
+file_explorer = SecureFileExplorer(
+    start_path=storage.user_data_directory,
+    sandbox_root=storage.user_data_directory
+)
 
 
 def get_node_model(setting_name_ref: str):
@@ -148,7 +153,7 @@ async def get_directory_contents(directory: str, file_types: List[str] = None,
     Returns:
         A list of `FileInfo` objects representing the directory's contents.
     """
-    directory_explorer = FileExplorer(directory)
+    directory_explorer = SecureFileExplorer(directory, storage.user_data_directory)
     try:
         return directory_explorer.list_contents(show_hidden=include_hidden, file_types=file_types)
     except Exception as e:
@@ -198,6 +203,24 @@ async def get_active_flow_file_sessions() -> List[schemas.FlowSettings]:
     return [flf.flow_settings for flf in flow_file_handler.flowfile_flows]
 
 
+@router.post("/node/trigger_fetch_data", tags=['editor'])
+async def trigger_fetch_node_data(flow_id: int, node_id: int, background_tasks: BackgroundTasks):
+    """Fetches and refreshes the data for a specific node."""
+    flow = flow_file_handler.get_flow(flow_id)
+    lock = get_flow_run_lock(flow_id)
+    async with lock:
+        if flow.flow_settings.is_running:
+            raise HTTPException(422, 'Flow is already running')
+        try:
+            flow.validate_if_node_can_be_fetched(node_id)
+        except Exception as e:
+            raise HTTPException(422, str(e))
+        background_tasks.add_task(flow.trigger_fetch_node, node_id)
+    return JSONResponse(content={"message": "Data started",
+                                 "flow_id": flow_id,
+                                 "node_id": node_id}, status_code=status.HTTP_200_OK)
+
+
 @router.post('/flow/run/', tags=['editor'])
 async def run_flow(flow_id: int, background_tasks: BackgroundTasks) -> JSONResponse:
     """Executes a flow in a background task.
@@ -228,6 +251,16 @@ def cancel_flow(flow_id: int):
     flow.cancel()
 
 
+@router.post("/flow/apply_standard_layout/", tags=["editor"])
+def apply_standard_layout(flow_id: int):
+    flow = flow_file_handler.get_flow(flow_id)
+    if not flow:
+        raise HTTPException(status_code=404, detail="Flow not found")
+    if flow.flow_settings.is_running:
+        raise HTTPException(422, "Flow is running")
+    flow.apply_layout()
+
+
 @router.get('/flow/run_status/', tags=['editor'],
             response_model=output_model.RunInformation)
 def get_run_status(flow_id: int, response: Response):
@@ -238,10 +271,12 @@ def get_run_status(flow_id: int, response: Response):
     flow = flow_file_handler.get_flow(flow_id)
     if not flow:
         raise HTTPException(status_code=404, detail="Flow not found")
+    if flow.latest_run_info is None:
+        raise HTTPException(status_code=404, detail="No run information available")
     if flow.flow_settings.is_running:
         response.status_code = status.HTTP_202_ACCEPTED
-        return flow.get_run_info()
-    response.status_code = status.HTTP_200_OK
+    else:
+        response.status_code = status.HTTP_200_OK
     return flow.get_run_info()
 
 
@@ -439,11 +474,24 @@ def get_generated_code(flow_id: int) -> str:
 
 
 @router.post('/editor/create_flow/', tags=['editor'])
-def create_flow(flow_path: str):
+def create_flow(flow_path: str = None, name: str = None):
     """Creates a new, empty flow file at the specified path and registers a session for it."""
-    flow_path = Path(flow_path)
-    logger.info('Creating flow')
-    return flow_file_handler.add_flow(name=flow_path.stem, flow_path=str(flow_path))
+    if flow_path is not None and name is None:
+        name = Path(flow_path).stem
+    elif flow_path is not None and name is not None:
+        if name not in flow_path and flow_path.endswith(".flowfile"):
+            raise HTTPException(422, 'The name must be part of the flow path when a full path is provided')
+        elif name in flow_path and not flow_path.endswith(".flowfile"):
+            flow_path = str(Path(flow_path) / (name + ".flowfile"))
+        elif name not in flow_path and name.endswith(".flowfile"):
+            flow_path = str(Path(flow_path) / name)
+        elif name not in flow_path and not name.endswith(".flowfile"):
+            flow_path = str(Path(flow_path) / (name + ".flowfile"))
+    if flow_path is not None:
+        flow_path_ref = Path(flow_path)
+        if not flow_path_ref.parent.exists():
+            raise HTTPException(422, 'The directory does not exist')
+    return flow_file_handler.add_flow(name=name, flow_path=flow_path)
 
 
 @router.post('/editor/close_flow/', tags=['editor'])
@@ -471,6 +519,7 @@ def add_generic_settings(input_data: Dict[str, Any], node_type: str, current_use
     add_func = getattr(flow, 'add_' + node_type)
     parsed_input = None
     setting_name_ref = 'node' + node_type.replace('_', '')
+
     if add_func is None:
         raise HTTPException(404, 'could not find the function')
     try:

flowfile_core/schemas/input_schema.py

@@ -196,7 +196,6 @@ class NodeBase(BaseModel):
     user_id: Optional[int] = None
     is_flow_output: Optional[bool] = False
 
-
 class NodeSingleInput(NodeBase):
     """A base model for any node that takes a single data input."""
     depending_on_id: Optional[int] = -1

flowfile_core/schemas/output_model.py

@@ -1,4 +1,4 @@
-from typing import List, Dict, Optional, Any
+from typing import List, Dict, Optional, Any, Literal
 from pydantic import BaseModel, Field
 from datetime import datetime
 import time
@@ -21,10 +21,11 @@ class RunInformation(BaseModel):
     flow_id: int
     start_time: Optional[datetime] = Field(default_factory=datetime.now)
     end_time: Optional[datetime] = None
-    success: bool
+    success: Optional[bool] = None
     nodes_completed: int = 0
     number_of_nodes: int = 0
     node_step_result: List[NodeResult]
+    run_type: Literal["fetch_one", "full_run"]
 
 
 class BaseItem(BaseModel):
@@ -61,6 +62,8 @@ class TableExample(BaseModel):
     table_schema: List[FileColumn]
     columns: List[str]
     data: Optional[List[Dict]] = {}
+    has_example_data: bool = False
+    has_run_with_current_setup: bool = False
 
 
 class NodeData(BaseModel):

flowfile_core/schemas/schemas.py

@@ -138,6 +138,8 @@ class NodeTemplate(BaseModel):
     node_group: str
     prod_ready: bool = True
     can_be_start: bool = False
+    drawer_title: str = "Node title"
+    drawer_intro: str = "Drawer into"
 
 
 class NodeInformation(BaseModel):