Merge pull request #51 from vedb/devel

Release 0.5

.bumpversion.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 0.4.1
+current_version = 0.5.0
 commit = True
 
 [bumpversion:file:setup.py]

installer/install_ved_capture.py

@@ -28,8 +28,7 @@
 import re
 
 
-__installer_version = "1.4.3"
-__maintainer_email = "peter.hausamann@tum.de"
+__installer_version = "1.4.4"
 
 # -- LOGGING -- #
 logger = logging.getLogger(Path(__file__).stem)
@@ -176,9 +175,9 @@ def handle_process(process, command, error_msg, n_bytes=4096):
                 " ".join([str(c) for c in command])
                 + f" failed with exit code {return_code}. See the output "
                 f"above for more information. If you don't know how to fix "
-                f"this by yourself, please send an email with the "
-                f"'install_ved_capture.log' file located in "
-                f"{Path(__file__).resolve().parent} to {__maintainer_email}.",
+                f"this by yourself, please send a message on the #software "
+                f"Slack channel and attach the 'install_ved_capture.log' "
+                f"file located in {Path(__file__).resolve().parent}.",
             )
         else:
             logger.error(error_msg)
@@ -666,8 +665,8 @@ def write_paths(
     if not show_welcome_message(args.yes):
         logger.info(
             f"\nPlease create an account at https://www.github.com and send "
-            f"an email with your user name to {__maintainer_email} to get "
-            f"access.",
+            f"a message with your user name on the #software Slack channel to "
+            f"get access.",
         )
         abort()
 

setup.py

@@ -9,7 +9,7 @@
 
 setup(
     name="ved-capture",
-    version="0.4.1",
+    version="0.5.0",
     packages=find_packages(),
     long_description=open("README.md").read(),
     entry_points="""

tests/conftest.py

@@ -3,7 +3,7 @@
 
 import pytest
 
-from ved_capture.config import APPNAME
+from ved_capture.config import APPNAME, ConfigParser
 
 
 @pytest.fixture()
@@ -26,7 +26,36 @@ def user_config_dir(test_data_dir, config_dir):
 
 
 @pytest.fixture(autouse=True)
-def set_config_search_path():
+def set_config_search_path(config_dir):
     """ Override local configuration for tests. """
-    # assuming test dir does not contain a config file...
-    os.environ[APPNAME.upper() + "DIR"] = str(Path(__file__).parent)
+    os.environ[APPNAME.upper() + "DIR"] = str(config_dir)
+
+
+@pytest.fixture()
+def config_file(config_dir):
+    """ Path to the test config file. """
+    yield Path(config_dir) / "config.yaml"
+
+
+@pytest.fixture()
+def parser():
+    """ Parser with test config. """
+    yield ConfigParser()
+
+
+@pytest.fixture()
+def parser_default():
+    """ Parser with default config. """
+    yield ConfigParser(ignore_user=True)
+
+
+@pytest.fixture()
+def parser_minimal(config_dir):
+    """ Parser with minimal config (standard user config). """
+    yield ConfigParser(Path(config_dir) / "config_minimal.yaml")
+
+
+@pytest.fixture()
+def parser_override(config_dir):
+    """ Parser with overriding config (e.g. from generate_config). """
+    yield ConfigParser(Path(config_dir) / "config_override.yaml")

tests/test_config.py

@@ -1,80 +1,149 @@
-import os
 from pathlib import Path
 
 import pytest
+from confuse import NotFoundError
 
-from ved_capture.config import APPNAME, ConfigParser
+from ved_capture.config import ConfigParser, flatten, save_config
 
 
 class TestConfigParser:
-    @pytest.fixture()
-    def config_file(self, config_dir):
-        """"""
-        yield Path(config_dir) / "config.yaml"
-
-    @pytest.fixture()
-    def parser(self, config_file):
-        """"""
-        yield ConfigParser(config_file)
-
     def test_constructor(self, config_dir, config_file):
         """"""
+        # path to file
         parser = ConfigParser(config_file)
         assert (
-            parser.config["streams"]["video"]["t265"]["device_type"].get()
+            parser.config["streams"]["video"]["t265"]["device_uid"].get()
             == "t265"
         )
 
-        parser = ConfigParser()
+        # package default
+        parser = ConfigParser(ignore_user=True)
         assert (
-            parser.config["commands"]["record"]["metadata"]["study_site"].get()
+            parser.config["streams"]["video"]["t265"]["device_uid"].get()
             is None
         )
 
-        # config name
-        os.environ[APPNAME.upper() + "DIR"] = str(config_dir)
+        # config file by name
         parser = ConfigParser("config_minimal")
         assert (
-            parser.config["streams"]["video"]["world"]["device_type"].get()
-            == "uvc"
+            parser.config["commands"]["record"]["metadata"]["study_site"].get()
+            == "test_site"
         )
 
-    def test_get_folder(self, parser, config_dir):
+    def test_get_stream_config(self, parser, parser_override):
+        """"""
+        # single updated value
+        assert parser.get_stream_config("video", "eye0", "fps") == 200
+
+        # whole dict
+        assert set(parser.get_stream_config("video", "eye0").keys()) == {
+            "device_type",
+            "device_uid",
+            "resolution",
+            "fps",
+            "color_format",
+            "exposure_mode",
+            "controls",
+        }
+
+        # override
+        assert set(
+            parser_override.get_stream_config("video", "t265").keys()
+        ) == {
+            "device_type",
+            "device_uid",
+            "resolution",
+            "fps",
+            "color_format",
+        }
+
+    def test_get_command_config(self, parser, parser_override):
+        """"""
+        # single updated value
+        assert parser.get_command_config("record", "policy") == "overwrite"
+
+        # whole dict
+        assert set(parser.get_command_config("record", "motion").keys()) == {
+            "odometry",
+            "accel",
+            "gyro",
+        }
+
+        # override
+        assert set(parser_override.get_command_config("record").keys()) == {
+            "video",
+            "motion",
+            "folder",
+            "policy",
+        }
+
+    def test_set_profile(self, parser):
+        """"""
+        parser.set_profile("outdoor")
+        assert (
+            parser.get_stream_config("video", "eye0", "controls", "Gamma")
+            == 10
+        )
+
+        with pytest.raises(NotFoundError):
+            parser.set_profile("not_a_profile")
+
+    def test_get_folder(
+        self, parser, parser_minimal, parser_override, config_dir
+    ):
         """"""
         import datetime
 
-        folder = parser.get_folder("record", None)
+        # with metadata
+        folder = parser.get_folder("record", subject_id="000")
+        assert folder == config_dir.parent / "out" / "recordings" / "000"
+
+        # minimal config / package default
+        folder = parser_minimal.get_folder("record")
         assert (
-            folder == config_dir / "out" / f"{datetime.date.today():%Y-%m-%d}"
+            folder
+            == Path.home()
+            / "recordings"
+            / f"{datetime.datetime.today():%Y_%m_%d_%H_%M_%S}"
         )
 
-    def test_get_policy(self, parser):
+        # override
+        folder = parser_override.get_folder("record")
+        assert folder == Path.home() / "recordings" / "vedc_test"
+
+        # user specified
+        folder = parser.get_folder("record", folder=config_dir)
+        assert folder == config_dir
+
+    def test_get_policy(self, parser, parser_minimal, parser_override):
         """"""
         # test config file
         assert parser.get_policy("record") == "overwrite"
-        # user override
+        # minimal/package default
+        assert parser_minimal.get_policy("record") == "here"
+        # override
+        assert parser_override.get_policy("record") == "overwrite"
+        # user specified
         assert parser.get_policy("record", "new_folder") == "new_folder"
-        # package default
-        assert ConfigParser().get_policy("record") == "here"
 
-    def test_get_show_video(self, parser):
+    def test_get_show_video(self, parser, parser_minimal):
         """"""
         # test config file
         assert parser.get_show_video()
-        # user override
+        # minimal/package default
+        assert not parser_minimal.get_show_video()
+        # user specified
         assert not parser.get_show_video(False)
-        # package default
-        assert not ConfigParser().get_show_video()
 
-    def test_get_recording_cam_params(self, parser):
+    def test_get_recording_cam_params(self, parser_minimal):
         """"""
-        # package default
-        assert ConfigParser().get_recording_cam_params() == (
+        # minimal/package default
+        assert parser_minimal.get_recording_cam_params() == (
             ["world"],
             ["world", "t265"],
         )
 
-    def test_get_metadata(self, parser, monkeypatch):
+    def test_get_metadata(self, parser, parser_override, monkeypatch):
         """"""
         # as list
         monkeypatch.setattr("builtins.input", lambda x: "000")
@@ -87,20 +156,28 @@ def test_get_metadata(self, parser, monkeypatch):
         monkeypatch.setattr("builtins.input", lambda x: "001")
         assert parser.get_metadata() == {"subject_id": "001"}
 
+        # override
+        assert parser_override.get_metadata() == {}
+
     def test_get_recording_configs(self, parser):
         """"""
         # TODO add __eq__ to Config to handle equality check
         config_list = parser.get_recording_configs()
 
         assert config_list[0].stream_type == "video"
-        assert config_list[0].device_type == "t265"
-        assert config_list[0].resolution == (1696, 800)
+        assert config_list[0].device_type == "flir"
+        assert config_list[0].device_uid == "flir"
+        assert config_list[0].resolution == (2048, 1536)
         assert config_list[0].pipeline[0].process_type == "video_recorder"
         assert config_list[0].pipeline[1].process_type == "video_display"
 
-        assert config_list[1].stream_type == "motion"
-        assert config_list[1].device_type == "t265"
-        assert config_list[1].pipeline[0].process_type == "motion_recorder"
+        assert config_list[1].fps == 200
+        assert config_list[2].fps == 200
+
+        assert config_list[4].stream_type == "motion"
+        assert config_list[4].device_type == "t265"
+        assert config_list[4].device_uid == "t265"
+        assert config_list[4].pipeline[0].process_type == "motion_recorder"
 
     def test_get_calibration_configs(self, parser):
         """"""
@@ -168,3 +245,31 @@ def test_get_show_configs(self, parser):
 
         assert config_list[1].device_type == "t265"
         assert config_list[1].pipeline[0].process_type == "video_display"
+
+
+class TestMethods:
+    def test_flatten(self, parser, parser_override):
+        """"""
+        config = flatten(parser.config)
+        assert config["streams"]["video"]["eye0"]["fps"] == 200
+
+        config = flatten(parser_override.config)
+        assert set(config["commands"].keys()) == {
+            "override",
+            "record",
+            "estimate_cam_params",
+            "validate",
+            "calibrate",
+        }
+        assert set(config["streams"]["video"].keys()) == {"t265"}
+
+    def test_save_config(self, tmpdir, parser, parser_override):
+        """"""
+        # dict
+        save_config(tmpdir, {})
+
+        # config
+        save_config(tmpdir, parser.config)
+
+        # override config
+        save_config(tmpdir, parser_override.config)