masster 0.6.1__py3-none-any.whl → 0.6.2__py3-none-any.whl

masster/study/export.py

@@ -1022,8 +1022,11 @@ def export_mztab(self, filename: str | None = None, include_mgf=True, **kwargs)
                     if SME_row.get("matcher") is not None:
                         id_method = f"[MS, MS:1002888, {SME_row['matcher']}, ]"
 
-                    # MS level - assume MS1 for now
-                    ms_level = "[MS, MS:1000511, ms level, 1]"
+                    # MS level - check if ms1 exists in matched
+                    if 'ms1' in SME_row['matcher'].lower():                        
+                        ms_level = "[MS, MS:1000511, ms level, 1]"
+                    else:
+                        ms_level = "[MS,MS:1000511, ms level, 2]"
 
                     # Experimental mass-to-charge from consensus feature
                     exp_mz = safe_str(consensus_mz)
@@ -1125,7 +1128,7 @@ def export_mztab(self, filename: str | None = None, include_mgf=True, **kwargs)
     self.logger.success(f"Exported mzTab-M to {filename}")
 
 
-def export_xlsx(self, filename: str | None = None) -> None:
+def export_excel(self, filename: str | None = None) -> None:
     """
     Export the study data to an Excel workbook with multiple worksheets.
 
@@ -1390,3 +1393,151 @@ def export_parquet(self, filename: str | None = None) -> None:
         self.logger.success(f"Study exported to {len(exported_files)} Parquet files.")
     else:
         self.logger.error("No Parquet files were created - no data available to export")
+
+
+def export_slaw(self, filename="features_slaw.csv"):
+    """
+    Export the consensus features DataFrame to a SLAW-formatted CSV file.
+
+    This method exports the consensus features to a CSV format compatible with SLAW,
+    including feature metadata and intensity quantification across all samples. The file 
+    contains comprehensive feature information including m/z, RT, annotations, isotopic 
+    patterns, MS2 data, and intensity values for each sample.
+
+    Parameters:
+        filename (str): The path to the output CSV file. Defaults to 'features_slaw.csv'.
+
+    Side Effects:
+        Writes the exported data to the specified CSV file and logs the export operation.
+    """
+    if self.consensus_df is None:
+        self.logger.warning("No consensus features found. Cannot export to SLAW format.")
+        return
+
+    # Make filename absolute if not already
+    if not os.path.isabs(filename):
+        if self.folder is not None:
+            filename = os.path.join(self.folder, filename)
+        else:
+            filename = os.path.join(os.getcwd(), filename)
+
+    df = self.consensus_df
+    
+    # Get consensus matrix for quantification across samples
+    try:
+        quant_matrix = self.get_consensus_matrix()
+    except Exception as e:
+        self.logger.error(f"Error getting consensus matrix: {e}")
+        return
+    
+    # Evaluate the charge column
+    if "charge_mean" in df.columns:
+        charge_series = df.select(
+            pl.when(pl.col("charge_mean") == 0)
+            .then(1 if self.polarity == "positive" else -1)
+            .otherwise(pl.col("charge_mean"))
+            .alias("charge")
+        ).get_column("charge")
+    else:
+        charge_series = pl.Series([1 if self.polarity == "positive" else -1] * len(df))
+
+    # Evaluate the group column (from adduct_group_top)
+    # Features with adduct_group_top == 0 should each get a unique group index
+    if "adduct_group_top" in df.columns:
+        max_adduct_group = df.get_column("adduct_group_top").max()
+        if max_adduct_group is None:
+            max_adduct_group = 0
+        
+        group_series = df.select(
+            pl.when(pl.col("adduct_group_top") == 0)
+            .then(max_adduct_group + 1 + pl.int_range(pl.len()).over(pl.col("adduct_group_top") == 0))
+            .otherwise(pl.col("adduct_group_top"))
+            .alias("group")
+        ).get_column("group")
+    else:
+        group_series = pl.Series([None] * len(df))
+
+    # Evaluate the annotation column (adduct + isotope info)
+    if "adduct_top" in df.columns and "iso_mean" in df.columns:
+        annotation_series = df.select(
+            pl.when(pl.col("iso_mean") == 0)
+            .then(pl.col("adduct_top").str.replace(r"\?", "H"))
+            .otherwise(pl.col("adduct_top").str.replace(r"\?", "H") + " +" + pl.col("iso_mean").cast(pl.Int64).cast(pl.Utf8))
+            .alias("annotation")
+        ).get_column("annotation")
+    elif "adduct_top" in df.columns:
+        annotation_series = df.get_column("adduct_top").str.replace(r"\?", "H")
+    else:
+        annotation_series = pl.Series([""] * len(df))
+
+    # Get sample columns from quant_matrix (excluding consensus_uid)
+    sample_columns = [col for col in quant_matrix.columns if col != "consensus_uid"]
+    
+    # Create SLAW columns with appropriate mappings from consensus_df
+    slaw_data = {
+        "feature_id": df.get_column("consensus_id") if "consensus_id" in df.columns else pl.Series(range(1, len(df) + 1)),
+        "mz": df.get_column("mz") if "mz" in df.columns else pl.Series([None] * len(df)),
+        "rt": df.get_column("rt") if "rt" in df.columns else pl.Series([None] * len(df)),
+        "group": group_series,
+        "annotation": annotation_series,
+        "neutral_mass": df.get_column("adduct_neutral_mass_top") if "adduct_neutral_mass_top" in df.columns else pl.Series([None] * len(df)),
+        "charge": charge_series,
+        "main_id": df.get_column("main_id") if "main_id" in df.columns else df.get_column("consensus_id") if "consensus_id" in df.columns else pl.Series(range(1, len(df) + 1)),
+        "ion": df.get_column("adduct_top").str.replace(r"\?", "H") if "adduct_top" in df.columns else pl.Series([""] * len(df)),
+        "iso": df.get_column("iso_mean").cast(pl.Int64) if "iso_mean" in df.columns else pl.Series([0] * len(df)),
+        "clique": df.get_column("clique") if "clique" in df.columns else pl.Series([None] * len(df)),
+        "num_detection": df.get_column("num_detection") if "num_detection" in df.columns else pl.Series([1] * len(df)),
+        "total_detection": df.get_column("total_detection") if "total_detection" in df.columns else pl.Series([1] * len(df)),
+        "mz_mean": df.get_column("mz") if "mz" in df.columns else pl.Series([None] * len(df)),
+        "mz_min": df.get_column("mz_min") if "mz_min" in df.columns else df.get_column("mz") if "mz" in df.columns else pl.Series([None] * len(df)),
+        "mz_max": df.get_column("mz_max") if "mz_max" in df.columns else df.get_column("mz") if "mz" in df.columns else pl.Series([None] * len(df)),
+        "rt_mean": df.get_column("rt") if "rt" in df.columns else pl.Series([None] * len(df)),
+        "rt_min": df.get_column("rt_min") if "rt_min" in df.columns else df.get_column("rt") if "rt" in df.columns else pl.Series([None] * len(df)),
+        "rt_max": df.get_column("rt_max") if "rt_max" in df.columns else df.get_column("rt") if "rt" in df.columns else pl.Series([None] * len(df)),
+        "rt_cor_mean": df.get_column("rt") if "rt" in df.columns else pl.Series([None] * len(df)),
+        "rt_cor_min": df.get_column("rt_min") if "rt_min" in df.columns else df.get_column("rt") if "rt" in df.columns else pl.Series([None] * len(df)),
+        "rt_cor_max": df.get_column("rt_max") if "rt_max" in df.columns else df.get_column("rt") if "rt" in df.columns else pl.Series([None] * len(df)),
+        "height_mean": df.get_column("height_mean") if "height_mean" in df.columns else pl.Series([None] * len(df)),
+        "height_min": df.get_column("height_min") if "height_min" in df.columns else pl.Series([None] * len(df)),
+        "height_max": df.get_column("height_max") if "height_max" in df.columns else pl.Series([None] * len(df)),
+        "intensity_mean": df.get_column("inty_mean") if "inty_mean" in df.columns else pl.Series([None] * len(df)),
+        "intensity_min": df.get_column("inty_min") if "inty_min" in df.columns else pl.Series([None] * len(df)),
+        "intensity_max": df.get_column("inty_max") if "inty_max" in df.columns else pl.Series([None] * len(df)),
+        "SN_mean": df.get_column("sn_mean") if "sn_mean" in df.columns else pl.Series([None] * len(df)),
+        "SN_min": df.get_column("sn_min") if "sn_min" in df.columns else pl.Series([None] * len(df)),
+        "SN_max": df.get_column("sn_max") if "sn_max" in df.columns else pl.Series([None] * len(df)),
+        "peakwidth_mean": df.get_column("fwhm_mean") if "fwhm_mean" in df.columns else pl.Series([None] * len(df)),
+        "peakwidth_min": df.get_column("fwhm_min") if "fwhm_min" in df.columns else pl.Series([None] * len(df)),
+        "peakwidth_max": df.get_column("fwhm_max") if "fwhm_max" in df.columns else pl.Series([None] * len(df)),
+        "ms2_mgf_id": pl.Series([""] * len(df)),  # Not available in study
+        "ms2_num_fused": pl.Series([None] * len(df)),  # Not available in study
+        "ms2_source": pl.Series([""] * len(df)),  # Not available in study
+        "isotopic_pattern_annot": pl.Series([""] * len(df)),  # Not available in study
+        "isotopic_pattern_rel": pl.Series([""] * len(df)),  # Not available in study
+        "isotopic_pattern_abs": pl.Series([""] * len(df)),  # Not available in study
+    }
+    
+    # Add quantification columns for each sample
+    for sample_col in sample_columns:
+        quant_column_name = f"quant_{sample_col}"
+        # Join with quant_matrix to get values for this sample
+        sample_values = quant_matrix.join(
+            df.select("consensus_uid"), 
+            on="consensus_uid", 
+            how="right"
+        ).get_column(sample_col)
+        slaw_data[quant_column_name] = sample_values
+    
+    # Create the polars DataFrame
+    slaw_df = pl.DataFrame(slaw_data)
+    
+    # Convert to pandas for CSV export
+    pandas_df = slaw_df.to_pandas()
+    
+    # Export to CSV with comma separator - only quote when necessary (QUOTE_MINIMAL)
+    try:
+        pandas_df.to_csv(filename, sep=',', index=False, quoting=0)  # quoting=0 means QUOTE_MINIMAL
+        self.logger.success(f"Features exported to {filename} (SLAW format)")
+        self.logger.debug(f"Exported {len(slaw_df)} features with {len(slaw_df.columns)} columns")
+    except PermissionError:
+        self.logger.error(f"Permission denied: Cannot write to {filename}. The file may be open in another program. Please close it and try again.")

masster/study/importers.py

@@ -2,12 +2,13 @@
 import.py
 
 Module providing import functionality for Study class, specifically for importing
-oracle identification data into consensus features.
+oracle and TIMA identification data into consensus features.
 """
 
 from __future__ import annotations
 
 import os
