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

masster/wizard/wizard.py

@@ -228,10 +228,9 @@ class Wizard:
     that process raw MS data through the complete pipeline: file discovery, feature
     detection, sample processing, study assembly, alignment, merging, and export.
     
-    This simplified version focuses on three core functions:
-    - create_analysis(): Generate standalone analysis scripts
-    - create_notebook(): Generate marimo interactive notebooks
-    - analyze(): Create and run analysis scripts with interactive notebook
+    This simplified version focuses on two core functions:
+    - create_scripts(): Generate standalone analysis scripts
+    - execute(): Create and run analysis scripts
     """
     
     def __init__(
@@ -240,7 +239,7 @@ class Wizard:
         folder: str = "",
         polarity: str = "positive",
         adducts: Optional[List[str]] = None,
-        num_cores: int = 0,
+        num_cores: int = 6,
         **kwargs
     ):
         """
@@ -350,101 +349,525 @@ class Wizard:
         """Get the adduct specifications."""
         return self.params.adducts
 
-    def create_analysis(self, filename: str = "run_masster.py") -> bool:
+    def create_scripts(self) -> Dict[str, Any]:
         """
-        Generate a standalone Python script for the analysis pipeline.
+        Generate analysis scripts based on source file analysis.
+        
+        This method:
+        1. Analyzes the source files to extract metadata
+        2. Creates 1_masster_workflow.py with sample processing logic
+        3. Creates 2_interactive_analysis.py marimo notebook for study exploration
+        4. Returns instructions for next steps
         
-        Parameters:
-            filename: Name for the generated script file
-            
         Returns:
-            True if script was generated successfully, False otherwise
+            Dictionary containing:
+            - status: "success" or "error"
+            - message: Status message
+            - instructions: List of next steps
+            - files_created: List of created file paths
+            - source_info: Metadata about source files
         """
         try:
-            script_path = self.folder_path / filename
-            script_content = self._generate_script_content()
+            # Step 1: Analyze source files to extract metadata
+            source_info = self._analyze_source_files()
             
-            with open(script_path, 'w', encoding='utf-8') as f:
-                f.write(script_content)
+            # Update wizard parameters based on detected metadata
+            if source_info.get('polarity') and source_info['polarity'] != 'positive':
+                self.params.polarity = source_info['polarity']
             
-            print(f"Analysis script created: {script_path}")
-            return True
+            files_created = []
             
-        except Exception as e:
-            print(f"Failed to create script: {e}")
-            return False
-
-    def create_notebook(self, filename: str = "interactive.py") -> bool:
-        """
-        Generate a marimo notebook for interactive analysis of the study.
-        
-        Parameters:
-            filename: Name for the generated notebook file
+            # Step 2: Create 1_masster_workflow.py
+            workflow_script_path = self.folder_path / "1_masster_workflow.py"
+            workflow_content = self._generate_workflow_script_content(source_info)
             
-        Returns:
-            True if notebook was generated successfully, False otherwise
-        """
-        try:
-            notebook_path = self.folder_path / filename
-            notebook_content = self._generate_notebook_content()
+            with open(workflow_script_path, 'w', encoding='utf-8') as f:
+                f.write(workflow_content)
+            files_created.append(str(workflow_script_path))
+            
+            # Step 3: Create 2_interactive_analysis.py marimo notebook
+            notebook_path = self.folder_path / "2_interactive_analysis.py"
+            notebook_content = self._generate_interactive_notebook_content(source_info)
             
             with open(notebook_path, 'w', encoding='utf-8') as f:
                 f.write(notebook_content)
+            files_created.append(str(notebook_path))
+            
+            # Step 4: Generate instructions
+            instructions = self._generate_instructions(source_info, files_created)
             
-            print(f"Interactive notebook created: {notebook_path}")
-            return True
+            return {
+                "status": "success",
+                "message": f"Successfully created {len(files_created)} script files",
+                "instructions": instructions,
+                "files_created": files_created,
+                "source_info": source_info
+            }
             
         except Exception as e:
-            print(f"Failed to create notebook: {e}")
-            return False
+            return {
+                "status": "error", 
+                "message": f"Failed to create scripts: {e}",
+                "instructions": [],
+                "files_created": [],
+                "source_info": {}
+            }
 
-    def analyze(self, filename: str = "run_masster.py") -> bool:
-        """
-        Create and execute a standalone analysis script.
+    def _analyze_source_files(self) -> Dict[str, Any]:
+        """Analyze source files to extract metadata."""
+        result = {
+            "number_of_files": 0,
+            "file_types": [],
+            "polarity": "positive", 
+            "length_minutes": 0.0,
+            "first_file": None
+        }
         
-        Parameters:
-            filename: Name for the generated script file
+        try:
+            # Find raw data files
+            extensions = [".wiff", ".raw", ".mzML"]
+            raw_files = []
             
-        Returns:
-            True if execution completed successfully, False otherwise
-        """
-        # First create the analysis script
-        if not self.create_analysis(filename):
-            return False
+            for ext in extensions:
+                pattern = f"**/*{ext}"
+                files = list(self.source_path.rglob(pattern))
+                if files:
+                    raw_files.extend(files)
+                    if ext not in result["file_types"]:
+                        result["file_types"].append(ext)
+            
+            result["number_of_files"] = len(raw_files)
             
