Tooluniverse Drug Repurposing

Drug Repurposing with ToolUniverse

Systematically identify and evaluate drug repurposing candidates using multiple computational strategies.

IMPORTANT: Always use English terms in tool calls. Respond in the user's language.

---

Reasoning Before Searching

Start by asking: WHY might this drug work for a new disease? Three strategies:

• (a) Same target: The drug's primary target is also involved in the new disease. This is the strongest hypothesis — use OpenTargets to check if the target has genetic evidence in both diseases before any other search.
• (b) Off-target activity: The drug has secondary targets or off-target effects that are relevant to the new disease. Check ChEMBL bioactivity data for all known targets of the drug, not just its primary one.
• (c) Shared pathways: The original indication and new disease share molecular pathways, even if the target itself is not genetically linked. Use Reactome and STRING to compare pathway overlap between diseases.

Each strategy uses different tools and has different evidentiary weight. Identify which strategy applies FIRST, then choose the corresponding workflow below. Do not run all three strategies blindly — reason about which is most plausible given the drug's mechanism.

LOOK UP DON'T GUESS: Never assume a drug hits a target, never assume a target is disease-relevant, never assume pathway overlap. Verify each link with tool calls.

Core Strategies

1. Target-Based: Disease targets -> Find drugs that modulate those targets 2. Compound-Based: Approved drugs -> Find new disease indications 3. Disease-Driven: Disease -> Targets -> Match to existing drugs

---

Workflow Overview

Phase 1: Disease & Target Analysis
  Get disease info (OpenTargets), find associated targets, get target details

Phase 2: Drug Discovery
  Search DrugBank, DGIdb, ChEMBL for drugs targeting disease-associated genes
  Get drug details, indications, pharmacology

Phase 3: Safety & Feasibility Assessment
  FDA warnings, FAERS adverse events, drug interactions, ADMET predictions

Phase 4: Literature Evidence
  PubMed, Europe PMC, clinical trials for existing evidence

Phase 5: Scoring & Ranking
  Composite score: target association + safety + literature + drug properties

See: PROCEDURES.md for detailed step-by-step procedures and code patterns.

---

Quick Start

from tooluniverse import ToolUniverse
tu = ToolUniverse()
tu.load_tools()

# Step 1: Get disease targets
disease_info = tu.tools.OpenTargets_get_disease_id_description_by_name(diseaseName="rheumatoid arthritis")
# Response nests ID at data.search.hits[0].id
disease_id = disease_info['data']['search']['hits'][0]['id']
targets = tu.tools.OpenTargets_get_associated_targets_by_disease_efoId(efoId=disease_id, limit=10)

# Step 2: Find drugs for each target
# Response nests targets at data.disease.associatedTargets.rows
rows = targets['data']['disease']['associatedTargets']['rows']
for target in rows[:5]:
    gene = target['target']['approvedSymbol']
    drugs = tu.tools.DGIdb_get_drug_gene_interactions(genes=[gene])

---

Key ToolUniverse Tools

Disease & Target:

• OpenTargets_get_disease_id_description_by_name - Disease lookup
• OpenTargets_get_associated_targets_by_disease_efoId - Disease targets
• UniProt_get_entry_by_accession - Protein details

Drug Discovery:

• drugbank_get_drug_name_and_description_by_target_name - Drugs by target. Param: `query=` (NOT `target_name=`)
• drugbank_get_drug_name_and_description_by_indication - Drugs by indication. Param: `query=` (NOT `indication=`)
• DGIdb_get_drug_gene_interactions - Drug-gene interactions. Response path: data.data.genes.nodes[0].interactions
• ChEMBL_search_drugs / ChEMBL_get_drug_mechanisms - Drug search and MOA

Drug Information (ALL DrugBank tools use query= as the search parameter, plus case_sensitive=False, exact_match=False, limit=N):

• drugbank_get_drug_basic_info_by_drug_name_or_id - Basic info. Param: `query="drug_name"`
• drugbank_get_indications_by_drug_name_or_drugbank_id - Approved indications. Param: `query="drug_name"`
• drugbank_get_pharmacology_by_drug_name_or_drugbank_id - Pharmacology. Param: `query="drug_name"`
• drugbank_get_targets_by_drug_name_or_drugbank_id - Drug targets. Param: `query="drug_name"`

Safety:

• FDA_get_warnings_and_cautions_by_drug_name - FDA warnings
• FAERS_search_reports_by_drug_and_reaction - Adverse events. Param: `medicinalproduct=` (NOT `drug_name=`)
• FAERS_count_death_related_by_drug - Serious outcomes. Param: `medicinalproduct=` (NOT `drug_name=`)
• drugbank_get_drug_interactions_by_drug_name_or_id - Interactions

Property Prediction:

• ADMETAI_predict_physicochemical_properties / ADMETAI_predict_toxicity - ADMET and toxicity

Pathway & Network Analysis:

• ReactomeAnalysis_pathway_enrichment - Pathway enrichment. Param: `identifiers="SOD1\nTARDBP\nFUS"` (newline-separated string, NOT array)
• STRING_get_network - Protein interaction networks. Param: `identifiers="SOD1\rTARDBP\rFUS"` (CR-separated string), `species=9606`
• CTD_get_gene_diseases - Curated gene-disease associations. Param: `input_terms="gene_symbol"` (NOT `gene_symbol=`)

Literature & Clinical Trials:

• PubMed_search_articles / EuropePMC_search_articles - Literature search
• search_clinical_trials - ClinicalTrials.gov search. Use condition for disease name. The intervention filter is strict and may miss trials — use query_term for broader drug-name matching as fallback.

CNS diseases note: For neurological indications (ALS, Alzheimer's, Parkinson's), prioritize BBB-penetrant candidates. Use ChEMBL molecular properties (MW < 500, PSA < 90) as BBB proxy since ADMETAI_predict_BBB_penetrance may require the tooluniverse[ml] extra. Consider route of administration (oral preferred for patients with swallowing difficulty) and sex-specific effects from preclinical models.

---

Scoring & Decision Framework

Repurposing Viability Score (0-100)

Classification:

• 80-100: Strong candidate — proceed to clinical evaluation
• 60-79: Promising — worth preclinical validation or retrospective study
• 40-59: Speculative — needs significant additional evidence
• <40: Weak — likely not worth pursuing without new mechanistic insight

Evidence Grading for Repurposing

How to Interpret and Combine Results

After running Phases 1-4, synthesize by answering:

1. Is the target validated for this disease? Check OpenTargets association score (>0.5 = strong). Cross-reference with genetic evidence (GWAS hits, rare variant studies). If target association is only pathway-level, the repurposing hypothesis is speculative.

2. Does the drug actually hit the target at achievable doses? Check ChEMBL IC50/Ki values. If the drug's affinity for the new target is >10x weaker than for its original target, clinical efficacy is unlikely at safe doses.

3. What's the safety margin? Compare the dose needed for the new indication to the approved dose. If higher doses are needed, safety data from the original indication may not apply.

4. Is there prior clinical evidence? A Phase II trial for the new indication (even failed) is more informative than 100 computational predictions. Check search_clinical_trials first.

5. What's the competitive landscape? If better drugs already exist for the disease, repurposing offers little value. Check DrugBank indications for approved therapies.

---

Best Practices

1. Check clinical trials FIRST: search_clinical_trials(condition="[disease]", intervention="[drug]") — if a trial already exists, start there 2. Validate targets with genetics: Genetic evidence (GWAS, rare variants) is the strongest predictor of successful drug development 3. Safety first: Prioritize approved drugs with known safety profiles 4. Dose matters: A drug that hits a disease target at 100x its approved dose is not a repurposing candidate 5. Mechanism over correlation: Network proximity alone is insufficient — explain WHY the drug should work 6. Consider IP and formulation: Generic drugs are easier to repurpose but harder to fund trials for

Computational Procedure: Drug-Target Dose Feasibility Check

A drug that hits a new target only at 100x its approved dose is NOT a viable repurposing candidate. Use this procedure after identifying drug-target pairs:

# Drug-target dose feasibility analysis
# Uses ChEMBL bioactivity data from ToolUniverse
from tooluniverse import ToolUniverse

tu = ToolUniverse()
tu.load_tools()

def check_dose_feasibility(drug_name, original_target, new_target):
    """
    Compare drug's potency at original vs new target.
    If new_target IC50 > 10x original_target IC50, flag as unlikely feasible.
    """
    # Get bioactivity for original target
    orig = tu.run_one_function({
        'name': 'ChEMBL_get_bioactivities',
        'arguments': {
            'molecule_chembl_id': drug_name,  # or search first
            'target_chembl_id': original_target,
            'limit': 10
        }
    })

    # Get bioactivity for new target
    new = tu.run_one_function({
        'name': 'ChEMBL_get_bioactivities',
        'arguments': {
            'molecule_chembl_id': drug_name,
            'target_chembl_id': new_target,
            'limit': 10
        }
    })

    # Extract IC50/Ki values and compare
    # If new target requires >10x concentration → NOT FEASIBLE at safe doses
    # If new target is within 3x → PROMISING
    # If new target is within 1x → STRONG candidate
    pass  # Parse actual values from results

# Alternative: Quick Cmax check
# If published Cmax at approved dose < IC50 for new target → NOT FEASIBLE
# Cmax data can be found in:
#   - DrugBank pharmacology section
#   - DailyMed clinical pharmacology section
#   - PubMed PK studies

Key principle: The most common reason repurposing fails is insufficient drug exposure at the new target. Always check whether the drug's concentration at approved doses reaches the IC50 for the new target.

---

Troubleshooting

---

Reference Files

• REFERENCE.md - Detailed reference documentation
• EXAMPLES.md - Sample repurposing analyses
• PROCEDURES.md - Step-by-step procedures with code
• REPORT_TEMPLATE.md - Output report template
• Related skills: disease-intelligence-gatherer, chemical-compound-retrieval, tooluniverse-sdk

Drug Repurposing Examples

Concrete examples of drug repurposing workflows using ToolUniverse.

Example 1: Target-Based Repurposing for Alzheimer's Disease

from tooluniverse import ToolUniverse

tu = ToolUniverse(use_cache=True)
tu.load_tools()

# Step 1: Get disease information
disease_info = tu.tools.OpenTargets_get_disease_id_description_by_name(
    diseaseName="Alzheimer's disease"
)
print(f"Disease ID: {disease_info['data']['id']}")
print(f"Description: {disease_info['data']['description']}")

