fractal-server 2.12.0a1__py3-none-any.whl → 2.13.0__py3-none-any.whl

fractal_server/app/runner/executors/slurm/sudo/_executor_wait_thread.py

@@ -1,12 +1,10 @@
 import os
+import threading
 import time
 import traceback
 from itertools import count
-from typing import Callable
 from typing import Optional
 
-from cfut import FileWaitThread
-
 from ......logger import set_logger
 from ._check_jobs_status import _jobs_finished
 from fractal_server.app.runner.exceptions import JobExecutionError
@@ -14,33 +12,43 @@ from fractal_server.app.runner.exceptions import JobExecutionError
 logger = set_logger(__name__)
 
 
-class FractalFileWaitThread(FileWaitThread):
+class FractalSlurmSudoWaitThread(threading.Thread):
     """
-    Overrides the original clusterfutures.FileWaitThread, so that:
-
-    1. Each jobid in the waiting list is associated to a tuple of filenames,
-       rather than a single one.
-    2. In the `check` method, we avoid output-file existence checks (which
-       would require `sudo -u user ls` calls), and we rather check for the
-       existence of the shutdown file. All the logic to check whether a job is
-       complete is deferred to the `cfut.slurm.jobs_finished` function.
-    3. There are additional attributes (`slurm_user`, `shutdown_file` and
-       `shutdown_callback`).
-
-    This class is copied from clusterfutures 0.5. Original Copyright: 2022
-    Adrian Sampson, released under the MIT licence
-
-    Note: in principle we could avoid the definition of
-    `FractalFileWaitThread`, and pack all this code in
-    `FractalSlurmWaitThread`.
+    Thread that monitors a pool of SLURM jobs
+
+    This class is a custom re-implementation of the waiting thread class from:
+
+    > clusterfutures <https://github.com/sampsyo/clusterfutures>
+    > Original Copyright
+    > Copyright 2021 Adrian Sampson <asampson@cs.washington.edu>
+    > License: MIT
+
+    Attributes:
+        slurm_user:
+        shutdown_file:
+        shutdown_callback:
+        slurm_poll_interval:
+        waiting:
+        shutdown:
+        lock:
     """
 
     slurm_user: str
     shutdown_file: Optional[str] = None
