monai-weekly 1.5.dev2506__py3-none-any.whl → 1.5.dev2508__py3-none-any.whl

tests/utils/misc/test_ensure_tuple.py

@@ -0,0 +1,53 @@
+# 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 unittest
+
+import numpy as np
+import torch
+from parameterized import parameterized
+
+from monai.utils.misc import ensure_tuple
+from tests.test_utils import assert_allclose
+
+TESTS = [
+    ["test", ("test",)],
+    [["test1", "test2"], ("test1", "test2")],
+    [123, (123,)],
+    [(1, [2], 3), (1, [2], 3)],
+    [(1, 2, 3), (1, 2, 3), True],
+    [np.array([1, 2]), (np.array([1, 2]),), True],
+    [np.array([1, 2]), (1, 2), False],
+    [torch.tensor([1, 2]), (torch.tensor([1, 2]),), True],
+    [np.array([]), (np.array([]),)],
+    [torch.tensor([]), (torch.tensor([]),)],
+    [np.array(123), (np.array(123),), True],
+    [torch.tensor(123), (torch.tensor(123),)],
+]
+
+
+class TestEnsureTuple(unittest.TestCase):
+    @parameterized.expand(TESTS)
+    def test_value(self, input, expected_value, wrap_array=False):
+        result = ensure_tuple(input, wrap_array)
+
+        self.assertTrue(isinstance(result, tuple))
+        if isinstance(input, (np.ndarray, torch.Tensor)):
+            for i, j in zip(result, expected_value):
+                assert_allclose(i, j)
+        else:
+            self.assertTupleEqual(result, expected_value)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/utils/misc/test_monai_env_vars.py

