resubmit 0.0.2__tar.gz → 0.0.4__tar.gz

resubmit-0.0.4/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: resubmit
+Version: 0.0.4
+Summary: Small wrapper around submitit to simplify cluster submissions
+Author: Amir Mehrpanah
+License: MIT
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: submitit>=0.8
+Provides-Extra: debug
+Requires-Dist: debugpy; extra == "debug"
+Dynamic: license-file
+
+# resubmit
+
+Small utility library to simplify job submission with Submitit on SLURM clusters.
+
+Quick usage:
+
+- Install locally for development:
+
+```bash
+pip install -e .[debug]
+```
+
+- Use in your project:
+
+```python
+from resubmit import submit_jobs, maybe_attach_debugger
+
+# attach remote debugger if requested
+maybe_attach_debugger(args.get("port", None))
+
+# submit jobs (list of dicts)
+submit_jobs(jobs_list, my_entrypoint, timeout_min=60, block=True)
+```
+
+## API
+
+### submit_jobs(...) 🔧
+
+Submit multiple jobs to a Slurm cluster using Submitit.
+
+Signature (short):
+
+`submit_jobs(jobs_args: Iterable[dict], func: Callable[[List[dict]], Any], *, timeout_min: int, cpus_per_task: int = 16, mem_gb: int = 64, num_gpus: int = 1, account: Optional[str] = None, folder: str = "logs/%j", block: bool = False, prompt: bool = True, local_run: bool = False, slurm_additional_parameters: Optional[Dict] = None, constraint: Optional[str] = None, reservation: Optional[str] = None)`
+
+- `jobs_args`: iterable of per-job kwargs (each item is passed to `func`).
+- `func`: entrypoint called for each job (should accept a list or single job dict depending on your usage).
+- `timeout_min`, `cpus_per_task`, `mem_gb`, `num_gpus`: common Slurm resources.
+- `account`: optional Slurm account name.
+- `folder`: logs folder for Submitit files (supports `%j` for job id).
+- `block`: if True, waits for all jobs and returns results.
+- `prompt`: if True, asks for confirmation interactively; set to `False` for CI or tests.
+- `local_run`: run the jobs locally without Submitit (useful for debugging).
+- `slurm_additional_parameters`: pass any extra Slurm key/value pairs to Submitit.
+- `constraint` / `reservation`: cluster-specific options kept out of defaults — provide them explicitly if you need them (they take precedence over values in `slurm_additional_parameters`).
+
+Example:
+
+```python
+submit_jobs(
+    jobs_list,
+    my_entrypoint,
+    timeout_min=60,
+    num_gpus=2,
+    prompt=False,
+    constraint="gpu",
+)
+```
+
+### maybe_attach_debugger(port: Optional[int]) 🐞
+
+Attach `debugpy` to the job when `port` is provided (> 0). Safe no-op if `port` is `None` or `<= 0`.
+
+- If `debugpy` (and `submitit`) are not available on the node, a `RuntimeError` is raised with an explanatory message.
+
+Example:
+
+```python
+# attach remote debugger only when a port is provided (e.g., from CLI args)
+maybe_attach_debugger(args.get("port"))
+```
+
+---
+
+Tips:
+- Use `prompt=False` when calling `submit_jobs` from scripts or CI to avoid interactive prompts.
+- Tests demonstrate non-interactive behavior (`prompt=False`) and optional `constraint`/`reservation` handling.

resubmit-0.0.4/README.md