-        # Create interactive notebook
-        if not self.create_notebook("interactive.py"):
-            print("Warning: Failed to create interactive notebook")
+            if raw_files:
+                result["first_file"] = str(raw_files[0])
+                # Simple heuristic: assume 30 minutes per file if we can't determine
+                result["length_minutes"] = 30.0
+                
+        except Exception as e:
+            print(f"Warning: Could not analyze source files: {e}")
             
-        # Then execute the analysis script
-        script_path = self.folder_path / filename
+        return result
+
+    def _generate_workflow_script_content(self, source_info: Dict[str, Any]) -> str:
+        """Generate the content for 1_masster_workflow.py script."""
         
+        script_lines = [
+            '#!/usr/bin/env python3',
+            '"""',
+            'Automated Mass Spectrometry Data Analysis Pipeline',
+            'Generated by masster wizard',
+            '"""',
+            '',
+            'import sys',
+            'import time',
+            'from pathlib import Path',
+            '',
+            '# Import masster modules',
+            'from masster.study import Study',
+            'from masster import __version__',
+            '',
+            '# Analysis parameters',
+            'PARAMS = {',
+            '    # === Core Configuration ===',
+            f'    "source": {str(self.source_path)!r},  # Directory containing raw data files',
+            f'    "folder": {str(self.folder_path)!r},  # Output directory for processed study',
+            f'    "polarity": {self.params.polarity!r},  # Ion polarity mode ("positive" or "negative")',
+            f'    "num_cores": {self.params.num_cores},  # Number of CPU cores for parallel processing',
+            '',
+            '    # === File Discovery ===',
+            f'    "file_extensions": {self.params.file_extensions!r},  # File extensions to search for',
+            f'    "search_subfolders": {self.params.search_subfolders},  # Whether to search subdirectories recursively',
+            f'    "skip_patterns": {self.params.skip_patterns!r},  # Filename patterns to skip',
+            '',
+            '    # === Processing Parameters ===',
+            f'    "adducts": {self.params.adducts!r},  # Adduct specifications for feature detection and annotation',
+            f'    "noise": {self.params.noise},  # Noise threshold for feature detection',
+            f'    "chrom_fwhm": {self.params.chrom_fwhm},  # Chromatographic peak full width at half maximum (seconds)',
+            f'    "chrom_peak_snr": {self.params.chrom_peak_snr},  # Minimum signal-to-noise ratio for chromatographic peaks',
+            '',
+            '    # === Alignment & Merging ===',
+            f'    "rt_tol": {self.params.rt_tolerance},  # Retention time tolerance for alignment (seconds)',
+            f'    "mz_tol": {self.params.mz_max_diff},  # Mass-to-charge ratio tolerance for alignment (Da)',
+            f'    "alignment_method": {self.params.alignment_algorithm!r},  # Algorithm for sample alignment',
+            f'    "min_samples_per_feature": {self.params.min_samples_for_merge},  # Minimum samples required per consensus feature',
+            f'    "merge_method": {self.params.merge_method!r},  # Method for merging consensus features',
+            '',
+            '    # === Sample Processing (used in add_samples_from_folder) ===',
+            f'    "batch_size": {self.params.batch_size},  # Number of files to process per batch',
+            f'    "memory_limit_gb": {self.params.memory_limit_gb},  # Memory limit for processing (GB)',
+            '',
+            '    # === Script Options ===',
+            f'    "resume_enabled": {self.params.resume_enabled},  # Enable automatic resume capability',
+            f'    "force_reprocess": {self.params.force_reprocess},  # Force reprocessing of existing files',
+            f'    "cleanup_temp_files": {self.params.cleanup_temp_files},  # Clean up temporary files after processing',
+            '}',
+            '',
+            '',
+            'def discover_raw_files(source_folder, file_extensions, search_subfolders=True):',
+            '    """Discover raw data files in the source folder."""',
+            '    source_path = Path(source_folder)',
+            '    raw_files = []',
+            '    ',
+            '    for ext in file_extensions:',
+            '        if search_subfolders:',
+            '            pattern = f"**/*{ext}"',
+            '            files = list(source_path.rglob(pattern))',
+            '        else:',
+            '            pattern = f"*{ext}"',
+            '            files = list(source_path.glob(pattern))',
+            '        raw_files.extend(files)',
+            '    ',
+            '    return raw_files',
+            '',
+            '',
+            'def process_single_file(args):',
+            '    """Process a single raw file to sample5 format - module level for multiprocessing."""',
+            '    raw_file, output_folder = args',
+            '    from masster.sample import Sample',
+            '    ',
+            '    try:',
+            '        # Create sample5 filename',
+            '        sample_name = raw_file.stem',
+            '        sample5_path = Path(output_folder) / f"{sample_name}.sample5"',
+            '        ',
+            '        # Skip if sample5 already exists',
+            '        if sample5_path.exists() and not PARAMS["force_reprocess"]:',
+            '            print(f"  Skipping {raw_file.name} (sample5 already exists)")',
+            '            return str(sample5_path)',
+            '        ',
+            '        print(f"  Converting {raw_file.name}...")',
+            '        ',
+            '        # Load and process raw file with full pipeline',
+            '        sample = Sample(log_label=sample_name)',
+            '        sample.load(filename=str(raw_file))',
+            '        sample.find_features(',
+            '            noise=PARAMS["noise"],',
+            '            chrom_fwhm=PARAMS["chrom_fwhm"],',
+            '            chrom_peak_snr=PARAMS["chrom_peak_snr"]',
+            '        )',
+            '        sample.find_ms2()',
+            '        sample.find_iso()',
+            '        # sample.export_mgf()',
+            '        # sample.plot_2d(filename=f"{sample5_path.replace(".sample5", ".html")}")',
+            '        sample.save(str(sample5_path))',
+            '        ',
+            '        # print(f"  Completed {raw_file.name} -> {sample5_path.name}")',
+            '        return str(sample5_path)',
+            '        ',
+            '    except Exception as e:',
+            '        print(f"  ERROR processing {raw_file.name}: {e}")',
+            '        return None',
+            '',
+            '',
+            'def convert_raw_to_sample5(raw_files, output_folder, polarity, num_cores):',
+            '    """Convert raw data files to sample5 format."""',
+            '    import concurrent.futures',
+            '    import os',
+            '    ',
+            '    # Create output directory',
+            '    os.makedirs(output_folder, exist_ok=True)',
+            '    ',
+            '    # Prepare arguments for multiprocessing',
+            '    file_args = [(raw_file, output_folder) for raw_file in raw_files]',
+            '    ',
+            '    # Process files in parallel',
+            '    sample5_files = []',
+            '    with concurrent.futures.ProcessPoolExecutor(max_workers=num_cores) as executor:',
+            '        futures = [executor.submit(process_single_file, args) for args in file_args]',
+            '        ',
+            '        for future in concurrent.futures.as_completed(futures):',
+            '            result = future.result()',
+            '            if result:',
+            '                sample5_files.append(result)',
+            '    ',
+            '    return sample5_files',
+            '',
+            '',
+            'def main():',
+            '    """Main analysis pipeline."""',
+            '    try:',
+            '        print("=" * 70)',
+            f'        print("masster {version} - Automated MS Data Analysis")',
+            '        print("=" * 70)',
+            '        print(f"Source: {PARAMS[\'source\']}")',
+            '        print(f"Output: {PARAMS[\'folder\']}")',
+            '        print(f"Polarity: {PARAMS[\'polarity\']}")',
+            '        print(f"CPU Cores: {PARAMS[\'num_cores\']}")',
+            '        print("=" * 70)',
+            '        ',
+            '        start_time = time.time()',
+            '        ',
+            '        # Step 1: Discover raw data files',
+            '        print("\\nStep 1/7: Discovering raw data files...")',
+            '        raw_files = discover_raw_files(',
+            '            PARAMS[\'source\'],',
+            '            PARAMS[\'file_extensions\'],',
+            '            PARAMS[\'search_subfolders\']',
+            '        )',
+            '        ',
+            '        if not raw_files:',
+            '            print("No raw data files found!")',
+            '            return False',
+            '        ',
+            '        print(f"Found {len(raw_files)} raw data files")',
+            '        for f in raw_files[:5]:  # Show first 5 files',
+            '            print(f"  {f.name}")',
+            '        if len(raw_files) > 5:',
+            '            print(f"  ... and {len(raw_files) - 5} more")',
+            '        ',
+            '        # Step 2: Process raw files',
+            '        print("\\nStep 2/7: Processing raw files...")',
+            '        sample5_files = convert_raw_to_sample5(',
+            '            raw_files,',
+            '            PARAMS[\'folder\'],',
+            '            PARAMS[\'polarity\'],',
+            '            PARAMS[\'num_cores\']',
+            '        )',
+            '        ',
+            '        if not sample5_files:',
+            '            print("No sample5 files were created!")',
+            '            return False',
+            '        ',
+            '        print(f"Successfully processed {len(sample5_files)} files to sample5")',
+            '        ',
+            '        # Step 3: Create and configure study',
+            '        print("\\nStep 3/7: Initializing study...")',
+            '        study = Study(folder=PARAMS[\'folder\'])',
+            '        study.polarity = PARAMS[\'polarity\']',
+            '        study.adducts = PARAMS[\'adducts\']',
+            '        ',
+            '        # Step 4: Add sample5 files to study',
+            '        print("\\nStep 4/7: Adding samples to study...")',
+            '        study.add(str(Path(PARAMS[\'folder\']) / "*.sample5"))',
+            '        study.features_filter(study.features_select(chrom_coherence=0.1, chrom_prominence_scaled=1))',
+            '        ',
+            '        # Step 5: Core processing',
+            '        print("\\nStep 5/7: Processing...")',
+            '        study.align(',
+            '            algorithm=PARAMS[\'alignment_method\'],',
+            '            rt_tol=PARAMS[\'rt_tol\']',
+            '        )',
+            '        ',
+            '        study.merge(',
+            '            method="qt",',
+            '            min_samples=PARAMS[\'min_samples_per_feature\'],',
+            '            threads=PARAMS[\'num_cores\'],',
+            '            rt_tol=PARAMS[\'rt_tol\']',
+            '        )',
+            '        study.find_iso()',
+            '        study.fill()',
+            '        study.integrate()',
+            '        ',
+            '        # Step 6/7: Saving results',
+            '        print("\\nStep 6/7: Saving results...")',
+            '        study.save()',
+            '        study.export_xlsx()',
+            '        study.export_mgf()',
+            '        study.export_mztab()',
+            '        ',
+            '        # Step 7: Plots',
+            '        print("\\nStep 7/7: Exporting plots...")',
+            '        study.plot_consensus_2d(filename="consensus.html")',
+            '        study.plot_consensus_2d(filename="consensus.png")',
+            '        study.plot_alignment(filename="alignment.html")',
+            '        study.plot_alignment(filename="alignment.png")',
+            '        study.plot_samples_pca(filename="pca.html")',
+            '        study.plot_samples_pca(filename="pca.png")',
+            '        study.plot_bpc(filename="bpc.html")',
+            '        study.plot_bpc(filename="bpc.png")',
+            '        study.plot_rt_correction(filename="rt_correction.html")',
+            '        study.plot_rt_correction(filename="rt_correction.png")',
+            '        ',
+            '        # Print summary',
+            '        study.info()',
+            '        total_time = time.time() - start_time',
+            '        print("\\n" + "=" * 70)',
+            '        print("ANALYSIS COMPLETE")',
+            '        print("=" * 70)',
+            '        print(f"Total processing time: {total_time:.1f} seconds ({total_time/60:.1f} minutes)")',
+            '        print(f"Raw files processed: {len(raw_files)}")',
+            '        print(f"Sample5 files created: {len(sample5_files)}")',
+            '        if hasattr(study, "consensus_df"):',
+            '            print(f"Consensus features generated: {len(study.consensus_df)}")',
+            '        print("=" * 70)',
+            '        ',
+            '        return True',
+            '        ',
+            '    except KeyboardInterrupt:',
+            '        print("\\nAnalysis interrupted by user")',
+            '        return False',
+            '    except Exception as e:',
+            '        print(f"Analysis failed with error: {e}")',
+            '        import traceback',
+            '        traceback.print_exc()',
+            '        return False',
+            '',
+            '',
+            'if __name__ == "__main__":',
+            '    success = main()',
+            '    sys.exit(0 if success else 1)',
+        ]
+        
+        return '\n'.join(script_lines)
+
+    def _generate_interactive_notebook_content(self, source_info: Dict[str, Any]) -> str:
+        """Generate the content for 2_interactive_analysis.py marimo notebook."""
+        
+        notebook_lines = [
+            'import marimo',
+            '',
+            '__generated_with = "0.9.14"',
+            'app = marimo.App(width="medium")',
+            '',
+            '@app.cell',
+            'def __():',
+            '    import marimo as mo',
+            '    return (mo,)',
+            '',
+            '@app.cell',
+            'def __(mo):',
+            '    mo.md(r"""',
+            '    # MASSter Interactive Analysis',
+            '    ',
+            f'    **Source:** {source_info.get("number_of_files", 0)} files detected',
+            f'    **Polarity:** {source_info.get("polarity", "unknown")}',
+            '    ',
+            '    This notebook provides interactive exploration of your processed study.',
+            '    Make sure you have run `python 1_masster_workflow.py` first.',
+            '    """)',
+            '    return ()',
+            '',
+            '@app.cell',
+            'def __():',
+            '    import masster',
+            '    return (masster,)',
+            '',
+            '@app.cell',
+            'def __(masster):',
+            '    study = masster.Study(folder=".")',
+            '    return (study,)',
+            '',
+            '@app.cell',
+            'def __(study):',
+            '    study.info()',
+            '    return ()',
+            '',
+            'if __name__ == "__main__":',
+            '    app.run()',
+        ]
+        
+        return '\n'.join(notebook_lines)
+
+    def _generate_instructions(self, source_info: Dict[str, Any], files_created: List[str]) -> List[str]:
+        """Generate usage instructions for the created scripts."""
+        instructions = [f"Source analysis: {source_info.get('number_of_files', 0)} files found",
+            f"Polarity detected: {source_info.get('polarity', 'unknown')}",
+            "Files created:"]
+        for file_path in files_created:
+            instructions.append(f"  ✅ {str(Path(file_path).resolve())}")
+        
+        # Find the workflow script name from created files
+        workflow_script_name = "1_masster_workflow.py"
+        for file_path in files_created:
+            if Path(file_path).name == "1_masster_workflow.py":
+                workflow_script_name = Path(file_path).name
+                break
+            
+        instructions.extend([
+            "",
+            "Next steps:",
+            f"1. REVIEW PARAMETERS in {workflow_script_name}:",
+            f"   In particular, verify the NOISE, CHROM_FWHM, and MIN_SAMPLES_FOR_MERGE",
+            "",
+            "2. EXECUTE SAMPLE PROCESSING:",
+            f"   uv run python {workflow_script_name}",
+            "",
+            "3. INTERACTIVE ANALYSIS:",
+            f"   uv run marimo edit {Path('2_interactive_analysis.py').name}",
+            ""]            
+        )
+        
+        return instructions
+
+    def execute(self) -> Dict[str, Any]:
+        """
+        Execute the sample processing workflow.
+        
+        This method:
+        1. Creates scripts if they don't exist (calls create_scripts())
+        2. Runs the 1_masster_workflow.py script to process raw files
+        
+        Returns:
+            Dictionary containing:
+            - status: "success", "error", or "scripts_created"
+            - message: Status message
+            - instructions: List of next steps
+            - files_created: List of created file paths (if scripts were created)
+        """
         try:
