♻️ Cleanup of xtl.jobs.Job

xtl.jobs.config
- Abstraction of JobConfig to _BaseJobConfig
- JobConfig now holds configuration of multiple steps
- If `job_directory` is provided for a JobConfig, it will be propagated
  to all of its steps

xtl.jobs.config2
- BatchConfig now inherits from _BaseJobConfig

xtl.jobs.jobs:Job
- Removed all of the batch execution functionality, which is now handled
  by the compute site
- Logging of tracebacks upon exceptions in the .run() method are now
  toggleable with the option settings.jobs.tracebacks
- Fixed a bug where the config class was not properly propagated to new
  subclasses of BatchJob

xtl.jobs.jobs:BatchJob
- Positional arguments can now be passed to the shell when executing a
  BatchJob
- These can be passed as `batch_args` in the .with_config() method

xtl.config.settings
- Fixed a bug where the Settings class was not hashable
- Added option `tracebacks` to JobSettings

Author: dtriand

src/xtl/config/settings.py

@@ -51,6 +51,9 @@ class Settings(Options):
     #   instantiated without any input file. Any unknown options will then be stored
     #   in the model's `__pydantic_extra__` attribute.
 
+    # Make Settings hashable so that it can be used in sets or as dict keys
+    __hash__ = object.__hash__
+
 
 class UnitsSettings(Settings):
     """
@@ -141,6 +144,12 @@ class JobsSettings(Settings):
             desc='Default compute site for job execution'
         )
 
+    tracebacks: bool = \
+        Option(
+            default=False,
+            desc='Whether to include tracebacks in job logs when exceptions occur'
+        )
+
 
 class DependencySettings(Settings):
     """
