nullpol 0.2.2__tar.gz → 0.2.3__tar.gz

nullpol-0.2.3/.github/workflows/ci.yml

@@ -0,0 +1,66 @@
+name: CI
+on:
+    push:
+        branches: [main]
+    pull_request:
+        branches: [main]
+    workflow_dispatch:
+    workflow_call:
+
+jobs:
+    test:
+        strategy:
+            matrix:
+                python-version: ['3.12', '3.13', '3.14']
+                os: [ubuntu-latest, macos-latest]
+        runs-on: ${{ matrix.os }}
+        steps:
+            - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6
+              with:
+                  persist-credentials: false
+
+            - name: Install uv
+              uses: astral-sh/setup-uv@fac544c07dec837d0ccb6301d7b5580bf5edae39 # v8.2.0
+              with:
+                  python-version: ${{ matrix.python-version }}
+                  enable-cache: 'true'
+
+            - name: Install dependencies
+              run: uv sync --group dev --frozen
+
+            - name: Run tests with pytest
+              run: uv run --frozen pytest
+
+            - name: Upload coverage to Codecov
+              if: ${{ !cancelled() }}
+              uses: codecov/codecov-action@0fb7174895f61a3b6b78fc075e0cd60383518dac # v5
+              with:
+                  token: ${{ secrets.CODECOV_TOKEN }}
+
+    integration:
+        # Runs the @pytest.mark.integration suite once (not in the matrix) to
+        # keep the fast unit-test matrix cheap while still gating on the
+        # heavier integration tests. Installs the optional `asimov` extra so
+        # real asimov/cbcflow paths can be exercised now and in the future.
+        needs: test
+        runs-on: ubuntu-latest
+        steps:
+            - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6
+              with:
+                  persist-credentials: false
+
+            - name: Install uv
+              uses: astral-sh/setup-uv@fac544c07dec837d0ccb6301d7b5580bf5edae39 # v8.2.0
+              with:
+                  python-version: '3.13'
+                  enable-cache: 'true'
+
+            - name: Install dependencies (with asimov extra)
+              run: uv sync --group dev --extra asimov --frozen
+
+            - name: Run integration tests
+              # Clear the default addopts (which selects `-m 'not integration'`)
+              # and explicitly select the integration marker instead.
+              run:
+                  uv run --frozen pytest -o addopts="" -m integration --cov src
+                  --cov-report=term-missing

{nullpol-0.2.2 → nullpol-0.2.3}/.github/workflows/codeql.yml

@@ -18,12 +18,12 @@ jobs:
             - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6
 
             - name: Initialize CodeQL
-              uses: github/codeql-action/init@8aad20d150bbac5944a9f9d289da16a4b0d87c1e # v4
+              uses: github/codeql-action/init@54f647b7e1bb85c95cddabcd46b0c578ec92bc1a # v4
               with:
                   languages: python
 
             - name: Autobuild
-              uses: github/codeql-action/autobuild@8aad20d150bbac5944a9f9d289da16a4b0d87c1e # v4
+              uses: github/codeql-action/autobuild@54f647b7e1bb85c95cddabcd46b0c578ec92bc1a # v4
 
             - name: Perform CodeQL Analysis
-              uses: github/codeql-action/analyze@8aad20d150bbac5944a9f9d289da16a4b0d87c1e # v4
+              uses: github/codeql-action/analyze@54f647b7e1bb85c95cddabcd46b0c578ec92bc1a # v4

{nullpol-0.2.2 → nullpol-0.2.3}/.github/workflows/scheduled-release.yml

@@ -20,7 +20,7 @@ jobs:
 
             - name: Check for new commits
               id: check_commits
-              uses: isaac-cf-wong/detect-git-changes-action@484da6639676d11009fc70cf1a09b73d31737fe9 # v0.0.13
+              uses: isaac-cf-wong/detect-git-changes-action@ecc6bf915a7987eb27f70d560c8067a69b943cb5 # v0.0.14
               with:
                   use-latest-tag: true
 

{nullpol-0.2.2 → nullpol-0.2.3}/.pre-commit-config.yaml

@@ -29,18 +29,18 @@ repos:
           - id: taplo-format
 
     - repo: https://github.com/crate-ci/typos
