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

experimaestro/tests/test_types.py

@@ -1,7 +1,7 @@
 # --- Task and types definitions
 
 import logging
-from experimaestro import Config, Param
+from experimaestro import Config, Param, field
 from typing import Union
 
 import pytest
@@ -63,3 +63,125 @@ def test_types_union():
     A.C(x="hello")
     with pytest.raises(ValueError):
         A.C(x=[])
+
+
+def test_override_warning_without_flag(caplog):
+    """Test that overriding a parameter without overrides=True produces a warning"""
+
+    class Parent(Config):
+        value: Param[int]
+
+    with caplog.at_level(logging.WARNING, logger="xpm"):
+        # Child overrides value without overrides=True
+        class Child(Parent):
+            value: Param[int]
+
+        # Force initialization to trigger the warning
+        Child.__getxpmtype__().arguments
+
+    assert "overrides parent parameter" in caplog.text
+    assert "Child" in caplog.text
+    assert "value" in caplog.text
+
+
+def test_override_no_warning_with_flag(caplog):
+    """Test that overriding with overrides=True suppresses the warning"""
+
+    class Parent(Config):
+        value: Param[int]
+
+    with caplog.at_level(logging.WARNING, logger="xpm"):
+        # Child overrides value with overrides=True
+        class Child(Parent):
+            value: Param[int] = field(overrides=True)
+
+        # Force initialization
+        Child.__getxpmtype__().arguments
+
+    # No warning should be issued
+    assert "overrides parent parameter" not in caplog.text
+
+
+def test_override_type_check_subtype_config():
+    """Test that overriding Config type with subtype is allowed"""
+
+    class BaseValue(Config):
+        x: Param[int]
+
+    class DerivedValue(BaseValue):
+        y: Param[int]
+
+    class Parent(Config):
+        value: Param[BaseValue]
+
+    # Should succeed - DerivedValue is subtype of BaseValue
+    class Child(Parent):
+        value: Param[DerivedValue] = field(overrides=True)
+
+    Child.__getxpmtype__().arguments
+
+
+def test_override_type_check_incompatible_config():
+    """Test that overriding Config type with incompatible type raises error"""
+
+    class ValueA(Config):
+        x: Param[int]
+
+    class ValueB(Config):
+        y: Param[int]
+
+    class Parent(Config):
+        value: Param[ValueA]
+
+    # Should fail - ValueB is not a subtype of ValueA
+    with pytest.raises(TypeError, match="is not a subtype"):
+
+        class Child(Parent):
+            value: Param[ValueB] = field(overrides=True)
+
+        Child.__getxpmtype__().arguments
+
+
+def test_override_type_check_primitive_incompatible():
+    """Test that overriding primitive type with incompatible type raises error"""
+
+    class Parent(Config):
+        value: Param[int]
+
+    # Should fail - str is not a subtype of int
+    with pytest.raises(TypeError, match="is not compatible"):
+
+        class Child(Parent):
+            value: Param[str] = field(overrides=True)
+
+        Child.__getxpmtype__().arguments
+
+
+def test_override_type_check_same_type():
+    """Test that overriding with the same type is allowed"""
+
+    class Parent(Config):
+        value: Param[int]
+
+    # Should succeed - same type
+    class Child(Parent):
+        value: Param[int] = field(overrides=True)
+
+    Child.__getxpmtype__().arguments
+
+
+def test_no_override_warning_for_new_param(caplog):
+    """Test that defining a new parameter doesn't produce a warning"""
+
+    class Parent(Config):
+        x: Param[int]
+
+    with caplog.at_level(logging.WARNING, logger="xpm"):
+        # Child defines a new parameter y, doesn't override x
+        class Child(Parent):
+            y: Param[int]
+
+        Child.__getxpmtype__().arguments
+
+    # No warning should be issued for new parameter
+    assert "overrides parent parameter" not in caplog.text

experimaestro/tests/test_workspace_triggers.py