+import glob
 import pandas as pd
 import polars as pl
 
@@ -320,3 +321,385 @@ def import_oracle(
             "id_matches": len(self.id_df),
         },
     )
+
+
+def import_tima(self, folder, file="results_annotation"):
+    """
+    Import TIMA identification data and map it to consensus features.
+
+    This method reads TIMA identification results from folder/results_annotation_*.tsv
+    and creates lib_df and id_df DataFrames with detailed library and identification information.
+    It also updates consensus_df with top identification results.
+
+    Parameters:
+        folder (str): Path to TIMA folder containing results_annotation_*.tsv files
+        file (str, optional): Base name of TIMA results file (default: "results_annotation")
+
+    Returns:
+        None: Updates consensus_df, creates lib_df and id_df in-place with TIMA identification data
+
+    Raises:
+        FileNotFoundError: If the TIMA results file doesn't exist
+        ValueError: If consensus_df is empty or doesn't have required columns
+
+    Example:
+        >>> study.import_tima(folder="path/to/tima_results")
+    """
+
+    self.logger.info(f"Starting TIMA import from folder: {folder}")
+
+    # Validate inputs
+    if self.consensus_df is None or self.consensus_df.is_empty():
+        raise ValueError("consensus_df is empty or not available. Run merge() first.")
+
+    if "consensus_id" not in self.consensus_df.columns:
+        raise ValueError("consensus_df must contain 'consensus_id' column")
+
+    # Find TIMA file
+    tima_pattern = os.path.join(folder, f"*{file}*.tsv")
+    tima_files = glob.glob(tima_pattern)
+
+    if not tima_files:
+        raise FileNotFoundError(f"TIMA results file not found with pattern: {tima_pattern}")
+
+    tima_file_path = tima_files[0]
+    self.logger.debug(f"Loading TIMA data from: {tima_file_path}")
+
+    try:
+        # Read TIMA data using polars
+        tima_data = pl.read_csv(
+            tima_file_path,
+            separator="\t",
+            schema_overrides={
+                "feature_id": pl.Utf8,  # Read as Utf8 string
+            },
+            infer_schema_length=10000,
+        )
+        self.logger.info(f"TIMA data loaded successfully with {len(tima_data)} rows")
+    except Exception as e:
+        self.logger.error(f"Could not read {tima_file_path}: {e}")
+        raise
+
+    # Check if TIMA feature_ids match consensus_df consensus_id column
+    if "consensus_id" not in self.consensus_df.columns:
+        raise ValueError("consensus_df must contain 'consensus_id' column")
+
+    # Compare TIMA feature_ids with consensus_df consensus_ids
+    consensus_ids = set(self.consensus_df["consensus_id"].to_list())
+    tima_ids = set(tima_data["feature_id"].to_list())
+
+    matching_ids = consensus_ids.intersection(tima_ids)
+    non_matching_ids = tima_ids - consensus_ids
+
+    if non_matching_ids:
+        self.logger.warning(
+            f"Found {len(non_matching_ids)} feature_ids in TIMA data that do not match any consensus_id in consensus_df. "
+            f"These will be filtered out. Matching features: {len(matching_ids)}/{len(tima_ids)}"
+        )
+        # Filter to only matching feature_ids
+        tima_data = tima_data.filter(pl.col("feature_id").is_in(list(consensus_ids)))
+
+    if len(tima_data) == 0:
+        self.logger.error("No TIMA feature_ids match consensus_df consensus_id values")
+        raise ValueError("No matching features found between TIMA data and consensus_df")
+
+    self.logger.debug(f"Matched {len(tima_data)} TIMA entries to consensus_df consensus_id values")
+
+    # Filter to only rows with identification data (non-empty label_compound)
+    initial_count = len(tima_data)
+    tima_data = tima_data.filter(
+        pl.col("label_compound").is_not_null() & (pl.col("label_compound").cast(pl.Utf8).str.strip_chars() != "")
+    )
+
+    self.logger.debug(f"Filtered to {len(tima_data)}/{initial_count} TIMA entries with identifications")
+
+    if len(tima_data) == 0:
+        self.logger.warning("No TIMA entries with identifications found")
+        return
+
+    # === CREATE LIB_DF ===
+    self.logger.debug("Creating lib_df from TIMA annotation data")
+    self.logger.debug(f"TIMA data shape before lib_df creation: {tima_data.shape}")
+
+    # Create unique lib_uid for each library entry
+    tima_data = tima_data.with_columns(pl.arange(0, len(tima_data)).alias("lib_uid"))
+
+    # Map TIMA columns to lib_df schema
+    lib_data = []
+    for row in tima_data.iter_rows(named=True):
+        # Extract z (charge) from adduct
+        z = None
+        adduct_str = str(row.get("adduct", ""))
+        if "+" in adduct_str:
+            z = 1
+        elif "-" in adduct_str:
+            z = -1
+
+        # Get SMILES
+        smiles = row.get("smiles_no_stereo", None)
+        if smiles is None or (isinstance(smiles, str) and smiles.strip() == ""):
+            smiles = None
+
+        # Calculate InChI from SMILES if available
+        inchi = None
+        if smiles:
+            try:
+                from rdkit import Chem
+
+                mol_rdkit = Chem.MolFromSmiles(smiles)
+                if mol_rdkit:
+                    inchi = Chem.MolToInchi(mol_rdkit)
+            except ImportError:
+                pass  # RDKit not available
+            except Exception:
+                pass
+
+        # Calculate formula from SMILES if available
+        formula = None
+        if smiles:
+            try:
+                from rdkit import Chem
+
+                mol_rdkit = Chem.MolFromSmiles(smiles)
+                if mol_rdkit:
+                    formula = Chem.rdMolDescriptors.CalcMolFormula(mol_rdkit)
+            except ImportError:
+                pass  # RDKit not available
+            except Exception:
+                pass
+
+        # Calculate mass from m/z and charge
+        m = None
+        mz_value = row.get("mz", None)
+        if mz_value is not None and z is not None:
+            try:
+                m = float(mz_value) * abs(z)
+            except (ValueError, TypeError):
+                pass
+
+        # Get class and clean NaN values
+        class_value = row.get("label_classyfire", None)
+        if class_value is None or (isinstance(class_value, str) and class_value.upper() == "NAN"):
+            class_value = None
+
+        lib_entry = {
+            "lib_uid": row["lib_uid"],
+            "cmpd_uid": row["lib_uid"],  # Use lib_uid as compound identifier
+            "source_id": None,  # Leave empty as requested
+            "name": row.get("label_compound", None),
+            "shortname": None,  # Not available in TIMA data
+            "class": class_value,
+            "smiles": smiles,
+            "inchi": inchi,
+            "inchikey": row.get("inchikey_connectivity_layer", None),
+            "formula": formula,
+            "iso": 0,  # Fixed isotope value
+            "adduct": row.get("adduct", None),
+            "probability": row.get("score", None),
+            "m": m,
+            "z": z,
+            "mz": row.get("mz", None),
+            "rt": None,  # Set to null as requested
+            "quant_group": None,
+            "db_id": None,  # Not available in TIMA data
+            "db": row.get("library", None),
+        }
+        lib_data.append(lib_entry)
+
+    self.logger.debug(f"Created {len(lib_data)} lib_data entries")
+
+    # Create lib_df as Polars DataFrame with error handling for mixed types
+    try:
+        lib_df_temp = pl.DataFrame(lib_data)
+    except Exception as e:
+        self.logger.warning(f"Error creating lib_df with polars: {e}")
+        # Fallback: convert to pandas first, then to polars
+        lib_df_pandas = pd.DataFrame(lib_data)
+        lib_df_temp = pl.from_pandas(lib_df_pandas)
+
+    # Ensure uniqueness by name and adduct combination
+    # Sort by lib_uid and keep first occurrence (earliest in processing order)
+    self.lib_df = lib_df_temp.sort("lib_uid").unique(subset=["name", "adduct"], keep="first")
+
+    self.logger.info(
+        f"Created lib_df with {len(self.lib_df)} library entries ({len(lib_data) - len(self.lib_df)} duplicates removed)"
+    )
+
+    # === CREATE ID_DF ===
+    self.logger.debug("Creating id_df from TIMA identification matches")
+
+    # Create a mapping from consensus_id to consensus_uid
+    # TIMA data has feature_id which matches consensus_id, map to consensus_uid for id_df
+    consensus_id_to_uid_map = dict(
+        zip(self.consensus_df["consensus_id"].to_list(), self.consensus_df["consensus_uid"].to_list())
+    )
+
+    # Create identification matches
+    id_data = []
+    for row in tima_data.iter_rows(named=True):
+        # Map TIMA feature_id to consensus_df consensus_uid
+        tima_feature_id = row["feature_id"]
+        consensus_uid = consensus_id_to_uid_map.get(tima_feature_id)
+
+        if consensus_uid is None:
+            # Skip if we can't find the mapping (shouldn't happen after filtering)
+            continue
+
+        # Use error_mz for mz_delta
+        mz_delta = None
+        error_mz = row.get("error_mz", None)
+        if error_mz is not None:
+            try:
+                mz_delta = float(error_mz)
+            except (ValueError, TypeError):
+                pass
+
+        # Use error_rt for rt_delta
+        rt_delta = None
+        rt_err_value = row.get("error_rt", None)
+        if rt_err_value is not None:
+            try:
+                rt_delta = float(rt_err_value)
+            except (ValueError, TypeError):
+                pass
+
+        # Create matcher as "tima-" + library
+        matcher = "tima"  # default fallback
+        library_value = row.get("library", None)
+        if library_value is not None:
+            try:
+                library = str(library_value)
+                matcher = f"tima-{library}"
+            except (ValueError, TypeError):
+                pass
+
+        id_entry = {
+            "consensus_uid": consensus_uid,  # Use mapped consensus_uid from consensus_df
+            "lib_uid": row["lib_uid"],
+            "mz_delta": mz_delta,
+            "rt_delta": rt_delta,
+            "matcher": matcher,
+            "score": row.get("score", None),
+        }
+        id_data.append(id_entry)
+
+    # Create id_df as Polars DataFrame with explicit schema to avoid inference issues
+    # Match consensus_uid type to consensus_df
+    consensus_uid_dtype = self.consensus_df["consensus_uid"].dtype
+    id_schema = {
+        "consensus_uid": consensus_uid_dtype,  # Match the type from consensus_df
+        "lib_uid": pl.Int64,
+        "mz_delta": pl.Float64,
+        "rt_delta": pl.Float64,
+        "matcher": pl.Utf8,
+        "score": pl.Float64,
+    }
+    id_df_temp = pl.DataFrame(id_data, schema=id_schema)
+
+    # Filter id_df to only include lib_uids that exist in the final unique lib_df
+    unique_lib_uids = self.lib_df.select("lib_uid").to_series()
+    self.id_df = id_df_temp.filter(pl.col("lib_uid").is_in(unique_lib_uids))
+
+    self.logger.info(f"Created id_df with {len(self.id_df)} identification matches")
+
+    # === UPDATE CONSENSUS_DF ===
+    self.logger.debug("Updating consensus_df with top identification results")
+
+    # tima_data is already a polars DataFrame
+    tima_pl = tima_data
+
+    # Group by feature_id and select the best identification (highest score)
+    # In case of ties, take the first one
+    best_ids = (
+        tima_pl.group_by("feature_id")
+        .agg([pl.col("score").max().alias("max_score")])
+        .join(tima_pl, on="feature_id")
+        .filter(pl.col("score") == pl.col("max_score"))
+        .group_by("feature_id")
+        .first()  # In case of ties, take the first
+    )
+
+    # Join with consensus_df to map consensus_id to consensus_uid
+    best_ids = best_ids.join(
+        self.consensus_df.select(["consensus_id", "consensus_uid"]), left_on="feature_id", right_on="consensus_id", how="left"
+    )
+
+    self.logger.debug(f"Selected best identifications for {len(best_ids)} consensus features")
+
+    # Prepare the identification columns
+    id_columns = {
+        "id_top_name": best_ids.select("consensus_uid", "label_compound"),
+        "id_top_adduct": best_ids.select("consensus_uid", "adduct"),
+        "id_top_class": best_ids.select("consensus_uid", "label_classyfire"),
+        "id_top_score": best_ids.select("consensus_uid", pl.col("score").round(3).alias("score")),
+    }
+
+    # Initialize identification columns in consensus_df if they don't exist
+    for col_name in id_columns.keys():
+        if col_name not in self.consensus_df.columns:
+            if col_name == "id_top_score":
+                self.consensus_df = self.consensus_df.with_columns(pl.lit(None, dtype=pl.Float64).alias(col_name))
+            else:
+                self.consensus_df = self.consensus_df.with_columns(pl.lit(None, dtype=pl.String).alias(col_name))
+
+    # Update consensus_df with TIMA identifications
+    for col_name, id_data_col in id_columns.items():
+        tima_column = id_data_col.columns[1]  # second column (after consensus_uid)
+
+        # Create update dataframe
+        update_data = id_data_col.rename({tima_column: col_name})
+
+        # Join and update
+        self.consensus_df = (
+            self.consensus_df.join(update_data, on="consensus_uid", how="left", suffix="_tima")
+            .with_columns(pl.coalesce([f"{col_name}_tima", col_name]).alias(col_name))
+            .drop(f"{col_name}_tima")
+        )
+
+    # Replace NaN values with None in identification columns
+    id_col_names = ["id_top_name", "id_top_adduct", "id_top_class", "id_top_score"]
+    for col_name in id_col_names:
+        if col_name in self.consensus_df.columns:
+            # For string columns, replace empty strings and "nan" with None
+            if col_name != "id_top_score":
+                self.consensus_df = self.consensus_df.with_columns(
+                    pl.when(
+                        pl.col(col_name).is_null()
+                        | (pl.col(col_name) == "")
+                        | (pl.col(col_name) == "nan")
+                        | (pl.col(col_name) == "NaN")
+                    )
+                    .then(None)
+                    .otherwise(pl.col(col_name))
+                    .alias(col_name)
+                )
+            # For numeric columns, replace NaN with None
+            else:
+                self.consensus_df = self.consensus_df.with_columns(
+                    pl.when(pl.col(col_name).is_null() | pl.col(col_name).is_nan())
+                    .then(None)
+                    .otherwise(pl.col(col_name))
+                    .alias(col_name)
+                )
+
+    # Count how many consensus features were updated
+    updated_count = self.consensus_df.filter(pl.col("id_top_name").is_not_null()).height
+    total_consensus = len(self.consensus_df)
+
+    self.logger.success(
+        f"TIMA import completed. {updated_count}/{total_consensus} "
+        f"consensus features now have identifications ({updated_count / total_consensus * 100:.1f}%)"
+    )
+
+    # Update history
+    self.update_history(
+        ["import_tima"],
+        {
+            "folder": folder,
+            "file": file,
+            "updated_features": updated_count,
+            "total_features": total_consensus,
+            "lib_entries": len(self.lib_df),
+            "id_matches": len(self.id_df),
+        },
+    )

