Slight rework on uploading. Fixes: multiple measurement or other files in PEtab problem.

Previously: Silently ignored the other files

Author: PaulJonasJost

src/petab_gui/controllers/mother_controller.py

@@ -732,6 +732,109 @@ def _open_file(self, actionable, file_path, sep, mode):
                 file_path, mode, sep
             )
 
+    def _validate_yaml_structure(self, yaml_content):
+        """Validate PEtab YAML structure before attempting to load files.
+
+        Parameters
+        ----------
+        yaml_content : dict
+            The parsed YAML content.
+
+        Returns
+        -------
+        tuple
+            (is_valid: bool, errors: list[str])
+        """
+        errors = []
+
+        # Check format version
+        if "format_version" not in yaml_content:
+            errors.append("Missing 'format_version' field")
+
+        # Check problems array
+        if "problems" not in yaml_content:
+            errors.append("Missing 'problems' field")
+            return False, errors
+
+        if (
+            not isinstance(yaml_content["problems"], list)
+            or not yaml_content["problems"]
+        ):
+            errors.append("'problems' must be a non-empty list")
+            return False, errors
+
+        problem = yaml_content["problems"][0]
+
+        # Required fields
+        if "sbml_files" not in problem or not problem["sbml_files"]:
+            errors.append("Problem must contain at least one SBML file")
+
+        # Optional but recommended fields
+        for field in [
+            "measurement_files",
+            "observable_files",
+            "condition_files",
+        ]:
+            if field not in problem or not problem[field]:
+                errors.append(f"Warning: No {field} specified")
+
+        # Check parameter_file (at root level)
+        if "parameter_file" not in yaml_content:
+            errors.append("Missing 'parameter_file' at root level")
+
+        return len([e for e in errors if "Warning" not in e]) == 0, errors
+
+    def _validate_files_exist(self, yaml_dir, yaml_content):
+        """Validate that all files referenced in YAML exist.
+
+        Parameters
+        ----------
+        yaml_dir : Path
+            The directory containing the YAML file.
+        yaml_content : dict
+            The parsed YAML content.
+
+        Returns
+        -------
+        tuple
+            (all_exist: bool, missing_files: list[str])
+        """
+        missing_files = []
+        problem = yaml_content["problems"][0]
+
+        # Check SBML files
+        for sbml_file in problem.get("sbml_files", []):
+            if not (yaml_dir / sbml_file).exists():
+                missing_files.append(str(sbml_file))
+
+        # Check measurement files
+        for meas_file in problem.get("measurement_files", []):
+            if not (yaml_dir / meas_file).exists():
+                missing_files.append(str(meas_file))
+
+        # Check observable files
+        for obs_file in problem.get("observable_files", []):
+            if not (yaml_dir / obs_file).exists():
+                missing_files.append(str(obs_file))
+
+        # Check condition files
+        for cond_file in problem.get("condition_files", []):
+            if not (yaml_dir / cond_file).exists():
+                missing_files.append(str(cond_file))
+
+        # Check parameter file
+        if "parameter_file" in yaml_content:
+            param_file = yaml_content["parameter_file"]
+            if not (yaml_dir / param_file).exists():
+                missing_files.append(str(param_file))
+
+        # Check visualization files (optional)
+        for vis_file in problem.get("visualization_files", []):
+            if not (yaml_dir / vis_file).exists():
+                missing_files.append(str(vis_file))
+
+        return len(missing_files) == 0, missing_files
+
     def open_yaml_and_load_files(self, yaml_path=None, mode="overwrite"):
         """Open files from a YAML configuration.
 
@@ -749,62 +852,161 @@ def open_yaml_and_load_files(self, yaml_path=None, mode="overwrite"):
                 if controller == self.sbml_controller:
                     continue
                 controller.release_completers()
+
             # Load the YAML content
-            with open(yaml_path) as file:
+            with open(yaml_path, encoding="utf-8") as file:
                 yaml_content = yaml.safe_load(file)
 
+            # Validate PEtab version
             if (major := get_major_version(yaml_content)) != 1:
                 raise ValueError(
                     f"Only PEtab v1 problems are currently supported. "
                     f"Detected version: {major}.x."
                 )
 
+            # Validate YAML structure
+            is_valid, errors = self._validate_yaml_structure(yaml_content)
+            if not is_valid:
+                error_msg = "Invalid YAML structure:\n  - " + "\n  - ".join(
+                    [e for e in errors if "Warning" not in e]
+                )
+                self.logger.log_message(error_msg, color="red")
+                QMessageBox.critical(
+                    self.view, "Invalid PEtab YAML", error_msg
+                )
+                return
+
+            # Log warnings but continue
+            warnings = [e for e in errors if "Warning" in e]
+            for warning in warnings:
+                self.logger.log_message(warning, color="orange")
+
             # Resolve the directory of the YAML file to handle relative paths
             yaml_dir = Path(yaml_path).parent
 
-            # Upload SBML model
-            sbml_file_path = (
-                yaml_dir / yaml_content["problems"][0]["sbml_files"][0]
-            )
-            self.sbml_controller.overwrite_sbml(sbml_file_path)
-            self.measurement_controller.open_table(
-                yaml_dir / yaml_content["problems"][0]["measurement_files"][0]
-            )
-            self.observable_controller.open_table(
-                yaml_dir / yaml_content["problems"][0]["observable_files"][0]
+            # Validate file existence
+            all_exist, missing_files = self._validate_files_exist(
+                yaml_dir, yaml_content
             )
-            self.parameter_controller.open_table(
-                yaml_dir / yaml_content["parameter_file"]
-            )
-            self.condition_controller.open_table(
-                yaml_dir / yaml_content["problems"][0]["condition_files"][0]
-            )
-            # Visualization is optional
-            vis_path = yaml_content["problems"][0].get("visualization_files")
-            if vis_path:
-                self.visualization_controller.open_table(
-                    yaml_dir / vis_path[0]
+            if not all_exist:
+                error_msg = (
+                    "The following files referenced in the YAML are missing:\n  - "
+                    + "\n  - ".join(missing_files)
                 )
+                self.logger.log_message(error_msg, color="red")
+                QMessageBox.critical(self.view, "Missing Files", error_msg)
+                return
+
+            problem = yaml_content["problems"][0]
+
+            # Load SBML model (required, single file)
+            sbml_files = problem.get("sbml_files", [])
+            if sbml_files:
+                sbml_file_path = yaml_dir / sbml_files[0]
+                self.sbml_controller.overwrite_sbml(sbml_file_path)
+                self.logger.log_message(
+                    f"Loaded SBML file: {sbml_files[0]}", color="blue"
+                )
+
+            # Load measurement files (multiple allowed)
+            measurement_files = problem.get("measurement_files", [])
+            if measurement_files:
+                for i, meas_file in enumerate(measurement_files):
+                    file_mode = "overwrite" if i == 0 else "append"
+                    self.measurement_controller.open_table(
+                        yaml_dir / meas_file, mode=file_mode
+                    )
+                    self.logger.log_message(
+                        f"Loaded measurement file ({i + 1}/{len(measurement_files)}): {meas_file}",
+                        color="blue",
+                    )
+
+            # Load observable files (multiple allowed)
+            observable_files = problem.get("observable_files", [])
+            if observable_files:
+                for i, obs_file in enumerate(observable_files):
+                    file_mode = "overwrite" if i == 0 else "append"
+                    self.observable_controller.open_table(
+                        yaml_dir / obs_file, mode=file_mode
+                    )
+                    self.logger.log_message(
+                        f"Loaded observable file ({i + 1}/{len(observable_files)}): {obs_file}",
+                        color="blue",
+                    )
+
+            # Load condition files (multiple allowed)
+            condition_files = problem.get("condition_files", [])
+            if condition_files:
+                for i, cond_file in enumerate(condition_files):
+                    file_mode = "overwrite" if i == 0 else "append"
+                    self.condition_controller.open_table(
+                        yaml_dir / cond_file, mode=file_mode
+                    )
+                    self.logger.log_message(
+                        f"Loaded condition file ({i + 1}/{len(condition_files)}): {cond_file}",
+                        color="blue",
+                    )
+
+            # Load parameter file (required, single file at root level)
+            if "parameter_file" in yaml_content:
+                param_file = yaml_content["parameter_file"]
+                self.parameter_controller.open_table(yaml_dir / param_file)
+                self.logger.log_message(
+                    f"Loaded parameter file: {param_file}", color="blue"
+                )
+
+            # Load visualization files (optional, multiple allowed)
+            visualization_files = problem.get("visualization_files", [])
+            if visualization_files:
+                for i, vis_file in enumerate(visualization_files):
+                    file_mode = "overwrite" if i == 0 else "append"
+                    self.visualization_controller.open_table(
+                        yaml_dir / vis_file, mode=file_mode
+                    )
+                    self.logger.log_message(
+                        f"Loaded visualization file ({i + 1}/{len(visualization_files)}): {vis_file}",
+                        color="blue",
+                    )
             else:
                 self.visualization_controller.clear_table()
+
             # Simulation should be cleared
             self.simulation_controller.clear_table()
+
             self.logger.log_message(
                 "All files opened successfully from the YAML configuration.",
                 color="green",
             )
             self.check_model()
-            # rerun the completers
+
+            # Rerun the completers
             for controller in self.controllers:
                 if controller == self.sbml_controller:
                     continue
                 controller.setup_completers()
             self.unsaved_changes_change(False)
 
+        except FileNotFoundError as e:
+            error_msg = f"File not found: {e.filename if hasattr(e, 'filename') else str(e)}"
+            self.logger.log_message(error_msg, color="red")
+            QMessageBox.warning(self.view, "File Not Found", error_msg)
+        except KeyError as e:
+            error_msg = f"Missing required field in YAML: {str(e)}"
+            self.logger.log_message(error_msg, color="red")
+            QMessageBox.warning(self.view, "Invalid YAML", error_msg)
+        except ValueError as e:
+            error_msg = f"Invalid YAML structure: {str(e)}"
+            self.logger.log_message(error_msg, color="red")
+            QMessageBox.warning(self.view, "Invalid YAML", error_msg)
+        except yaml.YAMLError as e:
+            error_msg = f"YAML parsing error: {str(e)}"
+            self.logger.log_message(error_msg, color="red")
+            QMessageBox.warning(self.view, "YAML Parsing Error", error_msg)
         except Exception as e:
-            self.logger.log_message(
-                f"Failed to open files from YAML: {str(e)}", color="red"
-            )
+            error_msg = f"Unexpected error loading YAML: {str(e)}"
+            self.logger.log_message(error_msg, color="red")
+            logging.exception("Full traceback for YAML loading error:")
+            QMessageBox.critical(self.view, "Error", error_msg)
 
     def open_omex_and_load_files(self, omex_path=None):
         """Opens a petab problem from a COMBINE Archive."""

src/petab_gui/models/pandas_table_model.py

@@ -1095,7 +1095,7 @@ class MeasurementModel(PandasTableModel):
     possibly_new_observable = Signal(str)  # Signal for new observable
 
     def __init__(self, data_frame, type: str = "measurement", parent=None):
-        allowed_columns = COLUMNS[type]
+        allowed_columns = COLUMNS[type].copy()
         super().__init__(
             data_frame=data_frame,
             allowed_columns=allowed_columns,
@@ -1128,7 +1128,7 @@ class ObservableModel(IndexedPandasTableModel):
     def __init__(self, data_frame, parent=None):
         super().__init__(
             data_frame=data_frame,
-            allowed_columns=COLUMNS["observable"],
+            allowed_columns=COLUMNS["observable"].copy(),
             table_type="observable",
             parent=parent,
         )
@@ -1140,7 +1140,7 @@ class ParameterModel(IndexedPandasTableModel):
     def __init__(self, data_frame, parent=None, sbml_model=None):
         super().__init__(
             data_frame=data_frame,
-            allowed_columns=COLUMNS["parameter"],
+            allowed_columns=COLUMNS["parameter"].copy(),
             table_type="parameter",
             parent=parent,
         )
@@ -1153,9 +1153,11 @@ class ConditionModel(IndexedPandasTableModel):
     """Table model for the condition data."""
 
     def __init__(self, data_frame, parent=None):
+        # Use a copy to avoid mutating the global COLUMNS constant
+        condition_columns = COLUMNS["condition"].copy()
         super().__init__(
             data_frame=data_frame,
-            allowed_columns=COLUMNS["condition"],
+            allowed_columns=condition_columns,
             table_type="condition",
             parent=parent,
         )
@@ -1206,7 +1208,7 @@ class VisualizationModel(PandasTableModel):
     def __init__(self, data_frame, parent=None):
         super().__init__(
             data_frame=data_frame,
-            allowed_columns=COLUMNS["visualization"],
+            allowed_columns=COLUMNS["visualization"].copy(),
             table_type="visualization",
             parent=parent,
         )