scientiflow-cli 0.4.6__tar.gz → 0.4.8__tar.gz

{scientiflow_cli-0.4.6 → scientiflow_cli-0.4.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: scientiflow-cli
-Version: 0.4.6
+Version: 0.4.8
 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.6 → scientiflow_cli-0.4.8}/pyproject.toml

@@ -1,6 +1,9 @@
+[tool.scientiflow]
+mode = "prod"
+
 [tool.poetry]
 name = "scientiflow-cli"
-version = "0.4.6"
+version = "0.4.8"
 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.6 → scientiflow_cli-0.4.8}/scientiflow_cli/main.py

@@ -7,10 +7,11 @@ from importlib.metadata import PackageNotFoundError
 from scientiflow_cli.cli.login import login_user
 from scientiflow_cli.cli.logout import logout_user
 from scientiflow_cli.pipeline.get_jobs import get_jobs
-from scientiflow_cli.services.executor import execute_jobs, execute_jobs_sync, execute_job_id
+from scientiflow_cli.services.executor import execute_jobs
 from scientiflow_cli.services.base_directory import set_base_directory, get_base_directory
 from scientiflow_cli.utils.singularity import install_singularity_main as install_singularity
 from scientiflow_cli.pipeline.container_manager import manage_containers
+from scientiflow_cli.services.modes import set_mode
 from scientiflow_cli.services.rich_printer import RichPrinter
 from art import text2art
 
@@ -82,6 +83,8 @@ def main():
     parser.add_argument('--execute-jobs', nargs='*', type=int, help="Execute jobs. Specify job IDs as arguments \n(e.g., --execute-jobs jobID1 jobID2 ...) or leave empty to execute all jobs.\nUse -p or --parallel flag to execute jobs in parallel.")
     parser.add_argument('--hostname', type=str, help=argparse.SUPPRESS)  # Hide --hostname from --help
     parser.add_argument('--token', type=str, help=argparse.SUPPRESS)  # Hide --token from --help
+    parser.add_argument('--set-mode', type=str, choices=["dev", "prod"], help=argparse.SUPPRESS) # Hide --set-mode from --help
+    parser.add_argument('--cloud-job', action='store_true', help=argparse.SUPPRESS) # Hide --cloud-job from --help
 
     # Parse arguments
     args, unknown_args = parser.parse_known_args()
@@ -120,7 +123,7 @@ def main():
         elif args.execute_jobs is not None:
             # Use the parsed `parallel` flag
             job_ids = args.execute_jobs if args.execute_jobs else None
-            execute_jobs(job_ids=job_ids, parallel=args.parallel)
+            execute_jobs(job_ids=job_ids, parallel=args.parallel, is_cloud=args.cloud_job)
         elif args.install_singularity:
             install_singularity(enable_gpu=args.enable_gpu)
         elif args.manage_containers:
@@ -128,6 +131,10 @@ def main():
             if not base_dir:
                 sys.exit(2)
             manage_containers(base_dir=base_dir)
+        elif args.set_mode:
+            logout_user()
+            set_mode(args.set_mode)
+            sys.exit(0)
         else:
             display_title()
             printer.print_message("No arguments specified. Use --help to see available options", style="bold red")

{scientiflow_cli-0.4.6 → scientiflow_cli-0.4.8}/scientiflow_cli/pipeline/decode_and_execute.py

@@ -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)
@@ -165,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."""
@@ -284,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:
@@ -344,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.6 → scientiflow_cli-0.4.8}/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
@@ -21,7 +21,7 @@ def get_all_pending_jobs() -> list[dict]:
         return []
 
 
-def execute_jobs(job_ids: list[int] = None, parallel: bool = False) -> None:
+def execute_jobs(job_ids: list[int] = None, parallel: bool = False, is_cloud: bool = False) -> None:
     """
     Execute jobs based on the provided job IDs. If no job IDs are provided, execute all pending jobs.
     If `parallel` is True, execute jobs asynchronously.
