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

experimaestro/utils/environment.py

@@ -4,12 +4,16 @@ This module provides functions to capture the full Python environment state
 when experiments are run, including:
 - Git information for editable (development) packages
 - Version information for all installed Python packages
+- Run information (hostname, start time) for experiment runs
 """
 
+import json
 import sys
 import logging
+from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Optional
+from typing import Any, Dict, Optional
+
 from importlib.metadata import distributions
 
 from experimaestro.utils.git import get_git_info
@@ -17,6 +21,94 @@ from experimaestro.utils.git import get_git_info
 logger = logging.getLogger("xpm.environment")
 
 
+@dataclass
+class ExperimentRunInfo:
+    """Information about a single experiment run"""
+
+    hostname: Optional[str] = None
+    started_at: Optional[str] = None
+    ended_at: Optional[str] = None
+    status: Optional[str] = None  # 'completed' or 'failed'
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for JSON serialization"""
+        return {
+            "hostname": self.hostname,
+            "started_at": self.started_at,
+            "ended_at": self.ended_at,
+            "status": self.status,
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "ExperimentRunInfo":
+        """Create from dictionary"""
+        return cls(
+            hostname=data.get("hostname"),
+            started_at=data.get("started_at"),
+            ended_at=data.get("ended_at"),
+            status=data.get("status"),
+        )
+
+
+@dataclass
+class ExperimentEnvironment:
+    """Experiment environment stored in environment.json
+
+    This combines Python environment info with experiment run metadata.
+    """
+
+    python_version: Optional[str] = None
+    packages: Dict[str, str] = field(default_factory=dict)
+    editable_packages: Dict[str, Any] = field(default_factory=dict)
+    run: Optional[ExperimentRunInfo] = None
+    projects: list[Dict[str, Any]] = field(
+        default_factory=list
+    )  # Git info for projects
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for JSON serialization"""
+        result: Dict[str, Any] = {
+            "python_version": self.python_version,
+            "packages": self.packages,
+            "editable_packages": self.editable_packages,
+        }
+        if self.run is not None:
+            result["run"] = self.run.to_dict()
+        if self.projects:
+            result["projects"] = self.projects
+        return result
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "ExperimentEnvironment":
+        """Create from dictionary"""
+        run_data = data.get("run")
+        run = ExperimentRunInfo.from_dict(run_data) if run_data else None
+        return cls(
+            python_version=data.get("python_version"),
+            packages=data.get("packages", {}),
+            editable_packages=data.get("editable_packages", {}),
+            run=run,
+            projects=data.get("projects", []),
+        )
+
+    @classmethod
+    def load(cls, path: Path) -> "ExperimentEnvironment":
+        """Load from a JSON file"""
+        if not path.exists():
+            return cls()
+        try:
+            with path.open("r") as f:
+                data = json.load(f)
+            return cls.from_dict(data)
+        except (json.JSONDecodeError, Exception) as e:
+            logger.warning("Failed to read environment.json: %s", e)
+            return cls()
+
+    def save(self, path: Path) -> None:
+        """Save to a JSON file"""
+        path.write_text(json.dumps(self.to_dict(), indent=2))
+
+
 def get_environment_info() -> dict:
     """Capture complete environment information for reproducibility
 
@@ -110,39 +202,30 @@ def get_editable_packages_git_info() -> dict:
     return editable_packages
 
 
-def save_environment_info(path: Path) -> dict:
-    """Save environment information to a JSON file
-
-    Args:
-        path: Path to save the environment info JSON file
+def get_current_environment() -> ExperimentEnvironment:
+    """Get current environment as an ExperimentEnvironment object
 
     Returns:
-        The environment info dictionary that was saved
+        ExperimentEnvironment with current Python version, packages, etc.
     """
-    import json
-
-    env_info = get_environment_info()
-    path.write_text(json.dumps(env_info, indent=2))
-    logger.info("Saved environment info to %s", path)
-    return env_info
+    current_info = get_environment_info()
+    return ExperimentEnvironment(
+        python_version=current_info["python_version"],
+        packages=current_info["packages"],
+        editable_packages=current_info["editable_packages"],
+    )
 
 
-def load_environment_info(path: Path) -> Optional[dict]:
+def load_environment_info(path: Path) -> Optional[ExperimentEnvironment]:
     """Load environment information from a JSON file
 
     Args:
         path: Path to the environment info JSON file
 
     Returns:
-        Environment info dictionary if file exists and is valid, None otherwise
+        ExperimentEnvironment if file exists and is valid, None otherwise
     """
-    import json
-
     if not path.exists():
         return None
 
-    try:
-        return json.loads(path.read_text())
-    except (json.JSONDecodeError, OSError) as e:
-        logger.warning("Error loading environment info from %s: %s", path, e)
-        return None
+    return ExperimentEnvironment.load(path)

experimaestro/utils/fswatcher.py

@@ -0,0 +1,124 @@
+"""File system watcher utilities
+
+Workarounds for platform-specific file watching limitations.
+"""
+
+import logging
+import sys
+import threading
+from pathlib import Path
+from typing import Optional
+
+logger = logging.getLogger("xpm.fswatcher")
+
+# Marker file for macOS FSEvents workaround
+# See https://github.com/experimaestro/experimaestro-python/issues/154
+# FSEvents doesn't reliably detect SQLite WAL file changes
+DB_CHANGE_MARKER = ".db_changed"
+DB_CHANGE_MARKER_DEBOUNCE_SECONDS = 1.0
+
+
+class FSEventsMarkerWorkaround:
+    """Workaround for FSEvents not detecting SQLite WAL file changes on macOS
+
+    On macOS, FSEvents doesn't reliably detect SQLite WAL file modifications.
+    This class schedules a marker file touch after a delay. If the file system
+    detects the database change before the delay (via cancel()), the touch is
+    skipped.
+
+    Multiple rapid DB writes reset the timer, so touch happens only once after
+    DB_CHANGE_MARKER_DEBOUNCE_SECONDS of inactivity.
+
+    Usage:
+        workaround = FSEventsMarkerWorkaround(db_dir)
+
+        # After each DB write:
+        workaround.schedule_touch()
+
+        # When FSEvents detects a change:
+        workaround.cancel()
+
+        # On cleanup:
+        workaround.stop()
+
+    See https://github.com/experimaestro/experimaestro-python/issues/154
+    """
+
+    def __init__(
+        self,
+        db_dir: Path,
+        debounce_seconds: float = DB_CHANGE_MARKER_DEBOUNCE_SECONDS,
+    ):
+        """Initialize the workaround
+
+        Args:
+            db_dir: Directory containing the database files
+            debounce_seconds: Delay before touching the marker file
+        """
+        self._db_dir = db_dir
+        self._debounce_seconds = debounce_seconds
+        self._timer: Optional[threading.Timer] = None
+        self._lock = threading.Lock()
+        self._enabled = sys.platform == "darwin"
+
+    def schedule_touch(self) -> None:
+        """Schedule a marker file touch after the delay
+
+        First call schedules a touch in debounce_seconds. Subsequent calls
+        within that window are ignored. After the touch happens, the next
+        call can schedule another touch.
+
+        This provides rate limiting: touch happens at most once per
+        debounce_seconds interval.
+        """
+        if not self._enabled:
+            return
+
+        with self._lock:
+            # If timer already running, ignore this event
+            if self._timer is not None:
+                logger.debug("Marker file touch already scheduled, ignoring")
+                return
+
+            # Schedule new touch
+            self._timer = threading.Timer(
+                self._debounce_seconds,
+                self._do_touch,
+            )
+            self._timer.daemon = True
+            self._timer.start()
+            logger.debug("Scheduled marker file touch in %.1fs", self._debounce_seconds)
+
+    def cancel(self) -> None:
+        """Cancel any pending marker file touch
+
+        Call this when FSEvents successfully detected a database change,
+        meaning the workaround is not needed for this change.
+        """
+        if not self._enabled:
+            return
+
+        with self._lock:
+            if self._timer is not None:
+                self._timer.cancel()
+                self._timer = None
+                logger.debug("Cancelled pending marker file touch")
+
+    def stop(self) -> None:
+        """Stop and cleanup (call on shutdown)"""
+        self.cancel()
+
+    def _do_touch(self) -> None:
+        """Actually touch the marker file (called by timer)"""
+        with self._lock:
+            self._timer = None
+
+        if not self._enabled:
+            return
+
+        try:
+            marker_path = self._db_dir / DB_CHANGE_MARKER
+            marker_path.touch()
+            logger.debug("Touched marker file %s for FSEvents workaround", marker_path)
+        except Exception as e:
+            logger.warning("Failed to touch marker file: %s", e)

experimaestro/utils/jobs.py

@@ -60,8 +60,7 @@ def jobmonitor(*outputs: Config):
                             reporter.update(100 - progress)
                     else:
                         raise RuntimeError(
-                            f"Job did not complete successfully ({job.state.name})."
-                            f"Check the error log {job.stderr}"
+                            f"Job did not complete successfully ({job.state.name}).Check the error log {job.stderr}"
                         )
 
         finally:

experimaestro/utils/jupyter.py

@@ -36,8 +36,7 @@ class serverwidget:
             if experiment.CURRENT:
                 self.button.description = "Stop experimaestro server"
                 print(  # noqa: T201
-                    "Server started : "
-                    f"http://localhost:{self.port}/auth?xpm-token={serverwidget.TOKEN}"
+                    f"Server started : http://localhost:{self.port}/auth?xpm-token={serverwidget.TOKEN}"
                 )
             else:
                 self.button.description = "Start experimaestro server"

experimaestro/utils/logging.py

@@ -0,0 +1,72 @@
+"""Logging utilities with colored output support"""
+
+import datetime
+import logging
+import sys
+
+from termcolor import colored
+
+
+class ColoredFormatter(logging.Formatter):
+    """Logging formatter with colors for terminal output"""
+
+    COLORS = {
+        logging.DEBUG: "dark_grey",
+        logging.INFO: "green",
+        logging.WARNING: "yellow",
+        logging.ERROR: "red",
+        logging.CRITICAL: "red",
+    }
+
+    LEVEL_NAMES = {
+        logging.DEBUG: "DEBUG",
+        logging.INFO: "INFO",
+        logging.WARNING: "WARN",
+        logging.ERROR: "ERROR",
+        logging.CRITICAL: "CRIT",
+    }
+
+    def __init__(self, use_color: bool = True):
+        super().__init__()
+        self.use_color = use_color
+
+    def format(self, record: logging.LogRecord) -> str:
+        # ISO format timestamp
+        timestamp = datetime.datetime.fromtimestamp(record.created).isoformat(
+            timespec="seconds"
+        )
+        level_name = self.LEVEL_NAMES.get(record.levelno, record.levelname[:5])
+        message = record.getMessage()
+
+        if self.use_color:
+            color = self.COLORS.get(record.levelno, "white")
+            level_str = colored(f"{level_name:5}", color, attrs=["bold"])
+            name_str = colored(record.name, "cyan")
+            return f"{timestamp} {level_str} {name_str}: {message}"
+        else:
+            return f"{timestamp} {level_name:5} {record.name}: {message}"
+
+
+def setup_logging(debug: bool = False, force_color: bool = False):
+    """Set up logging with optional colors for terminal output
+
+    Args:
+        debug: Enable debug level logging
+        force_color: Force colored output even if not a TTY
+    """
+    root_logger = logging.getLogger()
+    root_logger.setLevel(logging.DEBUG if debug else logging.INFO)
+
+    # Remove existing handlers
+    for handler in root_logger.handlers[:]:
+        root_logger.removeHandler(handler)
+
+    # Check if stderr is a TTY (terminal) for colored output
+    use_color = force_color or sys.stderr.isatty()
+
+    handler = logging.StreamHandler(sys.stderr)
+    handler.setFormatter(ColoredFormatter(use_color=use_color))
+    root_logger.addHandler(handler)
+
+    # Set specific loggers to INFO to reduce noise
+    logging.getLogger("xpm.hash").setLevel(logging.INFO)

experimaestro/version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '2.0.0b8'
-__version_tuple__ = version_tuple = (2, 0, 0, 'b8')
+__version__ = version = '2.0.0b17'
+__version_tuple__ = version_tuple = (2, 0, 0, 'b17')
 
 __commit_id__ = commit_id = None

experimaestro/webui/__init__.py

@@ -0,0 +1,9 @@
+"""WebUI module for experimaestro
+
+FastAPI-based web server with native WebSocket support for monitoring experiments.
+Aligned with TUI architecture using StateProvider abstraction.
+"""
+
+from experimaestro.webui.server import WebUIServer
+
+__all__ = ["WebUIServer"]

experimaestro/webui/app.py

@@ -0,0 +1,117 @@
+"""FastAPI application for WebUI
+
+Creates the FastAPI app with WebSocket endpoint and routes.
+"""
+
+import logging
+from importlib.resources import files
+from typing import TYPE_CHECKING
+
+from fastapi import FastAPI, Request, WebSocket, WebSocketDisconnect
+from fastapi.responses import RedirectResponse, Response
+
+from experimaestro.webui.websocket import WebSocketHandler
+from experimaestro.webui.state_bridge import StateBridge
+from experimaestro.webui.routes import auth, proxy
+
+if TYPE_CHECKING:
+    from experimaestro.webui.server import WebUIServer
+
+logger = logging.getLogger("xpm.webui")
+
+# MIME types for static files
+MIMETYPES = {
+    "html": "text/html",
+    "map": "text/plain",
+    "txt": "text/plain",
+    "ico": "image/x-icon",
+    "png": "image/png",
+    "css": "text/css",
+    "js": "application/javascript",
+    "json": "application/json",
+    "eot": "font/vnd.ms-fontobject",
+    "woff": "font/woff",
+    "woff2": "font/woff2",
+    "ttf": "font/ttf",
+}
+
+
+def create_app(server: "WebUIServer") -> FastAPI:
+    """Create FastAPI application
+
+    Args:
+        server: WebUIServer instance with state_provider and settings
+
+    Returns:
+        Configured FastAPI app
+    """
+    app = FastAPI(title="Experimaestro WebUI", docs_url=None, redoc_url=None)
+
+    # Create WebSocket handler
+    ws_handler = WebSocketHandler(server.state_provider, server.token)
+
+    # Create state bridge to forward state events to WebSocket
+    state_bridge = StateBridge(server.state_provider, ws_handler)
+
+    # Store references on app for routes to access
+    app.state.server = server
+    app.state.ws_handler = ws_handler
+    app.state.state_bridge = state_bridge
+
+    # Include route modules
+    app.include_router(auth.router)
+    app.include_router(proxy.router)
+
+    # WebSocket endpoint
+    @app.websocket("/ws")
+    async def websocket_endpoint(websocket: WebSocket):
+        """Main WebSocket endpoint for real-time updates"""
+        await ws_handler.connect(websocket)
+        try:
+            while True:
+                data = await websocket.receive_json()
+                await ws_handler.handle_message(websocket, data)
+        except WebSocketDisconnect:
+            await ws_handler.disconnect(websocket)
+        except Exception as e:
+            logger.error("WebSocket error: %s", e)
+            await ws_handler.disconnect(websocket)
+
+    # Root route
+    @app.get("/")
+    async def root(request: Request):
+        """Root redirect based on auth status"""
+        # Check cookie for authentication
+        token = request.cookies.get("experimaestro_token")
+        if token == server.token:
+            return RedirectResponse(url="/index.html", status_code=302)
+        return RedirectResponse(url="/login.html", status_code=302)
+
+    # Static file serving (catch-all, must be last)
+    @app.get("/{path:path}")
+    async def static_files(request: Request, path: str):
+        """Serve static files from data/ directory"""
+        # Check authentication for index.html
+        if path == "index.html":
+            token = request.cookies.get("experimaestro_token")
+            if token != server.token:
+                return RedirectResponse(url="/login.html", status_code=302)
+
+        # Get static file
+        datapath = f"data/{path}"
+        logger.debug("Looking for %s", datapath)
+
+        try:
+            package_files = files("experimaestro.webui")
+            resource_file = package_files / datapath
+            if resource_file.is_file():
+                ext = datapath.rsplit(".", 1)[-1]
+                mimetype = MIMETYPES.get(ext, "application/octet-stream")
+                content = resource_file.read_bytes()
+                return Response(content=content, media_type=mimetype)
+        except (FileNotFoundError, KeyError):
+            pass
+
+        return Response(content="Page not found", status_code=404)
+
+    return app

experimaestro/{server → webui}/data/index.css

@@ -3,7 +3,7 @@
   \**********************************************************************************************************************************************************************************************************************************************/
 @charset "UTF-8";
 /*!
-* Bootstrap  v5.3.5 (https://getbootstrap.com/)
+* Bootstrap  v5.3.8 (https://getbootstrap.com/)
 * Copyright 2011-2025 The Bootstrap Authors
 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
 */
@@ -520,6 +520,11 @@ legend + * {
   outline-offset: -2px;
 }
 
+[type=search]::-webkit-search-cancel-button {
+  cursor: pointer;
+  filter: grayscale(1);
+}
+
 ::-webkit-search-decoration {
   -webkit-appearance: none;
 }
@@ -4492,20 +4497,20 @@ textarea.form-control-lg {
     border-top-right-radius: 0;
     border-bottom-right-radius: 0;
   }
-  .card-group > .card:not(:last-child) .card-header, .card-group > .card:not(:last-child) .card-img-top {
+  .card-group > .card:not(:last-child) > .card-header, .card-group > .card:not(:last-child) > .card-img-top {
     border-top-right-radius: 0;
   }
-  .card-group > .card:not(:last-child) .card-footer, .card-group > .card:not(:last-child) .card-img-bottom {
+  .card-group > .card:not(:last-child) > .card-footer, .card-group > .card:not(:last-child) > .card-img-bottom {
     border-bottom-right-radius: 0;
   }
   .card-group > .card:not(:first-child) {
     border-top-left-radius: 0;
     border-bottom-left-radius: 0;
   }
-  .card-group > .card:not(:first-child) .card-header, .card-group > .card:not(:first-child) .card-img-top {
+  .card-group > .card:not(:first-child) > .card-header, .card-group > .card:not(:first-child) > .card-img-top {
     border-top-left-radius: 0;
   }
-  .card-group > .card:not(:first-child) .card-footer, .card-group > .card:not(:first-child) .card-img-bottom {
+  .card-group > .card:not(:first-child) > .card-footer, .card-group > .card:not(:first-child) > .card-img-bottom {
     border-bottom-left-radius: 0;
   }
 }
@@ -6232,6 +6237,7 @@ textarea.form-control-lg {
 
 .spinner-border, .spinner-grow {
   display: inline-block;
+  flex-shrink: 0;
   width: var(--bs-spinner-width);
   height: var(--bs-spinner-height);
   vertical-align: var(--bs-spinner-vertical-align);
@@ -7196,6 +7202,10 @@ textarea.form-control-lg {
   position: absolute !important;
 }
 
+.visually-hidden *, .visually-hidden-focusable:not(:focus):not(:focus-within) * {
+  overflow: hidden !important;
+}
+
 .stretched-link::after {
   position: absolute;
   top: 0;
@@ -20375,8 +20385,8 @@ readers do not read off random characters that represent icons */
  * Copyright 2024 Fonticons, Inc.
  */
 :root, :host {
-  --fa-style-family-classic: "Font Awesome 6 Free";
-  --fa-font-regular: normal 400 1em/1 "Font Awesome 6 Free";
+  --fa-style-family-classic: 'Font Awesome 6 Free';
+  --fa-font-regular: normal 400 1em/1 'Font Awesome 6 Free';
 }
 
 @font-face {
@@ -20397,8 +20407,8 @@ readers do not read off random characters that represent icons */
  * Copyright 2024 Fonticons, Inc.
  */
 :root, :host {
-  --fa-style-family-brands: "Font Awesome 6 Brands";
-  --fa-font-brands: normal 400 1em/1 "Font Awesome 6 Brands";
+  --fa-style-family-brands: 'Font Awesome 6 Brands';
+  --fa-font-brands: normal 400 1em/1 'Font Awesome 6 Brands';
 }
 
 @font-face {
@@ -22539,8 +22549,8 @@ readers do not read off random characters that represent icons */
  * Copyright 2024 Fonticons, Inc.
  */
 :root, :host {
-  --fa-style-family-classic: "Font Awesome 6 Free";
-  --fa-font-solid: normal 900 1em/1 "Font Awesome 6 Free";
+  --fa-style-family-classic: 'Font Awesome 6 Free';
+  --fa-font-solid: normal 900 1em/1 'Font Awesome 6 Free';
 }
 
 @font-face {
@@ -22753,6 +22763,51 @@ readers do not read off random characters that represent icons */
   font-weight: bold;
 }
 
+.dependencies {
+  display: inline-block;
+  margin-left: 8px;
+  font-size: 0.75rem;
+  line-height: 1.2rem;
+}
+.dependencies .dependencies-label {
+  color: #666;
+  font-style: italic;
+  margin-right: 4px;
+}
+.dependencies .dependency {
+  display: inline-block;
+  padding: 2px 6px;
+  margin: 1px 2px;
+  border-radius: 3px;
+  font-size: 0.7rem;
+  font-weight: 500;
+  cursor: default;
+}
+.dependencies .dependency.status-done {
+  background: #c8e6c9;
+  color: #2e7d32;
+}
+.dependencies .dependency.status-running {
+  background: #fff9c4;
+  color: #f57f17;
+}
+.dependencies .dependency.status-waiting {
+  background: #ffe0b2;
+  color: #e65100;
+}
+.dependencies .dependency.status-ready {
+  background: #fff59d;
+  color: #827717;
+}
+.dependencies .dependency.status-error {
+  background: #ffcdd2;
+  color: #c62828;
+}
+.dependencies .dependency.status-unknown {
+  background: #e0e0e0;
+  color: #616161;
+}
+
 body {
   font-size: 1rem;
 }