scientiflow-cli 0.4.5__tar.gz → 0.4.7__tar.gz

{scientiflow_cli-0.4.5 → scientiflow_cli-0.4.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: scientiflow-cli
-Version: 0.4.5
+Version: 0.4.7
 Summary: CLI tool for scientiflow. This application runs on the client side, decodes pipelines, and executes them in the configured order!
 License: Proprietary
 Author: ScientiFlow

{scientiflow_cli-0.4.5 → scientiflow_cli-0.4.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "scientiflow-cli"
-version = "0.4.5"
+version = "0.4.7"
 description = "CLI tool for scientiflow. This application runs on the client side, decodes pipelines, and executes them in the configured order!"
 authors = ["ScientiFlow <scientiflow@gmail.com>"]
 license = "Proprietary"

{scientiflow_cli-0.4.5 → scientiflow_cli-0.4.7}/scientiflow_cli/config.py

@@ -5,5 +5,4 @@ class Config:
     if mode=="prod":
         APP_BASE_URL = os.getenv("APP_BASE_URL", "https://www.backend.scientiflow.com/api")
     elif mode=="dev":
-        APP_BASE_URL = "http://127.0.0.1:8000/api"
-        # APP_BASE_URL = os.getenv("APP_BASE_URL", "https://www.scientiflow-backend-dev.scientiflow.com/api")
+        APP_BASE_URL = os.getenv("APP_BASE_URL", "https://www.scientiflow-backend-dev.scientiflow.com/api")

{scientiflow_cli-0.4.5 → scientiflow_cli-0.4.7}/scientiflow_cli/pipeline/decode_and_execute.py

@@ -1,7 +1,7 @@
 import subprocess
 import tempfile
 import os
-import re
+import re, shlex
 import multiprocessing
 import threading
 from concurrent.futures import ProcessPoolExecutor, as_completed
@@ -12,6 +12,85 @@ from scientiflow_cli.services.rich_printer import RichPrinter
 
 printer = RichPrinter()
 
+# Global background job tracker
+class GlobalBackgroundJobTracker:
+    _instance = None
+    _lock = threading.Lock()
+    
+    def __new__(cls):
+        if cls._instance is None:
+            with cls._lock:
+                if cls._instance is None:
+                    cls._instance = super().__new__(cls)
+                    cls._instance._initialize()
+        return cls._instance
+    
+    def _initialize(self):
+        self.background_executors = []
+        self.background_jobs_count = 0
+        self.background_jobs_completed = 0
+        self.background_jobs_lock = threading.Lock()
+    
+    def register_background_job(self, executor, futures, node_label, log_file_path):
+        """Register a background job for global tracking."""
+        with self.background_jobs_lock:
+            self.background_jobs_count += 1
+            self.background_executors.append(executor)
+        
+        # Start monitoring in a separate thread
+        monitor_thread = threading.Thread(
+            target=self._monitor_job,
+            args=(futures, node_label, executor, log_file_path),
+            daemon=True
+        )
+        monitor_thread.start()
+    
+    def _monitor_job(self, futures, node_label, executor, log_file_path):
+        """Monitor background job completion."""
+        all_successful = True
+        for future in as_completed(futures):
+            success = future.result()
+            if not success:
+                all_successful = False
+        
+        if not all_successful:
+            with open(log_file_path, 'a') as f:
+                f.write(f"[ERROR] Background job {node_label} failed\n")
+            printer.print_message(f"[BACKGROUND JOB] {node_label} Failed - some commands in background job failed", style="bold red")
+        else:
+            printer.print_message(f"[BACKGROUND JOB] {node_label} Execution completed in the background", style="bold green")
+        
+        # Clean up executor
+        executor.shutdown(wait=False)
+        with self.background_jobs_lock:
+            if executor in self.background_executors:
+                self.background_executors.remove(executor)
+            self.background_jobs_completed += 1
+    
+    def wait_for_all_jobs(self):
+        """Wait for all background jobs to complete."""
+        import time
+        if self.background_jobs_count > 0:
+            printer.print_message(f"[INFO] Waiting for {self.background_jobs_count} background job(s) to complete...", style="bold yellow")
+            
+            while True:
+                with self.background_jobs_lock:
+                    if self.background_jobs_completed >= self.background_jobs_count:
+                        break
+                time.sleep(0.5)  # Check every 500ms
+            
+            printer.print_message("[INFO] All background jobs completed.", style="bold green")
+    
+    def reset(self):
+        """Reset the tracker for a new execution cycle."""
+        with self.background_jobs_lock:
+            self.background_executors = []
+            self.background_jobs_count = 0
+            self.background_jobs_completed = 0
+
+# Global tracker instance
+global_bg_tracker = GlobalBackgroundJobTracker()
+
 def execute_background_command_standalone(command: str, log_file_path: str):
     """Execute a command in background without real-time output display - standalone function for multiprocessing."""
     try:
@@ -51,10 +130,6 @@ class PipelineExecutor:
         self.current_node = None
         self.job_status = job_status
         self.current_node_from_config = current_node_from_config
-        self.background_executors = []  # Keep track of background executors
-        self.background_jobs_count = 0  # Track number of active background jobs
-        self.background_jobs_completed = 0  # Track completed background jobs
-        self.background_jobs_lock = threading.Lock()  # Thread-safe counter updates
         
         # For resuming: flag to track if we've reached the resume point
         self.resume_mode = (job_status == "running" and current_node_from_config is not None)
@@ -114,9 +189,23 @@ class PipelineExecutor:
             print(f"[ERROR] Failed to update terminal output: {e}")
 
     def replace_variables(self, command: str) -> str:
-        """Replace placeholders like ${VAR} with environment values."""
-        return re.sub(r'\$\{(\w+)\}', lambda m: self.environment_variables.get(m.group(1), m.group(0)), command)
-
+        #     """Replace placeholders like ${VAR} with environment values."""
+        #     print(self.environment_variables)
+        #     return re.sub(r'\$\{(\w+)\}', lambda m: self.environment_variables.get(m.group(1), m.group(0)), command)
+        """Replace placeholders like ${VAR} with environment values.
+        - If value is a list: safely join into space-separated arguments (quoted).
+        - Otherwise: use the old behavior (direct substitution).
+        """
+        def replacer(match):
+            key = match.group(1)
+            value = self.environment_variables.get(key, match.group(0))
+            # ✅ Special handling for lists
+            if isinstance(value, list):
+                return " ".join(shlex.quote(str(v)) for v in value)
+            # ✅ Default: keep original behavior for strings, numbers, None
+            return self.environment_variables.get(key, match.group(0))
+        return re.sub(r'\$\{(\w+)\}', replacer, command)
+        
     def execute_command(self, command: str):
         """Run the command in the terminal, display output in real-time, and log the captured output."""
         import sys
@@ -151,47 +240,7 @@ class PipelineExecutor:
             self.update_terminal_output()
             raise SystemExit("[ERROR] Pipeline execution terminated due to an unexpected error.")
 
-    def monitor_background_job(self, futures, node_label, executor):
-        """Monitor background job completion in a separate thread."""
-        def monitor():
-            all_successful = True
-            for future in as_completed(futures):
-                success = future.result()
-                if not success:
-                    all_successful = False
-            
-            if not all_successful:
-                self.log_output(f"[ERROR] Background job {node_label} failed")
-                printer.print_message(f"[BACKGROUND JOB] {node_label} Failed - some commands in background job failed", style="bold red")
-            else:
-                printer.print_message(f"[BACKGROUND JOB] {node_label} Execution completed in the background", style="bold green")
-            
-            # Clean up executor
-            executor.shutdown(wait=False)
-            if executor in self.background_executors:
-                self.background_executors.remove(executor)
-            
-            # Update background job completion count
-            with self.background_jobs_lock:
-                self.background_jobs_completed += 1
-        
-        # Start monitoring thread
-        monitor_thread = threading.Thread(target=monitor, daemon=True)
-        monitor_thread.start()
 
-    def wait_for_background_jobs(self):
-        """Wait for all background jobs to complete."""
-        import time
-        if self.background_jobs_count > 0:
-            printer.print_message(f"[INFO] Waiting for {self.background_jobs_count} background job(s) to complete...", style="bold yellow")
-            
-            while True:
-                with self.background_jobs_lock:
-                    if self.background_jobs_completed >= self.background_jobs_count:
-                        break
-                time.sleep(0.5)  # Check every 500ms
-            
-            printer.print_message("[INFO] All background jobs completed.", style="bold green")
 
     def dfs(self, node: str):
         """Perform Depth-First Search (DFS) for executing pipeline nodes."""
@@ -270,19 +319,14 @@ class PipelineExecutor:
                 
                 # Execute commands in background using ProcessPoolExecutor (non-blocking)
                 if command_list:
-                    # Increment background jobs counter
-                    with self.background_jobs_lock:
-                        self.background_jobs_count += 1
-                    
                     executor = ProcessPoolExecutor(max_workers=numberOfThreads)
-                    self.background_executors.append(executor)  # Keep reference to prevent garbage collection
                     futures = []
                     for cmd in command_list:
                         future = executor.submit(execute_background_command_standalone, cmd, self.log_file_path)
                         futures.append(future)
                     
-                    # Start monitoring in a separate thread (non-blocking)
-                    self.monitor_background_job(futures, node_label, executor)
+                    # Register with global tracker (non-blocking)
+                    global_bg_tracker.register_background_job(executor, futures, node_label, self.log_file_path)
                     
                     # Don't wait for completion, immediately continue to next node
                 else:
@@ -330,9 +374,9 @@ class PipelineExecutor:
         if starting_node:
             self.dfs(starting_node)
 
-        # Wait for all background jobs to complete before marking pipeline as completed
-        self.wait_for_background_jobs()
-
+        # Don't wait for background jobs here - let them continue across multiple jobs
+        # Background jobs will be waited for at the end of all job executions
+        
         update_job_status(self.project_job_id, "completed")
         update_stopped_at_node(self.project_id, self.project_job_id, self.current_node)
 

{scientiflow_cli-0.4.5 → scientiflow_cli-0.4.7}/scientiflow_cli/services/executor.py

@@ -1,7 +1,7 @@
 from concurrent.futures import ThreadPoolExecutor
 import asyncio
 from scientiflow_cli.pipeline.get_jobs import get_jobs
-from scientiflow_cli.pipeline.decode_and_execute import decode_and_execute_pipeline
+from scientiflow_cli.pipeline.decode_and_execute import decode_and_execute_pipeline, global_bg_tracker
 from scientiflow_cli.pipeline.container_manager import get_job_containers
 from scientiflow_cli.utils.file_manager import create_job_dirs, get_job_files
 from scientiflow_cli.services.rich_printer import RichPrinter
@@ -51,6 +51,9 @@ def execute_jobs(job_ids: list[int] = None, parallel: bool = False) -> None:
         # Execute jobs synchronously
         for job in jobs_to_execute:
             execute_single_job(job)
+        
+        # Wait for all background jobs from all executed jobs to complete
+        global_bg_tracker.wait_for_all_jobs()
 
 
 def execute_jobs_sync(job_ids: list[int] = None) -> None:
@@ -69,6 +72,9 @@ def execute_jobs_sync(job_ids: list[int] = None) -> None:
             printer.print_error(f"No job found with ID: {job_id}")
             continue
         execute_single_job(job_dict[job_id])
+    
+    # Wait for all background jobs from all executed jobs to complete
+    global_bg_tracker.wait_for_all_jobs()
 
 
 def sort_jobs_by_id(all_pending_jobs: list[dict]) -> list[dict]:
@@ -117,6 +123,9 @@ def execute_job_id(job_id: int) -> None:
 
     execute_single_job(job_dict[job_id])
     
+    # Wait for all background jobs to complete
+    global_bg_tracker.wait_for_all_jobs()
+    
 
 
 async def execute_async(jobs: list[dict]) -> None:
@@ -150,6 +159,9 @@ async def execute_async(jobs: list[dict]) -> None:
 
     await asyncio.gather(*running_jobs)  # Wait for all jobs to complete
     printer.print_success("[ASYNC COMPLETE] All jobs finished!")
+    
+    # Wait for all background jobs from all executed jobs to complete
+    global_bg_tracker.wait_for_all_jobs()
 
 
 def execute_single_job(job: dict) -> None: