experimaestro 1.13.0__py3-none-any.whl → 1.15.0__py3-none-any.whl

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/core/identifier.py

@@ -6,7 +6,7 @@ import logging
 import os
 import struct
 from typing import Optional
-from experimaestro.core.objects import Config
+from experimaestro.core.objects import Config, ConfigMixin
 
 
 class ConfigPath:
@@ -116,7 +116,7 @@ class IdentifierComputer:
     CYCLE_REFERENCE = b"\x0b"
     INIT_TASKS = b"\x0c"
 
-    def __init__(self, config: "Config", config_path: ConfigPath, *, version=None):
+    def __init__(self, config: "ConfigMixin", config_path: ConfigPath, *, version=None):
         # Hasher for parameters
         self._hasher = hashlib.sha256()
         self.config = config
@@ -170,7 +170,7 @@ class IdentifierComputer:
             self._hashupdate(IdentifierComputer.ENUM_ID)
             k = value.__class__
             self._hashupdate(
-                f"{k.__module__}.{k.__qualname__ }:{value.name}".encode("utf-8"),
+                f"{k.__module__}.{k.__qualname__}:{value.name}".encode("utf-8"),
             )
         elif isinstance(value, dict):
             self._hashupdate(IdentifierComputer.DICT_ID)
@@ -183,7 +183,7 @@ class IdentifierComputer:
                 self.update(value)
 
         # Handles configurations
-        elif isinstance(value, Config):
+        elif isinstance(value, ConfigMixin):
             # Encodes the identifier
             self._hashupdate(IdentifierComputer.OBJECT_ID)
 
@@ -264,12 +264,17 @@ class IdentifierComputer:
                 self._hashupdate(IdentifierComputer.NAME_ID)
                 self.update(argvalue)
 
+            # Add init tasks
+            if value.__xpm__.init_tasks:
+                self._hashupdate(IdentifierComputer.INIT_TASKS)
+                for init_task in value.__xpm__.init_tasks:
+                    self.update(init_task)
         else:
             raise NotImplementedError("Cannot compute hash of type %s" % type(value))
 
     @staticmethod
     def compute(
-        config: "Config", config_path: ConfigPath | None = None, version=None
+        config: "ConfigMixin", config_path: ConfigPath | None = None, version=None
     ) -> Identifier:
         """Compute the identifier for a configuration
 
@@ -281,7 +286,7 @@ class IdentifierComputer:
         # Try to use the cached value first
         # (if there are no loops)
         if config.__xpm__._sealed:
-            identifier = config.__xpm__._raw_identifier
+            identifier = config.__xpm__._identifier
             if identifier is not None and not identifier.has_loops:
                 return identifier
 

experimaestro/core/objects/config.py

@@ -9,7 +9,6 @@ from experimaestro import taskglobals
 
 from termcolor import cprint
 from pathlib import Path
-import hashlib
 import logging
 import io
 from enum import Enum
@@ -20,7 +19,6 @@ from typing import (
     Callable,
     ClassVar,
     Dict,
-    Iterator,
     List,
     Optional,
     Set,
@@ -49,7 +47,6 @@ from .config_walk import ConfigWalk, ConfigWalkContext
 from .config_utils import (
     getqualattr,
     add_to_path,
-    SealedError,
     TaggedValue,
     ObjectStore,
     classproperty,
@@ -149,9 +146,6 @@ class ConfigInformation:
         # This is used to check typevars coherence
         self.concrete_typevars: Dict[TypeVar, type] = {}
 
-        # Lightweight tasks
-        self.pre_tasks: List["LightweightTask"] = []
-
         # Initialization tasks
         self.init_tasks: List["LightweightTask"] = []
 
@@ -160,20 +154,40 @@ class ConfigInformation:
 
         # Cached information
 
-        self._full_identifier = None
-        """The full identifier (with pre-tasks)"""
-
-        self._raw_identifier = None
-        """The identifier without taking into account pre-tasks"""
+        self._identifier = None
+        """The configuration identifier (cached when sealed)"""
 
         self._validated = False
         self._sealed = False
         self._meta = None
 
-        #: This flags is True when a value in this configuration,
-        #: or any sub-configuration, is generated. This prevents problem
-        #: when a configuration with generated values is re-used
-        self._has_generated_value = False
+        # 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"""
@@ -192,6 +206,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
 
@@ -208,18 +247,16 @@ class ConfigInformation:
                 "Configuration (and not objects) should be used. Consider using .C(...)"
             )
 
-        if (
-            isinstance(v, ConfigMixin)
-            and v.__xpm__._has_generated_value
-            and v.__xpm__.task is None
-        ):
-            raise AttributeError(
-                f"Cannot set {k} to a configuration with generated values"
-            )
-
         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
                 ):
@@ -321,10 +358,6 @@ class ConfigInformation:
                             % (k, self.xpmtype, self._initinfo)
                         )
 
-            # Validate pre-tasks
-            for pre_task in self.pre_tasks:
-                pre_task.__xpm__.validate()
-
             # Validate init tasks
             for init_task in self.init_tasks:
                 init_task.__xpm__.validate()
@@ -345,6 +378,15 @@ 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: ConfigMixin):
@@ -368,13 +410,15 @@ class ConfigInformation:
                                 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)
-                            config.__xpm__._has_generated_value = True
                         else:
                             value = config.__xpm__.values.get(k)
                     except Exception:
@@ -387,9 +431,9 @@ class ConfigInformation:
                     if (
                         (value is not None)
                         and isinstance(value, ConfigMixin)
-                        and value.__xpm__._has_generated_value
+                        and value.__xpm__._generated_values
                     ):
-                        self._has_generated_value = True
+                        config.__xpm__._generated_values.append(k)
 
                 config.__xpm__._sealed = True
 
@@ -403,90 +447,29 @@ class ConfigInformation:
         context = ConfigWalkContext()
 
         class Unsealer(ConfigWalk):