-    shutdown_callback: Callable
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
+    shutdown_callback: callable
+    slurm_poll_interval: int = 30
+    waiting: dict[tuple[str, ...], str]
+    shutdown: bool
+    _lock: threading.Lock
+
+    def __init__(self, callback: callable, interval=1):
+        threading.Thread.__init__(self, daemon=True)
+        self.callback = callback
+        self.interval = interval
+        self.waiting = {}
+        self._lock = threading.Lock()  # To protect the .waiting dict
+        self.shutdown = False
+        self.active_job_ids = []
 
     def wait(
         self,
@@ -61,10 +69,10 @@ class FractalFileWaitThread(FileWaitThread):
             error_msg = "Cannot call `wait` method after executor shutdown."
             logger.warning(error_msg)
             raise JobExecutionError(info=error_msg)
-        with self.lock:
+        with self._lock:
             self.waiting[filenames] = jobid
 
-    def check(self, i):
+    def check_shutdown(self, i):
         """
         Do one shutdown-file-existence check.
 
@@ -99,30 +107,12 @@ class FractalFileWaitThread(FileWaitThread):
             if self.shutdown:
                 self.shutdown_callback()
                 return
-            with self.lock:
+            with self._lock:
                 self.check(i)
             time.sleep(self.interval)
 
-
-class FractalSlurmWaitThread(FractalFileWaitThread):
-    """
-    Replaces the original clusterfutures.SlurmWaitThread, to inherit from
-    FractalFileWaitThread instead of FileWaitThread.
-
-    The function is copied from clusterfutures 0.5. Original Copyright: 2022
-    Adrian Sampson, released under the MIT licence
-
-    **Note**: if `self.interval != 1` then this should be modified, but for
-    `clusterfutures` v0.5 `self.interval` is indeed equal to `1`.
-
-    Changed from clusterfutures:
-    * Rename `id_to_filename` to `id_to_filenames`
-    """
-
-    slurm_poll_interval = 30
-
     def check(self, i):
-        super().check(i)
+        self.check_shutdown(i)
         if i % (self.slurm_poll_interval // self.interval) == 0:
             try:
                 finished_jobs = _jobs_finished(self.waiting.values())

fractal_server/app/runner/executors/slurm/sudo/executor.py

@@ -1,20 +1,12 @@
-# This adapts clusterfutures <https://github.com/sampsyo/clusterfutures>
-# Original Copyright
-# Copyright 2021 Adrian Sampson <asampson@cs.washington.edu>
-# License: MIT
-#
-# Modified by:
-# Jacopo Nespolo <jacopo.nespolo@exact-lab.it>
-# Tommaso Comparin <tommaso.comparin@exact-lab.it>
-# Marco Franzon <marco.franzon@exact-lab.it>
-#
-# Copyright 2022 (C) Friedrich Miescher Institute for Biomedical Research and
-# University of Zurich
+import json
 import math
 import shlex
 import subprocess  # nosec
 import sys
+import threading
 import time
+import uuid
+from concurrent.futures import Executor
 from concurrent.futures import Future
 from concurrent.futures import InvalidStateError
 from copy import copy
@@ -26,8 +18,6 @@ from typing import Optional
 from typing import Sequence
 
 import cloudpickle
-from cfut import SlurmExecutor
-from cfut.util import random_string
 
 from ......config import get_settings
 from ......logger import set_logger
@@ -42,7 +32,7 @@ from .._batching import heuristics
 from ..utils_executors import get_pickle_file_path
 from ..utils_executors import get_slurm_file_path
 from ..utils_executors import get_slurm_script_file_path
-from ._executor_wait_thread import FractalSlurmWaitThread
+from ._executor_wait_thread import FractalSlurmSudoWaitThread
 from ._subprocess_run_as_user import _glob_as_user
 from ._subprocess_run_as_user import _glob_as_user_strict
 from ._subprocess_run_as_user import _path_exists_as_user
@@ -161,7 +151,6 @@ class SlurmJob:
         self,
         num_tasks_tot: int,
         slurm_config: SlurmConfig,
-        workflow_task_file_prefix: Optional[str] = None,
         slurm_file_prefix: Optional[str] = None,
         wftask_file_prefixes: Optional[tuple[str, ...]] = None,
         single_task_submission: bool = False,
@@ -180,9 +169,7 @@ class SlurmJob:
             )
         else:
             self.wftask_file_prefixes = wftask_file_prefixes
-        self.workerids = tuple(
-            random_string() for i in range(self.num_tasks_tot)
-        )
+        self.workerids = tuple(uuid.uuid4() for i in range(self.num_tasks_tot))
         self.slurm_config = slurm_config
 
     def get_clean_output_pickle_files(self) -> tuple[str, ...]:
@@ -193,9 +180,17 @@ class SlurmJob:
         return tuple(str(f.as_posix()) for f in self.output_pickle_files)
 
 
-class FractalSlurmExecutor(SlurmExecutor):
+class FractalSlurmSudoExecutor(Executor):
     """
-    FractalSlurmExecutor (inherits from cfut.SlurmExecutor)
+    Executor to submit SLURM jobs as a different user, via `sudo -u`
+
+    This class is a custom re-implementation of the SLURM executor from
+
+    > clusterfutures <https://github.com/sampsyo/clusterfutures>
+    > Original Copyright
+    > Copyright 2021 Adrian Sampson <asampson@cs.washington.edu>
+    > License: MIT
+
 
     Attributes:
         slurm_user:
@@ -211,7 +206,7 @@ class FractalSlurmExecutor(SlurmExecutor):
             Dictionary with paths of slurm-related files for active jobs
     """
 
-    wait_thread_cls = FractalSlurmWaitThread
+    wait_thread_cls = FractalSlurmSudoWaitThread
     slurm_user: str
     shutdown_file: str
     common_script_lines: list[str]
@@ -219,8 +214,7 @@ class FractalSlurmExecutor(SlurmExecutor):
     workflow_dir_local: Path
     workflow_dir_remote: Path
     map_jobid_to_slurm_files: dict[str, tuple[str, str, str]]
-    keep_pickle_files: bool
-    slurm_account: Optional[str]
+    slurm_account: Optional[str] = None
     jobs: dict[str, tuple[Future, SlurmJob]]
 
     def __init__(
@@ -232,7 +226,6 @@ class FractalSlurmExecutor(SlurmExecutor):
         user_cache_dir: Optional[str] = None,
         common_script_lines: Optional[list[str]] = None,
         slurm_poll_interval: Optional[int] = None,
-        keep_pickle_files: bool = False,
         slurm_account: Optional[str] = None,
         *args,
         **kwargs,
@@ -246,18 +239,31 @@ class FractalSlurmExecutor(SlurmExecutor):
                 "Missing attribute FractalSlurmExecutor.slurm_user"
             )
 
-        super().__init__(*args, **kwargs)
+        self.jobs = {}
+        self.job_outfiles = {}
+        self.jobs_lock = threading.Lock()
+        self.jobs_empty_cond = threading.Condition(self.jobs_lock)
+
+        self.wait_thread = self.wait_thread_cls(self._completion)
+        self.wait_thread.start()
 
         # Assign `wait_thread.shutdown_callback` early, since it may be called
         # from within `_stop_and_join_wait_thread` (e.g. if an exception is
         # raised within `__init__`).
         self.wait_thread.shutdown_callback = self.shutdown
 
-        self.keep_pickle_files = keep_pickle_files
         self.slurm_user = slurm_user
         self.slurm_account = slurm_account
 
         self.common_script_lines = common_script_lines or []
+        settings = Inject(get_settings)
+
+        if settings.FRACTAL_SLURM_WORKER_PYTHON is not None:
+            try:
+                self.check_remote_python_interpreter()
+            except Exception as e:
+                self._stop_and_join_wait_thread()
+                raise RuntimeError(f"Original error {str(e)}")
 
         # Check that SLURM account is not set here
         try:
@@ -289,7 +295,6 @@ class FractalSlurmExecutor(SlurmExecutor):
         # Set the attribute slurm_poll_interval for self.wait_thread (see
         # cfut.SlurmWaitThread)
         if not slurm_poll_interval:
-            settings = Inject(get_settings)
             slurm_poll_interval = settings.FRACTAL_SLURM_POLL_INTERVAL
         self.wait_thread.slurm_poll_interval = slurm_poll_interval
         self.wait_thread.slurm_user = self.slurm_user
@@ -608,7 +613,14 @@ class FractalSlurmExecutor(SlurmExecutor):
             _prefixes = []
             _subfolder_names = []
             for component in components:
-                actual_component = component.get(_COMPONENT_KEY_, None)
+                # In Fractal, `component` is a `dict` by construction (e.g.
+                # `component = {"zarr_url": "/something", "param": 1}``). The
+                # try/except covers the case of e.g. `executor.map([1, 2])`,
+                # which is useful for testing.
+                try:
+                    actual_component = component.get(_COMPONENT_KEY_, None)
+                except AttributeError:
+                    actual_component = str(component)
                 _task_file_paths = get_task_file_paths(
                     workflow_dir_local=task_files.workflow_dir_local,
                     workflow_dir_remote=task_files.workflow_dir_remote,
@@ -860,8 +872,7 @@ class FractalSlurmExecutor(SlurmExecutor):
                             " cancelled, exit from"
                             " FractalSlurmExecutor._completion."
                         )
-                        if not self.keep_pickle_files:
-                            in_path.unlink()
+                        in_path.unlink()
                         self._cleanup(jobid)
                         return
 
@@ -903,23 +914,20 @@ class FractalSlurmExecutor(SlurmExecutor):
                             exc = TaskExecutionError(proxy.tb, **kwargs)
                             fut.set_exception(exc)
                             return
-                    if not self.keep_pickle_files:
-                        out_path.unlink()
+                    out_path.unlink()
                 except InvalidStateError:
                     logger.warning(
                         f"Future {fut} (SLURM job ID: {jobid}) was already"
                         " cancelled, exit from"
                         " FractalSlurmExecutor._completion."
                     )
-                    if not self.keep_pickle_files:
-                        out_path.unlink()
-                        in_path.unlink()
+                    out_path.unlink()
+                    in_path.unlink()
                     self._cleanup(jobid)
                     return
 
                 # Clean up input pickle file
-                if not self.keep_pickle_files:
-                    in_path.unlink()
+                in_path.unlink()
             self._cleanup(jobid)
             if job.single_task_submission:
                 fut.set_result(outputs[0])
@@ -1155,8 +1163,10 @@ class FractalSlurmExecutor(SlurmExecutor):
         script_lines = slurm_config.sort_script_lines(script_lines)
         logger.debug(script_lines)
 
-        # Always print output of `pwd`
-        script_lines.append('echo "Working directory (pwd): `pwd`"\n')
+        # Always print output of `uname -n` and `pwd`
+        script_lines.append(
+            '"Hostname: `uname -n`; current directory: `pwd`"\n'
+        )
 
         # Complete script preamble
         script_lines.append("\n")
@@ -1230,7 +1240,7 @@ class FractalSlurmExecutor(SlurmExecutor):
         logger.debug("Executor shutdown: end")
 
     def _stop_and_join_wait_thread(self):
-        self.wait_thread.stop()
+        self.wait_thread.shutdown = True
         self.wait_thread.join()
 
     def __exit__(self, *args, **kwargs):
@@ -1243,3 +1253,29 @@ class FractalSlurmExecutor(SlurmExecutor):
         )
         self._stop_and_join_wait_thread()
         logger.debug("[FractalSlurmExecutor.__exit__] End")
+
+    def check_remote_python_interpreter(self):
+        """
+        Check fractal-server version on the _remote_ Python interpreter.
+        """
+        settings = Inject(get_settings)
+        output = _subprocess_run_or_raise(
+            (
+                f"{settings.FRACTAL_SLURM_WORKER_PYTHON} "
+                "-m fractal_server.app.runner.versions"
+            )
+        )
+        runner_version = json.loads(output.stdout.strip("\n"))[
+            "fractal_server"
+        ]
+
+        if runner_version != __VERSION__:
+            error_msg = (
+                "Fractal-server version mismatch.\n"
+                "Local interpreter: "
+                f"({sys.executable}): {__VERSION__}.\n"
+                "Remote interpreter: "
+                f"({settings.FRACTAL_SLURM_WORKER_PYTHON}): {runner_version}."
+            )
+            logger.error(error_msg)
+            raise ValueError(error_msg)

fractal_server/app/runner/v2/__init__.py

@@ -31,9 +31,6 @@ from ..executors.slurm.sudo._subprocess_run_as_user import _mkdir_as_user
 from ..filenames import WORKFLOW_LOG_FILENAME
 from ..task_files import task_subfolder_name
 from ._local import process_workflow as local_process_workflow
-from ._local_experimental import (
-    process_workflow as local_experimental_process_workflow,
-)
 from ._slurm_ssh import process_workflow as slurm_ssh_process_workflow
 from ._slurm_sudo import process_workflow as slurm_sudo_process_workflow
 from .handle_failed_job import mark_last_wftask_as_failed
@@ -45,7 +42,6 @@ _backends = {}
 _backends["local"] = local_process_workflow
 _backends["slurm"] = slurm_sudo_process_workflow
 _backends["slurm_ssh"] = slurm_ssh_process_workflow
-_backends["local_experimental"] = local_experimental_process_workflow
 
 
 def fail_job(
@@ -184,8 +180,6 @@ def submit_workflow(
             # Define and create WORKFLOW_DIR_REMOTE
             if FRACTAL_RUNNER_BACKEND == "local":
                 WORKFLOW_DIR_REMOTE = WORKFLOW_DIR_LOCAL
-            elif FRACTAL_RUNNER_BACKEND == "local_experimental":
-                WORKFLOW_DIR_REMOTE = WORKFLOW_DIR_LOCAL
             elif FRACTAL_RUNNER_BACKEND == "slurm":
                 WORKFLOW_DIR_REMOTE = (
                     Path(user_cache_dir) / WORKFLOW_DIR_LOCAL.name
@@ -287,9 +281,6 @@ def submit_workflow(
         if FRACTAL_RUNNER_BACKEND == "local":
             process_workflow = local_process_workflow
             backend_specific_kwargs = {}
-        elif FRACTAL_RUNNER_BACKEND == "local_experimental":
-            process_workflow = local_experimental_process_workflow
-            backend_specific_kwargs = {}
         elif FRACTAL_RUNNER_BACKEND == "slurm":
             process_workflow = slurm_sudo_process_workflow
             backend_specific_kwargs = dict(

fractal_server/app/runner/v2/_local/_local_config.py

@@ -17,8 +17,8 @@ from typing import Literal
 from typing import Optional
 
 from pydantic import BaseModel
-from pydantic import Extra
-from pydantic.error_wrappers import ValidationError
+from pydantic import ConfigDict
+from pydantic import ValidationError
 
 from .....config import get_settings
 from .....syringe import Inject
@@ -33,7 +33,7 @@ class LocalBackendConfigError(ValueError):
     pass
 
 
-class LocalBackendConfig(BaseModel, extra=Extra.forbid):
+class LocalBackendConfig(BaseModel):
     """
     Specifications of the local-backend configuration
 
@@ -44,7 +44,8 @@ class LocalBackendConfig(BaseModel, extra=Extra.forbid):
             start at the same time.
     """
 
-    parallel_tasks_per_job: Optional[int]
+    model_config = ConfigDict(extra="forbid")
+    parallel_tasks_per_job: Optional[int] = None
 
 
 def get_default_local_backend_config():

fractal_server/app/runner/v2/_slurm_common/get_slurm_config.py

@@ -67,14 +67,14 @@ def get_slurm_config(
 
     # Incorporate slurm_env.default_slurm_config
     slurm_env = load_slurm_config_file(config_path=config_path)
-    slurm_dict = slurm_env.default_slurm_config.dict(
+    slurm_dict = slurm_env.default_slurm_config.model_dump(
         exclude_unset=True, exclude={"mem"}
     )
     if slurm_env.default_slurm_config.mem:
         slurm_dict["mem_per_task_MB"] = slurm_env.default_slurm_config.mem
 
     # Incorporate slurm_env.batching_config
-    for key, value in slurm_env.batching_config.dict().items():
+    for key, value in slurm_env.batching_config.model_dump().items():
         slurm_dict[key] = value
 
     # Incorporate slurm_env.user_local_exports
@@ -82,7 +82,7 @@ def get_slurm_config(
 
     logger.debug(
         "[get_slurm_config] Fractal SLURM configuration file: "
-        f"{slurm_env.dict()=}"
+        f"{slurm_env.model_dump()=}"
     )
 
     # GPU-related options
@@ -97,7 +97,7 @@ def get_slurm_config(
         needs_gpu = False
     logger.debug(f"[get_slurm_config] {needs_gpu=}")
     if needs_gpu:
-        for key, value in slurm_env.gpu_slurm_config.dict(
+        for key, value in slurm_env.gpu_slurm_config.model_dump(
             exclude_unset=True, exclude={"mem"}
         ).items():
             slurm_dict[key] = value

fractal_server/app/runner/v2/_slurm_sudo/__init__.py

@@ -21,7 +21,7 @@ from typing import Optional
 
 from ....models.v2 import DatasetV2
 from ....models.v2 import WorkflowV2
-from ...executors.slurm.sudo.executor import FractalSlurmExecutor
+from ...executors.slurm.sudo.executor import FractalSlurmSudoExecutor
 from ...set_start_and_last_task_index import set_start_and_last_task_index
 from ..runner import execute_tasks_v2
 from ._submit_setup import _slurm_submit_setup
@@ -64,7 +64,7 @@ def process_workflow(
     if isinstance(worker_init, str):
         worker_init = worker_init.split("\n")
 
-    with FractalSlurmExecutor(
+    with FractalSlurmSudoExecutor(
         debug=True,
         keep_logs=True,
         slurm_user=slurm_user,

fractal_server/app/runner/v2/deduplicate_list.py

@@ -16,7 +16,7 @@ def deduplicate_list(
     new_list_dict = []
     new_list_objs = []
     for this_obj in this_list:
-        this_dict = this_obj.dict()
+        this_dict = this_obj.model_dump()
         if this_dict not in new_list_dict:
             new_list_dict.append(this_dict)
             new_list_objs.append(this_obj)

fractal_server/app/runner/v2/runner.py

@@ -75,10 +75,13 @@ def execute_tasks_v2(
         with next(get_sync_db()) as db:
             db_dataset = db.get(DatasetV2, dataset.id)
             new_history_item = _DatasetHistoryItemV2(
-                workflowtask=wftask,
+                workflowtask=dict(
+                    **wftask.model_dump(exclude={"task"}),
+                    task=wftask.task.model_dump(),
+                ),
                 status=WorkflowTaskStatusTypeV2.SUBMITTED,
                 parallelization=dict(),  # FIXME: re-include parallelization
-            ).dict()
+            ).model_dump()
             db_dataset.history.append(new_history_item)
             flag_modified(db_dataset, "history")
             db.merge(db_dataset)
@@ -132,7 +135,9 @@ def execute_tasks_v2(
             and current_task_output.image_list_removals == []
         ):
             current_task_output = TaskOutput(
-                **current_task_output.dict(exclude={"image_list_updates"}),
+                **current_task_output.model_dump(
+                    exclude={"image_list_updates"}
+                ),
                 image_list_updates=[
                     dict(zarr_url=img["zarr_url"]) for img in filtered_images
                 ],
@@ -141,7 +146,7 @@ def execute_tasks_v2(
         # Update image list
         current_task_output.check_zarr_urls_are_unique()
         for image_obj in current_task_output.image_list_updates:
-            image = image_obj.dict()
+            image = image_obj.model_dump()
             # Edit existing image
             tmp_image_paths = [img["zarr_url"] for img in tmp_images]
             if image["zarr_url"] in tmp_image_paths:

fractal_server/app/runner/v2/task_interface.py

@@ -1,15 +1,17 @@
 from typing import Any
 
 from pydantic import BaseModel
-from pydantic import Extra
+from pydantic import ConfigDict
 from pydantic import Field
-from pydantic import validator
+from pydantic import field_validator
 
 from ....images import SingleImageTaskOutput
 from fractal_server.urls import normalize_url
 
 
-class TaskOutput(BaseModel, extra=Extra.forbid):
+class TaskOutput(BaseModel):
+
+    model_config = ConfigDict(extra="forbid")
 
     image_list_updates: list[SingleImageTaskOutput] = Field(
         default_factory=list
@@ -35,21 +37,27 @@ class TaskOutput(BaseModel, extra=Extra.forbid):
                 msg = f"{msg}\n{duplicate}"
             raise ValueError(msg)
 
-    @validator("image_list_removals")
+    @field_validator("image_list_removals")
+    @classmethod
     def normalize_paths(cls, v: list[str]) -> list[str]:
         return [normalize_url(zarr_url) for zarr_url in v]
 
 
-class InitArgsModel(BaseModel, extra=Extra.forbid):
+class InitArgsModel(BaseModel):
+
+    model_config = ConfigDict(extra="forbid")
 
     zarr_url: str
     init_args: dict[str, Any] = Field(default_factory=dict)
 
-    @validator("zarr_url")
+    @field_validator("zarr_url")
+    @classmethod
     def normalize_path(cls, v: str) -> str:
         return normalize_url(v)
 
 
-class InitTaskOutput(BaseModel, extra=Extra.forbid):
+class InitTaskOutput(BaseModel):
+
+    model_config = ConfigDict(extra="forbid")
 
     parallelization_list: list[InitArgsModel] = Field(default_factory=list)

fractal_server/app/schemas/_filter_validators.py

@@ -5,22 +5,25 @@ from fractal_server.images.models import AttributeFiltersType
 
 
 def validate_type_filters(
-    type_filters: Optional[dict[str, bool]]
+    cls, type_filters: Optional[dict[str, bool]]
 ) -> dict[str, bool]:
     if type_filters is None:
         raise ValueError("'type_filters' cannot be 'None'.")
 
-    type_filters = valdict_keys("type_filters")(type_filters)
+    type_filters = valdict_keys("type_filters")(cls, type_filters)
     return type_filters
 
 
 def validate_attribute_filters(
+    cls,
     attribute_filters: Optional[AttributeFiltersType],
 ) -> AttributeFiltersType:
     if attribute_filters is None:
         raise ValueError("'attribute_filters' cannot be 'None'.")
 
-    attribute_filters = valdict_keys("attribute_filters")(attribute_filters)
+    attribute_filters = valdict_keys("attribute_filters")(
+        cls, attribute_filters
+    )
     for key, values in attribute_filters.items():
         if values == []:
             raise ValueError(

fractal_server/app/schemas/_validators.py

@@ -11,7 +11,7 @@ def valstr(attribute: str, accept_none: bool = False):
     If `accept_none`, the validator also accepts `None`.
     """
 
-    def val(string: Optional[str]) -> Optional[str]:
+    def val(cls, string: Optional[str]) -> Optional[str]:
         if string is None:
             if accept_none:
                 return string
@@ -28,14 +28,16 @@ def valstr(attribute: str, accept_none: bool = False):
 
 
 def valdict_keys(attribute: str):
-    def val(d: Optional[dict[str, Any]]) -> Optional[dict[str, Any]]:
+    def val(cls, d: Optional[dict[str, Any]]) -> Optional[dict[str, Any]]:
         """
         Apply valstr to every key of the dictionary, and fail if there are
         identical keys.
         """
         if d is not None:
             old_keys = list(d.keys())
-            new_keys = [valstr(f"{attribute}[{key}]")(key) for key in old_keys]
+            new_keys = [
+                valstr(f"{attribute}[{key}]")(cls, key) for key in old_keys
+            ]
             if len(new_keys) != len(set(new_keys)):
                 raise ValueError(
                     f"Dictionary contains multiple identical keys: '{d}'."
@@ -53,7 +55,7 @@ def val_absolute_path(attribute: str, accept_none: bool = False):
     Check that a string attribute is an absolute path
     """
 
-    def val(string: Optional[str]) -> Optional[str]:
+    def val(cls, string: Optional[str]) -> Optional[str]:
         if string is None:
             if accept_none:
                 return string
@@ -75,7 +77,7 @@ def val_absolute_path(attribute: str, accept_none: bool = False):
 
 
 def val_unique_list(attribute: str):
-    def val(must_be_unique: Optional[list]) -> Optional[list]:
+    def val(cls, must_be_unique: Optional[list]) -> Optional[list]:
         if must_be_unique is not None:
             if len(set(must_be_unique)) != len(must_be_unique):
                 raise ValueError(f"`{attribute}` list has repetitions")