hpcflow-new2 0.2.0a188__py3-none-any.whl → 0.2.0a190__py3-none-any.whl

hpcflow/sdk/submission/shells/os_version.py

@@ -2,16 +2,17 @@
 Operating system information discovery helpers.
 """
 
-import os
+from __future__ import annotations
+from collections.abc import Mapping
 import platform
 import re
 import subprocess
-from typing import Dict, List, Optional
+from typing import Final
 
-DEFAULT_LINUX_RELEASE_FILE = "/etc/os-release"
+_DEFAULT_LINUX_RELEASE_FILE: Final = "/etc/os-release"
 
 
-def get_OS_info() -> Dict:
+def get_OS_info() -> Mapping[str, str]:
     """
     Get basic operating system version info.
     """
@@ -23,7 +24,7 @@ def get_OS_info() -> Dict:
     }
 
 
-def get_OS_info_windows() -> Dict:
+def get_OS_info_windows() -> Mapping[str, str]:
     """
     Get operating system version info: Windows version.
     """
@@ -31,10 +32,10 @@ def get_OS_info_windows() -> Dict:
 
 
 def get_OS_info_POSIX(
-    WSL_executable: Optional[List[str]] = None,
-    use_py: Optional[bool] = True,
-    linux_release_file: Optional[str] = None,
-) -> Dict:
+    WSL_executable: list[str] | None = None,
+    use_py: bool = True,
+    linux_release_file: str | None = None,
+) -> Mapping[str, str]:
     """
     Get operating system version info: POSIX version.
 
