monai-weekly 1.5.dev2505__py3-none-any.whl → 1.5.dev2507__py3-none-any.whl

tests/integration/test_loader_semaphore.py

@@ -0,0 +1,48 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""this test should not generate errors or
+UserWarning: semaphore_tracker: There appear to be 1 leaked semaphores"""
+from __future__ import annotations
+
+import multiprocessing as mp
+import unittest
+
+import monai  # noqa
+
+
+def w():
+    pass
+
+
+def _main():
+    ps = mp.Process(target=w)
+    ps.start()
+    ps.join()
+
+
+def _run_test():
+    try:
+        tmp = mp.get_context("spawn")
+    except RuntimeError:
+        tmp = mp
+    p = tmp.Process(target=_main)
+    p.start()
+    p.join()
+
+
+class TestImportLock(unittest.TestCase):
+
+    def test_start(self):
+        _run_test()
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/integration/test_mapping_filed.py

@@ -0,0 +1,122 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import tempfile
+import unittest
+
+import numpy as np
+import torch
+from parameterized import parameterized
+
+from monai.data import DataLoader, Dataset, decollate_batch
+from monai.inferers import sliding_window_inference
+from monai.networks.nets import UNet
+from monai.transforms import Compose, EnsureChannelFirstd, LoadImaged, SaveImaged, WriteFileMappingd
+from monai.utils import optional_import
+
+nib, has_nib = optional_import("nibabel")
+
+
+def create_input_file(temp_dir, name):
+    test_image = np.random.rand(128, 128, 128)
+    input_file = os.path.join(temp_dir, name + ".nii.gz")
+    nib.save(nib.Nifti1Image(test_image, np.eye(4)), input_file)
+    return input_file
+
+
+# Test cases that should succeed
+SUCCESS_CASES = [(["seg"], ["seg"]), (["image", "seg"], ["seg"])]
+
+# Test cases that should fail
+FAILURE_CASES = [(["seg"], ["image"]), (["image"], ["seg"]), (["seg"], ["image", "seg"])]
+
+
+@unittest.skipUnless(has_nib, "nibabel required")
+class TestWriteFileMappingd(unittest.TestCase):
+    def setUp(self):
+        self.temp_dir = tempfile.mkdtemp()
+        self.output_dir = os.path.join(self.temp_dir, "output")
+        os.makedirs(self.output_dir)
+        self.mapping_file_path = os.path.join(self.temp_dir, "mapping.json")
+
+    def tearDown(self):
+        shutil.rmtree(self.temp_dir)
+        if os.path.exists(self.mapping_file_path):
+            os.remove(self.mapping_file_path)
+
+    def run_test(self, save_keys, write_keys):
+        name = "test_image"
+        input_file = create_input_file(self.temp_dir, name)
+        output_file = os.path.join(self.output_dir, name, name + "_seg.nii.gz")
+        data = [{"image": input_file}]
+
+        test_transforms = Compose([LoadImaged(keys=["image"]), EnsureChannelFirstd(keys=["image"])])
+
+        post_transforms = Compose(
+            [
+                SaveImaged(
+                    keys=save_keys,
+                    meta_keys="image_meta_dict",
+                    output_dir=self.output_dir,
+                    output_postfix="seg",
+                    savepath_in_metadict=True,
+                ),
+                WriteFileMappingd(keys=write_keys, mapping_file_path=self.mapping_file_path),
+            ]
+        )
+
+        dataset = Dataset(data=data, transform=test_transforms)
+        dataloader = DataLoader(dataset, batch_size=1)
+        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        model = UNet(spatial_dims=3, in_channels=1, out_channels=2, channels=(16, 32), strides=(2,)).to(device)
+        model.eval()
+
+        with torch.no_grad():
+            for batch_data in dataloader:
+                test_inputs = batch_data["image"].to(device)
+                roi_size = (64, 64, 64)
+                sw_batch_size = 2
+                batch_data["seg"] = sliding_window_inference(test_inputs, roi_size, sw_batch_size, model)
+                batch_data = [post_transforms(i) for i in decollate_batch(batch_data)]
+
+        return input_file, output_file
+
+    @parameterized.expand(SUCCESS_CASES)
+    def test_successful_mapping_filed(self, save_keys, write_keys):
+        input_file, output_file = self.run_test(save_keys, write_keys)
+        self.assertTrue(os.path.exists(self.mapping_file_path))
+        with open(self.mapping_file_path) as f:
+            mapping_data = json.load(f)
+        self.assertEqual(len(mapping_data), len(write_keys))
+        for entry in mapping_data:
+            self.assertEqual(entry["input"], input_file)
+            self.assertEqual(entry["output"], output_file)
+
+    @parameterized.expand(FAILURE_CASES)
+    def test_failure_mapping_filed(self, save_keys, write_keys):
+        with self.assertRaises(RuntimeError) as cm:
+            self.run_test(save_keys, write_keys)
+
+        cause_exception = cm.exception.__cause__
+        self.assertIsInstance(cause_exception, KeyError)
+        self.assertIn(
+            "Missing 'saved_to' key in metadata. Check SaveImage argument 'savepath_in_metadict' is True.",
+            str(cause_exception),
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/integration/test_meta_affine.py

@@ -0,0 +1,183 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import os
+import unittest
+from copy import deepcopy
+from pathlib import Path
+
+import numpy as np
+from parameterized import parameterized
+
+from monai.data.image_writer import ITKWriter
+from monai.transforms import (
+    Compose,
+    EnsureChannelFirst,
+    EnsureChannelFirstd,
+    LoadImage,
+    LoadImaged,
+    MapTransform,
+    Orientation,
+    Orientationd,
+    Randomizable,
+    Spacing,
+    Spacingd,
+    Transform,
+)
+from monai.utils import convert_data_type, optional_import
+from tests.test_utils import assert_allclose, download_url_or_skip_test, testing_data_config
+
+itk, has_itk = optional_import("itk")
+TINY_DIFF = 1e-4
+
+keys = ("img1", "img2")
+key, key_1 = "ref_avg152T1_LR", "ref_avg152T1_RL"
+TESTS_PATH = Path(__file__).parents[1]
+FILE_PATH = os.path.join(TESTS_PATH, "testing_data", f"{key}.nii.gz")
+FILE_PATH_1 = os.path.join(TESTS_PATH, "testing_data", f"{key_1}.nii.gz")
+
+TEST_CASES_ARRAY = [
+    [Compose([Spacing(pixdim=(1.0, 1.1, 1.2)), Orientation(axcodes="RAS")]), {}, TINY_DIFF],
+    [Compose([Orientation(axcodes="RAS"), Spacing(pixdim=(1.0, 1.1, 1.2))]), {}, TINY_DIFF],
+    ["CropForeground", {"k_divisible": 3}, TINY_DIFF],
+    ["BorderPad", {"spatial_border": (2, 3, 4)}, TINY_DIFF],
+    ["CenterScaleCrop", {"roi_scale": (0.6, 0.7, 0.8)}, TINY_DIFF],
+    ["CenterSpatialCrop", {"roi_size": (30, 200, 52)}, TINY_DIFF],
+    ["DivisiblePad", {"k": 16}, TINY_DIFF],
+    ["RandScaleCrop", {"roi_scale": (0.3, 0.4, 0.5)}, TINY_DIFF],
+    ["RandSpatialCrop", {"roi_size": (31, 32, 33)}, TINY_DIFF],
+    ["ResizeWithPadOrCrop", {"spatial_size": (50, 80, 200)}, TINY_DIFF],
+    ["Spacing", {"pixdim": (1.0, 1.1, 1.2)}, TINY_DIFF],
+    ["Orientation", {"axcodes": "RAS"}, TINY_DIFF],
+    ["Flip", {"spatial_axis": (0, 1)}, TINY_DIFF],
+    ["Resize", {"spatial_size": (100, 201, 1)}, 30.0],
+    ["Rotate", {"angle": (np.pi / 3, np.pi / 2, np.pi / 4), "mode": "bilinear"}, 20.0],
+    ["Zoom", {"zoom": (0.8, 0.91, 1.2)}, 20.0],
+    ["Rotate90", {"k": 3}, TINY_DIFF],
+    ["RandRotate90", {"prob": 1.0, "max_k": 3}, TINY_DIFF],
+    ["RandRotate", {"prob": 1.0, "range_x": np.pi / 3}, 20.0],
+    ["RandFlip", {"prob": 1.0}, TINY_DIFF],
+    ["RandAxisFlip", {"prob": 1.0}, TINY_DIFF],
+    ["RandZoom", {"prob": 1.0, "mode": "trilinear"}, TINY_DIFF],
+    [
+        "RandAffine",
+        {
+            "prob": 1.0,
+            "rotate_range": (np.pi / 4, np.pi / 3, np.pi / 2),
+            "translate_range": (3, 4, 5),
+            "scale_range": (-0.1, 0.2),
+            "spatial_size": (30, 40, 50),
+            "cache_grid": True,
+            "mode": "bilinear",
+        },
+        20.0,
+    ],
+    [
+        "Affine",
+        {
+            "rotate_params": (np.pi / 4, 0.0, 0.0),
+            "translate_params": (3, 4, 5),
+            "spatial_size": (30, 40, 50),
+            "mode": "bilinear",
+            "image_only": True,
+        },
+        20.0,
+    ],
+]
+
+TEST_CASES_DICT = [
+    [Compose([Spacingd(keys, pixdim=(1.0, 1.1, 1.2)), Orientationd(keys, axcodes="LAS")]), {}, TINY_DIFF],
+    [Compose([Orientationd(keys, axcodes="LAS"), Spacingd(keys, pixdim=(1.0, 1.1, 1.2))]), {}, TINY_DIFF],
+    ["CropForegroundd", {"k_divisible": 3, "source_key": "img1"}, TINY_DIFF],
+]
+for c in TEST_CASES_ARRAY[3:-1]:  # exclude CropForegroundd and Affined
+    TEST_CASES_DICT.append(deepcopy(c))
+    TEST_CASES_DICT[-1][0] = TEST_CASES_DICT[-1][0] + "d"  # type: ignore
+
+
+def _create_itk_obj(array, affine):
+    itk_img = deepcopy(array)
+    itk_img = convert_data_type(itk_img, np.ndarray)[0]
+    itk_obj = ITKWriter.create_backend_obj(itk_img, channel_dim=None, affine=affine, affine_lps=True)
+    return itk_obj
+
+
+def _resample_to_affine(itk_obj, ref_obj):
+    """linear resample"""
+    dim = itk_obj.GetImageDimension()
+    transform = itk.IdentityTransform[itk.D, dim].New()
+    interpolator = itk.LinearInterpolateImageFunction[type(itk_obj), itk.D].New()
+    resampled = itk.resample_image_filter(
+        Input=itk_obj, interpolator=interpolator, transform=transform, UseReferenceImage=True, ReferenceImage=ref_obj
+    )
+    return resampled
+
+
+@unittest.skipUnless(has_itk, "Requires itk package.")
+class TestAffineConsistencyITK(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        for k, n in ((key, FILE_PATH), (key_1, FILE_PATH_1)):
+            config = testing_data_config("images", f"{k}")
+            download_url_or_skip_test(filepath=n, **config)
+
+    def run_transform(self, img, xform_cls, args_dict):
+        if isinstance(xform_cls, Transform):
+            xform = xform_cls
+            output = xform(img, **args_dict)
+        else:
+            if isinstance(xform_cls, str):
+                xform_cls, _ = optional_import("monai.transforms", name=xform_cls)
+            if issubclass(xform_cls, MapTransform):
+                args_dict.update({"keys": keys})
+            xform = xform_cls(**args_dict)
+            if isinstance(xform, Randomizable):
+                xform.set_random_state(5)
+            output = xform(img)
+        return output
+
+    @parameterized.expand(TEST_CASES_ARRAY)
+    def test_linear_consistent(self, xform_cls, input_dict, atol):
+        """xform cls testing itk consistency"""
+        img = LoadImage(image_only=True, simple_keys=True)(FILE_PATH)
+        img = EnsureChannelFirst()(img)
+        ref_1 = _create_itk_obj(img[0], img.affine)
+        output = self.run_transform(img, xform_cls, input_dict)
+        ref_2 = _create_itk_obj(output[0], output.affine)
+        assert_allclose(output.pixdim, np.asarray(ref_2.GetSpacing()), type_test=False)
+        expected = _resample_to_affine(ref_1, ref_2)
+        # compare ref_2 and expected results from itk
+        diff = np.abs(itk.GetArrayFromImage(ref_2) - itk.GetArrayFromImage(expected))
+        avg_diff = np.mean(diff)
+
+        self.assertLess(avg_diff, atol, f"{xform_cls} avg_diff: {avg_diff}, tol: {atol}")
+
+    @parameterized.expand(TEST_CASES_DICT)
+    def test_linear_consistent_dict(self, xform_cls, input_dict, atol):
+        """xform cls testing itk consistency"""
+        img = LoadImaged(keys, image_only=True, simple_keys=True)({keys[0]: FILE_PATH, keys[1]: FILE_PATH_1})
+        img = EnsureChannelFirstd(keys)(img)
+        ref_1 = {k: _create_itk_obj(img[k][0], img[k].affine) for k in keys}
+        output = self.run_transform(img, xform_cls, input_dict)
+        ref_2 = {k: _create_itk_obj(output[k][0], output[k].affine) for k in keys}
+        expected = {k: _resample_to_affine(ref_1[k], ref_2[k]) for k in keys}
+        # compare ref_2 and expected results from itk
+        diff = {k: np.abs(itk.GetArrayFromImage(ref_2[k]) - itk.GetArrayFromImage(expected[k])) for k in keys}
+        avg_diff = {k: np.mean(diff[k]) for k in keys}
+        for k in keys:
+            self.assertLess(avg_diff[k], atol, f"{xform_cls} avg_diff: {avg_diff}, tol: {atol}")
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/integration/test_metatensor_integration.py

@@ -0,0 +1,114 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import os
+import tempfile
+import unittest
+from copy import deepcopy
+from pathlib import Path
+
+import numpy as np
+from parameterized import parameterized
+
+from monai import config as monai_config
+from monai.bundle import ConfigParser
+from monai.data import CacheDataset, DataLoader, MetaTensor, decollate_batch
+from monai.data.utils import TraceKeys
+from monai.transforms import InvertD, SaveImageD, reset_ops_id
+from monai.utils import optional_import, set_determinism
+from tests.test_utils import assert_allclose, download_url_or_skip_test, testing_data_config
+
+nib, has_nib = optional_import("nibabel")
+TINY_DIFF = 0.1
+
+keys = ("img", "seg")
+key, key_1 = "MNI152_T1_2mm", "MNI152_T1_2mm_strucseg"
+TESTS_PATH = Path(__file__).parents[1]
+FILE_PATH = os.path.join(TESTS_PATH, "testing_data", f"{key}.nii.gz")
+FILE_PATH_1 = os.path.join(TESTS_PATH, "testing_data", f"{key_1}.nii.gz")
+TEST_CASES = os.path.join(TESTS_PATH, "testing_data", "transform_metatensor_cases.yaml")
+
+
+@unittest.skipUnless(has_nib, "Requires nibabel package.")
+class TestMetaTensorIntegration(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        for k, n in ((key, FILE_PATH), (key_1, FILE_PATH_1)):
+            config = testing_data_config("images", f"{k}")
+            download_url_or_skip_test(filepath=n, **config)
+        cls.files = [{keys[0]: x, keys[1]: y} for (x, y) in [[FILE_PATH, FILE_PATH_1]] * 4]
+
+    @classmethod
+    def tearDownClass(cls):
+        super().tearDownClass()
+        set_determinism(None)
+
+    @parameterized.expand(["TEST_CASE_1", "TEST_CASE_2", "TEST_CASE_3"])
+    def test_transforms(self, case_id):
+        set_determinism(2022)
+        config = ConfigParser()
+        config.read_config(TEST_CASES)
+        config["input_keys"] = keys
+        test_case = config.get_parsed_content(id=case_id, instantiate=True, lazy=False)  # transform instance
+
+        dataset = CacheDataset(self.files, transform=test_case)
+        loader = DataLoader(dataset, batch_size=3, shuffle=True)
+        for x in loader:
+            self.assertIsInstance(x[keys[0]], MetaTensor)
+            self.assertIsInstance(x[keys[1]], MetaTensor)
+            out = decollate_batch(x)  # decollate every batch should work
+
+        # test forward patches
+        loaded = out[0]
+        if not monai_config.USE_META_DICT:
+            self.assertEqual(len(loaded), len(keys))
+        else:
+            self.assertNotEqual(len(loaded), len(keys))
+        img, seg = loaded[keys[0]], loaded[keys[1]]
+        expected = config.get_parsed_content(id=f"{case_id}_answer", instantiate=True)  # expected results
+        self.assertEqual(expected["load_shape"], list(x[keys[0]].shape))
+        assert_allclose(expected["affine"], img.affine, type_test=False, atol=TINY_DIFF, rtol=TINY_DIFF)
+        assert_allclose(expected["affine"], seg.affine, type_test=False, atol=TINY_DIFF, rtol=TINY_DIFF)
+        test_cls = [type(x).__name__ for x in test_case.transforms]
+        tracked_cls = [x[TraceKeys.CLASS_NAME] for x in img.applied_operations]
+        self.assertTrue(len(tracked_cls) <= len(test_cls))  # tracked items should  be no more than the compose items.
+        with tempfile.TemporaryDirectory() as tempdir:  # test writer
+            SaveImageD(keys, resample=False, output_dir=tempdir, output_postfix=case_id)(loaded)
+        test_data = reset_ops_id(deepcopy(loaded))
+        for val in test_data.values():
+            if isinstance(val, MetaTensor) and val.applied_operations:
+                self.assertEqual(val.applied_operations[-1][TraceKeys.ID], TraceKeys.NONE)
+
+        # test inverse
+        inv = InvertD(keys, orig_keys=keys, transform=test_case, nearest_interp=True)
+        out = inv(loaded)
+        img, seg = out[keys[0]], out[keys[1]]
+        assert_allclose(expected["inv_affine"], img.affine, type_test=False, atol=TINY_DIFF, rtol=TINY_DIFF)
+        assert_allclose(expected["inv_affine"], seg.affine, type_test=False, atol=TINY_DIFF, rtol=TINY_DIFF)
+        self.assertFalse(img.applied_operations)
+        self.assertFalse(seg.applied_operations)
+        assert_allclose(expected["inv_shape"], img.shape, type_test=False, atol=TINY_DIFF, rtol=TINY_DIFF)
+        assert_allclose(expected["inv_shape"], seg.shape, type_test=False, atol=TINY_DIFF, rtol=TINY_DIFF)
+        with tempfile.TemporaryDirectory() as tempdir:  # test writer
+            SaveImageD(keys, resample=False, output_dir=tempdir, output_postfix=case_id)(out)
+            seg_file = os.path.join(tempdir, key_1, f"{key_1}_{case_id}.nii.gz")
+            segout = nib.load(seg_file).get_fdata()
+            segin = nib.load(FILE_PATH_1).get_fdata()
+            ndiff = np.sum(np.abs(segout - segin) > 0)
+            total = np.prod(segout.shape)
+        self.assertTrue(ndiff / total < 0.4, f"{ndiff / total}")
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/integration/test_module_list.py

@@ -0,0 +1,76 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import glob
+import inspect
+import os
+import pathlib
+import unittest
+
+import monai
+
+
+class TestAllImport(unittest.TestCase):
+
+    def test_public_api(self):
+        """
+        This is to check "monai.__all__" should be consistent with
+        the top-level folders except for "__pycache__", "_extensions" and "csrc" (cpp/cuda src)
+        """
+        base_folder = os.path.dirname(monai.__file__)
+        to_search = os.path.join(base_folder, "*", "")
+        subfolders = [os.path.basename(x[:-1]) for x in glob.glob(to_search)]
+        to_exclude = ("__pycache__", "_extensions", "csrc")
+        mod = []
+        for code_folder in subfolders:
+            if code_folder in to_exclude:
+                continue
+            mod.append(code_folder)
+        self.assertEqual(sorted(monai.__all__), sorted(mod))
+
+    def test_transform_api(self):
+        """monai subclasses of MapTransforms must have alias names ending with 'd', 'D', 'Dict'"""
+        to_exclude = {"MapTransform"}  # except for these transforms
+        to_exclude_docs = {"Decollate", "Ensemble", "Invert", "SaveClassification", "RandTorchVision", "RandCrop"}
+        to_exclude_docs.update({"DeleteItems", "SelectItems", "FlattenSubKeys", "CopyItems", "ConcatItems"})
+        to_exclude_docs.update({"ToMetaTensor", "FromMetaTensor"})
+        xforms = {
+            name: obj
+            for name, obj in monai.transforms.__dict__.items()
+            if inspect.isclass(obj) and issubclass(obj, monai.transforms.MapTransform)
+        }
+        names = sorted(x for x in xforms if x not in to_exclude)
+        remained = set(names)
+        doc_file = os.path.join(pathlib.Path(__file__).parent.parent, "docs", "source", "transforms.rst")
+        contents = pathlib.Path(doc_file).read_text() if os.path.exists(doc_file) else None
+        for n in names:
+            if not n.endswith("d"):
+                continue
+            with self.subTest(n=n):
+                basename = n[:-1]  # Transformd basename is Transform
+
+                # remove aliases to check, do this before the assert below so that a failed assert does skip this
+                for postfix in ("D", "d", "Dict"):
+                    remained.remove(f"{basename}{postfix}")
+
+                for docname in (f"{basename}", f"{basename}d"):
+                    if docname in to_exclude_docs:
+                        continue
+                    if (contents is not None) and f"`{docname}`" not in f"{contents}":
+                        self.assertTrue(False, f"please add `{docname}` to docs/source/transforms.rst")
+
+        self.assertFalse(remained)
+
+
+if __name__ == "__main__":
+    unittest.main()