@@ -0,0 +1,158 @@
+"""Tests for workspace trigger matching (issue #119)"""
+
+from pathlib import Path
+from experimaestro.settings import WorkspaceSettings, find_workspace, Settings
+from unittest.mock import patch
+
+
+def test_workspace_trigger_exact_match():
+    """Test exact match trigger"""
+    workspaces = [
+        WorkspaceSettings(
+            id="neuralir",
+            path=Path("/tmp/test1"),
+            triggers=["my-awesome-experiment"],
+        ),
+        WorkspaceSettings(
+            id="default",
+            path=Path("/tmp/test2"),
+        ),
+    ]
+
+    settings = Settings(workspaces=workspaces)
+
+    with patch("experimaestro.settings.get_settings", return_value=settings):
+        ws = find_workspace(experiment_id="my-awesome-experiment")
+        assert ws.id == "neuralir"
+
+
+def test_workspace_trigger_glob_match():
+    """Test glob pattern trigger"""
+    workspaces = [
+        WorkspaceSettings(
+            id="neuralir",
+            path=Path("/tmp/test1"),
+            triggers=["base_id-*"],
+        ),
+        WorkspaceSettings(
+            id="default",
+            path=Path("/tmp/test2"),
+        ),
+    ]
+
+    settings = Settings(workspaces=workspaces)
+
+    with patch("experimaestro.settings.get_settings", return_value=settings):
+        ws = find_workspace(experiment_id="base_id-123")
+        assert ws.id == "neuralir"
+
+        ws = find_workspace(experiment_id="base_id-test")
+        assert ws.id == "neuralir"
+
+
+def test_workspace_trigger_multiple_patterns():
+    """Test multiple trigger patterns"""
+    workspaces = [
+        WorkspaceSettings(
+            id="neuralir",
+            path=Path("/tmp/test1"),
+            triggers=["base_id-*", "my-awesome-experiment", "test-*"],
+        ),
+        WorkspaceSettings(
+            id="default",
+            path=Path("/tmp/test2"),
+        ),
+    ]
+
+    settings = Settings(workspaces=workspaces)
+
+    with patch("experimaestro.settings.get_settings", return_value=settings):
+        ws = find_workspace(experiment_id="base_id-123")
+        assert ws.id == "neuralir"
+
+        ws = find_workspace(experiment_id="my-awesome-experiment")
+        assert ws.id == "neuralir"
+
+        ws = find_workspace(experiment_id="test-foo")
+        assert ws.id == "neuralir"
+
+
+def test_workspace_trigger_no_match_uses_default():
+    """Test that default workspace (first in list) is used when no trigger matches"""
+    workspaces = [
+        WorkspaceSettings(
+            id="default",
+            path=Path("/tmp/test1"),
+        ),
+        WorkspaceSettings(
+            id="neuralir",
+            path=Path("/tmp/test2"),
+            triggers=["base_id-*"],
+        ),
+    ]
+
+    settings = Settings(workspaces=workspaces)
+
+    with patch("experimaestro.settings.get_settings", return_value=settings):
+        ws = find_workspace(experiment_id="other-experiment")
+        assert ws.id == "default"  # First workspace is the default
+
+
+def test_workspace_trigger_first_match_wins():
+    """Test that first matching workspace is selected"""
+    workspaces = [
+        WorkspaceSettings(
+            id="first",
+            path=Path("/tmp/test1"),
+            triggers=["test-*"],
+        ),
+        WorkspaceSettings(
+            id="second",
+            path=Path("/tmp/test2"),
+            triggers=["test-*"],
+        ),
+    ]
+
+    settings = Settings(workspaces=workspaces)
+
+    with patch("experimaestro.settings.get_settings", return_value=settings):
+        ws = find_workspace(experiment_id="test-experiment")
+        assert ws.id == "first"
+
+
+def test_workspace_explicit_takes_precedence():
+    """Test that explicit workspace parameter overrides triggers"""
+    workspaces = [
+        WorkspaceSettings(
+            id="neuralir",
+            path=Path("/tmp/test1"),
+            triggers=["base_id-*"],
+        ),
+        WorkspaceSettings(
+            id="other",
+            path=Path("/tmp/test2"),
+        ),
+    ]
+
+    settings = Settings(workspaces=workspaces)
+
+    with patch("experimaestro.settings.get_settings", return_value=settings):
+        # Even though experiment_id matches neuralir trigger, explicit workspace wins
+        ws = find_workspace(workspace="other", experiment_id="base_id-123")
+        assert ws.id == "other"
+
+
+def test_workspace_no_triggers_backward_compatible():
+    """Test that workspaces without triggers still work (backward compatibility)"""
+    workspaces = [
+        WorkspaceSettings(
+            id="default",
+            path=Path("/tmp/test1"),
+        ),
+    ]
+
+    settings = Settings(workspaces=workspaces)
+
+    with patch("experimaestro.settings.get_settings", return_value=settings):
+        ws = find_workspace(experiment_id="any-experiment")
+        assert ws.id == "default"

