subhaloscript 1.1.2__tar.gz → 1.1.4__tar.gz

{subhaloscript-1.1.2 → subhaloscript-1.1.4}/.claude/skills/galacticus-analysis/SKILL.md

@@ -3,9 +3,11 @@
 **SubScript** is a Python library providing ergonomic utility functions for analyzing Galacticus semi-analytic model outputs. 
 
 **Repository:** https://github.com/cgannonucm/SubScript
-**Package:** `subhaloscript` (v1.1.2)
+**Package:** `subhaloscript` (v1.1.4)
 **Author:** Charles Gannon (cgannon@ucmerced.edu)
 
+> **Note:** Refer to SubScript as a "library" (preferred), "package", or "toolkit" — never as an "API".
+
 ---
 
 ## Quick Start
@@ -223,7 +225,7 @@ nf.subhalos_valid(gout, mass_min=1e9, mass_max=1e12)   # All filters combined
 
 ### Filter Combinations
 
-Combine filters using boolean logic:
+Combine filters using boolean logic. `logical_and()` and `logical_or()` accept any number of positional arguments:
 
 ```python
 from subscript.scripts.nfilters import logical_and, logical_or, logical_not
@@ -234,9 +236,19 @@ combined = nf.logical_and(
     nf.r3d(None, 0, 0.05)  # Passing None "freezes" arguments
 )
 
+# AND: Three or more conditions as positional args
+combined3 = nf.logical_and(
+    nf.subhalos,
+    nf.r3d(None, 0, 0.05),
+    nf.interval(None, 1e9, 1e12, key=ParamKeys.mass_bound)
+)
+
 # OR: Either condition true
 either = nf.logical_or(filter1, filter2)
 
+# OR: Multiple conditions as positional args
+any_match = nf.logical_or(filter1, filter2, filter3)
+
 # NOT: Invert condition
 inverted = nf.logical_not(nf.subhalos)  # Select only host halos
 ```

{subhaloscript-1.1.2 → subhaloscript-1.1.4}/.claude/skills/galacticus-analysis/references/subscript_functions.md

@@ -1,8 +1,8 @@
 # SubScript Function Reference
 
-Complete documentation of all functions in the SubScript library (v1.1.2), organized by module.
+Complete documentation of all functions in the SubScript library (v1.1.4), organized by module.
 
-**Last Updated:** 2026-02-20
+**Last Updated:** 2026-02-23
 **Repository:** https://github.com/cgannonucm/SubScript
 
 ---
@@ -541,36 +541,53 @@ valid_mass = nodedata(gout, ParamKeys.mass_bound, nfilter=valid_filter)
 **Signature:**
 ```python
 def logical_and(arg1: (np.ndarray[bool] | Callable),
-                arg2: (np.ndarray[bool] | Callable)) → Callable
+                arg2: (np.ndarray[bool] | Callable),
+                *args: (np.ndarray[bool] | Callable)) → Callable
 ```
 
-**Description:** Create logical AND of two filters or boolean arrays.
+**Description:** Create logical AND of two or more filters or boolean arrays. Accepts any number of additional positional arguments.
+
+**Parameters:**
+- `arg1` (np.ndarray[bool] | Callable): First condition
+- `arg2` (np.ndarray[bool] | Callable): Second condition
+- `*args` (np.ndarray[bool] | Callable): Additional conditions to AND together
 
 ```python
-from subscript.scripts.nfilters import logical_and, subhalos, r3d
+from subscript.scripts.nfilters import logical_and, subhalos, r3d, interval
 
-# Combine filters
+# Combine two filters
 inner_subhalos = logical_and(subhalos, r3d(None, 0, 0.1))
 mass = nodedata(gout, ParamKeys.mass_bound, nfilter=inner_subhalos)
 
-# Combine arrays
-array_and = logical_and(bool_array1, bool_array2)
+# Combine three or more filters as positional args
+combined = logical_and(
+    subhalos,
+    r3d(None, 0, 0.1),
+    interval(None, 1e9, 1e12, key=ParamKeys.mass_bound)
+)
 ```
 
 **Notes:**
 - Works with both callables (filters) and arrays
 - Returns callable that can be used as `nfilter`