masster/study/study.py

@@ -15,7 +15,7 @@ Main class:
     - Retrieval: get_consensus, get_chrom, get_samples, get_*_stats, get_*_matrix
     - Plotting: plot_alignment, plot_samples_pca/umap/2d, plot_tic/bpc/eic, plot_chrom,
         plot_rt_correction, plot_consensus_2d/stats, plot_heatmap
-    - Export: export_mgf, export_mztab, export_xlsx, export_parquet
+    - Export: export_mgf, export_mztab, export_excel, export_parquet
     - Identification: lib_load, identify, get_id, id_reset, lib_reset
     - Parameters: get/update parameters, update_history
 
@@ -109,7 +109,7 @@ from masster.study.parameters import update_parameters
 from masster.study.parameters import get_parameters_property
 from masster.study.parameters import set_parameters_property
 from masster.study.save import save, save_consensus, save_samples
-from masster.study.export import export_mgf, export_mztab, export_xlsx, export_parquet
+from masster.study.export import export_mgf, export_mztab, export_excel, export_parquet
 from masster.study.id import lib_load, identify, get_id, id_reset, lib_reset, _get_adducts
 from masster.study.importers import import_oracle
 
@@ -438,7 +438,7 @@ class Study:
     # === Export Operations ===
     export_mgf = export_mgf
     export_mztab = export_mztab
-    export_xlsx = export_xlsx
+    export_excel = export_excel
     export_parquet = export_parquet
 
     # === Identification and Library Matching ===

masster/wizard/wizard.py

@@ -709,7 +709,7 @@ class Wizard:
             "        # Step 6/7: Saving results",
             '        print("\\nStep 6/7: Saving results...")',
             "        study.save()",
-            "        study.export_xlsx()",
+            "        study.export_excel()",
             "        study.export_mgf()",
             "        study.export_mztab()",
             "        ",
@@ -1381,7 +1381,7 @@ class Wizard:
             "        # Step 6/7: Saving results",
             '        print("\\nStep 6/7: Saving results...")',
             "        study.save()",
-            "        study.export_xlsx()",
+            "        study.export_excel()",
             "        study.export_mgf()",
             "        study.export_mztab()",
             "        ",

{masster-0.6.1.dist-info → masster-0.6.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: masster
-Version: 0.6.1
+Version: 0.6.2
 Summary: Mass spectrometry data analysis package
 Project-URL: homepage, https://github.com/zamboni-lab/masster
 Project-URL: repository, https://github.com/zamboni-lab/masster