fractal-server 2.12.1__py3-none-any.whl → 2.13.0__py3-none-any.whl

fractal_server/app/runner/executors/slurm/_slurm_config.py

@@ -18,9 +18,9 @@ from typing import Optional
 from typing import Union
 
 from pydantic import BaseModel
-from pydantic import Extra
+from pydantic import ConfigDict
 from pydantic import Field
-from pydantic.error_wrappers import ValidationError
+from pydantic import ValidationError
 
 from .....config import get_settings
 from .....logger import set_logger
@@ -37,7 +37,7 @@ class SlurmConfigError(ValueError):
     pass
 
 
-class _SlurmConfigSet(BaseModel, extra=Extra.forbid):
+class _SlurmConfigSet(BaseModel):
     """
     Options that can be set in `FRACTAL_SLURM_CONFIG_FILE` for the default/gpu
     SLURM config. Only used as part of `SlurmConfigFile`.
@@ -54,19 +54,21 @@ class _SlurmConfigSet(BaseModel, extra=Extra.forbid):
         extra_lines:
     """
 
-    partition: Optional[str]
-    cpus_per_task: Optional[int]
-    mem: Optional[Union[int, str]]
-    constraint: Optional[str]
-    gres: Optional[str]
-    time: Optional[str]
-    account: Optional[str]
-    extra_lines: Optional[list[str]]
-    pre_submission_commands: Optional[list[str]]
-    gpus: Optional[str]
+    model_config = ConfigDict(extra="forbid")
 
+    partition: Optional[str] = None
+    cpus_per_task: Optional[int] = None
+    mem: Optional[Union[int, str]] = None
+    constraint: Optional[str] = None
+    gres: Optional[str] = None
+    time: Optional[str] = None
+    account: Optional[str] = None
+    extra_lines: Optional[list[str]] = None
+    pre_submission_commands: Optional[list[str]] = None
+    gpus: Optional[str] = None
 
-class _BatchingConfigSet(BaseModel, extra=Extra.forbid):
+
+class _BatchingConfigSet(BaseModel):
     """
     Options that can be set in `FRACTAL_SLURM_CONFIG_FILE` to configure the
     batching strategy (that is, how to combine several tasks in a single SLURM
@@ -83,6 +85,8 @@ class _BatchingConfigSet(BaseModel, extra=Extra.forbid):
         max_num_jobs:
     """
 
+    model_config = ConfigDict(extra="forbid")
+
     target_cpus_per_job: int
     max_cpus_per_job: int
     target_mem_per_job: Union[int, str]
@@ -91,7 +95,7 @@ class _BatchingConfigSet(BaseModel, extra=Extra.forbid):
     max_num_jobs: int
 
 
-class SlurmConfigFile(BaseModel, extra=Extra.forbid):
+class SlurmConfigFile(BaseModel):
     """
     Specifications for the content of `FRACTAL_SLURM_CONFIG_FILE`
 
@@ -136,10 +140,12 @@ class SlurmConfigFile(BaseModel, extra=Extra.forbid):
             directory.
     """
 
+    model_config = ConfigDict(extra="forbid")
+
     default_slurm_config: _SlurmConfigSet
-    gpu_slurm_config: Optional[_SlurmConfigSet]
+    gpu_slurm_config: Optional[_SlurmConfigSet] = None
     batching_config: _BatchingConfigSet