-            def preprocess(self, config: Config):
+            def preprocess(self, config: ConfigMixin):
                 return config.__xpm__._sealed, config
 
-            def postprocess(self, stub, config: Config, values):
+            def postprocess(self, stub, config: ConfigMixin, values):
                 config.__xpm__._sealed = False
                 config.__xpm__._identifier = None
 
         Unsealer(context, recurse_task=True)(self.pyobject)
 
-    def collect_pre_tasks(self) -> Iterator["Config"]:
-        context = ConfigWalkContext()
-        pre_tasks: Dict[int, "Config"] = {}
-
-        class PreTaskCollect(ConfigWalk):
-            def preprocess(self, config: Config):
-                # Do not cross tasks
-                return not isinstance(config.__xpm__, Task), config
-
-            def postprocess(self, stub, config: Config, values):
-                pre_tasks.update(
-                    {id(pre_task): pre_task for pre_task in config.__xpm__.pre_tasks}
-                )
-
-        PreTaskCollect(context, recurse_task=True)(self.pyobject)
-        return pre_tasks.values()
-
-    def identifiers(self, only_raw: bool):
+    @property
+    def identifier(self):
         """Computes the unique identifier"""
-        from ..identifier import IdentifierComputer, Identifier
-
-        raw_identifier = self._raw_identifier
-        full_identifier = self._full_identifier
+        from ..identifier import IdentifierComputer
 
         # Computes raw identifier if needed
-        if raw_identifier is None or not self._sealed:
-            # Get the main identifier
-            raw_identifier = IdentifierComputer.compute(self.pyobject)
-            if self._sealed:
-                self._raw_identifier = raw_identifier
-
-        if only_raw:
-            return raw_identifier, full_identifier
-
-        # OK, let's compute the full identifier
-        if full_identifier is None or not self._sealed:
-            # Compute the full identifier by including the pre-tasks
-            hasher = hashlib.sha256()
-            hasher.update(raw_identifier.all)
-            pre_tasks_ids = [
-                pre_task.__xpm__.raw_identifier.all
-                for pre_task in self.collect_pre_tasks()
-            ]
-            for task_id in sorted(pre_tasks_ids):
-                hasher.update(task_id)
-
-            # Adds init tasks
-            if self.init_tasks:
-                hasher.update(IdentifierComputer.INIT_TASKS)
-                for init_task in self.init_tasks:
-                    hasher.update(init_task.__xpm__.raw_identifier.all)
-
-            full_identifier = Identifier(hasher.digest())
-            full_identifier.has_loops = raw_identifier.has_loops
-
-            # Only cache the identifier if sealed
-            if self._sealed:
-                self._full_identifier = full_identifier
+        if self._identifier is not None:
+            return self._identifier
 
-        return raw_identifier, full_identifier
-
-    @property
-    def raw_identifier(self) -> "Identifier":
-        """Computes the unique identifier (without task modifiers)"""
-        raw_identifier, _ = self.identifiers(True)
-        return raw_identifier
-
-    @property
-    def full_identifier(self) -> "Identifier":
-        """Computes the unique identifier (with task modifiers)"""
-        _, full_identifier = self.identifiers(False)
-        return full_identifier
-
-    identifier = full_identifier
-    """Deprecated: use full_identifier"""
+        # Get the main identifier
+        identifier = IdentifierComputer.compute(self.pyobject)
+        if self._sealed:
+            self._identifier = identifier
+        return identifier
 
     def dependency(self):
         """Returns a dependency"""
@@ -501,12 +484,6 @@ class ConfigInformation:
         path: List[str],
         taskids: Set[int],
     ):
-        # Add pre-tasks
-        for pre_task in self.pre_tasks:
-            pre_task.__xpm__.updatedependencies(
-                dependencies, path + ["__pre_tasks__"], taskids
-            )
-
         # Add initialization tasks
         for init_task in self.init_tasks:
             init_task.__xpm__.updatedependencies(
@@ -776,9 +753,6 @@ class ConfigInformation:
         if self.task is not None and self.task is not self:
             ConfigInformation.__collect_objects__(self.task, objects, context)
 
-        # Serialize pre-tasks
-        ConfigInformation.__collect_objects__(self.pre_tasks, objects, context)
-
         # Serialize initialization tasks
         ConfigInformation.__collect_objects__(self.init_tasks, objects, context)
 
@@ -792,8 +766,6 @@ class ConfigInformation:
         }
 
         # Add pre/init tasks
-        if self.pre_tasks:
-            state_dict["pre-tasks"] = [id(pre_task) for pre_task in self.pre_tasks]
         if self.init_tasks:
             state_dict["init-tasks"] = [id(init_task) for init_task in self.init_tasks]
 
@@ -1125,12 +1097,6 @@ class ConfigInformation:
                 o.__post_init__()
 
             else:
-                # Sets pre-tasks
-                o.__xpm__.pre_tasks = [
-                    objects[pre_task_id]
-                    for pre_task_id in definition.get("pre-tasks", [])
-                ]
-
                 if task_id := definition.get("task", None):
                     o.__xpm__.task = objects[task_id]
 
@@ -1164,15 +1130,6 @@ class ConfigInformation:
 
         # Run pre-task (or returns them)
         if as_instance or return_tasks:
-            # Collect pre-tasks (just once)
-            completed_pretasks = set()
-            pre_tasks = []
-            for definition in definitions:
-                for pre_task_id in definition.get("pre-tasks", []):
-                    if pre_task_id not in completed_pretasks:
-                        completed_pretasks.add(pre_task_id)
-                        pre_tasks.append(objects[pre_task_id])
-
             # Collect init tasks
             init_tasks = []
             for init_task_id in definitions[-1].get("init-tasks", []):
