py-cluster-api 0.6.0__tar.gz → 0.7.0__tar.gz

{py_cluster_api-0.6.0 → py_cluster_api-0.7.0}/.github/workflows/ci.yml

@@ -23,7 +23,7 @@ jobs:
     - name: Set up Pixi
       uses: prefix-dev/setup-pixi@v0.9.0
       with:
-        pixi-version: v0.65.0
+        pixi-version: v0.70.2
         cache: true
 
     - name: Lint

{py_cluster_api-0.6.0 → py_cluster_api-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: py-cluster-api
-Version: 0.6.0
+Version: 0.7.0
 Summary: Generic Python library for running jobs on HPC clusters
 Project-URL: Homepage, https://github.com/JaneliaSciComp/py-cluster-api
 Project-URL: Repository, https://github.com/JaneliaSciComp/py-cluster-api

{py_cluster_api-0.6.0 → py_cluster_api-0.7.0}/cluster_api/core.py

@@ -82,14 +82,27 @@ class Executor(abc.ABC):
         epilogue: list[str] | None = None,
         env: dict[str, str] | None = None,
         metadata: dict[str, Any] | None = None,
+        inherit_env: bool = True,
+        login_shell: bool = False,
     ) -> JobRecord:
-        """Submit a job to the scheduler."""
+        """Submit a job to the scheduler.
+
+        Args:
+            inherit_env: When True (default), the job inherits the submitting
+                process's environment. When False, the job starts from a
+                minimal environment: only *env* plus scheduler-provided
+                variables reach the job.
+            login_shell: When True, the job runs under a login shell so the
+                target user's own profile builds the environment (PATH,
+                modules, conda), as if they had SSH'd to the node.
+        """
         resources = resources or ResourceSpec()
         full_name = _sanitize_job_name(f"{self._prefix}-{name}" if self._prefix else name)
 
         job_id, script_path = await self._submit_job(
             command, full_name, resources, prologue, epilogue, env,
             cwd=resources.work_dir,
+            inherit_env=inherit_env, login_shell=login_shell,
         )
 
         record = JobRecord(
@@ -117,6 +130,8 @@ class Executor(abc.ABC):
         env: dict[str, str] | None = None,
         metadata: dict[str, Any] | None = None,
         max_concurrent: int | None = None,
+        inherit_env: bool = True,
+        login_shell: bool = False,
     ) -> JobRecord:
         """Submit a job array to the scheduler."""
         resources = resources or ResourceSpec()
@@ -125,6 +140,7 @@ class Executor(abc.ABC):
         job_id, script_path = await self._submit_array_job(
             command, full_name, array_range, resources, prologue, epilogue,
             env, max_concurrent, cwd=resources.work_dir,
+            inherit_env=inherit_env, login_shell=login_shell,
         )
 
         meta = {**(metadata or {}), "array_range": array_range}
@@ -159,6 +175,8 @@ class Executor(abc.ABC):
         env: dict[str, str] | None = None,
         *,
         cwd: str | None = None,
