resolving issues mentioned in issue #114 with water_entropy argument beign ignored:

- within the `arg_config_manager.py` a new function `str2bool` ensures all types of boolean are accpeted
- `setup_argsparse` has been updated to ensure if `property` is a type `bool` it is handled correctly
- additional test cases to ensure that the modified `setup_argsparse` and the `str2bool` function works as intended

Author: harryswift01

CodeEntropy/config/arg_config_manager.py

@@ -85,15 +85,54 @@ def load_config(self, file_path):
 
         return config
 
+    def str2bool(self, value):
+        """
+        Convert a string or boolean input into a boolean value.
+
+        Accepts common string representations of boolean values such as:
+        - True values: "true", "t", "yes", "1"
+        - False values: "false", "f", "no", "0"
+
+        If the input is already a boolean, it is returned as-is.
+        Raises:
+            argparse.ArgumentTypeError: If the input cannot be interpreted as a boolean.
+
+        Args:
+            value (str or bool): The input value to convert.
+
+        Returns:
+            bool: The corresponding boolean value.
+        """
+        if isinstance(value, bool):
+            return value
+        value = value.lower()
+        if value in {"true", "t", "yes", "1"}:
+            return True
+        elif value in {"false", "f", "no", "0"}:
+            return False
+        else:
+            raise argparse.ArgumentTypeError("Boolean value expected (True/False).")
+
     def setup_argparse(self):
         """Setup argument parsing dynamically based on arg_map."""
         parser = argparse.ArgumentParser(
             description="CodeEntropy: Entropy calculation with MCC method."
         )
 
         for arg, properties in self.arg_map.items():
-            kwargs = {key: properties[key] for key in properties if key != "help"}
-            parser.add_argument(f"--{arg}", **kwargs, help=properties.get("help"))
+            help_text = properties.get("help", "")
+            default = properties.get("default", None)
+
+            if properties.get("type") == bool:
+                parser.add_argument(
+                    f"--{arg}",
+                    type=self.str2bool,
+                    default=default,
+                    help=f"{help_text} (default: {default})",
+                )
+            else:
+                kwargs = {k: v for k, v in properties.items() if k != "help"}
+                parser.add_argument(f"--{arg}", **kwargs, help=help_text)
 
         return parser
 

config.yaml

@@ -12,4 +12,4 @@ run1:
   thread:
   output_file:
   force_partitioning:
-  disable_water_entropy:
+  water_entropy:

tests/test_CodeEntropy/test_arg_config_manager.py

@@ -137,6 +137,77 @@ def test_setup_argparse(self, mock_args):
         self.assertEqual(args.top_traj_file, ["/path/to/tpr", "/path/to/trr"])
         self.assertEqual(args.selection_string, "all")
 
+    @patch(
+        "argparse.ArgumentParser.parse_args",
+        return_value=MagicMock(
+            top_traj_file=["/path/to/tpr", "/path/to/trr"],
+            start=10,
+            water_entropy=False,
+        ),
+    )
+    def test_setup_argparse_false_boolean(self, mock_args):
+        """
+        Test that non-boolean arguments are parsed correctly.
+        """
+        arg_config = ConfigManager()
+        parser = arg_config.setup_argparse()
+        args = parser.parse_args()
+
+        self.assertEqual(args.top_traj_file, ["/path/to/tpr", "/path/to/trr"])
+        self.assertEqual(args.start, 10)
+        self.assertFalse(args.water_entropy)
+
+    def test_str2bool_true_variants(self):
+        """Test that various string representations of True are correctly parsed."""
+        arg_config = ConfigManager()
+
+        self.assertTrue(arg_config.str2bool("true"))
+        self.assertTrue(arg_config.str2bool("True"))
+        self.assertTrue(arg_config.str2bool("t"))
+        self.assertTrue(arg_config.str2bool("yes"))
+        self.assertTrue(arg_config.str2bool("1"))
+
+    def test_str2bool_false_variants(self):
+        """Test that various string representations of False are correctly parsed."""
+        arg_config = ConfigManager()
+
+        self.assertFalse(arg_config.str2bool("false"))
+        self.assertFalse(arg_config.str2bool("False"))
+        self.assertFalse(arg_config.str2bool("f"))
+        self.assertFalse(arg_config.str2bool("no"))
+        self.assertFalse(arg_config.str2bool("0"))
+
+    def test_str2bool_boolean_passthrough(self):
+        """Test that boolean values passed directly are returned unchanged."""
+        arg_config = ConfigManager()
+
+        self.assertTrue(arg_config.str2bool(True))
+        self.assertFalse(arg_config.str2bool(False))
+
+    def test_str2bool_invalid_input(self):
+        """Test that invalid string inputs raise an ArgumentTypeError."""
+        arg_config = ConfigManager()
+
+        with self.assertRaises(Exception) as context:
+            arg_config.str2bool("maybe")
+        self.assertIn("Boolean value expected", str(context.exception))
+
+    def test_str2bool_empty_string(self):
+        """Test that an empty string raises an ArgumentTypeError."""
+        arg_config = ConfigManager()
+
+        with self.assertRaises(Exception) as context:
+            arg_config.str2bool("")
+        self.assertIn("Boolean value expected", str(context.exception))
+
+    def test_str2bool_unexpected_number(self):
+        """Test that unexpected numeric strings raise an ArgumentTypeError."""
+        arg_config = ConfigManager()
+
+        with self.assertRaises(Exception) as context:
+            arg_config.str2bool("2")
+        self.assertIn("Boolean value expected", str(context.exception))
+
     def test_cli_overrides_defaults(self):
         """
         Test if CLI parameters override default values.