addressing issue #83, ensuring there are sensible checks in place for the input parameters

Author: harryswift01

CodeEntropy/config/arg_config_manager.py

@@ -185,3 +185,62 @@ def merge_configs(self, args, run_config):
                 handler.setLevel(logging.INFO)
 
         return args
+
+    def input_parameters_validation(self, u, args):
+        """Check the validity of the user inputs against sensible values"""
+
+        self._check_input_start(u, args)
+        self._check_input_end(u, args)
+        self._check_input_step(args)
+        self._check_input_bin_width(args)
+        self._check_input_temperature(args)
+        self._check_input_force_partitioning(args)
+
+    def _check_input_start(self, u, args):
+        """Check that the input does not exceed the length of the trajectory."""
+        if args.start > len(u.trajectory):
+            raise ValueError(
+                f"Invalid 'start' value: {args.start}. It exceeds the trajectory length"
+                " of {len(u.trajectory)}."
+            )
+
+    def _check_input_end(self, u, args):
+        """Check that the end index does not exceed the trajectory length."""
+        if args.end > len(u.trajectory):
+            raise ValueError(
+                f"Invalid 'end' value: {args.end}. It exceeds the trajectory length of"
+                " {len(u.trajectory)}."
+            )
+
+    def _check_input_step(self, args):
+        """Check that the step value is non-negative."""
+        if args.step < 0:
+            logger.warning(
+                f"Negative 'step' value provided: {args.step}. This may lead to"
+                " unexpected behavior."
+            )
+
+    def _check_input_bin_width(self, args):
+        """Check that the bin width is within the valid range [0, 360]."""
+        if args.bin_width < 0 or args.bin_width > 360:
+            raise ValueError(
+                f"Invalid 'bin_width': {args.bin_width}. It must be between 0 and 360"
+                " degrees."
+            )
+
+    def _check_input_temperature(self, args):
+        """Check that the temperature is non-negative."""
+        if args.temperature < 0:
+            raise ValueError(
+                f"Invalid 'temperature': {args.temperature}. Temperature cannot be"
+                " below 0."
+            )
+
+    def _check_input_force_partitioning(self, args):
+        """Warn if force partitioning is not set to the default value."""
+        default_value = arg_map["force_partitioning"]["default"]
+        if args.force_partitioning != default_value:
+            logger.warning(
+                f"'force_partitioning' is set to {args.force_partitioning},"
+                " which differs from the default ({default_value})."
+            )

CodeEntropy/run.py

@@ -135,6 +135,8 @@ def run_entropy_workflow(self):
                 logger.debug(f"Loading Universe with {tprfile} and {trrfile}")
                 u = mda.Universe(tprfile, trrfile)
 
+                self._config_manager.input_parameters_validation(u, args)
+
                 # Create LevelManager instance
                 level_manager = LevelManager()
 

tests/test_CodeEntropy/test_arg_config_manager.py

@@ -494,6 +494,103 @@ def test_empty_yaml_config(self, mock_exists, mock_file):
         self.assertIsInstance(config, dict)
         self.assertEqual(config, {})
 
+    def test_input_parameters_validation_all_valid(self):
+        """Test that input_parameters_validation passes with all valid inputs."""
+        manager = ConfigManager()
+        u = MagicMock()
+        u.trajectory = [0] * 100
+
+        args = MagicMock(
+            start=10,
+            end=90,
+            step=1,
+            bin_width=30,
+            temperature=298.0,
+            force_partitioning=0.5,
+        )
+
+        with patch.dict(
+            "CodeEntropy.config.arg_config_manager.arg_map",
+            {"force_partitioning": {"default": 0.5}},
+        ):
+            manager.input_parameters_validation(u, args)
+
+    def test_check_input_start_valid(self):
+        """Test that a valid 'start' value does not raise an error."""
+        args = MagicMock(start=50)
+        u = MagicMock()
+        u.trajectory = [0] * 100
+        ConfigManager()._check_input_start(u, args)
+
+    def test_check_input_start_invalid(self):
+        """Test that an invalid 'start' value raises a ValueError."""
+        args = MagicMock(start=150)
+        u = MagicMock()
+        u.trajectory = [0] * 100
+        with self.assertRaises(ValueError):
+            ConfigManager()._check_input_start(u, args)
+
+    def test_check_input_end_valid(self):
+        """Test that a valid 'end' value does not raise an error."""
+        args = MagicMock(end=100)
+        u = MagicMock()
+        u.trajectory = [0] * 100
+        ConfigManager()._check_input_end(u, args)
+
+    def test_check_input_end_invalid(self):
+        """Test that an 'end' value exceeding trajectory length raises a ValueError."""
+        args = MagicMock(end=101)
+        u = MagicMock()
+        u.trajectory = [0] * 100
+        with self.assertRaises(ValueError):
+            ConfigManager()._check_input_end(u, args)
+
+    @patch("CodeEntropy.config.arg_config_manager.logger")
+    def test_check_input_step_negative(self, mock_logger):
+        """Test that a negative 'step' value triggers a warning."""
+        args = MagicMock(step=-1)
+        ConfigManager()._check_input_step(args)
+        mock_logger.warning.assert_called_once()
+
+    def test_check_input_bin_width_valid(self):
+        """Test that a valid 'bin_width' value does not raise an error."""
+        args = MagicMock(bin_width=180)
+        ConfigManager()._check_input_bin_width(args)
+
+    def test_check_input_bin_width_invalid_low(self):
+        """Test that a negative 'bin_width' value raises a ValueError."""
+        args = MagicMock(bin_width=-10)
+        with self.assertRaises(ValueError):
+            ConfigManager()._check_input_bin_width(args)
+
+    def test_check_input_bin_width_invalid_high(self):
+        """Test that a 'bin_width' value above 360 raises a ValueError."""
+        args = MagicMock(bin_width=400)
+        with self.assertRaises(ValueError):
+            ConfigManager()._check_input_bin_width(args)
+
+    def test_check_input_temperature_valid(self):
+        """Test that a valid 'temperature' value does not raise an error."""
+        args = MagicMock(temperature=298.0)
+        ConfigManager()._check_input_temperature(args)
+
+    def test_check_input_temperature_invalid(self):
+        """Test that a negative 'temperature' value raises a ValueError."""
+        args = MagicMock(temperature=-5)
+        with self.assertRaises(ValueError):
+            ConfigManager()._check_input_temperature(args)
+
+    @patch("CodeEntropy.config.arg_config_manager.logger")
+    def test_check_input_force_partitioning_warning(self, mock_logger):
+        """Test that a non-default 'force_partitioning' value triggers a warning."""
+        args = MagicMock(force_partitioning=0.7)
+        with patch.dict(
+            "CodeEntropy.config.arg_config_manager.arg_map",
+            {"force_partitioning": {"default": 0.5}},
+        ):
+            ConfigManager()._check_input_force_partitioning(args)
+            mock_logger.warning.assert_called_once()
+
 
 if __name__ == "__main__":
     unittest.main()