# Step 2: Get top associated targets
targets = tu.tools.OpenTargets_get_associated_targets_by_disease_efoId(
    efoId=disease_info['data']['id'],
    limit=10
)

print(f"\nTop 10 targets for Alzheimer's disease:")
for i, target in enumerate(targets['data'], 1):
    print(f"{i}. {target['gene_symbol']} - Score: {target['score']}")

# Step 3: Find drugs for top 3 targets
repurposing_candidates = []

for target in targets['data'][:3]:
    gene_symbol = target['gene_symbol']
    print(f"\nSearching drugs for target: {gene_symbol}")
    
    # Search DGIdb
    dgidb_results = tu.tools.DGIdb_get_drug_gene_interactions(
        gene_name=gene_symbol
    )
    
    if dgidb_results and 'data' in dgidb_results:
        for drug in dgidb_results['data']:
            # Get detailed drug information
            drug_info = tu.tools.drugbank_get_drug_basic_info_by_drug_name_or_id(
                drug_name_or_drugbank_id=drug['drug_name']
            )
            
            # Get current indications
            indications = tu.tools.drugbank_get_indications_by_drug_name_or_drugbank_id(
                drug_name_or_drugbank_id=drug['drug_name']
            )
            
            # Check if already used for Alzheimer's
            current_indications = [ind['indication'] for ind in indications.get('data', [])]
            if not any('alzheimer' in ind.lower() for ind in current_indications):
                repurposing_candidates.append({
                    'drug_name': drug['drug_name'],
                    'target': gene_symbol,
                    'interaction_type': drug.get('interaction_type'),
                    'current_indications': current_indications,
                    'approval_status': drug_info.get('data', {}).get('groups')
                })

# Step 4: Score and rank candidates
print(f"\n{'='*80}")
print("REPURPOSING CANDIDATES FOR ALZHEIMER'S DISEASE")
print(f"{'='*80}\n")

for i, candidate in enumerate(repurposing_candidates[:10], 1):
    print(f"{i}. {candidate['drug_name']}")
    print(f"   Target: {candidate['target']}")
    print(f"   Status: {candidate['approval_status']}")
    print(f"   Current uses: {', '.join(candidate['current_indications'][:3])}")
    print()

# Step 5: Deep dive on top candidate
if repurposing_candidates:
    top_drug = repurposing_candidates[0]['drug_name']
    print(f"\nDETAILED ANALYSIS: {top_drug}")
    print("="*80)
    
    # Get safety data
    warnings = tu.tools.FDA_get_warnings_and_cautions_by_drug_name(
        drug_name=top_drug
    )
    
    # Get adverse events
    adverse_events = tu.tools.FAERS_search_reports_by_drug_and_reaction(
        drug_name=top_drug,
        limit=100
    )
    
    # Search literature
    papers = tu.tools.PubMed_search_articles(
        query=f"{top_drug} AND Alzheimer's disease",
        max_results=20
    )
    
    print(f"FDA Warnings: {len(warnings.get('data', []))} found")
    print(f"Adverse Event Reports: {len(adverse_events.get('data', []))} found")
    print(f"Related Literature: {len(papers.get('data', []))} papers")

Expected Output:

Disease ID: EFO_0000249
Description: Alzheimer's disease is a neurodegenerative disorder...

Top 10 targets for Alzheimer's disease:
1. APP - Score: 0.95
2. APOE - Score: 0.89
3. MAPT - Score: 0.85
...

REPURPOSING CANDIDATES FOR ALZHEIMER'S DISEASE
================================================================================

1. Donepezil (approved for other indication)
   Target: ACHE
   Status: ['approved']
   Current uses: mild to moderate dementia, vascular dementia
   
2. Memantine
   Target: GRIN1
   Status: ['approved']
   Current uses: moderate to severe Alzheimer's disease
...

---

Example 2: Compound-Based Repurposing - Finding New Uses for Metformin

from tooluniverse import ToolUniverse

tu = ToolUniverse(use_cache=True)
tu.load_tools()

# Step 1: Get comprehensive drug information
drug_name = "metformin"

print(f"DRUG REPURPOSING ANALYSIS: {drug_name.upper()}")
print("="*80)

# Basic info
drug_info = tu.tools.drugbank_get_drug_basic_info_by_drug_name_or_id(
    drug_name_or_drugbank_id=drug_name
)

# Current indications
indications = tu.tools.drugbank_get_indications_by_drug_name_or_drugbank_id(
    drug_name_or_drugbank_id=drug_name
)

# Targets
targets = tu.tools.drugbank_get_targets_by_drug_name_or_drugbank_id(
    drug_name_or_drugbank_id=drug_name
)

# Pharmacology
pharmacology = tu.tools.drugbank_get_pharmacology_by_drug_name_or_drugbank_id(
    drug_name_or_drugbank_id=drug_name
)

print(f"\nCURRENT APPROVED INDICATIONS:")
for ind in indications.get('data', [])[:5]:
    print(f"  - {ind['indication']}")

print(f"\nTARGETS:")
for target in targets.get('data', [])[:5]:
    print(f"  - {target['name']} ({target['organism']})")

# Step 2: Find diseases associated with drug targets
print(f"\n{'='*80}")
print("POTENTIAL NEW INDICATIONS BASED ON TARGET ANALYSIS")
print("="*80)

potential_indications = []

for target in targets.get('data', [])[:5]:
    gene_symbol = target.get('gene_symbol')
    if gene_symbol:
        # Search for diseases associated with this target
        target_diseases = tu.tools.OpenTargets_get_diseases_by_target_ensemblId(
            ensemblId=target['ensembl_id']
        )
        
        for disease in target_diseases.get('data', [])[:3]:
            # Check if not already indicated
            if disease['disease_name'] not in [ind['indication'] for ind in indications.get('data', [])]:
                potential_indications.append({
                    'disease': disease['disease_name'],
                    'target': gene_symbol,
                    'association_score': disease['score'],
                    'disease_id': disease['disease_id']
                })

# Step 3: Literature evidence for potential indications
print(f"\nLITERATURE EVIDENCE FOR REPURPOSING:")
print("-"*80)

for indication in sorted(potential_indications, key=lambda x: x['association_score'], reverse=True)[:5]:
    # Search for existing research
    query = f"{drug_name} AND {indication['disease']}"
    papers = tu.tools.PubMed_search_articles(
        query=query,
        max_results=10
    )
    
    clinical_trials = tu.tools.search_clinical_trials(
        condition=indication['disease'],
        intervention=drug_name
    )
    
    print(f"\n{indication['disease']}")
    print(f"  Target: {indication['target']} (score: {indication['association_score']:.2f})")
    print(f"  Literature: {len(papers.get('data', []))} papers")
    print(f"  Clinical Trials: {len(clinical_trials.get('data', []))} trials")
    
    if papers.get('data'):
        print(f"  Recent paper: {papers['data'][0].get('title', 'N/A')}")

# Step 4: Safety assessment for new indications
print(f"\n{'='*80}")
print("SAFETY PROFILE")
print("="*80)

# FDA warnings
warnings = tu.tools.FDA_get_warnings_and_cautions_by_drug_name(
    drug_name=drug_name
)

# Adverse events
adverse_events = tu.tools.FAERS_count_reactions_by_drug_event(
    medicinalproduct=drug_name.upper()
)

# Drug interactions
interactions = tu.tools.drugbank_get_drug_interactions_by_drug_name_or_id(
    drug_name_or_id=drug_name
)

print(f"\nFDA Warnings: {len(warnings.get('data', []))}")
print(f"Top Adverse Events:")
for event in adverse_events.get('results', [])[:5]:
    print(f"  - {event['term']}: {event['count']} reports")

print(f"\nDrug-Drug Interactions: {len(interactions.get('data', []))}")

# Step 5: Generate repurposing recommendation
print(f"\n{'='*80}")
print("REPURPOSING RECOMMENDATION")
print("="*80)

print(f"""
Drug: {drug_name.upper()}
Current Indication: Type 2 Diabetes
Repurposing Potential: HIGH

Top 3 Repurposing Opportunities:
1. {potential_indications[0]['disease']} (Score: {potential_indications[0]['association_score']:.2f})
   - {len([p for p in papers.get('data', []) if potential_indications[0]['disease'].lower() in p.get('title', '').lower()])} supporting papers
   - Known safety profile (widely used for 60+ years)
   - Low cost, generic availability
   
2. {potential_indications[1]['disease']} (Score: {potential_indications[1]['association_score']:.2f})
   - Emerging evidence from preclinical studies
   - Phase II trial feasibility high
   
3. {potential_indications[2]['disease']} (Score: {potential_indications[2]['association_score']:.2f})
   - Mechanistic rationale strong
   - Population overlap with diabetes patients

Recommended Next Steps:
- Systematic review of existing literature
- Phase II trial design for top indication
- Patient stratification analysis
- Pharmacokinetic/pharmacodynamic modeling
""")

---

Example 3: Disease-Driven Repurposing for COVID-19

from tooluniverse import ToolUniverse
import json

tu = ToolUniverse(use_cache=True)
tu.load_tools()

# Step 1: Define disease and get information
disease_name = "COVID-19"

print(f"EMERGENCY DRUG REPURPOSING: {disease_name}")
print("="*80)

# Get disease info
disease_info = tu.tools.OpenTargets_get_disease_id_description_by_name(
    diseaseName=disease_name
)

# Step 2: Get viral-host interaction targets
print("\nKEY HOST TARGETS:")
targets = tu.tools.OpenTargets_get_associated_targets_by_disease_efoId(
    efoId=disease_info['data']['id'],
    limit=20
)

for i, target in enumerate(targets['data'][:10], 1):
    print(f"{i}. {target['gene_symbol']} - {target['gene_name']}")

# Step 3: Rapid screening - find ALL approved drugs for these targets
print(f"\n{'='*80}")
print("APPROVED DRUGS TARGETING COVID-19-ASSOCIATED PROTEINS")
print("="*80)

approved_candidates = []

