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

griptape_nodes/retained_mode/managers/flow_manager.py

@@ -4,8 +4,6 @@ import logging
 from queue import Queue
 from typing import TYPE_CHECKING, cast
 
-from griptape.events import EventBus
-
 from griptape_nodes.exe_types.connections import Connections
 from griptape_nodes.exe_types.core_types import (
     Parameter,
@@ -869,6 +867,8 @@ class FlowManager:
                     node_name=target_node.name,
                     value=value,
                     data_type=source_param.type,
+                    incoming_connection_source_node_name=source_node.name,
+                    incoming_connection_source_parameter_name=source_param.name,
                 )
             )
 
@@ -1031,7 +1031,7 @@ class FlowManager:
         result = DeleteConnectionResultSuccess()
         return result
 
-    def on_start_flow_request(self, request: StartFlowRequest) -> ResultPayload:  # noqa: C901, PLR0911, PLR0912
+    async def on_start_flow_request(self, request: StartFlowRequest) -> ResultPayload:  # noqa: C901, PLR0911, PLR0912
         # which flow
         flow_name = request.flow_name
         debug_mode = request.debug_mode
@@ -1075,7 +1075,7 @@ class FlowManager:
             self.get_start_node_queue()  # initialize the start flow queue!
             start_node = None
         # Run Validation before starting a flow
