resubmit 0.0.3__tar.gz → 0.0.5__tar.gz

{resubmit-0.0.3/src/resubmit.egg-info → resubmit-0.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: resubmit
-Version: 0.0.3
+Version: 0.0.5
 Summary: Small wrapper around submitit to simplify cluster submissions
 Author: Amir Mehrpanah
 License: MIT

{resubmit-0.0.3 → resubmit-0.0.5}/pyproject.toml

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

resubmit-0.0.5/src/resubmit/__bookkeeping.py

@@ -0,0 +1,197 @@
+import re
+from typing import Any, Dict, List, Tuple, Union, Optional, Iterable
+import pandas as pd
+from itertools import product
+import logging
+
+
+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
+        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
+
+    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.3 → resubmit-0.0.5}/src/resubmit/__init__.py

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

resubmit-0.0.3/src/resubmit/submit.py → resubmit-0.0.5/src/resubmit/__submit.py

@@ -1,23 +1,21 @@
 """Core submission utilities wrapping submitit."""
+
 from typing import Any, Callable, Iterable, List, Optional, Dict
 
 
-def submit_jobs(
+def _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,
+    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,
-    constraint: Optional[str] = None,
-    reservation: Optional[str] = None,
 ):
     """Submit jobs described by `jobs_args` where each entry is a dict of kwargs for `func`.
 
@@ -46,6 +44,7 @@ def submit_jobs(
             return
 
     import submitit
+
     print("submitting jobs")
     executor = submitit.AutoExecutor(folder=folder)
 
@@ -56,14 +55,6 @@ def submit_jobs(
         slurm_additional_parameters = dict(slurm_additional_parameters)
         slurm_additional_parameters.setdefault("gpus", num_gpus)
 
-    # Allow explicit overrides similar to `account`.
-    if account is not None:
-        slurm_additional_parameters["account"] = account
-    if reservation is not None:
-        slurm_additional_parameters["reservation"] = reservation
-    if constraint is not None:
-        slurm_additional_parameters["constraint"] = constraint
-
     print("Slurm additional parameters:", slurm_additional_parameters)
 
     executor.update_parameters(

{resubmit-0.0.3 → resubmit-0.0.5/src/resubmit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: resubmit
-Version: 0.0.3
+Version: 0.0.5
 Summary: Small wrapper around submitit to simplify cluster submissions
 Author: Amir Mehrpanah
 License: MIT

{resubmit-0.0.3 → resubmit-0.0.5}/src/resubmit.egg-info/SOURCES.txt

@@ -1,12 +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/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.5/tests/test_bookkeeping.py

@@ -0,0 +1,45 @@
+import re
+import pandas as pd
+from 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__callable": 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.5/tests/test_resubmit.py

@@ -0,0 +1,115 @@
+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,
+        num_gpus=0,
+        cpus_per_task=1,
+        mem_gb=8,
+        folder="dummy/%j",
+        block=False,
+        prompt=False,
+    )
+    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,
+        cpus_per_task=4,
+        mem_gb=16,
+        folder="logs/%j",
+        block=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,
+        prompt=False,
+        slurm_additional_parameters={
+            "constraint": "thin",
+            "reservation": "safe",
+        },
+        cpus_per_task=4,
+        mem_gb=16,
+        folder="logs/%j",
+        block=False,
+        num_gpus=1,
+    )
+    slurm = events["update"]["slurm_additional_parameters"]
+    assert slurm["constraint"] == "thin"
+    assert slurm["reservation"] == "safe"
+

resubmit-0.0.3/tests/test_resubmit.py

@@ -1,116 +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)
-
-
-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'