nullpol 0.2.2__tar.gz → 0.2.4__tar.gz

nullpol-0.2.4/.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@11f9893b081a58869d3b5fccaea48c9e9e46f990 # v8.3.2
+              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@11f9893b081a58869d3b5fccaea48c9e9e46f990 # v8.3.2
+              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.4}/.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@99df26d4f13ea111d4ec1a7dddef6063f76b97e9 # v4
               with:
                   languages: python
 
             - name: Autobuild
-              uses: github/codeql-action/autobuild@8aad20d150bbac5944a9f9d289da16a4b0d87c1e # v4
+              uses: github/codeql-action/autobuild@99df26d4f13ea111d4ec1a7dddef6063f76b97e9 # v4
 
             - name: Perform CodeQL Analysis
-              uses: github/codeql-action/analyze@8aad20d150bbac5944a9f9d289da16a4b0d87c1e # v4
+              uses: github/codeql-action/analyze@99df26d4f13ea111d4ec1a7dddef6063f76b97e9 # v4

{nullpol-0.2.2 → nullpol-0.2.4}/.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@c49bec37fa3496222c70649af3a09e2c2612310e # v0.0.15
               with:
                   use-latest-tag: true
 

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

@@ -17,7 +17,7 @@ repos:
           - id: check-json
 
     - repo: https://github.com/astral-sh/ruff-pre-commit
-      rev: v0.15.20
+      rev: v0.15.21
       hooks:
           - id: ruff
             args: [--fix, --config=pyproject.toml]
@@ -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.5
       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.28
       hooks:
           # Update the uv lockfile
           - id: uv-lock

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nullpol
-Version: 0.2.2
+Version: 0.2.4
 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.4}/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.4}/src/nullpol/cli/input.py

@@ -113,22 +113,32 @@ class Input(BilbyInput):
             "time_frequency_filter": self.meta_data["time_frequency_filter"],  # pylint: disable=no-member
             "priors": self.search_priors,
         }
+        extra_likelihood_kwargs = self.extra_likelihood_kwargs
         if self.likelihood_type == "Chi2TimeFrequencyLikelihood":
             Likelihood = Chi2TimeFrequencyLikelihood
-            likelihood_kwargs.update(self.extra_likelihood_kwargs)
+            likelihood_kwargs.update(extra_likelihood_kwargs)
         elif "." in self.likelihood_type:
             split_path = self.likelihood_type.split(".")
             module = ".".join(split_path[:-1])
             likelihood_class = split_path[-1]
             Likelihood = getattr(import_module(module), likelihood_class)
-            likelihood_kwargs.update(self.extra_likelihood_kwargs)
+            likelihood_kwargs.update(extra_likelihood_kwargs)
         else:
             raise ValueError(f"Unknown Likelihood class {self.likelihood_type}")
 
+        likelihood_signature = inspect.signature(Likelihood.__init__)
+        accepted_keyword_names = {
+            name
+            for name, parameter in likelihood_signature.parameters.items()
+            if parameter.kind in (inspect.Parameter.POSITIONAL_OR_KEYWORD, inspect.Parameter.KEYWORD_ONLY)
+        }
+        accepts_extra_kwargs = any(
+            parameter.kind == inspect.Parameter.VAR_KEYWORD for parameter in likelihood_signature.parameters.values()
+        )
         likelihood_kwargs = {
             key: value
             for key, value in likelihood_kwargs.items()
-            if key in inspect.getfullargspec(Likelihood.__init__).args
+            if key in accepted_keyword_names or (accepts_extra_kwargs and key in extra_likelihood_kwargs)
         }
 
         logger.debug(f"Initialise likelihood {Likelihood} with kwargs: \n{likelihood_kwargs}")

{nullpol-0.2.2 → nullpol-0.2.4}/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.4}/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.4}/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.4/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.4/tests/cli/test_input.py