-            print("Executing...")
+            workflow_script_path = self.folder_path / "1_masster_workflow.py"
+            
+            # Check if workflow script exists, create it if not
+            if not workflow_script_path.exists():
+                print("📝 Workflow script not found, creating scripts first...")
+                result = self.create_scripts()
+                if result["status"] != "success":
+                    return result
+                
+                print("✅ Scripts created successfully")
+                print(f"📁 Output folder: {self.folder_path}")
+                
+            # Execute the workflow script
+            print(f"🚀 Executing sample processing workflow...")
+            print(f"📄 Running: {workflow_script_path.name}")
+            print("=" * 60)
             
             import subprocess
             result = subprocess.run([
-                sys.executable, str(script_path)
-            ], cwd=str(self.folder_path), encoding='utf-8', errors='replace')
+                sys.executable, str(workflow_script_path)
+            ], cwd=str(self.folder_path))
             
             success = result.returncode == 0
             
             if success:
-                print("=" * 70)
-                print("Script execution completed successfully")
-                print("=" * 70)
-                print("For interactive analysis, run:")
-                print(f"  uv run marimo edit {self.folder_path / 'interactive.py'}")
-                print("=" * 70)
+                print("=" * 60)
+                print("✅ Sample processing completed successfully!")
+                print("📋 Next step: Run interactive analysis")
+                print("   uv run marimo edit 2_interactive_analysis.py")
+                print("=" * 60)
+                
+                return {
+                    "status": "success",
+                    "message": "Sample processing completed successfully",
+                    "instructions": [
+                        "✅ Sample processing completed",
+                        "Next: uv run marimo edit 2_interactive_analysis.py"
+                    ],
+                    "files_created": []
+                }
             else:
-                print("=" * 70)
-                print(f"Script execution failed with return code: {result.returncode}")
+                return {
+                    "status": "error",
+                    "message": f"Workflow execution failed with return code {result.returncode}",
+                    "instructions": [
+                        "❌ Check the error messages above",
+                        "Review parameters in 1_masster_workflow.py",
+                        f"Try running manually: python {workflow_script_path.name}"
+                    ],
+                    "files_created": []
+                }
                 
-            return success
-            
         except Exception as e:
-            print(f"Error during script execution: {e}")
-            return False
+            return {
+                "status": "error",
+                "message": f"Failed to execute workflow: {e}",
+                "instructions": [
+                    "❌ Execution failed",
+                    "Check that source files exist and are accessible",
+                    "Verify folder permissions"
+                ],
+                "files_created": []
+            }
 
     def _generate_script_content(self) -> str:
         """Generate the complete analysis script content."""
@@ -751,154 +1174,8 @@ class Wizard:
         
         return '\n'.join(script_lines)
 
-    def _generate_notebook_content(self) -> str:
-        """Generate the content for a marimo interactive notebook."""
-        
-        notebook_lines = [
-            'import marimo',
-            '',
-            '__generated_with = "0.9.14"',
-            'app = marimo.App(width="medium")',
-            '',
-            '',
-            '@app.cell',
-            'def __():',
-            '    import marimo as mo',
-            '    return (mo,)',
-            '',
-            '',
-            '@app.cell',
-            'def __(mo):',
-            '    mo.md(r"""',
-            '    # MASSter Interactive Analysis',
-            '    ',
-            '    This notebook provides interactive exploration of your mass spectrometry study results.',
-            '    The study has been processed and is ready for analysis.',
-            '    """)',
-            '',
-            '',
-            '@app.cell',
-            'def __():',
-            '    # Import masster',
-            '    import masster',
-            '    return (masster,)',
-            '',
-            '',
-            '@app.cell',
-            'def __(masster):',
-            '    # Load the processed study',
-            f'    study = masster.Study(folder=".")',
-            '    study.load()',
-            '    return (study,)',
-            '',
-            '',
-            '@app.cell',
-            'def __(mo, study):',
-            '    # Display study information',
-            '    mo.md(f"""',
-            '    ## Study Overview',
-            '    ',
-            '    **Samples:** {len(study.samples) if hasattr(study, "samples") else "Not loaded"}',
-            '    ',
-            '    **Features:** {len(study.consensus_df) if hasattr(study, "consensus_df") else "Not available"}',
-            '    ',
-            '    **Polarity:** {study.polarity if hasattr(study, "polarity") else "Unknown"}',
-            '    """)',
-            '',
-            '',
-            '@app.cell',
-            'def __(study):',
-            '    # Print detailed study info',
-            '    study.info()',
-            '',
-            '',
-            '@app.cell',
-            'def __(mo):',
-            '    mo.md(r"""',
-            '    ## Quick Visualizations',
-            '    ',
-            '    Use the cells below to create interactive plots of your data.',
-            '    """)',
-            '',
-            '',
-            '@app.cell',
-            'def __(study):',
-            '    # Generate consensus 2D plot',
-            '    if hasattr(study, "consensus_df") and len(study.consensus_df) > 0:',
-            '        study.plot_consensus_2d(filename="consensus_interactive.html")',
-            '        print("Consensus 2D plot saved as: consensus_interactive.html")',
-            '    else:',
-            '        print("No consensus features available for plotting")',
-            '',
-            '',
-            '@app.cell',
-            'def __(study):',
-            '    # Generate PCA plot',
-            '    if hasattr(study, "samples") and len(study.samples) > 1:',
-            '        study.plot_samples_pca(filename="pca_interactive.html")',
-            '        print("PCA plot saved as: pca_interactive.html")',
-            '    else:',
-            '        print("Not enough samples for PCA analysis")',
-            '',
-            '',
-            '@app.cell',
-            'def __(mo):',
-            '    mo.md(r"""',
-            '    ## Data Export',
-            '    ',
-            '    Export your processed data in various formats.',
-            '    """)',
-            '',
-            '',
-            '@app.cell',
-            'def __(study):',
-            '    # Export options',
-            '    if hasattr(study, "consensus_df"):',
-            '        # Export to Excel',
-            '        study.export_xlsx(filename="study_results.xlsx")',
-            '        print("✓ Results exported to: study_results.xlsx")',
-            '        ',
-            '        # Export to MGF',
-            '        study.export_mgf(filename="study_spectra.mgf")',
-            '        print("✓ Spectra exported to: study_spectra.mgf")',
-            '    else:',
-            '        print("No data available for export")',
-            '',
-            '',
-            '@app.cell',
-            'def __(mo):',
-            '    mo.md(r"""',
-            '    ## Custom Analysis',
-            '    ',
-            '    Add your own analysis code in the cells below.',
-            '    """)',
-            '',
-            '',
-            '@app.cell',
-            'def __(study):',
-            '    # Access consensus features dataframe',
-            '    if hasattr(study, "consensus_df"):',
-            '        df = study.consensus_df',
-            '        print(f"Consensus features shape: {df.shape}")',
-            '        print("\\nFirst 5 features:")',
-            '        print(df.head())',
-            '    return (df,) if "df" in locals() else ()',
-            '',
-            '',
-            '@app.cell',
-            'def __():',
-            '    # Your custom analysis here',
-            '    pass',
-            '',
-            '',
-            'if __name__ == "__main__":',
-            '    app.run()',
-        ]
-        
-        return '\n'.join(notebook_lines)
-
 