+        inherit_env: bool = True,
+        login_shell: bool = False,
     ) -> tuple[str, str | None]:
         """Submit a single job.
 
@@ -179,10 +197,13 @@ class Executor(abc.ABC):
         max_concurrent: int | None = None,
         *,
         cwd: str | None = None,
+        inherit_env: bool = True,
+        login_shell: bool = False,
     ) -> tuple[str, str | None]:
         """Submit an array job. Override in subclasses."""
         return await self._submit_job(
             command, name, resources, prologue, epilogue, env, cwd=cwd,
+            inherit_env=inherit_env, login_shell=login_shell,
         )
 
     def _job_id_from_submit_output(self, out: str) -> str:

{py_cluster_api-0.6.0 → py_cluster_api-0.7.0}/cluster_api/executors/local.py

@@ -17,6 +17,22 @@ from ..script import render_script, write_script
 
 logger = logging.getLogger(__name__)
 
+# PATH for jobs that don't inherit the submitting process's environment;
+# mirrors what cron/sshd hand a fresh process. A login shell's profile will
+# prepend the user's own entries on top of this.
+_BASELINE_PATH = "/usr/local/bin:/usr/bin:/bin"
+
+# Identity and locale variables that describe the *user*, not the submitting
+# process, so they are safe to carry into a non-inheriting job.
+_BASELINE_KEYS = ("HOME", "USER", "LOGNAME", "SHELL", "LANG", "TERM")
+
+
+def _baseline_env(env: dict[str, str] | None) -> dict[str, str]:
+    """Minimal job environment for inherit_env=False submissions."""
+    base = {k: os.environ[k] for k in _BASELINE_KEYS if k in os.environ}
+    base["PATH"] = _BASELINE_PATH
+    return {**base, **(env or {})}
+
 
 class LocalExecutor(Executor):
     """Runs jobs as local bash subprocesses. Useful for testing."""
@@ -49,6 +65,8 @@ class LocalExecutor(Executor):
         env: dict[str, str] | None = None,
         *,
         cwd: str | None = None,
+        inherit_env: bool = True,
+        login_shell: bool = False,
     ) -> tuple[str, str | None]:
         """Render script, write to disk, run as a background subprocess."""
         header = self.build_header(name, resources)
@@ -58,13 +76,17 @@ class LocalExecutor(Executor):
         job_id = str(self._next_id)
         self._next_id += 1
 
-        full_env = {**os.environ, **(env or {})}
+        if inherit_env:
+            full_env = {**os.environ, **(env or {})}
+        else:
+            full_env = _baseline_env(env)
+        bash_cmd = ["bash", "-l", script_path] if login_shell else ["bash", script_path]
 
         # Write stdout/stderr directly to log files for real-time access
         stdout_dest, stderr_dest = self._open_output_files(resources, job_id=job_id)
 
         proc = await asyncio.create_subprocess_exec(
-            "bash", script_path,
+            *bash_cmd,
             stdout=stdout_dest,
             stderr=stderr_dest,
             env=full_env,
@@ -86,6 +108,8 @@ class LocalExecutor(Executor):
         max_concurrent: int | None = None,
         *,
         cwd: str | None = None,
+        inherit_env: bool = True,
+        login_shell: bool = False,
     ) -> tuple[str, str | None]:
         """Spawn one subprocess per array element with ARRAY_INDEX env var."""
         if max_concurrent is not None:
@@ -101,7 +125,11 @@ class LocalExecutor(Executor):
         job_id = str(self._next_id)
         self._next_id += 1
 
-        full_env = {**os.environ, **(env or {})}
+        if inherit_env:
+            full_env = {**os.environ, **(env or {})}
+        else:
+            full_env = _baseline_env(env)
+        bash_cmd = ["bash", "-l", script_path] if login_shell else ["bash", script_path]
 
         for index in range(array_range[0], array_range[1] + 1):
             element_env = {**full_env, "ARRAY_INDEX": str(index)}
@@ -109,7 +137,7 @@ class LocalExecutor(Executor):
                 resources, job_id=job_id, element_index=index,
             )
             proc = await asyncio.create_subprocess_exec(
-                "bash", script_path,
+                *bash_cmd,
                 stdout=stdout_dest,
                 stderr=stderr_dest,
                 env=element_env,

{py_cluster_api-0.6.0 → py_cluster_api-0.7.0}/cluster_api/executors/lsf.py

@@ -8,6 +8,7 @@ import json
 import logging
 import math
 import re
+import shlex
 from datetime import datetime, timezone
 from typing import Any
 
@@ -134,6 +135,33 @@ class LSFExecutor(Executor):
             args.extend(resources.extra_args)
         return args
 
+    @staticmethod
+    def _env_control_args(inherit_env: bool, login_shell: bool) -> list[str]:
+        """bsub args controlling the job's starting environment."""
+        args: list[str] = []
+        if not inherit_env:
+            # Don't copy the submitting process's environment into the job;
+            # it starts from scheduler-provided variables only.
+            args.extend(["-env", "none"])
+        if login_shell:
+            # Initialize the execution environment through the user's login
+            # shell, as an SSH session to the node would.
+            args.extend(["-L", "/bin/bash"])
+        return args
+
+    @staticmethod
+    def _env_prologue(env: dict[str, str] | None, inherit_env: bool,
+                      prologue: list[str] | None) -> list[str] | None:
+        """Fold explicit env vars into the script when bsub won't copy them.
+
+        With ``-env none`` the submission environment never reaches the job,
+        so variables passed via *env* must be exported by the script itself.
+        """
+        if inherit_env or not env:
+            return prologue
+        exports = [f"export {k}={shlex.quote(v)}" for k, v in env.items()]
+        return [*exports, *(prologue or [])]
+
     async def _bsub(
         self, script_path: str, env: dict[str, str] | None,
         extra_args: list[str] | None = None,
@@ -158,13 +186,17 @@ class LSFExecutor(Executor):
         env: dict[str, str] | None = None,
         *,
         cwd: str | None = None,
+        inherit_env: bool = True,
+        login_shell: bool = False,
     ) -> tuple[str, str | None]:
         """Render script, write to disk, submit via bsub."""
         header = self.build_header(name, resources)