@@ -50,26 +50,8 @@ def execute_jobs(job_ids: list[int] = None, parallel: bool = False) -> None:
     else:
         # Execute jobs synchronously
         for job in jobs_to_execute:
-            execute_single_job(job)
-
-
-def execute_jobs_sync(job_ids: list[int] = None) -> None:
-    """
-    Execute all jobs synchronously and in order
-    """
-
-    all_pending_jobs: list[dict] = []
-    all_pending_jobs = get_all_pending_jobs()
-    all_pending_jobs = sort_jobs_by_id(all_pending_jobs)
-
-    job_dict: dict[int, dict] = store_jobs_in_dict(all_pending_jobs)
-
-    for job_id in job_ids:
-        if job_id not in job_dict:
-            printer.print_error(f"No job found with ID: {job_id}")
-            continue
-        execute_single_job(job_dict[job_id])
-
+            execute_single_job(job, is_cloud)
+        
 
 def sort_jobs_by_id(all_pending_jobs: list[dict]) -> list[dict]:
     """
@@ -97,28 +79,6 @@ def store_jobs_in_dict(all_pending_jobs: list[dict]) -> dict:
 
     return job_dict
 
-
-def execute_job_id(job_id: int) -> None:
-    """
-    Execute job with the given job_id
-    """
-    
-    # Retrieve all jobs using 'get_jobs'
-    all_pending_jobs: list[dict] = []
-    
-    all_pending_jobs = get_all_pending_jobs()
-
-    # Store jobs in order of their job_id
-    job_dict: dict[int, dict] = store_jobs_in_dict(all_pending_jobs)
-
-    if job_id not in job_dict:
-        printer.print_error(f"No job found with ID: {job_id}")
-        return
-
-    execute_single_job(job_dict[job_id])
-    
-
-
 async def execute_async(jobs: list[dict]) -> None:
     """Execute jobs asynchronously."""
     running_jobs = []
@@ -150,9 +110,12 @@ 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:
+def execute_single_job(job: dict, is_cloud: bool = False) -> None:
     """Function to decode and execute a job."""
     try:
         # Validate the job dictionary
@@ -189,7 +152,7 @@ def execute_single_job(job: dict) -> None:
         if job_status != "running":
             if job["new_job"] == 1:
                 # Initialize folders for the project / project_job 
-                create_job_dirs(job)
+                create_job_dirs(job, is_cloud)
 
             # Fetch the files and folder from the backend
             get_job_files(job)

scientiflow_cli-0.4.8/scientiflow_cli/services/modes.py

@@ -0,0 +1,45 @@
+from pathlib import Path
+from scientiflow_cli.services.rich_printer import RichPrinter
+import os
+
+printer = RichPrinter()
+
+# Use ~/.scientiflow/mode for mode configuration (plain text file)
+MODE_FILE = os.path.expanduser("~/.scientiflow/mode")
+MODE_DIR = os.path.dirname(MODE_FILE)
+
+def set_mode(mode: str):
+    mode = mode.lower()
+    if mode not in {"dev", "prod"}:
+        raise ValueError("Mode must be either 'dev' or 'prod'")
+
+    # Ensure directory exists
+    os.makedirs(MODE_DIR, exist_ok=True)
+
+    # Write mode to plain text file
+    with open(MODE_FILE, "w") as file:
+        file.write(mode)
+
+    printer.print_message(
+        f"ScientiFlow mode set to '{mode}'",
+        style="bold green"
+    )
+
+
+def get_mode() -> str:
+    # Create mode file with default "prod" if it doesn't exist
+    if not os.path.exists(MODE_FILE):
+        os.makedirs(MODE_DIR, exist_ok=True)
+        with open(MODE_FILE, "w") as file:
+            file.write("prod")
+        return "prod"
+
+    # Read mode from file
+    try:
+        with open(MODE_FILE, "r") as file:
+            mode = file.read().strip().lower()
+            if mode in {"dev", "prod"}:
+                return mode
+            return "prod"
+    except Exception:
+        return "prod"

scientiflow_cli-0.4.8/scientiflow_cli/services/request_handler.py

@@ -0,0 +1,44 @@
+import requests
+from scientiflow_cli.utils.config import get_app_base_url
+from scientiflow_cli.cli.auth_utils import getAuthToken
+
+
+def handle_response(response, error_message):
+    return response 
+
+def make_auth_request(endpoint, method, data=None, params=None, error_message=None):
+    headers = {'Authorization': f'Bearer {getAuthToken()}'}
+    base_url = get_app_base_url()
+
+    try:
+        if method == 'GET':
+            response = requests.get(base_url + endpoint, headers=headers, params=params)
+        elif method == 'POST':
+            response = requests.post(base_url + endpoint, json=data, headers=headers)
+        else:
+            raise ValueError("Unsupported HTTP method")
+
+        return handle_response(response, error_message)
+
+    except requests.RequestException as e:
+        print(e)
+        return "Request failed"
+
+
+def make_no_auth_request(endpoint, method, data=None, error_message=None):
+    base_url = get_app_base_url()
+
+    try:
+        if method == 'GET':
+            response = requests.get(base_url + endpoint)
+        elif method == 'POST':
+            response = requests.post(base_url + endpoint, json=data)
+            print(response)
+        else:
+            raise ValueError("Unsupported HTTP method")
+
+        return handle_response(response, error_message)
+
+    except requests.RequestException as e:
+        print(e)
+        return "Request failed"

scientiflow_cli-0.4.8/scientiflow_cli/utils/config.py

@@ -0,0 +1,9 @@
+from scientiflow_cli.services.modes import get_mode
+
+
+def get_app_base_url() -> str:
+    mode = get_mode()
+    if mode == "dev":
+        return "https://www.scientiflow-backend-dev.scientiflow.com/api"
+
+    return "https://www.backend.scientiflow.com/api"

{scientiflow_cli-0.4.6 → scientiflow_cli-0.4.8}/scientiflow_cli/utils/file_manager.py

@@ -37,9 +37,12 @@ def get_job_files(job: dict) -> None:
 
     printer.print_success(f"[+] Files extracted to {str(project_dir_name).strip()}")
         
-def create_job_dirs(job: dict) -> None:
+def create_job_dirs(job: dict, is_cloud: bool = False) -> None:
     base_dir = Path(job['server']['base_directory'])
-    project_dir = base_dir / job['project']['project_title']
+    if is_cloud:
+        project_dir = base_dir / (job['project']['id']+"_"+job['project']['project_title'])
+    else:
+        project_dir = base_dir / job['project']['project_title']       
     job_dir = project_dir / job['project_job']['job_directory']
     job_dir.mkdir(parents=True, exist_ok=True)
 

scientiflow_cli-0.4.6/scientiflow_cli/config.py

@@ -1,9 +0,0 @@
-import os
-
-class Config:
-    mode="prod" 
-    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")

scientiflow_cli-0.4.6/scientiflow_cli/services/request_handler.py

@@ -1,31 +0,0 @@
-import requests
-from scientiflow_cli.config import Config
-from scientiflow_cli.cli.auth_utils import getAuthToken
-
-app_base_url = Config.APP_BASE_URL
-
-
-def handle_response(response, error_message):
-    return response 
-
-def make_auth_request(endpoint,method,data=None,params=None,error_message=None):
-    headers = {'Authorization': f'Bearer {getAuthToken()}'}
-    try:
-        if method == 'GET':
-            response = requests.get(app_base_url+endpoint,headers=headers,params=params)
-        elif method == 'POST':
-            response = requests.post(app_base_url+endpoint, json=data,headers=headers)
-        return handle_response(response, error_message)
-    except requests.RequestException as e:
-        return "Unsupported HTTP method"
-    
-def make_no_auth_request(endpoint,method,data=None,error_message=None):
-    try:
-        if method == 'GET':
-                response = requests.get(app_base_url+endpoint)
-        elif method == 'POST':
-                response = requests.post(app_base_url+endpoint, json=data)
-        return handle_response(response, error_message)
-    except requests.RequestException as e:
-        return "Unsupported HTTP method"
-