masster 0.4.19__py3-none-any.whl → 0.4.21__py3-none-any.whl

masster/study/plot.py

@@ -42,9 +42,10 @@ def _isolated_save_plot(plot_object, filename, abs_filename, logger, plot_title=
             from bokeh.io.export import export_png
             export_png(plot_object, filename=filename)
             logger.info(f"Plot saved to: {abs_filename}")
-        except Exception:
+        except Exception as e:
             # Fall back to HTML if PNG export not available
             html_filename = filename.replace('.png', '.html')
+            abs_html_filename = html_filename if abs_filename == filename else abs_filename.replace('.png', '.html')
             from bokeh.resources import Resources
             from bokeh.embed import file_html
 
@@ -54,7 +55,7 @@ def _isolated_save_plot(plot_object, filename, abs_filename, logger, plot_title=
             with open(html_filename, 'w', encoding='utf-8') as f:
                 f.write(html)
 
-            logger.warning(f"PNG export not available, saved as HTML instead: {html_filename}")
+            logger.warning(f"PNG export not available ({str(e)}). Use export_png. Saved as HTML instead: {abs_html_filename}")
     elif filename.endswith(".pdf"):
         # Try to save as PDF, fall back to HTML if not available
         try:
@@ -74,6 +75,26 @@ def _isolated_save_plot(plot_object, filename, abs_filename, logger, plot_title=
                 f.write(html)
 
             logger.warning(f"PDF export not available, saved as HTML instead: {html_filename}")
+    elif filename.endswith(".svg"):
+        # Try to save as SVG, fall back to HTML if not available
+        try:
+            from bokeh.io.export import export_svg
+            export_svg(plot_object, filename=filename)
+            logger.info(f"Plot saved to: {abs_filename}")
+        except Exception as e:
+            # Fall back to HTML if SVG export not available
+            html_filename = filename.replace('.svg', '.html')
+            abs_html_filename = html_filename if abs_filename == filename else abs_filename.replace('.svg', '.html')
+            from bokeh.resources import Resources
+            from bokeh.embed import file_html
+
+            resources = Resources(mode='cdn')
+            html = file_html(plot_object, resources, title=plot_title)
+
+            with open(html_filename, 'w', encoding='utf-8') as f:
+                f.write(html)
+
+            logger.warning(f"SVG export not available ({str(e)}). Saved as HTML instead: {abs_html_filename}")
     else:
         # Default to HTML for unknown extensions using isolated approach
         from bokeh.resources import Resources
@@ -181,6 +202,22 @@ def _isolated_save_panel_plot(panel_obj, filename, abs_filename, logger, plot_ti
                 logger.warning(f"PDF export not available, saved as HTML instead: {abs_html_filename}")
             except Exception as e:
                 logger.error(f"Failed to save {plot_title} as HTML fallback: {e}")
+    elif filename.endswith(".svg"):
+        # Try to save as SVG, fall back to HTML if not available
+        try:
+            from bokeh.io.export import export_svg
+            bokeh_layout = panel_obj.get_root()
+            export_svg(bokeh_layout, filename=filename)
+            logger.info(f"{plot_title} saved to: {abs_filename}")
+        except Exception as e:
+            # Fall back to HTML if SVG export not available
+            html_filename = filename.replace('.svg', '.html')
+            abs_html_filename = os.path.abspath(html_filename)
+            try:
+                panel_obj.save(html_filename, embed=True)
+                logger.warning(f"SVG export not available ({str(e)}), saved as HTML instead: {abs_html_filename}")
+            except Exception as e:
+                logger.error(f"Failed to save {plot_title} as HTML fallback: {e}")
     else:
         # Default to HTML for unknown extensions
         try:
@@ -512,9 +549,9 @@ def plot_consensus_2d(
     filename=None,
     colorby="number_samples",
     cmap=None,
-    markersize=4,
+    markersize=8,
     sizeby="inty_mean",
-    scaling="dynamic",
+    scaling="static",
     alpha=0.7,
     width=600,
     height=450,
@@ -529,7 +566,7 @@ def plot_consensus_2d(
         colorby (str): Column name to use for color mapping (default: "number_samples")
         sizeby (str): Column name to use for size mapping (default: "inty_mean")
         markersize (int): Base marker size (default: 6)
-        size (str): Controls whether points scale with zoom. Options:
+        scaling (str): Controls whether points scale with zoom. Options:
                    'dynamic' - points use circle() and scale with zoom
                    'static' - points use scatter() and maintain fixed pixel size
         alpha (float): Transparency level (default: 0.7)
@@ -553,7 +590,7 @@ def plot_consensus_2d(
     if colorby not in data.columns:
         self.logger.error(f"Column {colorby} not found in consensus_df.")
         return
-    if sizeby not in data.columns:
+    if sizeby is not None and sizeby not in data.columns:
         self.logger.warning(f"Column {sizeby} not found in consensus_df.")
         sizeby = None
     # if sizeby is not None, set markersize to sizeby
@@ -673,10 +710,16 @@ def plot_consensus_2d(
     p.yaxis.axis_label = "m/z"
     scatter_renderer: Any = None
     if scaling.lower() in ["dyn", "dynamic"]:
+        # Calculate appropriate radius for dynamic scaling based on data range
+        rt_range = data["rt"].max() - data["rt"].min()
+        mz_range = data["mz"].max() - data["mz"].min()
+        # Use a fraction of the smaller dimension for radius, similar to sample plotting
+        dynamic_radius = min(rt_range, mz_range) * 0.0005 * markersize
+        
         scatter_renderer = p.circle(
             x="rt",
             y="mz",
-            radius=markersize,
+            radius=dynamic_radius,
             fill_color={"field": colorby, "transform": color_mapper},
             line_color=None,
             alpha=alpha,

masster/study/processing.py

@@ -59,6 +59,17 @@ def align(self, **kwargs):
     """
     # parameters initialization
     params = align_defaults()
+    
+    # Handle 'params' keyword argument specifically (like merge does)
+    if 'params' in kwargs:
+        provided_params = kwargs.pop('params')
+        if isinstance(provided_params, align_defaults):
+            params = provided_params
+            self.logger.debug("Using provided align_defaults parameters from 'params' argument")
+        else:
+            self.logger.warning("'params' argument is not an align_defaults instance, ignoring")
+    
+    # Process remaining kwargs
     for key, value in kwargs.items():
         if isinstance(value, align_defaults):
             params = value
@@ -72,7 +83,7 @@ def align(self, **kwargs):
                         f"Failed to set parameter {key} = {value} (validation failed)",
                     )
             else:
-                self.logger.debug(f"Unknown parameter {key} ignored")
+                self.logger.warning(f"Unknown parameter '{key}' ignored")
     # end of parameter initialization
 
     # Store parameters in the Study object
@@ -825,6 +836,11 @@ def _align_kd_algorithm(study_obj, fmaps, params):
         f"Align time axes with rt_tol={params.get('rt_tol')}, min_samples={params.get('min_samples')}, max_points={max_points}",
     )
 
+    # Check if feature maps are empty before proceeding
+    if not fmaps:
+        study_obj.logger.error("No feature maps available for alignment. Cannot proceed with alignment.")
+        raise ValueError("No feature maps available for alignment. This usually indicates that all samples failed to load properly.")
+    
     # Choose reference map (largest number of features)
     ref_index = max(range(len(fmaps)), key=lambda i: fmaps[i].size())
     ref_map = fmaps[ref_index]
@@ -1003,3 +1019,243 @@ def _align_pose_clustering_fallback(study_obj, fmaps, params):
         transformer.transformRetentionTimes(fm, trafo, True)
 
     study_obj.alignment_ref_index = ref_index
+
+
+def find_iso(self, rt_tol=0.1, mz_tol=0.01):
+    """
+    Find isotope patterns for consensus features by searching raw MS1 data.
+    OPTIMIZED VERSION: Each sample file is loaded only once for maximum efficiency.
+    
+    For each consensus feature:
+    1. Find the associated feature with highest intensity  
+    2. Load the corresponding sample5 file to access raw MS1 data
+    3. Use original_rt (before alignment) to find the correct scan
+    4. Search for isotope patterns in raw MS1 spectra
+    5. Look for isotope patterns: 0.33, 0.50, 0.66, 1.00, 1.50, 2.00, 3.00, 4.00, 5.00 Da
+    6. Store results as numpy arrays with [mz, inty] in the iso column
+    
+    Parameters:
+        rt_tol (float): RT tolerance for scan matching in seconds
+        mz_tol (float): Additional m/z tolerance for isotope matching in Da
+    """
+    if self.consensus_df is None or self.consensus_df.is_empty():
+        self.logger.error("No consensus features found. Please run merge() first.")
+        return
+        
+    if self.consensus_mapping_df is None or self.consensus_mapping_df.is_empty():
+        self.logger.error("No consensus mapping found. Please run merge() first.")
+        return
+        
+    if self.features_df is None or self.features_df.is_empty():
+        self.logger.error("No features found.")
+        return
+    
+    if self.samples_df is None or self.samples_df.is_empty():
+        self.logger.error("No samples found.")
+        return
+    
+    # Add iso column if it doesn't exist
+    if "iso" not in self.consensus_df.columns:
+        self.consensus_df = self.consensus_df.with_columns(
+            pl.lit(None, dtype=pl.Object).alias("iso")
+        )
+    
+    self.logger.info("Extracting isotopomers from raw MS1 data...")
+    
+    # Isotope mass shifts to search for (up to 7x 13C isotopes)
+    isotope_shifts = [
+        0.33,
+        0.50,
+        0.66,
+        1.00335,
+        1.50502,
+        2.00670,
+        3.01005,
+        4.01340,
+        5.01675,
+        6.02010,
+        7.02345,
+    ]
+    
+    consensus_iso_data = {}
+    
+    # SUPER OPTIMIZATION: Vectorized pre-calculation using joins (10-100x faster)
+    self.logger.debug("Building sample-to-consensus mapping using vectorized operations...")
+    
+    # Step 1: Join consensus_mapping with features to get intensities in one operation
+    consensus_with_features = self.consensus_mapping_df.join(
+        self.features_df.select(['feature_uid', 'sample_uid', 'inty', 'mz', 'rt', 'rt_original']),
+        on=['feature_uid', 'sample_uid'],
+        how='left'
+    )
+    
+    # Step 2: Find the best feature (highest intensity) for each consensus using window functions
+    best_features = consensus_with_features.with_columns(
+        pl.col('inty').fill_null(0)  # Handle null intensities
+    ).with_columns(
+        pl.col('inty').max().over('consensus_uid').alias('max_inty')
+    ).filter(
+        pl.col('inty') == pl.col('max_inty')
+    ).group_by('consensus_uid').first()  # Take first if there are ties
+    
+    # Step 3: Join with samples to get sample paths in one operation
+    best_features_with_paths = best_features.join(
+        self.samples_df.select(['sample_uid', 'sample_path']),
+        on='sample_uid',
+        how='left'
+    ).filter(
+        pl.col('sample_path').is_not_null()
+    )
+    
+    # Step 4: Group by sample path for batch processing (much faster than nested loops)
+    sample_to_consensus = {}
+    for row in best_features_with_paths.iter_rows(named=True):
+        sample_path = row['sample_path']
+        consensus_uid = row['consensus_uid']
+        
+        # Create feature data dictionary for compatibility
+        feature_data = {
+            'mz': row['mz'],
+            'rt': row['rt'], 
+            'rt_original': row.get('rt_original', row['rt']),
+            'inty': row['inty']
+        }
+        
+        if sample_path not in sample_to_consensus:
+            sample_to_consensus[sample_path] = []
+        
+        sample_to_consensus[sample_path].append((consensus_uid, feature_data))
+    
+    # Initialize failed consensus features (those not in the mapping)
+    processed_consensus_uids = set(best_features_with_paths['consensus_uid'].to_list())
+    for consensus_row in self.consensus_df.iter_rows(named=True):
+        consensus_uid = consensus_row["consensus_uid"]
+        if consensus_uid not in processed_consensus_uids:
+            consensus_iso_data[consensus_uid] = None
+    
+    self.logger.debug(f"Will read {len(sample_to_consensus)} unique sample files for {len(self.consensus_df)} consensus features")
+    
+    tdqm_disable = self.log_level not in ["TRACE", "DEBUG", "INFO"]
+    
+    # OPTIMIZATION 2: Process by sample file (load each file only once)
+    for sample_path, consensus_list in tqdm(
+        sample_to_consensus.items(),
+        desc=f"{datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]} | INFO     | {self.log_label}Read files",
+        disable=tdqm_disable,
+    ):
+        try:
+            # Load MS1 data once per sample
+            ms1_df = self._load_ms1(sample_path)
+            
+            if ms1_df is None or ms1_df.is_empty():
+                # Mark all consensus features from this sample as failed
+                for consensus_uid, _ in consensus_list:
+                    consensus_iso_data[consensus_uid] = None
+                continue
+            
+            # Process all consensus features for this sample
+            for consensus_uid, best_feature in consensus_list:
+                # Get the original RT (before alignment correction)
+                base_mz = best_feature["mz"]
+                original_rt = best_feature.get("rt_original", best_feature["rt"])
+                
+                # Find MS1 scans near the original RT
+                rt_min = original_rt - rt_tol
+                rt_max = original_rt + rt_tol
+                
+                # Filter MS1 data for scans within RT window
+                ms1_window = ms1_df.filter(
+                    (pl.col("rt") >= rt_min) & (pl.col("rt") <= rt_max)
+                )
+                
+                if ms1_window.is_empty():
+                    consensus_iso_data[consensus_uid] = None
+                    continue
+                
+                isotope_matches = []
+                
+                # Search for each isotope shift
+                for shift in isotope_shifts:
+                    target_mz = base_mz + shift
+                    mz_min_iso = target_mz - mz_tol
+                    mz_max_iso = target_mz + mz_tol
+                    
+                    # Find peaks in MS1 data within m/z tolerance
+                    isotope_peaks = ms1_window.filter(
+                        (pl.col("mz") >= mz_min_iso) & (pl.col("mz") <= mz_max_iso)
+                    )
+                    
+                    if not isotope_peaks.is_empty():
+                        # Get the peak with maximum intensity for this isotope
+                        max_peak = isotope_peaks.filter(
+                            pl.col("inty") == pl.col("inty").max()
+                        ).row(0, named=True)
+                        
+                        # Store as float with specific precision: m/z to 4 decimals, intensity rounded to integer
+                        mz_formatted = round(float(max_peak["mz"]), 4)
+                        inty_formatted = float(round(max_peak["inty"]))  # Round to integer, but keep as float
+                        isotope_matches.append([mz_formatted, inty_formatted])
+                
+                # Store results as numpy array
+                if isotope_matches:
+                    consensus_iso_data[consensus_uid] = np.array(isotope_matches)
+                else:
+                    consensus_iso_data[consensus_uid] = None
+                    
+        except Exception as e:
+            self.logger.warning(f"Failed to load MS1 data from {sample_path}: {e}")
+            # Mark all consensus features from this sample as failed
+            for consensus_uid, _ in consensus_list:
+                consensus_iso_data[consensus_uid] = None
+            continue
+    
+    # Update consensus_df with isotope data
+    # Create mapping function for update
+    def get_iso_data(uid):
+        return consensus_iso_data.get(uid, None)
+    
+    # Update the iso column
+    self.consensus_df = self.consensus_df.with_columns(
+        pl.col("consensus_uid").map_elements(
+            lambda uid: get_iso_data(uid),
+            return_dtype=pl.Object
+        ).alias("iso")
+    )
+    
+    # Count how many consensus features have isotope data
+    iso_count = sum(1 for data in consensus_iso_data.values() if data is not None and len(data) > 0)
+    
+    self.logger.info(f"Optimized isotope detection completed. Found isotope patterns for {iso_count}/{len(self.consensus_df)} consensus features.")
+
+
+def reset_iso(self):
+    """
+    Reset the iso column in consensus_df to None, clearing all isotope data.
+    
+    This function clears any previously computed isotope patterns from the
+    consensus_df, setting the 'iso' column to None for all features. This
+    is useful before re-running isotope detection with different parameters
+    or to clear isotope data entirely.
+    
+    Returns:
+        None
+    """
+    if self.consensus_df is None:
+        self.logger.warning("No consensus_df found. Nothing to reset.")
+        return
+    
+    if "iso" not in self.consensus_df.columns:
+        self.logger.warning("No 'iso' column found in consensus_df. Nothing to reset.")
+        return
+    
+    # Count how many features currently have isotope data
+    iso_count = self.consensus_df.select(
+        pl.col("iso").is_not_null().sum().alias("count")
+    ).item(0, "count")
+    
+    # Reset the iso column to None
+    self.consensus_df = self.consensus_df.with_columns(
+        pl.lit(None, dtype=pl.Object).alias("iso")
+    )
+    
+    self.logger.info(f"Reset isotope data for {iso_count} features. All 'iso' values set to None.")

masster/study/save.py

@@ -154,13 +154,56 @@ def save_samples(self, samples=None):
 
 
 def _save_consensusXML(self, filename: str):
-    if self.consensus_map is None:
-        self.logger.error("No consensus map found.")
+    if self.consensus_df is None or self.consensus_df.is_empty():
+        self.logger.error("No consensus features found.")
         return
-
+        
+    # Build consensus map from consensus_df with proper consensus_id values
+    import pyopenms as oms
+    consensus_map = oms.ConsensusMap()
+    
+    # Set up file descriptions for all samples
+    file_descriptions = consensus_map.getColumnHeaders()
+    if hasattr(self, 'samples_df') and not self.samples_df.is_empty():
+        for i, sample_row in enumerate(self.samples_df.iter_rows(named=True)):
+            file_description = file_descriptions.get(i, oms.ColumnHeader())
+            file_description.filename = sample_row.get("sample_name", f"sample_{i}")
+            file_description.size = 0  # Will be updated if needed
+            file_description.unique_id = i + 1
+            file_descriptions[i] = file_description
+        consensus_map.setColumnHeaders(file_descriptions)
+    
+    # Add consensus features to the map (simplified version without individual features)
+    for consensus_row in self.consensus_df.iter_rows(named=True):
+        consensus_feature = oms.ConsensusFeature()
+        
+        # Set basic properties
+        consensus_feature.setRT(float(consensus_row.get("rt", 0.0)))
+        consensus_feature.setMZ(float(consensus_row.get("mz", 0.0)))
+        consensus_feature.setIntensity(float(consensus_row.get("inty_mean", 0.0)))
+        consensus_feature.setQuality(float(consensus_row.get("quality", 1.0)))
+        
+        # Set the unique consensus_id as the unique ID
+        consensus_id_str = consensus_row.get("consensus_id", "")
+        if consensus_id_str and len(consensus_id_str) == 16:
+            try:
+                # Convert 16-character hex string to integer for OpenMS
+                consensus_uid = int(consensus_id_str, 16)
+                consensus_feature.setUniqueId(consensus_uid)
+            except ValueError:
+                # Fallback to hash if not hex
+                consensus_feature.setUniqueId(hash(consensus_id_str) & 0x7FFFFFFFFFFFFFFF)
+        else:
+            # Fallback to consensus_uid
+            consensus_feature.setUniqueId(consensus_row.get("consensus_uid", 0))
+        
+        consensus_map.push_back(consensus_feature)
+    
+    # Save the consensus map
     fh = oms.ConsensusXMLFile()
-    fh.store(filename, self.consensus_map)
-    self.logger.debug(f"Saved consensus map to {filename}")
+    fh.store(filename, consensus_map)
+    self.logger.debug(f"Saved consensus map with {len(self.consensus_df)} features to {filename}")
+    self.logger.debug("Features use unique 16-character consensus_id strings")
 
 
 def save_consensus(self, **kwargs):

masster/study/study.py

@@ -55,6 +55,7 @@ import polars as pl
 from masster.study.h5 import _load_study5
 from masster.study.h5 import _save_study5
 from masster.study.h5 import _save_study5_compressed
+from masster.study.h5 import _load_ms1
 from masster.study.helpers import _get_consensus_uids
 from masster.study.helpers import _get_feature_uids
 from masster.study.helpers import _get_sample_uids
@@ -120,9 +121,14 @@ from masster.study.merge import merge
 from masster.study.merge import _reset_consensus_data
 from masster.study.merge import _extract_consensus_features
 from masster.study.merge import _perform_adduct_grouping
+from masster.study.merge import _consensus_cleanup
+from masster.study.merge import _identify_adduct_by_mass_shift
 from masster.study.merge import _finalize_merge
+from masster.study.merge import _count_tight_clusters
 from masster.study.processing import integrate
 from masster.study.processing import find_ms2
+from masster.study.processing import find_iso
+from masster.study.processing import reset_iso
 from masster.study.parameters import store_history
 from masster.study.parameters import get_parameters
 from masster.study.parameters import update_parameters
@@ -382,6 +388,9 @@ class Study:
     merge = merge
     find_consensus = merge  # Backward compatibility alias
     find_ms2 = find_ms2
+    find_iso = find_iso
+    reset_iso = reset_iso
+    iso_reset = reset_iso
     integrate = integrate
     integrate_chrom = integrate  # Backward compatibility alias
     fill = fill
@@ -418,9 +427,11 @@ class Study:
     set_source = set_source
     sample_color = sample_color
     sample_color_reset = sample_color_reset
+    reset_sample_color = sample_color_reset
     name_replace = sample_name_replace
     name_reset = sample_name_reset
-    
+    reset_name = sample_name_reset
+
     # === Data Compression and Storage ===
     compress = compress
     compress_features = compress_features
@@ -433,8 +444,10 @@ class Study:
     
     # === Reset Operations ===
     fill_reset = fill_reset
+    reset_fill = fill_reset
     align_reset = align_reset
-    
+    reset_align = align_reset
+
     # === Plotting and Visualization ===
     plot_alignment = plot_alignment
     plot_chrom = plot_chrom
@@ -458,8 +471,10 @@ class Study:
     identify = identify
     get_id = get_id
     id_reset = id_reset
+    reset_id = id_reset
     lib_reset = lib_reset
-    
+    reset_lib = lib_reset
+
     # === Parameter Management ===
     store_history = store_history
     get_parameters = get_parameters
@@ -475,6 +490,7 @@ class Study:
     _load_study5 = _load_study5
     _save_study5 = _save_study5
     _save_study5_compressed = _save_study5_compressed
+    _load_ms1 = _load_ms1
     _get_consensus_uids = _get_consensus_uids
     _get_feature_uids = _get_feature_uids
     _get_sample_uids = _get_sample_uids
@@ -496,6 +512,8 @@ class Study:
     _reset_consensus_data = _reset_consensus_data
     _extract_consensus_features = _extract_consensus_features
     _perform_adduct_grouping = _perform_adduct_grouping
+    _consensus_cleanup = _consensus_cleanup
+    _identify_adduct_by_mass_shift = _identify_adduct_by_mass_shift
     _finalize_merge = _finalize_merge
     
     # === Default Parameters ===
@@ -873,6 +891,15 @@ class Study:
             + (self.consensus_mapping_df.estimated_size() if self.consensus_mapping_df is not None else 0)
         )
 
+        # Calculate tight clusters count
+        tight_clusters_count = 0
+        if consensus_df_len > 0:
+            try:
+                tight_clusters_count = _count_tight_clusters(self, mz_tol=0.04, rt_tol=0.3)
+            except Exception as e:
+                # If tight clusters calculation fails, just use 0
+                tight_clusters_count = 0
+
         # Add warning symbols for out-of-range values
         consensus_warning = f" {_WARNING_SYMBOL}" if consensus_df_len < 50 else ""
 
@@ -901,6 +928,9 @@ class Study:
             elif max_samples < samples_df_len * 0.8:
                 max_samples_warning = f" {_WARNING_SYMBOL}"
 
+        # Add warning for tight clusters
+        tight_clusters_warning = f" {_WARNING_SYMBOL}" if tight_clusters_count > 10 else ""
+
         summary = (
             f"Study folder:           {self.folder}\n"
             f"Last save:              {self.filename}\n"
@@ -910,6 +940,7 @@ class Study:
             f"- not in consensus:     {ratio_not_in_consensus_to_total:.0f}%\n"
             f"Consensus:              {consensus_df_len}{consensus_warning}\n"
             f"- RT spread:            {rt_spread_text}{rt_spread_warning}\n"
+            f"- Tight clusters:       {tight_clusters_count}{tight_clusters_warning}\n"
             f"- Min samples count:    {min_samples:.0f}\n"
             f"- Mean samples count:   {mean_samples:.0f}\n"
             f"- Max samples count:    {max_samples:.0f}{max_samples_warning}\n"

masster/study/study5_schema.json

@@ -70,6 +70,9 @@
       "chrom_height_scaled_mean": {
         "dtype": "pl.Float64"
       },
+      "iso": {
+        "dtype": "pl.Object"
+      },
       "iso_mean": {
         "dtype": "pl.Float64"
       },

masster/wizard/__init__.py

@@ -4,8 +4,14 @@ Wizard module for automated processing of mass spectrometry studies.
 This module provides the Wizard class for fully automated processing of MS data
 from raw files to final study results, including batch conversion, assembly,
 alignment, merging, plotting, and export.
+
+The create_script() function allows immediate generation of standalone analysis
+scripts without creating a Wizard instance first.
+
+The execute() function combines create_script() with immediate execution of the
+generated script for fully automated processing.
 """
 
-from .wizard import Wizard, wizard_def
+from .wizard import Wizard, wizard_def, create_script, execute
 
-__all__ = ["Wizard", "wizard_def"]
+__all__ = ["Wizard", "wizard_def", "create_script", "execute"]