@@ -1180,14 +1137,11 @@ class ConfigInformation:
                 init_tasks.append(init_task)
 
             if as_instance:
-                for pre_task in pre_tasks:
-                    logger.info("Executing pre-task %s", type(pre_task))
-                    pre_task.execute()
                 for init_task in init_tasks:
                     logger.info("Executing init task %s", type(init_task))
                     init_task.execute()
             else:
-                return o, pre_tasks, pre_task + init_tasks
+                return o, init_tasks
 
         return o
 
@@ -1195,7 +1149,6 @@ class ConfigInformation:
         def __init__(self, context: ConfigWalkContext, *, objects: ObjectStore = None):
             super().__init__(context)
             self.objects = ObjectStore() if objects is None else objects
-            self.pre_tasks = {}
 
         def preprocess(self, config: "Config"):
             if self.objects.is_constructed(id(config)):
@@ -1222,10 +1175,6 @@ class ConfigInformation:
             # Call __post_init__
             stub.__post_init__()
 
-            # Gather pre-tasks
-            for pre_task in config.__xpm__.pre_tasks:
-                self.pre_tasks[id(pre_task)] = self.stub(pre_task)
-
             self.objects.set_constructed(id(config))
             return stub
 
@@ -1239,10 +1188,6 @@ class ConfigInformation:
         processor = ConfigInformation.FromPython(context, objects=objects)
         last_object = processor(self.pyobject)
 
-        # Execute pre-tasks
-        for pre_task in processor.pre_tasks.values():
-            pre_task.execute()
-
         return last_object
 
     def add_dependencies(self, *dependencies):
