experimaestro 2.0.0b4__py3-none-any.whl → 2.0.0b8__py3-none-any.whl

experimaestro/scheduler/state_sync.py

@@ -97,6 +97,35 @@ def read_services_json(exp_dir: Path) -> Dict[str, Dict]:
     return {}
 
 
+def read_informations_json(exp_dir: Path) -> Dict:
+    """Read informations.json file containing experiment metadata
+
+    Args:
+        exp_dir: Path to the experiment directory
+
+    Returns:
+        Dictionary with experiment informations including:
+        - runs: Dict[run_id, {hostname, started_at}]
+    """
+    info_path = exp_dir / "informations.json"
+
+    if not info_path.exists():
+        logger.debug("No informations.json found in %s", exp_dir)
+        return {}
+
+    try:
+        with info_path.open("r") as f:
+            info_data = json.load(f)
+            logger.debug("Read informations.json from %s", exp_dir)
+            return info_data
+    except json.JSONDecodeError as e:
+        logger.warning("Failed to parse informations.json: %s", e)
+    except Exception as e:
+        logger.warning("Failed to read informations.json from %s: %s", info_path, e)
+
+    return {}
+
+
 def acquire_sync_lock(
     workspace_path: Path, blocking: bool = True
 ) -> Optional[fasteners.InterProcessLock]:
@@ -551,6 +580,10 @@ def sync_workspace_from_disk(  # noqa: C901
                 # Read services.json to get services for this experiment
                 service_records = read_services_json(exp_dir)
 
+                # Read informations.json for run metadata (hostname, etc.)
+                info_data = read_informations_json(exp_dir)
+                runs_info = info_data.get("runs", {})
+
                 if write_mode:
                     # Ensure experiment exists in database
                     now = datetime.now()
@@ -575,16 +608,32 @@ def sync_workspace_from_disk(  # noqa: C901
                     # Use the most recent run as current
                     current_run_id = existing_runs[0].run_id
                     runs_found += len(existing_runs)
+
+                    # Update hostname from informations.json if available
+                    if write_mode:
+                        for run in existing_runs:
+                            run_info = runs_info.get(run.run_id, {})
+                            hostname = run_info.get("hostname")
+                            if hostname and not run.hostname:
+                                ExperimentRunModel.update(hostname=hostname).where(
+                                    (ExperimentRunModel.experiment_id == experiment_id)
+                                    & (ExperimentRunModel.run_id == run.run_id)
+                                ).execute()
                 else:
                     # Create initial run
                     current_run_id = "initial"
                     runs_found += 1
 
+                    # Get hostname from informations.json if available
+                    run_info = runs_info.get(current_run_id, {})
+                    hostname = run_info.get("hostname")
+
                     if write_mode:
                         ExperimentRunModel.insert(
                             experiment_id=experiment_id,
                             run_id=current_run_id,
                             status="active",
+                            hostname=hostname,
                         ).on_conflict_ignore().execute()
 
                         # Update experiment's current_run_id
@@ -603,17 +652,29 @@ def sync_workspace_from_disk(  # noqa: C901
                 if write_mode and service_records:
                     for service_id, service_data in service_records.items():
                         now = datetime.now()
-                        # Store the full state_dict as JSON for recreation
-                        state_dict_json = json.dumps(service_data)
+                        # Extract only the state_dict keys (not metadata like
+                        # service_id, description, state, url, timestamp)
+                        # The state_dict should have __class__ and service-specific
+                        # fields like 'path' for TensorboardService
+                        metadata_keys = {
+                            "service_id",
+                            "description",
+                            "url",
+                            "timestamp",
+                        }
+                        state_dict = {
+                            k: v
+                            for k, v in service_data.items()
+                            if k not in metadata_keys
+                        }
+                        state_dict_json = json.dumps(state_dict)
                         ServiceModel.insert(
                             service_id=service_id,
                             experiment_id=experiment_id,
                             run_id=current_run_id,
                             description=service_data.get("description", ""),
-                            state=service_data.get("state", "STOPPED"),
                             state_dict=state_dict_json,
                             created_at=now,
-                            updated_at=now,
                         ).on_conflict(
                             conflict_target=[
                                 ServiceModel.service_id,
@@ -624,11 +685,7 @@ def sync_workspace_from_disk(  # noqa: C901
                                 ServiceModel.description: service_data.get(
                                     "description", ""
                                 ),
-                                ServiceModel.state: service_data.get(
-                                    "state", "STOPPED"
-                                ),
                                 ServiceModel.state_dict: state_dict_json,
-                                ServiceModel.updated_at: now,
                             },
                         ).execute()
                         logger.debug(

experimaestro/tests/test_cli_jobs.py

@@ -33,7 +33,7 @@ def workspace_path(tmp_path):
     xpm_dir = ws_path / ".experimaestro"
     xpm_dir.mkdir()
     db_path = xpm_dir / "workspace.db"
-    db = initialize_workspace_database(db_path, read_only=False)
+    db, _ = initialize_workspace_database(db_path, read_only=False)
 
     # Create jobs directory
     jobs_dir = ws_path / "jobs"
@@ -48,7 +48,7 @@ def workspace_path(tmp_path):
 def workspace_with_jobs(workspace_path):
     """Create a workspace with some test jobs in the database"""
     db_path = workspace_path / ".experimaestro" / "workspace.db"
-    db = initialize_workspace_database(db_path, read_only=False)
+    db, _ = initialize_workspace_database(db_path, read_only=False)
 
     with db.bind_ctx(ALL_MODELS):
         # Create experiment and run
@@ -152,7 +152,7 @@ def test_jobs_list_fullpath(workspace_with_jobs):
 def workspace_with_timed_jobs(workspace_path):
     """Create a workspace with jobs that have different submission times"""
     db_path = workspace_path / ".experimaestro" / "workspace.db"
-    db = initialize_workspace_database(db_path, read_only=False)
+    db, _ = initialize_workspace_database(db_path, read_only=False)
 
     with db.bind_ctx(ALL_MODELS):
         ExperimentModel.create(experiment_id="test_exp", current_run_id="run_001")