griptape-nodes 0.45.0__tar.gz → 0.46.0__tar.gz

{griptape_nodes-0.45.0 → griptape_nodes-0.46.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: griptape-nodes
-Version: 0.45.0
+Version: 0.46.0
 Summary: Add your description here
 Requires-Dist: griptape>=1.8.0
 Requires-Dist: pydantic>=2.10.6

{griptape_nodes-0.45.0 → griptape_nodes-0.46.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "griptape-nodes"
-version = "0.45.0"
+version = "0.46.0"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.12.0, <3.13"

{griptape_nodes-0.45.0 → griptape_nodes-0.46.0}/src/griptape_nodes/__init__.py

@@ -154,21 +154,23 @@ def _handle_storage_backend_config(config: InitConfig) -> str | None:
     return storage_backend
 
 
-def _handle_bucket_config(config: InitConfig, storage_backend: str | None) -> str | None:
-    """Handle bucket configuration step (depends on API key and storage backend)."""
-    storage_backend_bucket_id = None
+def _handle_bucket_config(config: InitConfig) -> str | None:
+    """Handle bucket configuration step (depends on API key)."""
+    bucket_id = None
 
-    if storage_backend == StorageBackend.GTC.value:
-        if config.interactive:
-            storage_backend_bucket_id = _prompt_for_gtc_bucket_name(default_bucket_name=config.bucket_name)
-        elif config.bucket_name is not None:
-            storage_backend_bucket_id = _get_or_create_bucket_id(config.bucket_name)
+    if config.interactive:
+        # First ask if they want to configure a bucket
+        configure_bucket = _prompt_for_bucket_configuration()
+        if configure_bucket:
+            bucket_id = _prompt_for_gtc_bucket_name(default_bucket_name=config.bucket_name)
+    elif config.bucket_name is not None:
+        bucket_id = _get_or_create_bucket_id(config.bucket_name)
 
-    if storage_backend_bucket_id is not None:
-        secrets_manager.set_secret("GT_CLOUD_BUCKET_ID", storage_backend_bucket_id)
-        console.print(f"[bold green]Storage backend bucket ID set to: {storage_backend_bucket_id}[/bold green]")
+    if bucket_id is not None:
+        secrets_manager.set_secret("GT_CLOUD_BUCKET_ID", bucket_id)
+        console.print(f"[bold green]Bucket ID set to: {bucket_id}[/bold green]")
 
-    return storage_backend_bucket_id
+    return bucket_id
 
 
 def _handle_advanced_library_config(config: InitConfig) -> bool | None:
@@ -211,9 +213,9 @@ def _run_init_configuration(config: InitConfig) -> None:
 
     _handle_workspace_config(config)
 
-    storage_backend = _handle_storage_backend_config(config)
+    _handle_storage_backend_config(config)
 
-    _handle_bucket_config(config, storage_backend)
+    _handle_bucket_config(config)
 
     _handle_advanced_library_config(config)
 
@@ -477,6 +479,41 @@ def _get_griptape_cloud_buckets_and_display_table() -> tuple[list[str], dict[str
     return bucket_names, name_to_id, table
 
 
+def _prompt_for_bucket_configuration() -> bool:
+    """Prompts the user whether to configure a bucket for multi-machine workflow and asset syncing."""
+    # Check if there's already a bucket configured
+    current_bucket_id = secrets_manager.get_secret("GT_CLOUD_BUCKET_ID", should_error_on_not_found=False)
+
+    if current_bucket_id:
+        explainer = f"""[bold cyan]Griptape Cloud Bucket Configuration[/bold cyan]
+    You currently have a bucket configured (ID: {current_bucket_id}).
+
+    Buckets are used for multi-machine workflow and asset syncing, allowing you to:
+    - Share workflows and assets across multiple devices
+    - Sync generated content between different Griptape Nodes instances
+    - Access your work from anywhere
+
+    Would you like to change your selected bucket or keep the current one?"""
+        prompt_text = "Change selected Griptape Cloud bucket?"
+        default_value = False
+    else:
+        explainer = """[bold cyan]Griptape Cloud Bucket Configuration[/bold cyan]
+    Would you like to configure a Griptape Cloud bucket?
+    Buckets are used for multi-machine workflow and asset syncing, allowing you to:
+    - Share workflows and assets across multiple devices
+    - Sync generated content between different Griptape Nodes instances
+    - Access your work from anywhere
+
+    If you do not intend to use Griptape Nodes to collaborate or revision control your workflows, you can skip this step.
+
+    You can always configure a bucket later by running the initialization process again."""
+        prompt_text = "Configure Griptape Cloud bucket?"
+        default_value = False
+
+    console.print(Panel(explainer, expand=False))
+    return Confirm.ask(prompt_text, default=default_value)
+
+
 def _prompt_for_gtc_bucket_name(default_bucket_name: str | None = None) -> str:
     """Prompts the user for a GTC bucket and returns the bucket ID."""
     explainer = """[bold cyan]Storage Backend Bucket Selection[/bold cyan]

{griptape_nodes-0.45.0 → griptape_nodes-0.46.0}/src/griptape_nodes/node_library/workflow_registry.py

@@ -13,7 +13,7 @@ from griptape_nodes.utils.metaclasses import SingletonMeta
 
 
 class WorkflowMetadata(BaseModel):
-    LATEST_SCHEMA_VERSION: ClassVar[str] = "0.6.1"
+    LATEST_SCHEMA_VERSION: ClassVar[str] = "0.7.0"
 
     name: str
     schema_version: str

{griptape_nodes-0.45.0 → griptape_nodes-0.46.0}/src/griptape_nodes/retained_mode/events/workflow_events.py

@@ -31,7 +31,7 @@ class RunWorkflowFromScratchRequest(RequestPayload):
 
 @dataclass
 @PayloadRegistry.register
-class RunWorkflowFromScratchResultSuccess(WorkflowAlteredMixin, ResultPayloadSuccess):
+class RunWorkflowFromScratchResultSuccess(ResultPayloadSuccess):
     """Workflow loaded and started successfully from file."""
 
 
@@ -91,7 +91,7 @@ class RunWorkflowFromRegistryRequest(RequestPayload):
 
 @dataclass
 @PayloadRegistry.register
-class RunWorkflowFromRegistryResultSuccess(WorkflowAlteredMixin, ResultPayloadSuccess):
+class RunWorkflowFromRegistryResultSuccess(ResultPayloadSuccess):
     """Workflow from registry started successfully."""
 
 
@@ -347,6 +347,8 @@ class PublishWorkflowRequest(RequestPayload):
 
     workflow_name: str
     publisher_name: str
+    execute_on_publish: bool = False
+    published_workflow_file_name: str | None = None
 
 
 @dataclass

{griptape_nodes-0.45.0 → griptape_nodes-0.46.0}/src/griptape_nodes/retained_mode/managers/node_manager.py

@@ -1480,11 +1480,7 @@ class NodeManager:
                 return SetParameterValueResultFailure()
         if request.initial_setup is False and not request.is_output and modified:
             # Mark node as unresolved, broadcast an event
-            node.make_node_unresolved(
-                current_states_to_trigger_change_event=set(
-                    {NodeResolutionState.RESOLVED, NodeResolutionState.RESOLVING}
-                )
-            )
+            node.make_node_unresolved(current_states_to_trigger_change_event=set({NodeResolutionState.RESOLVED}))
             # Get the flow
             # Pass the value through!
             # Optional data_type parameter for internal handling!

{griptape_nodes-0.45.0 → griptape_nodes-0.46.0}/src/griptape_nodes/retained_mode/managers/version_compatibility_manager.py

@@ -14,8 +14,10 @@ from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes, Version
 
 if TYPE_CHECKING:
     from griptape_nodes.node_library.library_registry import LibrarySchema
+    from griptape_nodes.node_library.workflow_registry import WorkflowMetadata
     from griptape_nodes.retained_mode.managers.event_manager import EventManager
     from griptape_nodes.retained_mode.managers.library_lifecycle.library_status import LibraryStatus
+    from griptape_nodes.retained_mode.managers.workflow_manager import WorkflowManager
 
 logger = logging.getLogger("griptape_nodes")
 
@@ -39,16 +41,41 @@ class LibraryVersionCompatibilityCheck(ABC):
         """Perform the library compatibility check."""
 
 
+class WorkflowVersionCompatibilityIssue(NamedTuple):
+    """Represents a workflow version compatibility issue found in a workflow."""
+
+    message: str
+    severity: WorkflowManager.WorkflowStatus
+
+
+class WorkflowVersionCompatibilityCheck(ABC):
+    """Abstract base class for workflow version compatibility checks."""
+
+    @abstractmethod
+    def applies_to_workflow(self, workflow_metadata: WorkflowMetadata) -> bool:
+        """Return True if this check applies to the given workflow."""
+
+    @abstractmethod
+    def check_workflow(self, workflow_metadata: WorkflowMetadata) -> list[WorkflowVersionCompatibilityIssue]:
+        """Perform the workflow compatibility check."""
+
+
 class VersionCompatibilityManager:
     """Manages version compatibility checks for libraries and other components."""
 
     def __init__(self, event_manager: EventManager) -> None:
         self._event_manager = event_manager
         self._compatibility_checks: list[LibraryVersionCompatibilityCheck] = []
+        self._workflow_compatibility_checks: list[WorkflowVersionCompatibilityCheck] = []
         self._discover_version_checks()
 
     def _discover_version_checks(self) -> None:
-        """Automatically discover and register library version compatibility checks."""
+        """Automatically discover and register library and workflow version compatibility checks."""
+        self._discover_library_version_checks()
+        self._discover_workflow_version_checks()
+
+    def _discover_library_version_checks(self) -> None:
+        """Discover and register library version compatibility checks."""
         # Get the path to the version_compatibility/versions directory
         import griptape_nodes.version_compatibility.versions as versions_module
 
@@ -59,6 +86,21 @@ class VersionCompatibilityManager:
             if version_dir.is_dir() and not version_dir.name.startswith("__"):
                 self._discover_checks_in_version_dir(version_dir)
 
+    def _discover_workflow_version_checks(self) -> None:
+        """Discover and register workflow version compatibility checks."""
+        try:
+            import griptape_nodes.version_compatibility.workflow_versions as workflow_versions_module
+
+            workflow_versions_path = Path(workflow_versions_module.__file__).parent
+
+            # Iterate through version directories
+            for version_dir in workflow_versions_path.iterdir():
+                if version_dir.is_dir() and not version_dir.name.startswith("__"):
+                    self._discover_workflow_checks_in_version_dir(version_dir)
+        except ImportError:
+            # workflow_versions directory doesn't exist yet, skip discovery
+            logger.debug("No workflow version compatibility checks directory found, skipping workflow check discovery")
+
     def _discover_checks_in_version_dir(self, version_dir: Path) -> None:
         """Discover compatibility checks in a specific version directory."""
         # Iterate through Python files in the version directory
@@ -82,6 +124,33 @@ class VersionCompatibilityManager:
                     self._compatibility_checks.append(check_instance)
                     logger.debug("Registered library version compatibility check: %s", attr_name)
 
+    def _discover_workflow_checks_in_version_dir(self, version_dir: Path) -> None:
+        """Discover workflow compatibility checks in a specific version directory."""
+        # Iterate through Python files in the version directory
+        for check_file in version_dir.glob("*.py"):
+            if check_file.name.startswith("__"):
+                continue
+
+            # Import the module
+            module_path = f"griptape_nodes.version_compatibility.workflow_versions.{version_dir.name}.{check_file.stem}"
+            try:
+                module = importlib.import_module(module_path)
+            except ImportError as e:
+                logger.debug("Failed to import workflow compatibility check module %s: %s", module_path, e)
+                continue
+
+            # Look for classes that inherit from WorkflowVersionCompatibilityCheck
+            for attr_name in dir(module):
+                attr = getattr(module, attr_name)
+                if (
+                    isinstance(attr, type)
+                    and issubclass(attr, WorkflowVersionCompatibilityCheck)
+                    and attr is not WorkflowVersionCompatibilityCheck
+                ):
+                    check_instance = attr()
+                    self._workflow_compatibility_checks.append(check_instance)
+                    logger.debug("Registered workflow version compatibility check: %s", attr_name)
+
     def check_library_version_compatibility(
         self, library_data: LibrarySchema
     ) -> list[LibraryVersionCompatibilityIssue]:
@@ -96,6 +165,20 @@ class VersionCompatibilityManager:
 
         return version_issues
 
+    def check_workflow_version_compatibility(
+        self, workflow_metadata: WorkflowMetadata
+    ) -> list[WorkflowVersionCompatibilityIssue]:
+        """Check a workflow for version compatibility issues."""
+        version_issues = []
+
+        # Run all discovered workflow compatibility checks
+        for check_instance in self._workflow_compatibility_checks:
+            if check_instance.applies_to_workflow(workflow_metadata):
+                issues = check_instance.check_workflow(workflow_metadata)
+                version_issues.extend(issues)
+
+        return version_issues
+
     def _get_current_engine_version(self) -> Version:
         """Get the current engine version."""
         result = GriptapeNodes.handle_request(GetEngineVersionRequest())

{griptape_nodes-0.45.0 → griptape_nodes-0.46.0}/src/griptape_nodes/retained_mode/managers/workflow_manager.py

@@ -959,6 +959,16 @@ class WorkflowManager:
                     status=status,
                 )
             )
+
+        # Check for workflow version-based compatibility issues and add to problems
+        workflow_version_issues = GriptapeNodes.VersionCompatibilityManager().check_workflow_version_compatibility(
+            workflow_metadata
+        )
+        for issue in workflow_version_issues:
+            problems.append(issue.message)
+            if issue.severity == WorkflowManager.WorkflowStatus.UNUSABLE:
+                had_critical_error = True
+
         # OK, we have all of our dependencies together. Let's look at the overall scenario.
         if had_critical_error:
             overall_status = WorkflowManager.WorkflowStatus.UNUSABLE
@@ -1490,6 +1500,7 @@ class WorkflowManager:
 
         # === imports ===
         import_recorder.add_import("argparse")
+        import_recorder.add_import("json")
         import_recorder.add_from_import(
             "griptape_nodes.bootstrap.workflow_executors.local_workflow_executor", "LocalWorkflowExecutor"
         )
@@ -1629,6 +1640,29 @@ class WorkflowManager:
             )
         )
 
+        # Add json input argument
+        add_arg_calls.append(
+            ast.Expr(
+                value=ast.Call(
+                    func=ast.Attribute(
+                        value=ast.Name(id="parser", ctx=ast.Load()),
+                        attr="add_argument",
+                        ctx=ast.Load(),
+                    ),
+                    args=[ast.Constant("--json-input")],
+                    keywords=[
+                        ast.keyword(arg="default", value=ast.Constant(None)),
+                        ast.keyword(
+                            arg="help",
+                            value=ast.Constant(
+                                "JSON string containing parameter values. Takes precedence over individual parameter arguments if provided."
+                            ),
+                        ),
+                    ],
+                )
+            )
+        )
+
         # Generate individual arguments for each parameter in workflow_shape["input"]
         if "input" in workflow_shape:
             for node_name, node_params in workflow_shape["input"].items():
@@ -1670,13 +1704,47 @@ class WorkflowManager:
             ),
         )
 
-        # Build flow_input dictionary from individual CLI arguments
+        # Build flow_input dictionary from JSON input or individual CLI arguments
         flow_input_init = ast.Assign(
             targets=[ast.Name(id="flow_input", ctx=ast.Store())],
             value=ast.Dict(keys=[], values=[]),
         )
 
-        # Build the flow_input dict structure from individual arguments
+        # Check if json_input is provided and parse it
+        json_input_if = ast.If(
+            test=ast.Compare(
+                left=ast.Attribute(
+                    value=ast.Name(id="args", ctx=ast.Load()),
+                    attr="json_input",
+                    ctx=ast.Load(),
+                ),
+                ops=[ast.IsNot()],
+                comparators=[ast.Constant(value=None)],
+            ),
+            body=[
+                ast.Assign(
+                    targets=[ast.Name(id="flow_input", ctx=ast.Store())],
+                    value=ast.Call(
+                        func=ast.Attribute(
+                            value=ast.Name(id="json", ctx=ast.Load()),
+                            attr="loads",
+                            ctx=ast.Load(),
+                        ),
+                        args=[
+                            ast.Attribute(
+                                value=ast.Name(id="args", ctx=ast.Load()),
+                                attr="json_input",
+                                ctx=ast.Load(),
+                            )
+                        ],
+                        keywords=[],
+                    ),
+                )
+            ],
+            orelse=[],
+        )
+
+        # Build the flow_input dict structure from individual arguments (fallback when no JSON input)
         build_flow_input_stmts = []
 
         # For each node, ensure it exists in flow_input
@@ -1747,6 +1815,21 @@ class WorkflowManager:
             ]
         )
 
+        # Wrap the individual argument processing in an else clause
+        individual_args_else = ast.If(
+            test=ast.Compare(
+                left=ast.Attribute(
+                    value=ast.Name(id="args", ctx=ast.Load()),
+                    attr="json_input",
+                    ctx=ast.Load(),
+                ),
+                ops=[ast.Is()],
+                comparators=[ast.Constant(value=None)],
+            ),
+            body=build_flow_input_stmts,
+            orelse=[],
+        )
+
         workflow_output = ast.Assign(
             targets=[ast.Name(id="workflow_output", ctx=ast.Store())],
             value=ast.Call(
@@ -1780,7 +1863,8 @@ class WorkflowManager:
                 *add_arg_calls,
                 parse_args,
                 flow_input_init,
-                *build_flow_input_stmts,
+                json_input_if,
+                individual_args_else,
                 workflow_output,
                 print_output,
             ],

griptape_nodes-0.46.0/src/griptape_nodes/version_compatibility/workflow_versions/__init__.py

@@ -0,0 +1 @@
+"""Workflow version compatibility checks module."""

griptape_nodes-0.46.0/src/griptape_nodes/version_compatibility/workflow_versions/v0_7_0/__init__.py

@@ -0,0 +1 @@
+"""Version 0.7.0 workflow compatibility checks."""

griptape_nodes-0.46.0/src/griptape_nodes/version_compatibility/workflow_versions/v0_7_0/local_executor_argument_addition.py

@@ -0,0 +1,42 @@
+"""Schema compatibility check for workflows."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from griptape_nodes.retained_mode.griptape_nodes import Version
+from griptape_nodes.retained_mode.managers.version_compatibility_manager import (
+    WorkflowVersionCompatibilityCheck,
+    WorkflowVersionCompatibilityIssue,
+)
+from griptape_nodes.retained_mode.managers.workflow_manager import WorkflowManager
+
+if TYPE_CHECKING:
+    from griptape_nodes.node_library.workflow_registry import WorkflowMetadata
+
+
+class LocalExecutorArgumentAddition(WorkflowVersionCompatibilityCheck):
+    """Check for workflow schema version compatibility issues due to missing `--json-input` argument in LocalExecutor."""
+
+    def applies_to_workflow(self, workflow_metadata: WorkflowMetadata) -> bool:
+        """Apply this check to workflows with schema version < 0.7.0."""
+        workflow_version = Version.from_string(workflow_metadata.schema_version)
+        return workflow_version is not None and workflow_version < Version(0, 7, 0)
+
+    def check_workflow(self, workflow_metadata: WorkflowMetadata) -> list[WorkflowVersionCompatibilityIssue]:
+        """Check workflow schema version compatibility."""
+        issues = []
+
+        workflow_schema_version = Version.from_string(workflow_metadata.schema_version)
+
+        if workflow_schema_version is not None and workflow_schema_version < Version(0, 7, 0):
+            issues.append(
+                WorkflowVersionCompatibilityIssue(
+                    message=f"Workflow schema version {workflow_metadata.schema_version} is older than version 0.7.0. "
+                    "The generated LocalExecutor code for the workflow file is missing the `--json-input` argument, which may cause issues for Publish Workflow requests when using certain Library targets. "
+                    "Consider updating the workflow by saving it again.",
+                    severity=WorkflowManager.WorkflowStatus.FLAWED,
+                )
+            )
+
+        return issues