-- Implements: `arg1(...) & arg2(...)`
+- Raises `ValueError` if argument shapes mismatch
+- Implements: `arg1(...) & arg2(...) & args[0](...) & ...`
 
 #### logical_or()
 
 **Signature:**
 ```python
 def logical_or(arg1: (np.ndarray[bool] | Callable),
-               arg2: (np.ndarray[bool] | Callable)) → Callable
+               arg2: (np.ndarray[bool] | Callable),
+               *args: (np.ndarray[bool] | Callable)) → Callable
 ```
 
-**Description:** Create logical OR of two filters or boolean arrays.
+**Description:** Create logical OR of two or more filters or boolean arrays. Accepts any number of additional positional arguments.
+
+**Parameters:**
+- `arg1` (np.ndarray[bool] | Callable): First condition
+- `arg2` (np.ndarray[bool] | Callable): Second condition
+- `*args` (np.ndarray[bool] | Callable): Additional conditions to OR together
 
 ```python
 # Nodes either in inner region OR above mass threshold
@@ -578,8 +595,16 @@ inner_or_massive = logical_or(
     r3d(None, 0, 0.05),
     interval(None, 1e11, np.inf, key=ParamKeys.mass_bound)
 )
+
+# Three or more conditions as positional args
+any_match = logical_or(filter1, filter2, filter3, filter4)
 ```
 
+**Notes:**
+- Works with both callables (filters) and arrays
+- Returns callable that can be used as `nfilter`
+- Raises `ValueError` if argument shapes mismatch
+
 #### logical_not()
 
 **Signature:**

{subhaloscript-1.1.2 → subhaloscript-1.1.4}/.claude/skills/update/SKILL.md

@@ -24,19 +24,22 @@ When invoked, this skill will:
    - Also update the Summary Table at the bottom of that file
    - If the function fits an existing section in `SKILL.md`, add a usage snippet there too
 6. **Update the `Last Updated` date** and version number at the top of `subscript_functions.md`
-7. **Install package** in the `.venv` virtual environment:
+7. **If new features were detected** (new functions, new parameters, changed signatures), ask the user via `AskUserQuestion`:
+   - "Yes" — write tests for the new features in the appropriate `tests/test_*.py` file, following the existing test style (mock data dicts, `numpy.testing.assert_equal`, etc.)
+   - "No" — skip test writing
+8. **Install package** in the `.venv` virtual environment:
    ```bash
    .venv/bin/python -m pip install -e .
    ```
-8. **Run tests** to verify everything passes:
+9. **Run tests** to verify everything passes:
    ```bash
    .venv/bin/python -m pytest
    ```
    - If any tests fail, fix the issues before proceeding to commit
-9. **Draft a commit message** and present it to the user using `AskUserQuestion`, offering options:
-   - "Use as-is" — commit with the drafted message
-   - "Edit message" — let the user provide a custom message
-10. **Stage and commit** all changed files with the finalized message
+10. **Draft a commit message** and present it to the user using `AskUserQuestion`, offering options:
+    - "Use as-is" — commit with the drafted message
+    - "Edit message" — let the user provide a custom message
+11. **Stage and commit** all changed files with the finalized message
 
 ## Files Updated
 