experimaestro/tests/token_reschedule.py

@@ -19,9 +19,9 @@ if __name__ == "__main__":
     handler = logging.StreamHandler()
     bf = logging.Formatter(
         f"[XP{x}] "
-        "[%(levelname)s] %(asctime)s %(name)s "
+        "[%(levelname)s] %(asctime)s.%(msecs)03d %(name)s "
         "[%(process)d/%(threadName)s]: %(message)s",
-        datefmt="%H:%M:%S.%f",
+        datefmt="%H:%M:%S",
     )
     handler.setFormatter(bf)
     root.handlers.clear()
@@ -46,4 +46,6 @@ if __name__ == "__main__":
         # Wait until the experiment
         task.__xpm__.task.job.wait()
         logging.info("Reschedule with token [%s]: finished", x)
+
+        # Write the timestamp from the task so the test can retrieve them easily
         Path(timepath).write_text(Path(task.stdout()).read_text())

experimaestro/tests/utils.py

@@ -5,7 +5,7 @@ from pathlib import Path
 import logging
 import signal
 
-from experimaestro import experiment, task
+from experimaestro import experiment, Task
 from experimaestro.scheduler.workspace import RunMode
 
 
@@ -24,7 +24,7 @@ class TimeInterval:
         return str(self)
 
 