for target in targets['data'][:10]:
    gene_symbol = target['gene_symbol']
    
    # Search multiple databases
    dgidb = tu.tools.DGIdb_get_drug_gene_interactions(gene_name=gene_symbol)
    drugbank = tu.tools.drugbank_get_drug_name_and_description_by_target_name(target_name=gene_symbol)
    
    # Combine results
    all_drugs = []
    if dgidb and 'data' in dgidb:
        all_drugs.extend([d['drug_name'] for d in dgidb['data']])
    if drugbank and 'data' in drugbank:
        all_drugs.extend([d['drug_name'] for d in drugbank['data']])
    
    # Filter to approved only
    for drug_name in set(all_drugs):
        try:
            drug_info = tu.tools.drugbank_get_drug_basic_info_by_drug_name_or_id(
                drug_name_or_drugbank_id=drug_name
            )
            
            if drug_info and 'approved' in drug_info.get('data', {}).get('groups', []):
                approved_candidates.append({
                    'drug': drug_name,
                    'target': gene_symbol,
                    'target_score': target['score']
                })
        except:
            continue

# Step 4: Literature mining for COVID-19 evidence
print(f"\nEVIDENCE ANALYSIS:")
print("-"*80)

scored_candidates = []

for candidate in approved_candidates[:20]:  # Analyze top 20
    drug = candidate['drug']
    
    # Search COVID-19 literature
    query = f"{drug} AND (COVID-19 OR SARS-CoV-2)"
    papers = tu.tools.PubMed_search_articles(
        query=query,
        max_results=50
    )
    
    # Search clinical trials
    trials = tu.tools.search_clinical_trials(
        condition="COVID-19",
        intervention=drug
    )
    
    # Calculate evidence score
    paper_count = len(papers.get('data', []))
    trial_count = len(trials.get('data', []))
    
    evidence_score = (
        candidate['target_score'] * 40 +
        min(trial_count * 10, 30) +  # Max 30 points for trials
        min(paper_count * 2, 30)      # Max 30 points for papers
    )
    
    if paper_count > 0 or trial_count > 0:
        scored_candidates.append({
            **candidate,
            'papers': paper_count,
            'trials': trial_count,
            'evidence_score': evidence_score
        })
        
        print(f"{drug}: {paper_count} papers, {trial_count} trials (Score: {evidence_score:.1f})")

# Step 5: Safety rapid assessment
print(f"\n{'='*80}")
print("TOP CANDIDATES - SAFETY ASSESSMENT")
print("="*80)

top_candidates = sorted(scored_candidates, key=lambda x: x['evidence_score'], reverse=True)[:5]

for i, candidate in enumerate(top_candidates, 1):
    drug = candidate['drug']
    print(f"\n{i}. {drug.upper()}")
    print("-"*80)
    
    # Get safety info
    try:
        warnings = tu.tools.FDA_get_warnings_and_cautions_by_drug_name(drug_name=drug)
        adverse = tu.tools.FAERS_count_death_related_by_drug(medicinalproduct=drug.upper())
        
        print(f"Target: {candidate['target']}")
        print(f"Evidence: {candidate['papers']} papers, {candidate['trials']} trials")
        print(f"FDA Warnings: {len(warnings.get('data', []))}")
        print(f"Death-related AEs: {adverse.get('meta', {}).get('total', 0)} reports")
        
        # Get mechanism
        pharmacology = tu.tools.drugbank_get_pharmacology_by_drug_name_or_drugbank_id(
            drug_name_or_drugbank_id=drug
        )
        
        if pharmacology:
            print(f"Mechanism: {pharmacology.get('data', {}).get('mechanism_of_action', 'N/A')[:200]}")
    except:
        print("Safety data unavailable")

# Step 6: Generate priority recommendation
print(f"\n{'='*80}")
print("EMERGENCY USE RECOMMENDATION")
print("="*80)

print(f"""
REPURPOSING CANDIDATES FOR COVID-19 (Ranked by Priority)

HIGH PRIORITY (Strong Evidence + Approved + Safe):
""")

for i, candidate in enumerate(top_candidates[:3], 1):
    print(f"""
{i}. {candidate['drug'].upper()}
   Evidence Score: {candidate['evidence_score']:.1f}/100
   Target: {candidate['target']}
   Clinical Trials: {candidate['trials']} ongoing/completed
   Literature: {candidate['papers']} publications
   Status: FDA approved for other indications
   
   Recommendation: Fast-track to Phase III trial
   Timeline: 6-12 months to emergency use authorization
""")

print("""
NEXT STEPS:
1. Initiate multi-center randomized controlled trial
2. Establish optimal dosing regimen
3. Identify patient subgroups most likely to benefit
4. Monitor for drug-drug interactions with standard COVID treatments
5. Prepare emergency use authorization application
""")

---

Example 4: Network-Based Repurposing Using Pathway Analysis

from tooluniverse import ToolUniverse

tu = ToolUniverse(use_cache=True)
tu.load_tools()

# Step 1: Analyze pathways affected by known effective drug
known_drug = "aspirin"
target_disease = "cardiovascular disease"

print(f"PATHWAY-BASED REPURPOSING: Finding drugs similar to {known_drug}")
print("="*80)

# Get drug pathways
pathways = tu.tools.drugbank_get_pathways_reactions_by_drug_or_id(
    drug_name_or_drugbank_id=known_drug
)

print(f"\nPathways affected by {known_drug}:")
for pathway in pathways.get('data', [])[:5]:
    print(f"  - {pathway['pathway_name']}")

# Step 2: Find other drugs affecting same pathways
pathway_drugs = {}

for pathway in pathways.get('data', [])[:3]:
    pathway_name = pathway['pathway_name']
    
    drugs = tu.tools.drugbank_get_drug_name_and_description_by_pathway_name(
        pathway_name=pathway_name
    )
    
    if drugs and 'data' in drugs:
        pathway_drugs[pathway_name] = [d['drug_name'] for d in drugs['data']]

# Step 3: Score drugs by pathway overlap
drug_scores = {}
for pathway, drugs in pathway_drugs.items():
    for drug in drugs:
        if drug != known_drug:
            drug_scores[drug] = drug_scores.get(drug, 0) + 1

# Rank by pathway overlap
ranked_drugs = sorted(drug_scores.items(), key=lambda x: x[1], reverse=True)

print(f"\nDrugs with highest pathway overlap:")
for drug, score in ranked_drugs[:10]:
    print(f"  {drug}: {score} shared pathways")

# Step 4: Validate for target disease
print(f"\n{'='*80}")
print(f"VALIDATION FOR {target_disease.upper()}")
print("="*80)

validated_candidates = []

for drug, overlap_score in ranked_drugs[:20]:
    # Search for disease-specific evidence
    query = f"{drug} AND {target_disease}"
    papers = tu.tools.PubMed_search_articles(query=query, max_results=10)
    
    # Get drug info
    drug_info = tu.tools.drugbank_get_drug_basic_info_by_drug_name_or_id(
        drug_name_or_drugbank_id=drug
    )
    
    if papers.get('data'):
        validated_candidates.append({
            'drug': drug,
            'pathway_overlap': overlap_score,
            'evidence_papers': len(papers['data']),
            'status': drug_info.get('data', {}).get('groups', [])
        })

# Print validated candidates
for i, candidate in enumerate(validated_candidates[:5], 1):
    print(f"\n{i}. {candidate['drug']}")
    print(f"   Shared pathways: {candidate['pathway_overlap']}")
    print(f"   Supporting papers: {candidate['evidence_papers']}")
    print(f"   Status: {', '.join(candidate['status'])}")

---

Example 5: Structure-Based Repurposing

from tooluniverse import ToolUniverse

tu = ToolUniverse(use_cache=True)
tu.load_tools()

# Step 1: Start with known active compound
known_active = "imatinib"  # Cancer drug
target_disease = "rheumatoid arthritis"

print(f"STRUCTURE-BASED REPURPOSING")
print("="*80)
print(f"Known active: {known_active}")
print(f"Target disease: {target_disease}\n")

# Get structure
cid_result = tu.tools.PubChem_get_CID_by_compound_name(
    compound_name=known_active
)
cid = cid_result['data']['cid']

# Get SMILES
props = tu.tools.PubChem_get_compound_properties_by_CID(cid=cid)
smiles = props['data']['CanonicalSMILES']

print(f"PubChem CID: {cid}")
print(f"SMILES: {smiles}\n")

# Step 2: Find structurally similar compounds
print("Searching for similar structures...")
similar_compounds = tu.tools.PubChem_search_compounds_by_similarity(
    smiles=smiles,
    threshold=85,  # 85% similarity
    limit=50
)

print(f"Found {len(similar_compounds.get('data', []))} similar compounds")

# Step 3: Check which are approved drugs
approved_analogs = []

for compound in similar_compounds.get('data', [])[:20]:
    compound_cid = compound['cid']
    
    # Get drug information
    # FDA labels are keyed by drug name, not CID -- resolve the name first
    _syn = tu.tools.PubChem_get_compound_synonyms_by_CID(cid=compound_cid)
    _name = _syn['data'][0] if isinstance(_syn, dict) and _syn.get('data') else None
    drug_label = tu.tools.FDA_get_drug_label(drug_name=_name)
    
    if drug_label and 'data' in drug_label:
        # This is an approved drug
        drug_name = drug_label['data'].get('drug_name')
        
        # Get current indications
        drugbank_info = tu.tools.drugbank_get_indications_by_drug_name_or_drugbank_id(
            drug_name_or_drugbank_id=drug_name
        )
        
        approved_analogs.append({
            'drug_name': drug_name,
            'cid': compound_cid,
            'similarity': compound.get('similarity_score', 'N/A'),
            'indications': drugbank_info.get('data', [])
        })

print(f"\nFound {len(approved_analogs)} approved structural analogs\n")

# Step 4: Evaluate for target disease
print(f"Evaluating analogs for {target_disease}:")
print("-"*80)

for analog in approved_analogs[:5]:
    drug = analog['drug_name']
    
    # Check if already used for target disease
    current_indications = [ind['indication'] for ind in analog['indications']]
    already_used = any(target_disease.lower() in ind.lower() for ind in current_indications)
    
    if not already_used:
        # Search literature
        query = f"{drug} AND {target_disease}"
        papers = tu.tools.PubMed_search_articles(query=query, max_results=10)
        
        # Predict properties
        analog_props = tu.tools.PubChem_get_compound_properties_by_CID(
            cid=analog['cid']
        )
        
        print(f"\n{drug}")
        print(f"  Structural similarity: {analog['similarity']}")
        print(f"  Current indications: {', '.join(current_indications[:2])}")
        print(f"  Literature evidence: {len(papers.get('data', []))} papers")
        print(f"  MW: {analog_props['data']['MolecularWeight']}, LogP: {analog_props['data']['XLogP']}")