@@ -48,11 +49,11 @@ def get_OS_info_POSIX(
         when getting OS info in WSL on Windows, since we need to call the WSL executable.
     linux_release_file:
         If on Linux, record the name and version fields from this file.
-
     """
 
-    def try_subprocess_call(command):
+    def try_subprocess_call(*args: str) -> str:
         exc = None
+        command = [*WSL_exe, *args]
         try:
             proc = subprocess.run(
                 args=command,
@@ -63,23 +64,21 @@ def get_OS_info_POSIX(
         except Exception as err:
             exc = err
 
-        if proc.returncode != 0 or exc:
+        if proc.returncode or exc:
             raise RuntimeError(
                 f"Failed to get POSIX OS info. Command was: {command!r}. Subprocess "
                 f"exception was: {exc!r}. Stderr was: {proc.stderr!r}."
             )
-        else:
-            return proc.stdout
+        return proc.stdout
 
-    WSL_executable = WSL_executable or []
-    out = {}
+    WSL_exe = WSL_executable or []
+    out: dict[str, str] = {}
     if use_py:
         out.update(**get_OS_info())
-
     else:
-        OS_name = try_subprocess_call(WSL_executable + ["uname", "-s"]).strip()
-        OS_release = try_subprocess_call(WSL_executable + ["uname", "-r"]).strip()
-        OS_version = try_subprocess_call(WSL_executable + ["uname", "-v"]).strip()
+        OS_name = try_subprocess_call("uname", "-s").strip()
+        OS_release = try_subprocess_call("uname", "-r").strip()
+        OS_version = try_subprocess_call("uname", "-v").strip()
 
         out["OS_name"] = OS_name
         out["OS_release"] = OS_release
@@ -87,28 +86,30 @@ def get_OS_info_POSIX(
 
     if out["OS_name"] == "Linux":
         # get linux distribution name and version:
-        linux_release_file = linux_release_file or DEFAULT_LINUX_RELEASE_FILE
-        release_out = try_subprocess_call(WSL_executable + ["cat", linux_release_file])
+        linux_release_file = linux_release_file or _DEFAULT_LINUX_RELEASE_FILE
+        release_out = try_subprocess_call("cat", linux_release_file)
 
-        name_match = re.search(r"^NAME=\"(.*)\"", release_out, flags=re.MULTILINE)
-        if name_match:
-            lin_name = name_match.group(1)
-        else:
+        name_match = _NAME_RE.search(release_out)
+        if not name_match:
             raise RuntimeError(
                 f"Failed to get Linux distribution name from file `{linux_release_file}`."
             )
+        lin_name: str = name_match[1]
 
-        version_match = re.search(r"^VERSION=\"(.*)\"", release_out, flags=re.MULTILINE)
-        if version_match:
-            lin_version = version_match.group(1)
-        else:
+        version_match = _VERSION_RE.search(release_out)
+        if not version_match:
             raise RuntimeError(
                 f"Failed to get Linux distribution version from file "
                 f"`{linux_release_file}`."
             )
+        lin_version: str = version_match[1]
 
         out["linux_release_file"] = linux_release_file
         out["linux_distribution_name"] = lin_name
         out["linux_distribution_version"] = lin_version
 
     return out
+
+
+_NAME_RE: Final = re.compile(r"^NAME=\"(.*)\"", flags=re.MULTILINE)
+_VERSION_RE: Final = re.compile(r"^VERSION=\"(.*)\"", flags=re.MULTILINE)

hpcflow/sdk/submission/shells/powershell.py

@@ -2,32 +2,40 @@
 Shell models based on Microsoft PowerShell.
 """
 
+from __future__ import annotations
 import subprocess
 from textwrap import dedent, indent
-from typing import Dict, List, Optional
+from typing import TYPE_CHECKING
+from typing_extensions import override
+from hpcflow.sdk.typing import hydrate
 from hpcflow.sdk.core import ABORT_EXIT_CODE
-from hpcflow.sdk.submission.shells import Shell
+from hpcflow.sdk.submission.shells.base import Shell
 from hpcflow.sdk.submission.shells.os_version import get_OS_info_windows
 
+if TYPE_CHECKING:
+    from typing import ClassVar
+    from .base import VersionInfo
 
+
+@hydrate
 class WindowsPowerShell(Shell):
     """Class to represent using PowerShell on Windows to generate and submit a jobscript."""
 
     # TODO: add snippets that can be used in demo task schemas?
 
     #: Default for executable name.
-    DEFAULT_EXE = "powershell.exe"
+    DEFAULT_EXE: ClassVar[str] = "powershell.exe"
 
     #: File extension for jobscripts.
-    JS_EXT = ".ps1"
+    JS_EXT: ClassVar[str] = ".ps1"
     #: Basic indent.
-    JS_INDENT = "    "
+    JS_INDENT: ClassVar[str] = "    "
     #: Indent for environment setup.
-    JS_ENV_SETUP_INDENT = 2 * JS_INDENT
+    JS_ENV_SETUP_INDENT: ClassVar[str] = 2 * JS_INDENT
     #: Template for the jobscript shebang line.
-    JS_SHEBANG = ""
+    JS_SHEBANG: ClassVar[str] = ""
     #: Template for the common part of the jobscript header.
-    JS_HEADER = dedent(
+    JS_HEADER: ClassVar[str] = dedent(
         """\
         function {workflow_app_alias} {{
             & {{
@@ -71,7 +79,7 @@ class WindowsPowerShell(Shell):
     """
     )
     #: Template for the jobscript header when directly executed.
-    JS_DIRECT_HEADER = dedent(
+    JS_DIRECT_HEADER: ClassVar[str] = dedent(
         """\
         {shebang}
 
@@ -80,7 +88,7 @@ class WindowsPowerShell(Shell):
     """
     )
     #: Template for the jobscript body.
-    JS_MAIN = dedent(
+    JS_MAIN: ClassVar[str] = dedent(
         """\
         $elem_EAR_IDs = get_nth_line $EAR_ID_FILE $JS_elem_idx
         $elem_run_dirs = get_nth_line $ELEM_RUN_DIR_FILE $JS_elem_idx
@@ -101,7 +109,6 @@ class WindowsPowerShell(Shell):
             $exc_sk = $LASTEXITCODE
 
             if ($exc_sk -eq 0) {{
-            
                 if ($skip -eq "1") {{
                     continue
                 }}
@@ -120,7 +127,7 @@ class WindowsPowerShell(Shell):
                     $exit_code = If ($exc_wc -ne 0) {{$exc_wc}} Else {{$exc_se}}
                 }}
             }}
-            else {{ 
+            else {{
                 $exit_code = $exc_sk
             }}
             $global:LASTEXITCODE = $null
@@ -130,7 +137,7 @@ class WindowsPowerShell(Shell):
     """
     )
     #: Template for the element processing loop in a jobscript.
-    JS_ELEMENT_LOOP = dedent(
+    JS_ELEMENT_LOOP: ClassVar[str] = dedent(
         """\
         for ($JS_elem_idx = 0; $JS_elem_idx -lt {num_elements}; $JS_elem_idx += 1) {{
         {main}
@@ -139,14 +146,12 @@ class WindowsPowerShell(Shell):
     """
     )
 
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-
-    def get_direct_submit_command(self, js_path) -> List[str]:
+    def get_direct_submit_command(self, js_path: str) -> list[str]:
         """Get the command for submitting a non-scheduled jobscript."""
-        return self.executable + ["-File", js_path]
+        return [*self.executable, "-File", js_path]
 
-    def get_version_info(self, exclude_os: Optional[bool] = False) -> Dict:
+    @override
+    def get_version_info(self, exclude_os: bool = False) -> VersionInfo:
         """Get powershell version information.
 
         Parameters
@@ -166,30 +171,29 @@ class WindowsPowerShell(Shell):
         else:
             raise RuntimeError("Failed to parse PowerShell version information.")
 
-        out = {
+        osinfo = {} if exclude_os else get_OS_info_windows()
+        return {
             "shell_name": "powershell",
             "shell_executable": self.executable,
             "shell_version": PS_version,
+            **osinfo,
         }
 
-        if not exclude_os:
-            out.update(**get_OS_info_windows())
-
-        return out
-
     @staticmethod
-    def process_app_invoc_executable(app_invoc_exe):
+    def process_app_invoc_executable(app_invoc_exe: str) -> str:
         if " " in app_invoc_exe:
             # use call operator and single-quote the executable path:
             app_invoc_exe = f"& '{app_invoc_exe}'"
         return app_invoc_exe
 
-    def format_stream_assignment(self, shell_var_name, command):
+    @override
+    def format_stream_assignment(self, shell_var_name: str, command: str) -> str:
         """
         Produce code to assign the output of the command to a shell variable.
         """
         return f"${shell_var_name} = {command}"
 
+    @override
     def format_save_parameter(
         self,
         workflow_app_alias: str,
@@ -198,7 +202,7 @@ class WindowsPowerShell(Shell):
         EAR_ID: int,
         cmd_idx: int,
         stderr: bool,
-    ):
+    ) -> str:
         """
         Produce code to save a parameter's value into the workflow persistent store.
         """
@@ -213,7 +217,10 @@ class WindowsPowerShell(Shell):
             f"\n"
         )
 
-    def format_loop_check(self, workflow_app_alias: str, loop_name: str, run_ID: int):
+    @override
+    def format_loop_check(
+        self, workflow_app_alias: str, loop_name: str, run_ID: int
+    ) -> str:
         """
         Produce code to check the looping status of part of a workflow.
         """
@@ -225,6 +232,7 @@ class WindowsPowerShell(Shell):
             f"\n"
         )
 
+    @override
     def wrap_in_subshell(self, commands: str, abortable: bool) -> str:
         """Format commands to run within a child scope.