@@ -0,0 +1,76 @@
+# resubmit
+
+Small utility library to simplify job submission with Submitit on SLURM clusters.
+
+Quick usage:
+
+- Install locally for development:
+
+```bash
+pip install -e .[debug]
+```
+
+- Use in your project:
+
+```python
+from resubmit import submit_jobs, maybe_attach_debugger
+
+# attach remote debugger if requested
+maybe_attach_debugger(args.get("port", None))
+
+# submit jobs (list of dicts)
+submit_jobs(jobs_list, my_entrypoint, timeout_min=60, block=True)
+```
+
+## API
+
+### submit_jobs(...) 🔧
+
+Submit multiple jobs to a Slurm cluster using Submitit.
+
+Signature (short):
+
+`submit_jobs(jobs_args: Iterable[dict], func: Callable[[List[dict]], Any], *, timeout_min: int, cpus_per_task: int = 16, mem_gb: int = 64, num_gpus: int = 1, account: Optional[str] = None, folder: str = "logs/%j", block: bool = False, prompt: bool = True, local_run: bool = False, slurm_additional_parameters: Optional[Dict] = None, constraint: Optional[str] = None, reservation: Optional[str] = None)`
+
+- `jobs_args`: iterable of per-job kwargs (each item is passed to `func`).
+- `func`: entrypoint called for each job (should accept a list or single job dict depending on your usage).
+- `timeout_min`, `cpus_per_task`, `mem_gb`, `num_gpus`: common Slurm resources.
+- `account`: optional Slurm account name.
+- `folder`: logs folder for Submitit files (supports `%j` for job id).
+- `block`: if True, waits for all jobs and returns results.
+- `prompt`: if True, asks for confirmation interactively; set to `False` for CI or tests.
+- `local_run`: run the jobs locally without Submitit (useful for debugging).
+- `slurm_additional_parameters`: pass any extra Slurm key/value pairs to Submitit.
+- `constraint` / `reservation`: cluster-specific options kept out of defaults — provide them explicitly if you need them (they take precedence over values in `slurm_additional_parameters`).
+
+Example:
+
+```python
+submit_jobs(
+    jobs_list,
+    my_entrypoint,
+    timeout_min=60,
+    num_gpus=2,
+    prompt=False,
+    constraint="gpu",
+)
+```
+
+### maybe_attach_debugger(port: Optional[int]) 🐞
+
+Attach `debugpy` to the job when `port` is provided (> 0). Safe no-op if `port` is `None` or `<= 0`.
+
+- If `debugpy` (and `submitit`) are not available on the node, a `RuntimeError` is raised with an explanatory message.
+
+Example:
+
+```python
+# attach remote debugger only when a port is provided (e.g., from CLI args)
+maybe_attach_debugger(args.get("port"))
+```
+
+---
+
+Tips:
+- Use `prompt=False` when calling `submit_jobs` from scripts or CI to avoid interactive prompts.
+- Tests demonstrate non-interactive behavior (`prompt=False`) and optional `constraint`/`reservation` handling.