@@ -0,0 +1,44 @@
+# 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 monai.utils.misc import MONAIEnvVars
+
+
+class TestMONAIEnvVars(unittest.TestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        super(__class__, cls).setUpClass()
+        cls.orig_value = str(MONAIEnvVars.debug())
+
+    @classmethod
+    def tearDownClass(cls):
+        if cls.orig_value is not None:
+            os.environ["MONAI_DEBUG"] = cls.orig_value
+        else:
+            os.environ.pop("MONAI_DEBUG")
+        print("MONAI debug value:", str(MONAIEnvVars.debug()))
+        super(__class__, cls).tearDownClass()
+
+    def test_monai_env_vars(self):
+        for debug in (False, True):
+            os.environ["MONAI_DEBUG"] = str(debug)
+            self.assertEqual(os.environ.get("MONAI_DEBUG"), str(debug))
+            self.assertEqual(MONAIEnvVars.debug(), debug)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/utils/misc/test_monai_utils_misc.py

@@ -0,0 +1,103 @@
+# 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 parameterized import parameterized
+
+from monai.utils.misc import MONAIEnvVars, check_kwargs_exist_in_class_init, run_cmd, to_tuple_of_dictionaries
+
+TO_TUPLE_OF_DICTIONARIES_TEST_CASES = [
+    ({}, tuple(), tuple()),
+    ({}, ("x",), ({},)),
+    ({}, ("x", "y"), ({}, {})),
+    ({"a": 1}, tuple(), tuple()),
+    ({"a": 1}, ("x",), ({"a": 1},)),
+    ({"a": (1,)}, ("x",), ({"a": 1},)),
+    ({"a": (1,)}, ("x", "y"), ValueError()),
+    ({"a": 1}, ("x", "y"), ({"a": 1}, {"a": 1})),
+    ({"a": (1, 2)}, tuple(), tuple()),
+    ({"a": (1, 2)}, ("x", "y"), ({"a": 1}, {"a": 2})),
+    ({"a": (1, 2, 3)}, ("x", "y"), ValueError()),
+    ({"b": (2,), "a": 1}, tuple(), tuple()),
+    ({"b": (2,), "a": 1}, ("x",), ({"b": 2, "a": 1},)),
+    ({"b": (2,), "a": 1}, ("x", "y"), ValueError()),
+    ({"b": (3, 2), "a": 1}, tuple(), tuple()),
+    ({"b": (3, 2), "a": 1}, ("x",), ValueError()),
+    ({"b": (3, 2), "a": 1}, ("x", "y"), ({"b": 3, "a": 1}, {"b": 2, "a": 1})),
+]
+
+
+class MiscClass:
+
+    def __init__(self, arg1, arg2, kwargs1=None, kwargs2=None):
+        pass
+
+
+class TestToTupleOfDictionaries(unittest.TestCase):
+
+    @parameterized.expand(TO_TUPLE_OF_DICTIONARIES_TEST_CASES)
+    def test_to_tuple_of_dictionaries(self, dictionary, keys, expected):
+        self._test_to_tuple_of_dictionaries(dictionary, keys, expected)
+
+    def _test_to_tuple_of_dictionaries(self, dictionary, keys, expected):
+        if isinstance(expected, Exception):
+            with self.assertRaises(type(expected)):
+                to_tuple_of_dictionaries(dictionary, keys)
+            print(type(expected))
+        else:
+            actual = to_tuple_of_dictionaries(dictionary, keys)
+            print(actual, expected)
+            self.assertTupleEqual(actual, expected)
+
+
+class TestMiscKwargs(unittest.TestCase):
+
+    def test_kwargs(self):
+        present, extra_args = self._custom_user_function(MiscClass, 1, kwargs1="value1", kwargs2="value2")
+        self.assertEqual(present, True)
+        self.assertEqual(extra_args, set())
+        present, extra_args = self._custom_user_function(MiscClass, 1, kwargs1="value1", kwargs3="value3")
+        self.assertEqual(present, False)
+        self.assertEqual(extra_args, {"kwargs3"})
+
+    def _custom_user_function(self, cls, *args, **kwargs):
+        return check_kwargs_exist_in_class_init(cls, kwargs)
+
+
+class TestCommandRunner(unittest.TestCase):
+
+    def setUp(self):
+        self.orig_flag = str(MONAIEnvVars.debug())
+
+    def tearDown(self):
+        if self.orig_flag is not None:
+            os.environ["MONAI_DEBUG"] = self.orig_flag
+        else:
+            os.environ.pop("MONAI_DEBUG")
+
+    def test_run_cmd(self):
+        cmd1 = "python"
+        cmd2 = "-c"
+        cmd3 = 'import sys; print("\\tThis is on stderr\\n", file=sys.stderr); sys.exit(1)'
+        os.environ["MONAI_DEBUG"] = str(True)
+        with self.assertRaises(RuntimeError) as cm:
+            run_cmd([cmd1, cmd2, cmd3], check=True)
+        self.assertIn("This is on stderr", str(cm.exception))
+        self.assertNotIn("\\n", str(cm.exception))
+        self.assertNotIn("\\t", str(cm.exception))
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/utils/misc/test_str2bool.py

@@ -0,0 +1,34 @@
+# 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 unittest
+
+from monai.utils.misc import str2bool
+
+
+class TestStr2Bool(unittest.TestCase):
+
+    def test_str_2_bool(self):
+        for i in ("yes", "true", "t", "y", "1", True):
+            self.assertTrue(str2bool(i))
+        for i in ("no", "false", "f", "n", "0", False):
+            self.assertFalse(str2bool(i))
+        for bad_value in ("test", 0, 1, 2, None):
+            self.assertFalse(str2bool(bad_value, default=False, raise_exc=False))
+            self.assertTrue(str2bool(bad_value, default=True, raise_exc=False))
+            with self.assertRaises(ValueError):
+                self.assertTrue(str2bool(bad_value))
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/utils/misc/test_str2list.py

@@ -0,0 +1,33 @@
+# 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 unittest
+
+from monai.utils.misc import str2list
+
+
+class TestStr2List(unittest.TestCase):
+
+    def test_str_2_list(self):
+        for i in ("1,2,3", "1, 2, 3", "1,2e-0,3.0", [1, 2, 3]):
+            self.assertEqual(str2list(i), [1, 2, 3])
+        for i in ("1,2,3", "1,2,3,4.3", [1, 2, 3, 4.001]):
+            self.assertNotEqual(str2list(i), [1, 2, 3, 4])
+        for bad_value in ((1, 3), int):
+            self.assertIsNone(str2list(bad_value, raise_exc=False))
+            with self.assertRaises(ValueError):
+                self.assertIsNone(str2list(bad_value))
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/utils/test_alias.py

@@ -0,0 +1,44 @@
+# 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 unittest
+from pathlib import Path
+
+from monai.utils import optional_import
+
+TESTS_PATH = Path(__file__).parents[1]
+
+
+class TestModuleAlias(unittest.TestCase):
+    """check that 'import monai.xx.file_name' returns a module"""
+
+    def test_files(self):
+        src_dir = os.path.dirname(TESTS_PATH)
+        monai_dir = os.path.join(src_dir, "monai")
+        py_files = glob.glob(os.path.join(monai_dir, "**", "*.py"), recursive=True)
+        for x in py_files:
+            if os.path.basename(x).startswith("_"):
+                continue
+            mod_name = x[len(src_dir) : -3]  # create relative path
+            mod_name = mod_name[1:].replace(mod_name[0], ".")
+            mod, cls = mod_name.rsplit(".", 1)
+            obj, exist = optional_import(mod, name=cls)
+            if exist:
+                self.assertTrue(inspect.ismodule(obj), msg=mod_name)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/utils/test_component_store.py

@@ -0,0 +1,73 @@
+# 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 unittest
+
+from monai.utils import ComponentStore
+
+
+class TestComponentStore(unittest.TestCase):
+
+    def setUp(self):
+        self.cs = ComponentStore("TestStore", "I am a test store, please ignore")
+
+    def test_empty(self):
+        self.assertEqual(len(self.cs), 0)
+        self.assertEqual(list(self.cs), [])
+
+    def test_add(self):
+        test_obj = object()
+
+        self.assertFalse("test_obj" in self.cs)
+
+        self.cs.add("test_obj", "Test object", test_obj)
+
+        self.assertTrue("test_obj" in self.cs)
+
+        self.assertEqual(len(self.cs), 1)
+        self.assertEqual(list(self.cs), [("test_obj", test_obj)])
+
+        self.assertEqual(self.cs.test_obj, test_obj)
+        self.assertEqual(self.cs["test_obj"], test_obj)
+
+    def test_add2(self):
+        test_obj1 = object()
+        test_obj2 = object()
+
+        self.cs.add("test_obj1", "Test object", test_obj1)
+        self.cs.add("test_obj2", "Test object", test_obj2)
+
+        self.assertEqual(len(self.cs), 2)
+        self.assertIn("test_obj1", self.cs)
+        self.assertIn("test_obj2", self.cs)
+
+    def test_add_def(self):
+        self.assertNotIn("test_func", self.cs)
+
+        @self.cs.add_def("test_func", "Test function")
+        def test_func():
+            return 123
+
+        self.assertIn("test_func", self.cs)
+
+        self.assertEqual(len(self.cs), 1)
+        self.assertEqual(list(self.cs), [("test_func", test_func)])
+
+        self.assertEqual(self.cs.test_func, test_func)
+        self.assertEqual(self.cs["test_func"], test_func)
+
+        # try adding the same function again
+        self.cs.add_def("test_func", "Test function but with new description")(test_func)
+
+        self.assertEqual(len(self.cs), 1)
+        self.assertEqual(self.cs.test_func, test_func)