---

Example 6: Adverse Event Mining for Repurposing

from tooluniverse import ToolUniverse
from collections import Counter

tu = ToolUniverse(use_cache=True)
tu.load_tools()

# Concept: Adverse effects can be therapeutic in different contexts
# Example: Weight loss (AE in some drugs) → Obesity treatment

print("ADVERSE EVENT MINING FOR REPURPOSING")
print("="*80)

# Step 1: Define therapeutic target from adverse event
target_adverse_event = "weight loss"  # Could be therapeutic for obesity
therapeutic_indication = "obesity"

# Step 2: Find drugs with this adverse event
print(f"\nSearching for drugs causing: {target_adverse_event}")

# Query FAERS for drugs associated with weight loss
weight_loss_drugs = tu.tools.FAERS_count_drugs_by_drug_event(
    patient_reaction=target_adverse_event
)

top_drugs = [drug['term'] for drug in weight_loss_drugs.get('results', [])[:20]]

print(f"Found {len(top_drugs)} drugs with significant {target_adverse_event} reports")

# Step 3: For each drug, validate the effect and check safety
candidates = []

for drug_name in top_drugs:
    # Get full adverse event profile
    all_reactions = tu.tools.FAERS_count_reactions_by_drug_event(
        medicinalproduct=drug_name
    )
    
    # Check seriousness
    seriousness = tu.tools.FAERS_count_seriousness_by_drug_event(
        medicinalproduct=drug_name
    )
    
    # Get drug info
    try:
        drug_info = tu.tools.drugbank_get_drug_basic_info_by_drug_name_or_id(
            drug_name_or_drugbank_id=drug_name.lower()
        )
        
        indications = tu.tools.drugbank_get_indications_by_drug_name_or_drugbank_id(
            drug_name_or_drugbank_id=drug_name.lower()
        )
        
        # Check if already used for obesity
        current_uses = [ind['indication'] for ind in indications.get('data', [])]
        if not any('obesity' in use.lower() for use in current_uses):
            candidates.append({
                'drug': drug_name,
                'current_indications': current_uses[:3],
                'weight_loss_reports': next((r['count'] for r in all_reactions.get('results', []) 
                                            if 'weight' in r['term'].lower()), 0),
                'serious_reports': seriousness.get('meta', {}).get('serious_count', 0),
                'status': drug_info.get('data', {}).get('groups', [])
            })
    except:
        continue

# Step 4: Rank by safety and efficacy signals
print(f"\n{'='*80}")
print(f"REPURPOSING CANDIDATES FOR {therapeutic_indication.upper()}")
print("="*80)

# Sort by weight loss reports, but filter out highly toxic
safe_candidates = [c for c in candidates 
                   if 'approved' in c.get('status', []) 
                   and c['serious_reports'] < 1000]

ranked = sorted(safe_candidates, 
                key=lambda x: x['weight_loss_reports'], 
                reverse=True)

for i, candidate in enumerate(ranked[:10], 1):
    print(f"\n{i}. {candidate['drug']}")
    print(f"   Weight loss reports: {candidate['weight_loss_reports']}")
    print(f"   Status: {', '.join(candidate['status'])}")
    print(f"   Current use: {', '.join(candidate['current_indications'])}")
    print(f"   Serious AE reports: {candidate['serious_reports']}")
    
    # Check mechanism
    try:
        pharmacology = tu.tools.drugbank_get_pharmacology_by_drug_name_or_drugbank_id(
            drug_name_or_drugbank_id=candidate['drug'].lower()
        )
        moa = pharmacology.get('data', {}).get('mechanism_of_action', '')
        if moa:
            print(f"   Mechanism: {moa[:150]}...")
    except:
        pass

print(f"\n{'='*80}")
print("RECOMMENDATION")
print("="*80)
print("""
Strategy: Repurpose drugs with weight loss adverse events for obesity treatment

Top candidates show:
- Consistent weight loss signal in FAERS data
- Approved status (known safety profile)
- Mechanisms compatible with weight regulation
- Lower serious adverse event rates

Next steps:
1. Systematic review of weight loss magnitude
2. Dose-response relationship analysis  
3. Patient population stratification
4. Phase II efficacy trial design
5. Long-term safety monitoring protocol
""")

---

Example 7: Multi-Database Integration for Comprehensive Analysis

from tooluniverse import ToolUniverse

tu = ToolUniverse(use_cache=True)
tu.load_tools()

def comprehensive_repurposing_analysis(drug_name, new_indication):
    """
    Comprehensive drug repurposing analysis integrating multiple databases.
    """
    results = {
        'drug': drug_name,
        'proposed_indication': new_indication,
        'scores': {}
    }
    
    print(f"COMPREHENSIVE REPURPOSING ANALYSIS")
    print("="*80)
    print(f"Drug: {drug_name}")
    print(f"Proposed indication: {new_indication}\n")
    
    # 1. DRUG INFORMATION (DrugBank)
    print("1. DRUGBANK ANALYSIS")
    print("-"*80)
    
    basic_info = tu.tools.drugbank_get_drug_basic_info_by_drug_name_or_id(
        drug_name_or_drugbank_id=drug_name
    )
    
    targets = tu.tools.drugbank_get_targets_by_drug_name_or_drugbank_id(
        drug_name_or_drugbank_id=drug_name
    )
    
    indications = tu.tools.drugbank_get_indications_by_drug_name_or_drugbank_id(
        drug_name_or_drugbank_id=drug_name
    )
    
    print(f"Status: {basic_info.get('data', {}).get('groups', [])}")
    print(f"Targets: {len(targets.get('data', []))}")
    print(f"Current indications: {len(indications.get('data', []))}")
    
    results['drugbank'] = {
        'status': basic_info.get('data', {}).get('groups', []),
        'targets': targets.get('data', []),
        'indications': indications.get('data', [])
    }
    
    # 2. TARGET-DISEASE ASSOCIATION (OpenTargets)
    print(f"\n2. OPENTARGETS ANALYSIS")
    print("-"*80)
    
    disease_info = tu.tools.OpenTargets_get_disease_id_description_by_name(
        diseaseName=new_indication
    )
    
    disease_targets = tu.tools.OpenTargets_get_associated_targets_by_disease_efoId(
        efoId=disease_info['data']['id'],
        limit=50
    )
    
    # Calculate target overlap
    drug_target_symbols = [t.get('gene_symbol') for t in targets.get('data', [])]
    disease_target_symbols = [t['gene_symbol'] for t in disease_targets.get('data', [])]
    overlap = set(drug_target_symbols) & set(disease_target_symbols)
    
    print(f"Disease targets: {len(disease_target_symbols)}")
    print(f"Drug targets: {len(drug_target_symbols)}")
    print(f"Overlap: {len(overlap)} targets")
    if overlap:
        print(f"Shared targets: {', '.join(overlap)}")
    
    target_score = len(overlap) / max(len(drug_target_symbols), 1) * 100
    results['scores']['target_overlap'] = target_score
    
    # 3. CHEMICAL PROPERTIES (PubChem)
    print(f"\n3. PUBCHEM ANALYSIS")
    print("-"*80)
    
    cid = tu.tools.PubChem_get_CID_by_compound_name(
        compound_name=drug_name
    )
    
    if cid and 'data' in cid:
        properties = tu.tools.PubChem_get_compound_properties_by_CID(
            cid=cid['data']['cid']
        )
        
        bioactivity = tu.tools.PubChem_get_compound_bioactivity(
            cid=cid['data']['cid']
        )
        
        print(f"CID: {cid['data']['cid']}")
        print(f"MW: {properties['data']['MolecularWeight']}")
        print(f"LogP: {properties['data']['XLogP']}")
        print(f"Active assays: {bioactivity['data']['active_assay_count']}")
        
        results['pubchem'] = {
            'cid': cid['data']['cid'],
            'properties': properties['data'],
            'bioactivity': bioactivity['data']
        }
    
    # 4. BIOACTIVITY DATA (ChEMBL)
    print(f"\n4. CHEMBL ANALYSIS")
    print("-"*80)
    
    chembl_drugs = tu.tools.ChEMBL_search_drugs(
        query=drug_name,
        limit=1
    )
    
    if chembl_drugs and 'data' in chembl_drugs:
        chembl_id = chembl_drugs['data'][0]['molecule_chembl_id']
        
        mechanisms = tu.tools.ChEMBL_get_drug_mechanisms(
            chembl_id=chembl_id
        )
        
        bioactivity_chembl = tu.tools.ChEMBL_search_activities(
            chembl_id=chembl_id
        )
        
        print(f"ChEMBL ID: {chembl_id}")
        print(f"Mechanisms: {len(mechanisms.get('data', []))}")
        print(f"Bioactivity records: {len(bioactivity_chembl.get('data', []))}")
        
        results['chembl'] = {
            'id': chembl_id,
            'mechanisms': mechanisms.get('data', []),
            'bioactivity': bioactivity_chembl.get('data', [])
        }
    
    # 5. SAFETY PROFILE (FDA + FAERS)
    print(f"\n5. SAFETY ASSESSMENT")
    print("-"*80)
    
    warnings = tu.tools.FDA_get_warnings_and_cautions_by_drug_name(
        drug_name=drug_name
    )
    
    adverse_events = tu.tools.FAERS_count_reactions_by_drug_event(
        medicinalproduct=drug_name.upper()
    )
    
    death_reports = tu.tools.FAERS_count_death_related_by_drug(
        medicinalproduct=drug_name.upper()
    )
    
    print(f"FDA warnings: {len(warnings.get('data', []))}")
    print(f"Adverse event types: {len(adverse_events.get('results', []))}")
    print(f"Death-related reports: {death_reports.get('meta', {}).get('total', 0)}")
    
    # Safety score (inverse - fewer issues = higher score)
    death_count = death_reports.get('meta', {}).get('total', 0)
    safety_score = max(0, 100 - (death_count / 100))  # Cap at 100
    results['scores']['safety'] = safety_score
    
    results['safety'] = {
        'warnings': warnings.get('data', []),
        'adverse_events': adverse_events.get('results', [])[:10],
        'deaths': death_count
    }
    
    # 6. LITERATURE EVIDENCE (PubMed + Europe PMC)
    print(f"\n6. LITERATURE EVIDENCE")
    print("-"*80)
    
    query = f"{drug_name} AND {new_indication}"
    
    pubmed = tu.tools.PubMed_search_articles(
        query=query,
        max_results=50
    )
    
    pmc = tu.tools.EuropePMC_search_articles(
        query=query,
        limit=50
    )
    
    print(f"PubMed articles: {len(pubmed.get('data', []))}")
    print(f"Europe PMC articles: {len(pmc.get('data', []))}")
    
    literature_score = min(len(pubmed.get('data', [])) * 2, 100)
    results['scores']['literature'] = literature_score
    
    results['literature'] = {
        'pubmed_count': len(pubmed.get('data', [])),
        'pmc_count': len(pmc.get('data', [])),
        'recent_papers': pubmed.get('data', [])[:5]
    }
    
    # 7. CLINICAL TRIALS
    print(f"\n7. CLINICAL TRIALS")
    print("-"*80)
    
    trials = tu.tools.search_clinical_trials(
        condition=new_indication,
        intervention=drug_name
    )
    
    print(f"Relevant trials: {len(trials.get('data', []))}")
    
    if trials.get('data'):
        for trial in trials['data'][:3]:
            print(f"  - {trial.get('title', 'N/A')}")
            print(f"    Status: {trial.get('status', 'N/A')}")
    
    trial_score = min(len(trials.get('data', [])) * 20, 100)
    results['scores']['clinical_trials'] = trial_score
    
    results['trials'] = trials.get('data', [])
    
    # 8. CALCULATE OVERALL REPURPOSING SCORE
    print(f"\n{'='*80}")
    print("REPURPOSING SCORE")
    print("="*80)
    
    weights = {
        'target_overlap': 0.30,
        'safety': 0.25,
        'literature': 0.25,
        'clinical_trials': 0.20
    }
    
    overall_score = sum(
        results['scores'].get(key, 0) * weight 
        for key, weight in weights.items()
    )
    
    print(f"\nTarget Overlap: {results['scores']['target_overlap']:.1f}/100 (30%)")
    print(f"Safety Profile: {results['scores']['safety']:.1f}/100 (25%)")
    print(f"Literature Evidence: {results['scores']['literature']:.1f}/100 (25%)")
    print(f"Clinical Trials: {results['scores']['clinical_trials']:.1f}/100 (20%)")
    print(f"\n{'='*80}")
    print(f"OVERALL REPURPOSING POTENTIAL: {overall_score:.1f}/100")
    print("="*80)
    
    # Classification
    if overall_score >= 70:
        recommendation = "HIGH POTENTIAL - Recommend immediate trial planning"
    elif overall_score >= 50:
        recommendation = "MODERATE POTENTIAL - Additional validation recommended"
    elif overall_score >= 30:
        recommendation = "LOW POTENTIAL - Requires more evidence"
    else:
        recommendation = "INSUFFICIENT DATA - Not recommended at this time"
    
    print(f"\nRecommendation: {recommendation}")
    
    return results

