nemo-evaluator-launcher 0.1.0rc6__py3-none-any.whl → 0.1.41__py3-none-any.whl

nemo_evaluator_launcher/executors/slurm/proxy.cfg.template

@@ -0,0 +1,26 @@
+global
+    log stdout format raw local0
+    maxconn 4096
+
+defaults
+    log     global
+    mode    http
+    option  httplog
+    timeout connect 10s
+    timeout client  100000s
+    timeout server  100000s
+
+frontend service_frontend
+    bind *:{{ haproxy_port }}
+    default_backend service_backend
+
+backend service_backend
+    mode http
+    option httpchk GET {{ health_check_path }}
+    http-check expect status {{ health_check_status }}
+    option http-server-close
+    balance leastconn
+{% for node in nodes %}
+    server node{{ loop.index }} {{ node.ip }}:{{ node.port }} check
+{% endfor %}
+

nemo_evaluator_launcher/exporters/base.py

@@ -70,6 +70,15 @@ class BaseExporter(ABC):
 
     def get_job_paths(self, job_data: JobData) -> Dict[str, Any]:
         """Get result paths based on executor type from job metadata."""
+        # Special case: remote executor artifacts accessed locally (remote auto-export)
+        if job_data.data.get("storage_type") == "remote_local":
+            output_dir = Path(job_data.data["output_dir"])
+            return {
+                "artifacts_dir": output_dir / "artifacts",
+                "logs_dir": output_dir / "logs",
+                "storage_type": "remote_local",
+            }
+
         if job_data.executor == "local":
             output_dir = Path(job_data.data["output_dir"])
             return {

nemo_evaluator_launcher/exporters/gsheets.py

@@ -15,6 +15,7 @@
 #
 """Google Sheets evaluation results exporter."""
 
+import os
 import shutil
 import tempfile
 from pathlib import Path
@@ -89,28 +90,38 @@ class GSheetsExporter(BaseExporter):
             }
 
         try:
+            # Load exporter config from the first job (supports job-embedded config and CLI overrides)
+            first_job = next(iter(jobs.values()))
+            gsheets_config = extract_exporter_config(first_job, "gsheets", self.config)
+
             # Connect to Google Sheets
-            service_account_file = self.config.get("service_account_file")
-            spreadsheet_name = self.config.get(
+            service_account_file = gsheets_config.get("service_account_file")
+            spreadsheet_name = gsheets_config.get(
                 "spreadsheet_name", "NeMo Evaluator Launcher Results"
             )
 
             if service_account_file:
-                gc = gspread.service_account(filename=service_account_file)
+                gc = gspread.service_account(
+                    filename=os.path.expanduser(service_account_file)
+                )
             else:
                 gc = gspread.service_account()
 
             # Get or create spreadsheet
+            spreadsheet_id = gsheets_config.get("spreadsheet_id")
             try:
-                sh = gc.open(spreadsheet_name)
+                if spreadsheet_id:
+                    sh = gc.open_by_key(spreadsheet_id)
+                else:
+                    sh = gc.open(spreadsheet_name)
                 logger.info(f"Opened existing spreadsheet: {spreadsheet_name}")
             except gspread.SpreadsheetNotFound:
+                if spreadsheet_id:
+                    raise  # Can't create with explicit ID
                 sh = gc.create(spreadsheet_name)
                 logger.info(f"Created new spreadsheet: {spreadsheet_name}")
-                sh.share("", perm_type="anyone", role="reader")
 
             worksheet = sh.sheet1
-
             # Extract metrics from ALL jobs first to determine headers
             all_job_metrics = {}
             results = {}
@@ -226,16 +237,23 @@ class GSheetsExporter(BaseExporter):
                 )
 
                 if service_account_file:
-                    gc = gspread.service_account(filename=service_account_file)
+                    gc = gspread.service_account(
+                        filename=os.path.expanduser(service_account_file)
+                    )
                 else:
                     gc = gspread.service_account()
 
                 # Get or create spreadsheet
+                spreadsheet_id = gsheets_config.get("spreadsheet_id")
                 try:
-                    sh = gc.open(spreadsheet_name)
+                    if spreadsheet_id:
+                        sh = gc.open_by_key(spreadsheet_id)
+                    else:
+                        sh = gc.open(spreadsheet_name)
                 except gspread.SpreadsheetNotFound:
+                    if spreadsheet_id:
+                        raise  # Can't create with explicit ID
                     sh = gc.create(spreadsheet_name)