@@ -1428,29 +1373,7 @@ class ConfigMixin:
         attributes)"""
         return clone(self)
 
-    def add_pretasks(self, *tasks: "LightweightTask"):
-        assert all(
-            [isinstance(task, LightweightTask) for task in tasks]
-        ), "One of the pre-tasks are not lightweight tasks"
-        if self.__xpm__._sealed:
-            raise SealedError("Cannot add pre-tasks to a sealed configuration")
-        self.__xpm__.pre_tasks.extend(tasks)
-        return self
-
-    def add_pretasks_from(self, *configs: "Config"):
-        assert all(
-            [isinstance(config, ConfigMixin) for config in configs]
-        ), "One of the parameters is not a configuration object"
-        for config in configs:
-            self.add_pretasks(*config.__xpm__.pre_tasks)
-        return self
-
-    @property
-    def pre_tasks(self) -> List["LightweightTask"]:
-        """Access pre-tasks"""
-        return self.__xpm__.pre_tasks
-
-    def copy_dependencies(self, other: "Config"):
+    def copy_dependencies(self, other: "ConfigMixin"):
         """Add all the dependencies from other configuration"""
 
         # Add task dependency
@@ -1587,27 +1510,12 @@ class Config:
     def __identifier__(self) -> "Identifier":
         return self.__xpm__.full_identifier
 
-    def add_pretasks(self, *tasks: "LightweightTask"):
-        """Add pre-tasks"""
-        raise AssertionError("This method can only be used during configuration")
-
-    def add_pretasks_from(self, *configs: "Config"):
-        """Add pre-tasks from the listed configurations"""
-        raise AssertionError(
-            "The 'add_pretasks_from' can only be used during configuration"
-        )
-
     def copy_dependencies(self, other: "Config"):
         """Add pre-tasks from the listed configurations"""
         raise AssertionError(
             "The 'copy_dependencies' method can only be used during configuration"
         )
 
-    @property
-    def pre_tasks(self) -> List["LightweightTask"]:
-        """Access pre-tasks"""
-        raise AssertionError("Pre-tasks can be accessed only during configuration")
-
     def register_task_output(self, method, *args, **kwargs):
         # Determine the path for this...
         path = taskglobals.Env.instance().xpm_path / "task-outputs.jsonl"

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):
@@ -108,11 +109,7 @@ class ConfigWalk:
                 else:
                     result[arg.name] = None
 
-            # Deals with pre-tasks
-            if info.pre_tasks:
-                with self.map("__pre_tasks__"):
-                    self(info.pre_tasks)
-
+            # Deals with init tasks
             if info.init_tasks:
                 with self.map("__init_tasks__"):
                     self(info.init_tasks)
@@ -123,7 +120,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/core/objects.pyi

@@ -168,7 +168,7 @@ class ConfigMixin:
         *,
         workspace: Incomplete | None = ...,
         launcher: Incomplete | None = ...,
-        run_mode: RunMode = ...
+        run_mode: RunMode = ...,
     ): ...
     def stdout(self): ...
     def stderr(self): ...
@@ -195,11 +195,7 @@ class Config:
     def __post_init__(self) -> None: ...
     def __json__(self): ...
     def __identifier__(self) -> Identifier: ...
-    def add_pretasks(self, *tasks: "LightweightTask"): ...
-    def add_pretasks_from(self, configs: "Config"): ...
     def copy_dependencies(self, other: "Config"): ...
-    @property
-    def pre_tasks(self) -> List["LightweightTask"]: ...
 
 class LightweightTask(Config):
     def execute(self) -> None: ...
@@ -213,7 +209,7 @@ class Task(LightweightTask):
         workspace: Incomplete | None = ...,
         launcher: Incomplete | None = ...,
         run_mode: RunMode = ...,
-        init_tasks: List["LightweightTask"] = []
+        init_tasks: List["LightweightTask"] = [],
     ): ...
     def task_outputs(self, dep: Callable[[Config], None]) -> Any: ...
 

experimaestro/core/serializers.py

@@ -1,10 +1,8 @@
-from typing import List, TypeVar, Callable, Any
-from pathlib import Path
+from typing import List, TypeVar
 from experimaestro import Param
 
 from .objects import Config, LightweightTask
 from .arguments import DataPath
-from experimaestro import copyconfig
 
 
 class SerializationLWTask(LightweightTask):
@@ -39,8 +37,3 @@ class PathSerializationLWTask(SerializationLWTask):
 
     path: DataPath
     """Path containing the data"""
-
-    @classmethod
-    def construct(cls, value: T, path: Path, dep: Callable[[Config], Any]) -> T:
-        value = copyconfig(value)
-        return value.add_pretasks(dep(cls(value=value, path=path)))

experimaestro/tests/test_dependencies.py

@@ -85,9 +85,3 @@ def test_dependencies_inner_task_output(xp):
     a = task_a.submit()
     b = Inner_TaskB(param_a=a).submit()
     check_dependencies(b, task_a)
-
-
-def test_dependencies_pre_task(xp):
-    a = TaskA().submit()
-    a2 = TaskA().add_pretasks(a).submit()
-    check_dependencies(a2, a)

experimaestro/tests/test_generators.py

@@ -13,8 +13,35 @@ class Learner(Task):
     validation: Param[Validation]
     x: Param[int]
 
+    @staticmethod
+    def create(x: int, validation: Param[Validation]):
+        return Learner.C(x=x, validation=validation)
 
-def test_generators_reuse():
+
+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()
 
@@ -25,9 +52,42 @@ def test_generators_reuse():
     )
 
     # OK, the path is generated depending on Learner with x=1
-    Learner.C(x=1, validation=validation).submit(workspace=workspace)
+    cls.create(1, validation).submit(workspace=workspace)
 
     with pytest.raises((AttributeError)):
         # Here we have a problem...
         # the path is still the previous one
-        Learner.C(x=2, validation=validation).submit(workspace=workspace)
+        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)

experimaestro/tests/test_identifier.py

@@ -68,42 +68,42 @@ def assert_notequal(a, b, message=""):
     assert getidentifier(a) != getidentifier(b), message
 
 
-def test_param_int():
-    assert_equal(A(a=1), A(a=1))
+def test_identifier_int():
+    assert_equal(A.C(a=1), A.C(a=1))
 
 
-def test_param_different_type():
-    assert_notequal(A(a=1), B(a=1))
+def test_identifier_different_type():
+    assert_notequal(A.C(a=1), B.C(a=1))
 
 
-def test_param_order():
-    assert_equal(Values(value1=1, value2=2), Values(value2=2, value1=1))
+def test_identifier_order():
+    assert_equal(Values.C(value1=1, value2=2), Values.C(value2=2, value1=1))
 
 
-def test_param_default():
-    assert_equal(C(a=1, b=2), C(b=2))
+def test_identifier_default():
+    assert_equal(C.C(a=1, b=2), C.C(b=2))
 
 
 def test_identifier_default_field():
     assert_equal(CField(a=1, b=2), CField(b=2))
 
 
-def test_param_inner_eq():
-    assert_equal(D(a=A(a=1)), D(a=A(a=1)))
+def test_identifier_inner_eq():
+    assert_equal(D.C(a=A.C(a=1)), D.C(a=A.C(a=1)))
 
 
-def test_param_float():
-    assert_equal(Float(value=1), Float(value=1))
+def test_identifier_float():
+    assert_equal(Float.C(value=1), Float.C(value=1))
 
 
-def test_param_float2():
-    assert_equal(Float(value=1.0), Float(value=1))
+def test_identifier_float2():
+    assert_equal(Float.C(value=1.0), Float.C(value=1))
 
 
 # --- Argument name
 
 
-def test_param_name():
+def test_identifier_name():
     """The identifier fully determines the hash code"""
 
     class Config0(Config):
@@ -125,7 +125,7 @@ def test_param_name():
 # --- Test option
 
 
-def test_param_option():
+def test_identifier_option():
     class OptionConfig(Config):
         __xpmid__ = "test.identifier.option"
         a: Param[int]
@@ -139,7 +139,7 @@ def test_param_option():
 # --- Dictionnary
 
 
-def test_param_identifier_dict():
+def test_identifier_dict():
     """Test identifiers of dictionary structures"""
 
     class B(Config):
@@ -163,7 +163,7 @@ class TypeWithPath(Config):
     path: Param[Path]
 
 
-def test_param_identifier_path():
+def test_identifier_path():
     """Path should be ignored"""
     assert_equal(TypeWithPath(a=1, path="/a/b"), TypeWithPath(a=1, path="/c/d"))
     assert_notequal(TypeWithPath(a=2, path="/a/b"), TypeWithPath(a=1, path="/c/d"))
@@ -172,7 +172,7 @@ def test_param_identifier_path():
 # --- Test with added arguments
 
 
-def test_param_identifier_pathoption():
+def test_identifier_pathoption():
     """Path arguments should be ignored"""
 
     class A_with_path(Config):
@@ -187,7 +187,7 @@ def test_param_identifier_pathoption():
     assert_equal(A_with_path(a=1), A_without_path(a=1))
 
 
-def test_param_identifier_enum():
+def test_identifier_enum():
     """test enum parameters"""
     from enum import Enum
 
@@ -202,7 +202,7 @@ def test_param_identifier_enum():
     assert_equal(EnumConfig(a=EnumParam.FIRST), EnumConfig(a=EnumParam.FIRST))
 
 
-def test_param_identifier_addnone():
+def test_identifier_addnone():
     """Test the case of new parameter (with None default)"""
 
     class B(Config):
@@ -219,7 +219,7 @@ def test_param_identifier_addnone():
     assert_notequal(A_with_b(b=B(x=1)), A())
 
 
-def test_param_defaultnew():
+def test_identifier_defaultnew():
     """Path arguments should be ignored"""
 
     class A_with_b(Config):
@@ -236,7 +236,7 @@ def test_param_defaultnew():
     assert_equal(A_with_b(a=1), A(a=1))
 
 
-def test_param_taskconfigidentifier():
+def test_identifier_taskconfigidentifier():
     """Test whether the embedded task arguments make the configuration different"""
 
     class MyConfig(Config):
@@ -258,7 +258,7 @@ def test_param_taskconfigidentifier():
     )
 
 
-def test_param_constant():
+def test_identifier_constant():
     """Test if constants are taken into account for signature computation"""
 
     class A1(Config):
@@ -278,7 +278,7 @@ def test_param_constant():
     assert_notequal(A1(), A2())
 
 
-def test_param_identifier_deprecated_class():
+def test_identifier_deprecated_class():
     """Test that when submitting the task, the computed identifier is the one of
     the new class"""
 
@@ -300,7 +300,7 @@ def test_param_identifier_deprecated_class():
     )
 
 
-def test_param_identifier_deprecated_attribute():
+def test_identifier_deprecated_attribute():
     class Values(Config):
         values: Param[List[int]] = []
 
@@ -315,7 +315,7 @@ class MetaA(Config):
     x: Param[int]
 
 
-def test_param_identifier_meta():
+def test_identifier_meta():
     """Test forced meta-parameter"""
 
     class B(Config):
@@ -354,7 +354,7 @@ def test_param_identifier_meta():
     )
 
 
-def test_param_identifier_meta_default_dict():
+def test_identifier_meta_default_dict():
     class DictConfig(Config):
         params: Param[Dict[str, MetaA]] = {}
 
@@ -370,7 +370,7 @@ def test_param_identifier_meta_default_dict():
     )
 
 
-def test_param_identifier_meta_default_array():
+def test_identifier_meta_default_array():
     class ArrayConfigWithDefault(Config):
         array: Param[List[MetaA]] = []
 
@@ -386,37 +386,7 @@ def test_param_identifier_meta_default_array():
     )
 
 
-def test_param_identifier_pre_task():
-    class MyConfig(Config):
-        pass
-
-    class IdentifierPreLightTask(LightweightTask):
-        pass
-
-    class IdentifierPreTask(Task):
-        x: Param[MyConfig]
-
-    task = IdentifierPreTask(x=MyConfig()).submit(run_mode=RunMode.DRY_RUN)
-    task_with_pre = (
-        IdentifierPreTask(x=MyConfig())
-        .add_pretasks(IdentifierPreLightTask())
-        .submit(run_mode=RunMode.DRY_RUN)
-    )
-    task_with_pre_2 = (
-        IdentifierPreTask(x=MyConfig())
-        .add_pretasks(IdentifierPreLightTask())
-        .submit(run_mode=RunMode.DRY_RUN)
-    )
-    task_with_pre_3 = IdentifierPreTask(
-        x=MyConfig().add_pretasks(IdentifierPreLightTask())
-    ).submit(run_mode=RunMode.DRY_RUN)
-
-    assert_notequal(task, task_with_pre, "No pre-task")
-    assert_equal(task_with_pre, task_with_pre_2, "Same parameters")
-    assert_equal(task_with_pre, task_with_pre_3, "Pre-tasks are order-less")
-
-
-def test_param_identifier_init_task():
+def test_identifier_init_task():
     class MyConfig(Config):
         pass
 
@@ -426,26 +396,67 @@ def test_param_identifier_init_task():
     class IdentifierInitTask2(Task):
         pass
 
-    class IdentierTask(Task):
+    class IdentifierTask(Task):
         x: Param[MyConfig]
 
-    task = IdentierTask(x=MyConfig()).submit(run_mode=RunMode.DRY_RUN)
-    task_with_pre = IdentierTask(x=MyConfig()).submit(
+    task = IdentifierTask.C(x=MyConfig.C()).submit(run_mode=RunMode.DRY_RUN)
+    task_with_pre = IdentifierTask.C(x=MyConfig.C()).submit(
         run_mode=RunMode.DRY_RUN,
         init_tasks=[IdentifierInitTask(), IdentifierInitTask2()],
     )
-    task_with_pre_2 = IdentierTask(x=MyConfig()).submit(
+    task_with_pre_2 = IdentifierTask.C(x=MyConfig.C()).submit(
         run_mode=RunMode.DRY_RUN,
         init_tasks=[IdentifierInitTask(), IdentifierInitTask2()],
     )
-    task_with_pre_3 = IdentierTask(x=MyConfig()).submit(
+    task_with_pre_3 = IdentifierTask.C(x=MyConfig.C()).submit(
         run_mode=RunMode.DRY_RUN,
         init_tasks=[IdentifierInitTask2(), IdentifierInitTask()],
     )
 
-    assert_notequal(task, task_with_pre, "No pre-task")
+    assert_notequal(task, task_with_pre, "Should be different with init-task")
     assert_equal(task_with_pre, task_with_pre_2, "Same parameters")
-    assert_notequal(task_with_pre, task_with_pre_3, "Same parameters")
+    assert_notequal(task_with_pre, task_with_pre_3, "Other parameters")
+
+
+def test_identifier_init_task_dep():
+    class Loader(LightweightTask):
+        param1: Param[float]
+
+        def execute(self):
+            pass
+
+    class FirstTask(Task):
+        def task_outputs(self, dep):
+            return dep(Loader.C(param1=1))
+
+        def execute(self):
+            pass
+
+    class SecondTask(Task):
+        param3: Param[int]
+
+        def execute(self):
+            pass
+
+    # Two identical tasks
+    task_a_1 = FirstTask.C()
+    task_a_2 = FirstTask.C()
+    assert_equal(task_a_1, task_a_2)
+
+    # We process them with two different init tasks
+    loader_1 = task_a_1.submit(
+        init_tasks=[Loader.C(param1=0.5)], run_mode=RunMode.DRY_RUN
+    )
+    loader_2 = task_a_2.submit(
+        init_tasks=[Loader.C(param1=5)], run_mode=RunMode.DRY_RUN
+    )
+    assert_notequal(loader_1, loader_2)
+
+    # Now, we process
+    c_1 = SecondTask.C(param3=2).submit(init_tasks=[loader_1], run_mode=RunMode.DRY_RUN)
+
+    c_2 = SecondTask.C(param3=2).submit(init_tasks=[loader_2], run_mode=RunMode.DRY_RUN)
+    assert_notequal(c_1, c_2)
 
 
 # --- Check configuration reloads
@@ -463,7 +474,7 @@ def check_reload(config):
     new_config = ConfigInformation.fromParameters(
         data, as_instance=False, discard_id=True
     )
-    assert new_config.__xpm__._full_identifier is None
+    assert new_config.__xpm__._identifier is None
     new_identifier = new_config.__xpm__.identifier.all
 
     assert new_identifier == old_identifier
@@ -473,7 +484,7 @@ class IdentifierReloadConfig(Config):
     id: Param[str]
 
 
-def test_param_identifier_reload_config():
+def test_identifier_reload_config():
     # Creates the configuration
     check_reload(IdentifierReloadConfig(id="123"))
 
@@ -489,7 +500,7 @@ class IdentifierReloadDerived(Config):
     task: Param[IdentifierReloadConfig]
 
 
-def test_param_identifier_reload_taskoutput():
+def test_identifier_reload_taskoutput():
     """When using a task output, the identifier should not be different"""
 
     # Creates the configuration
@@ -511,7 +522,7 @@ class IdentifierReloadTaskDerived(Config):
     other: Param[IdentifierReloadTaskConfig]
 
 
-def test_param_identifier_reload_task_direct():
+def test_identifier_reload_task_direct():
     """When using a direct task output, the identifier should not be different"""
 
     # Creates the configuration
@@ -522,7 +533,7 @@ def test_param_identifier_reload_task_direct():
     check_reload(config)
 
 
-def test_param_identifier_reload_meta():
+def test_identifier_reload_meta():
     """Test identifier don't change when using meta"""
     # Creates the configuration
     task = IdentifierReloadTask(id="123").submit(run_mode=RunMode.DRY_RUN)
