experimaestro 1.12.0__tar.gz → 1.14.0__tar.gz

{experimaestro-1.12.0 → experimaestro-1.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: experimaestro
-Version: 1.12.0
+Version: 1.14.0
 Summary: "Experimaestro is a computer science experiment manager"
 License: GPL-3
 License-File: LICENSE

{experimaestro-1.12.0 → experimaestro-1.14.0}/pyproject.toml

@@ -48,7 +48,7 @@ dependencies = [
     "typing-extensions >=4.2; python_version < \"3.12\"",
     "watchdog >=2"
 ]
-version = "1.12.0"
+version = "1.14.0"
 
 [tool.poetry-dynamic-versioning]
 enable = false
@@ -140,7 +140,7 @@ warn_unused_ignores = true
 
 [tool.commitizen]
 name = "cz_conventional_commits"
-version = "1.12.0"
+version = "1.14.0"
 changelog_start_rev = "v1.0.0"
 tag_format = "v$major.$minor.$patch$prerelease"
 # update_changelog_on_bump = true

{experimaestro-1.12.0 → experimaestro-1.14.0}/src/experimaestro/core/arguments.py

@@ -80,10 +80,12 @@ class Argument:
 
         self.generator = generator
         self.default = None
+        self.ignore_generated = False
 
         if default is not None:
             assert self.generator is None, "generator and default are exclusive options"
             if isinstance(default, field):
+                self.ignore_generated = default.ignore_generated
                 if default.default is not None:
                     self.default = default.default
                 elif default.default_factory is not None:
@@ -184,13 +186,20 @@ DataPath = Annotated[Path, dataHint]
 class field:
     """Extra information for a given experimaestro field (param or meta)"""
 
-    def __init__(self, *, default: Any = None, default_factory: Callable = None):
+    def __init__(
+        self,
+        *,
+        default: Any = None,
+        default_factory: Callable = None,
+        ignore_generated=False,
+    ):
         assert not (
             (default is not None) and (default_factory is not None)
         ), "default and default_factory are mutually exclusive options"
 
         self.default_factory = default_factory
         self.default = default
+        self.ignore_generated = ignore_generated
 
 
 class help(TypeAnnotation):

{experimaestro-1.12.0 → experimaestro-1.14.0}/src/experimaestro/core/objects/config.py

@@ -122,11 +122,11 @@ class ConfigInformation:
     def __init__(self, pyobject: "ConfigMixin"):
         # The underlying pyobject and XPM type
         self.pyobject = pyobject
-        self.xpmtype = pyobject.__xpmtype__  # type: ObjectType
+        self.xpmtype: "ObjectType" = pyobject.__xpmtype__
         self.values = {}
 
         # Meta-informations
-        self._tags = {}
+        self._tags: dict[str, Any] = {}
         self._initinfo = ""
 
         self._taskoutput = None
@@ -142,7 +142,7 @@ class ConfigInformation:
         #: True when this configuration was loaded from disk
         self.loaded = False
 
-        # Explicitely added dependencies
+        # Explicitly added dependencies
         self.dependencies = []
 
         # Concrete type variables resolutions
@@ -170,6 +170,34 @@ class ConfigInformation:
         self._sealed = False
         self._meta = None
 
+        # This contains the list of generated values (using context) in this
+        # configuration or any sub-configuration, is generated. This prevents
+        # problem when a configuration with generated values is re-used.
+        self._generated_values = []
+
+    def get_generated_paths(
+        self, path: list[str] = None, paths: list[str] = None
+    ) -> list[str]:
+        """Get the list of generated paths, useful to track down those
+
+        :param path: The current path
+        :param paths: The list of generated paths so far, defaults to None
+        :return: The full list of generated paths
+        """
+        paths = [] if paths is None else paths
+        path = [] if path is None else path
+
+        for key in self._generated_values:
+            value = self.values[key]
+            if isinstance(value, ConfigMixin) and value.__xpm__._generated_values:
+                path.append(key)
+                value.__xpm__.get_generated_paths(path, paths)
+                path.pop()
+            else:
+                paths.append(".".join(path + [key]))
+
+        return paths
+
     def set_meta(self, value: Optional[bool]):
         """Sets the meta flag"""
         assert not self._sealed, "Configuration is sealed"
@@ -187,6 +215,31 @@ class ConfigInformation:
         # Not an argument, bypass
         return object.__getattribute__(self.pyobject, name)
 
+    @staticmethod
+    def is_generated_value(argument, value):
+        if argument.ignore_generated:
+            return False
+
+        if value is None:
+            return False
+
+        if isinstance(value, (int, str, float, bool, Path)):
+            return False
+
+        if isinstance(value, ConfigMixin):
+            return value.__xpm__._generated_values and value.__xpm__.task is None
+
+        if isinstance(value, list):
+            return any(ConfigInformation.is_generated_value(argument, x) for x in value)
+
+        if isinstance(value, dict):
+            return any(
+                ConfigInformation.is_generated_value(argument, x)
+                for x in value.values()
+            )
+
+        return False
+
     def set(self, k, v, bypass=False):
         from experimaestro.generators import Generator
 
@@ -198,9 +251,21 @@ class ConfigInformation:
         if self._sealed and not bypass:
             raise AttributeError(f"Object is read-only (trying to set {k})")
 
+        if not isinstance(v, ConfigMixin) and isinstance(v, Config):
+            raise AttributeError(
+                "Configuration (and not objects) should be used. Consider using .C(...)"
+            )
+
         try:
             argument = self.xpmtype.arguments.get(k, None)
             if argument:
+                if ConfigInformation.is_generated_value(argument, v):
+                    raise AttributeError(
+                        f"Cannot set {k} to a configuration with generated values. "
+                        "Here is the list of paths to help you: "
+                        f"""{', '.join(v.__xpm__.get_generated_paths([k]))}"""
+                    )
+
                 if not bypass and (
                     (isinstance(argument.generator, Generator)) or argument.constant
                 ):
@@ -326,12 +391,21 @@ class ConfigInformation:
         Arguments:
             - context: the generation context
         """
+        if generated_keys := [
+            k
+            for k, v in self.values.items()
+            if ConfigInformation.is_generated_value(self.xpmtype.arguments[k], v)
+        ]:
+            raise AttributeError(
+                "Cannot seal a configuration with generated values:"
+                f"""{",".join(generated_keys)} in {context.currentpath}"""
+            )
 
         class Sealer(ConfigWalk):
-            def preprocess(self, config: Config):
+            def preprocess(self, config: ConfigMixin):
                 return not config.__xpm__._sealed, config
 
-            def postprocess(self, stub, config: Config, values):
+            def postprocess(self, stub, config: ConfigMixin, values):
                 # Generate values
                 from experimaestro.generators import Generator
 
@@ -344,22 +418,36 @@ class ConfigInformation:
                                     continue
                                 value = argument.generator()
                             else:
+                                # Generate a value
                                 sig = inspect.signature(argument.generator)
                                 if len(sig.parameters) == 0:
                                     value = argument.generator()
                                 elif len(sig.parameters) == 2:
+                                    # Only in that case do we need to flag this configuration
+                                    # as containing generated values
+                                    config.__xpm__._generated_values.append(k)
                                     value = argument.generator(self.context, config)
                                 else:
                                     assert (
                                         False
                                     ), "generator has either two parameters (context and config), or none"
                             config.__xpm__.set(k, value, bypass=True)
+                        else:
+                            value = config.__xpm__.values.get(k)
                     except Exception:
                         logger.error(
                             "While setting %s of %s", argument.name, config.__xpmtype__
                         )
                         raise
 
+                    # Propagate the generated value flag
+                    if (
+                        (value is not None)
+                        and isinstance(value, ConfigMixin)
+                        and value.__xpm__._generated_values
+                    ):
+                        config.__xpm__._generated_values.append(k)
+
                 config.__xpm__._sealed = True
 
         Sealer(context, recurse_task=True)(self.pyobject)
@@ -657,13 +745,6 @@ class ConfigInformation:
 
                 print(file=sys.stderr)  # noqa: T201
 
-        # Handle an output configuration # FIXME: remove
-        def mark_output(config: "Config"):
-            """Sets a dependency on the job"""
-            assert not isinstance(config, Task), "Cannot set a dependency on a task"
-            config.__xpm__.task = self.pyobject
-            return config
-
         # Mark this configuration also
         self.task = self.pyobject
 
@@ -1242,6 +1323,9 @@ def clone(v):
     if isinstance(v, Enum):
         return v
 
+    if isinstance(v, tuple):
+        return tuple(clone(x) for x in v)
+
     if isinstance(v, Config):
         # Create a new instance
         kwargs = {
@@ -1260,6 +1344,11 @@ class ConfigMixin:
     """Class for configuration objects"""
 
     __xpmtype__: ObjectType
+    """The associated XPM type"""
+
+    __xpm__: ConfigInformation
+    """The __xpm__ object contains all instance specific information about a
+    configuration/task"""
 
     def __init__(self, **kwargs):
         """Initialize the configuration with the given parameters"""
@@ -1441,10 +1530,6 @@ class Config:
     """The object type holds all the information about a specific subclass
     experimaestro metadata"""
 
-    __xpm__: ConfigInformation
-    """The __xpm__ object contains all instance specific information about a
-    configuration/task"""
-
     @classproperty
     def XPMConfig(cls):
         if issubclass(cls, ConfigMixin):

{experimaestro-1.12.0 → experimaestro-1.14.0}/src/experimaestro/core/objects/config_walk.py

@@ -71,6 +71,7 @@ class ConfigWalk:
         return self.context.push(str(i))
 
     def map(self, k: str):
+        """Provides a path context when processing a tree"""
         return self.context.push(k)
 
     def stub(self, config):
@@ -123,7 +124,8 @@ class ConfigWalk:
                 and self.recurse_task
                 and x.__xpm__.task is not x
             ):
-                self(x.__xpm__.task)
+                with self.map("__task__"):
+                    self(x.__xpm__.task)
 
             processed = self.postprocess(stub, x, result)
             self.visited[xid] = processed

experimaestro-1.14.0/src/experimaestro/tests/test_generators.py

@@ -0,0 +1,93 @@
+from experimaestro import Config, Task, Param, Meta, Path, field, PathGenerator
+from experimaestro.scheduler.workspace import Workspace
+from experimaestro.settings import Settings, WorkspaceSettings
+import pytest
+from experimaestro.scheduler import RunMode
+
+
+class Validation(Config):
+    best_checkpoint: Meta[Path] = field(default_factory=PathGenerator("index"))
+
+
+class Learner(Task):
+    validation: Param[Validation]
+    x: Param[int]
+
+    @staticmethod
+    def create(x: int, validation: Param[Validation]):
+        return Learner.C(x=x, validation=validation)
+
+
+class LearnerList(Task):
+    validation: Param[list[Validation]]
+    x: Param[int]
+
+    @staticmethod
+    def create(x: int, validation: Param[Validation]):
+        return LearnerList.C(x=x, validation=[validation])
+
+
+class LearnerDict(Task):
+    validation: Param[dict[str, Validation]]
+    x: Param[int]
+
+    @staticmethod
+    def create(x: int, validation: Param[Validation]):
+        return LearnerDict.C(x=x, validation={"key": validation})
+
+
+class ModuleLoader(Task):
+    validation: Param[Validation] = field(ignore_generated=True)
+
+
+@pytest.mark.parametrize("cls", [Learner, LearnerDict, LearnerList])
+def test_generators_reuse_on_submit(cls):
+    # We have one way to select the best model
+    validation = Validation.C()
+
+    workspace = Workspace(
+        Settings(),
+        WorkspaceSettings("test_generators_reuse", path=Path("/tmp")),
+        run_mode=RunMode.DRY_RUN,
+    )
+
+    # OK, the path is generated depending on Learner with x=1
+    cls.create(1, validation).submit(workspace=workspace)
+
+    with pytest.raises((AttributeError)):
+        # Here we have a problem...
+        # the path is still the previous one
+        cls.create(2, validation).submit(workspace=workspace)
+
+
+@pytest.mark.parametrize("cls", [Learner, LearnerDict, LearnerList])
+def test_generators_delayed_submit(cls):
+    workspace = Workspace(
+        Settings(),
+        WorkspaceSettings("test_generators_simple", path=Path("/tmp")),
+        run_mode=RunMode.DRY_RUN,
+    )
+    validation = Validation.C()
+    task1 = cls.create(1, validation)
+    task2 = cls.create(2, validation)
+    task1.submit(workspace=workspace)
+    with pytest.raises((AttributeError)):
+        task2.submit(workspace=workspace)
+
+
+@pytest.mark.parametrize("cls", [Learner, LearnerDict, LearnerList])
+def test_generators_reuse_on_set(cls):
+    workspace = Workspace(
+        Settings(),
+        WorkspaceSettings("test_generators_simple", path=Path("/tmp")),
+        run_mode=RunMode.DRY_RUN,
+    )
+    validation = Validation.C()
+    cls.create(1, validation).submit(workspace=workspace)
+    with pytest.raises((AttributeError)):
+        # We should not be able to *create* a second task with the same validation,
+        # even without submitting it
+        cls.create(2, validation)
+
+    # This should run OK
+    ModuleLoader.C(validation=validation)