@@ -0,0 +1,179 @@
+"""Tests for likelihood construction from CLI input."""
+
+from __future__ import annotations
+
+import types
+
+from bilby_pipe.main import parse_args
+
+from nullpol.cli import input as input_module
+from nullpol.cli.data_analysis import DataAnalysisInput
+from nullpol.cli.parser import create_nullpol_parser
+
+
+class _KeywordOnlyLikelihood:
+    """Capture the arguments supplied by :attr:`Input.likelihood`."""
+
+    def __init__(
+        self,
+        interferometers,
+        wavelet_frequency_resolution,
+        wavelet_nx,
+        polarization_modes,
+        *args,
+        polarization_basis=None,
+        time_frequency_filter=None,
+        **kwargs,
+    ):
+        self.interferometers = interferometers
+        self.wavelet_frequency_resolution = wavelet_frequency_resolution
+        self.wavelet_nx = wavelet_nx
+        self.polarization_modes = polarization_modes
+        self.polarization_basis = polarization_basis
+        self.time_frequency_filter = time_frequency_filter
+        self.extra_kwargs = kwargs
+
+
+class _StrictLikelihood:
+    """Likelihood without ``**kwargs``; unknown extras must be dropped, not forwarded."""
+
+    def __init__(
+        self,
+        interferometers,
+        wavelet_frequency_resolution,
+        wavelet_nx,
+        polarization_modes,
+        polarization_basis=None,
+        time_frequency_filter=None,
+        priors=None,
+    ):
+        self.interferometers = interferometers
+        self.wavelet_frequency_resolution = wavelet_frequency_resolution
+        self.wavelet_nx = wavelet_nx
+        self.polarization_modes = polarization_modes
+        self.polarization_basis = polarization_basis
+        self.time_frequency_filter = time_frequency_filter
+        self.priors = priors
+
+
+def _build_inputs(args, *, interferometers, time_frequency_filter, priors, likelihood_type=None):
+    """Assemble a :class:`DataAnalysisInput` wired for :attr:`Input.likelihood`."""
+    inputs = object.__new__(DataAnalysisInput)
+    inputs._interferometers = interferometers
+    inputs.search_priors = priors
+    inputs.wavelet_frequency_resolution = 16.0
+    inputs.wavelet_nx = 4.0
+    inputs.polarization_modes = args.polarization_modes
+    inputs.polarization_basis = args.polarization_basis
+    inputs.meta_data = {"time_frequency_filter": time_frequency_filter}
+    inputs.likelihood_type = likelihood_type if likelihood_type is not None else args.likelihood_type
+    inputs.extra_likelihood_kwargs = args.extra_likelihood_kwargs
+    return inputs
+
+
+def _parse_config(tmp_path, body):
+    config_file = tmp_path / "analysis.ini"
+    config_file.write_text(body, encoding="utf-8")
+    args, unknown_args = parse_args([str(config_file)], create_nullpol_parser(top_level=False))
+    assert unknown_args == []
+    return args
+
+
+def test_analysis_config_forwards_keyword_only_parameters(monkeypatch, tmp_path):
+    """A configured analysis forwards its normalized basis to the likelihood."""
+    args = _parse_config(
+        tmp_path,
+        "polarization-modes = pc\n"
+        "polarization-basis = p\n"
+        "extra-likelihood-kwargs = {'regularization_constant': 0.99}\n",
+    )
+
+    assert args.polarization_modes == ["pc"]
+    assert args.polarization_basis == ["p"]
+
+    interferometers = object()
+    time_frequency_filter = object()
+    priors = object()
+    inputs = _build_inputs(
+        args,
+        interferometers=interferometers,
+        time_frequency_filter=time_frequency_filter,
+        priors=priors,
+    )
+
+    assert inputs.polarization_modes == "pc"
+    assert inputs.polarization_basis == "p"
+
+    monkeypatch.setattr(input_module, "Chi2TimeFrequencyLikelihood", _KeywordOnlyLikelihood)
+
+    likelihood = input_module.Input.likelihood.fget(inputs)
+
+    assert likelihood.interferometers is interferometers
+    assert likelihood.wavelet_frequency_resolution == 16.0
+    assert likelihood.wavelet_nx == 4.0
+    assert likelihood.polarization_modes == "pc"
+    assert likelihood.polarization_basis == "p"
+    assert likelihood.time_frequency_filter is time_frequency_filter
+    assert likelihood.extra_kwargs == {"regularization_constant": 0.99}
+
+
+def test_extra_kwargs_dropped_when_likelihood_rejects_variadic(monkeypatch, tmp_path):
+    """A likelihood without ``**kwargs`` must not receive unknown extras (no TypeError)."""
+    args = _parse_config(
+        tmp_path,
+        "polarization-modes = pc\n"
+        "polarization-basis = p\n"
+        "extra-likelihood-kwargs = {'regularization_constant': 0.99}\n",
+    )
+
+    interferometers = object()
+    time_frequency_filter = object()
+    priors = object()
+    inputs = _build_inputs(
+        args,
+        interferometers=interferometers,
+        time_frequency_filter=time_frequency_filter,
+        priors=priors,
+    )
+
+    monkeypatch.setattr(input_module, "Chi2TimeFrequencyLikelihood", _StrictLikelihood)
+
+    # Would raise ``TypeError: unexpected keyword argument 'regularization_constant'``
+    # if the unknown extra were forwarded to a signature without ``**kwargs``.
+    likelihood = input_module.Input.likelihood.fget(inputs)
+
+    assert likelihood.interferometers is interferometers
+    assert likelihood.polarization_basis == "p"
+    assert likelihood.time_frequency_filter is time_frequency_filter
+    assert likelihood.priors is priors
+
+
+def test_dotted_path_forwards_keyword_only_parameters(monkeypatch, tmp_path):
+    """The ``module.Class`` likelihood_type branch also forwards keyword-only params."""
+    args = _parse_config(
+        tmp_path,
+        "polarization-modes = pc\n"
+        "polarization-basis = p\n"
+        "extra-likelihood-kwargs = {'regularization_constant': 0.99}\n",
+    )
+
+    interferometers = object()
+    time_frequency_filter = object()
+    priors = object()
+    inputs = _build_inputs(
+        args,
+        interferometers=interferometers,
+        time_frequency_filter=time_frequency_filter,
+        priors=priors,
+        likelihood_type="my_pkg.CustomLikelihood",
+    )
+
+    fake_module = types.ModuleType("my_pkg")
+    fake_module.CustomLikelihood = _KeywordOnlyLikelihood
+    monkeypatch.setattr(input_module, "import_module", lambda name: fake_module)
+
+    likelihood = input_module.Input.likelihood.fget(inputs)
+
+    assert likelihood.polarization_basis == "p"
+    assert likelihood.time_frequency_filter is time_frequency_filter
+    assert likelihood.extra_kwargs == {"regularization_constant": 0.99}

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

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