@@ -545,10 +556,10 @@ class LoopC(Config):
     param_b: Param["LoopB"]
 
 
-def test_param_identifier_loop():
-    c = LoopC()
-    b = LoopB(param_c=c)
-    a = LoopA(param_b=b)
+def test_identifier_loop():
+    c = LoopC.C()
+    b = LoopB.C(param_c=c)
+    a = LoopA.C(param_b=b)
     c.param_a = a
     c.param_b = b
 

experimaestro/tests/test_instance.py

@@ -46,18 +46,6 @@ class LoadModel(SerializationLWTask):
         self.value.initialized = True
 
 
-def test_instance_serialized():
-    model = Model()
-    model.add_pretasks(LoadModel(value=model))
-    trainer = Evaluator(model=model)
-    instance = trainer.instance()
-
-    assert isinstance(
-        instance.model, Model
-    ), f"The model is not a Model but a {type(instance.model).__qualname__}"
-    assert instance.model.initialized, "The model was not initialized"
-
-
 class ConfigWithOptional(Config):
     x: Param[int] = 1
     y: Param[Optional[int]]

experimaestro/tests/test_serializers.py

@@ -1,71 +1,12 @@
 from typing import Optional
 from experimaestro import (
     Config,
-    Task,
     Param,
-    SerializationLWTask,
-    copyconfig,
     state_dict,
     from_state_dict,
 )
 from experimaestro.core.context import SerializationContext
 from experimaestro.core.objects import ConfigMixin