+        prologue = self._env_prologue(env, inherit_env, prologue)
         script = render_script(self.config, command, header, prologue, epilogue)
         script_path = write_script(resources.work_dir, script, name, next(self._script_counter))
 
         extra_args = self._collect_extra_args(resources)
+        extra_args.extend(self._env_control_args(inherit_env, login_shell))
         out = await self._bsub(script_path, env, extra_args)
         return self._job_id_from_submit_output(out), script_path
 
@@ -180,9 +212,12 @@ class LSFExecutor(Executor):
         max_concurrent: int | None = None,
         *,
         cwd: str | None = None,
+        inherit_env: bool = True,
+        login_shell: bool = False,
     ) -> tuple[str, str | None]:
         """Render script, rewrite for array syntax, submit via bsub."""
         header = self.build_header(name, resources)
+        prologue = self._env_prologue(env, inherit_env, prologue)
         script = render_script(self.config, command, header, prologue, epilogue)
         script_path = write_script(resources.work_dir, script, name, next(self._script_counter))
 
@@ -206,20 +241,31 @@ class LSFExecutor(Executor):
             f.write(content)
 
         extra_args = self._collect_extra_args(resources)
+        extra_args.extend(self._env_control_args(inherit_env, login_shell))
         out = await self._bsub(script_path, env, extra_args)
         return self._job_id_from_submit_output(out), script_path
 
     def _build_status_args(self) -> list[str]:
-        """Build bjobs command with JSON output."""
+        """Build bjobs command with JSON output.
+
+        When jobs are being tracked, always query their IDs explicitly: LSF
+        resolves explicit job IDs across user boundaries, whereas a
+        name-filtered query (``-J``) returns only the calling user's jobs
+        without ``-u all`` — so polling other users' jobs through one user's
+        account would silently miss them. Combining ``-J`` with explicit IDs
+        is an intersection, which would hide any tracked job whose name does
+        not match the prefix, so the prefix filter is applied only when there
+        is nothing tracked yet; :meth:`reconnect` has its own query builder
+        for name-based discovery.
+        """
         args = [self.status_command]
         if self.config.poll_all_users:
             args.extend(["-u", "all"])
-        if self._prefix:
+        active_ids = [jid for jid, r in self._jobs.items() if not r.is_terminal]
+        if not active_ids and self._prefix:
             args.extend(["-J", f"{self._prefix}-*"])
         args.extend(["-a", "-o", _BJOBS_FIELDS, "-json"])
-        if not self._prefix:
-            active_ids = [jid for jid, r in self._jobs.items() if not r.is_terminal]
-            args.extend(active_ids)
+        args.extend(active_ids)
         return args
 
     def _parse_job_statuses(