-                    sh.share("", perm_type="anyone", role="reader")
 
                 worksheet = sh.sheet1
 

nemo_evaluator_launcher/exporters/local.py

@@ -62,6 +62,7 @@ class LocalExporter(BaseExporter):
         """Export job artifacts to local directory."""
         # Merge auto-export + CLI config
         cfg = extract_exporter_config(job_data, "local", self.config)
+        skip_validation = bool(cfg.get("skip_validation", False))
 
         output_dir = Path(cfg.get("output_dir", "./nemo-evaluator-launcher-results"))
         job_export_dir = output_dir / job_data.invocation_id / job_data.job_id
@@ -74,25 +75,34 @@ class LocalExporter(BaseExporter):
             # Stage artifacts per storage type
             if paths["storage_type"] == "local_filesystem":
                 exported_files = self._copy_local_artifacts(paths, job_export_dir, cfg)
-            elif paths["storage_type"] == "remote_ssh":
-                exported_files = ssh_download_artifacts(
-                    paths, job_export_dir, cfg, None
-                )
-            elif paths["storage_type"] == "gitlab_ci_local":
+            elif paths["storage_type"] == "remote_local":
+                # Same as local_filesystem (we're on the remote machine, accessing locally)
                 exported_files = self._copy_local_artifacts(paths, job_export_dir, cfg)
-            elif paths["storage_type"] == "gitlab_remote":
-                raise NotImplementedError("Unsupported storage type")
-                # exported_files = self._download_gitlab_remote_artifacts(
-                #     paths, job_export_dir
-                # )
+            elif paths["storage_type"] == "remote_ssh":
+                cp = ssh_setup_masters({job_data.job_id: job_data})
+                try:
+                    exported_files = ssh_download_artifacts(
+                        paths, job_export_dir, cfg, cp
+                    )
+                finally:
+                    ssh_cleanup_masters(cp)
             else:
-                raise ValueError(
-                    f"Cannot export from storage type: {paths['storage_type']}"
+                raise NotImplementedError(
+                    f"Export not implemented for storage type: {paths['storage_type']}"
                 )
 
             # Validate artifacts
             artifacts_dir = job_export_dir / "artifacts"
-            validation = validate_artifacts(artifacts_dir)
+            validation = (
+                validate_artifacts(artifacts_dir)
+                if not skip_validation
+                else {
+                    "can_export": True,
+                    "missing_required": [],
+                    "missing_optional": [],
+                    "message": "Validation skipped",
+                }
+            )
 
             # Save metadata
             self._save_job_metadata(job_data, job_export_dir)
@@ -125,6 +135,8 @@ class LocalExporter(BaseExporter):
                     logger.warning(f"Failed to create {fmt} summary: {e}")
                     msg += " (summary failed)"
 
+            meta["output_dir"] = str(job_export_dir.resolve())
+
             return ExportResult(
                 success=True, dest=str(job_export_dir), message=msg, metadata=meta
             )
@@ -266,10 +278,12 @@ class LocalExporter(BaseExporter):
     ) -> List[str]:
         exported_files: List[str] = []
         copy_logs = bool(cfg.get("copy_logs", False))
+        copy_artifacts = bool(cfg.get("copy_artifacts", True))
         only_required = bool(cfg.get("only_required", True))
 
+        # separate logic for artifacts and logs
         # artifacts/
-        if paths["artifacts_dir"].exists():
+        if copy_artifacts and paths["artifacts_dir"].exists():
             if only_required:
                 names = [
                     a
@@ -283,7 +297,7 @@ class LocalExporter(BaseExporter):
                     shutil.copy2(src, dst)
                     exported_files.append(str(dst))
             else:
-                # Copy everything under artifacts/ recursively
+                # Restore recursive copy (test_copy_all_tree expects nested files)
                 shutil.copytree(
                     paths["artifacts_dir"], export_dir / "artifacts", dirs_exist_ok=True
                 )
@@ -297,7 +311,7 @@ class LocalExporter(BaseExporter):
 
         # logs/
         # If only_required is False → always copy logs; otherwise respect copy_logs
-        if (not only_required or copy_logs) and paths["logs_dir"].exists():
+        if ((not only_required) or copy_logs) and paths["logs_dir"].exists():
             shutil.copytree(paths["logs_dir"], export_dir / "logs", dirs_exist_ok=True)
             exported_files.extend(
                 [str(f) for f in (export_dir / "logs").rglob("*") if f.is_file()]