-from experimaestro.tests.utils import TemporaryExperiment
-
-
-class SubModel(Config):
-    pass
-
-
-class Model(Config):
-    submodel: Param[SubModel]
-
-    def __post_init__(self):
-        self.initialized = False
-        self.submodel.initialized = False
-
-
-class LoadModel(SerializationLWTask):
-    def execute(self):
-        self.value.initialized = True
-        self.value.submodel.initialized = True
-
-
-class Trainer(Task):
-    model: Param[Config]
-
-    def task_outputs(self, dep):
-        model = copyconfig(self.model)
-        return model.add_pretasks(dep(LoadModel(value=model)))
-
-    def execute(self):
-        assert not self.model.initialized, "Model not initialized"
-
-
-class Evaluate(Task):
-    model: Param[Config]
-    is_submodel: Param[bool] = False
-
-    def execute(self):
-        assert self.model.initialized, "Model not initialized"
-        if self.is_submodel:
-            assert isinstance(self.model, SubModel)
-        else:
-            assert isinstance(self.model, Model)
-
-
-def test_serializers_xp():
-    with TemporaryExperiment("serializers", maxwait=20, port=0):
-        model = Model(submodel=SubModel())
-        trained_model: Model = Trainer(model=model).submit()
-
-        # Use the model itself
-        Evaluate(model=trained_model).submit()
-
-        # Use a submodel
-        Evaluate(model=trained_model.submodel, is_submodel=True).add_pretasks_from(
-            trained_model
-        ).submit()
 
 
 class Object1(Config):

experimaestro/tests/test_tasks.py

@@ -299,26 +299,6 @@ class MyLightweightTask(Task):
         assert self.x.data == 1
 
 
-def test_task_lightweight():
-    with TemporaryExperiment("lightweight", maxwait=20):
-        x = LightweightConfig()
-        lwtask = LightweightTask(x=x)
-        assert (
-            MyLightweightTask(x=x).add_pretasks(lwtask).submit().__xpm__.job.wait()
-            == JobState.DONE
-        ), "Pre-tasks should be executed"
-
-        x_2 = LightweightConfig()
-        lwtask_2 = LightweightTask(x=x)
-        assert (
-            MyLightweightTask(x=x_2.add_pretasks(lwtask_2))
-            .add_pretasks(lwtask_2)
-            .submit()
-            .__xpm__.job.wait()
-            == JobState.DONE
-        ), "Pre-tasks should be run just once"
-
-
 def test_task_lightweight_init():
     with TemporaryExperiment("lightweight_init", maxwait=20):
         x = LightweightConfig()