-      rev: v1.47.2
+      rev: v1.48.0
       hooks:
           - id: typos
             args: []
 
     - repo: https://github.com/rbubley/mirrors-prettier
-      rev: v3.9.1
+      rev: v3.9.4
       hooks:
           - id: prettier
 
     - repo: https://github.com/DavidAnson/markdownlint-cli2
-      rev: v0.22.1
+      rev: v0.23.0
       hooks:
           - id: markdownlint-cli2
             args:
@@ -48,7 +48,7 @@ repos:
                 - .markdownlint.yaml
 
     - repo: https://github.com/astral-sh/uv-pre-commit
-      rev: 0.11.25
+      rev: 0.11.26
       hooks:
           # Update the uv lockfile
           - id: uv-lock

{nullpol-0.2.2 → nullpol-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nullpol
-Version: 0.2.2
+Version: 0.2.3
 Summary: A package to perform model-independent polarization test of gravitational-wave signals.
 Project-URL: Documentation, https://isaac-cf-wong.github.io/nullpol/
 Project-URL: Source, https://github.com/isaac-cf-wong/nullpol

{nullpol-0.2.2 → nullpol-0.2.3}/src/nullpol/cli/data_analysis.py

@@ -147,7 +147,7 @@ class DataAnalysisInput(BInput, Input):
             raise NullpolError(f"Unsupported polarization-basis input: {modes}")
 
     def _validate_polarization_model_setting(self):
-        supported_modes = ["b", "c", "b", "l", "x", "y"]
+        supported_modes = ["b", "c", "p", "l", "x", "y"]
         # Check whether the modes are supported.
         for mode in self.polarization_modes:
             if mode not in supported_modes:

{nullpol-0.2.2 → nullpol-0.2.3}/src/nullpol/integrations/asimov/tgrflow.py

@@ -166,12 +166,12 @@ class Collector:
         analysis_output["Notes"] = []
 
         if analysis.comment is not None and (
-            corresponding_analysis is None or analysis.comment not in corresponding_analysis["Notes"]
+            corresponding_analysis is None or analysis.comment not in corresponding_analysis.get("Notes", [])
         ):
             # We only want to add the comment to the notes if it doesn't already exist
             analysis_output["Notes"].append(analysis.comment)
 
-        if analysis.review.status:
+        if analysis.review is not None and analysis.review.status:
             if analysis.review.status.lower() == "approved":
                 analysis_output["ReviewStatus"] = "pass"
             elif analysis.review.status.lower() == "rejected":
@@ -181,7 +181,8 @@ class Collector:
             messages = sorted(analysis.review.messages, key=lambda k: k.timestamp)
             if len(messages) > 0 and (
                 corresponding_analysis is None
-                or f"{messages[0].timestamp:%Y-%m-%d}: {messages[0].message}" in corresponding_analysis["Notes"]
+                or f"{messages[0].timestamp:%Y-%m-%d}: {messages[0].message}"
+                not in corresponding_analysis.get("Notes", [])
             ):
                 analysis_output["Notes"].append(f"{messages[0].timestamp:%Y-%m-%d}: {messages[0].message}")
 
@@ -285,6 +286,69 @@ class Collector:
         return {}
 
 
+def validate_gr_pe_result(result: dict) -> bool:
+    """Validate whether a PE result is suitable as the basis for a TGR analysis.
+
+    The result must be complete, non-deprecated, and not an online or
+    exploratory run.
+
+    Parameters
+    ----------
+    result : dict
+        Metadata for the result to be validated.
+
+    Returns:
+    -------
+    bool
+        Validity of the result.
+    """
+    uid = result.get("UID", "").lower()
+    if not uid or uid == "online" or uid.startswith("exp") or uid.startswith("detchar"):
+        return False
+    if result.get("RunStatus") != "complete":
+        return False
+    if result.get("ReviewStatus") != "pass":
+        return False
+    if result.get("Deprecated", False):
+        return False
+    # Ensure required files are present for actual PE results
+    if "ResultFile" not in result or "ConfigFile" not in result:
+        return False
+    return "PESummaryResultFile" in result
+
+
+def identify_basis_production(metadata) -> dict:
+    """Identify the PE result that will be used as the basis for TGR analyses.
+
+    The IllustrativeResult is tried first. If it passes full validation
+    (complete, non-deprecated, not online/exp*/detchar*, and has all required
+    files) it is returned. If it is not available or does not pass, the function
+    falls back to the first result that passes the full validation. Returns an
+    empty dict if no valid result is found.
+
+    Parameters
+    ----------
+    metadata :
+        CBCFlow superevent metadata.
+
+    Returns:
+    -------
+    dict
+        Result metadata for the basis production, or empty dict if none found.
+    """
+    illustrative_result_name = metadata.data["ParameterEstimation"].get("IllustrativeResult", None)
+    if illustrative_result_name is not None:
+        for result in metadata.data["ParameterEstimation"].get("Results", []):
+            if result["UID"] == illustrative_result_name and validate_gr_pe_result(result):
+                return result
+
+    for result in metadata.data["ParameterEstimation"]["Results"]:
+        if validate_gr_pe_result(result):
+            return result
+
+    return {}
+
+
 # Functionality for information which flows from cbcflow into Asimov
 # pylint: disable=too-few-public-methods
 class Applicator:
@@ -369,6 +433,8 @@ class Applicator:
                 ligo["preferred event"] = event["UID"]
                 ligo["false alarm rate"] = event["FAR"]
                 event_time = event["GPSTime"]
+        if event_time is None:
+            raise ValueError(f"No preferred GraceDB event found for {sid}. Cannot determine event time.")
         ligo["sname"] = sid
 
         # also add the sampling rate to the output
@@ -387,22 +453,22 @@ class Applicator:
             "event time": event_time,
         }
 
