Add range and levels error handling

backend/src/manager.py

@@ -106,8 +106,19 @@ class Manager:
                 unknown_names = ", ".join(sorted(str(s) for s in unknown_symbols))
                 raise ValueError(f"Unknown variable(s): {unknown_names}. Allowed: x1, x2")
 
-            x1_range = self._parse_range(x1_range_input)
-            x2_range = self._parse_range(x2_range_input)
+            if not x1_range_input.strip():
+                raise ValueError("x1 range cannot be empty")
+            if not x2_range_input.strip():
+                raise ValueError("x2 range cannot be empty")
+
+            try:
+                x1_range = self._parse_range(x1_range_input)
+            except Exception as e:
+                raise ValueError(f"Invalid x1 range: {e}")
+            try:
+                x2_range = self._parse_range(x2_range_input)
+            except Exception as e:
+                raise ValueError(f"Invalid x2 range: {e}")
 
             method = x_selection_method.lower()
             if method not in ("grid", "random"):
@@ -154,9 +165,19 @@ class Manager:
         if regularizer_type not in ("l1", "l2"):
             raise ValueError(f"Invalid regularizer_type: {regularizer_type}")
 
-        reg_levels = self._parse_levels(reg_levels_input)
-        w1_range = self._parse_range(w1_range_input)
-        w2_range = self._parse_range(w2_range_input)
+        try:
+            reg_levels = self._parse_levels(reg_levels_input)
+        except Exception as e:
+            raise ValueError(f"Invalid regularization levels: {e}")
+
+        try:
+            w1_range = self._parse_range(w1_range_input)
+        except Exception as e:
+            raise ValueError(f"Invalid w1 range: {e}")
+        try:
+            w2_range = self._parse_range(w2_range_input)
+        except Exception as e:
+            raise ValueError(f"Invalid w2 range: {e}")
 
         self.plots_data = compute_plot_values(
             self.dataset,
@@ -352,16 +373,44 @@ class Manager:
 
     @staticmethod
     def _parse_range(range_input: str) -> tuple[float, float]:
-        values = tuple(float(x.strip()) for x in range_input.split(","))
+        values = tuple(x.strip() for x in range_input.split(","))
+
         if len(values) != 2:
             raise ValueError("Range must contain exactly two comma-separated values")
-        return values
+
+        low = values[0]
+        high = values[1]
+
+        if low == "":
+            raise ValueError("Range lower bound cannot be empty")
+        if high == "":
+            raise ValueError("Range upper bound cannot be empty")
+
+        try:
+            low = float(low)
+            high = float(high)
+        except ValueError:
+            raise ValueError("Range values must be valid numbers")
+
+        if low >= high:
+            raise ValueError("Range lower bound must be less than upper bound")
+
+        return low, high
 
     @staticmethod
     def _parse_levels(levels_input: str) -> list[float]:
-        values = [float(x.strip()) for x in levels_input.split(",")]
-        if not values:
+        values = [x.strip() for x in levels_input.split(",")]
+        if not values or all(x == "" for x in values):
             raise ValueError("At least one regularization level is required")
+
+        if any(x == "" for x in values):
+            raise ValueError("Regularization levels cannot contain empty values")
+
+        try:
+            values = [float(x) for x in values]
+        except ValueError:
+            raise ValueError("Level values must be valid numbers")
+
         return values
 
     @staticmethod