masster 0.5.12__py3-none-any.whl → 0.5.14__py3-none-any.whl

masster/study/importers.py

@@ -0,0 +1,331 @@
+"""
+import.py
+
+Module providing import functionality for Study class, specifically for importing
+oracle identification data into consensus features.
+"""
+
+from __future__ import annotations
+
+import os
+import pandas as pd
+import polars as pl
+
+
+def import_oracle(
+    self,
+    folder,
+    min_id_level=None,
+    max_id_level=None,
+):
+    """
+    Import oracle identification data and map it to consensus features.
+    
+    This method reads oracle identification results from folder/diag/annotation_full.csv
+    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 oracle folder containing diag/annotation_full.csv
+        min_id_level (int, optional): Minimum identification level to include
+        max_id_level (int, optional): Maximum identification level to include
+        
+    Returns:
+        None: Updates consensus_df, creates lib_df and id_df in-place with oracle identification data
+        
+    Raises:
+        FileNotFoundError: If the oracle annotation file doesn't exist
+        ValueError: If consensus_df is empty or doesn't have required columns
+        
+    Example:
+        >>> study.import_oracle(
+        ...     folder="path/to/oracle_results",
+        ...     min_id_level=2,
+        ...     max_id_level=4
+        ... )
+    """
+    
+    self.logger.info(f"Starting oracle 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_uid" not in self.consensus_df.columns:
+        raise ValueError("consensus_df must contain 'consensus_uid' column")
+    
+    # Check if oracle file exists
+    oracle_file_path = os.path.join(folder, "diag", "annotation_full.csv")
+    if not os.path.exists(oracle_file_path):
+        raise FileNotFoundError(f"Oracle annotation file not found: {oracle_file_path}")
+    
+    self.logger.debug(f"Loading oracle data from: {oracle_file_path}")
+    
+    try:
+        # Read oracle data using pandas first for easier processing
+        oracle_data = pd.read_csv(oracle_file_path)
+        self.logger.info(f"Oracle data loaded successfully with {len(oracle_data)} rows")
+    except Exception as e:
+        self.logger.error(f"Could not read {oracle_file_path}: {e}")
+        raise
+    
+    # Extract consensus_uid from scan_title column (format: "uid:XYZ, ...")
+    self.logger.debug("Extracting consensus UIDs from oracle scan_title using pattern 'uid:(\\d+)'")
+    oracle_data["consensus_uid"] = oracle_data["scan_title"].str.extract(r"uid:(\d+)", expand=False)
+    
+    # Remove rows where consensus_uid extraction failed
+    initial_count = len(oracle_data)
+    oracle_data = oracle_data.dropna(subset=["consensus_uid"])
+    oracle_data["consensus_uid"] = oracle_data["consensus_uid"].astype(int)
+    
+    self.logger.debug(f"Extracted consensus UIDs for {len(oracle_data)}/{initial_count} oracle entries")
+    
+    # Apply id_level filters if specified
+    if min_id_level is not None:
+        oracle_data = oracle_data[oracle_data["level"] >= min_id_level]
+        self.logger.debug(f"After min_id_level filter ({min_id_level}): {len(oracle_data)} entries")
+    
+    if max_id_level is not None:
+        oracle_data = oracle_data[oracle_data["level"] <= max_id_level]
+        self.logger.debug(f"After max_id_level filter ({max_id_level}): {len(oracle_data)} entries")
+    
+    if len(oracle_data) == 0:
+        self.logger.warning("No oracle entries remain after filtering")
+        return
+    
+    # === CREATE LIB_DF ===
+    self.logger.debug("Creating lib_df from Oracle annotation data")
+    self.logger.debug(f"Oracle data shape before lib_df creation: {oracle_data.shape}")
+    
+    # Create unique lib_uid for each library entry
+    oracle_data["lib_uid"] = range(len(oracle_data))
+    
+    # Map Oracle columns to lib_df schema
+    lib_data = []
+    for _, row in oracle_data.iterrows():
+        # Convert cmpd_uid to integer, using lib_uid as fallback
+        cmpd_uid = row["lib_uid"]  # Use lib_uid as integer compound identifier
+        try:
+            if row.get("lib_id") is not None:
+                cmpd_uid = int(float(str(row["lib_id"])))  # Convert to int, handling potential float strings
+        except (ValueError, TypeError):
+            pass  # Keep lib_uid as fallback
+            
+        lib_entry = {
+            "lib_uid": row["lib_uid"],
+            "cmpd_uid": cmpd_uid,  # Integer compound identifier
+            "source_id": "LipidOracle",  # Fixed source identifier
+            "name": row.get("name", None),
+            "shortname": row.get("species", None),
+            "class": row.get("hg", None),            
+            "smiles": None,  # Not available in Oracle data
+            "inchi": None,   # Not available in Oracle data
+            "inchikey": None, # Not available in Oracle data
+            "formula": row.get("formula", None),
+            "iso": 0,        # Fixed isotope value
+            "adduct": row.get("ion", None),
+            "probability": row.get("score", None),
+            "m": None,       # Would need to calculate from formula
+            "z": 1 if row.get("ion", "").find("+") != -1 else (-1 if row.get("ion", "").find("-") != -1 else None),
+            "mz": row.get("mz", None),  # Use mz column from annotation_full.csv
+            "rt": None,      # Set to null as requested
+            "quant_group": None,  # Set to null as requested
+            "db_id": row.get("lib_id", None),
+            "db": row.get("lib", 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 Oracle identification matches")
+    
+    # Create identification matches
+    id_data = []
+    for _, row in oracle_data.iterrows():
+        # Use dmz from annotation_full.csv directly for mz_delta
+        mz_delta = None
+        if row.get("dmz") is not None:
+            try:
+                mz_delta = float(row["dmz"])
+            except (ValueError, TypeError):
+                pass
+        
+        # Use rt_err from annotation_full.csv for rt_delta, None if NaN
+        rt_delta = None
+        rt_err_value = row.get("rt_err")
+        if rt_err_value is not None and not (isinstance(rt_err_value, float) and pd.isna(rt_err_value)):
+            try:
+                rt_delta = float(rt_err_value)
+            except (ValueError, TypeError):
+                pass
+        
+        # Create matcher as "lipidoracle-" + score_metric from annotation_full.csv
+        matcher = "lipidoracle"  # default fallback
+        if row.get("score_metric") is not None:
+            try:
+                score_metric = str(row["score_metric"])
+                matcher = f"lipidoracle-{score_metric}"
+            except (ValueError, TypeError):
+                pass
+        
+        id_entry = {
+            "consensus_uid": row["consensus_uid"],
+            "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 error handling
+    try:
+        id_df_temp = pl.DataFrame(id_data)
+    except Exception as e:
+        self.logger.warning(f"Error creating id_df with polars: {e}")
+        # Fallback: convert to pandas first, then to polars
+        id_df_pandas = pd.DataFrame(id_data)
+        id_df_temp = pl.from_pandas(id_df_pandas)
+    
+    # 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 (existing functionality) ===
+    self.logger.debug("Updating consensus_df with top identification results")
+    
+    # Convert to polars for efficient joining with error handling
+    try:
+        oracle_pl = pl.DataFrame(oracle_data)
+    except Exception as e:
+        self.logger.warning(f"Error converting oracle_data to polars: {e}")
+        # Convert using from_pandas properly
+        oracle_pl = pl.from_pandas(oracle_data.reset_index(drop=True))
+    
+    # Group by consensus_uid and select the best identification (highest level)
+    # In case of ties, take the first one
+    best_ids = (
+        oracle_pl
+        .group_by("consensus_uid")
+        .agg([
+            pl.col("level").max().alias("max_level")
+        ])
+        .join(oracle_pl, on="consensus_uid")
+        .filter(pl.col("level") == pl.col("max_level"))
+        .group_by("consensus_uid")
+        .first()  # In case of ties, take the first
+    )
+    
+    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", "name"),
+        "id_top_adduct": best_ids.select("consensus_uid", "ion"), 
+        "id_top_class": best_ids.select("consensus_uid", "hg"),
+        "id_top_score": best_ids.select("consensus_uid", pl.col("score").round(3).alias("score")),
+        "id_source": best_ids.select(
+            "consensus_uid", 
+            pl.when(pl.col("level") == 1)
+            .then(pl.lit("lipidoracle ms1"))
+            .otherwise(pl.lit("lipidoracle ms2"))
+            .alias("id_source")
+        )
+    }
+    
+    # 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 oracle identifications
+    for col_name, id_data_col in id_columns.items():
+        oracle_column = id_data_col.columns[1]  # second column (after consensus_uid)
+        
+        # Create update dataframe
+        update_data = id_data_col.rename({oracle_column: col_name})
+        
+        # Join and update
+        self.consensus_df = (
+            self.consensus_df
+            .join(update_data, on="consensus_uid", how="left", suffix="_oracle")
+            .with_columns(
+                pl.coalesce([f"{col_name}_oracle", col_name]).alias(col_name)
+            )
+            .drop(f"{col_name}_oracle")
+        )
+    
+    # Replace NaN values with None in identification columns
+    id_col_names = ["id_top_name", "id_top_adduct", "id_top_class", "id_top_score", "id_source"]
+    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"LipidOracle import completed. {updated_count}/{total_consensus} "
+        f"consensus features now have identifications ({updated_count/total_consensus*100:.1f}%)"
+    )
+    
+    # Update history
+    self.update_history(["import_oracle"], {
+        "folder": folder,
+        "min_id_level": min_id_level,
+        "max_id_level": max_id_level,
+        "updated_features": updated_count,
+        "total_features": total_consensus,
+        "lib_entries": len(self.lib_df),
+        "id_matches": len(self.id_df)
+    })

masster/study/merge.py

@@ -1792,6 +1792,7 @@ def _calculate_consensus_statistics(study_obj, consensus_uid: int, feature_data_
         "id_top_class": None,
         "id_top_adduct": None,
         "id_top_score": None,
+        "id_source": None,
     }
 
 
@@ -2194,6 +2195,7 @@ def _extract_consensus_features(study, consensus_map, min_samples, cached_adduct
                 "id_top_class": None,
                 "id_top_adduct": None,
                 "id_top_score": None,
+                "id_source": None,
             },
         )
 
@@ -3021,7 +3023,7 @@ def __identify_adduct_by_mass_shift(study, rt_tol, cached_adducts_df=None):
             pl.Series("adduct_mass_neutral_top", new_adduct_mass_neutral_top),
             pl.Series("adduct_mass_shift_top", new_adduct_mass_shift_top)
         ])
