Automatic type conversion for config values (#1499)

Author: zariiii9003

can/logger.py

@@ -8,6 +8,7 @@
 import can
 from can.io import BaseRotatingLogger
 from can.io.generic import MessageWriter
+from can.util import cast_from_string
 from . import Bus, BusState, Logger, SizedRotatingLogger
 from .typechecking import CanFilter, CanFilters
 
@@ -134,18 +135,7 @@ def _split_arg(_arg: str) -> Tuple[str, str]:
 
     args: Dict[str, Union[str, int, float, bool]] = {}
     for key, string_val in map(_split_arg, unknown_args):
-        if re.match(r"^[-+]?\d+$", string_val):
-            # value is integer
-            args[key] = int(string_val)
-        elif re.match(r"^[-+]?\d*\.\d+$", string_val):
-            # value is float
-            args[key] = float(string_val)
-        elif re.match(r"^(?:True|False)$", string_val):
-            # value is bool
-            args[key] = string_val == "True"
-        else:
-            # value is string
-            args[key] = string_val
+        args[key] = cast_from_string(string_val)
     return args
 
 

can/util.py

@@ -147,7 +147,7 @@ def load_config(
         It may set other values that are passed through.
 
     :param context:
-        Extra 'context' pass to config sources. This can be use to section
+        Extra 'context' pass to config sources. This can be used to section
         other than 'default' in the configuration file.
 
     :return:
@@ -197,9 +197,12 @@ def load_config(
                 cfg["interface"] = cfg["bustype"]
             del cfg["bustype"]
         # copy all new parameters
-        for key in cfg:
+        for key, val in cfg.items():
             if key not in config:
-                config[key] = cfg[key]
+                if isinstance(val, str):
+                    config[key] = cast_from_string(val)
+                else:
+                    config[key] = cfg[key]
 
     bus_config = _create_bus_config(config)
     can.log.debug("can config: %s", bus_config)
@@ -257,12 +260,8 @@ def _create_bus_config(config: Dict[str, Any]) -> typechecking.BusConfig:
         except (ValueError, TypeError):
             pass
 
-    if "bitrate" in config:
-        config["bitrate"] = int(config["bitrate"])
     if "fd" in config:
-        config["fd"] = config["fd"] not in ("0", "False", "false", False)
-    if "data_bitrate" in config:
-        config["data_bitrate"] = int(config["data_bitrate"])
+        config["fd"] = config["fd"] not in (0, False)
 
     return cast(typechecking.BusConfig, config)
 
@@ -478,6 +477,28 @@ def time_perfcounter_correlation() -> Tuple[float, float]:
     return t1, performance_counter
 
 
+def cast_from_string(string_val: str) -> Union[str, int, float, bool]:
+    """Perform trivial type conversion from :class:`str` values.
+
+    :param string_val:
+        the string, that shall be converted
+    """
+    if re.match(r"^[-+]?\d+$", string_val):
+        # value is integer
+        return int(string_val)
+
+    if re.match(r"^[-+]?\d*\.\d+(?:e[-+]?\d+)?$", string_val):
+        # value is float
+        return float(string_val)
+
+    if re.match(r"^(?:True|False)$", string_val, re.IGNORECASE):
+        # value is bool
+        return string_val.lower() == "true"
+
+    # value is string
+    return string_val
+
+
 if __name__ == "__main__":
     print("Searching for configuration named:")
     print("\n".join(CONFIG_FILES))

test/test_load_config.py

@@ -1,20 +1,25 @@
 #!/usr/bin/env python
 
-import os
 import shutil
 import tempfile
 import unittest
+import unittest.mock
 from tempfile import NamedTemporaryFile
 
 import can
 
 
 class LoadConfigTest(unittest.TestCase):
-    configuration = {
+    configuration_in = {
         "default": {"interface": "serial", "channel": "0"},
         "one": {"interface": "kvaser", "channel": "1", "bitrate": 100000},
         "two": {"channel": "2"},
     }
+    configuration_out = {
+        "default": {"interface": "serial", "channel": 0},
+        "one": {"interface": "kvaser", "channel": 1, "bitrate": 100000},
+        "two": {"channel": 2},
+    }
 
     def setUp(self):
         # Create a temporary directory
@@ -31,7 +36,7 @@ def _gen_configration_file(self, sections):
             content = []
             for section in sections:
                 content.append(f"[{section}]")
-                for k, v in self.configuration[section].items():
+                for k, v in self.configuration_in[section].items():
                     content.append(f"{k} = {v}")
             tmp_config_file.write("\n".join(content))
             return tmp_config_file.name
@@ -42,43 +47,43 @@ def _dict_to_env(self, d):
     def test_config_default(self):
         tmp_config = self._gen_configration_file(["default"])
         config = can.util.load_config(path=tmp_config)
-        self.assertEqual(config, self.configuration["default"])
+        self.assertEqual(config, self.configuration_out["default"])
 
     def test_config_whole_default(self):
-        tmp_config = self._gen_configration_file(self.configuration)
+        tmp_config = self._gen_configration_file(self.configuration_in)
         config = can.util.load_config(path=tmp_config)
-        self.assertEqual(config, self.configuration["default"])
+        self.assertEqual(config, self.configuration_out["default"])
 
     def test_config_whole_context(self):
-        tmp_config = self._gen_configration_file(self.configuration)
+        tmp_config = self._gen_configration_file(self.configuration_in)
         config = can.util.load_config(path=tmp_config, context="one")
-        self.assertEqual(config, self.configuration["one"])
+        self.assertEqual(config, self.configuration_out["one"])
 
     def test_config_merge_context(self):
-        tmp_config = self._gen_configration_file(self.configuration)
+        tmp_config = self._gen_configration_file(self.configuration_in)
         config = can.util.load_config(path=tmp_config, context="two")
-        expected = self.configuration["default"]
-        expected.update(self.configuration["two"])
+        expected = self.configuration_out["default"].copy()
+        expected.update(self.configuration_out["two"])
         self.assertEqual(config, expected)
 
     def test_config_merge_environment_to_context(self):
-        tmp_config = self._gen_configration_file(self.configuration)
+        tmp_config = self._gen_configration_file(self.configuration_in)
         env_data = {"interface": "serial", "bitrate": 125000}
         env_dict = self._dict_to_env(env_data)
         with unittest.mock.patch.dict("os.environ", env_dict):
             config = can.util.load_config(path=tmp_config, context="one")
-        expected = self.configuration["one"]
+        expected = self.configuration_out["one"].copy()
         expected.update(env_data)
         self.assertEqual(config, expected)
 
     def test_config_whole_environment(self):
-        tmp_config = self._gen_configration_file(self.configuration)
+        tmp_config = self._gen_configration_file(self.configuration_in)
         env_data = {"interface": "socketcan", "channel": "3", "bitrate": 250000}
         env_dict = self._dict_to_env(env_data)
         with unittest.mock.patch.dict("os.environ", env_dict):
             config = can.util.load_config(path=tmp_config, context="one")
-        expected = self.configuration["one"]
-        expected.update(env_data)
+        expected = self.configuration_out["one"].copy()
+        expected.update({"interface": "socketcan", "channel": 3, "bitrate": 250000})
         self.assertEqual(config, expected)
 
 

test/test_util.py

@@ -13,6 +13,7 @@
     channel2int,
     deprecated_args_alias,
     check_or_adjust_timing_clock,
+    cast_from_string,
 )
 
 
@@ -262,3 +263,27 @@ def test_adjust_timing_fd(self):
 
         with pytest.raises(CanInitializationError):
             check_or_adjust_timing_clock(timing, valid_clocks=[8_000, 16_000])
+
+
+class TestCastFromString(unittest.TestCase):
+    def test_cast_from_string(self) -> None:
+        self.assertEqual(1, cast_from_string("1"))
+        self.assertEqual(-1, cast_from_string("-1"))
+        self.assertEqual(0, cast_from_string("-0"))
+        self.assertEqual(1.1, cast_from_string("1.1"))
+        self.assertEqual(-1.1, cast_from_string("-1.1"))
+        self.assertEqual(0.1, cast_from_string(".1"))
+        self.assertEqual(10.0, cast_from_string(".1e2"))
+        self.assertEqual(0.001, cast_from_string(".1e-2"))
+        self.assertEqual(-0.001, cast_from_string("-.1e-2"))
+        self.assertEqual("text", cast_from_string("text"))
+        self.assertEqual("", cast_from_string(""))
+        self.assertEqual("can0", cast_from_string("can0"))
+        self.assertEqual("0can", cast_from_string("0can"))
+        self.assertEqual(False, cast_from_string("false"))
+        self.assertEqual(False, cast_from_string("False"))
+        self.assertEqual(True, cast_from_string("true"))
+        self.assertEqual(True, cast_from_string("True"))
+
+        with self.assertRaises(TypeError):
+            cast_from_string(None)