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

flowfile_core/flowfile/flow_data_engine/subprocess_operations/subprocess_operations.py

@@ -23,15 +23,10 @@ from flowfile_core.flowfile.sources.external_sources.sql_source.models import (D
                                                                                DatabaseExternalWriteSettings)
 from flowfile_core.schemas.cloud_storage_schemas import CloudStorageWriteSettingsWorkerInterface
 from flowfile_core.schemas.input_schema import (
-    ReceivedCsvTable,
-    ReceivedExcelTable,
-    ReceivedJsonTable,
-    ReceivedParquetTable
+    ReceivedTable
 )
 from flowfile_core.utils.arrow_reader import read
 
-ReceivedTableCollection = ReceivedCsvTable | ReceivedParquetTable | ReceivedJsonTable | ReceivedExcelTable
-
 
 def trigger_df_operation(flow_id: int, node_id: int | str, lf: pl.LazyFrame, file_ref: str, operation_type: OperationType = 'store') -> Status:
     encoded_operation = encodebytes(lf.serialize()).decode()
@@ -74,7 +69,7 @@ def trigger_fuzzy_match_operation(left_df: pl.LazyFrame, right_df: pl.LazyFrame,
     return Status(**v.json())
 
 
-def trigger_create_operation(flow_id: int, node_id: int | str, received_table: ReceivedTableCollection,
+def trigger_create_operation(flow_id: int, node_id: int | str, received_table: ReceivedTable,
                              file_type: str = Literal['csv', 'parquet', 'json', 'excel']):
     f = requests.post(url=f'{WORKER_URL}/create_table/{file_type}', data=received_table.model_dump_json(),
                       params={'flowfile_flow_id': flow_id, 'flowfile_node_id': node_id})
@@ -194,87 +189,161 @@ def cancel_task(file_ref: str) -> bool:
 
 
 class BaseFetcher:
-    result: Optional[Any] = None
-    started: bool = False
-    running: bool = False
-    error_code: int = 0
-    error_description: Optional[str] = None
-    file_ref: Optional[str] = None
+    """
+    Thread-safe fetcher for polling worker status and retrieving results.
+    """
 
     def __init__(self, file_ref: str = None):
         self.file_ref = file_ref if file_ref else str(uuid4())
-        self.stop_event = threading.Event()
-        self.thread = threading.Thread(target=self._fetch_cached_df)
-        self.result = None
-        self.error_description = None
-        self.running = False
-        self.started = False
-        self.condition = threading.Condition()
-        self.error_code = 0
+
+        # Thread synchronization
+        self._lock = threading.Lock()
+        self._condition = threading.Condition(self._lock)
+        self._stop_event = threading.Event()
+        self._thread = None
+
+        # State variables - use properties for thread-safe access
+        self._result: Optional[Any] = None
+        self._started: bool = False
+        self._running: bool = False
+        self._error_code: int = 0
+        self._error_description: Optional[str] = None
+
+    # Public properties for compatibility with subclasses
+    @property
+    def result(self) -> Optional[Any]:
+        with self._lock:
+            return self._result
+
+    @property
+    def started(self) -> bool:
+        with self._lock:
+            return self._started
+
+    @property
+    def running(self) -> bool:
+        with self._lock:
+            return self._running
+
+    @running.setter
+    def running(self, value: bool):
+        """Allow subclasses to set running status and auto-start if needed."""
+        with self._lock:
+            self._running = value
+            # If subclass sets running=True, auto-start the thread
+            if value and not self._started:
+                self._start_thread()
+
+    @property
+    def error_code(self) -> int:
+        with self._lock:
+            return self._error_code
+
+    @property
+    def error_description(self) -> Optional[str]:
+        with self._lock:
+            return self._error_description
+
+    def _start_thread(self):
+        """Internal method to start thread (must be called under lock)."""
+        if not self._started:
+            self._thread = threading.Thread(target=self._fetch_cached_df, daemon=True)
+            self._thread.start()
+            self._started = True
 
     def _fetch_cached_df(self):
-        with self.condition:
-            if self.running:
-                logger.info('Already running the fetching')
-                return
+        """Background thread that polls for results."""
+        sleep_time = 0.5
 
-            sleep_time = .5
-            self.running = True
-            while not self.stop_event.is_set():
+        # Don't check _running here - subclasses already set it
+        try:
+            while not self._stop_event.is_set():
                 try:
-                    r = requests.get(f'{WORKER_URL}/status/{self.file_ref}')
+                    r = requests.get(f'{WORKER_URL}/status/{self.file_ref}', timeout=10)
+
                     if r.status_code == 200:
                         status = Status(**r.json())
+
                         if status.status == 'Completed':
                             self._handle_completion(status)
                             return
                         elif status.status == 'Error':
                             self._handle_error(1, status.error_message)
-                            break
+                            return
                         elif status.status == 'Unknown Error':
-                            self._handle_error(-1,
-                                               'There was an unknown error with the process, '
-                                               'and the process got killed by the server')
-                            break
+                            self._handle_error(
+                                -1,
+                                'There was an unknown error with the process, '
+                                'and the process got killed by the server'
+                            )
+                            return
                     else:
-                        self._handle_error(2, r.text)
-                        break
+                        self._handle_error(2, f"HTTP {r.status_code}: {r.text}")
+                        return
+
                 except requests.RequestException as e:
                     self._handle_error(2, f"Request failed: {e}")
-                    break
+                    return
 
-                sleep(sleep_time)
+                # Sleep without holding the lock
+                if not self._stop_event.wait(timeout=sleep_time):
+                    continue
+                else:
+                    break
 
+            # Only reached if stop_event was set
             self._handle_cancellation()
 
+        except Exception as e:
+            # Catch any unexpected errors
+            logger.exception("Unexpected error in fetch thread")
+            self._handle_error(-1, f"Unexpected error: {e}")
+
     def _handle_completion(self, status):
-        self.running = False
-        self.condition.notify_all()
-        if status.result_type == 'polars':
-            self.result = get_df_result(status.results)
-        else:
-            self.result = status.results
-
-    def _handle_error(self, code, description):
-        self.error_code = code
-        self.error_description = description
-        self.running = False
-        self.condition.notify_all()
+        """Handle successful completion. Must be called from fetch thread."""
+        with self._condition:
+            try:
+                if status.result_type == 'polars':
+                    self._result = get_df_result(status.results)
+                else:
+                    self._result = status.results
+            except Exception as e:
+                logger.exception("Error processing result")
+                self._error_code = -1
+                self._error_description = f"Error processing result: {e}"
+            finally:
+                self._running = False
+                self._condition.notify_all()
+
+    def _handle_error(self, code: int, description: str):
+        """Handle error state. Must be called from fetch thread."""
+        with self._condition:
+            self._error_code = code
+            self._error_description = description
+            self._running = False
+            self._condition.notify_all()
 
     def _handle_cancellation(self):
-        logger.warning("Fetch operation cancelled")
-        if self.error_description is not None:
-            logger.warning(self.error_description)
-        self.running = False
-        self.condition.notify_all()
+        """Handle cancellation. Must be called from fetch thread."""
+        with self._condition:
+            if self._error_description is None:
+                self._error_description = "Task cancelled"
+            logger.warning(f"Fetch operation cancelled: {self._error_description}")
+            self._running = False
+            self._condition.notify_all()
 
     def start(self):
-        if self.running:
-            logger.info('Already running the fetching')
-            return
-        if not self.started:
-            self.thread.start()
-            self.started = True
+        """Start the background fetch thread."""
+        with self._lock:
+            if self._started:
+                logger.info('Fetcher already started')
+                return
+            if self._running:
+                logger.info('Already running the fetching')
+                return
+
+            self._running = True
+            self._start_thread()
 
     def cancel(self):
         """
@@ -282,30 +351,67 @@ class BaseFetcher:
         Also cleans up any resources being used.
         """
         logger.warning('Cancelling the operation')
+
+        # Cancel on the worker side
         try:
             cancel_task(self.file_ref)
         except Exception as e:
             logger.error(f'Failed to cancel task on worker: {str(e)}')
 
-        # Then stop the local monitoring thread
-        self.stop_event.set()
-        self.thread.join()
+        # Signal the thread to stop
+        self._stop_event.set()
 
-        # Update local state
-        with self.condition:
-            self.running = False
-            self.error_description = "Task cancelled by user"
-            self.condition.notify_all()
+        # Wait for thread to finish
+        if self._thread and self._thread.is_alive():
+            self._thread.join(timeout=5.0)
+            if self._thread.is_alive():
+                logger.warning("Fetch thread did not stop within timeout")
 
     def get_result(self) -> Optional[Any]:
-        if not self.started:
-            self.start()
-        with self.condition:
-            while self.running and self.result is None:
-                self.condition.wait()  # Wait until notified
-        if self.error_description is not None:
-            raise Exception(self.error_description)
-        return self.result
+        """
+        Get the result, blocking until it's available.
+
+        Returns:
+            The fetched result.
+
+        Raises:
+            Exception: If an error occurred during fetching.
+        """
+        # Start if not already started (for manual usage)
+        with self._lock:
+            if not self._started:
+                if not self._running:
+                    self._running = True
+                self._start_thread()
+
+        # Wait for completion
+        with self._condition:
+            while self._running:
+                self._condition.wait()
+
+        # Check for errors
+        with self._lock:
+            if self._error_description is not None:
+                raise Exception(self._error_description)
+            return self._result
+
+    @property
+    def is_running(self) -> bool:
+        """Check if the fetcher is currently running."""
+        with self._lock:
+            return self._running
+
+    @property
+    def has_error(self) -> bool:
+        """Check if the fetcher encountered an error."""
+        with self._lock:
+            return self._error_description is not None
+
+    @property
+    def error_info(self) -> tuple[int, Optional[str]]:
+        """Get error code and description."""
+        with self._lock:
+            return self._error_code, self._error_description
 
 
 class ExternalDfFetcher(BaseFetcher):
@@ -354,7 +460,7 @@ class ExternalFuzzyMatchFetcher(BaseFetcher):
 
 
 class ExternalCreateFetcher(BaseFetcher):
-    def __init__(self, received_table: ReceivedTableCollection, node_id: int, flow_id: int,
+    def __init__(self, received_table: ReceivedTable, node_id: int, flow_id: int,
                  file_type: str = 'csv', wait_on_completion: bool = True):
         r = trigger_create_operation(received_table=received_table, file_type=file_type,
                                      node_id=node_id, flow_id=flow_id)

flowfile_core/flowfile/flow_data_engine/utils.py

@@ -23,8 +23,10 @@ def get_data_type(vals: Iterable[Any]):
 def calculate_schema(lf: pl.LazyFrame) -> List[Dict]:
     r = ExternalDfFetcher(lf=lf, operation_type='calculate_schema', wait_on_completion=False, flow_id=-1, node_id=-1)
     schema_stats: List[Dict] = r.get_result()
+
     for schema_stat in schema_stats:
         schema_stat['pl_datatype'] = getattr(pl.datatypes, schema_stat['pl_datatype'])
+
     return schema_stats
 
 

flowfile_core/flowfile/flow_graph.py

@@ -1,9 +1,11 @@
 import datetime
-import pickle
 
 import os
+import yaml
+import json
 
 import polars as pl
+from pathlib import Path
 
 import fastexcel
 from fastapi.exceptions import HTTPException
@@ -19,6 +21,7 @@ from flowfile_core.flowfile.sources.external_sources.factory import data_source_
 from flowfile_core.flowfile.flow_data_engine.flow_file_column.main import FlowfileColumn, cast_str_to_polars_type
 
 from flowfile_core.flowfile.flow_data_engine.cloud_storage_reader import CloudStorageReader
+from flowfile_core.schemas.transform_schema import FuzzyMatchInputManager
 from flowfile_core.utils.arrow_reader import get_read_top_n
 from flowfile_core.flowfile.flow_data_engine.flow_data_engine import FlowDataEngine, execute_polars_code
 from flowfile_core.flowfile.flow_data_engine.read_excel_tables import (get_open_xlsx_datatypes,
@@ -52,6 +55,22 @@ from flowfile_core.flowfile.database_connection_manager.db_connections import (g
                                                                                get_local_cloud_connection)
 from flowfile_core.flowfile.util.calculate_layout import calculate_layered_layout
 from flowfile_core.flowfile.node_designer.custom_node import CustomNodeBase
+from importlib.metadata import version, PackageNotFoundError
+
+try:
+    __version__ = version("Flowfile")
+except PackageNotFoundError:
+    __version__ = "0.0.0-dev"
+
+
+def represent_list_json(dumper, data):
+    """Use inline style for short simple lists, block style for complex ones."""
+    if len(data) <= 10 and all(isinstance(item, (int, str, float, bool, type(None))) for item in data):
+        return dumper.represent_sequence('tag:yaml.org,2002:seq', data, flow_style=True)
+    return dumper.represent_sequence('tag:yaml.org,2002:seq', data, flow_style=False)
+
+
+yaml.add_representer(list, represent_list_json)
 
 
 def get_xlsx_schema(engine: str, file_path: str, sheet_name: str, start_row: int, start_column: int,
@@ -152,7 +171,7 @@ def get_cloud_connection_settings(connection_name: str,
         HTTPException: If the connection settings cannot be found.
     """
     cloud_connection_settings = get_local_cloud_connection(connection_name, user_id)
-    if cloud_connection_settings is None and auth_mode in ("env_vars", "auto"):
+    if cloud_connection_settings is None and auth_mode in ("env_vars", transform_schema.AUTO_DATA_TYPE):
         # If the auth mode is aws-cli, we do not need connection settings
         cloud_connection_settings = FullCloudStorageConnection(storage_type="s3", auth_method="env_vars")
     elif cloud_connection_settings is None and auth_mode == "aws-cli":
@@ -223,7 +242,7 @@ class FlowGraph:
         self._node_ids = []
         self._node_db = {}
         self.cache_results = cache_results
-        self.__name__ = name if name else id(self)
+        self.__name__ = name if name else "flow_" + str(id(self))
         self.depends_on = {}
         if path_ref is not None:
             self.add_datasource(input_schema.NodeDatasource(file_path=path_ref))
@@ -733,11 +752,11 @@ class FlowGraph:
         """
 
         error = ""
-        if function_settings.function.field.data_type not in (None, "Auto"):
+        if function_settings.function.field.data_type not in (None, transform_schema.AUTO_DATA_TYPE):
             output_type = cast_str_to_polars_type(function_settings.function.field.data_type)
         else:
             output_type = None
-        if output_type not in (None, "Auto"):
+        if output_type not in (None, transform_schema.AUTO_DATA_TYPE):
             new_col = [FlowfileColumn.from_input(column_name=function_settings.function.field.name,
                                                  data_type=str(output_type))]
         else:
@@ -755,6 +774,7 @@ class FlowGraph:
                            setting_input=function_settings,
                            input_node_ids=[function_settings.depending_on_id]
                            )
+        # TODO: Add validation here
         if error != "":
             node = self.get_node(function_settings.node_id)
             node.results.errors = error
@@ -771,13 +791,11 @@ class FlowGraph:
         Returns:
             The `FlowGraph` instance for method chaining.
         """
-
         def _func(main: FlowDataEngine, right: FlowDataEngine) -> FlowDataEngine:
             for left_select in cross_join_settings.cross_join_input.left_select.renames:
                 left_select.is_available = True if left_select.old_name in main.schema else False
             for right_select in cross_join_settings.cross_join_input.right_select.renames:
                 right_select.is_available = True if right_select.old_name in right.schema else False
-
             return main.do_cross_join(cross_join_input=cross_join_settings.cross_join_input,
                                       auto_generate_selection=cross_join_settings.auto_generate_selection,
                                       verify_integrity=False,
@@ -800,13 +818,11 @@ class FlowGraph:
         Returns:
             The `FlowGraph` instance for method chaining.
         """
-
         def _func(main: FlowDataEngine, right: FlowDataEngine) -> FlowDataEngine:
             for left_select in join_settings.join_input.left_select.renames:
                 left_select.is_available = True if left_select.old_name in main.schema else False
             for right_select in join_settings.join_input.right_select.renames:
                 right_select.is_available = True if right_select.old_name in right.schema else False
-
             return main.join(join_input=join_settings.join_input,
                              auto_generate_selection=join_settings.auto_generate_selection,
                              verify_integrity=False,
@@ -844,7 +860,7 @@ class FlowGraph:
             return FlowDataEngine(f.get_result())
 
         def schema_callback():
-            fm_input_copy = deepcopy(fuzzy_settings.join_input)  # Deepcopy create an unique object per func
+            fm_input_copy = FuzzyMatchInputManager(fuzzy_settings.join_input)  # Deepcopy create an unique object per func
             node = self.get_node(node_id=fuzzy_settings.node_id)
             return calculate_fuzzy_match_schema(fm_input_copy,
                                                 left_schema=node.node_inputs.main_inputs[0].schema,
@@ -1131,7 +1147,6 @@ class FlowGraph:
         """
 
         def _func(df: FlowDataEngine):
-            output_file.output_settings.populate_abs_file_path()
             execute_remote = self.execution_location != 'local'
             df.output(output_fs=output_file.output_settings, flow_id=self.flow_id, node_id=output_file.node_id,
                       execute_remote=execute_remote)
@@ -1451,10 +1466,10 @@ class FlowGraph:
         Args:
             input_file: The settings for the read operation.
         """
-
-        if input_file.received_file.file_type in ('xlsx', 'excel') and input_file.received_file.sheet_name == '':
+        if (input_file.received_file.file_type in ('xlsx', 'excel') and
+                input_file.received_file.table_settings.sheet_name == ''):
             sheet_name = fastexcel.read_excel(input_file.received_file.path).sheet_names[0]
-            input_file.received_file.sheet_name = sheet_name
+            input_file.received_file.table_settings.sheet_name = sheet_name
 
         received_file = input_file.received_file
         input_file.received_file.set_absolute_filepath()
@@ -1463,7 +1478,7 @@ class FlowGraph:
             input_file.received_file.set_absolute_filepath()
             if input_file.received_file.file_type == 'parquet':
                 input_data = FlowDataEngine.create_from_path(input_file.received_file)
-            elif input_file.received_file.file_type == 'csv' and 'utf' in input_file.received_file.encoding:
+            elif input_file.received_file.file_type == 'csv' and 'utf' in input_file.received_file.table_settings.encoding:
                 input_data = FlowDataEngine.create_from_path(input_file.received_file)
             else:
                 input_data = FlowDataEngine.create_from_path_worker(input_file.received_file,
@@ -1500,12 +1515,12 @@ class FlowGraph:
                     # If the file is an Excel file, we need to use the openpyxl engine to read the schema
                     schema_callback = get_xlsx_schema_callback(engine='openpyxl',
                                                                file_path=received_file.file_path,
-                                                               sheet_name=received_file.sheet_name,
-                                                               start_row=received_file.start_row,
-                                                               end_row=received_file.end_row,
-                                                               start_column=received_file.start_column,
-                                                               end_column=received_file.end_column,
-                                                               has_headers=received_file.has_headers)
+                                                               sheet_name=received_file.table_settings.sheet_name,
+                                                               start_row=received_file.table_settings.start_row,
+                                                               end_row=received_file.table_settings.end_row,
+                                                               start_column=received_file.table_settings.start_column,
+                                                               end_column=received_file.table_settings.end_column,
+                                                               has_headers=received_file.table_settings.has_headers)
                 else:
                     schema_callback = None
         else:
@@ -1636,6 +1651,13 @@ class FlowGraph:
             run_type=run_type
         )
 
+    def create_empty_run_information(self) -> RunInformation:
+        return RunInformation(
+            flow_id=self.flow_id, start_time=None, end_time=None,
+            success=None, number_of_nodes=0, node_step_result=[],
+            run_type="init"
+        )
+
     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:
@@ -1746,6 +1768,7 @@ class FlowGraph:
                     skip_nodes.extend(list(node.get_all_dependent_nodes()))
                 node_logger.info(f'Completed node with success: {node_result.success}')
                 self.latest_run_info.nodes_completed += 1
+            self.latest_run_info.end_time = datetime.datetime.now()
             self.flow_logger.info('Flow completed!')
             self.end_datetime = datetime.datetime.now()
             self.flow_settings.is_running = False
@@ -1757,7 +1780,7 @@ class FlowGraph:
         finally:
             self.flow_settings.is_running = False
 
-    def get_run_info(self) -> RunInformation | None:
+    def get_run_info(self) -> RunInformation:
         """Gets a summary of the most recent graph execution.
 
         Returns:
@@ -1765,7 +1788,7 @@ class FlowGraph:
         """
         is_running = self.flow_settings.is_running
         if self.latest_run_info is None:
-            return
+            return self.create_empty_run_information()
 
         elif not is_running and self.latest_run_info.success is not None:
             return self.latest_run_info
@@ -1806,6 +1829,42 @@ class FlowGraph:
         node = self._node_db[node_id]
         return node.get_node_data(flow_id=self.flow_id, include_example=include_example)
 
+    def get_flowfile_data(self) -> schemas.FlowfileData:
+        start_node_ids = {v.node_id for v in self._flow_starts}
+
+        nodes = []
+        for node in self.nodes:
+            node_info = node.get_node_information()
+            flowfile_node = schemas.FlowfileNode(
+                id=node_info.id,
+                type=node_info.type,
+                is_start_node=node.node_id in start_node_ids,
+                description=node_info.description,
+                x_position=int(node_info.x_position),
+                y_position=int(node_info.y_position),
+                left_input_id=node_info.left_input_id,
+                right_input_id=node_info.right_input_id,
+                input_ids=node_info.input_ids,
+                outputs=node_info.outputs,
+                setting_input=node_info.setting_input,
+            )
+            nodes.append(flowfile_node)
+
+        settings = schemas.FlowfileSettings(
+            description=self.flow_settings.description,
+            execution_mode=self.flow_settings.execution_mode,
+            execution_location=self.flow_settings.execution_location,
+            auto_save=self.flow_settings.auto_save,
+            show_detailed_progress=self.flow_settings.show_detailed_progress,
+        )
+        return schemas.FlowfileData(
+            flowfile_version=__version__,
+            flowfile_id=self.flow_id,
+            flowfile_name=self.__name__,
+            flowfile_settings=settings,
+            nodes=nodes,
+        )
+
     def get_node_storage(self) -> schemas.FlowInformation:
         """Serializes the entire graph's state into a storable format.
 
@@ -1838,19 +1897,63 @@ class FlowGraph:
         for node in self.nodes:
             node.remove_cache()
 
+    def _handle_flow_renaming(self, new_name: str, new_path: Path):
+        """
+        Handle the rename of a flow when it is being saved.
+        """
+        if self.flow_settings and self.flow_settings.path and Path(self.flow_settings.path).absolute() != new_path.absolute():
+            self.__name__ = new_name
+            self.flow_settings.save_location = str(new_path.absolute())
+            self.flow_settings.name = new_name
+        if self.flow_settings and not self.flow_settings.save_location:
+            self.flow_settings.save_location = str(new_path.absolute())
+            self.__name__ = new_name
+            self.flow_settings.name = new_name
+
     def save_flow(self, flow_path: str):
         """Saves the current state of the flow graph to a file.
 
+        Supports multiple formats based on file extension:
+        - .yaml / .yml: New YAML format
+        - .json: JSON format
+
         Args:
             flow_path: The path where the flow file will be saved.
         """
         logger.info("Saving flow to %s", flow_path)
-        os.makedirs(os.path.dirname(flow_path), exist_ok=True)
+        path = Path(flow_path)
+        os.makedirs(path.parent, exist_ok=True)
+        suffix = path.suffix.lower()
+        new_flow_name = path.name.replace(suffix, "")
+        self._handle_flow_renaming(new_flow_name, path)
+        self.flow_settings.modified_on = datetime.datetime.now().timestamp()
         try:
-            with open(flow_path, 'wb') as f:
-                pickle.dump(self.get_node_storage(), f)
+            if suffix == '.flowfile':
+                raise DeprecationWarning(
+                    f"The .flowfile format is deprecated. Please use .yaml or .json formats.\n\n"
+                    "Or stay on v0.4.1 if you still need .flowfile support.\n\n"
+                )
+            elif suffix in ('.yaml', '.yml'):
+                flowfile_data = self.get_flowfile_data()
+                data = flowfile_data.model_dump(mode='json')
+                with open(flow_path, 'w', encoding='utf-8') as f:
+                    yaml.dump(data, f, default_flow_style=False, sort_keys=False, allow_unicode=True)
+            elif suffix == '.json':
+                flowfile_data = self.get_flowfile_data()
+                data = flowfile_data.model_dump(mode='json')
+                with open(flow_path, 'w', encoding='utf-8') as f:
+                    json.dump(data, f, indent=2, ensure_ascii=False)
+
+            else:
+                flowfile_data = self.get_flowfile_data()
+                logger.warning(f"Unknown file extension {suffix}. Defaulting to YAML format.")
+                data = flowfile_data.model_dump(mode='json')
+                with open(flow_path, 'w', encoding='utf-8') as f:
+                    yaml.dump(data, f, default_flow_style=False, sort_keys=False, allow_unicode=True)
+
         except Exception as e:
             logger.error(f"Error saving flow: {e}")
+            raise
 
         self.flow_settings.path = flow_path