-        study.logger.success(f"Adduct information updated for {updated_count} consensus features.")
+        study.logger.info(f"Adduct information updated for {updated_count} consensus features.")
     else:
         study.logger.debug("No consensus features updated based on mass shift analysis")
 

masster/study/plot.py

@@ -630,6 +630,8 @@ def plot_consensus_2d(
     height=450,
     mz_range=None,
     rt_range=None,
+    legend="bottom_right",
+    show_none=True,
 ):
     """
     Plot consensus features in a 2D scatter plot with retention time vs m/z.
@@ -652,6 +654,10 @@ def plot_consensus_2d(
         height (int): Plot height in pixels (default: 900)
         mz_range (tuple, optional): m/z range for filtering consensus features (min_mz, max_mz)
         rt_range (tuple, optional): Retention time range for filtering consensus features (min_rt, max_rt)
+        legend (str, optional): Legend position for categorical data. Options: 'top_right', 'top_left', 
+                               'bottom_right', 'bottom_left', 'right', 'left', 'top', 'bottom'.
+                               If None, legend is hidden. Only applies to categorical coloring (default: "bottom_right")
+        show_none (bool): Whether to display points with None values for colorby column (default: True)
     """
     if self.consensus_df is None:
         self.logger.error("No consensus map found.")
@@ -730,6 +736,10 @@ def plot_consensus_2d(
         from bokeh.models.annotations import ColorBar
     from bokeh.palettes import viridis, Category20
 
+    # Filter out None values for colorby column if show_none=False
+    if not show_none and colorby in data.columns:
+        data = data.filter(pl.col(colorby).is_not_null())
+    
     # Convert Polars DataFrame to pandas for Bokeh compatibility
     data_pd = data.to_pandas()
     source = ColumnDataSource(data_pd)
@@ -783,13 +793,20 @@ def plot_consensus_2d(
         # Sorting would break the correspondence between legend labels and point colors
         unique_values = [v for v in data_pd[colorby].unique() if v is not None]
         
-        if len(unique_values) <= 20:
-            palette = Category20[min(20, max(3, len(unique_values)))]
+        # Use the custom palette from cmap if available, otherwise fall back to defaults
+        if len(palette) >= len(unique_values):
+            # Use custom colormap palette - sample evenly across the palette
+            import numpy as np
+            indices = np.linspace(0, len(palette) - 1, len(unique_values)).astype(int)
+            categorical_palette = [palette[i] for i in indices]
+        elif len(unique_values) <= 20:
+            # Fall back to Category20 if custom palette is too small
+            categorical_palette = Category20[min(20, max(3, len(unique_values)))]
         else:
             # For many categories, use a subset of the viridis palette
-            palette = viridis(min(256, len(unique_values)))
+            categorical_palette = viridis(min(256, len(unique_values)))
         
-        color_mapper = factor_cmap(colorby, palette, unique_values)
+        color_mapper = factor_cmap(colorby, categorical_palette, unique_values)
     else:
         # Handle numeric coloring with LinearColorMapper
         color_mapper = LinearColorMapper(
@@ -809,21 +826,65 @@ def plot_consensus_2d(
     if is_categorical:
         # For categorical data, create separate renderers for each category
         # This enables proper legend interactivity where each category can be toggled independently
-        unique_values = [v for v in data_pd[colorby].unique() if v is not None]
+        all_unique_values = list(data_pd[colorby].unique())
+        unique_values = [v for v in all_unique_values if v is not None]
+        has_none_values = None in all_unique_values
         
-        if len(unique_values) <= 20:
-            palette = Category20[min(20, max(3, len(unique_values)))]
+        # Use the custom palette from cmap if available, otherwise fall back to defaults
+        if len(palette) >= len(unique_values):
+            # Use custom colormap palette - sample evenly across the palette
+            import numpy as np
+            indices = np.linspace(0, len(palette) - 1, len(unique_values)).astype(int)
+            categorical_palette = [palette[i] for i in indices]
+        elif len(unique_values) <= 20:
+            # Fall back to Category20 if custom palette is too small
+            categorical_palette = Category20[min(20, max(3, len(unique_values)))]
         else:
-            palette = viridis(min(256, len(unique_values)))
+            categorical_palette = viridis(min(256, len(unique_values)))
         
-        # Create a separate renderer for each category
+        # Handle None values with black color FIRST so they appear in the background
+        if has_none_values and show_none:
+            # Filter data for None values
+            none_data = data.filter(pl.col(colorby).is_null())
+            none_data_pd = none_data.to_pandas()
+            none_source = bp.ColumnDataSource(none_data_pd)
+            
+            if scaling.lower() in ["dyn", "dynamic"]:
+                # Calculate appropriate radius for dynamic scaling
+                rt_range = data["rt"].max() - data["rt"].min()
+                mz_range = data["mz"].max() - data["mz"].min()
+                dynamic_radius = min(rt_range, mz_range) * 0.0005 * markersize
+                
+                renderer = p.circle(
+                    x="rt",
+                    y="mz", 
+                    radius=dynamic_radius,
+                    fill_color="lightgray",
+                    line_color=None,
+                    alpha=alpha,
+                    source=none_source,
+                    legend_label="None",
+                )
+            else:
+                renderer = p.scatter(
+                    x="rt",
+                    y="mz",
+                    size="markersize", 
+                    fill_color="lightgray",
+                    line_color=None,
+                    alpha=alpha,
+                    source=none_source,
+                    legend_label="None",
+                )
+        
+        # Create a separate renderer for each non-None category (plotted on top of None values)
         for i, category in enumerate(unique_values):
             # Filter data for this category
             category_data = data.filter(pl.col(colorby) == category)
             category_data_pd = category_data.to_pandas()
             category_source = bp.ColumnDataSource(category_data_pd)
             
-            color = palette[i % len(palette)]
+            color = categorical_palette[i % len(categorical_palette)]
             
             if scaling.lower() in ["dyn", "dynamic"]:
                 # Calculate appropriate radius for dynamic scaling
@@ -892,33 +953,19 @@ def plot_consensus_2d(
         ("number_samples", "@number_samples"),
         ("number_ms2", "@number_ms2"),
         ("inty_mean", "@inty_mean"),
-        ("coherence_mean", "@chrom_coherence_mean"),
-        ("prominence_scaled_mean", "@chrom_prominence_scaled_mean"),
     ]
     
-    # Add adduct_top if it exists in data
-    if "adduct_top" in data.columns:
-        tooltips.append(("adduct_top", "@adduct_top"))
-    
-    # Add id_top_name if it exists in data
-    if "id_top_name" in data.columns:
-        tooltips.append(("id_top_name", "@id_top_name"))
-    
-    # Add id_top_adduct if it exists in data
-    if "id_top_adduct" in data.columns:
-        tooltips.append(("id_top_adduct", "@id_top_adduct"))
-    
     # Add id_top_* columns if they exist and have non-null values
-    id_top_columns = ["id_top_name", "id_top_class", "id_top_adduct", "id_top_score"]
+    id_top_columns = ["id_top_name", "id_top_adduct", "id_top_class", "id_top_score"]
     for col in id_top_columns:
         if col in data.columns:
             # Check if the column has any non-null values
             if data.filter(pl.col(col).is_not_null()).height > 0:
                 # Format score column with decimal places, others as strings
                 if col == "id_top_score":
-                    tooltips.append((col.replace("id_top_", "id_"), f"@{col}{{0.0000}}"))
+                    tooltips.append((col, f"@{col}{{0.0}}"))
                 else:
-                    tooltips.append((col.replace("id_top_", "id_"), f"@{col}"))
+                    tooltips.append((col, f"@{col}"))
     
     hover = HoverTool(
         tooltips=tooltips,
@@ -942,8 +989,25 @@ def plot_consensus_2d(
         p.add_layout(color_bar, "right")
     else:
         # For categorical data, configure the legend that was automatically created
-        p.legend.location = "top_right"
-        p.legend.click_policy = "hide"
+        if legend is not None:
+            # Map legend position parameter to Bokeh legend position
+            legend_position_map = {
+                "top_right": "top_right",
+                "top_left": "top_left", 
+                "bottom_right": "bottom_right",
+                "bottom_left": "bottom_left",
+                "right": "right",
+                "left": "left",
+                "top": "top",
+                "bottom": "bottom"
+            }
+            
+            bokeh_legend_pos = legend_position_map.get(legend, "bottom_right")
+            p.legend.location = bokeh_legend_pos
+            p.legend.click_policy = "hide"
+        else:
+            # Hide legend when legend=None
+            p.legend.visible = False
 
     if filename is not None:
         # Convert relative paths to absolute paths using study folder as base

masster/study/study.py

@@ -109,6 +109,7 @@ 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.id import lib_load, identify, get_id, id_reset, lib_reset, _get_adducts
+from masster.study.importers import import_oracle
 
 from masster.logger import MassterLogger
 from masster.study.defaults.study_def import study_defaults
@@ -454,6 +455,9 @@ class Study:
     reset_id = id_reset
     lib_reset = lib_reset
     reset_lib = lib_reset
+    
+    # === Oracle Import Operations ===
+    import_oracle = import_oracle
 
     # === Parameter Management ===
     update_history = update_history

masster/study/study5_schema.json

@@ -114,6 +114,9 @@
       },
       "id_top_score": {
         "dtype": "pl.Float64"
+      },
+      "id_source": {
+        "dtype": "pl.String"
       }
     }
   },
@@ -318,6 +321,12 @@
       "name": {
         "dtype": "pl.String"
       },
+      "shortname": {
+        "dtype": "pl.String"
+      },
+      "class": {
+        "dtype": "pl.String"
+      },
       "smiles": {
         "dtype": "pl.String"
       },
@@ -336,6 +345,9 @@
       "adduct": {
         "dtype": "pl.String"
       },
+      "probability": {
+        "dtype": "pl.Float64"
+      },
       "m": {
         "dtype": "pl.Float64"
       },

masster/wizard/__init__.py

@@ -5,13 +5,13 @@ 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
+The create_analysis() 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
+The analyze() function combines create_analysis() with immediate execution of the
 generated script for fully automated processing.
 """
 
-from .wizard import Wizard, wizard_def, create_script, execute
+from .wizard import Wizard, wizard_def, create_analysis, create_notebook, analyze
 
-__all__ = ["Wizard", "wizard_def", "create_script", "execute"]
+__all__ = ["Wizard", "wizard_def", "create_analysis", "create_notebook", "analyze"]