-        result = self.on_validate_flow_dependencies_request(
+        result = await self.on_validate_flow_dependencies_request(
             ValidateFlowDependenciesRequest(flow_name=flow_name, flow_node_name=start_node.name if start_node else None)
         )
         try:
@@ -1098,7 +1098,7 @@ class FlowManager:
             return StartFlowResultFailure(validation_exceptions=[e], result_details=details)
         # By now, it has been validated with no exceptions.
         try:
-            self.start_flow(flow, start_node, debug_mode)
+            await self.start_flow(flow, start_node, debug_mode)
         except Exception as e:
             details = f"Failed to kick off flow with name {flow_name}. Exception occurred: {e} "
             logger.error(details)
@@ -1157,7 +1157,7 @@ class FlowManager:
 
         return CancelFlowResultSuccess()
 
-    def on_single_node_step_request(self, request: SingleNodeStepRequest) -> ResultPayload:
+    async def on_single_node_step_request(self, request: SingleNodeStepRequest) -> ResultPayload:
         flow_name = request.flow_name
         if not flow_name:
             details = "Could not advance to the next step of a running workflow. No flow name was provided."
@@ -1173,7 +1173,7 @@ class FlowManager:
             return SingleNodeStepResultFailure(validation_exceptions=[err], result_details=details)
         try:
             flow = self.get_flow_by_name(flow_name)
-            self.single_node_step(flow)
+            await self.single_node_step(flow)
         except Exception as e:
             details = f"Could not advance to the next step of a running workflow. Exception: {e}"
             logger.error(details)
@@ -1185,7 +1185,7 @@ class FlowManager:
 
         return SingleNodeStepResultSuccess()
 
-    def on_single_execution_step_request(self, request: SingleExecutionStepRequest) -> ResultPayload:
+    async def on_single_execution_step_request(self, request: SingleExecutionStepRequest) -> ResultPayload:
         flow_name = request.flow_name
         if not flow_name:
             details = "Could not advance to the next step of a running workflow. No flow name was provided."
@@ -1201,7 +1201,7 @@ class FlowManager:
             return SingleExecutionStepResultFailure(result_details=details)
         change_debug_mode = request.request_id is not None
         try:
-            self.single_execution_step(flow, change_debug_mode)
+            await self.single_execution_step(flow, change_debug_mode)
         except Exception as e:
             # We REALLY don't want to fail here, else we'll take the whole engine down
             try:
@@ -1219,7 +1219,7 @@ class FlowManager:
 
         return SingleExecutionStepResultSuccess()
 
-    def on_continue_execution_step_request(self, request: ContinueExecutionStepRequest) -> ResultPayload:
+    async def on_continue_execution_step_request(self, request: ContinueExecutionStepRequest) -> ResultPayload:
         flow_name = request.flow_name
         if not flow_name:
             details = "Failed to continue execution step because no flow name was provided"
@@ -1234,7 +1234,7 @@ class FlowManager:
 
             return ContinueExecutionStepResultFailure(result_details=details)
         try:
-            self.continue_executing(flow)
+            await self.continue_executing(flow)
         except Exception as e:
             details = f"Failed to continue execution step. An exception occurred: {e}."
             logger.error(details)
@@ -1265,7 +1265,7 @@ class FlowManager:
         logger.debug(details)
         return UnresolveFlowResultSuccess()
 
-    def on_validate_flow_dependencies_request(self, request: ValidateFlowDependenciesRequest) -> ResultPayload:
+    async def on_validate_flow_dependencies_request(self, request: ValidateFlowDependenciesRequest) -> ResultPayload:
         flow_name = request.flow_name
         # get the flow name
         try:
@@ -1658,7 +1658,7 @@ class FlowManager:
                 node.emit_parameter_changes()
         return FlushParameterChangesResultSuccess()
 
-    def start_flow(self, flow: ControlFlow, start_node: BaseNode | None = None, debug_mode: bool = False) -> None:  # noqa: FBT001, FBT002, ARG002
+    async def start_flow(self, flow: ControlFlow, start_node: BaseNode | None = None, debug_mode: bool = False) -> None:  # noqa: FBT001, FBT002, ARG002
         if self.check_for_existing_running_flow():
             # If flow already exists, throw an error
             errormsg = "This workflow is already in progress. Please wait for the current process to finish before starting again."
@@ -1676,7 +1676,7 @@ class FlowManager:
             self._global_control_flow_machine = ControlFlowMachine()
 
         try:
-            self._global_control_flow_machine.start_flow(start_node, debug_mode)
+            await self._global_control_flow_machine.start_flow(start_node, debug_mode)
         except Exception:
             if self.check_for_existing_running_flow():
                 self.cancel_flow_run()
@@ -1707,7 +1707,7 @@ class FlowManager:
         self._global_single_node_resolution = False
         logger.debug("Cancelling flow run")
 
-        EventBus.publish_event(
+        GriptapeNodes.EventManager().put_event(
             ExecutionGriptapeNodeEvent(wrapped_event=ExecutionEvent(payload=ControlFlowCancelledEvent()))
         )
 
@@ -1754,7 +1754,13 @@ class FlowManager:
         return self._has_connection(source_node, source_parameter, target_node, target_parameter)
 
     # Internal execution queue helper methods to consolidate redundant operations
-    def _handle_flow_start_if_not_running(self, flow: ControlFlow, *, debug_mode: bool, error_message: str) -> None:  # noqa: ARG002
+    async def _handle_flow_start_if_not_running(
+        self,
+        flow: ControlFlow,  # noqa: ARG002
+        *,
+        debug_mode: bool,
+        error_message: str,
+    ) -> None:
         """Common logic for starting flow execution if not already running."""
         if not self.check_for_existing_running_flow():
             if self._global_flow_queue.empty():
@@ -1763,17 +1769,17 @@ class FlowManager:
             self._global_flow_queue.task_done()
             if self._global_control_flow_machine is None:
                 self._global_control_flow_machine = ControlFlowMachine()
-            self._global_control_flow_machine.start_flow(start_node, debug_mode)
+            await self._global_control_flow_machine.start_flow(start_node, debug_mode)
 
-    def _handle_post_execution_queue_processing(self, *, debug_mode: bool) -> None:
+    async def _handle_post_execution_queue_processing(self, *, debug_mode: bool) -> None:
         """Handle execution queue processing after execution completes."""
         if not self.check_for_existing_running_flow() and not self._global_flow_queue.empty():
             start_node = self._global_flow_queue.get()
             self._global_flow_queue.task_done()
             if self._global_control_flow_machine is not None:
-                self._global_control_flow_machine.start_flow(start_node, debug_mode)
+                await self._global_control_flow_machine.start_flow(start_node, debug_mode)
 
-    def resolve_singular_node(self, flow: ControlFlow, node: BaseNode, debug_mode: bool = False) -> None:  # noqa: FBT001, FBT002, ARG002
+    async def resolve_singular_node(self, flow: ControlFlow, node: BaseNode, debug_mode: bool = False) -> None:  # noqa: FBT001, FBT002, ARG002
         # Set that we are only working on one node right now! no other stepping allowed
         if self.check_for_existing_running_flow():
             # If flow already exists, throw an error
@@ -1790,30 +1796,30 @@ class FlowManager:
         resolution_machine.change_debug_mode(debug_mode)
         # Resolve the node.
         node.state = NodeResolutionState.UNRESOLVED
-        resolution_machine.resolve_node(node)
+        await resolution_machine.resolve_node(node)
         # decide if we can change it back to normal flow mode!
         if resolution_machine.is_complete():
             self._global_single_node_resolution = False
             self._global_control_flow_machine._context.current_node = None
 
-    def single_execution_step(self, flow: ControlFlow, change_debug_mode: bool) -> None:  # noqa: FBT001
+    async def single_execution_step(self, flow: ControlFlow, change_debug_mode: bool) -> None:  # noqa: FBT001
         # do a granular step
-        self._handle_flow_start_if_not_running(
+        await self._handle_flow_start_if_not_running(
             flow, debug_mode=True, error_message="Flow has not yet been started. Cannot step while no flow has begun."
         )
         if not self.check_for_existing_running_flow():
             return
         if self._global_control_flow_machine is not None:
-            self._global_control_flow_machine.granular_step(change_debug_mode)
+            await self._global_control_flow_machine.granular_step(change_debug_mode)
             resolution_machine = self._global_control_flow_machine._context.resolution_machine
             if self._global_single_node_resolution:
                 resolution_machine = self._global_control_flow_machine._context.resolution_machine
                 if resolution_machine.is_complete():
                     self._global_single_node_resolution = False
 
-    def single_node_step(self, flow: ControlFlow) -> None:
+    async def single_node_step(self, flow: ControlFlow) -> None:
         # It won't call single_node_step without an existing flow running from US.
-        self._handle_flow_start_if_not_running(
+        await self._handle_flow_start_if_not_running(
             flow, debug_mode=True, error_message="Flow has not yet been started. Cannot step while no flow has begun."
         )
         if not self.check_for_existing_running_flow():
@@ -1823,12 +1829,12 @@ class FlowManager:
             msg = "Cannot step through the Control Flow in Single Node Execution"
             raise RuntimeError(msg)
         if self._global_control_flow_machine is not None:
-            self._global_control_flow_machine.node_step()
+            await self._global_control_flow_machine.node_step()
         # Start the next resolution step now please.
-        self._handle_post_execution_queue_processing(debug_mode=True)
+        await self._handle_post_execution_queue_processing(debug_mode=True)
 
-    def continue_executing(self, flow: ControlFlow) -> None:
-        self._handle_flow_start_if_not_running(
+    async def continue_executing(self, flow: ControlFlow) -> None:
+        await self._handle_flow_start_if_not_running(
             flow, debug_mode=False, error_message="Flow has not yet been started. Cannot step while no flow has begun."
         )
         if not self.check_for_existing_running_flow():
@@ -1840,11 +1846,11 @@ class FlowManager:
                 if self._global_control_flow_machine._context.resolution_machine.is_complete():
                     self._global_single_node_resolution = False
                 else:
-                    self._global_control_flow_machine._context.resolution_machine.update()
+                    await self._global_control_flow_machine._context.resolution_machine.update()
             else:
-                self._global_control_flow_machine.node_step()
+                await self._global_control_flow_machine.node_step()
         # Now it is done executing. make sure it's actually done?
-        self._handle_post_execution_queue_processing(debug_mode=False)
+        await self._handle_post_execution_queue_processing(debug_mode=False)
 
     def unresolve_whole_flow(self, flow: ControlFlow) -> None:
         for node in flow.nodes.values():

griptape_nodes/retained_mode/managers/library_lifecycle/library_directory.py

@@ -35,7 +35,7 @@ class LibraryDirectory:
         # Own all FSM instances for library lifecycle management
         self._provenance_to_fsm: dict[LibraryProvenance, LibraryLifecycleFSM] = {}
 
-    def discover_library(self, provenance: LibraryProvenance) -> None:
+    async def discover_library(self, provenance: LibraryProvenance) -> None:
         """Discover a library and its provenance.
 
         Discovery is purely about cataloging - activation state is handled separately.
@@ -49,26 +49,26 @@ class LibraryDirectory:
         self._discovered_libraries[provenance] = entry
 
         # Create FSM and run evaluation automatically
-        self._create_fsm_and_evaluate(provenance)
+        await self._create_fsm_and_evaluate(provenance)
 
-    def add_curated_candidate(self, provenance: LibraryProvenance) -> None:
+    async def add_curated_candidate(self, provenance: LibraryProvenance) -> None:
         """Add a curated library candidate.
 
         Curated libraries default to inactive and need to be activated by user.
         """
-        self.discover_library(provenance)
+        await self.discover_library(provenance)
 
         # Set curated library as inactive by default
         if provenance in self._discovered_libraries:
             entry = self._discovered_libraries[provenance]
             entry.active = False
 
-    def add_user_candidate(self, provenance: LibraryProvenance) -> None:
+    async def add_user_candidate(self, provenance: LibraryProvenance) -> None:
         """Add a user-supplied library candidate.
 
         User libraries default to active.
         """
-        self.discover_library(provenance)
+        await self.discover_library(provenance)
 
         # Set user library as active by default
         if provenance in self._discovered_libraries:
@@ -202,7 +202,7 @@ class LibraryDirectory:
 
         return blockers
 
-    def _create_fsm_and_evaluate(self, provenance: LibraryProvenance) -> None:
+    async def _create_fsm_and_evaluate(self, provenance: LibraryProvenance) -> None:
         """Create FSM for provenance and run through evaluation phase.
 
         This method is called automatically when a library is discovered.
@@ -214,11 +214,11 @@ class LibraryDirectory:
         self._provenance_to_fsm[provenance] = fsm
 
         # Start the lifecycle and run through evaluation
-        fsm.start_lifecycle()
+        await fsm.start_lifecycle()
 
         # Progress through inspection
         if fsm.can_begin_inspection():
-            fsm.begin_inspection()
+            await fsm.begin_inspection()
         else:
             logger.error(
                 "Cannot inspect library '%s' - inspection step cannot proceed",
@@ -228,7 +228,7 @@ class LibraryDirectory:
 
         # Progress through evaluation
         if fsm.can_begin_evaluation():
-            fsm.begin_evaluation()
+            await fsm.begin_evaluation()
         else:
             logger.error(
                 "Cannot evaluate library '%s' - evaluation step cannot proceed",
@@ -247,7 +247,7 @@ class LibraryDirectory:
 
         logger.debug("Completed FSM evaluation for library: %s", provenance.get_display_name())
 
-    def install_library(self, provenance: LibraryProvenance) -> bool:
+    async def install_library(self, provenance: LibraryProvenance) -> bool:
         """Install a library by running its FSM through the installation phase.
 
         Returns True if installation was successful, False otherwise.
@@ -272,7 +272,7 @@ class LibraryDirectory:
 
         # Proceed with installation
         if fsm.can_begin_installation():
-            fsm.begin_installation()
+            await fsm.begin_installation()
             logger.info("Installation completed for library: %s", provenance.get_display_name())
             return True
         logger.error(
@@ -281,7 +281,7 @@ class LibraryDirectory:
         )
         return False
 
-    def load_library(self, provenance: LibraryProvenance) -> bool:
+    async def load_library(self, provenance: LibraryProvenance) -> bool:
         """Load a library by running its FSM through the loading phase.
 
         Returns True if loading was successful, False otherwise.
@@ -299,7 +299,7 @@ class LibraryDirectory:
             return False
 
         # Proceed with loading
-        fsm.begin_loading()
+        await fsm.begin_loading()
 
         if not fsm.is_loaded():
             logger.error(

griptape_nodes/retained_mode/managers/library_lifecycle/library_fsm.py

@@ -87,7 +87,7 @@ class CandidateState(State):
     """Initial state where we have a library candidate ready for processing."""
 
     @staticmethod
-    def on_enter(context: LibraryLifecycleContext) -> StateType | None:
+    async def on_enter(context: LibraryLifecycleContext) -> StateType | None:
         logger.info("Library %s is now a candidate for processing", context.provenance.get_display_name())
         return None  # Wait for explicit transition to InspectingState
 
@@ -106,7 +106,7 @@ class InspectingState(State):
         return {InspectedState}
 
     @staticmethod
-    def on_enter(context: LibraryLifecycleContext) -> StateType | None:
+    async def on_enter(context: LibraryLifecycleContext) -> StateType | None:
         logger.info("Inspecting library %s", context.provenance.get_display_name())
 
         # Store inspection result directly
@@ -145,7 +145,7 @@ class InspectedState(State):
         return {EvaluatingState}
 
     @staticmethod
-    def on_enter(context: LibraryLifecycleContext) -> StateType | None:
+    async def on_enter(context: LibraryLifecycleContext) -> StateType | None:
         if context.inspection_result and context.inspection_result.issues:
             logger.warning(
                 "Library %s inspection completed with problems: %s",
@@ -167,7 +167,7 @@ class EvaluatingState(State):
         return {EvaluatedState}
 
     @staticmethod
-    def on_enter(context: LibraryLifecycleContext) -> StateType | None:
+    async def on_enter(context: LibraryLifecycleContext) -> StateType | None:
         logger.info("Evaluating library %s", context.provenance.get_display_name())
 
         context.evaluation_result = context.provenance.evaluate(context)
@@ -185,7 +185,7 @@ class EvaluatedState(State):
         return {InstallingState}
 
     @staticmethod
-    def on_enter(context: LibraryLifecycleContext) -> StateType | None:
+    async def on_enter(context: LibraryLifecycleContext) -> StateType | None:
         evaluation_issues = context.get_evaluation_issues()
         if evaluation_issues:
             logger.warning(
@@ -208,7 +208,7 @@ class InstallingState(State):
         return {InstalledState}
 
     @staticmethod
-    def on_enter(context: LibraryLifecycleContext) -> StateType | None:
+    async def on_enter(context: LibraryLifecycleContext) -> StateType | None:
         logger.info("Installing library %s", context.provenance.get_display_name())
 
         # Check if user has disabled this library
@@ -219,7 +219,7 @@ class InstallingState(State):
             return InstalledState
 
         # Perform installation using delegation
-        context.installation_result = context.provenance.install(context)
+        context.installation_result = await context.provenance.install(context)
 
         # Auto-transition to InstalledState
         return InstalledState
@@ -234,7 +234,7 @@ class InstalledState(State):
         return {LoadingState}
 
     @staticmethod
-    def on_enter(context: LibraryLifecycleContext) -> StateType | None:
+    async def on_enter(context: LibraryLifecycleContext) -> StateType | None:
         installation_issues = context.get_installation_issues()
         if installation_issues:
             logger.warning(
@@ -257,7 +257,7 @@ class LoadingState(State):
         return {LoadedState}
 
     @staticmethod
-    def on_enter(context: LibraryLifecycleContext) -> StateType | None:
+    async def on_enter(context: LibraryLifecycleContext) -> StateType | None:
         logger.info("Loading library %s", context.provenance.get_display_name())
 
         # Check if user has disabled this library
@@ -292,7 +292,7 @@ class LoadedState(State):
         return set()  # Terminal state
 
     @staticmethod
-    def on_enter(context: LibraryLifecycleContext) -> StateType | None:
+    async def on_enter(context: LibraryLifecycleContext) -> StateType | None:
         library_loaded_issues = context.get_library_loaded_issues()
         if library_loaded_issues:
             logger.warning(
@@ -313,31 +313,31 @@ class LibraryLifecycleFSM(FSM[LibraryLifecycleContext]):
         context = LibraryLifecycleContext(provenance=provenance)
         super().__init__(context)
 
-    def start_lifecycle(self) -> None:
+    async def start_lifecycle(self) -> None:
         """Start the library lifecycle from CandidateState."""
         if self._current_state is not None:
             raise InvalidStateTransitionError(self._current_state, CandidateState, "Lifecycle has already been started")
-        self.start(CandidateState)
+        await self.start(CandidateState)
 
-    def begin_inspection(self) -> None:
+    async def begin_inspection(self) -> None:
         """Explicitly transition from Candidate to Inspecting."""
         self._validate_state_transition(InspectingState)
-        self.transition_state(InspectingState)
+        await self.transition_state(InspectingState)
 
-    def begin_evaluation(self) -> None:
+    async def begin_evaluation(self) -> None:
         """Explicitly transition from Inspected to Evaluating."""
         self._validate_state_transition(EvaluatingState)
-        self.transition_state(EvaluatingState)
+        await self.transition_state(EvaluatingState)
 
-    def begin_installation(self) -> None:
+    async def begin_installation(self) -> None:
         """Explicitly transition from Evaluated to Installing."""
         self._validate_state_transition(InstallingState)
-        self.transition_state(InstallingState)
+        await self.transition_state(InstallingState)
 
-    def begin_loading(self) -> None:
+    async def begin_loading(self) -> None:
         """Explicitly transition from Installed to Loading."""
         self._validate_state_transition(LoadingState)
-        self.transition_state(LoadingState)
+        await self.transition_state(LoadingState)
 
     def get_context(self) -> LibraryLifecycleContext:
         """Get the current context."""

griptape_nodes/retained_mode/managers/library_lifecycle/library_provenance/base.py

@@ -60,7 +60,7 @@ class LibraryProvenance(ABC):
         """
 
     @abstractmethod
-    def install(self, context: LibraryLifecycleContext) -> InstallationResult:
+    async def install(self, context: LibraryLifecycleContext) -> InstallationResult:
         """Install this provenance.
 
         Args:

griptape_nodes/retained_mode/managers/library_lifecycle/library_provenance/github.py

@@ -72,7 +72,7 @@ class LibraryProvenanceGitHub(LibraryProvenance):
         )
         return EvaluationResult(issues=issues)
 
-    def install(self, context: LibraryLifecycleContext) -> InstallationResult:  # noqa: ARG002
+    async def install(self, context: LibraryLifecycleContext) -> InstallationResult:  # noqa: ARG002
         """Install this GitHub repository library."""
         issues = []
         issues.append(

griptape_nodes/retained_mode/managers/library_lifecycle/library_provenance/local_file.py

@@ -31,6 +31,7 @@ from griptape_nodes.retained_mode.managers.library_lifecycle.data_models import
 from griptape_nodes.retained_mode.managers.library_lifecycle.library_provenance.base import LibraryProvenance
 from griptape_nodes.retained_mode.managers.library_lifecycle.library_status import LibraryStatus
 from griptape_nodes.retained_mode.managers.os_manager import OSManager
+from griptape_nodes.utils.async_utils import subprocess_run
 
 if TYPE_CHECKING:
     from griptape_nodes.retained_mode.managers.library_lifecycle.library_fsm import LibraryLifecycleContext
@@ -114,7 +115,7 @@ class LibraryProvenanceLocalFile(LibraryProvenance):
 
         return EvaluationResult(issues=issues)
 
-    def install(self, context: LibraryLifecycleContext) -> InstallationResult:
+    async def install(self, context: LibraryLifecycleContext) -> InstallationResult:
         """Install this local file library."""
         problems = []
         venv_path = ""
@@ -150,7 +151,7 @@ class LibraryProvenanceLocalFile(LibraryProvenance):
         # Only install dependencies if conditions are met
         library_venv_python_path = None
         try:
-            library_venv_python_path = library_manager._init_library_venv(venv_path)
+            library_venv_python_path = await library_manager._init_library_venv(venv_path)
         except RuntimeError as e:
             problems.append(
                 LifecycleIssue(
@@ -187,7 +188,7 @@ class LibraryProvenanceLocalFile(LibraryProvenance):
             # Grab the python executable from the virtual environment so that we can pip install there
             logger.info("Installing dependencies for library '%s' with pip in venv at %s", library_data.name, venv_path)
             try:
-                subprocess.run(  # noqa: S603
+                await subprocess_run(
                     [
                         sys.executable,
                         "-m",

griptape_nodes/retained_mode/managers/library_lifecycle/library_provenance/package.py

@@ -61,7 +61,7 @@ class LibraryProvenancePackage(LibraryProvenance):
         )
         return EvaluationResult(issues=issues)
 
-    def install(self, context: LibraryLifecycleContext) -> InstallationResult:  # noqa: ARG002
+    async def install(self, context: LibraryLifecycleContext) -> InstallationResult:  # noqa: ARG002
         """Install this package library."""
         issues = []
         issues.append(

griptape_nodes/retained_mode/managers/library_lifecycle/library_provenance/sandbox.py

@@ -110,7 +110,7 @@ class LibraryProvenanceSandbox(LibraryProvenance):
 
         return EvaluationResult(issues=issues)
 
-    def install(self, context: LibraryLifecycleContext) -> InstallationResult:  # noqa: ARG002
+    async def install(self, context: LibraryLifecycleContext) -> InstallationResult:  # noqa: ARG002
         """Install this sandbox library."""
         issues = []