masster 0.4.4__py3-none-any.whl → 0.4.6__py3-none-any.whl

masster/study/load.py

@@ -94,7 +94,9 @@ def add(
 
         if len(files) > 0:
             # Limit files if max_files is specified
-            remaining_slots = max_files - counter if max_files is not None else len(files)
+            remaining_slots = (
+                max_files - counter if max_files is not None else len(files)
+            )
             files = files[:remaining_slots]
 
             self.logger.debug(f"Found {len(files)} {ext} files")
@@ -117,7 +119,9 @@ def add(
 
             # Batch process all files of this extension using ultra-optimized method
             if files_to_process:
-                self.logger.debug(f"Batch processing {len(files_to_process)} {ext} files")
+                self.logger.debug(
+                    f"Batch processing {len(files_to_process)} {ext} files",
+                )
                 successful = self._add_samples_batch(
                     files_to_process,
                     reset=reset,
@@ -140,6 +144,9 @@ def add(
         )
     else:
         self.logger.debug(f"Successfully added {counter} samples to the study.")
+    
+    # Return a simple summary to suppress marimo's automatic object display
+    return f"Added {counter} samples to study"
 
 
 # TODO type is not used
@@ -256,7 +263,8 @@ def _fill_chrom_single_impl(
     if min_number > 0:
         original_count = len(uids)
         uids = self.consensus_df.filter(
-            (pl.col("number_samples") >= min_number) & (pl.col("consensus_uid").is_in(uids)),
+            (pl.col("number_samples") >= min_number)
+            & (pl.col("consensus_uid").is_in(uids)),
         )["consensus_uid"].to_list()
         self.logger.debug(
             f"Features to fill: {original_count} -> {len(uids)}",
@@ -271,13 +279,15 @@ def _fill_chrom_single_impl(
     # Build lookup dictionaries
     self.logger.debug("Building lookup dictionaries...")
     consensus_info = {}
-    consensus_subset = self.consensus_df.select([
-        "consensus_uid",
-        "rt_start_mean",
-        "rt_end_mean",
-        "mz",
-        "rt",
-    ]).filter(pl.col("consensus_uid").is_in(uids))
+    consensus_subset = self.consensus_df.select(
+        [
+            "consensus_uid",
+            "rt_start_mean",
+            "rt_end_mean",
+            "mz",
+            "rt",
+        ],
+    ).filter(pl.col("consensus_uid").is_in(uids))
 
     for row in consensus_subset.iter_rows(named=True):
         consensus_info[row["consensus_uid"]] = {
@@ -444,11 +454,13 @@ def _fill_chrom_single_impl(
             }
 
             new_features.append(new_feature)
-            new_mapping.append({
-                "consensus_uid": consensus_uid,
-                "sample_uid": sample_uid,
-                "feature_uid": feature_uid,
-            })
+            new_mapping.append(
+                {
+                    "consensus_uid": consensus_uid,
+                    "sample_uid": sample_uid,
+                    "feature_uid": feature_uid,
+                },
+            )
             counter += 1
 
     # Add new features to DataFrames
@@ -471,7 +483,10 @@ def _fill_chrom_single_impl(
             for row in rows_to_add:
                 # Cast numeric columns to ensure consistency
                 for key, value in row.items():
-                    if key in ["mz", "rt", "intensity", "area", "height"] and value is not None:
+                    if (
+                        key in ["mz", "rt", "intensity", "area", "height"]
+                        and value is not None
+                    ):
                         row[key] = float(value)
                     elif key in ["sample_id", "feature_id"] and value is not None:
                         row[key] = int(value)
@@ -690,11 +705,13 @@ def _process_sample_for_parallel_fill(
         }
 
         new_features.append(new_feature)
-        new_mapping.append({
-            "consensus_uid": consensus_uid,
-            "sample_uid": sample_uid,
-            "feature_uid": feature_uid,
-        })
+        new_mapping.append(
+            {
+                "consensus_uid": consensus_uid,
+                "sample_uid": sample_uid,
+                "feature_uid": feature_uid,
+            },
+        )
         counter += 1
 
     return new_features, new_mapping, counter
@@ -740,7 +757,8 @@ def _fill_chrom_impl(
     if min_number > 0:
         original_count = len(uids)
         uids = self.consensus_df.filter(
-            (pl.col("number_samples") >= min_number) & (pl.col("consensus_uid").is_in(uids)),
+            (pl.col("number_samples") >= min_number)
+            & (pl.col("consensus_uid").is_in(uids)),
         )["consensus_uid"].to_list()
         self.logger.debug(f"Features to fill: {original_count} -> {len(uids)}")
 
@@ -767,13 +785,15 @@ def _fill_chrom_impl(
     # Build lookup dictionaries
     self.logger.debug("Building lookup dictionaries...")
     consensus_info = {}
-    consensus_subset = self.consensus_df.select([
-        "consensus_uid",
-        "rt_start_mean",
-        "rt_end_mean",
-        "mz",
-        "rt",
-    ]).filter(pl.col("consensus_uid").is_in(uids))
+    consensus_subset = self.consensus_df.select(
+        [
+            "consensus_uid",
+            "rt_start_mean",
+            "rt_end_mean",
+            "mz",
+            "rt",
+        ],
+    ).filter(pl.col("consensus_uid").is_in(uids))
 
     for row in consensus_subset.iter_rows(named=True):
         consensus_info[row["consensus_uid"]] = {
@@ -790,11 +810,13 @@ def _fill_chrom_impl(
     for row in self.samples_df.filter(
         pl.col("sample_uid").is_in(unique_sample_uids),
     ).iter_rows(named=True):
-        samples_to_process.append({
-            "sample_name": row["sample_name"],
-            "sample_uid": row["sample_uid"],
-            "sample_path": row["sample_path"],
-        })
+        samples_to_process.append(
+            {
+                "sample_name": row["sample_name"],
+                "sample_uid": row["sample_uid"],
+                "sample_path": row["sample_path"],
+            },
+        )
 
     total_missing = len(missing_combinations_df)
     self.logger.debug(
@@ -802,7 +824,9 @@ def _fill_chrom_impl(
     )
 
     # Calculate current max feature_uid to avoid conflicts
-    features_df_max_uid = self.features_df["feature_uid"].max() if not self.features_df.is_empty() else 0
+    features_df_max_uid = (
+        self.features_df["feature_uid"].max() if not self.features_df.is_empty() else 0
+    )
 
     # Process samples in parallel
     all_new_features: list[dict] = []
@@ -876,7 +900,10 @@ def _fill_chrom_impl(
             for row in rows_to_add:
                 # Cast numeric columns to ensure consistency
                 for key, value in row.items():
-                    if key in ["mz", "rt", "intensity", "area", "height"] and value is not None:
+                    if (
+                        key in ["mz", "rt", "intensity", "area", "height"]
+                        and value is not None
+                    ):
                         row[key] = float(value)
                     elif key in ["sample_id", "feature_id"] and value is not None:
                         row[key] = int(value)
@@ -925,7 +952,10 @@ def fill(self, **kwargs):
     """
     # parameters initialization
     params = fill_defaults()
-    num_workers = kwargs.get("num_workers", 4)  # Default parameter not in defaults class
+    num_workers = kwargs.get(
+        "num_workers",
+        4,
+    )  # Default parameter not in defaults class
 
     for key, value in kwargs.items():
         if isinstance(value, fill_defaults):
@@ -988,7 +1018,9 @@ def _get_missing_consensus_sample_combinations(self, uids):
         .agg(pl.count("feature_uid").alias("count"))
     )
 
-    total_existing = consensus_counts["count"].sum() if not consensus_counts.is_empty() else 0
+    total_existing = (
+        consensus_counts["count"].sum() if not consensus_counts.is_empty() else 0
+    )
 
     # If >95% filled, likely no gaps (common case)
     if total_existing >= total_possible * 0.95:
@@ -1007,10 +1039,12 @@ def _get_missing_consensus_sample_combinations(self, uids):
 
         # Get existing combinations for target UIDs only
         existing_by_consensus = {}
-        for consensus_uid, feature_uid in self.consensus_mapping_df.select([
-            "consensus_uid",
-            "feature_uid",
-        ]).iter_rows():
+        for consensus_uid, feature_uid in self.consensus_mapping_df.select(
+            [
+                "consensus_uid",
+                "feature_uid",
+            ],
+        ).iter_rows():
             if consensus_uid in uids_set and feature_uid in feature_to_sample:
                 if consensus_uid not in existing_by_consensus:
                     existing_by_consensus[consensus_uid] = set()
@@ -1018,7 +1052,9 @@ def _get_missing_consensus_sample_combinations(self, uids):
 
         # Get sample info once
         all_samples = list(
-            self.samples_df.select(["sample_uid", "sample_name", "sample_path"]).iter_rows(),
+            self.samples_df.select(
+                ["sample_uid", "sample_name", "sample_path"],
+            ).iter_rows(),
         )
 
         # Check for missing combinations
@@ -1026,13 +1062,17 @@ def _get_missing_consensus_sample_combinations(self, uids):
             existing_samples = existing_by_consensus.get(consensus_uid, set())
             for sample_uid, sample_name, sample_path in all_samples:
                 if sample_uid not in existing_samples:
-                    missing_combinations.append((consensus_uid, sample_uid, sample_name, sample_path))
+                    missing_combinations.append(
+                        (consensus_uid, sample_uid, sample_name, sample_path),
+                    )
 
         return missing_combinations
 
     else:
         # For studies with many gaps, use bulk operations
-        self.logger.debug(f"Study {total_existing / total_possible * 100:.1f}% filled, using bulk optimization")
+        self.logger.debug(
+            f"Study {total_existing / total_possible * 100:.1f}% filled, using bulk optimization",
+        )
 
         # Build efficient lookups
         uids_set = set(uids)
@@ -1043,16 +1083,20 @@ def _get_missing_consensus_sample_combinations(self, uids):
         # Build existing combinations set
         existing_combinations = {
             (consensus_uid, feature_to_sample[feature_uid])
-            for consensus_uid, feature_uid in self.consensus_mapping_df.select([
-                "consensus_uid",
-                "feature_uid",
-            ]).iter_rows()
+            for consensus_uid, feature_uid in self.consensus_mapping_df.select(
+                [
+                    "consensus_uid",
+                    "feature_uid",
+                ],
+            ).iter_rows()
             if consensus_uid in uids_set and feature_uid in feature_to_sample
         }
 
         # Get all sample info
         all_samples = list(
-            self.samples_df.select(["sample_uid", "sample_name", "sample_path"]).iter_rows(),
+            self.samples_df.select(
+                ["sample_uid", "sample_name", "sample_path"],
+            ).iter_rows(),
         )
 
         # Generate all missing combinations
@@ -1121,7 +1165,10 @@ def sanitize(self):
                 for ms2_specs in row_data["ms2_specs"]:
                     if not isinstance(ms2_specs, Spectrum):
                         try:
-                            new_ms2_specs = Spectrum(mz=np.array([0]), inty=np.array([0]))
+                            new_ms2_specs = Spectrum(
+                                mz=np.array([0]),
+                                inty=np.array([0]),
+                            )
                             if hasattr(ms2_specs, "__dict__"):
                                 new_ms2_specs.from_dict(ms2_specs.__dict__)
                             else:
@@ -1160,8 +1207,8 @@ def sanitize(self):
 def load_features(self):
     """
     Load features by reconstructing FeatureMaps from the processed features_df data.
-    
-    This ensures that the loaded FeatureMaps contain the same processed features 
+
+    This ensures that the loaded FeatureMaps contain the same processed features
     as stored in features_df, rather than loading raw features from .featureXML files
     which may not match the processed data after filtering, alignment, etc.
     """
@@ -1169,25 +1216,25 @@ def load_features(self):
     import pyopenms as oms
     from tqdm import tqdm
     from datetime import datetime
-    
+
     self.features_maps = []
-    
+
     # Check if features_df exists and is not empty
     if self.features_df is None:
         self.logger.warning("features_df is None. Falling back to XML loading.")
         self._load_features_from_xml()
         return
-    
+
     if len(self.features_df) == 0:
         self.logger.warning("features_df is empty. Falling back to XML loading.")
         self._load_features_from_xml()
         return
-    
+
     # If we get here, we should use the new method
     self.logger.debug("Reconstructing FeatureMaps from features_df.")
-    
+
     tdqm_disable = self.log_level not in ["TRACE", "DEBUG", "INFO"]
-    
+
     # Process each sample in order
     for sample_index, row_dict in tqdm(
         enumerate(self.samples_df.iter_rows(named=True)),
@@ -1195,37 +1242,39 @@ def load_features(self):
         desc=f"{datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]} | INFO     | {self.log_label}Reconstruct FeatureMaps from DataFrame",
         disable=tdqm_disable,
     ):
-        sample_uid = row_dict['sample_uid']
-        sample_name = row_dict['sample_name']
-        
+        sample_uid = row_dict["sample_uid"]
+        sample_name = row_dict["sample_name"]
+
         # Get features for this sample from features_df
-        sample_features = self.features_df.filter(pl.col('sample_uid') == sample_uid)
-        
+        sample_features = self.features_df.filter(pl.col("sample_uid") == sample_uid)
+
         # Create new FeatureMap
         feature_map = oms.FeatureMap()
-        
+
         # Convert DataFrame features to OpenMS Features
         for feature_row in sample_features.iter_rows(named=True):
             feature = oms.Feature()
-            
+
             # Set properties from DataFrame (handle missing values gracefully)
             try:
-                feature.setUniqueId(int(feature_row['feature_id']))
-                feature.setMZ(float(feature_row['mz']))
-                feature.setRT(float(feature_row['rt']))
-                feature.setIntensity(float(feature_row['inty']))
-                feature.setOverallQuality(float(feature_row['quality']))
-                feature.setCharge(int(feature_row['charge']))
-                
+                feature.setUniqueId(int(feature_row["feature_id"]))
+                feature.setMZ(float(feature_row["mz"]))
+                feature.setRT(float(feature_row["rt"]))
+                feature.setIntensity(float(feature_row["inty"]))
+                feature.setOverallQuality(float(feature_row["quality"]))
+                feature.setCharge(int(feature_row["charge"]))
+
                 # Add to feature map
                 feature_map.push_back(feature)
             except (ValueError, TypeError) as e:
                 self.logger.warning(f"Skipping feature due to conversion error: {e}")
                 continue
-        
+
         self.features_maps.append(feature_map)
-    
-    self.logger.debug(f"Successfully reconstructed {len(self.features_maps)} FeatureMaps from features_df.")
+
+    self.logger.debug(
+        f"Successfully reconstructed {len(self.features_maps)} FeatureMaps from features_df.",
+    )
 
 
 def _load_features_from_xml(self):
@@ -1280,7 +1329,14 @@ def _load_consensusXML(self, filename="alignment.consensusXML"):
     self.logger.debug(f"Loaded consensus map from {filename}.")
 
 
-def _add_samples_batch(self, files, reset=False, adducts=None, blacklist=None, fast=True):
+def _add_samples_batch(
+    self,
+    files,
+    reset=False,
+    adducts=None,
+    blacklist=None,
+    fast=True,
+):
     """
     Optimized batch addition of samples.
 
@@ -1303,7 +1359,9 @@ def _add_samples_batch(self, files, reset=False, adducts=None, blacklist=None, f
     if blacklist is None:
         blacklist = set()
 
-    self.logger.debug(f"Starting batch addition of {len(files)} samples (skip_ms1={fast})...")
+    self.logger.debug(
+        f"Starting batch addition of {len(files)} samples (skip_ms1={fast})...",
+    )
 
     successful_additions = 0
     failed_additions = 0
@@ -1360,7 +1418,9 @@ def _add_samples_batch(self, files, reset=False, adducts=None, blacklist=None, f
         # Color assignment done once for all samples
         self._sample_color_reset_optimized()
 
-        self.logger.debug(f"Add samples complete: {successful_additions} successful, {failed_additions} failed")
+        self.logger.debug(
+            f"Add samples complete: {successful_additions} successful, {failed_additions} failed",
+        )
 
     return successful_additions
 
@@ -1406,7 +1466,7 @@ def _add_sample_optimized(
     # Load sample
     ddaobj = Sample()
     ddaobj.logger_update(level="WARNING", label=os.path.basename(file))
-    
+
     # Try optimized loading first (study-specific, skips ms1_df for better performance)
 
     if file.endswith(".sample5"):
@@ -1442,7 +1502,7 @@ def _add_sample_optimized(
     # Handle file paths
     if file.endswith(".sample5"):
         final_sample_path = file
-        #self.logger.debug(f"Using existing .sample5 file: {final_sample_path}")
+        # self.logger.debug(f"Using existing .sample5 file: {final_sample_path}")
     else:
         if self.folder is not None:
             if not os.path.exists(self.folder):
@@ -1455,8 +1515,14 @@ def _add_sample_optimized(
 
     # Efficient scan counting
     ms1_count = ms2_count = 0
-    if hasattr(ddaobj, "scans_df") and ddaobj.scans_df is not None and not ddaobj.scans_df.is_empty():
-        scan_counts = ddaobj.scans_df.group_by("ms_level").len().to_dict(as_series=False)
+    if (
+        hasattr(ddaobj, "scans_df")
+        and ddaobj.scans_df is not None
+        and not ddaobj.scans_df.is_empty()
+    ):
+        scan_counts = (
+            ddaobj.scans_df.group_by("ms_level").len().to_dict(as_series=False)
+        )
         ms_levels = scan_counts.get("ms_level", [])
         counts = scan_counts.get("len", [])
         for level, count in zip(ms_levels, counts):
@@ -1467,21 +1533,23 @@ def _add_sample_optimized(
 
     # Create sample entry
     next_sequence = len(self.samples_df) + 1 if not self.samples_df.is_empty() else 1
-    new_sample = pl.DataFrame({
-        "sample_uid": [int(len(self.samples_df) + 1)],
-        "sample_name": [sample_name],
-        "sample_path": [final_sample_path],
-        "sample_type": [sample_type],
-        "map_id": [map_id_value],
-        "sample_source": [getattr(ddaobj, "file_source", file)],
-        "sample_color": [None],  # Will be set in batch at end
-        "sample_group": [""],
-        "sample_batch": [1],
-        "sample_sequence": [next_sequence],
-        "num_features": [int(ddaobj._oms_features_map.size())],
-        "num_ms1": [ms1_count],
-        "num_ms2": [ms2_count],
-    })
+    new_sample = pl.DataFrame(
+        {
+            "sample_uid": [int(len(self.samples_df) + 1)],
+            "sample_name": [sample_name],
+            "sample_path": [final_sample_path],
+            "sample_type": [sample_type],
+            "map_id": [map_id_value],
+            "sample_source": [getattr(ddaobj, "file_source", file)],
+            "sample_color": [None],  # Will be set in batch at end
+            "sample_group": [""],
+            "sample_batch": [1],
+            "sample_sequence": [next_sequence],
+            "num_features": [int(ddaobj._oms_features_map.size())],
+            "num_ms1": [ms1_count],
+            "num_ms2": [ms2_count],
+        },
+    )
 
     self.samples_df = pl.concat([self.samples_df, new_sample])
 
@@ -1523,7 +1591,9 @@ def _add_sample_optimized(
     # - No type casting loops
     # - No sample_color_reset()
 
-    self.logger.debug(f"Added sample {sample_name} with {ddaobj._oms_features_map.size()} features (optimized)")
+    self.logger.debug(
+        f"Added sample {sample_name} with {ddaobj._oms_features_map.size()} features (optimized)",
+    )
     return True
 
 
@@ -1567,7 +1637,7 @@ def _add_sample_standard(
     ddaobj = Sample()
     ddaobj.logger_update(level="WARNING", label=os.path.basename(file))
     # Use standard loading method that loads all data including ms1_df
-    
+
     if file.endswith(".sample5"):
         ddaobj.load(file)
         # restore _oms_features_map
@@ -1601,7 +1671,7 @@ def _add_sample_standard(
     # Handle file paths
     if file.endswith(".sample5"):
         final_sample_path = file
-        #self.logger.trace(f"Using existing .sample5 file: {final_sample_path}")
+        # self.logger.trace(f"Using existing .sample5 file: {final_sample_path}")
     else:
         if self.folder is not None:
             if not os.path.exists(self.folder):
@@ -1614,8 +1684,14 @@ def _add_sample_standard(
 
     # Efficient scan counting
     ms1_count = ms2_count = 0
-    if hasattr(ddaobj, "scans_df") and ddaobj.scans_df is not None and not ddaobj.scans_df.is_empty():
-        scan_counts = ddaobj.scans_df.group_by("ms_level").len().to_dict(as_series=False)
+    if (
+        hasattr(ddaobj, "scans_df")
+        and ddaobj.scans_df is not None
+        and not ddaobj.scans_df.is_empty()
+    ):
+        scan_counts = (
+            ddaobj.scans_df.group_by("ms_level").len().to_dict(as_series=False)
+        )
         ms_levels = scan_counts.get("ms_level", [])
         counts = scan_counts.get("len", [])
         for level, count in zip(ms_levels, counts):
@@ -1626,21 +1702,23 @@ def _add_sample_standard(
 
     # Create sample entry
     next_sequence = len(self.samples_df) + 1 if not self.samples_df.is_empty() else 1
-    new_sample = pl.DataFrame({
-        "sample_uid": [int(len(self.samples_df) + 1)],
-        "sample_name": [sample_name],
-        "sample_path": [final_sample_path],
-        "sample_type": [sample_type],
-        "map_id": [map_id_value],
-        "sample_source": [getattr(ddaobj, "file_source", file)],
-        "sample_color": [None],  # Will be set in batch at end
-        "sample_group": [""],
-        "sample_batch": [1],
-        "sample_sequence": [next_sequence],
-        "num_features": [int(ddaobj._oms_features_map.size())],
-        "num_ms1": [ms1_count],
-        "num_ms2": [ms2_count],
-    })
+    new_sample = pl.DataFrame(
+        {
+            "sample_uid": [int(len(self.samples_df) + 1)],
+            "sample_name": [sample_name],
+            "sample_path": [final_sample_path],
+            "sample_type": [sample_type],
+            "map_id": [map_id_value],
+            "sample_source": [getattr(ddaobj, "file_source", file)],
+            "sample_color": [None],  # Will be set in batch at end
+            "sample_group": [""],
+            "sample_batch": [1],
+            "sample_sequence": [next_sequence],
+            "num_features": [int(ddaobj._oms_features_map.size())],
+            "num_ms1": [ms1_count],
+            "num_ms2": [ms2_count],
+        },
+    )
 
     self.samples_df = pl.concat([self.samples_df, new_sample])
 
@@ -1675,7 +1753,9 @@ def _add_sample_standard(
         # Use diagonal concatenation for flexibility
         self.features_df = pl.concat([self.features_df, f_df], how="diagonal")
 
-    self.logger.debug(f"Added sample {sample_name} with {ddaobj._oms_features_map.size()} features (standard)")
+    self.logger.debug(
+        f"Added sample {sample_name} with {ddaobj._oms_features_map.size()} features (standard)",
+    )
     return True
     ## COMMENT AR: Is this intentional?
     # Use standard loading method that loads all data including ms1_df
@@ -1703,7 +1783,7 @@ def _add_sample_standard(
     # Handle file paths
     if file.endswith(".sample5"):
         final_sample_path = file
-        #self.logger.trace(f"Using existing .sample5 file: {final_sample_path}")
+        # self.logger.trace(f"Using existing .sample5 file: {final_sample_path}")
     else:
         if self.folder is not None:
             if not os.path.exists(self.folder):
@@ -1716,8 +1796,14 @@ def _add_sample_standard(
 
     # Efficient scan counting
     ms1_count = ms2_count = 0
-    if hasattr(ddaobj, "scans_df") and ddaobj.scans_df is not None and not ddaobj.scans_df.is_empty():
-        scan_counts = ddaobj.scans_df.group_by("ms_level").len().to_dict(as_series=False)
+    if (
+        hasattr(ddaobj, "scans_df")
+        and ddaobj.scans_df is not None
+        and not ddaobj.scans_df.is_empty()
+    ):
+        scan_counts = (
+            ddaobj.scans_df.group_by("ms_level").len().to_dict(as_series=False)
+        )
         ms_levels = scan_counts.get("ms_level", [])
         counts = scan_counts.get("len", [])
         for level, count in zip(ms_levels, counts):
@@ -1728,21 +1814,23 @@ def _add_sample_standard(
 
     # Create sample entry
     next_sequence = len(self.samples_df) + 1 if not self.samples_df.is_empty() else 1
-    new_sample = pl.DataFrame({
-        "sample_uid": [int(len(self.samples_df) + 1)],
-        "sample_name": [sample_name],
-        "sample_path": [final_sample_path],
-        "sample_type": [sample_type],
-        "map_id": [map_id_value],
-        "sample_source": [getattr(ddaobj, "file_source", file)],
-        "sample_color": [None],  # Will be set in batch at end
-        "sample_group": [""],
-        "sample_batch": [1],
-        "sample_sequence": [next_sequence],
-        "num_features": [int(ddaobj._oms_features_map.size())],
-        "num_ms1": [ms1_count],
-        "num_ms2": [ms2_count],
-    })
+    new_sample = pl.DataFrame(
+        {
+            "sample_uid": [int(len(self.samples_df) + 1)],
+            "sample_name": [sample_name],
+            "sample_path": [final_sample_path],
+            "sample_type": [sample_type],
+            "map_id": [map_id_value],
+            "sample_source": [getattr(ddaobj, "file_source", file)],
+            "sample_color": [None],  # Will be set in batch at end
+            "sample_group": [""],
+            "sample_batch": [1],
+            "sample_sequence": [next_sequence],
+            "num_features": [int(ddaobj._oms_features_map.size())],
+            "num_ms1": [ms1_count],
+            "num_ms2": [ms2_count],
+        },
+    )
 
     self.samples_df = pl.concat([self.samples_df, new_sample])
 
@@ -1777,7 +1865,9 @@ def _add_sample_standard(
         # Use diagonal concatenation for flexibility
         self.features_df = pl.concat([self.features_df, f_df], how="diagonal")
 
-    self.logger.debug(f"Added sample {sample_name} with {ddaobj._oms_features_map.size()} features (standard)")
+    self.logger.debug(
+        f"Added sample {sample_name} with {ddaobj._oms_features_map.size()} features (standard)",
+    )
     return True