{resubmit-0.0.2 → resubmit-0.0.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "resubmit"
-version = "0.0.2"
+version = "0.0.4"
 description = "Small wrapper around submitit to simplify cluster submissions"
 readme = "README.md"
 license = { text = "MIT" }

resubmit-0.0.4/src/resubmit/__bookkeeping.py

@@ -0,0 +1,223 @@
+import re
+from typing import Any, Dict, List, Tuple, Union, Optional, Iterable
+import pandas as pd
+from itertools import product
+import logging
+
+
+def _is_regex_spec(val: Any) -> bool:
+    """Return True if val looks like a regex specifier.
+
+    Accepted forms:
+    - compiled `re.Pattern`
+    - tuple (`re.Pattern`, exclude: bool)
+    - dict with keys `pattern` (re.Pattern) and optional `exclude` (bool)
+    - string starting with 're:' (e.g. 're:^foo.*') meaning include matches
+    - string starting with '!re:' meaning exclude matches
+    """
+    if hasattr(val, "search") and callable(val.search):
+        return True
+    if isinstance(val, tuple) and len(val) >= 1 and hasattr(val[0], "search"):
+        return True
+    if isinstance(val, dict) and "pattern" in val:
+        return True
+    if isinstance(val, str) and (val.startswith("re:") or val.startswith("!re:")):
+        return True
+    return False
+
+
+def _normalize_regex_spec(val: Any) -> Tuple[re.Pattern, bool]:
+    """Return (compiled_pattern, exclude_flag) for a given regex spec.
+
+    Raises ValueError for unsupported types.
+    """
+    if hasattr(val, "search") and callable(val.search):
+        return val, False
+    if isinstance(val, tuple) and len(val) >= 1:
+        pat = val[0]
+        exclude = bool(val[1]) if len(val) > 1 else False
+        return pat, exclude
+    if isinstance(val, dict):
+        pat = val["pattern"]
+        exclude = bool(val.get("exclude", False))
+        return pat, exclude
+    if isinstance(val, str):
+        if val.startswith("!re:"):
+            return re.compile(val[4:]), True
+        elif val.startswith("re:"):
+            return re.compile(val[3:]), False
+    raise ValueError(f"Unsupported regex spec: {val!r}")
+
+
+def ensure_unique_combinations(
+    df: pd.DataFrame, cols: Union[str, List[str]], raise_on_conflict: bool = True
+) -> Tuple[bool, Optional[pd.DataFrame]]:
+    """Check that combinations of columns `cols` are unique across `df`.
+
+    Returns (is_unique, duplicates_df) where `duplicates_df` is None when unique.
+    If `raise_on_conflict` is True, raises `ValueError` when duplicates are found.
+    """
+    if isinstance(cols, str):
+        cols = [cols]
+    # Stringify to avoid dtype mismatch effects
+    key_series = df[cols].astype(str).agg("||".join, axis=1)
+    nunique = key_series.nunique()
+    if nunique == len(df):
+        return True, None
+
+    duplicates = df[key_series.duplicated(keep=False)]
+    if raise_on_conflict:
+        raise ValueError(
+            f"Found {len(duplicates)} rows with non-unique combinations for cols={cols}."
+        )
+    return False, duplicates
+
+
+def create_jobs_dataframe(params: Dict[str, Any]) -> pd.DataFrame:
+    """Create a job DataFrame from a parameter map.
+
+    Rules:
+    - For parameters whose values are iterable (lists, tuples), we build the Cartesian
+      product across all such parameters.
+    - If a parameter value is callable, it is evaluated AFTER the initial DataFrame
+      is created; the callable is called as `col_values = fn(df)` and the result is
+      used as the column values (must be same length as `df`).
+    - If a parameter value is a regex spec (see `_is_regex_spec`), it is applied LAST
+      as a filter on the generated DataFrame. Regex specs can be used to include or
+      exclude rows based on the stringified value of that column.
+
+    Returns a filtered DataFrame with the applied callables and regex filters.
+    """
+    # Separate static values (used for product), callables and regex specs
+    static_items = {}
+    callables: Dict[str, Any] = {}
+    regex_specs: Dict[str, Any] = {}
+    unique_items: Dict[str, Any] = {}
+
+    for k, v in params.items():
+        # support explicit regex keys like 'name__regex' or 'name_regex' to filter 'name'
+        if k.endswith("__regex") or k.endswith("_regex"):
+            if k.endswith("__regex"):
+                base = k[: -len("__regex")]
+            else:
+                base = k[: -len("_regex")]
+            regex_specs[base] = v
+        elif k.endswith("__callable") or k.endswith("_callable"):
+            if k.endswith("__callable"):
+                base = k[: -len("__callable")]
+            else:
+                base = k[: -len("_callable")]
+            callables[base] = v
+        elif k.endswith("__unique") or k.endswith("_unique"):
+            if k.endswith("__unique"):
+                base = k[: -len("__unique")]
+            else:
+                base = k[: -len("_unique")]
+            unique_items[base] = v
+            continue
+        elif callable(v):
+            callables[k] = v
+        elif _is_regex_spec(v):
+            # treat a regex spec provided under the same key as a filter for that column
+            regex_specs[k] = v
+        else:
+            static_items[k] = v
+
+    # If there are no static items, start from single-row DataFrame so callables
+    # can still compute columns.
+    if len(static_items) == 0:
+        df = pd.DataFrame([{}])
+    else:
+        df = pd.DataFrame(
+            list(product(*static_items.values())), columns=static_items.keys()
+        )
+
+    # Apply callables (they must accept the dataframe and return a list-like)
+    for k, fn in callables.items():
+        vals = fn(df)
+        if len(vals) != len(df):
+            raise ValueError(
+                f"Callable for param {k!r} returned length {len(vals)} != {len(df)}"
+            )
+        df[k] = vals
+
+    # Apply regex specs last as filters
+    if len(regex_specs) > 0:
+        mask = pd.Series([True] * len(df), index=df.index)
+        for k, spec in regex_specs.items():
+            pat, exclude = _normalize_regex_spec(spec)
+            col_str = df[k].astype(str)
+            matches = col_str.apply(lambda s: bool(pat.search(s)))
+            if exclude:
+                mask = mask & ~matches
+            else:
+                mask = mask & matches
+        df = df[mask].reset_index(drop=True)
+
+    # apply unique constraints
+    for k, unique_val in unique_items.items():
+        is_unique, duplicates = ensure_unique_combinations(
+            df,
+            k,
+            raise_on_conflict=unique_val,
+        )
+        if not is_unique:
+            logging.warning(f"Non-unique values found for column {k!r}:\n{duplicates}")
+
+    return df
+
+
+def submit_jobs(
+    jobs_args: dict[Iterable],
+    func: Any,
+    *,
+    timeout_min: int,
+    cpus_per_task: int = 16,
+    mem_gb: int = 64,
+    num_gpus: int = 1,
+    folder: str = "logs/%j",
+    block: bool = False,
+    prompt: bool = True,
+    local_run: bool = False,
+    slurm_additional_parameters: Dict | None = None,
+) -> Any:
+    """
+    Submit jobs described by `jobs_args` where each entry is a dict of kwargs for `func`.
+    A dataframe is created from cartesian product of parameter lists, with support for callables and regex filtering.
+    1. use `__unique' postfix in keys to enforce uniqueness.
+    2. use `__callable' postfix in keys to define callables for column values.
+    3. use `__regex' postfix in keys to define regex filters for columns.
+
+    Args:
+        jobs_args: dict of lists of job parameters.
+        func: Function to be submitted for each job.
+        timeout_min: Job timeout in minutes.
+        cpus_per_task: Number of CPUs per task.
+        mem_gb: Memory in GB.
+        num_gpus: Number of GPUs.
+        folder: Folder for logs.
+        block: Whether to block until jobs complete.
+        prompt: Whether to prompt for confirmation before submission.
+        local_run: If True, runs the function locally instead of submitting.
+        slurm_additional_parameters: Additional Slurm parameters as a dict. If not provided, defaults to {"gpus": num_gpus}.
+    Returns:
+        The result of `submit_jobs` from `.__submit`.
+    """
+
+    jobs_df = create_jobs_dataframe(jobs_args)
+    records = jobs_df.to_dict(orient="records")
+    from .__submit import submit_jobs as _submit_jobs
+
+    return _submit_jobs(
+        records,
+        func,
+        timeout_min=timeout_min,
+        cpus_per_task=cpus_per_task,
+        mem_gb=mem_gb,
+        num_gpus=num_gpus,
+        folder=folder,
+        block=block,
+        prompt=prompt,
+        local_run=local_run,
+        slurm_additional_parameters=slurm_additional_parameters,
+    )

resubmit-0.0.4/src/resubmit/__init__.py

@@ -0,0 +1,6 @@
+"""resubmit: small helpers around submitit for reproducible cluster submissions."""
+
+from .__debug import maybe_attach_debugger
+from .__bookkeeping import submit_jobs
+
+__all__ = ["submit_jobs", "maybe_attach_debugger"]

resubmit-0.0.2/src/resubmit/submit.py → resubmit-0.0.4/src/resubmit/__submit.py

@@ -1,4 +1,5 @@
 """Core submission utilities wrapping submitit."""
+
 from typing import Any, Callable, Iterable, List, Optional, Dict
 
 
@@ -7,20 +8,24 @@ def submit_jobs(
     func: Callable[[List[dict]], Any],
     *,
     timeout_min: int,
-    cpus_per_task: int = 16,
-    mem_gb: int = 64,
-    num_gpus: int = 1,
-    account: Optional[str] = None,
-    folder: str = "logs/%j",
-    block: bool = False,
-    prompt: bool = True,
-    local_run: bool = False,
+    cpus_per_task: int,
+    mem_gb: int,
+    num_gpus: int,
+    folder: str,
+    block: bool,
+    prompt: bool,
+    local_run: bool,
     slurm_additional_parameters: Optional[Dict] = None,
 ):
     """Submit jobs described by `jobs_args` where each entry is a dict of kwargs for `func`.
 
     - If `local_run` is True, the function is called directly: `func(jobs_args)`.
     - Otherwise, submits via submitit.AutoExecutor and returns job objects or, if `block` is True, waits and returns results.
+
+    Optional Slurm settings `constraint` and `reservation` can be provided via explicit
+    parameters (they take precedence) or by passing `slurm_additional_parameters`.
+    If not provided, they are omitted so the code is not tied to cluster-specific
+    defaults.
     """
     jobs_list = list(jobs_args) if not isinstance(jobs_args, list) else jobs_args
 
@@ -39,23 +44,17 @@ def submit_jobs(
             return
 
     import submitit
+
     print("submitting jobs")
     executor = submitit.AutoExecutor(folder=folder)
 
-    # default slurm params
+    # default slurm params (keep cluster-specific options out unless explicitly set)
     if slurm_additional_parameters is None:
-        slurm_additional_parameters = {
-            "constraint": "thin",
-            "reservation": "safe",
-            "gpus": num_gpus,
-        }
+        slurm_additional_parameters = {"gpus": num_gpus}
     else:
         slurm_additional_parameters = dict(slurm_additional_parameters)
         slurm_additional_parameters.setdefault("gpus", num_gpus)
 
-    if account is not None:
-        slurm_additional_parameters["account"] = account
-
     print("Slurm additional parameters:", slurm_additional_parameters)
 
     executor.update_parameters(

resubmit-0.0.4/src/resubmit.egg-info/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: resubmit
+Version: 0.0.4
+Summary: Small wrapper around submitit to simplify cluster submissions
+Author: Amir Mehrpanah
+License: MIT
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: submitit>=0.8
+Provides-Extra: debug
+Requires-Dist: debugpy; extra == "debug"
+Dynamic: license-file
+
+# resubmit
+
+Small utility library to simplify job submission with Submitit on SLURM clusters.
+
+Quick usage:
+
+- Install locally for development:
+
+```bash
+pip install -e .[debug]
+```
+
+- Use in your project:
+
+```python
+from resubmit import submit_jobs, maybe_attach_debugger
+
+# attach remote debugger if requested
+maybe_attach_debugger(args.get("port", None))
+
+# submit jobs (list of dicts)
+submit_jobs(jobs_list, my_entrypoint, timeout_min=60, block=True)
+```
+
+## API
+
+### submit_jobs(...) 🔧
+
+Submit multiple jobs to a Slurm cluster using Submitit.
+
+Signature (short):
+
+`submit_jobs(jobs_args: Iterable[dict], func: Callable[[List[dict]], Any], *, timeout_min: int, cpus_per_task: int = 16, mem_gb: int = 64, num_gpus: int = 1, account: Optional[str] = None, folder: str = "logs/%j", block: bool = False, prompt: bool = True, local_run: bool = False, slurm_additional_parameters: Optional[Dict] = None, constraint: Optional[str] = None, reservation: Optional[str] = None)`
+
+- `jobs_args`: iterable of per-job kwargs (each item is passed to `func`).
+- `func`: entrypoint called for each job (should accept a list or single job dict depending on your usage).
+- `timeout_min`, `cpus_per_task`, `mem_gb`, `num_gpus`: common Slurm resources.
+- `account`: optional Slurm account name.
+- `folder`: logs folder for Submitit files (supports `%j` for job id).
+- `block`: if True, waits for all jobs and returns results.
+- `prompt`: if True, asks for confirmation interactively; set to `False` for CI or tests.
+- `local_run`: run the jobs locally without Submitit (useful for debugging).
+- `slurm_additional_parameters`: pass any extra Slurm key/value pairs to Submitit.
+- `constraint` / `reservation`: cluster-specific options kept out of defaults — provide them explicitly if you need them (they take precedence over values in `slurm_additional_parameters`).
+
+Example:
+
+```python
+submit_jobs(
+    jobs_list,
+    my_entrypoint,
+    timeout_min=60,
+    num_gpus=2,
+    prompt=False,
+    constraint="gpu",
+)
+```
+
+### maybe_attach_debugger(port: Optional[int]) 🐞
+
+Attach `debugpy` to the job when `port` is provided (> 0). Safe no-op if `port` is `None` or `<= 0`.
+
+- If `debugpy` (and `submitit`) are not available on the node, a `RuntimeError` is raised with an explanatory message.
+
+Example:
+
+```python
+# attach remote debugger only when a port is provided (e.g., from CLI args)
+maybe_attach_debugger(args.get("port"))
+```
+
+---
+
+Tips:
+- Use `prompt=False` when calling `submit_jobs` from scripts or CI to avoid interactive prompts.
+- Tests demonstrate non-interactive behavior (`prompt=False`) and optional `constraint`/`reservation` handling.

{resubmit-0.0.2 → resubmit-0.0.4}/src/resubmit.egg-info/SOURCES.txt

@@ -1,13 +1,14 @@
 LICENSE
 README.md
 pyproject.toml
+src/resubmit/__bookkeeping.py
+src/resubmit/__debug.py
 src/resubmit/__init__.py
-src/resubmit/debug.py
-src/resubmit/slurm.py
-src/resubmit/submit.py
+src/resubmit/__submit.py
 src/resubmit.egg-info/PKG-INFO
 src/resubmit.egg-info/SOURCES.txt
 src/resubmit.egg-info/dependency_links.txt
 src/resubmit.egg-info/requires.txt
 src/resubmit.egg-info/top_level.txt
+tests/test_bookkeeping.py
 tests/test_resubmit.py

resubmit-0.0.4/tests/test_bookkeeping.py

@@ -0,0 +1,45 @@
+import re
+import pandas as pd
+from src.resubmit.__bookkeeping import create_jobs_dataframe, ensure_unique_combinations
+
+
+def test_create_jobs_basic():
+    params = {"a": [1, 2], "b": [10]}
+    df = create_jobs_dataframe(params)
+    assert len(df) == 2
+    assert set(df.columns) == {"a", "b"}
+
+
+def test_create_jobs_callable():
+    params = {"a": [1, 2], "b": lambda df: df["a"] * 10}
+    df = create_jobs_dataframe(params)
+    assert list(df["b"]) == [10, 20]
+
+
+def test_create_jobs_regex_include():
+    params = {"name": ["apple", "banana", "apricot"], "name__regex": re.compile(r"^a")}
+    df = create_jobs_dataframe(params)
+    assert set(df["name"]) == {"apple", "apricot"}
+
+
+def test_create_jobs_regex_exclude():
+    params = {"name": ["apple", "banana", "apricot"], "name_regex": "!re:^a"}
+    df = create_jobs_dataframe(params)
+    assert set(df["name"]) == {"banana"}
+
+
+def test_ensure_unique_combinations_raises():
+    df = pd.DataFrame({"a": [1, 1, 2], "b": [3, 3, 4]})
+    try:
+        ensure_unique_combinations(df, ["a", "b"], raise_on_conflict=True)
+        raised = False
+    except ValueError:
+        raised = True
+    assert raised
+
+
+def test_ensure_unique_combinations_ok():
+    df = pd.DataFrame({"a": [1, 2, 3], "b": [3, 4, 5]})
+    ok, dup = ensure_unique_combinations(df, ["a", "b"], raise_on_conflict=False)
+    assert ok
+    assert dup is None

resubmit-0.0.4/tests/test_resubmit.py

@@ -0,0 +1,117 @@
+import pytest
+from resubmit import maybe_attach_debugger
+from resubmit.__submit import submit_jobs 
+
+
+def dummy_func(jobs):
+    # return a list of strings to show behavior
+    return [f"ok-{j['id']}" for j in jobs]
+
+
+def test_submit_local_run():
+    jobs = [{"id": 1}, {"id": 2}]
+    res = submit_jobs(jobs, dummy_func, timeout_min=1, local_run=True)
+    assert res == ["ok-1", "ok-2"]
+
+
+def test_maybe_attach_debugger_noop():
+    # should not raise when port is None or 0
+    maybe_attach_debugger(None)
+    maybe_attach_debugger(0)
+
+
+def test_slurm_parameters_optional(monkeypatch):
+    events = {}
+
+    class DummyExecutor:
+        def __init__(self, folder):
+            events['folder'] = folder
+
+        def update_parameters(self, **kwargs):
+            # capture the parameters passed to the executor
+            events['update'] = kwargs
+
+        def map_array(self, func, jobs_list):
+            return []
+
+    class DummyModule:
+        AutoExecutor = DummyExecutor
+
+    import sys
+    monkeypatch.setitem(sys.modules, 'submitit', DummyModule)
+
+    jobs = [{"id": 1}]
+    # default: no constraint/reservation keys
+    submit_jobs(jobs, dummy_func, timeout_min=1, local_run=False, num_gpus=2, prompt=False)
+    slurm = events['update']['slurm_additional_parameters']
+    assert slurm['gpus'] == 2
+    assert 'constraint' not in slurm
+    assert 'reservation' not in slurm
+
+
+def test_slurm_parameters_settable(monkeypatch):
+    events = {}
+
+    class DummyExecutor:
+        def __init__(self, folder):
+            events['folder'] = folder
+
+        def update_parameters(self, **kwargs):
+            events['update'] = kwargs
+
+        def map_array(self, func, jobs_list):
+            return []
+
+    class DummyModule:
+        AutoExecutor = DummyExecutor
+
+    import sys
+    monkeypatch.setitem(sys.modules, 'submitit', DummyModule)
+
+    jobs = [{"id": 1}]
+    submit_jobs(
+        jobs,
+        dummy_func,
+        timeout_min=1,
+        local_run=False,
+        constraint='thin',
+        reservation='safe',
+        prompt=False,
+    )
+    slurm = events['update']['slurm_additional_parameters']
+    assert slurm['constraint'] == 'thin'
+    assert slurm['reservation'] == 'safe'
+
+
+def test_slurm_parameters_arg_precedence(monkeypatch):
+    events = {}
+
+    class DummyExecutor:
+        def __init__(self, folder):
+            events['folder'] = folder
+
+        def update_parameters(self, **kwargs):
+            events['update'] = kwargs
+
+        def map_array(self, func, jobs_list):
+            return []
+
+    class DummyModule:
+        AutoExecutor = DummyExecutor
+
+    import sys
+    monkeypatch.setitem(sys.modules, 'submitit', DummyModule)
+
+    jobs = [{"id": 1}]
+    # slurm_additional_parameters has constraint='foo' but explicit arg should override
+    submit_jobs(
+        jobs,
+        dummy_func,
+        timeout_min=1,
+        local_run=False,
+        slurm_additional_parameters={'constraint': 'foo'},
+        constraint='bar',
+        prompt=False,
+    )
+    slurm = events['update']['slurm_additional_parameters']
+    assert slurm['constraint'] == 'bar'

resubmit-0.0.2/PKG-INFO

@@ -1,36 +0,0 @@
-Metadata-Version: 2.4
-Name: resubmit
-Version: 0.0.2
-Summary: Small wrapper around submitit to simplify cluster submissions
-Author: Amir Mehrpanah
-License: MIT
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: submitit>=0.8
-Provides-Extra: debug
-Requires-Dist: debugpy; extra == "debug"
-Dynamic: license-file
-
-# resubmit
-
-Small utility library to simplify job submission with Submitit on SLURM clusters.
-
-Quick usage:
-
-- Install locally for development:
-
-```bash
-pip install -e .[debug]
-```
-
-- Use in your project:
-
-```python
-from resubmit import submit_jobs, maybe_attach_debugger
-
-# attach remote debugger if requested
-maybe_attach_debugger(args.get("port", None))
-
-# submit jobs (list of dicts)
-submit_jobs(jobs_list, my_entrypoint, timeout_min=60, block=True)
-```

resubmit-0.0.2/README.md

@@ -1,23 +0,0 @@
-# resubmit
-
-Small utility library to simplify job submission with Submitit on SLURM clusters.
-
-Quick usage:
-
-- Install locally for development:
-
-```bash
-pip install -e .[debug]
-```
-
-- Use in your project:
-
-```python
-from resubmit import submit_jobs, maybe_attach_debugger
-
-# attach remote debugger if requested
-maybe_attach_debugger(args.get("port", None))
-
-# submit jobs (list of dicts)
-submit_jobs(jobs_list, my_entrypoint, timeout_min=60, block=True)
-```

resubmit-0.0.2/src/resubmit/__init__.py

@@ -1,7 +0,0 @@
-"""resubmit: small helpers around submitit for reproducible cluster submissions."""
-
-from .submit import submit_jobs
-from .debug import maybe_attach_debugger
-from .slurm import make_default_slurm_params
-
-__all__ = ["submit_jobs", "maybe_attach_debugger", "make_default_slurm_params"]

resubmit-0.0.2/src/resubmit/slurm.py

@@ -1,10 +0,0 @@
-"""Small helpers for SLURM parameter construction."""
-
-
-from typing import Optional
-
-def make_default_slurm_params(gpus: int = 1, constraint: str = "thin", reservation: str = "safe", account: Optional[str] = None) -> dict:
-    params = {"constraint": constraint, "reservation": reservation, "gpus": gpus}
-    if account is not None:
-        params["account"] = account
-    return params

resubmit-0.0.2/src/resubmit.egg-info/PKG-INFO

@@ -1,36 +0,0 @@
-Metadata-Version: 2.4
-Name: resubmit
-Version: 0.0.2
-Summary: Small wrapper around submitit to simplify cluster submissions
-Author: Amir Mehrpanah
-License: MIT
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: submitit>=0.8
-Provides-Extra: debug
-Requires-Dist: debugpy; extra == "debug"
-Dynamic: license-file
-
-# resubmit
-
-Small utility library to simplify job submission with Submitit on SLURM clusters.
-
-Quick usage:
-
-- Install locally for development:
-
-```bash
-pip install -e .[debug]
-```
-
-- Use in your project:
-
-```python
-from resubmit import submit_jobs, maybe_attach_debugger
-
-# attach remote debugger if requested
-maybe_attach_debugger(args.get("port", None))
-
-# submit jobs (list of dicts)
-submit_jobs(jobs_list, my_entrypoint, timeout_min=60, block=True)
-```

resubmit-0.0.2/tests/test_resubmit.py

@@ -1,19 +0,0 @@
-import pytest
-from resubmit import submit_jobs, maybe_attach_debugger
-
-
-def dummy_func(jobs):
-    # return a list of strings to show behavior
-    return [f"ok-{j['id']}" for j in jobs]
-
-
-def test_submit_local_run():
-    jobs = [{"id": 1}, {"id": 2}]
-    res = submit_jobs(jobs, dummy_func, timeout_min=1, local_run=True)
-    assert res == ["ok-1", "ok-2"]
-
-
-def test_maybe_attach_debugger_noop():
-    # should not raise when port is None or 0
-    maybe_attach_debugger(None)
-    maybe_attach_debugger(0)