@@ -178,7 +187,7 @@ class DependenciesSettings(Settings):
     resolution: str = \
         Option(
             default='loose',
-            choices=('strict', 'loose'),
+            choices={'strict', 'loose'},
             desc='Dependency resolution strategy. '
                  'If "strict", jobs requiring missing dependencies will fail to run. '
                  'If "loose", missing dependencies will be ignored.'

src/xtl/exceptions/base.py

@@ -54,3 +54,11 @@ def __init__(self, message: str, command: Any, raiser=None):
         self.message = message
         self.command = command
         self.raiser = raiser
+
+
+class StderrError(Error):
+
+    def __init__(self, message: str, stderr: str, raiser=None):
+        self.message = message
+        self.stderr = stderr
+        self.raiser = raiser

src/xtl/jobs/config.py

@@ -1,7 +1,8 @@
 from pathlib import Path
-from typing import Optional
+from typing import Optional, get_origin
 import tempfile
 from typing import TYPE_CHECKING
+from typing_extensions import TypedDict
 
 from pydantic import computed_field, PrivateAttr, model_validator
 
@@ -158,27 +159,73 @@ def get_batch(self) -> 'BatchFile':
         return batch
 
 
-class JobConfig(Options):
+# Setting total=False to make all keys optional during initialization
+#  NB: This needs to happen on every subclass of JobStepsConfig
+class JobStepsConfig(TypedDict, total=True):
     """
-    Base class for passing configuration to a job.
+    Base class for defining the steps of a job. Each key is the name of a step, and the value is the configuration for
+    that step, which must be a subclass of JobConfig.
     """
-    job_directory: Optional[Path] = Option(default=None,
-                                           desc='Directory for job execution and '
-                                                'results')
+    ...
 
-    # TODO: Remove all below when BatchJob/BatchJobConfig2 is fully implemented
-    batch: Optional[BatchConfig] = Option(default=None,
-                                          desc='Configuration for execution of batch'
-                                               'files')
 
-    _include_default_dependencies: bool = PrivateAttr(True)
-    """Whether to include the default dependencies in the job."""
+class _BaseJobConfig(Options):
+    """
+    Base class for job configuration, containing fields common to all jobs.
+    """
+
+    job_directory: Optional[Path] = \
+        Option(
+            default=None,
+            desc='Directory for job execution and results'
+        )
+
+
+class JobConfig(_BaseJobConfig):
+    """
+    Class for passing configuration to a job.
+    """
+
+    steps: JobStepsConfig = \
+        Option(
+            default_factory=JobStepsConfig,
+            desc='Configuration for each step of the job.'
+        )
+
+    def _get_steps_class(self) -> type[TypedDict]:
+        """
+        Get the class of the steps field.
+        """
+        # Get the `steps` field
+        step_field = self.model_fields.get('steps', None)
+        if step_field is None:
+            raise ValueError('JobConfig must have a steps field')
+
+        # Get the type of the `steps` field and ensure it's a simple type
+        #  Will raise for e.g. list[int], Union[str, int], etc.
+        StepsClass: type[TypedDict] = step_field.annotation
+        if get_origin(StepsClass) is not None:
+            raise TypeError(f'`steps` must be a simple type, not {StepsClass}')
+
+        return StepsClass
+
+    @property
+    def steps_list(self) -> list[str]:
+        """
+        Returns the list of steps in the job, in the order they are defined.
+        """
+        return list(self._get_steps_class().__annotations__.keys())
 
     @model_validator(mode='after')
     def _propagate_job_directory(self):
         """
         Propagate job_directory to batch.batch_directory if both are set
         """
-        if self.job_directory is not None and self.batch is not None:
-            self.batch.directory = self.job_directory
+        if self.job_directory:
+            for i, step in enumerate(self.steps_list):
+                config = self.steps.get(step, {})
+                if not hasattr(config, 'job_directory'):
+                    continue
+                config.job_directory = self.job_directory / f'{i+1}_{step}'
+
         return self

src/xtl/jobs/config2.py

@@ -10,7 +10,7 @@
 from xtl.common.serializers import PermissionOctal
 from xtl.common.validators import cast_as_temp_dir_if_none
 from xtl.jobs import Shell
-from xtl.jobs.config import JobConfig
+from xtl.jobs.config import _BaseJobConfig
 from xtl.jobs.sites import ComputeSite
 
 
@@ -21,26 +21,28 @@ class ResourcesConfig(Options):
 
     # TODO: Custom formatters & aliases for SLURM
     # TODO: Custom validators for SLURM-like input
+    # Formatting should be handled within different methods, e.g. to_slurm()
+    # Maybe we implement a _aliases and _formatters PrivateAttr in the ResourcesConfig for this purpose?
     cpus: int = \
         Option(
             default=1, ge=1,
             desc='Number of CPU cores required for the job',
-            alias='cpus-per-task'
+            # alias='cpus-per-task'
         )
 
     memory: float = \
         Option(
             default=1.0, ge=0.0,
             desc='Amount of memory (in GB) required for the job',
-            alias='mem',
-            formatter=lambda x: f'{x}G'
+            # alias='mem',
+            # formatter=lambda x: f'{x}G'
         )
 
     timeout: float | str | timedelta | None = \
         Option(
             default=None,
             desc='Maximum runtime for the job (in minutes or D-HH:MM:SS format)',
-            alias='time',
+            # alias='time',
             # cast_as=...,
             # formatter=...
         )
@@ -49,21 +51,20 @@ class ResourcesConfig(Options):
         Option(
             default=0, ge=0,
             desc='Number of GPUs required for the job',
-            alias='gpus'
         )
 
     no_tasks: int = \
         Option(
             default=1, ge=1,
             desc='Number of tasks required for the job (only used in MPI jobs)',
-            alias='ntasks'
+            # alias='ntasks'
         )
 
     no_nodes: int = \
         Option(
             default=1, ge=1,
             desc='Number of nodes required for the job (only used in MPI jobs)',
-            alias='nodes'
+            # alias='nodes'
         )
 
     def to_slurm(self) -> list[str]:
@@ -74,13 +75,14 @@ def to_slurm(self) -> list[str]:
         return args
 
 
-class BatchJobConfig(JobConfig):
+class BatchJobConfig(_BaseJobConfig):
 
-    # Generate a temporary directory if not provided
-    job_directory: Optional[Path] = Option(
-        default_factory=lambda: cast_as_temp_dir_if_none(None, prefix='xtl_batch_'),
-        desc='Directory for job execution and results',
-        cast_as=lambda x: cast_as_temp_dir_if_none(x, prefix='xtl_batch_'),
+    # Batch jobs always require a job directory
+    job_directory: Optional[Path] = \
+        Option(
+            default_factory=lambda: cast_as_temp_dir_if_none(None, prefix='xtl_batch_'),
+            desc='Directory for job execution and results',
+            cast_as=lambda x: cast_as_temp_dir_if_none(x, prefix='xtl_batch_'),
     )
     filename: str = \
         Option(