-def get_times(task: task) -> TimeInterval:
+def get_times(task: Task) -> TimeInterval:
     logging.info("Reading times from %s", task.stdout())
     return TimeInterval(
         *(float(t) for t in task.stdout().read_text().strip().split("\n"))

experimaestro/tokens.py

@@ -5,6 +5,8 @@ a computational resource (e.g. number of launched jobs, etc.)
 from dataclasses import dataclass
 import sys
 from pathlib import Path
+import time
+import weakref
 
 from omegaconf import DictConfig
 from experimaestro.core.objects import Config
@@ -19,7 +21,7 @@ from experimaestro.launcherfinder.registry import LauncherRegistry
 
 from .ipc import ipcom
 from .locking import Lock, LockError
-from .scheduler.dependencies import Dependency, DependencyStatus, Resource
+from .scheduler.dependencies import DynamicDependency, Resource
 import logging
 import json
 
@@ -32,16 +34,6 @@ class Token(Resource):
 
     available: int
 
-    def aio_notify(self):
-        # Notifying
-        def check(dependency: Dependency):
-            if self.available > 0:
-                dependency.check()
-
-        with self.dependents as dependents:
-            for _dependency in dependents:
-                _dependency.loop.call_soon_threadsafe(check, _dependency)
-
 
 class CounterTokenLock(Lock):
     def __init__(self, dependency: "CounterTokenDependency"):
@@ -58,8 +50,8 @@ class CounterTokenLock(Lock):
         return "Lock(%s)" % self.dependency
 
 
-class CounterTokenDependency(Dependency):
-    """A dependency onto a token"""
+class CounterTokenDependency(DynamicDependency):
+    """A dependency onto a token (dynamic - availability can change)"""
 
     def __init__(self, token: "CounterToken", count: int):
         super().__init__(token)
@@ -71,13 +63,54 @@ class CounterTokenDependency(Dependency):
         """The (file) name for this dependency, when taken"""
         return f"{self.target.identifier}.token"
 
-    def status(self) -> DependencyStatus:
-        if self.count <= self.token.available:
-            return DependencyStatus.OK
-        return DependencyStatus.WAIT
+    async def aio_lock(self, timeout: float = 0) -> "Lock":
+        """Acquire lock on token with event-driven waiting
+
+        Args:
+            timeout: Timeout in seconds (0 = wait indefinitely)
+
+        Returns:
+            Lock object
+
+        Raises:
+            LockError: If lock cannot be acquired within timeout
+        """
+        from experimaestro.utils.asyncio import asyncThreadcheck
+        import time
+
+        start_time = time.time()
+
+        while True:
+            try:
+                lock = CounterTokenLock(self)
+                lock.acquire()
+                return lock
+            except LockError:
+                # Wait for token availability notification
+                def wait_for_available():
+                    with self.token.available_condition:
+                        # Calculate remaining timeout
+                        if timeout == 0:
+                            wait_timeout = None  # Wait indefinitely
+                        else:
+                            elapsed = time.time() - start_time
+                            if elapsed >= timeout:
+                                return False  # Timeout exceeded
+                            wait_timeout = timeout - elapsed
+
+                        # Wait for notification
+                        return self.token.available_condition.wait(timeout=wait_timeout)
+
+                # Wait in a thread (since condition is threading-based)
+                result = await asyncThreadcheck(
+                    "token availability", wait_for_available
+                )
+
+                # If wait returned False, we timed out
+                if result is False:
+                    raise LockError("Timeout waiting for tokens")
 
-    def lock(self) -> "Lock":
-        return CounterTokenLock(self)
+                # Otherwise, loop back to try acquiring again
 
     @property
     def token(self):
@@ -85,17 +118,38 @@ class CounterTokenDependency(Dependency):
 
 
 class TokenFile:
-    """Represents a token file"""
+    """Represents a token file
+
+    The token file (whose name refers to the corresponding job) is composed of
+    two lines:
+
+    1. The number of tokens taken by the job
+    2. The URI reference of the job directory
+    """
 
     def __init__(self, path: Path):
-        try:
-            self.path = path
-            with path.open("rt") as fp:
-                count, self.uri = [line.strip() for line in fp.readlines()]
-                self.count = int(count)
-        except Exception:
-            logging.exception("Error while reading %s", self.path)
-            raise
+        # Case where the file was deleted
+        self.count = 0
+        self.uri = None
+
+        retries = 0
+        while retries < 5:
+            retries += 1
+            try:
+                self.path = path
+                with path.open("rt") as fp:
+                    count, self.uri = [line.strip() for line in fp.readlines()]
+                    self.count = int(count)
+            except FileNotFoundError:
+                # Case where the file was deleted
+                self.count = 0
+                self.uri = None
+            except Exception:
+                logging.exception("Error while reading %s", self.path)
+                time.sleep(0.1)
+                continue
+
+            break
 
     @staticmethod
     def create(dependency: CounterTokenDependency):
@@ -119,6 +173,11 @@ class TokenFile:
 
     def watch(self):
         """Watch the matching process"""
+
+        # No need to watch if there was no token file...
+        if self.uri is None:
+            return
+
         logger.debug(
             "Watching process for %s (%s, taken %d)", self.path, self.uri, self.count
         )
@@ -130,9 +189,11 @@ class TokenFile:
         def run():
             logger.debug("Locking job lock path %s", lockpath)
             process = None
+            # Acquire the job lock - blocks if scheduler is still starting the job
+            # Once we get the lock, the job has either started or finished
             with fasteners.InterProcessLock(lockpath):
                 if not pidpath.is_file():
-                    logger.debug("Job already finished (no PID file)")
+                    logger.debug("Job already finished (no PID file %s)", pidpath)
                 else:
                     s = ""
                     while s == "":
@@ -157,6 +218,29 @@ class TokenFile:
         threading.Thread(target=run).start()
 
 
+class CounterTokenProxy(FileSystemEventHandler):
+    """Hold a weak reference to the counter token to handle gracefully deleted
+    counter tokens"""
+
+    def __init__(self, token: "CounterToken"):
+        self._token_ref = weakref.ref(token)
+
+    def on_modified(self, event):
+        token = self._token_ref()
+        if token is not None:
+            return token.on_modified(event)
+
+    def on_deleted(self, event):
+        token = self._token_ref()
+        if token is not None:
+            return token.on_deleted(event)
+
+    def on_created(self, event):
+        token = self._token_ref()
+        if token is not None:
+            return token.on_created(event)
+
+
 class CounterToken(Token, FileSystemEventHandler):
     """File-based counter token
 
@@ -213,6 +297,9 @@ class CounterToken(Token, FileSystemEventHandler):
         self.ipc_lock = fasteners.InterProcessLock(path / "token.lock")
         self.lock = threading.Lock()
 
+        # Condition variable for waiting on token availability
+        self.available_condition = threading.Condition(self.lock)
+
         self.name = name
 
         # Set the new number of tokens
@@ -227,8 +314,16 @@ class CounterToken(Token, FileSystemEventHandler):
 
         # Watched path
         self.watchedpath = str(path.absolute())
-        self.watcher = ipcom().fswatch(self, self.path, recursive=True)
-        logger.info("Watching %s", self.watchedpath)
+        self.proxy = CounterTokenProxy(self)
+        self.watcher = ipcom().fswatch(self.proxy, self.path, recursive=True)
+        logger.debug("Watching %s", self.watchedpath)
+
+    def __del__(self):
+        # Remove the watcher
+        if self.watcher is not None:
+            logging.debug("Removing watcher on %s", self.watchedpath)
+            ipcom().fsunwatch(self.watcher)
+            self.watcher = None
 
     def _update(self):
         """Update the state by reading all the information from disk
@@ -281,9 +376,8 @@ class CounterToken(Token, FileSystemEventHandler):
                         self.available,
                     )
 