# Example usage
result = comprehensive_repurposing_analysis(
    drug_name="metformin",
    new_indication="Alzheimer's disease"
)

This comprehensive example demonstrates:

• Multi-database integration
• Systematic scoring methodology
• Evidence-based ranking
• Practical recommendations

Drug Repurposing: Detailed Procedures

Complete Workflow Code

Phase 1: Disease & Target Analysis

# 1.1 Get disease information
disease_info = tu.tools.OpenTargets_get_disease_id_description_by_name(
    diseaseName="[disease_name]"
)

# 1.2 Find associated targets
targets = tu.tools.OpenTargets_get_associated_targets_by_disease_efoId(
    efoId=disease_info['data']['id'],
    limit=20
)

# 1.3 Get target details for top candidates
target_details = []
for target in targets['data'][:10]:
    details = tu.tools.UniProt_get_entry_by_accession(
        accession=target['uniprot_id']
    )
    target_details.append(details)

Phase 2: Drug Discovery

# 2.1 Find drugs targeting disease-associated targets
drug_candidates = []

for target in targets['data'][:10]:
    # Search DrugBank
    drugbank_results = tu.tools.drugbank_get_drug_name_and_description_by_target_name(
        target_name=target['gene_symbol']
    )

    # Search DGIdb
    dgidb_results = tu.tools.DGIdb_get_drug_gene_interactions(
        gene_name=target['gene_symbol']
    )

    # Search ChEMBL
    chembl_results = tu.tools.ChEMBL_search_drugs(
        query=target['gene_symbol'],
        limit=10
    )

    drug_candidates.extend([drugbank_results, dgidb_results, chembl_results])

# 2.2 Get drug details
for drug_name in unique_drugs:
    drug_info = tu.tools.drugbank_get_drug_basic_info_by_drug_name_or_id(
        drug_name_or_drugbank_id=drug_name
    )
    indications = tu.tools.drugbank_get_indications_by_drug_name_or_drugbank_id(
        drug_name_or_drugbank_id=drug_name
    )
    pharmacology = tu.tools.drugbank_get_pharmacology_by_drug_name_or_drugbank_id(
        drug_name_or_drugbank_id=drug_name
    )

Phase 3: Safety & Feasibility Assessment

# 3.1 Check FDA safety data
for drug in top_candidates:
    warnings = tu.tools.FDA_get_warnings_and_cautions_by_drug_name(
        drug_name=drug['name']
    )
    adverse_events = tu.tools.FAERS_search_reports_by_drug_and_reaction(
        drug_name=drug['name'],
        limit=100
    )
    interactions = tu.tools.drugbank_get_drug_interactions_by_drug_name_or_id(
        drug_name_or_id=drug['name']
    )

# 3.2 Assess ADMET properties (for novel formulations)
for drug in top_candidates:
    if 'smiles' in drug:
        admet = tu.tools.ADMETAI_predict_physicochemical_properties(
            smiles=drug['smiles'],
            use_cache=True
        )

Phase 4: Literature Evidence

for drug in top_candidates:
    pubmed_results = tu.tools.PubMed_search_articles(
        query=f"{drug['name']} AND {disease_name}",
        max_results=50
    )
    pmc_results = tu.tools.EuropePMC_search_articles(
        query=f"{drug['name']} AND {disease_name}",
        limit=50
    )
    trials = tu.tools.search_clinical_trials(
        condition=disease_name,
        intervention=drug['name']
    )

Phase 5: Scoring & Ranking

def score_repurposing_candidate(drug, target_score, safety_data, literature_count):
    """Score drug repurposing candidate (0-100)."""
    score = 0

    # Target association strength (0-40 points)
    score += min(target_score * 40, 40)

    # Safety profile (0-30 points)
    if drug['approval_status'] == 'approved':
        score += 20
    elif drug['approval_status'] == 'clinical':
        score += 10
    if not safety_data.get('black_box_warning'):
        score += 10

    # Literature evidence (0-20 points)
    score += min(literature_count / 5 * 20, 20)

    # Drug-likeness (0-10 points)
    if drug.get('bioavailability') == 'high':
        score += 10

    return score

# Score and rank all candidates
scored_candidates = []
for drug in drug_candidates:
    score = score_repurposing_candidate(
        drug=drug,
        target_score=drug['target_association_score'],
        safety_data=drug['safety_profile'],
        literature_count=drug['supporting_papers']
    )
    drug['repurposing_score'] = score
    scored_candidates.append(drug)

ranked_candidates = sorted(
    scored_candidates,
    key=lambda x: x['repurposing_score'],
    reverse=True
)

Alternative Strategies

Strategy A: Mechanism-Based Repurposing

known_drug = "metformin"
moa = tu.tools.drugbank_get_drug_desc_pharmacology_by_moa(
    mechanism_of_action="[moa_term]"
)
similar = tu.tools.ChEMBL_search_similar_molecules(
    query=known_drug,
    similarity_threshold=70
)

Strategy B: Network-Based Repurposing

pathways = tu.tools.drugbank_get_pathways_reactions_by_drug_or_id(
    drug_name_or_drugbank_id="[drug_name]"
)
pathway_drugs = tu.tools.drugbank_get_drug_name_and_description_by_pathway_name(
    pathway_name=pathways['data'][0]['pathway_name']
)

Strategy C: Phenotype-Based Repurposing

indication_drugs = tu.tools.drugbank_get_drug_name_and_description_by_indication(
    indication="[related_indication]"
)
# Analyze adverse events as therapeutic effects (e.g., minoxidil → hair growth)
adverse_as_therapeutic = tu.tools.FAERS_search_reports_by_drug_and_reaction(
    drug_name="[drug_name]",
    limit=1000
)

Advanced Techniques

Polypharmacology-Based Repurposing

# Find drugs with multi-target activity matching disease network
targets = tu.tools.OpenTargets_get_associated_targets_by_disease_efoId(
    efoId=disease_id, limit=50
)
for drug in candidate_drugs:
    drug_targets = tu.tools.drugbank_get_targets_by_drug_name_or_drugbank_id(
        drug_name_or_drugbank_id=drug
    )
    overlap = len(set(drug_targets) & set(disease_targets))
    if overlap >= 3:
        print(f"{drug}: hits {overlap} disease targets")

Structure-Based Repurposing

cid = tu.tools.PubChem_get_CID_by_compound_name(compound_name=known_active)
similar = tu.tools.PubChem_search_compounds_by_similarity(
    cid=cid['data']['cid'], threshold=85
)
for compound in similar['data']:
    # FDA labels are keyed by drug name, not CID -- resolve the name first
    _syn = tu.tools.PubChem_get_compound_synonyms_by_CID(cid=compound['cid'])
    _name = _syn['data'][0] if isinstance(_syn, dict) and _syn.get('data') else None
    drug_info = tu.tools.FDA_get_drug_label(drug_name=_name)

AI-Powered Candidate Selection

for drug in candidates_with_smiles:
    admet = tu.tools.ADMETAI_predict_physicochemical_properties(smiles=drug['smiles'], use_cache=True)
    admet_results.append({
        'drug': drug['name'],
        'admet': admet,
        'pass': evaluate_admet_criteria(admet)
    })
viable_candidates = [r for r in admet_results if r['pass']]

Common Patterns

Pattern 1: Rapid Screening

targets = get_disease_targets(disease_id)[:10]
all_drugs = []
for target in targets:
    drugs = tu.tools.DGIdb_get_drug_gene_interactions(gene_name=target['gene_symbol'])
    all_drugs.extend(drugs)
approved_drugs = [d for d in all_drugs if d.get('approved')]

Pattern 2: Deep Dive Single Drug

