BUG: Address nightly failures due to stale/old tests

.github/workflows/nightly-health.yml

@@ -205,12 +205,19 @@ jobs:
         #
         # --cov-append adds to the core run's data, and the reports are written
         # here so that they cover both runs.
+        #
+        # --timeout sits well above --max-test-seconds on purpose. Killing a
+        # worker discards everything the tutorial had printed, which is exactly
+        # the record needed to see where its time went, so the backstop must
+        # only catch a tutorial that will never finish. An overrun that does
+        # finish is reported by --max-test-seconds instead, with its duration
+        # and its output intact.
         run: |
           pytest tests/test_tutorials.py -v `
             --run-all --require-tutorial-data `
             -n 1 --max-worker-restart=40 `
             --max-test-seconds=600 `
-            --timeout=900 `
+            --timeout=2400 `
             --cov=physiotwin4d `
             --cov-append `
             --cov-report=xml `

src/physiotwin4d/segment_chest_total_segmentator.py

@@ -44,7 +44,7 @@ class SegmentChestTotalSegmentator(SegmentAnatomyBase):
     group.
 
     Attributes:
-        target_spacing (float): Target spacing set to 1.5mm for TotalSegmentator.
+        target_spacing (float): Target spacing set to 1.0mm for TotalSegmentator.
 
     Example:
         >>> segmenter = SegmentChestTotalSegmentator()
@@ -225,12 +225,56 @@ def __init__(self, log_level: int | str = logging.INFO):
 
         self.has_academic_license = False
 
+    @staticmethod
+    def _academic_license_is_valid() -> bool:
+        """Return True when TotalSegmentator reports an installed license.
+
+        Deliberately the same offline check ``show_license_info`` performs
+        before a licensed task, so this predicts exactly whether that call
+        would exit.  The offline check only tests that a license number is
+        configured and 18 characters long, so a stale or revoked key of the
+        right length still reads as installed; TotalSegmentator would then
+        exit while downloading the licensed weights, which no pre-check of
+        ours can prevent.
+
+        ``has_valid_license`` would catch that by asking the backend, but it
+        reports a network failure as ``invalid_license`` too, so a runner that
+        is merely offline would silently segment without the licensed tasks
+        and quietly produce different anatomy.  Wrongly degrading a valid
+        licensed run is worse than the revoked-key case this misses.
+        """
+        from totalsegmentator.libs import (  # noqa: PLC0415
+            has_valid_license_offline,
+        )
+
+        status, _ = has_valid_license_offline()
+        return bool(status == "yes")
+
     def set_has_academic_license(self, has_academic_license: bool) -> None:
-        """Set whether the academic license is available.
+        """Request the licensed tasks, if a license is actually installed.
+
+        ``heartchambers_highres`` and ``tissue_4_types`` are not openly
+        available.  Asking for them without a license makes
+        ``totalsegmentator`` print its licensing notice and call
+        ``sys.exit(1)`` from inside the segmentation, which surfaces as a bare
+        ``SystemExit`` partway through whatever workflow was running.  Check
+        here instead, so that a machine without a key segments the heart as
+        one structure rather than aborting the run.  The fallback is logged,
+        because it is a coarser segmentation than a licensed run produces.
 
         Args:
             has_academic_license (bool): Whether the academic license is available
         """
+        if has_academic_license and not self._academic_license_is_valid():
+            self.log_warning(
+                "No valid TotalSegmentator license found; skipping the "
+                "'heartchambers_highres' and 'tissue_4_types' tasks, so the "
+                "heart is segmented as a single structure and no chamber "
+                "labels (141-144) are produced. Install one with "
+                "'totalseg_set_license -l <key>'; a free academic license is "
+                "at https://backend.totalsegmentator.com/license-academic/"
+            )
+            has_academic_license = False
         self.has_academic_license = has_academic_license
 
     def _add_extra_taxonomy_groups(self) -> None:

src/physiotwin4d/segment_heart_simpleware.py

@@ -75,10 +75,10 @@ def __init__(self, log_level: int | str = logging.INFO):
         self.target_spacing = 1.0
 
         # Heart and major-vessel labels from Simpleware Medical ASCardio.
-        # Lung / bone / soft_tissue are not segmented by ASCardio; they will
-        # be folded into the 'other' group by _finalize_other_group().
-        # Contrast (135) and soft_tissue (133) defaults are inherited from
-        # SegmentAnatomyBase.
+        # Lung, bone, soft_tissue and contrast are not segmented by ASCardio,
+        # and SegmentAnatomyBase seeds no defaults for them, so those groups
+        # stay empty and never reach a result. Ids ASCardio does emit but no
+        # group claims are folded into 'other' by _finalize_other_group().
         for group_name, organs in (
             (
                 "heart",

src/physiotwin4d/workflow_fit_statistical_model_to_patient.py

@@ -390,7 +390,9 @@ def set_use_pca_registration(
                 WorkflowCreateStatisticalModel result["pca_model"]) with keys
                 "eigenvalues" and "components".
             number_of_pca_components: Required when use is True. Number of PCA
-                components to use. Default 0 means use all components.
+                components to use. Default 0 means use all components.  A count
+                larger than the model actually carries is reduced to what it
+                carries; see below.
             use_surface: Whether to use the surface of the patient model for PCA registration.
         Raises:
             ValueError: If use is True and pca_model is None.
@@ -400,6 +402,22 @@ def set_use_pca_registration(
                 raise ValueError(
                     "When enabling PCA registration, pca_model must be provided."
                 )
+            # A PCA model carries at most one fewer mode than it had samples,
+            # and WorkflowCreateStatisticalModel already caps it there.  The
+            # count configured for a full population is therefore too large for
+            # a model built from a small one, and asking for more modes than
+            # exist raises out of the optimizer partway through the fit.  Read
+            # the count the model actually carries instead.
+            available_components = len(pca_model.get("components", []))
+            if available_components < number_of_pca_components:
+                self.log_info(
+                    "PCA model carries %d mode(s), fewer than the %d requested; "
+                    "fitting with the %d available.",
+                    available_components,
+                    number_of_pca_components,
+                    available_components,
+                )
+                number_of_pca_components = available_components
             self.pca_model = pca_model
             self.number_of_pca_components = number_of_pca_components
         else:

tests/test_register_time_series_images.py

@@ -29,13 +29,13 @@ class TestRegisterTimeSeriesImages:
     _class_name = "registration_time_series_images"
 
     def test_registrar_initialization_default(self) -> None:
-        """Test that the default registration_method is RegisterImagesGreedyICON."""
+        """Test that the default registration_method is RegisterImagesGreedy."""
         registrar = RegisterTimeSeriesImages()
-        assert isinstance(registrar.registrar, RegisterImagesGreedyICON), (
-            "Default registrar should be RegisterImagesGreedyICON"
+        assert isinstance(registrar.registrar, RegisterImagesGreedy), (
+            "Default registrar should be RegisterImagesGreedy"
         )
 
-        print("\nTime series registrar defaults to RegisterImagesGreedyICON")
+        print("\nTime series registrar defaults to RegisterImagesGreedy")
 
     def test_registrar_initialization_Greedy_ICON(self) -> None:
         """Initializes correctly with a RegisterImagesGreedyICON instance."""

tests/test_segment_chest_total_segmentator.py

@@ -28,7 +28,7 @@ def test_segmenter_initialization(
     ) -> None:
         """Test that SegmentChestTotalSegmentator initializes correctly."""
         assert segmenter_total_segmentator is not None, "Segmenter not initialized"
-        assert segmenter_total_segmentator.target_spacing == 1.5, (
+        assert segmenter_total_segmentator.target_spacing == 1.0, (
             "Target spacing not set correctly"
         )
 
@@ -271,3 +271,99 @@ def test_postprocessing(
 
 if __name__ == "__main__":
     pytest.main([__file__, "-v", "-s"])
+
+
+def test_academic_license_request_is_honoured_when_a_license_is_installed(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """With a license present, the licensed tasks stay requested."""
+    # staticmethod(), because setattr on the class would otherwise install a
+    # plain function and the call would pass self into it.
+    monkeypatch.setattr(
+        SegmentChestTotalSegmentator,
+        "_academic_license_is_valid",
+        staticmethod(lambda: True),
+    )
+    segmenter = SegmentChestTotalSegmentator()
+
+    segmenter.set_has_academic_license(True)
+
+    assert segmenter.has_academic_license is True
+
+
+def test_academic_license_request_falls_back_when_no_license_is_installed(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Without a license, asking for the licensed tasks must not abort the run.
+
+    ``heartchambers_highres`` and ``tissue_4_types`` are not openly available.
+    Requesting them unlicensed makes ``totalsegmentator`` call ``sys.exit(1)``
+    from inside the segmentation, which surfaces as a bare ``SystemExit``
+    partway through whatever workflow was running.  The request is dropped
+    here instead, so the heart is segmented as one structure.
+    """
+    monkeypatch.setattr(
+        SegmentChestTotalSegmentator,
+        "_academic_license_is_valid",
+        staticmethod(lambda: False),
+    )
+    segmenter = SegmentChestTotalSegmentator()
+
+    segmenter.set_has_academic_license(True)
+
+    assert segmenter.has_academic_license is False
+
+
+def test_declining_the_academic_license_never_checks_for_one(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Only a request for the licensed tasks should cost a license lookup."""
+
+    def _fail() -> bool:
+        raise AssertionError("license checked when it was not requested")
+
+    monkeypatch.setattr(
+        SegmentChestTotalSegmentator, "_academic_license_is_valid", staticmethod(_fail)
+    )
+    segmenter = SegmentChestTotalSegmentator()
+
+    segmenter.set_has_academic_license(False)
+
+    assert segmenter.has_academic_license is False
+
+
+def test_license_check_tracks_totalsegmentators_own_offline_gate(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """The check must agree with the gate it is predicting, weakness included.
+
+    ``show_license_info`` exits unless ``has_valid_license_offline`` returns
+    "yes", and that only tests for a configured 18-character key.  A key of the
+    right length but no longer entitled therefore reads as installed here, and
+    TotalSegmentator fails later, while downloading the licensed weights.
+    Asking the backend instead would report an offline runner as unlicensed and
+    silently change the anatomy it produces, so the weaker check is the
+    deliberate choice and this pins it.
+    """
+    import totalsegmentator.libs as ts_libs
+
+    monkeypatch.setattr(
+        ts_libs,
+        "has_valid_license_offline",
+        lambda: ("yes", "SUCCESS: License is valid."),
+    )
+    assert SegmentChestTotalSegmentator._academic_license_is_valid() is True
+
+    monkeypatch.setattr(
+        ts_libs,
+        "has_valid_license_offline",
+        lambda: ("invalid_license", "ERROR: Invalid license number (too-short)."),
+    )
+    assert SegmentChestTotalSegmentator._academic_license_is_valid() is False
+
+    monkeypatch.setattr(
+        ts_libs,
+        "has_valid_license_offline",
+        lambda: ("missing_license", "ERROR: A license number has not been set."),
+    )
+    assert SegmentChestTotalSegmentator._academic_license_is_valid() is False