griptape-nodes 0.51.2__py3-none-any.whl → 0.52.0__py3-none-any.whl

griptape_nodes/retained_mode/managers/workflow_manager.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import ast
+import asyncio
 import logging
 import pickle
 import pkgutil
@@ -57,6 +58,9 @@ from griptape_nodes.retained_mode.events.workflow_events import (
     ImportWorkflowAsReferencedSubFlowRequest,
     ImportWorkflowAsReferencedSubFlowResultFailure,
     ImportWorkflowAsReferencedSubFlowResultSuccess,
+    ImportWorkflowRequest,
+    ImportWorkflowResultFailure,
+    ImportWorkflowResultSuccess,
     ListAllWorkflowsRequest,
     ListAllWorkflowsResultFailure,
     ListAllWorkflowsResultSuccess,
@@ -271,6 +275,10 @@ class WorkflowManager:
             ImportWorkflowAsReferencedSubFlowRequest,
             self.on_import_workflow_as_referenced_sub_flow_request,
         )
+        event_manager.assign_manager_to_request_type(
+            ImportWorkflowRequest,
+            self.on_import_workflow_request,
+        )
         event_manager.assign_manager_to_request_type(
             BranchWorkflowRequest,
             self.on_branch_workflow_request,
@@ -621,6 +629,38 @@ class WorkflowManager:
             return RegisterWorkflowResultFailure(result_details=details)
         return RegisterWorkflowResultSuccess(workflow_name=workflow.metadata.name)
 
+    def on_import_workflow_request(self, request: ImportWorkflowRequest) -> ResultPayload:
+        # First, attempt to load metadata from the file
+        load_metadata_request = LoadWorkflowMetadata(file_name=request.file_path)
+        load_metadata_result = self.on_load_workflow_metadata_request(load_metadata_request)
+
+        if not isinstance(load_metadata_result, LoadWorkflowMetadataResultSuccess):
+            return ImportWorkflowResultFailure(result_details=load_metadata_result.result_details)
+
+        # Check if workflow is already registered
+        workflow_name = load_metadata_result.metadata.name
+        if WorkflowRegistry.has_workflow_with_name(workflow_name):
+            # Workflow already exists - no need to re-register
+            return ImportWorkflowResultSuccess(workflow_name=workflow_name)
+
+        # Now register the workflow with the extracted metadata
+        register_request = RegisterWorkflowRequest(metadata=load_metadata_result.metadata, file_name=request.file_path)
+        register_result = self.on_register_workflow_request(register_request)
+
+        if not isinstance(register_result, RegisterWorkflowResultSuccess):
+            return ImportWorkflowResultFailure(result_details=register_result.result_details)
+
+        # Add the workflow to the user configuration
+        try:
+            full_path = WorkflowRegistry.get_complete_file_path(request.file_path)
+            GriptapeNodes.ConfigManager().save_user_workflow_json(full_path)
+        except Exception as e:
+            details = f"Failed to add workflow '{register_result.workflow_name}' to user configuration: {e}"
+
+            return ImportWorkflowResultFailure(result_details=details)
+
+        return ImportWorkflowResultSuccess(workflow_name=register_result.workflow_name)
+
     def on_list_all_workflows_request(self, _request: ListAllWorkflowsRequest) -> ResultPayload:
         try:
             workflows = WorkflowRegistry.list_workflows()
@@ -1358,10 +1398,20 @@ class WorkflowManager:
                     file_name = new_file_name
 
         # Get file name stuff prepped.
-        if not file_name:
-            file_name = datetime.now(tz=UTC).strftime("%d.%m_%H.%M")
-        relative_file_path = f"{file_name}.py"
-        file_path = GriptapeNodes.ConfigManager().workspace_path.joinpath(relative_file_path)
+        # Use the existing registered file path if this is an existing workflow (not a template)
+        if prior_workflow and not prior_workflow.metadata.is_template:
+            # Use the existing registered file path
+            relative_file_path = prior_workflow.file_path
+            file_path = Path(WorkflowRegistry.get_complete_file_path(relative_file_path))
+            # Extract file name from the path for metadata generation
+            if not file_name:
+                file_name = prior_workflow.metadata.name
+        else:
+            # Create new path in workspace for new workflows or templates
+            if not file_name:
+                file_name = datetime.now(tz=UTC).strftime("%d.%m_%H.%M")
+            relative_file_path = f"{file_name}.py"
+            file_path = GriptapeNodes.ConfigManager().workspace_path.joinpath(relative_file_path)
 
         # Generate the workflow file contents
         try:
@@ -1384,20 +1434,17 @@ class WorkflowManager:
             logger.error(details)
             return SaveWorkflowResultFailure(result_details=details)
 
-        relative_serialized_file_path = f"{file_name}.py"
-        serialized_file_path = GriptapeNodes.ConfigManager().workspace_path.joinpath(relative_serialized_file_path)
-
         # Check disk space before writing
         config_manager = GriptapeNodes.ConfigManager()
         min_space_gb = config_manager.get_config_value("minimum_disk_space_gb_workflows")
-        if not OSManager.check_available_disk_space(serialized_file_path.parent, min_space_gb):
-            error_msg = OSManager.format_disk_space_error(serialized_file_path.parent)
+        if not OSManager.check_available_disk_space(file_path.parent, min_space_gb):
+            error_msg = OSManager.format_disk_space_error(file_path.parent)
             details = f"Attempted to save workflow '{file_name}' (requires {min_space_gb:.1f} GB). Failed: {error_msg}"
             logger.error(details)
             return SaveWorkflowResultFailure(result_details=details)
 
         try:
-            with serialized_file_path.open("w", encoding="utf-8") as file:
+            with file_path.open("w", encoding="utf-8") as file:
                 file.write(final_code_output)
         except OSError as e:
             details = f"Attempted to save workflow '{file_name}'. Failed when writing file: {e}"
@@ -1407,19 +1454,21 @@ class WorkflowManager:
         # save the created workflow as an entry in the JSON config file.
         registered_workflows = WorkflowRegistry.list_workflows()
         if file_name not in registered_workflows:
-            try:
-                GriptapeNodes.ConfigManager().save_user_workflow_json(str(file_path))
-            except OSError as e:
-                details = f"Attempted to save workflow '{file_name}'. Failed when saving configuration: {e}"
-                logger.error(details)
-                return SaveWorkflowResultFailure(result_details=details)
+            # Only add to config if it's in the workspace directory (not an external file)
+            if not Path(relative_file_path).is_absolute():
+                try:
+                    GriptapeNodes.ConfigManager().save_user_workflow_json(str(file_path))
+                except OSError as e:
+                    details = f"Attempted to save workflow '{file_name}'. Failed when saving configuration: {e}"
+                    logger.error(details)
+                    return SaveWorkflowResultFailure(result_details=details)
             WorkflowRegistry.generate_new_workflow(metadata=workflow_metadata, file_path=relative_file_path)
         # Update existing workflow's metadata in the registry
         existing_workflow = WorkflowRegistry.get_workflow_by_name(file_name)
         existing_workflow.metadata = workflow_metadata
-        details = f"Successfully saved workflow to: {serialized_file_path}"
+        details = f"Successfully saved workflow to: {file_path}"
         logger.info(details)
-        return SaveWorkflowResultSuccess(file_path=str(serialized_file_path))
+        return SaveWorkflowResultSuccess(file_path=str(file_path))
 
     def _generate_workflow_metadata(  # noqa: PLR0913
         self,
@@ -1515,6 +1564,7 @@ class WorkflowManager:
 
         # === imports ===
         import_recorder.add_import("argparse")
+        import_recorder.add_import("asyncio")
         import_recorder.add_import("json")
         import_recorder.add_from_import(
             "griptape_nodes.bootstrap.workflow_executors.local_workflow_executor", "LocalWorkflowExecutor"
@@ -1522,6 +1572,7 @@ class WorkflowManager:
         import_recorder.add_from_import(
             "griptape_nodes.bootstrap.workflow_executors.workflow_executor", "WorkflowExecutor"
         )
+        import_recorder.add_from_import("griptape_nodes.drivers.storage.storage_backend", "StorageBackend")
 
         # === 1) build the `def execute_workflow(input: dict, storage_backend: str = StorageBackend.LOCAL, workflow_executor: WorkflowExecutor | None = None) -> dict | None:` ===
         #   args
@@ -1554,6 +1605,16 @@ class WorkflowManager:
         # Generate the ensure flow context function call
         ensure_context_call = self._generate_ensure_flow_context_call()
 
+        # Convert string storage_backend to StorageBackend enum
+        storage_backend_convert = ast.Assign(
+            targets=[ast.Name(id="storage_backend_enum", ctx=ast.Store())],
+            value=ast.Call(
+                func=ast.Name(id="StorageBackend", ctx=ast.Load()),
+                args=[ast.Name(id="storage_backend", ctx=ast.Load())],
+                keywords=[],
+            ),
+        )
+
         # Create conditional logic: workflow_executor = workflow_executor or LocalWorkflowExecutor()
         executor_assign = ast.Assign(
             targets=[ast.Name(id="workflow_executor", ctx=ast.Store())],
@@ -1570,18 +1631,20 @@ class WorkflowManager:
             ),
         )
         run_call = ast.Expr(
-            value=ast.Call(
-                func=ast.Attribute(
-                    value=ast.Name(id="workflow_executor", ctx=ast.Load()),
-                    attr="run",
-                    ctx=ast.Load(),
-                ),
-                args=[],
-                keywords=[
-                    ast.keyword(arg="workflow_name", value=ast.Constant(flow_name)),
-                    ast.keyword(arg="flow_input", value=ast.Name(id="input", ctx=ast.Load())),
-                    ast.keyword(arg="storage_backend", value=ast.Name(id="storage_backend", ctx=ast.Load())),
-                ],
+            value=ast.Await(
+                value=ast.Call(
+                    func=ast.Attribute(
+                        value=ast.Name(id="workflow_executor", ctx=ast.Load()),
+                        attr="arun",
+                        ctx=ast.Load(),
+                    ),
+                    args=[],
+                    keywords=[
+                        ast.keyword(arg="workflow_name", value=ast.Constant(flow_name)),
+                        ast.keyword(arg="flow_input", value=ast.Name(id="input", ctx=ast.Load())),
+                        ast.keyword(arg="storage_backend", value=ast.Name(id="storage_backend_enum", ctx=ast.Load())),
+                    ],
+                )
             )
         )
         return_stmt = ast.Return(
@@ -1592,15 +1655,53 @@ class WorkflowManager:
             )
         )
 
-        func_def = ast.FunctionDef(
+        # === Generate async aexecute_workflow function ===
+        async_func_def = ast.AsyncFunctionDef(
+            name="aexecute_workflow",
+            args=args,
+            body=[ensure_context_call, storage_backend_convert, executor_assign, run_call, return_stmt],
+            decorator_list=[],
+            returns=return_annotation,
+            type_params=[],
+        )
+        ast.fix_missing_locations(async_func_def)
+
+        # === Generate sync execute_workflow function (backward compatibility wrapper) ===
+        sync_func_def = ast.FunctionDef(
             name="execute_workflow",
             args=args,
-            body=[ensure_context_call, executor_assign, run_call, return_stmt],
+            body=[
+                ast.Return(
+                    value=ast.Call(
+                        func=ast.Attribute(
+                            value=ast.Name(id="asyncio", ctx=ast.Load()),
+                            attr="run",
+                            ctx=ast.Load(),
+                        ),
+                        args=[
+                            ast.Call(
+                                func=ast.Name(id="aexecute_workflow", ctx=ast.Load()),
+                                args=[],
+                                keywords=[
+                                    ast.keyword(arg="input", value=ast.Name(id="input", ctx=ast.Load())),
+                                    ast.keyword(
+                                        arg="storage_backend", value=ast.Name(id="storage_backend", ctx=ast.Load())
+                                    ),
+                                    ast.keyword(
+                                        arg="workflow_executor", value=ast.Name(id="workflow_executor", ctx=ast.Load())
+                                    ),
+                                ],
+                            )
+                        ],
+                        keywords=[],
+                    )
+                )
+            ],
             decorator_list=[],
             returns=return_annotation,
             type_params=[],
         )
-        ast.fix_missing_locations(func_def)
+        ast.fix_missing_locations(sync_func_def)
 
         # === 2) build the `if __name__ == "__main__":` block ===
         main_test = ast.Compare(
@@ -1890,7 +1991,7 @@ class WorkflowManager:
         # Generate the ensure flow context function
         ensure_context_func = self._generate_ensure_flow_context_function(import_recorder)
 
-        return [ensure_context_func, func_def, if_node]
+        return [ensure_context_func, sync_func_def, async_func_def, if_node]
 
     def _generate_ensure_flow_context_function(
         self,
@@ -2094,6 +2195,9 @@ class WorkflowManager:
         import_recorder.add_from_import(
             "griptape_nodes.retained_mode.events.library_events", "GetAllInfoForAllLibrariesResultSuccess"
         )
+        import_recorder.add_from_import(
+            "griptape_nodes.retained_mode.events.library_events", "ReloadAllLibrariesRequest"
+        )
 
         code_blocks: list[ast.AST] = []
 
@@ -2168,24 +2272,22 @@ class WorkflowManager:
         )
         ast.fix_missing_locations(test)
 
-        # 3) the body: GriptapeNodes.LibraryManager().load_all_libraries_from_config()
+        # 3) the body: GriptapeNodes.handle_request(ReloadAllLibrariesRequest())
         # TODO (https://github.com/griptape-ai/griptape-nodes/issues/1615): Generate requests to load ONLY the libraries used in this workflow
         load_call = ast.Expr(
             value=ast.Call(
                 func=ast.Attribute(
-                    value=ast.Call(
-                        func=ast.Attribute(
-                            value=ast.Name(id="GriptapeNodes", ctx=ast.Load()),
-                            attr="LibraryManager",
-                            ctx=ast.Load(),
-                        ),
-                        args=[],
-                        keywords=[],
-                    ),
-                    attr="load_all_libraries_from_config",
+                    value=ast.Name(id="GriptapeNodes", ctx=ast.Load()),
+                    attr="handle_request",
                     ctx=ast.Load(),
                 ),
-                args=[],
+                args=[
+                    ast.Call(
+                        func=ast.Name(id="ReloadAllLibrariesRequest", ctx=ast.Load()),
+                        args=[],
+                        keywords=[],
+                    )
+                ],
                 keywords=[],
             )
         )
@@ -2954,7 +3056,8 @@ class WorkflowManager:
         set_parameter_value_asts.append(with_node_context)
         return set_parameter_value_asts
 
-    def _convert_parameter_to_minimal_dict(self, parameter: Parameter) -> dict[str, Any]:
+    @classmethod
+    def _convert_parameter_to_minimal_dict(cls, parameter: Parameter) -> dict[str, Any]:
         """Converts a parameter to a minimal dictionary for loading up a dynamic, black-box Node."""
         param_dict = parameter.to_dict()
         fields_to_include = [
@@ -2973,9 +3076,12 @@ class WorkflowManager:
             "traits",
             "ui_options",
             "settable",
-            "user_defined",
+            "is_user_defined",
         ]
         minimal_dict = {key: param_dict[key] for key in fields_to_include if key in param_dict}
+        minimal_dict["settable"] = bool(getattr(parameter, "settable", True))
+        minimal_dict["is_user_defined"] = bool(getattr(param_dict, "is_user_defined", True))
+
         return minimal_dict
 
     def _create_workflow_shape_from_nodes(
@@ -3053,7 +3159,7 @@ class WorkflowManager:
 
         return workflow_shape
 
-    def on_publish_workflow_request(self, request: PublishWorkflowRequest) -> ResultPayload:
+    async def on_publish_workflow_request(self, request: PublishWorkflowRequest) -> ResultPayload:
         try:
             publisher_name = request.publisher_name
             event_handler_mappings = GriptapeNodes.LibraryManager().get_registered_event_handlers(
@@ -3065,7 +3171,7 @@ class WorkflowManager:
                 msg = f"No publishing handler found for '{publisher_name}' in request type '{type(request).__name__}'."
                 raise ValueError(msg)  # noqa: TRY301
 
-            result = publishing_handler.handler(request)
+            result = await asyncio.to_thread(publishing_handler.handler, request)
             if isinstance(result, PublishWorkflowResultSuccess):
                 file = Path(result.published_workflow_file_path)
                 self._register_published_workflow_file(file)

griptape_nodes/retained_mode/variable_types.py

@@ -0,0 +1,18 @@
+from dataclasses import dataclass
+from enum import StrEnum
+from typing import Any
+
+
+class VariableScope(StrEnum):
+    CURRENT_FLOW_ONLY = "current_flow_only"
+    HIERARCHICAL = "hierarchical"
+    GLOBAL_ONLY = "global_only"
+    ALL = "all"  # For ListVariables to get all variables from all flows
+
+
+@dataclass
+class FlowVariable:
+    name: str
+    owning_flow_name: str | None  # None for global variables
+    type: str
+    value: Any

griptape_nodes/utils/__init__.py

@@ -1 +1,5 @@
 """Various utility functions."""
+
+from griptape_nodes.utils.async_utils import call_function
+
+__all__ = ["call_function"]

griptape_nodes/utils/async_utils.py

@@ -0,0 +1,89 @@
+"""Utilities for handling async/sync callback patterns."""
+
+from __future__ import annotations
+
+import asyncio
+import inspect
+import subprocess
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Sequence
+
+
+async def call_function(func: Callable[..., Any], *args: Any, **kwargs: Any) -> Any:
+    """Call a function, handling both sync and async cases.
+
+    Args:
+        func: The function to call (sync or async)
+        *args: Positional arguments to pass to the function
+        **kwargs: Keyword arguments to pass to the function
+
+    Returns:
+        The result of the function call
+    """
+    if inspect.iscoroutinefunction(func):
+        return await func(*args, **kwargs)
+    return func(*args, **kwargs)
+
+
+async def subprocess_run(
+    args: Sequence[str],
+    *,
+    capture_output: bool = False,
+    text: bool = False,
+    check: bool = False,
+) -> subprocess.CompletedProcess[str | bytes]:
+    """Run a subprocess asynchronously with an interface similar to subprocess.run().
+
+    Args:
+        args: Command and arguments to execute
+        capture_output: Whether to capture stdout and stderr
+        text: Whether to decode output as text
+        check: Whether to raise CalledProcessError on non-zero exit
+
+    Returns:
+        CompletedProcess with the result
+
+    Raises:
+        subprocess.CalledProcessError: If check=True and the process exits with non-zero code
+    """
+    if capture_output:
+        stdout_arg = asyncio.subprocess.PIPE
+        stderr_arg = asyncio.subprocess.PIPE
+    else:
+        stdout_arg = None
+        stderr_arg = None
+
+    process = await asyncio.create_subprocess_exec(
+        *args,
+        stdout=stdout_arg,
+        stderr=stderr_arg,
+    )
+
+    stdout_bytes, stderr_bytes = await process.communicate()
+
+    # Convert bytes to string if text=True
+    if text:
+        stdout = stdout_bytes.decode() if stdout_bytes else ""
+        stderr = stderr_bytes.decode() if stderr_bytes else ""
+    else:
+        stdout = stdout_bytes if stdout_bytes else b""
+        stderr = stderr_bytes if stderr_bytes else b""
+
+    completed_process = subprocess.CompletedProcess(
+        args=list(args),
+        returncode=process.returncode or 0,
+        stdout=stdout,
+        stderr=stderr,
+    )
+
+    if check and completed_process.returncode != 0:
+        raise subprocess.CalledProcessError(
+            completed_process.returncode,
+            args,
+            completed_process.stdout,
+            completed_process.stderr,
+        )
+
+    return completed_process

{griptape_nodes-0.51.2.dist-info → griptape_nodes-0.52.0.dist-info}/METADATA

@@ -1,8 +1,8 @@
 Metadata-Version: 2.3
 Name: griptape-nodes
-Version: 0.51.2
+Version: 0.52.0
 Summary: Add your description here
-Requires-Dist: griptape>=1.8.0
+Requires-Dist: griptape>=1.8.2
 Requires-Dist: pydantic>=2.10.6
 Requires-Dist: python-dotenv>=1.0.1
 Requires-Dist: xdg-base-dirs>=6.0.2
@@ -15,7 +15,6 @@ Requires-Dist: uvicorn>=0.34.2
 Requires-Dist: packaging>=25.0
 Requires-Dist: python-multipart>=0.0.20
 Requires-Dist: json-repair>=0.46.1
-Requires-Dist: imageio-ffmpeg>=0.6.0
 Requires-Dist: mcp[ws]>=1.10.1
 Requires-Dist: binaryornot>=0.4.4
 Requires-Dist: pillow>=11.3.0