drug_name = "metformin"
info = tu.tools.drugbank_get_drug_basic_info_by_drug_name_or_id(drug_name_or_drugbank_id=drug_name)
targets = tu.tools.drugbank_get_targets_by_drug_name_or_drugbank_id(drug_name_or_drugbank_id=drug_name)
indications = tu.tools.drugbank_get_indications_by_drug_name_or_drugbank_id(drug_name_or_drugbank_id=drug_name)
pharmacology = tu.tools.drugbank_get_pharmacology_by_drug_name_or_drugbank_id(drug_name_or_drugbank_id=drug_name)
interactions = tu.tools.drugbank_get_drug_interactions_by_drug_name_or_id(drug_name_or_id=drug_name)
warnings = tu.tools.FDA_get_warnings_and_cautions_by_drug_name(drug_name=drug_name)
papers = tu.tools.PubMed_search_articles(query=f"{drug_name} AND [new_disease]", max_results=100)

Pattern 3: Comparative Analysis

candidates = ["drug_a", "drug_b", "drug_c"]
comparison = []
for drug in candidates:
    data = {
        'name': drug,
        'info': tu.tools.drugbank_get_drug_basic_info_by_drug_name_or_id(drug_name_or_drugbank_id=drug),
        'safety': tu.tools.FDA_get_warnings_and_cautions_by_drug_name(drug_name=drug),
        'evidence': tu.tools.PubMed_search_articles(query=drug, max_results=10)
    }
    comparison.append(data)

Use Cases

Use Case 1: Rare Disease Repurposing

rare_disease = "Niemann-Pick disease"
related_disease = "Alzheimer's disease"  # Similar pathology
targets = tu.tools.OpenTargets_get_associated_targets_by_disease_efoId(efoId=related_disease_id)
# Find drugs for those targets, evaluate for rare disease applicability

Use Case 2: Adverse Effect as Therapeutic

# Example: Thalidomide (teratogenic) -> cancer treatment
adverse_events = tu.tools.FAERS_search_reports_by_drug_and_reaction(
    drug_name=drug, limit=1000
)
# Analyze if adverse effects beneficial in other contexts (e.g., weight loss AE -> obesity)

Use Case 3: Combination Therapy Discovery

disease_targets = tu.tools.OpenTargets_get_associated_targets_by_disease_efoId(efoId=disease_id)
primary_targets = tu.tools.drugbank_get_targets_by_drug_name_or_drugbank_id(
    drug_name_or_drugbank_id=primary_drug
)
uncovered_targets = [t for t in disease_targets if t not in primary_targets]
# Find drugs for uncovered targets

Troubleshooting

• "Disease not found": Try disease synonyms or EFO ID lookup; use broader disease categories
• "No drugs found for target": Check target name/symbol (HUGO nomenclature); expand to pathway-level drugs; consider similar targets (protein family)
• "Insufficient literature evidence": Search for drug class rather than specific drug; check preclinical/animal studies; look for mechanism papers
• "Safety data unavailable": Drug may not be FDA approved in US; check EMA or other regulatory databases; review clinical trial safety data

Drug Repurposing Reference

Detailed tool documentation and API reference for drug repurposing workflows.

ToolUniverse Tools by Category

Disease & Target Discovery Tools

OpenTargets_get_disease_id_description_by_name

disease_info = tu.tools.OpenTargets_get_disease_id_description_by_name(
    diseaseName="Alzheimer's disease"
)
# Returns: {'data': {'id': 'EFO_0000249', 'name': '...', 'description': '...'}}

Use: Initial disease lookup, get EFO ID for further queries

OpenTargets_get_associated_targets_by_disease_efoId

targets = tu.tools.OpenTargets_get_associated_targets_by_disease_efoId(
    efoId="EFO_0000249",
    limit=20
)
# Returns: List of targets with association scores

Use: Find proteins/genes associated with disease (repurposing targets)

OpenTargets_get_diseases_by_target_ensemblId

diseases = tu.tools.OpenTargets_get_diseases_by_target_ensemblId(
    ensemblId="ENSG00000012048"
)
# Returns: Diseases associated with gene/protein

Use: Reverse lookup - find diseases for drug targets (compound-based repurposing)

---

Drug Discovery Tools

drugbank_get_drug_name_and_description_by_target_name

drugs = tu.tools.drugbank_get_drug_name_and_description_by_target_name(
    target_name="BACE1"
)
# Returns: List of drugs targeting specified protein

Use: Primary tool for finding drugs by target (target-based repurposing)

drugbank_get_drug_name_and_description_by_indication

drugs = tu.tools.drugbank_get_drug_name_and_description_by_indication(
    indication="hypertension"
)
# Returns: Drugs approved for specified indication

Use: Find drugs for related indications (indication-based repurposing)

DGIdb_get_drug_gene_interactions

interactions = tu.tools.DGIdb_get_drug_gene_interactions(
    gene_name="APP"
)
# Returns: Drug-gene interactions with interaction types

Use: Alternative source for drug-target pairs, includes interaction types

DGIdb_get_gene_druggability

druggability = tu.tools.DGIdb_get_gene_druggability(
    gene_name="APOE"
)
# Returns: Druggability assessment and tier

Use: Assess if target is druggable before extensive search

ChEMBL_search_drugs

drugs = tu.tools.ChEMBL_search_drugs(
    query="kinase inhibitor",
    limit=10
)
# Returns: ChEMBL drug molecules matching query

Use: Broad drug search, alternative to DrugBank

ChEMBL_get_drug_mechanisms

mechanisms = tu.tools.ChEMBL_get_drug_mechanisms(
    chembl_id="CHEMBL941"
)
# Returns: Mechanism of action details

Use: Understand drug mechanism for repurposing rationale

---

Drug Information Tools

drugbank_get_drug_basic_info_by_drug_name_or_id

info = tu.tools.drugbank_get_drug_basic_info_by_drug_name_or_id(
    drug_name_or_drugbank_id="metformin"
)
# Returns: Basic drug info including approval status, groups, description

Use: Initial drug lookup, verify approval status

drugbank_get_indications_by_drug_name_or_drugbank_id

indications = tu.tools.drugbank_get_indications_by_drug_name_or_drugbank_id(
    drug_name_or_drugbank_id="aspirin"
)
# Returns: List of approved indications

Use: Check current uses, identify repurposing opportunities (new indications)

drugbank_get_targets_by_drug_name_or_drugbank_id

targets = tu.tools.drugbank_get_targets_by_drug_name_or_drugbank_id(
    drug_name_or_drugbank_id="imatinib"
)
# Returns: Drug targets with accessions

Use: Compound-based repurposing - find all targets for known drug

drugbank_get_pharmacology_by_drug_name_or_drugbank_id

pharmacology = tu.tools.drugbank_get_pharmacology_by_drug_name_or_drugbank_id(
    drug_name_or_drugbank_id="warfarin"
)
# Returns: Mechanism of action, pharmacodynamics, pharmacokinetics

Use: Understand drug mechanism for repurposing rationale

drugbank_get_pathways_reactions_by_drug_or_id

pathways = tu.tools.drugbank_get_pathways_reactions_by_drug_or_id(
    drug_name_or_drugbank_id="statins"
)
# Returns: Affected pathways and reactions

Use: Pathway-based repurposing - find drugs affecting similar pathways

drugbank_get_drug_name_and_description_by_pathway_name

drugs = tu.tools.drugbank_get_drug_name_and_description_by_pathway_name(
    pathway_name="cholesterol biosynthesis"
)
# Returns: Drugs affecting specified pathway

Use: Find drugs with pathway overlap (network-based repurposing)

drugbank_get_drug_desc_pharmacology_by_moa

drugs = tu.tools.drugbank_get_drug_desc_pharmacology_by_moa(
    mechanism_of_action="receptor antagonist"
)
# Returns: Drugs with specified mechanism

Use: Mechanism-based repurposing

---

Safety Assessment Tools

FDA_get_warnings_and_cautions_by_drug_name

warnings = tu.tools.FDA_get_warnings_and_cautions_by_drug_name(
    drug_name="aspirin"
)
# Returns: FDA warnings, precautions, contraindications

Use: Critical safety assessment before repurposing recommendation

FDA_get_precautions_by_drug_name

precautions = tu.tools.FDA_get_precautions_by_drug_name(
    drug_name="metformin"
)
# Returns: Precautions and special populations

Use: Identify patient populations to exclude

drugbank_get_drug_interactions_by_drug_name_or_id

interactions = tu.tools.drugbank_get_drug_interactions_by_drug_name_or_id(
    drug_name_or_id="warfarin"
)
# Returns: Drug-drug interactions

Use: Assess interaction risk for new indication (different patient population)

FAERS_search_reports_by_drug_and_reaction

reports = tu.tools.FAERS_search_reports_by_drug_and_reaction(
    drug_name="LIPITOR",
    reaction="myalgia",
    limit=100
)
# Returns: Adverse event reports

Use: Real-world safety data, specific adverse events

FAERS_count_reactions_by_drug_event

reactions = tu.tools.FAERS_count_reactions_by_drug_event(
    medicinalproduct="ASPIRIN"
)
# Returns: Counts of all reported reactions

Use: Overview of adverse event profile

FAERS_count_death_related_by_drug

deaths = tu.tools.FAERS_count_death_related_by_drug(
    medicinalproduct="FENTANYL"
)
# Returns: Death-related adverse event counts

Use: Most serious safety assessment

FAERS_count_seriousness_by_drug_event

seriousness = tu.tools.FAERS_count_seriousness_by_drug_event(
    medicinalproduct="METFORMIN"
)
# Returns: Classification of events by seriousness

Use: Stratify adverse events by severity

---

Chemical Property Tools

PubChem_get_CID_by_compound_name

cid = tu.tools.PubChem_get_CID_by_compound_name(
    compound_name="aspirin"
)
# Returns: PubChem Compound ID

Use: First step for PubChem queries

PubChem_get_compound_properties_by_CID

properties = tu.tools.PubChem_get_compound_properties_by_CID(
    cid=2244
)
# Returns: MW, formula, SMILES, LogP, H-bond donors/acceptors

Use: Assess drug-likeness, compare analogs

PubChem_search_compounds_by_similarity

similar = tu.tools.PubChem_search_compounds_by_similarity(
    smiles="CC(=O)Oc1ccccc1C(=O)O",
    threshold=85,
    limit=50
)
# Returns: Structurally similar compounds