-        metadata_pe_results = metadata.data["ParameterEstimation"]["Results"]
-        illustrative_prod = metadata.data["ParameterEstimation"]["IllustrativeResult"]
-        gr_pe = {"available": False}
-        for result in metadata_pe_results:
-            if result["UID"] == illustrative_prod and result["RunStatus"] == "complete":
-                gr_pe = {
-                    "available": True,
-                    "UID GR PE": result["UID"],
-                    "result file path": "/" + result["ResultFile"]["Path"].split(":/")[-1],
-                    "config file path": "/" + result["ConfigFile"]["Path"].split(":/")[-1],
-                    "pesummary result path": "/" + result["PESummaryResultFile"]["Path"].split(":/")[-1],
-                }
-                if "WaveformApproximant" in result:
-                    quality["waveform approximant"] = result["WaveformApproximant"]
-        if gr_pe["available"] is False:
-            raise AttributeError("IllustrativeResult not in the library or the PE run is incomplete.")
+        basis_result = identify_basis_production(metadata)
+        if not basis_result:
+            raise ValueError(
+                "No valid GR PE result found in the library. The IllustrativeResult "
+                "(if set) and all other results either have incomplete run status, "
+                "are deprecated, or are excluded by UID."
+            )
+        gr_pe = {
+            "available": True,
+            "UID GR PE": basis_result["UID"],
+            "result file path": "/" + basis_result["ResultFile"]["Path"].split(":/")[-1],
+            "config file path": "/" + basis_result["ConfigFile"]["Path"].split(":/")[-1],
+            "pesummary result path": "/" + basis_result["PESummaryResultFile"]["Path"].split(":/")[-1],
+        }
+        if "WaveformApproximant" in basis_result:
+            quality["waveform approximant"] = basis_result["WaveformApproximant"]
 
         # now, we need to read in the information from the config file
         # we need the reference frequency, the psd dict and the calibration dict
@@ -410,8 +476,10 @@ class Applicator:
         bilby_config = bilby_config_to_asimov(config_file)
 
         # read in the psd information if present
-        if "psds" in bilby_config:
+        if bilby_config.get("psds") is not None:
             gr_pe["psds"] = bilby_config.pop("psds")
+        elif "psds" in bilby_config:
+            bilby_config.pop("psds")
         output["gr pe info"] = gr_pe.copy()
         output["gr pe info"]["approximant"] = bilby_config["waveform"]["approximant"]
         # config file and cbcflow can disagree about which data to use (for example, preferred frame was updated)

{nullpol-0.2.2 → nullpol-0.2.3}/src/nullpol/integrations/asimov/utility.py

@@ -37,8 +37,11 @@ def read_bilby_ini_file(file: str) -> dict:
 def _convert_string_to_dict(string):
     try:
         return bilby_pipe.utils.convert_string_to_dict(string)
