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

experimaestro/scheduler/dependencies.py

@@ -1,22 +1,36 @@
 """Dependency between tasks and tokens"""
 
 import threading
-from typing import Set
+from typing import TYPE_CHECKING, Callable, Optional
 from abc import ABC, abstractmethod
 from enum import Enum
+
 from ..locking import Lock
 
+if TYPE_CHECKING:
+    from experimaestro.scheduler.jobs import Job
+
 
 class Dependents:
     """Encapsulate the access to the dependents"""
 
     def __init__(self):
         self.lock = threading.Lock()
-        self._dependents: Set[Dependency] = set()  # as source
+        self._dependents: set[Dependency] = set()  # as source
+        self._on_add_callback: Optional[Callable[[], None]] = None
+
+    def set_on_add_callback(self, callback: Optional[Callable[[], None]]):
+        """Set a callback to be called when a dependent is added"""
+        with self.lock:
+            self._on_add_callback = callback
 
     def add(self, dependency):
         with self.lock:
             self._dependents.add(dependency)
+            callback = self._on_add_callback
+        # Call callback outside the lock to avoid deadlocks
+        if callback is not None:
+            callback()
 
     def __enter__(self):
         # Returns the set after locking
@@ -40,10 +54,13 @@ class DependencyStatus(Enum):
     """Dependency can be locked"""
 
     FAIL = 2
-    """Dependency won't be availabe in the foreseeable future"""
+    """Dependency won't be available in the foreseeable future"""
 
 
 class Dependency(ABC):
+    origin: "Resource"
+    target: Optional["Job"]
+
     """Base class for dependencies
 
     Static dependencies (like jobs) have a fixed state once resolved - they cannot
@@ -78,16 +95,3 @@ class Dependency(ABC):
 
     def __repr__(self) -> str:
         return f"Dep[{self.origin}]"
-
-
-class DynamicDependency(Dependency):
-    """Base class for dynamic dependencies
-
-    Dynamic dependencies (like tokens) can change state at any time - availability
-    can go from OK to WAIT and back. These require special handling during lock
-    acquisition with retry logic.
-    """
-
-    def is_dynamic(self) -> bool:
-        """Returns True - this is a dynamic dependency"""
-        return True