-            # Do not lock here (notify only)
-            if self.available > 0:
-                self.aio_notify()
+                    # Notify waiting tasks that tokens are available
+                    self.available_condition.notify_all()
 
     def on_created(self, event):
         logger.debug(
@@ -311,7 +405,7 @@ class CounterToken(Token, FileSystemEventHandler):
     def on_modified(self, event):
         try:
             logger.debug(
-                "Watched path notification %s [watched %s]",
+                "on modified path: %s [watched %s]",
                 event.src_path,
                 self.watchedpath,
             )
@@ -321,26 +415,29 @@ class CounterToken(Token, FileSystemEventHandler):
 
             if event.src_path == str(self.infopath):
                 logger.debug("Token information modified")
-                timestamp = os.path.getmtime(self.infopath)
-                if timestamp <= self.timestamp:
+                with self.lock:
+                    timestamp = os.path.getmtime(self.infopath)
+                    if timestamp <= self.timestamp:
+                        logger.debug(
+                            "Not reading token file [%f <= %f]",
+                            timestamp,
+                            self.timestamp,
+                        )
+                        return
+
+                    total = int(self.infopath.read_text())
+                    delta = total - self.total
+                    self.total = total
+                    self.available += delta
                     logger.debug(
-                        "Not reading token file [%f <= %f]", timestamp, self.timestamp
+                        "Token information modified: available %d, total %d",
+                        self.available,
+                        self.total,
                     )
 
-                total = int(self.infopath.read_text())
-                delta = total - self.total
-                self.total = total
-                self.available += delta
-                logger.debug(
-                    "Token information modified: available %d, total %d",
-                    self.available,
-                    self.total,
-                )
-
-                if delta > 0 and self.available > 0:
-                    with self.dependents as dependents:
-                        for dependency in dependents:
-                            dependency.check()
+                    # Notify waiting tasks if tokens became available
+                    if delta > 0:
+                        self.available_condition.notify_all()
 
             # A modified dependency not in cache
             elif path.name.endswith(".token") and path.name not in self.cache:
@@ -371,7 +468,7 @@ class CounterToken(Token, FileSystemEventHandler):
         with self.lock, self.ipc_lock:
             self._update()
             if self.available < dependency.count:
-                logger.warning(
+                logger.debug(
                     "Not enough available (%d available, %d requested)",
                     self.available,
                     dependency.count,
@@ -406,9 +503,11 @@ class CounterToken(Token, FileSystemEventHandler):
             del self.cache[dependency.name]
             self.available += tf.count
             logging.debug("%s: available %d", self, self.available)
-            tf.delete()
 
-        self.aio_notify()
+            # Notify waiting tasks that tokens are available
+            self.available_condition.notify_all()
+
+            tf.delete()
 
 
 class ProcessCounterToken(Token):
@@ -456,8 +555,6 @@ class ProcessCounterToken(Token):
                 self.available,
             )
 
-        self.aio_notify()
-
 
 if sys.platform != "win32":
     os.register_at_fork(after_in_child=CounterToken.forkhandler)

experimaestro/tools/diff.py

@@ -3,7 +3,7 @@ from itertools import chain
 from typing import Dict, Any
 from pathlib import Path
 import json
-from src.experimaestro.core.objects.config_utils import getqualattr
+from experimaestro.core.objects.config_utils import getqualattr
 from termcolor import colored
 
 

experimaestro/tui/__init__.py

@@ -0,0 +1,8 @@
+"""Textual-based TUI for monitoring experiments"""
+
+from .app import ExperimaestroUI
+
+# Backward compatibility alias
+ExperimentTUI = ExperimaestroUI
+
+__all__ = ["ExperimaestroUI", "ExperimentTUI"]