Unit tests for ShellLauncher & additional shell launch context

.github/workflows/run_tests.yml

@@ -158,14 +158,19 @@ jobs:
           echo "SMARTSIM_LOG_LEVEL=debug" >> $GITHUB_ENV
           py.test -s --import-mode=importlib -o log_cli=true --cov=$(smart site) --cov-report=xml --cov-config=./tests/test_configs/cov/local_cov.cfg --ignore=tests/full_wlm/ -m ${{ matrix.subset }} ./tests
 
+      - name: try zip the test result folder
+        if: failure()
+        run: |
+          zip -r testResult.zip tests/test_output
+
       # Upload artifacts on failure, ignoring binary files
       - name: Upload Artifact
         if: failure()
         uses: actions/upload-artifact@v3
         with:
           name: test_artifact
           path: |
-            tests/test_output
+            testResult.zip
             !**/*.so
             !**/*.pb
             !**/*.pt

pyproject.toml

@@ -147,7 +147,6 @@ module = [
   # FIXME: DO NOT MERGE THIS INTO DEVELOP BRANCH UNLESS THESE ARE PASSING OR
   #        REMOVED!!
   "smartsim._core._cli.*",
-  "smartsim._core.commands.*",
   "smartsim._core.control.controller",
   "smartsim._core.control.manifest",
   "smartsim._core.entrypoints.dragon_client",

smartsim/_core/commands/command.py

@@ -26,41 +26,60 @@
 
 import typing as t
 from collections.abc import MutableSequence
+from copy import deepcopy
 
-from ...settings.launchCommand import LauncherType
+from typing_extensions import Self
 
 
 class Command(MutableSequence[str]):
     """Basic container for command information"""
 
-    def __init__(self, launcher: LauncherType, command: t.List[str]) -> None:
+    def __init__(self, command: t.List[str]) -> None:
         """Command constructor"""
-        self._launcher = launcher
         self._command = command
 
-    @property
-    def launcher(self) -> LauncherType:
-        """Get the launcher type.
-        Return a reference to the LauncherType.
-        """
-        return self._launcher
-
     @property
     def command(self) -> t.List[str]:
         """Get the command list.
         Return a reference to the command list.
         """
         return self._command
 
-    def __getitem__(self, idx: int) -> str:
+    @t.overload
+    def __getitem__(self, idx: int) -> str: ...
+    @t.overload
+    def __getitem__(self, idx: slice) -> Self: ...
+    def __getitem__(self, idx: t.Union[int, slice]) -> t.Union[str, Self]:
         """Get the command at the specified index."""
-        return self._command[idx]
+        cmd = self._command[idx]
+        if isinstance(cmd, str):
+            return cmd
+        return type(self)(cmd)
 
-    def __setitem__(self, idx: int, value: str) -> None:
+    @t.overload
+    def __setitem__(self, idx: int, value: str) -> None: ...
+    @t.overload
+    def __setitem__(self, idx: slice, value: t.Iterable[str]) -> None: ...
+    def __setitem__(
+        self, idx: t.Union[int, slice], value: t.Union[str, t.Iterable[str]]
+    ) -> None:
         """Set the command at the specified index."""
-        self._command[idx] = value
+        if isinstance(idx, int):
+            if not isinstance(value, str):
+                raise ValueError(
+                    "Value must be of type `str` when assigning to an index"
+                )
+            self._command[idx] = deepcopy(value)
+        elif isinstance(idx, slice):
+            if not isinstance(value, list) or not all(
+                isinstance(item, str) for item in value
+            ):
+                raise ValueError(
+                    "Value must be a list of strings when assigning to a slice"
+                )
+            self._command[idx] = (deepcopy(val) for val in value)
 
-    def __delitem__(self, idx: int) -> None:
+    def __delitem__(self, idx: t.Union[int, slice]) -> None:
         """Delete the command at the specified index."""
         del self._command[idx]
 
@@ -73,6 +92,5 @@ def insert(self, idx: int, value: str) -> None:
         self._command.insert(idx, value)
 
     def __str__(self) -> str:  # pragma: no cover
-        string = f"\nLauncher: {self.launcher.value}\n"
-        string += f"Command: {' '.join(str(cmd) for cmd in self.command)}"
+        string = f"\nCommand: {' '.join(str(cmd) for cmd in self.command)}"
         return string

smartsim/_core/commands/commandList.py

@@ -26,6 +26,7 @@
 
 import typing as t
 from collections.abc import MutableSequence
+from copy import deepcopy
 
 from .command import Command
 
@@ -46,15 +47,45 @@ def commands(self) -> t.List[Command]:
         """
         return self._commands
 
-    def __getitem__(self, idx: int) -> Command:
+    @t.overload
+    def __getitem__(self, idx: int) -> Command: ...
+    @t.overload
+    def __getitem__(self, idx: slice) -> t.List[Command]: ...
+    def __getitem__(
+        self, idx: t.Union[slice, int]
+    ) -> t.Union[Command, t.List[Command]]:
         """Get the Command at the specified index."""
         return self._commands[idx]
 
-    def __setitem__(self, idx: int, value: Command) -> None:
-        """Set the Command at the specified index."""
-        self._commands[idx] = value
+    @t.overload
+    def __setitem__(self, idx: int, value: Command) -> None: ...
+    @t.overload
+    def __setitem__(self, idx: slice, value: t.Iterable[Command]) -> None: ...
+    def __setitem__(
+        self, idx: t.Union[int, slice], value: t.Union[Command, t.Iterable[Command]]
+    ) -> None:
+        """Set the Commands at the specified index."""
+        if isinstance(idx, int):
+            if not isinstance(value, Command):
+                raise ValueError(
+                    "Value must be of type `Command` when assigning to an index"
+                )
+            self._commands[idx] = deepcopy(value)
+        elif isinstance(idx, slice):
+            if not isinstance(value, list):
+                raise ValueError(
+                    "Value must be a list of Commands when assigning to a slice"
+                )
+            for sublist in value:
+                if not isinstance(sublist.command, list) or not all(
+                    isinstance(item, str) for item in sublist.command
+                ):
+                    raise ValueError(
+                        "Value sublists must be a list of Commands when assigning to a slice"
+                    )
+            self._commands[idx] = (deepcopy(val) for val in value)
 
-    def __delitem__(self, idx: int) -> None:
+    def __delitem__(self, idx: t.Union[int, slice]) -> None:
         """Delete the Command at the specified index."""
         del self._commands[idx]
 

smartsim/_core/dispatch.py

@@ -28,6 +28,7 @@
 
 import dataclasses
 import os
+import pathlib
 import typing as t
 
 from typing_extensions import Self, TypeAlias, TypeVarTuple, Unpack
@@ -42,10 +43,11 @@
     from smartsim.experiment import Experiment
     from smartsim.settings.arguments import LaunchArguments
 
+
 _Ts = TypeVarTuple("_Ts")
 
 
-_WorkingDirectory: TypeAlias = t.Union[str, os.PathLike[str]]
+_WorkingDirectory: TypeAlias = pathlib.Path
 """A working directory represented as a string or PathLike object"""
 
 _DispatchableT = t.TypeVar("_DispatchableT", bound="LaunchArguments")
@@ -62,15 +64,25 @@
 a job
 """
 _FormatterType: TypeAlias = t.Callable[
-    [_DispatchableT, "ExecutableProtocol", _WorkingDirectory, _EnvironMappingType],
+    [
+        _DispatchableT,
+        "ExecutableProtocol",
+        _WorkingDirectory,
+        _EnvironMappingType,
+        pathlib.Path,
+        pathlib.Path,
+    ],
     _LaunchableT,
 ]
 """A callable that is capable of formatting the components of a job into a type
 capable of being launched by a launcher.
 """
-_LaunchConfigType: TypeAlias = (
-    "_LauncherAdapter[ExecutableProtocol, _WorkingDirectory, _EnvironMappingType]"
-)
+_LaunchConfigType: TypeAlias = """_LauncherAdapter[
+        ExecutableProtocol,
+        _WorkingDirectory,
+        _EnvironMappingType,
+        pathlib.Path,
+        pathlib.Path]"""
 
 """A launcher adapater that has configured a launcher to launch the components
 of a job with some pre-determined launch settings
@@ -260,10 +272,12 @@ def create_adapter_from_launcher(
 
         def format_(
             exe: ExecutableProtocol,
-            path: str | os.PathLike[str],
+            path: pathlib.Path,
             env: _EnvironMappingType,
+            out: pathlib.Path,
+            err: pathlib.Path,
         ) -> _LaunchableT:
-            return self.formatter(arguments, exe, path, env)
+            return self.formatter(arguments, exe, path, env, out, err)
 
         return _LauncherAdapter(launcher, format_)
 

smartsim/_core/generation/generator.py

@@ -108,7 +108,16 @@ def _log_file(log_path: pathlib.Path) -> pathlib.Path:
         """
         return pathlib.Path(log_path) / "smartsim_params.txt"
 
-    def generate_job(self, job: Job, job_index: int) -> pathlib.Path:
+    def _output_files(
+        self, log_path: pathlib.Path, job_name: str
+    ) -> t.Tuple[pathlib.Path, pathlib.Path]:
+        out_file_path = log_path / (job_name + ".out")
+        err_file_path = log_path / (job_name + ".err")
+        return out_file_path, err_file_path
+
+    def generate_job(
+        self, job: Job, job_index: int
+    ) -> t.Tuple[pathlib.Path, pathlib.Path, pathlib.Path]:
         """Write and configure input files for a Job.
 
         To have files or directories present in the created Job
@@ -136,10 +145,17 @@ def generate_job(self, job: Job, job_index: int) -> pathlib.Path:
             dt_string = datetime.now().strftime("%d/%m/%Y %H:%M:%S")
             log_file.write(f"Generation start date and time: {dt_string}\n")
 
+        # Create output files
+        out_file, err_file = self._output_files(log_path, job.entity.name)
+        # Open and write to .out file
+        open(out_file, mode="w", encoding="utf-8")
+        # Open and write to .err file
+        open(err_file, mode="w", encoding="utf-8")
+
         # Perform file system operations on attached files
         self._build_operations(job, job_path)
 
-        return job_path
+        return job_path, out_file, err_file
 
     @classmethod
     def _build_operations(cls, job: Job, job_path: pathlib.Path) -> None:

smartsim/_core/launcher/dragon/dragonLauncher.py

@@ -27,6 +27,7 @@
 from __future__ import annotations
 
 import os
+import pathlib
 import typing as t
 
 from smartsim._core.schemas.dragonRequests import DragonRunPolicy
@@ -371,6 +372,8 @@ def _as_run_request_args_and_policy(
     exe: ExecutableProtocol,
     path: str | os.PathLike[str],
     env: t.Mapping[str, str | None],
+    stdout_path: pathlib.Path,
+    stderr_path: pathlib.Path,
 ) -> tuple[DragonRunRequestView, DragonRunPolicy]:
     # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
     # FIXME: This type is 100% unacceptable, but I don't want to spend too much
@@ -392,8 +395,8 @@ def _as_run_request_args_and_policy(
             env=env,
             # TODO: Not sure how this info is injected
             name=None,
-            output_file=None,
-            error_file=None,
+            output_file=stdout_path,
+            error_file=stderr_path,
             **run_args,
         ),
         policy,