-def create_analysis(
+def create_script(
     source: str, 
     folder: str, 
     filename: str = 'run_masster.py', 
@@ -929,8 +1206,8 @@ def create_analysis(
         True if script was generated successfully, False otherwise
         
     Example:
-        >>> from masster.wizard import create_analysis
-        >>> create_analysis(
+        >>> from masster.wizard import create_script
+        >>> create_script(
         ...     source=r'D:\\Data\\raw_files',
         ...     folder=r'D:\\Data\\output', 
         ...     filename='run_masster.py',
@@ -976,8 +1253,9 @@ def create_analysis(
         # Create a temporary Wizard instance to generate the script
         temp_wizard = Wizard(params=wizard_params)
         
-        # Generate the script using the instance method
-        success = temp_wizard.create_analysis(filename)
+        # Generate the scripts using the instance method
+        result = temp_wizard.create_scripts()
+        success = result.get("status") == "success"
         
         return success
         
@@ -988,7 +1266,7 @@ def create_analysis(
         return False
 
 
-def analyze(
+def execute(
     source: str, 
     folder: str, 
     filename: str = 'run_masster.py', 
@@ -1001,7 +1279,7 @@ def analyze(
     """
     Create and execute a standalone analysis script for automated MS data processing.
     
-    This function generates a Python script with the same parameters as create_analysis(),
+    This function generates a Python script with the same parameters as create_script(),
     but immediately executes it after creation. Combines script generation and execution
     in a single step.
     
@@ -1019,8 +1297,8 @@ def analyze(
         True if script was created and executed successfully, False otherwise
         
     Example:
-        >>> from masster.wizard import analyze
-        >>> analyze(
+        >>> from masster.wizard import execute
+        >>> execute(
         ...     source=r'D:\\Data\\raw_files',
         ...     folder=r'D:\\Data\\output', 
         ...     polarity='positive'
@@ -1028,8 +1306,8 @@ def analyze(
     """
     
     try:
-        # First, create the script using create_analysis()
-        script_created = create_analysis(
+        # First, create the script using create_script()
+        script_created = create_script(
             source=source,
             folder=folder,
             filename=filename,
@@ -1089,244 +1367,73 @@ def analyze(
         return False
 
 
-def create_notebook(
-    source: str, 
-    folder: str, 
-    filename: str = 'interactive.py', 
+def create_scripts(
+    source: str = "", 
+    folder: str = "", 
     polarity: str = "positive",
     adducts: Optional[List[str]] = None,
-    params: Optional[wizard_def] = None,
     num_cores: int = 0,
     **kwargs
-) -> bool:
+) -> Dict[str, Any]:
     """
-    Create a marimo interactive notebook for analysis without initializing a Wizard instance.
+    Create analysis scripts without explicitly instantiating a Wizard.
     
-    This function generates a marimo notebook file that provides interactive exploration
-    of mass spectrometry study results with the specified configuration.
+    This is a convenience function that creates a Wizard instance internally
+    and calls its create_scripts() method.
     
     Parameters:
         source: Directory containing raw data files
-        folder: Output directory for processed study  
-        filename: Filename for the generated notebook (should end with .py)
+        folder: Output directory for processed study
         polarity: Ion polarity mode ("positive" or "negative")
         adducts: List of adduct specifications (auto-set if None)
-        params: Custom wizard_def parameters (optional)
         num_cores: Number of CPU cores (0 = auto-detect)
-        **kwargs: Additional parameters to override defaults
+        **kwargs: Additional parameters
         
     Returns:
-        True if notebook was generated successfully, False otherwise
+        Dictionary containing:
+        - status: "success" or "error"
+        - message: Status message
+        - instructions: List of next steps
+        - files_created: List of created file paths
+        - source_info: Metadata about source files
         
     Example:
-        >>> from masster.wizard import create_notebook
-        >>> create_notebook(
+        >>> import masster.wizard
+        >>> result = masster.wizard.create_scripts(
         ...     source=r'D:\\Data\\raw_files',
         ...     folder=r'D:\\Data\\output', 
-        ...     filename='interactive.py',
-        ...     polarity='positive'
+        ...     polarity='negative'
         ... )
+        >>> print("Status:", result["status"])
     """
     
     try:
-        # Create parameters
-        if params is not None:
-            # Use provided params as base
-            wizard_params = params
-            # Update with provided values
-            wizard_params.source = source
-            wizard_params.folder = folder
-            if polarity != "positive":  # Only override if explicitly different
-                wizard_params.polarity = polarity
-            if num_cores > 0:
-                wizard_params.num_cores = num_cores
-            if adducts is not None:
-                wizard_params.adducts = adducts
-        else:
-            # Create new params with provided values
-            wizard_params = wizard_def(
-                source=source,
-                folder=folder,
-                polarity=polarity,
-                num_cores=max(1, int(multiprocessing.cpu_count() * 0.75)) if num_cores <= 0 else num_cores
-            )
-            
-            if adducts is not None:
-                wizard_params.adducts = adducts
-            
-            # Apply any additional kwargs
-            for key, value in kwargs.items():
-                if hasattr(wizard_params, key):
-                    setattr(wizard_params, key, value)
-        
-        # Ensure study folder exists
-        study_path = Path(folder)
-        study_path.mkdir(parents=True, exist_ok=True)
-        
-        # Generate notebook content
-        notebook_content = _generate_notebook_content(wizard_params)
+        # Auto-detect optimal number of cores if not specified
+        if num_cores <= 0:
+            num_cores = max(1, int(multiprocessing.cpu_count() * 0.75))
         
-        # Write notebook file
-        notebook_path = study_path / filename
-        with open(notebook_path, 'w', encoding='utf-8') as f:
-            f.write(notebook_content)
+        # Create Wizard instance
+        wizard = Wizard(
+            source=source,
+            folder=folder,
+            polarity=polarity,
+            adducts=adducts,
+            num_cores=num_cores,
+            **kwargs
+        )
         
-        print(f"Interactive notebook created: {notebook_path}")
-        return True
+        # Call the instance method
+        return wizard.create_scripts()
         
     except Exception as e:
-        print(f"Failed to create notebook: {e}")
-        import traceback
-        traceback.print_exc()
-        return False
-
-
-def _generate_notebook_content(params: wizard_def) -> str:
-    """Generate the content for a marimo interactive notebook."""
-    
-    notebook_lines = [
-        'import marimo',
-        '',
-        '__generated_with = "0.9.14"',
-        'app = marimo.App(width="medium")',
-        '',
-        '',
-        '@app.cell',
-        'def __():',
-        '    import marimo as mo',
-        '    return (mo,)',
-        '',
-        '',
-        '@app.cell',
-        'def __(mo):',
-        '    mo.md(r"""',
-        '    # MASSter Interactive Analysis',
-        '    ',
-        '    This notebook provides interactive exploration of your mass spectrometry study results.',
-        '    The study has been processed and is ready for analysis.',
-        '    """)',
-        '',
-        '',
-        '@app.cell',
-        'def __():',
-        '    # Import masster',
-        '    import masster',
-        '    return (masster,)',
-        '',
-        '',
-        '@app.cell',
-        'def __(masster):',
-        '    # Load the processed study',
-        f'    study = masster.Study(folder=".")',
-        '    study.load()',
-        '    return (study,)',
-        '',
-        '',
-        '@app.cell',
-        'def __(mo, study):',
-        '    # Display study information',
-        '    mo.md(f"""',
-        '    ## Study Overview',
-        '    ',
-        '    **Samples:** {len(study.samples) if hasattr(study, "samples") else "Not loaded"}',
-        '    ',
-        '    **Features:** {len(study.consensus_df) if hasattr(study, "consensus_df") else "Not available"}',
-        '    ',
-        '    **Polarity:** {study.polarity if hasattr(study, "polarity") else "Unknown"}',
-        '    """)',
-        '',
-        '',
-        '@app.cell',
-        'def __(study):',
-        '    # Print detailed study info',
-        '    study.info()',
-        '',
-        '',
-        '@app.cell',
-        'def __(mo):',
-        '    mo.md(r"""',
-        '    ## Quick Visualizations',
-        '    ',
-        '    Use the cells below to create interactive plots of your data.',
-        '    """)',
-        '',
-        '',
-        '@app.cell',
-        'def __(study):',
-        '    # Generate consensus 2D plot',
-        '    if hasattr(study, "consensus_df") and len(study.consensus_df) > 0:',
-        '        study.plot_consensus_2d(filename="consensus_interactive.html")',
-        '        print("Consensus 2D plot saved as: consensus_interactive.html")',
-        '    else:',
-        '        print("No consensus features available for plotting")',
-        '',
-        '',
-        '@app.cell',
-        'def __(study):',
-        '    # Generate PCA plot',
-        '    if hasattr(study, "samples") and len(study.samples) > 1:',
-        '        study.plot_samples_pca(filename="pca_interactive.html")',
-        '        print("PCA plot saved as: pca_interactive.html")',
-        '    else:',
-        '        print("Not enough samples for PCA analysis")',
-        '',
-        '',
-        '@app.cell',
-        'def __(mo):',
-        '    mo.md(r"""',
-        '    ## Data Export',
-        '    ',
-        '    Export your processed data in various formats.',
-        '    """)',
-        '',
-        '',
-        '@app.cell',
-        'def __(study):',
-        '    # Export options',
-        '    if hasattr(study, "consensus_df"):',
-        '        # Export to Excel',
-        '        study.export_xlsx(filename="study_results.xlsx")',
-        '        print("✓ Results exported to: study_results.xlsx")',
-        '        ',
-        '        # Export to MGF',
-        '        study.export_mgf(filename="study_spectra.mgf")',
-        '        print("✓ Spectra exported to: study_spectra.mgf")',
-        '    else:',
-        '        print("No data available for export")',
-        '',
-        '',
-        '@app.cell',
-        'def __(mo):',
-        '    mo.md(r"""',
-        '    ## Custom Analysis',
-        '    ',
-        '    Add your own analysis code in the cells below.',
-        '    """)',
-        '',
-        '',
-        '@app.cell',
-        'def __(study):',
-        '    # Access consensus features dataframe',
-        '    if hasattr(study, "consensus_df"):',
-        '        df = study.consensus_df',
-        '        print(f"Consensus features shape: {df.shape}")',
-        '        print("\\nFirst 5 features:")',
-        '        print(df.head())',
-        '    return (df,) if "df" in locals() else ()',
-        '',
-        '',
-        '@app.cell',
-        'def __():',
-        '    # Your custom analysis here',
-        '    pass',
-        '',
-        '',
-        'if __name__ == "__main__":',
-        '    app.run()',
-    ]
-    
-    return '\n'.join(notebook_lines)
+        return {
+            "status": "error",
+            "message": f"Failed to create scripts: {e}",
+            "instructions": [],
+            "files_created": [],
+            "source_info": {}
+        }
 
 
 # Export the main classes and functions
-__all__ = ["Wizard", "wizard_def", "create_analysis", "create_notebook", "analyze"]
+__all__ = ["Wizard", "wizard_def", "create_scripts"]