experimaestro/tests/test_types.py

@@ -26,7 +26,7 @@ def test_multiple_inheritance():
 
     for C in (C1, C2):
         logging.info("Testing %s", C)
-        ctype = C.__xpmtype__
+        ctype = C.C.__xpmtype__
         assert issubclass(C, A)
         assert issubclass(C, B)
         assert issubclass(C, B1)
@@ -49,7 +49,7 @@ def test_missing_hierarchy():
     class B(A1):
         pass
 
-    B.__xpmtype__
+    B.C.__xpmtype__
 
     assert issubclass(B, A)
     assert issubclass(B, A1)

{experimaestro-1.13.0.dist-info → experimaestro-1.15.0.dist-info}/METADATA

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

{experimaestro-1.13.0.dist-info → experimaestro-1.15.0.dist-info}/RECORD

@@ -12,17 +12,17 @@ experimaestro/connectors/__init__.py,sha256=UKhDU3uv9jFH37oUb0JiejrekA85xtEirn79
 experimaestro/connectors/local.py,sha256=lCGIubqmUJZ1glLtLRXOgakTMfEaEmFtNkEcw9qV5vw,6143
 experimaestro/connectors/ssh.py,sha256=5giqvv1y0QQKF-GI0IFUzI_Z5H8Bj9EuL_Szpvk899Q,8600
 experimaestro/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-experimaestro/core/arguments.py,sha256=7hpkU1f8LJ7JL8kQaD514h9CFSfMotYLsVfMsMmdpWk,6487
+experimaestro/core/arguments.py,sha256=jlK2_EILKLblLSomUDjlGmR-_xq3rAZPgAwbUjU4boc,6710
 experimaestro/core/callbacks.py,sha256=59JfeUgWcCCdIQ3pvh-xNnoRp9BX8f4iOAkgm16wBzE,1660
 experimaestro/core/context.py,sha256=1tLmX7WcgEKSbGw77vfziTzS8KNsoZJ02JBWMBCqqOk,2606
-experimaestro/core/identifier.py,sha256=JadBAdW2fOIgoTyMRtKI_RY9SXQP2B1vq1rUcV465Hs,10214
+experimaestro/core/identifier.py,sha256=5r2F425yX7Sfeub3EJZCs2Q4Qggifgi4uxMGcpI-ex0,10473
 experimaestro/core/objects/__init__.py,sha256=ucJY5e17QQ1Kc-GYXeL7g8GFj8rP0XB4g2vrl32uhxY,721
-experimaestro/core/objects/config.py,sha256=QDmD82NyWN9OQ_UVSV6WaPd1srKHVXeAmfcEW1Fw9Ps,58080
+experimaestro/core/objects/config.py,sha256=dYDEqB_6WtTK51ECCkBmBQTBkKZbuAOFA-giVpyc1lU,54695
 experimaestro/core/objects/config_utils.py,sha256=ZLECGkeIWdzunm8vwWsQhvcSgV1e064BgXbLiZnxSEM,1288
-experimaestro/core/objects/config_walk.py,sha256=gyDMrVPbBMChn7r4em_gQXuqnxASO_JVauEbnJNO8II,4245
-experimaestro/core/objects.pyi,sha256=xvlsRj4u1xsJxbevJl5Ner_HwmxR8x1JlAeIVDJzuy0,6498
+experimaestro/core/objects/config_walk.py,sha256=SYBrGuT7HV12no9mQd1HjnebiyygHyO-zq_TO1brUtc,4233
+experimaestro/core/objects.pyi,sha256=Q1tq4F8LrExPm00E-P5aaygxMvViYZqhHvByo_TTZRE,6315
 experimaestro/core/serialization.py,sha256=CSPEwOzlDsgAz6V2og-TgyU0RXDtzt_nXaoXFZleDZE,5775
-experimaestro/core/serializers.py,sha256=R_CAMyjjfU1oi-eHU6VlEUixJpFayGqEPaYu7VsD9xA,1197
+experimaestro/core/serializers.py,sha256=iOBuASEgD8dRKPnL16iOLBsM0GHChCJgjBd7LixFui4,919
 experimaestro/core/types.py,sha256=AH3ni1nIKGTeRmc7ECL6GH_dYqiuZp_mAN4E-JqdqnY,21741
 experimaestro/core/utils.py,sha256=JfC3qGUS9b6FUHc2VxIYUI9ysNpXSQ1LjOBkjfZ8n7o,495
 experimaestro/exceptions.py,sha256=cUy83WHM3GeynxmMk6QRr5xsnpqUAdAoc-m3KQVrE2o,44
@@ -117,24 +117,24 @@ experimaestro/tests/tasks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJW
 experimaestro/tests/tasks/all.py,sha256=OMkHsWZkErCmTajiNO7hNhvnk9eKzJC-VatWgabWlsI,1955
 experimaestro/tests/tasks/foreign.py,sha256=uhXDOcWozkcm26ybbeEU9RElJpbhjC-zdzmlSKfPcdY,122
 experimaestro/tests/test_checkers.py,sha256=Kg5frDNRE3pvWVmmYzyk0tJFNO885KOrK48lSu-NlYA,403
-experimaestro/tests/test_dependencies.py,sha256=xfWrSkvjT45G4FSCL535m1huLT2ghmyW7kvP_XvvCJQ,2005
+experimaestro/tests/test_dependencies.py,sha256=fEmBNQaEkP8xb_P_5EfKIJflL-NCeSOOZk_FumlgBC0,1870
 experimaestro/tests/test_experiment.py,sha256=QWF9aHewL9hepagrKKFyfikKn3iiZ_lRRXl1LLttta0,1687
 experimaestro/tests/test_findlauncher.py,sha256=KPy8ow--NXS1KFCIpxrmEJFRvjo-v-PwlVHVyoVKLPg,3134
 experimaestro/tests/test_forward.py,sha256=9y1zYm7hT_Lx5citxnK7n20cMZ2WJbsaEeY5irCZ9U4,735