Use: Structure-based repurposing - find approved drug analogs

PubChem_get_compound_bioactivity

bioactivity = tu.tools.PubChem_get_compound_bioactivity(
    cid=2244
)
# Returns: Active/inactive assay counts

Use: Evidence of biological activity

ChEMBL_search_activities

bioactivity = tu.tools.ChEMBL_search_activities(
    chembl_id="CHEMBL25"
)
# Returns: Detailed bioactivity data (IC50, EC50, etc.)

Use: Quantitative activity data for target validation

---

ADMET Prediction Tools

ADMETAI_predict_physicochemical_properties

admet = tu.tools.ADMETAI_predict_physicochemical_properties(
    smiles="CC(C)Cc1ccc(cc1)C(C)C(O)=O"
)
# Returns: Absorption, distribution, metabolism, excretion, toxicity predictions

Use: Predict drug-like properties for candidates, filter early

Important: Use use_cache=True for expensive ML predictions

ADMETAI_predict_toxicity

toxicity = tu.tools.ADMETAI_predict_toxicity(
    smiles=["SMILES1", "SMILES2"]
)
# Returns: Toxicity predictions (hERG, hepatotoxicity, etc.)

Use: Safety screening before clinical consideration

---

Literature Search Tools

PubMed_search_articles

papers = tu.tools.PubMed_search_articles(
    query="metformin AND Alzheimer's disease",
    max_results=50
)
# Returns: PubMed articles with PMIDs, titles, abstracts

Use: Primary literature evidence for repurposing hypothesis

EuropePMC_search_articles

papers = tu.tools.EuropePMC_search_articles(
    query="aspirin AND cancer",
    limit=50
)
# Returns: Europe PMC articles (includes preprints)

Use: Alternative/additional literature source

search_clinical_trials

trials = tu.tools.search_clinical_trials(
    condition="COVID-19",
    intervention="hydroxychloroquine"
)
# Returns: Clinical trial records

Use: Check existing clinical evidence, identify completed/ongoing trials

---

Protein/Target Information Tools

UniProt_get_entry_by_accession

protein = tu.tools.UniProt_get_entry_by_accession(
    accession="P05067"
)
# Returns: Detailed protein information

Use: Understand target biology, confirm druggability

---

Parameter Guidelines

Query Construction

Drug names:

• Use generic names: "aspirin" not "Bayer Aspirin"
• Lowercase for DrugBank: drug_name="metformin"
• UPPERCASE for FAERS: medicinalproduct="METFORMIN"

Disease names:

• Use standard terminology: "Alzheimer's disease" not "dementia"
• Try variations if not found: "breast cancer", "breast carcinoma", "mammary carcinoma"

Gene/Target names:

• HUGO nomenclature: "APP" not "Amyloid Precursor Protein"
• Protein names: "Amyloid beta A4 protein" for UniProt
• Ensembl IDs: "ENSG00000" format for OpenTargets

Result Limits

Recommended limits by tool:

• OpenTargets_get_associated_targets_by_disease_efoId: 20-50 (prioritize by score)
• DGIdb_get_drug_gene_interactions: No limit (returns all)
• ChEMBL_search_drugs: 10-20
• PubMed_search_articles: 50-100 for thorough analysis
• FAERS tools: 100-1000 (statistical analysis)
• PubChem_search_compounds_by_similarity: 50-100

Caching Strategy

Always cache:

• ADMET predictions (expensive ML)
• Literature searches (large results)
• Drug/protein detail queries (static data)

Don't cache:

• FAERS data (updated quarterly)
• Clinical trials (frequently updated)
• Real-time safety alerts

# Enable caching globally
tu = ToolUniverse(use_cache=True)

# Or per-call
result = tu.tools.ADMETAI_predict_physicochemical_properties(smiles="...", use_cache=True)

---

Data Structure Patterns

Standard Result Format

{
    'data': [...],           # Main results (list or dict)
    'meta': {...},           # Metadata (counts, pagination)
    'status': 'success',     # Status indicator
    'message': 'Optional message'
}

OpenTargets Target Object

{
    'gene_symbol': 'APP',
    'gene_name': 'Amyloid Precursor Protein',
    'ensembl_id': 'ENSG00000142192',
    'uniprot_id': 'P05067',
    'score': 0.95,           # Association score (0-1)
    'data_sources': [...]    # Evidence sources
}

DrugBank Drug Object

{
    'drugbank_id': 'DB00945',
    'name': 'Aspirin',
    'description': '...',
    'groups': ['approved', 'vet_approved'],
    'indication': '...',
    'pharmacodynamics': '...',
    'mechanism_of_action': '...',
    'targets': [...]
}

FAERS Result Format

{
    'results': [
        {
            'term': 'NAUSEA',
            'count': 12345
        },
        ...
    ],
    'meta': {
        'total': 50000,
        'disclaimer': '...'
    }
}

---

Common Patterns & Recipes

Pattern 1: Batch Target Screening

# Screen multiple targets efficiently
targets = ['APP', 'APOE', 'MAPT', 'PSEN1', 'PSEN2']

all_drugs = []
for target in targets:
    drugs = tu.tools.DGIdb_get_drug_gene_interactions(gene_name=target)
    if drugs and 'data' in drugs:
        all_drugs.extend([{**d, 'target': target} for d in drugs['data']])

# Deduplicate by drug name
unique_drugs = {d['drug_name']: d for d in all_drugs}.values()

Pattern 2: Cross-Database Validation

# Validate drug-target interaction across databases
drug = "imatinib"
target = "ABL1"

# Check DrugBank
db_targets = tu.tools.drugbank_get_targets_by_drug_name_or_drugbank_id(
    drug_name_or_drugbank_id=drug
)
db_confirms = any(t['gene_symbol'] == target for t in db_targets.get('data', []))

# Check DGIdb
dgidb = tu.tools.DGIdb_get_drug_gene_interactions(gene_name=target)
dgidb_confirms = any(d['drug_name'].lower() == drug.lower() 
                     for d in dgidb.get('data', []))

# Check ChEMBL
chembl_drugs = tu.tools.ChEMBL_search_drugs(query=drug, limit=1)
if chembl_drugs and 'data' in chembl_drugs:
    chembl_id = chembl_drugs['data'][0]['molecule_chembl_id']
    mechanisms = tu.tools.ChEMBL_get_drug_mechanisms(chembl_id=chembl_id)
    chembl_confirms = any(target in str(m) for m in mechanisms.get('data', []))

validation_score = sum([db_confirms, dgidb_confirms, chembl_confirms])
print(f"Validation: {validation_score}/3 databases confirm {drug}-{target} interaction")

Pattern 3: Safety Signal Detection

# Detect safety signals for repurposing
drug = "THALIDOMIDE"

# Get all adverse events
all_reactions = tu.tools.FAERS_count_reactions_by_drug_event(
    medicinalproduct=drug
)

# Classify by seriousness
seriousness = tu.tools.FAERS_count_seriousness_by_drug_event(
    medicinalproduct=drug
)

# Get death reports
deaths = tu.tools.FAERS_count_death_related_by_drug(
    medicinalproduct=drug
)

# Calculate safety score
total_reports = sum(r['count'] for r in all_reactions.get('results', []))
death_count = deaths.get('meta', {}).get('total', 0)
death_ratio = death_count / max(total_reports, 1)

if death_ratio > 0.01:  # >1% death reports
    print(f"⚠️ HIGH RISK: {death_ratio*100:.2f}% death ratio")
elif death_ratio > 0.001:
    print(f"⚠️ MODERATE RISK: {death_ratio*100:.2f}% death ratio")
else:
    print(f"✓ ACCEPTABLE RISK: {death_ratio*100:.2f}% death ratio")

Pattern 4: Literature Evidence Scoring

# Score repurposing candidate by literature evidence
drug = "metformin"
disease = "cancer"

query = f"{drug} AND {disease}"

# Search multiple sources
pubmed = tu.tools.PubMed_search_articles(query=query, max_results=100)
pmc = tu.tools.EuropePMC_search_articles(query=query, limit=100)
trials = tu.tools.search_clinical_trials(condition=disease, intervention=drug)

# Count evidence types
review_count = sum(1 for p in pubmed.get('data', []) 
                   if 'review' in p.get('title', '').lower())
rct_count = sum(1 for p in pubmed.get('data', []) 
                if 'randomized' in p.get('title', '').lower())
trial_count = len(trials.get('data', []))

# Calculate evidence score
evidence_score = (
    len(pubmed.get('data', [])) * 1 +      # 1 point per paper
    review_count * 3 +                      # 3 points per review
    rct_count * 5 +                         # 5 points per RCT
    trial_count * 10                        # 10 points per trial
)

print(f"Evidence Score: {evidence_score}")
print(f"  Papers: {len(pubmed.get('data', []))}")
print(f"  Reviews: {review_count}")
print(f"  RCTs: {rct_count}")
print(f"  Trials: {trial_count}")

---

Troubleshooting

Issue: "Disease not found"

Solutions: 1. Try disease synonyms 2. Use broader disease categories 3. Search OMIM or other disease databases 4. Use EFO ID directly if known

Issue: "No drugs found for target"

Causes:

• Target not druggable
• Target name incorrect
• Limited database coverage

Solutions: 1. Check gene symbol (HUGO nomenclature) 2. Try protein name instead 3. Expand to pathway-level drugs 4. Check target druggability first

Issue: "Drug name not recognized"

Solutions: 1. Try generic name (not brand) 2. Try different capitalization 3. Use DrugBank ID if known 4. Search PubChem first

Issue: "API rate limits"

Solutions: 1. Enable caching: use_cache=True 2. Add delays between calls 3. Use batch operations 4. Register for API keys (NCBI, etc.)

Issue: "Empty results for FAERS"

Causes:

• Drug name spelling
• Insufficient reports
• Wrong capitalization

Solutions: 1. Use UPPERCASE: "ASPIRIN" not "aspirin" 2. Try brand names 3. Check OpenFDA directly

Issue: "Slow performance"

Solutions: 1. Enable caching globally 2. Limit result counts 3. Load specific tool categories 4. Use batch operations 5. Disable validation after testing

---

Best Practices Summary

1. Start with approved drugs - Known safety profiles 2. Validate across databases - Cross-reference DrugBank, DGIdb, ChEMBL 3. Check safety first - FDA warnings before detailed analysis 4. Use caching - Save API calls and time 5. Limit initial searches - Expand only promising candidates 6. Document evidence - Keep track of supporting papers 7. Consider mechanism - Biological plausibility critical 8. Assess patient populations - Different from original indication 9. Check IP landscape - Patent status for new indications 10. Think commercially - Market size and unmet need

