python_implementation_fixed.py

#!/usr/bin/env python3
"""
Metabolomics Research - FIXED Python SDK Implementation
This version fixes the critical bugs found during testing
"""

from tooluniverse import ToolUniverse
from datetime import datetime
import json

def metabolomics_analysis_pipeline(
    metabolite_list=None,
    study_id=None,
    search_query=None,
    organism="Homo sapiens",
    output_file=None
):
    """
    Metabolomics research analysis pipeline (FIXED VERSION).

    Args:
        metabolite_list: List of metabolite names (e.g., ["glucose", "lactate"])
        study_id: MetaboLights or Metabolomics Workbench study ID
        search_query: Keyword to search metabolomics studies
        organism: Organism name (default: "Homo sapiens")
        output_file: Output markdown file path (default: auto-generated)

    Returns:
        Path to generated report file
    """

    tu = ToolUniverse()
    tu.load_tools()

    # Generate output filename
    if output_file is None:
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        if metabolite_list:
            output_file = f"metabolomics_metabolites_{timestamp}.md"
        elif study_id:
            output_file = f"metabolomics_{study_id}_{timestamp}.md"
        elif search_query:
            output_file = f"metabolomics_search_{search_query}_{timestamp}.md"
        else:
            output_file = f"metabolomics_analysis_{timestamp}.md"

    # Initialize report
    report = []
    report.append("# Metabolomics Research Analysis Report\n")
    report.append(f"**Generated**: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")

    if metabolite_list:
        report.append(f"**Metabolites**: {', '.join(metabolite_list[:10])}{'...' if len(metabolite_list) > 10 else ''}\n")
    if study_id:
        report.append(f"**Study ID**: {study_id}\n")
    if search_query:
        report.append(f"**Search Query**: {search_query}\n")
    report.append(f"**Organism**: {organism}\n")

    report.append("\n---\n")

    # Phase 1: Metabolite Identification
    if metabolite_list and len(metabolite_list) > 0:
        report.append("\n## 1. Metabolite Identification & Annotation\n")

        for metabolite in metabolite_list[:10]:  # Limit to 10 for report length
            report.append(f"\n### Metabolite: {metabolite}\n")

            # HMDB Search - FIX: Handle nested results structure
            try:
                result = tu.tools.HMDB_search(
                    operation="search",
                    query=metabolite
                )

                if isinstance(result, dict) and result.get('status') == 'success':
                    data = result.get('data', {})  # FIX: data is dict, not list
                    results = data.get('results', [])  # FIX: results are nested

                    if results and len(results) > 0:
                        hmdb_entry = results[0]  # FIX: Access results array

                        # FIX: Use correct field names (cid, not accession)
                        report.append(f"**PubChem CID**: {hmdb_entry.get('cid', 'N/A')}\n")
                        report.append(f"**Name**: {hmdb_entry.get('name', 'N/A')}\n")
                        report.append(f"**Formula**: {hmdb_entry.get('formula', 'N/A')}\n")
                        report.append(f"**Molecular Weight**: {hmdb_entry.get('mw', 'N/A')}\n")

                        # Add search URLs
                        report.append(f"**HMDB Search**: {data.get('hmdb_search_url', 'N/A')}\n")

                        # Note about data source
                        metadata = result.get('metadata', {})
                        if metadata.get('source') == 'PubChem':
                            report.append(f"*Note: Data retrieved from {metadata.get('source')} proxy*\n")
                    else:
                        report.append(f"*No results found for {metabolite}*\n")
                else:
                    error_msg = result.get('error', 'Unknown error')
                    report.append(f"*HMDB search failed: {error_msg}*\n")

            except Exception as e:
                report.append(f"*Error querying HMDB: {type(e).__name__}: {str(e)[:200]}*\n")

            # PubChem search - FIX: Use correct parameter name
            try:
                result = tu.tools.PubChem_get_CID_by_compound_name(name=metabolite)  # FIX: name not compound_name
                if isinstance(result, dict) and result.get('status') == 'success':
                    data = result.get('data', {})
                    cid = data.get('cid', 'N/A')
                    if cid != 'N/A':
                        report.append(f"**PubChem CID (direct)**: {cid}\n")

                        # Get properties
                        props = tu.tools.PubChem_get_compound_properties_by_CID(cid=cid)
                        if isinstance(props, dict) and props.get('status') == 'success':
                            prop_data = props.get('data', {})
                            report.append(f"**SMILES**: {prop_data.get('CanonicalSMILES', 'N/A')}\n")
                            report.append(f"**InChI**: {prop_data.get('InChI', 'N/A')[:100]}...\n")
            except Exception as e:
                # PubChem fallback - only report if HMDB also failed
                pass

    # Phase 2: Study Retrieval
    if study_id:
        report.append(f"\n## 2. Study Details: {study_id}\n")

        # Try MetaboLights first
        if study_id.startswith('MTBLS'):
            try:
                result = tu.tools.metabolights_get_study(study_id=study_id)
                if isinstance(result, dict) and result.get('status') == 'success':
                    data = result.get('data', {})
                    study = data.get('mtblsStudy', {})  # FIX: Extract nested study object

                    report.append(f"**Database**: MetaboLights\n")

                    # FIX: Use actual field names from API
                    report.append(f"**Study Status**: {study.get('studyStatus', 'N/A')}\n")
                    report.append(f"**Study Category**: {study.get('studyCategory', 'N/A')}\n")
                    report.append(f"**Curation Request**: {study.get('curationRequest', 'N/A')}\n")
                    report.append(f"**Modified Time**: {study.get('modifiedTime', 'N/A')}\n")
                    report.append(f"**First Public Date**: {study.get('firstPublicDate', 'N/A')}\n")
                    report.append(f"**HTTP URL**: {study.get('studyHttpUrl', 'N/A')}\n")
                    report.append(f"**FTP URL**: {study.get('studyFtpUrl', 'N/A')}\n")
                    report.append(f"**Dataset License**: {study.get('datasetLicense', 'N/A')}\n")

                else:
                    error_msg = result.get('error', 'Unknown error')
                    report.append(f"*Study details unavailable: {error_msg}*\n")
            except Exception as e:
                report.append(f"*Error retrieving MetaboLights study: {type(e).__name__}: {str(e)[:200]}*\n")

        # Try Metabolomics Workbench
        elif study_id.startswith('ST'):
            try:
                result = tu.tools.MetabolomicsWorkbench_get_study(
                    study_id=study_id,
                    output_item="summary"
                )
                if isinstance(result, dict) and result.get('status') == 'success':
                    data = result.get('data', {})
                    report.append(f"**Database**: Metabolomics Workbench\n")

                    # Parse the text response
                    if isinstance(data, str):
                        lines = data.strip().split('\n')
                        for line in lines:
                            if '\t' in line:
                                key, value = line.split('\t', 1)
                                report.append(f"**{key}**: {value}\n")
                    else:
                        report.append(f"**Data**: {json.dumps(data, indent=2)}\n")
                else:
                    error_msg = result.get('error', 'Unknown error')
                    report.append(f"*Study details unavailable: {error_msg}*\n")
            except Exception as e:
                report.append(f"*Error retrieving Workbench study: {type(e).__name__}: {str(e)[:200]}*\n")

    # Phase 3: Study Search
    if search_query:
        report.append(f"\n## 3. Study Search: '{search_query}'\n")

        # MetaboLights search
        try:
            result = tu.tools.metabolights_search_studies(query=search_query)
            if isinstance(result, dict) and result.get('status') == 'success':
                data = result.get('data', [])
                count = result.get('count', len(data))

                if data:
                    report.append(f"\n### MetaboLights Studies ({count} total results)\n")
                    report.append("\n| Study ID | Preview |\n")
                    report.append("|----------|----------|\n")

                    for study in data[:15]:  # Limit to 15
                        if isinstance(study, str):
                            report.append(f"| {study} | - |\n")
                        elif isinstance(study, dict):
                            sid = study.get('accession', study.get('id', 'N/A'))
                            title = study.get('title', '')[:50]
                            report.append(f"| {sid} | {title} |\n")
                else:
                    report.append("\n*No MetaboLights studies found.*\n")
            else:
                error_msg = result.get('error', 'Unknown error')
                report.append(f"\n*Error searching MetaboLights: {error_msg}*\n")
        except Exception as e:
            report.append(f"\n*Error searching MetaboLights: {type(e).__name__}: {str(e)[:200]}*\n")

    # Phase 4: Database Statistics (always included)
    report.append("\n## 4. Metabolomics Database Overview\n")

    try:
        result = tu.tools.metabolights_list_studies(size=10)
        if isinstance(result, dict) and result.get('status') == 'success':
            data = result.get('data', [])
            count = result.get('count', len(data))
            report.append(f"\n**MetaboLights**: {count} total studies available\n")
            report.append(f"**Sample studies**: {', '.join([s if isinstance(s, str) else s.get('accession', '') for s in data[:5]])}\n")
    except:
        report.append("\n**MetaboLights**: Database available\n")

    report.append("\n**Databases integrated**:\n")
    report.append("- HMDB (Human Metabolome Database): 220,000+ metabolites\n")
    report.append("- MetaboLights: Public metabolomics repository\n")
    report.append("- Metabolomics Workbench: NIH metabolomics data\n")
    report.append("- PubChem: Chemical properties and bioactivity\n")

    # Write report to file
    report_content = ''.join(report)
    with open(output_file, 'w') as f:
        f.write(report_content)

    print(f"\n✅ Report generated: {output_file}")
    return output_file


if __name__ == "__main__":
    # Example usage with fixes applied
    print("Metabolomics Research Analysis - FIXED Implementation")
    print("="*80)

    # Example: Comprehensive diabetes analysis
    print("\nGenerating diabetes metabolomics report with fixed implementation...")
    metabolomics_analysis_pipeline(
        metabolite_list=["glucose", "lactate", "pyruvate", "citrate", "succinate"],
        study_id="MTBLS1",
        search_query="diabetes",
        organism="Homo sapiens",
        output_file="diabetes_metabolomics_report_FIXED.md"
    )

    print("\n✅ Fixed implementation completed!")
    print("Compare diabetes_metabolomics_report_FIXED.md with diabetes_metabolomics_report.md")