-experimaestro/tests/test_generators.py,sha256=Cx0jDI8JA_tFsEfg9EkV353iKxBd6j_1560p_66_oNU,1040
-experimaestro/tests/test_identifier.py,sha256=zgfpz5UumQftQTHhdw3nmr044Xd7Ntrh7e2hIAoS_PA,13862
-experimaestro/tests/test_instance.py,sha256=h-8UeoOlNsD-STWq5jbhmxw35CyiwJxtKAaUGmLPgB8,1521
+experimaestro/tests/test_generators.py,sha256=R0UypTzxX0dPYvY4A_kozpLDHhGzQDNfLQyc0oRaSx8,2891
+experimaestro/tests/test_identifier.py,sha256=REFB9RGyVlSdAPMpmvJ9a0WbAoe6ZTR1xl73lqtRFU0,14022
+experimaestro/tests/test_instance.py,sha256=xLdSNVo_vAEaOWmjik1tAOYgyOkJPbmnwopyuDEQm1A,1147
 experimaestro/tests/test_objects.py,sha256=zycxjvWuJAbPR8-q2T3zuBY9xfmlhf1YvtOcrImHxnc,2431
 experimaestro/tests/test_outputs.py,sha256=DYzPk5TT_yLumy8SsQbl-S66ivVxJ-ERFrZ68KQZ4KU,781
 experimaestro/tests/test_param.py,sha256=7BltCUm9uhtEupJZ-QSaj7MxuXoUl73NjE8NfzJD5BA,7290
 experimaestro/tests/test_progress.py,sha256=wtIGQzlV3ldd_wMng11LinVESchW-1J954mCJNlG28E,7580
-experimaestro/tests/test_serializers.py,sha256=u3A5JbusN8aW6x6reUIwpU1Fs-avnzTRU7WuTear9Qs,2722
+experimaestro/tests/test_serializers.py,sha256=dQkiuvHAQ1g-SCRCfOy977nQMWR7CFuBUud65N_vfiI,1248
 experimaestro/tests/test_snippets.py,sha256=rojnyDjtmAMnSuDUj6Bv9XEgdP8oQf2nVc132JF8vsM,3081
 experimaestro/tests/test_ssh.py,sha256=KS1NWltiXrJBSStY9d4mwrexeqgNGWmhxuAU_WLQDAU,1449
 experimaestro/tests/test_tags.py,sha256=v_8_7LuEHfY_gfa0JRCUkmgJh8h6RMya_nd5NcPAJPw,2852
-experimaestro/tests/test_tasks.py,sha256=bUSB_UT1MTN2P_RPHd4AT5NK-DFsgCVeFKSiXu3bEz8,9429
+experimaestro/tests/test_tasks.py,sha256=eka9LiOMTp0LhRxSM4Khw1jAner6wgjF8sNDOHSqwnQ,8781
 experimaestro/tests/test_tokens.py,sha256=U3nKBL1KftWhmk3dQZZLQd-MLJL_SscMjI3zMieMHfc,7823
-experimaestro/tests/test_types.py,sha256=HVOu05ivOQB0Y7iBLVBg1J_FKg9E49pbU3yk0jvWA6U,1301
+experimaestro/tests/test_types.py,sha256=CVyAyiWgEeV1FpWc-oC8TUqGN4o-9eVBrv75PHvWapA,1305
 experimaestro/tests/test_validation.py,sha256=t0fu-5wkCzpUKLu8K0rbU5zDE_LtsgehWm84HtIF5JY,4076
 experimaestro/tests/token_reschedule.py,sha256=V8lAbjTWTatBrBjxde_KN-fDEI4sQ3HNr4scCXBU6fI,1701
 experimaestro/tests/utils.py,sha256=41krZFgUaCxCYBQPmo5dNFDd9W6RU8ZzzyzY3FyutUI,3805
@@ -152,8 +152,8 @@ experimaestro/utils/multiprocessing.py,sha256=am3DkHP_kmWbpynbck2c9QystCUtPBoSAC
 experimaestro/utils/resources.py,sha256=j-nvsTFwmgENMoVGOD2Ap-UD3WU85WkI0IgeSszMCX4,1328
 experimaestro/utils/settings.py,sha256=jpFMqF0DLL4_P1xGal0zVR5cOrdD8O0Y2IOYvnRgN3k,793
 experimaestro/xpmutils.py,sha256=S21eMbDYsHfvmZ1HmKpq5Pz5O-1HnCLYxKbyTBbASyQ,638
-experimaestro-1.13.0.dist-info/METADATA,sha256=UbZQxb19lKM9jI8HI8aZli0ZmOck1UflmQmN6VHvDEI,5705
-experimaestro-1.13.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-experimaestro-1.13.0.dist-info/entry_points.txt,sha256=TppTNiz5qm5xm1fhAcdLKdCLMrlL-eQggtCrCI00D9c,446
-experimaestro-1.13.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-experimaestro-1.13.0.dist-info/RECORD,,
+experimaestro-1.15.0.dist-info/METADATA,sha256=c6VFYeeH9cN7JxYxGve-CJN-w45gvmxQnruB4q88WY4,5705
+experimaestro-1.15.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+experimaestro-1.15.0.dist-info/entry_points.txt,sha256=TppTNiz5qm5xm1fhAcdLKdCLMrlL-eQggtCrCI00D9c,446
+experimaestro-1.15.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+experimaestro-1.15.0.dist-info/RECORD,,