-    user_local_exports: Optional[dict[str, str]]
+    user_local_exports: Optional[dict[str, str]] = None
 
 
 def load_slurm_config_file(
@@ -196,7 +202,7 @@ def load_slurm_config_file(
     return obj
 
 
-class SlurmConfig(BaseModel, extra=Extra.forbid):
+class SlurmConfig(BaseModel):
     """
     Abstraction for SLURM parameters
 
@@ -247,6 +253,8 @@ class SlurmConfig(BaseModel, extra=Extra.forbid):
             command.
     """
 
+    model_config = ConfigDict(extra="forbid")
+
     # Required SLURM parameters (note that the integer attributes are those
     # that will need to scale up with the number of parallel tasks per job)
     partition: str

fractal_server/app/runner/executors/slurm/ssh/__init__.py

@@ -1,3 +0,0 @@
-from .executor import SlurmExecutor
-
-__all__ = ["SlurmExecutor"]

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

@@ -1,10 +1,8 @@
 import os
+import threading
 import time
 import traceback
 from itertools import count
-from typing import Callable
-
-from cfut import FileWaitThread
 
 from ......logger import set_logger
 from fractal_server.app.runner.exceptions import JobExecutionError
@@ -12,35 +10,46 @@ from fractal_server.app.runner.exceptions import JobExecutionError
 logger = set_logger(__name__)
 
 
-class FractalSlurmWaitThread(FileWaitThread):
+class FractalSlurmSSHWaitThread(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 (...).
-
-    This class is based on clusterfutures 0.5. Original Copyright: 2022
-    Adrian Sampson, released under the MIT licence
+    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:
+        shutdown_file:
+        shutdown_callback:
+        slurm_poll_interval:
+        jobs_finished_callback:
+        active_job_ids:
+        shutdown:
+        lock:
     """
 
     shutdown_file: str
-    shutdown_callback: Callable
-    jobs_finished_callback: Callable
+    shutdown_callback: callable
     slurm_poll_interval = 30
+    jobs_finished_callback: callable
     active_job_ids: list[str]
+    shutdown: bool
+    _lock: threading.Lock
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self, callback: callable, interval=1):
         """
         Init method
 
         This method is executed on the main thread.
         """
-        super().__init__(*args, **kwargs)
+        threading.Thread.__init__(self, daemon=True)
+        self.callback = callback
+        self.interval = interval
+        self._lock = threading.Lock()
+        self.shutdown = False
         self.active_job_ids = []
 
     def wait(self, *, job_id: str):
@@ -53,7 +62,7 @@ class FractalSlurmWaitThread(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.active_job_ids.append(job_id)
 
     def check_shutdown(self):
@@ -109,7 +118,7 @@ class FractalSlurmWaitThread(FileWaitThread):
                     pass
                 return
             if ind % skip == 0:
-                with self.lock:
+                with self._lock:
                     try:
                         self.check_jobs()
                     except Exception:  # nosec

fractal_server/app/runner/executors/slurm/ssh/_slurm_job.py

@@ -1,8 +1,7 @@
+import uuid
 from pathlib import Path
 from typing import Optional
 
-from cfut.util import random_string
-
 from fractal_server.app.runner.executors.slurm._slurm_config import (
     SlurmConfig,
 )
@@ -106,9 +105,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, ...]:

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

@@ -1,20 +1,9 @@
-# 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 sys
 import threading
 import time
+from concurrent.futures import Executor
 from concurrent.futures import Future
 from concurrent.futures import InvalidStateError
 from copy import copy
@@ -25,18 +14,18 @@ from typing import Optional
 from typing import Sequence
 
 import cloudpickle
-from cfut import SlurmExecutor
 
 from ....filenames import SHUTDOWN_FILENAME
 from ....task_files import get_task_file_paths
 from ....task_files import TaskFiles
 from ....versions import get_versions
+from ..._job_states import STATES_FINISHED
 from ...slurm._slurm_config import SlurmConfig
 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 FractalSlurmSSHWaitThread
 from fractal_server.app.runner.components import _COMPONENT_KEY_
 from fractal_server.app.runner.compress_folder import compress_folder
 from fractal_server.app.runner.exceptions import JobExecutionError
@@ -48,24 +37,31 @@ from fractal_server.logger import set_logger
 from fractal_server.ssh._fabric import FractalSSH
 from fractal_server.syringe import Inject
 
+
 logger = set_logger(__name__)
 
 
-class FractalSlurmSSHExecutor(SlurmExecutor):
+class FractalSlurmSSHExecutor(Executor):
     """
-    FractalSlurmSSHExecutor (inherits from cfut.SlurmExecutor)
+    Executor to submit SLURM jobs via SSH
+
+    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
 
-    FIXME: docstring
 
     Attributes:
         fractal_ssh: FractalSSH connection with custom lock
-        shutdown_file:
-        python_remote: Equal to `settings.FRACTAL_SLURM_WORKER_PYTHON`
-        wait_thread_cls: Class for waiting thread
         workflow_dir_local:
             Directory for both the cfut/SLURM and fractal-server files and logs
         workflow_dir_remote:
             Directory for both the cfut/SLURM and fractal-server files and logs
+        shutdown_file:
+        python_remote: Equal to `settings.FRACTAL_SLURM_WORKER_PYTHON`
+        wait_thread_cls: Class for waiting thread
         common_script_lines:
             Arbitrary script lines that will always be included in the
             sbatch script
@@ -82,10 +78,10 @@ class FractalSlurmSSHExecutor(SlurmExecutor):
     shutdown_file: str
     python_remote: str
 
-    wait_thread_cls = FractalSlurmWaitThread
+    wait_thread_cls = FractalSlurmSSHWaitThread
 
     common_script_lines: list[str]
-    slurm_account: Optional[str]
+    slurm_account: Optional[str] = None
 
     jobs: dict[str, tuple[Future, SlurmJob]]
     map_jobid_to_slurm_files_local: dict[str, tuple[str, str, str]]
@@ -1159,7 +1155,7 @@ class FractalSlurmSSHExecutor(SlurmExecutor):
             Path(tarfile_path_local).unlink()
 
         t_1 = time.perf_counter()
-        logger.info("[_get_subfolder_sftp] End - " f"elapsed: {t_1-t_0:.3f} s")
+        logger.info(f"[_get_subfolder_sftp] End - elapsed: {t_1 - t_0:.3f} s")
 
     def _prepare_sbatch_script(
         self,
@@ -1258,7 +1254,7 @@ class FractalSlurmSSHExecutor(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):
@@ -1295,8 +1291,6 @@ class FractalSlurmSSHExecutor(SlurmExecutor):
         (released under the MIT licence)
         """
 
-        from cfut.slurm import STATES_FINISHED
-
         logger.debug(
             f"[FractalSlurmSSHExecutor._jobs_finished] START ({job_ids=})"
         )
@@ -1387,6 +1381,6 @@ class FractalSlurmSSHExecutor(SlurmExecutor):
         t_end_handshake = time.perf_counter()
         logger.info(
             "[FractalSlurmSSHExecutor.ssh_handshake] END"
-            f" - elapsed: {t_end_handshake-t_start_handshake:.3f} s"
+            f" - elapsed: {t_end_handshake - t_start_handshake:.3f} s"
         )
         return remote_versions

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

@@ -1,3 +0,0 @@
-from .executor import SlurmExecutor
-
-__all__ = ["SlurmExecutor"]

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

@@ -1,8 +1,7 @@
 from subprocess import run  # nosec
 
-from cfut.slurm import STATES_FINISHED
-
 from ......logger import set_logger
+from ..._job_states import STATES_FINISHED
 
 
 logger = set_logger(__name__)

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,21 +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
@@ -27,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
@@ -43,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
@@ -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,7 +214,7 @@ class FractalSlurmExecutor(SlurmExecutor):
     workflow_dir_local: Path
     workflow_dir_remote: Path
     map_jobid_to_slurm_files: dict[str, tuple[str, str, str]]
-    slurm_account: Optional[str]
+    slurm_account: Optional[str] = None
     jobs: dict[str, tuple[Future, SlurmJob]]
 
     def __init__(
@@ -244,7 +239,13 @@ 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
@@ -1239,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):

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():