-    except (bilby_pipe.utils.BilbyPipeError, AttributeError):
-        return string
+    except (bilby_pipe.utils.BilbyPipeError, AttributeError, TypeError):
+        try:
+            return literal_eval(string)
+        except (ValueError, SyntaxError):
+            return string
 
 
 def fill_in_pol_specific_metadata(analysis, corresponding_analysis):  # pylint: disable=unused-argument

{nullpol-0.2.2 → nullpol-0.2.3}/tests/analysis/test_data_context.py

@@ -479,7 +479,7 @@ class TestTimeFrequencyDataContext:
         # Create filter with wrong shape
         wrong_filter = np.random.rand(10, 20)  # Wrong dimensions
 
-        with pytest.raises(AssertionError):
+        with pytest.raises(ValueError, match="does not match the time frequency filter"):
             TimeFrequencyDataContext(
                 interferometers=ifos,
                 wavelet_frequency_resolution=2.0,

nullpol-0.2.3/tests/cli/test_data_analysis_validation.py

@@ -0,0 +1,79 @@
+"""Unit tests for :meth:`DataAnalysisInput._validate_polarization_model_setting`.
+
+This guards the fix in commit ``74b4fc3`` where the supported-modes list
+contained a duplicate ``"b"`` and was missing ``"p"`` (plus), causing a valid
+``"p"`` mode to be rejected in both ``polarization-modes`` and
+``polarization-basis`` validation.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from nullpol.cli.data_analysis import DataAnalysisInput
+from nullpol.utils import NullpolError
+
+SUPPORTED = ["b", "c", "p", "l", "x", "y"]
+
+
+def _make_input(modes, basis):
+    """Build a DataAnalysisInput bypassing the heavy __init__.
+
+    The validation method only reads the ``polarization_modes`` and
+    ``polarization_basis`` properties, which are backed by the private
+    ``_polarization_modes`` / ``_polarization_basis`` attributes.
+    """
+    obj = object.__new__(DataAnalysisInput)
+    obj._polarization_modes = list(modes)
+    obj._polarization_basis = list(basis)
+    return obj
+
+
+class TestValidatePolarizationModelSetting:
+    """Tests for :meth:`_validate_polarization_model_setting`."""
+
+    @pytest.mark.parametrize("mode", SUPPORTED)
+    def test_each_supported_mode_accepted_alone(self, mode):
+        """Every one of the six canonical modes is accepted in polarization-modes."""
+        _make_input([mode], [mode])._validate_polarization_model_setting()
+
+    def test_all_six_modes_accepted_together(self):
+        """All six modes (b, c, p, l, x, y) pass when used together."""
+        _make_input(SUPPORTED, SUPPORTED)._validate_polarization_model_setting()
+
+    def test_plus_mode_accepted(self):
+        """Regression: ``"p"`` (plus) must be accepted -- it was rejected before the fix."""
+        _make_input(["p", "c"], ["p"])._validate_polarization_model_setting()
+
+    def test_plus_mode_rejected_before_fix_list(self):
+        """Sanity check: the fixed list no longer contains a duplicate ``b``."""
+        # If the old buggy list ["b","c","b","l","x","y"] were restored, "p" would fail.
+        assert SUPPORTED == ["b", "c", "p", "l", "x", "y"]
+        assert SUPPORTED.count("b") == 1
+        assert "p" in SUPPORTED
+
+    @pytest.mark.parametrize("bad_mode", ["z", "a", "B", "pc", "", "plus"])
+    def test_invalid_mode_in_modes_rejected(self, bad_mode):
+        """An unsupported mode in ``polarization-modes`` raises NullpolError."""
+        with pytest.raises(NullpolError, match="polarization-modes"):
+            _make_input([bad_mode], [bad_mode])._validate_polarization_model_setting()
+
+    @pytest.mark.parametrize("bad_mode", ["z", "a", "P"])
+    def test_invalid_mode_in_basis_rejected(self, bad_mode):
+        """An unsupported mode in ``polarization-basis`` raises NullpolError."""
+        with pytest.raises(NullpolError, match="polarization-basis"):
+            _make_input(["p", "c"], [bad_mode])._validate_polarization_model_setting()
+
+    def test_basis_not_subset_of_modes_rejected(self):
+        """A basis mode that is supported but not in ``polarization-modes`` is rejected."""
+        # "b" is a supported mode, but it is not in the modes list here.
+        with pytest.raises(NullpolError, match="Basis mode"):
+            _make_input(["p", "c"], ["b"])._validate_polarization_model_setting()
+
+    def test_empty_basis_accepted(self):
+        """An empty basis is valid (all modes are derived)."""
+        _make_input(["p", "c"], [])._validate_polarization_model_setting()
+
+    def test_basis_subset_of_modes_accepted(self):
+        """A basis that is a strict subset of the modes is valid."""
+        _make_input(["p", "c", "b", "l"], ["p", "c"])._validate_polarization_model_setting()

nullpol-0.2.3/tests/integrations/asimov/__init__.py

@@ -0,0 +1 @@
+"""Asimov integration tests."""

nullpol-0.2.3/tests/integrations/asimov/conftest.py

@@ -0,0 +1,78 @@
+"""Shared fixtures for the asimov integration tests.
+
+The ``asimov`` and ``cbcflow`` packages are *optional* dependencies (see the
+``asimov`` extra in ``pyproject.toml``) and are not installed in the default
+test environment. Importing :mod:`nullpol.integrations.asimov` normally
+triggers ``asimov.py`` / ``pesummary.py`` which require those packages (and
+``htcondor``) at import time.
+
+To allow the pure-Python logic in :mod:`nullpol.integrations.asimov.tgrflow`
+and :mod:`nullpol.integrations.asimov.utility` to be exercised without the
+optional deps, these fixtures:
+
+1. Inject lightweight :class:`~unittest.mock.MagicMock` stub modules for
+   ``asimov``, ``asimov.event`` and ``cbcflow`` into :data:`sys.modules`.
+2. Replace the real ``nullpol.integrations.asimov`` package object with an
+   empty package module whose ``__path__`` points at the real source directory,
+   so the submodules ``tgrflow`` and ``utility`` can be loaded by the import
+   machinery without running the package ``__init__`` (and therefore without
+   importing the real ``asimov`` / ``htcondor``).
+
+All stubs are scoped to the test via :class:`pytest.MonkeyPatch` and are
+removed again afterwards.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+import types
+from unittest import mock
+
+import pytest
+
+_STUB_MODULE_PATHS = ("asimov", "asimov.event", "cbcflow")
+
+
+def _make_stub(name: str) -> mock.MagicMock:
+    """Build a stub module that auto-creates any accessed attribute."""
+    mod = mock.MagicMock(name=name)
+    mod.__name__ = name
+    mod.__path__ = []
+    return mod
+
+
+@pytest.fixture
+def asimov_libs(monkeypatch):
+    """Import the asimov integration modules with optional deps stubbed out.
+
+    Returns a :class:`types.SimpleNamespace` exposing the loaded ``tgrflow``
+    and ``utility`` modules together with the most commonly used symbols.
+    """
+    for path in _STUB_MODULE_PATHS:
+        monkeypatch.setitem(sys.modules, path, _make_stub(path))
+
+    # Replace the real asimov package __init__ with an empty package module so
+    # that importing its submodules does not trigger the heavy asimov.py /
+    # pesummary.py imports (which require the real asimov + htcondor packages).
+    import nullpol
+
+    asimov_dir = os.path.join(os.path.dirname(nullpol.__file__), "integrations", "asimov")
+    fake_pkg = types.ModuleType("nullpol.integrations.asimov")
+    fake_pkg.__path__ = [asimov_dir]
+    fake_pkg.__package__ = "nullpol.integrations.asimov"
+    monkeypatch.setitem(sys.modules, "nullpol.integrations.asimov", fake_pkg)
+
+    from nullpol.integrations.asimov import tgrflow, utility
+
+    return types.SimpleNamespace(
+        tgrflow=tgrflow,
+        utility=utility,
+        validate_gr_pe_result=tgrflow.validate_gr_pe_result,
+        identify_basis_production=tgrflow.identify_basis_production,
+        Applicator=tgrflow.Applicator,
+        Collector=tgrflow.Collector,
+        convert_string_to_dict=utility._convert_string_to_dict,
+        bilby_config_to_asimov=utility.bilby_config_to_asimov,
+        deep_update=utility.deep_update,
+    )