---

Additional Resources

• ToolUniverse Documentation: https://zitniklab.hms.harvard.edu/ToolUniverse/
• Tool Catalog: https://zitniklab.hms.harvard.edu/ToolUniverse/tools/
• DrugBank: https://go.drugbank.com/
• OpenTargets: https://platform.opentargets.org/
• ChEMBL: https://www.ebi.ac.uk/chembl/
• OpenFDA: https://open.fda.gov/
• PubMed: https://pubmed.ncbi.nlm.nih.gov/

Drug Repurposing Report Template

Output Format

Present results as ranked candidates:

## Drug Repurposing Analysis: [Disease Name]

### Top 10 Repurposing Candidates

#### 1. [Drug Name] (Score: 87/100)

**Current Indications**: [list approved uses]
**Proposed Indication**: [new disease/condition]
**Repurposing Rationale**: Targets [gene/protein] with high association to disease

**Evidence Summary**:
- Target association score: 0.85
- Approval status: FDA approved (safer profile)
- Literature support: 23 papers, 4 clinical trials
- Safety profile: No black box warnings

**Mechanism**: [Brief mechanism description]

**Next Steps**:
- Phase II trial feasibility assessment
- Patient population identification
- Dosing optimization study

**Key Papers**:
1. Smith et al. 2024 - Clinical efficacy in similar condition
2. Jones et al. 2023 - Mechanism validation

---

#### 2. [Drug Name] (Score: 79/100)
[Similar structure...]

### Supporting Analysis

**Target Network**: [visualization or description]
**Pathway Overlap**: [affected pathways]
**Safety Considerations**: [major concerns]
**Development Timeline**: [estimated phases]

Scoring Criteria

Target Association (0-40 points):

• Strong genetic evidence: 40
• Moderate association: 25
• Pathway-level evidence: 15
• Weak/predicted: 5

Safety Profile (0-30 points):

• FDA approved: 20
• Phase III: 15
• Phase II: 10
• Phase I: 5
• No black box warning: +10
• Known serious AE: -10

Literature Evidence (0-20 points):

• Clinical trials: 5 points each (max 15)
• Preclinical studies: 1 point each (max 10)
• Case reports: 0.5 points each (max 5)

Drug Properties (0-10 points):

• High bioavailability: 5
• Good BBB penetration (if CNS): 5
• Low toxicity predictions: 5

Drug Repurposing: Strategies, Patterns, and Advanced Techniques

Complete code implementations for all repurposing strategies.

---

Phase 1: Disease & Target Analysis

# 1.1 Get disease information
disease_info = tu.tools.OpenTargets_get_disease_id_description_by_name(diseaseName="[disease_name]")

# 1.2 Find associated targets
targets = tu.tools.OpenTargets_get_associated_targets_by_disease_efoId(
    efoId=disease_info['data']['id'], limit=20
)

# 1.3 Get target details
for target in targets['data'][:10]:
    details = tu.tools.UniProt_get_entry_by_accession(accession=target['uniprot_id'])

---

Phase 2: Drug Discovery

for target in targets['data'][:10]:
    drugbank_results = tu.tools.drugbank_get_drug_name_and_description_by_target_name(
        target_name=target['gene_symbol'])
    dgidb_results = tu.tools.DGIdb_get_drug_gene_interactions(gene_name=target['gene_symbol'])
    chembl_results = tu.tools.ChEMBL_search_drugs(query=target['gene_symbol'], limit=10)

# Get drug details
for drug_name in unique_drugs:
    drug_info = tu.tools.drugbank_get_drug_basic_info_by_drug_name_or_id(drug_name_or_drugbank_id=drug_name)
    indications = tu.tools.drugbank_get_indications_by_drug_name_or_drugbank_id(drug_name_or_drugbank_id=drug_name)
    pharmacology = tu.tools.drugbank_get_pharmacology_by_drug_name_or_drugbank_id(drug_name_or_drugbank_id=drug_name)

---

Phase 3: Safety & Feasibility

for drug in top_candidates:
    warnings = tu.tools.FDA_get_warnings_and_cautions_by_drug_name(drug_name=drug['name'])
    adverse_events = tu.tools.FAERS_search_reports_by_drug_and_reaction(drug_name=drug['name'], limit=100)
    interactions = tu.tools.drugbank_get_drug_interactions_by_drug_name_or_id(drug_name_or_id=drug['name'])
    if 'smiles' in drug:
        admet = tu.tools.ADMETAI_predict_physicochemical_properties(smiles=drug['smiles'], use_cache=True)

---

Phase 4: Literature Evidence

for drug in top_candidates:
    query = f"{drug['name']} AND {disease_name}"
    pubmed_results = tu.tools.PubMed_search_articles(query=query, max_results=50)
    pmc_results = tu.tools.EuropePMC_search_articles(query=query, limit=50)
    trials = tu.tools.search_clinical_trials(condition=disease_name, intervention=drug['name'])

---

Phase 5: Scoring

def score_repurposing_candidate(drug, target_score, safety_data, literature_count):
    """Score drug repurposing candidate (0-100)."""
    score = 0
    score += min(target_score * 40, 40)  # Target association (0-40)
    if drug['approval_status'] == 'approved':
        score += 20
    elif drug['approval_status'] == 'clinical':
        score += 10
    if not safety_data.get('black_box_warning'):
        score += 10
    score += min(literature_count / 5 * 20, 20)  # Literature (0-20)
    if drug.get('bioavailability') == 'high':
        score += 10  # Drug properties (0-10)
    return score

---

Alternative Strategy A: Mechanism-Based Repurposing

known_drug = "metformin"
moa = tu.tools.drugbank_get_drug_desc_pharmacology_by_moa(mechanism_of_action="[moa_term]")
similar = tu.tools.ChEMBL_search_similar_molecules(query=known_drug, similarity_threshold=70)

---

Alternative Strategy B: Network-Based Repurposing

pathways = tu.tools.drugbank_get_pathways_reactions_by_drug_or_id(drug_name_or_drugbank_id="[drug_name]")
pathway_drugs = tu.tools.drugbank_get_drug_name_and_description_by_pathway_name(
    pathway_name=pathways['data'][0]['pathway_name'])

---

Alternative Strategy C: Phenotype-Based Repurposing

indication_drugs = tu.tools.drugbank_get_drug_name_and_description_by_indication(indication="[related_indication]")
# Analyze adverse events as therapeutic effects (e.g., minoxidil hair growth)
adverse_as_therapeutic = tu.tools.FAERS_search_reports_by_drug_and_reaction(drug_name="[drug_name]", limit=1000)

---

Common Patterns

Pattern 1: Rapid Screening

targets = get_disease_targets(disease_id)[:10]
all_drugs = []
for target in targets:
    drugs = tu.tools.DGIdb_get_drug_gene_interactions(gene_name=target['gene_symbol'])
    all_drugs.extend(drugs)
approved_drugs = [d for d in all_drugs if d.get('approved')]

Pattern 2: Deep Dive Single Drug

drug_name = "metformin"
info = tu.tools.drugbank_get_drug_basic_info_by_drug_name_or_id(drug_name_or_drugbank_id=drug_name)
targets = tu.tools.drugbank_get_targets_by_drug_name_or_drugbank_id(drug_name_or_drugbank_id=drug_name)
indications = tu.tools.drugbank_get_indications_by_drug_name_or_drugbank_id(drug_name_or_drugbank_id=drug_name)
pharmacology = tu.tools.drugbank_get_pharmacology_by_drug_name_or_drugbank_id(drug_name_or_drugbank_id=drug_name)
interactions = tu.tools.drugbank_get_drug_interactions_by_drug_name_or_id(drug_name_or_id=drug_name)
warnings = tu.tools.FDA_get_warnings_and_cautions_by_drug_name(drug_name=drug_name)
papers = tu.tools.PubMed_search_articles(query=f"{drug_name} AND [new_disease]", max_results=100)

Pattern 3: Comparative Analysis

candidates = ["drug_a", "drug_b", "drug_c"]
comparison = []
for drug in candidates:
    data = {
        'name': drug,
        'info': tu.tools.drugbank_get_drug_basic_info_by_drug_name_or_id(drug_name_or_drugbank_id=drug),
        'safety': tu.tools.FDA_get_warnings_and_cautions_by_drug_name(drug_name=drug),
        'evidence': tu.tools.PubMed_search_articles(query=drug, max_results=10)
    }
    comparison.append(data)

---

Advanced Techniques

Polypharmacology-Based Repurposing

Find drugs with multi-target activity matching disease network:

targets = tu.tools.OpenTargets_get_associated_targets_by_disease_efoId(efoId=disease_id, limit=50)
for drug in candidate_drugs:
    drug_targets = tu.tools.drugbank_get_targets_by_drug_name_or_drugbank_id(drug_name_or_drugbank_id=drug)
    overlap = len(set(drug_targets) & set(disease_targets))
    if overlap >= 3:
        print(f"{drug}: hits {overlap} disease targets")

Structure-Based Repurposing

Find structurally similar approved drugs:

cid = tu.tools.PubChem_get_CID_by_compound_name(compound_name=known_active)
similar = tu.tools.PubChem_search_compounds_by_similarity(cid=cid['data']['cid'], threshold=85)
for compound in similar['data']:
    # FDA labels are keyed by drug name, not CID -- resolve the name first
    _syn = tu.tools.PubChem_get_compound_synonyms_by_CID(cid=compound['cid'])
    _name = _syn['data'][0] if isinstance(_syn, dict) and _syn.get('data') else None
    drug_info = tu.tools.FDA_get_drug_label(drug_name=_name)

AI-Powered Candidate Selection

for drug in candidates_with_smiles:
    admet = tu.tools.ADMETAI_predict_physicochemical_properties(smiles=drug['smiles'], use_cache=True)
    # Keep only drugs passing ADMET criteria

---

Example Use Cases

Rare Disease Repurposing

Strategy: Find drugs targeting same pathways as related common diseases.

Adverse Effect as Therapy

Example: Thalidomide (teratogenic) -> cancer treatment. Analyze FAERS for beneficial adverse effects.

Combination Therapy Discovery

Find drugs covering targets not addressed by existing therapy.