@@ -112,6 +115,15 @@ You can then push to GitHub:
 git push
 ```
 
+## Test Writing
+
+When the user opts to write tests for new features:
+
+- Add tests to the existing `tests/test_<module>.py` file that corresponds to the changed module (e.g., changes in `nfilters.py` → `tests/test_nfilters.py`)
+- Follow the existing test style: mock data dicts, `numpy.testing.assert_equal`, simple assertions
+- Test new parameters, new functions, and edge cases (e.g., shape mismatches raising `ValueError`)
+- Include the new test file in the staged files for the commit
+
 ## Implementation Notes
 
 - Current version is read from `pyproject.toml` (source of truth)

{subhaloscript-1.1.2 → subhaloscript-1.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: subhaloscript
-Version: 1.1.2
+Version: 1.1.4
 Summary: Utility functions for analyzing subhalo distributions.
 Author-email: Charles Gannon <cgannon@ucmerced.edu>
 License-File: LICENSE

{subhaloscript-1.1.2 → subhaloscript-1.1.4}/meta.yaml

@@ -1,6 +1,6 @@
 package:
   name: subhaloscript
-  version: "1.1.2"
+  version: "1.1.4"
 
 source:
   path: .  # Or use `git_url`/`url` if not building from local files

{subhaloscript-1.1.2 → subhaloscript-1.1.4}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "hatchling.build"
 [project]
 dependencies = ["numpy","pandas","scipy","h5py", "scikit-learn", "astropy"]
 name = "subhaloscript"
-version = "1.1.2"
+version = "1.1.4"
 authors = [
   { name="Charles Gannon", email="cgannon@ucmerced.edu" },
 ]

{subhaloscript-1.1.2 → subhaloscript-1.1.4}/subscript/scripts/nfilters.py

@@ -2,14 +2,14 @@
 import numpy as np
 import numpy.testing
 import h5py
-from typing import Callable
+from typing import Callable, Iterable
 
 from subscript.scripts.spatial import project3d, project2d
 from subscript.wrappers import gscript
 from subscript.defaults import ParamKeys
 from subscript.util import deprecated
 
-def logical_or(arg1: (np.ndarray[bool] | Callable), arg2: (np.ndarray[bool] | Callable)):
+def logical_or(arg1: (np.ndarray[bool] | Callable), arg2: (np.ndarray[bool] | Callable), *args:(np.ndarray[bool] | Callable)):
     """
     Create a logical OR function from two nodefilters or boolean arrays.
 
@@ -19,19 +19,34 @@ def logical_or(arg1: (np.ndarray[bool] | Callable), arg2: (np.ndarray[bool] | Ca
         First condition array or callable returning a boolean array.
     arg2 : np.ndarray of bool or Callable
         Second condition array or callable returning a boolean array.
+    args : Iterable of np.ndarray of bool or Callable
 
     Returns
     -------
     Callable
-        A function that returns the element-wise logical OR of `arg1` and `arg2` when called.
+        A function that returns the element-wise logical OR arg1, arg2, and all additional args when called.
     """
-    _a1 = arg1
-    if isinstance(arg1, np.ndarray):
-        _a1 = lambda *a, **k: arg1
-    _a2 = arg2
-    if isinstance(arg2, np.ndarray):
-        _a2 = lambda *a, **k: arg2
-    return lambda *a, **k: _a1(*a, **k) | _a2(*a, **k)
+
+    def eval_or(*a, **k):
+        _args = [arg1, arg2] + list(args)
+        _arg_eval = None
+
+        for _arg in _args:            
+            if isinstance(_arg, np.ndarray):
+                _eval = _arg
+            else:
+                _eval = _arg(*a, **k)
+
+            if _arg_eval is None:
+                _arg_eval = _eval
+            else:                
+                if _arg_eval.shape != _eval.shape:
+                    raise ValueError(f"Shape mismatch between arguments: {_arg_eval.shape} and {_eval.shape}")
+                _arg_eval |= _eval
+
+        return _arg_eval
+
+    return eval_or
 
 @deprecated("Use logical_or() instead")
 def nfor(*args, **kwargs):
@@ -40,7 +55,7 @@ def nfor(*args, **kwargs):
     """
     return logical_or(*args, **kwargs)
 
-def logical_and(arg1: (np.ndarray[bool] | Callable), arg2: (np.ndarray[bool] | Callable)):
+def logical_and(arg1: (np.ndarray[bool] | Callable), arg2: (np.ndarray[bool] | Callable), *args: (np.ndarray[bool] | Callable)):
     """
     Create a logical AND function from two nodefilters or boolean arrays.
 
@@ -50,19 +65,30 @@ def logical_and(arg1: (np.ndarray[bool] | Callable), arg2: (np.ndarray[bool] | C
         First condition array or callable returning a boolean array.
     arg2 : np.ndarray of bool or Callable
         Second condition array or callable returning a boolean array.
-
+    args : Iterable of np.ndarray of bool or Callable    
     Returns
     -------
     Callable
-        A function that returns the element-wise logical AND of `arg1` and `arg2` when called.
-    """
-    _a1 = arg1
-    if isinstance(arg1, np.ndarray):
-        _a1 = lambda *a, **k: arg1
-    _a2 = arg2
-    if isinstance(arg2, np.ndarray):
-        _a2 = lambda *a, **k: arg2
-    return lambda *a, **k: _a1(*a, **k) & _a2(*a, **k)
+        A function that returns the element-wise logical AND of `arg1` and `arg2` and any aditional args when called.
+    """
+    def eval_and(*a, **k):
+        _args = [arg1, arg2] + list(args)
+        _arg_eval = None
+
+        for _arg in _args:            
+            if isinstance(_arg, np.ndarray):
+                _eval = _arg
+            else:
+                _eval = _arg(*a, **k)
+
+            if _arg_eval is None:
+                _arg_eval = _eval
+            else:                
+                if _arg_eval.shape != _eval.shape:
+                    raise ValueError(f"Shape mismatch between arguments: {_arg_eval.shape} and {_eval.shape}")
+                _arg_eval &= _eval
+        return _arg_eval
+    return eval_and
 
 
 @deprecated("Use logical_and() instead")

{subhaloscript-1.1.2 → subhaloscript-1.1.4}/tests/test_nfilters.py

@@ -43,11 +43,11 @@ def test_nfilter_logical_and():
     out_expected = np.zeros(5, dtype=bool)
     testing.assert_equal(out_actual, out_expected)
 
-def test_nfilter_logical_and():
+def test_nfilter_logical_or():
     mockdata = {
                 "nodeIsIsolated": np.asarray((1.0, 0.0, 1.0, 1.0, 0.0))
                }
- 
+
     test = logical_or(hosthalos, subhalos)
     out_actual = test(mockdata)
     out_expected = np.ones(5, dtype=bool)
@@ -116,3 +116,69 @@ def test_nfilter_project2d():
     testing.assert_equal(filter_actual, filter_expected)
 
 
+def test_logical_and_varargs():
+    mockdata = {
+                "nodeIsIsolated": np.asarray((1.0, 0.0, 1.0, 1.0, 0.0))
+               }
+
+    # Three callable args
+    test = logical_and(hosthalos, hosthalos, hosthalos)
+    out_actual = test(mockdata)
+    out_expected = hosthalos(mockdata)
+    testing.assert_equal(out_actual, out_expected)
+
+    # Mix of callables and arrays
+    test = logical_and(hosthalos, hosthalos(mockdata), subhalos)
+    out_actual = test(mockdata)
+    out_expected = np.zeros(5, dtype=bool)
+    testing.assert_equal(out_actual, out_expected)
+
+    # Four args: all True AND hosthalos AND subhalos → all False
+    all_true = np.ones(5, dtype=bool)
+    test = logical_and(hosthalos, subhalos, all_true)
+    out_actual = test(mockdata)
+    out_expected = np.zeros(5, dtype=bool)
+    testing.assert_equal(out_actual, out_expected)
+
+
+def test_logical_or_varargs():
+    mockdata = {
+                "nodeIsIsolated": np.asarray((1.0, 0.0, 1.0, 1.0, 0.0))
+               }
+
+    # Three callable args: hosthalos OR subhalos OR hosthalos → all True
+    test = logical_or(hosthalos, subhalos, hosthalos)
+    out_actual = test(mockdata)
+    out_expected = np.ones(5, dtype=bool)
+    testing.assert_equal(out_actual, out_expected)
+
+    # All-false array OR hosthalos → hosthalos
+    all_false = np.zeros(5, dtype=bool)
+    test = logical_or(all_false, all_false, hosthalos)
+    out_actual = test(mockdata)
+    out_expected = hosthalos(mockdata)
+    testing.assert_equal(out_actual, out_expected)
+
+
+def test_logical_and_shape_mismatch():
+    a = np.ones(5, dtype=bool)
+    b = np.ones(3, dtype=bool)
+
+    test = logical_and(a, a, b)
+    try:
+        test()
+        assert False, "Expected ValueError"
+    except ValueError:
+        pass
+
+
+def test_logical_or_shape_mismatch():
+    a = np.ones(5, dtype=bool)
+    b = np.ones(3, dtype=bool)
+
+    test = logical_or(a, a, b)
+    try:
+        test()
+        assert False, "Expected ValueError"
+    except ValueError:
+        pass