@bgicli/bgicli 2.1.1 → 2.2.0

package/data/skills/bio-systems-biology-context-specific-models/SKILL.md

@@ -0,0 +1,241 @@
+<!--
+# COPYRIGHT NOTICE
+# This file is part of the "Universal Biomedical Skills" project.
+# Copyright (c) 2026 MD BABU MIA, PhD <md.babu.mia@mssm.edu>
+# All Rights Reserved.
+#
+# This code is proprietary and confidential.
+# Unauthorized copying of this file, via any medium is strictly prohibited.
+#
+# Provenance: Authenticated by MD BABU MIA
+
+-->
+
+---
+name: bio-systems-biology-context-specific-models
+description: Build tissue and condition-specific metabolic models using GIMME, iMAT, and INIT algorithms with expression data constraints. Create models that reflect cell-type specific metabolism. Use when building tissue-specific metabolic models or integrating transcriptomics with FBA.
+tool_type: python
+primary_tool: cobrapy
+measurable_outcome: Execute skill workflow successfully with valid output within 15 minutes.
+allowed-tools:
+  - read_file
+  - run_shell_command
+---
+
+# Context-Specific Models
+
+## GIMME Algorithm
+
+```python
+import cobra
+import numpy as np
+
+def gimme(model, expression_data, threshold=0.25, required_growth=0.1):
+    '''Gene Inactivity Moderated by Metabolism and Expression (GIMME)
+
+    Creates context-specific model by:
+    1. Penalizing flux through lowly-expressed reactions
+    2. Requiring minimum biomass production
+
+    Args:
+        expression_data: dict mapping gene_id -> expression value
+        threshold: Expression percentile below which genes are inactive
+                  0.25 = bottom 25% considered inactive
+        required_growth: Minimum growth rate to maintain
+
+    Returns:
+        Context-specific model with inactive reactions constrained
+    '''
+    # Calculate expression threshold
+    values = list(expression_data.values())
+    cutoff = np.percentile(values, threshold * 100)
+
+    # Identify lowly-expressed genes
+    low_expressed = {g for g, v in expression_data.items() if v < cutoff}
+
+    # Create context model
+    context_model = model.copy()
+
+    # Set minimum growth constraint
+    context_model.reactions.get_by_id('Biomass_Ecoli_core').lower_bound = required_growth
+
+    # Minimize flux through reactions with low-expressed genes
+    for rxn in context_model.reactions:
+        genes = {g.id for g in rxn.genes}
+        if genes and genes.issubset(low_expressed):
+            # This reaction is likely inactive - constrain it
+            rxn.upper_bound = min(rxn.upper_bound, 1.0)
+            rxn.lower_bound = max(rxn.lower_bound, -1.0)
+
+    return context_model
+```
+
+## iMAT Algorithm
+
+```python
+def imat(model, expression_data, high_threshold=0.75, low_threshold=0.25):
+    '''Integrative Metabolic Analysis Tool (iMAT)
+
+    Maximizes agreement between flux activity and expression:
+    - Highly expressed reactions should carry flux
+    - Lowly expressed reactions should have zero flux
+
+    More sophisticated than GIMME - uses MILP optimization.
+    '''
+    from cobra import Reaction
+
+    # Classify reactions by expression
+    high_expr_rxns = []
+    low_expr_rxns = []
+
+    for rxn in model.reactions:
+        if rxn.genes:
+            # Aggregate gene expression (use max for OR, min for AND)
+            gene_expr = [expression_data.get(g.id, 0.5) for g in rxn.genes]
+            rxn_expr = max(gene_expr)  # Simplified OR logic
+
+            if rxn_expr > np.percentile(list(expression_data.values()), high_threshold * 100):
+                high_expr_rxns.append(rxn.id)
+            elif rxn_expr < np.percentile(list(expression_data.values()), low_threshold * 100):
+                low_expr_rxns.append(rxn.id)
+
+    # Create MILP to maximize consistent reactions
+    # This is a simplified version - full iMAT uses binary variables
+    context_model = model.copy()
+
+    # Force flux through highly expressed reactions
+    for rxn_id in high_expr_rxns:
+        rxn = context_model.reactions.get_by_id(rxn_id)
+        rxn.lower_bound = max(rxn.lower_bound, 0.01)
+
+    # Constrain lowly expressed reactions
+    for rxn_id in low_expr_rxns:
+        rxn = context_model.reactions.get_by_id(rxn_id)
+        rxn.upper_bound = min(rxn.upper_bound, 0.1)
+        rxn.lower_bound = max(rxn.lower_bound, -0.1)
+
+    return context_model, high_expr_rxns, low_expr_rxns
+```
+
+## Expression Data Integration
+
+```python
+def load_expression_data(filepath, gene_col='gene_id', expr_col='TPM'):
+    '''Load and normalize expression data
+
+    Accepts:
+    - RNA-seq counts (TPM, FPKM)
+    - Microarray intensities
+    - Proteomics abundances
+
+    Returns dict mapping gene_id -> normalized expression
+    '''
+    import pandas as pd
+
+    df = pd.read_csv(filepath)
+
+    # Log-transform if needed (high dynamic range)
+    expr = df[expr_col].values
+    if expr.max() / expr.mean() > 100:
+        expr = np.log2(expr + 1)
+
+    # Normalize to 0-1 range
+    expr_norm = (expr - expr.min()) / (expr.max() - expr.min())
+
+    return dict(zip(df[gene_col], expr_norm))
+
+
+def aggregate_gene_expression(model, expression_data, method='max'):
+    '''Map gene expression to reactions
+
+    Methods:
+    - 'max': Use maximum gene expression (OR logic)
+    - 'min': Use minimum gene expression (AND logic)
+    - 'mean': Average across genes
+
+    For GPR: (A and B) or C
+    - min(A, B) for the complex
+    - max(complex, C) for the alternatives
+    '''
+    rxn_expression = {}
+
+    for rxn in model.reactions:
+        if not rxn.genes:
+            rxn_expression[rxn.id] = 0.5  # Default for non-enzymatic
+            continue
+
+        gene_expr = [expression_data.get(g.id, 0.5) for g in rxn.genes]
+
+        if method == 'max':
+            rxn_expression[rxn.id] = max(gene_expr)
+        elif method == 'min':
+            rxn_expression[rxn.id] = min(gene_expr)
+        else:
+            rxn_expression[rxn.id] = np.mean(gene_expr)
+
+    return rxn_expression
+```
+
+## Tissue-Specific Human Models
+
+```python
+def create_tissue_model(generic_model, gtex_expression, tissue='liver'):
+    '''Create tissue-specific model from GTEx expression data
+
+    GTEx provides median TPM for 54 human tissues.
+    Download from: https://gtexportal.org/home/datasets
+    '''
+    import pandas as pd
+
+    # Load GTEx median expression
+    gtex = pd.read_csv(gtex_expression, sep='\t')
+
+    # Extract tissue column
+    tissue_col = [c for c in gtex.columns if tissue.lower() in c.lower()][0]
+    expression = dict(zip(gtex['gene_id'], gtex[tissue_col]))
+
+    # Apply GIMME
+    tissue_model = gimme(generic_model, expression, threshold=0.25)
+
+    return tissue_model
+```
+
+## Validate Context Model
+
+```python
+def validate_context_model(original, context, expression_data):
+    '''Compare original and context-specific models
+
+    Checks:
+    1. Growth capability maintained
+    2. Inactive reactions reduced
+    3. Active reactions maintained
+    '''
+    # Growth comparison
+    orig_growth = original.optimize().objective_value
+    context_growth = context.optimize().objective_value
+
+    # Count constrained reactions
+    constrained = 0
+    for rxn in context.reactions:
+        orig_rxn = original.reactions.get_by_id(rxn.id)
+        if rxn.upper_bound < orig_rxn.upper_bound:
+            constrained += 1
+
+    return {
+        'original_growth': orig_growth,
+        'context_growth': context_growth,
+        'growth_ratio': context_growth / orig_growth,
+        'constrained_reactions': constrained,
+        'total_reactions': len(context.reactions)
+    }
+```
+
+## Related Skills
+
+- systems-biology/flux-balance-analysis - Run FBA on context models
+- differential-expression/de-results - Generate expression data
+- single-cell/clustering - Cell-type specific expression
+
+
+<!-- AUTHOR_SIGNATURE: 9a7f3c2e-MD-BABU-MIA-2026-MSSM-SECURE -->

package/data/skills/bio-systems-biology-flux-balance-analysis/SKILL.md

@@ -0,0 +1,206 @@
+<!--
+# COPYRIGHT NOTICE
+# This file is part of the "Universal Biomedical Skills" project.
+# Copyright (c) 2026 MD BABU MIA, PhD <md.babu.mia@mssm.edu>
+# All Rights Reserved.
+#
+# This code is proprietary and confidential.
+# Unauthorized copying of this file, via any medium is strictly prohibited.
+#
+# Provenance: Authenticated by MD BABU MIA
+
+-->
+
+---
+name: bio-systems-biology-flux-balance-analysis
+description: Perform flux balance analysis (FBA) and flux variability analysis (FVA) on genome-scale metabolic models using COBRApy. Predict growth rates, metabolic fluxes, and optimal resource utilization. Use when predicting metabolic phenotypes or optimizing flux distributions.
+tool_type: python
+primary_tool: cobrapy
+measurable_outcome: Execute skill workflow successfully with valid output within 15 minutes.
+allowed-tools:
+  - read_file
+  - run_shell_command
+---
+
+# Flux Balance Analysis
+
+## Load Models
+
+```python
+import cobra
+
+# Load built-in test models
+model = cobra.io.load_model('textbook')  # E. coli core (95 reactions)
+model = cobra.io.load_model('iJO1366')   # Full E. coli (2583 reactions)
+
+# Load from file
+model = cobra.io.read_sbml_model('model.xml')
+model = cobra.io.load_json_model('model.json')
+
+# BiGG models available at: http://bigg.ucsd.edu/models
+```
+
+## Basic FBA
+
+```python
+import cobra
+
+model = cobra.io.load_model('textbook')
+
+# Run FBA (maximizes objective function, usually biomass)
+solution = model.optimize()
+
+# Growth rate interpretation:
+# >0.8 h^-1: Fast growth (rich media)
+# 0.3-0.8 h^-1: Moderate growth
+# <0.3 h^-1: Slow growth or stress
+# 0: No growth (lethal condition or missing nutrients)
+print(f'Growth rate: {solution.objective_value:.4f} h^-1')
+print(f'Status: {solution.status}')
+
+# Access flux values
+for rxn in model.reactions[:5]:
+    print(f'{rxn.id}: {solution.fluxes[rxn.id]:.4f}')
+```
+
+## Set Media Conditions
+
+```python
+def set_minimal_media(model, carbon_source='EX_glc__D_e', carbon_uptake=10):
+    '''Configure minimal media conditions
+
+    Args:
+        carbon_source: Exchange reaction ID for carbon source
+        carbon_uptake: Maximum uptake rate (mmol/gDW/h)
+                      Typical glucose uptake: 10-20 mmol/gDW/h
+    '''
+    # Close all exchange reactions
+    for rxn in model.exchanges:
+        rxn.lower_bound = 0  # No uptake
+
+    # Open essential exchanges
+    essential = ['EX_o2_e', 'EX_h2o_e', 'EX_h_e', 'EX_nh4_e',
+                 'EX_pi_e', 'EX_so4_e', 'EX_k_e', 'EX_mg2_e']
+
+    for ex_id in essential:
+        if ex_id in model.reactions:
+            model.reactions.get_by_id(ex_id).lower_bound = -1000
+
+    # Set carbon source
+    if carbon_source in model.reactions:
+        model.reactions.get_by_id(carbon_source).lower_bound = -carbon_uptake
+
+    return model
+
+
+# Example: Compare growth on different carbon sources
+carbon_sources = ['EX_glc__D_e', 'EX_ac_e', 'EX_succ_e']
+for cs in carbon_sources:
+    with model:
+        set_minimal_media(model, carbon_source=cs)
+        sol = model.optimize()
+        print(f'{cs}: Growth = {sol.objective_value:.4f}')
+```
+
+## Flux Variability Analysis (FVA)
+
+```python
+from cobra.flux_analysis import flux_variability_analysis
+
+# FVA finds the range of flux values for each reaction
+# while maintaining optimal (or near-optimal) growth
+
+# Standard FVA (at 100% optimum)
+fva = flux_variability_analysis(model)
+
+# FVA at 90% of optimal growth
+# fraction_of_optimum=0.9: allows 10% suboptimal solutions
+# This reveals alternative optimal flux distributions
+fva = flux_variability_analysis(model, fraction_of_optimum=0.9)
+
+# FVA for specific reactions
+rxns_of_interest = ['PFK', 'PGI', 'GAPD']
+fva = flux_variability_analysis(model, reaction_list=rxns_of_interest)
+
+# Identify essential vs flexible reactions
+fva['essential'] = (fva['minimum'] > 0) | (fva['maximum'] < 0)
+fva['flexible'] = fva['maximum'] - fva['minimum'] > 0.01
+
+print(fva[['minimum', 'maximum', 'essential', 'flexible']])
+```
+
+## Production Envelope
+
+```python
+from cobra.flux_analysis import production_envelope
+
+# Analyze tradeoff between growth and product secretion
+# Useful for metabolic engineering to find optimal conditions
+
+prod_env = production_envelope(
+    model,
+    reactions=['EX_ac_e'],  # Product (acetate)
+    objective='Biomass_Ecoli_core',
+    points=20
+)
+
+# prod_env is a DataFrame with:
+# - EX_ac_e: acetate production rate
+# - Biomass_Ecoli_core: growth rate at that production level
+print(prod_env)
+```
+
+## Phenotype Phase Plane
+
+```python
+from cobra.flux_analysis import phenotype_phase_plane
+
+# Analyze growth across two varying conditions
+# Typically oxygen and carbon uptake
+
+ppp = phenotype_phase_plane(
+    model,
+    variables=['EX_glc__D_e', 'EX_o2_e'],  # X and Y axes
+    points=10
+)
+
+# Returns growth rate as function of both uptake rates
+# Useful for identifying metabolic modes (aerobic vs anaerobic)
+```
+
+## Parsimonious FBA (pFBA)
+
+```python
+from cobra.flux_analysis import pfba
+
+# pFBA minimizes total flux while achieving optimal growth
+# Produces more biologically realistic flux distributions
+
+pfba_solution = pfba(model)
+
+# Compare total flux
+fba_total = sum(abs(model.optimize().fluxes))
+pfba_total = sum(abs(pfba_solution.fluxes))
+print(f'FBA total flux: {fba_total:.1f}')
+print(f'pFBA total flux: {pfba_total:.1f}')
+```
+
+## Loopless FBA
+
+```python
+from cobra.flux_analysis import loopless_solution
+
+# Remove thermodynamically infeasible loops
+# Important for realistic flux predictions
+
+solution = loopless_solution(model)
+```
+
+## Related Skills
+
+- systems-biology/gene-essentiality - In silico gene knockouts
+- systems-biology/context-specific-models - Tissue-specific FBA
+- metabolomics/pathway-mapping - Integrate metabolomics data
+
+
+<!-- AUTHOR_SIGNATURE: 9a7f3c2e-MD-BABU-MIA-2026-MSSM-SECURE -->

package/data/skills/bio-systems-biology-gene-essentiality/SKILL.md

@@ -0,0 +1,235 @@
+<!--
+# COPYRIGHT NOTICE
+# This file is part of the "Universal Biomedical Skills" project.
+# Copyright (c) 2026 MD BABU MIA, PhD <md.babu.mia@mssm.edu>
+# All Rights Reserved.
+#
+# This code is proprietary and confidential.
+# Unauthorized copying of this file, via any medium is strictly prohibited.
+#
+# Provenance: Authenticated by MD BABU MIA
+
+-->
+
+---
+name: bio-systems-biology-gene-essentiality
+description: Perform in silico gene knockout analysis and synthetic lethality screens using COBRApy single and double deletions. Predict essential genes and identify synthetic lethal pairs for drug target discovery. Use when identifying essential genes or finding synthetic lethal drug targets.
+tool_type: python
+primary_tool: cobrapy
+measurable_outcome: Execute skill workflow successfully with valid output within 15 minutes.
+allowed-tools:
+  - read_file
+  - run_shell_command
+---
+
+# Gene Essentiality Analysis
+
+## Single Gene Knockouts
+
+```python
+import cobra
+from cobra.flux_analysis import single_gene_deletion
+
+model = cobra.io.load_model('textbook')
+
+# Perform all single gene deletions
+# Returns growth rate with each gene knocked out
+deletion_results = single_gene_deletion(model)
+
+# deletion_results is a DataFrame with:
+# - ids: gene IDs (frozenset)
+# - growth: growth rate after deletion
+# - status: solver status
+
+# Find essential genes (no growth when deleted)
+# Essential: growth < 0.01 (allowing for numerical tolerance)
+essential = deletion_results[deletion_results['growth'] < 0.01]
+print(f'Essential genes: {len(essential)}')
+```
+
+## Classify Gene Essentiality
+
+```python
+def classify_gene_essentiality(model, growth_threshold=0.1):
+    '''Classify genes by their impact on growth
+
+    Categories:
+    - Essential: Growth < 1% of WT (lethal)
+    - Growth-reducing: 1-50% of WT
+    - Non-essential: >50% of WT
+    '''
+    from cobra.flux_analysis import single_gene_deletion
+
+    # Get wild-type growth
+    wt_growth = model.optimize().objective_value
+
+    # Run deletions
+    results = single_gene_deletion(model)
+    results['relative_growth'] = results['growth'] / wt_growth
+
+    # Classify
+    results['classification'] = 'non-essential'
+    results.loc[results['relative_growth'] < 0.5, 'classification'] = 'growth-reducing'
+    results.loc[results['relative_growth'] < 0.01, 'classification'] = 'essential'
+
+    classification_counts = results['classification'].value_counts()
+    return results, classification_counts
+```
+
+## Synthetic Lethality
+
+```python
+from cobra.flux_analysis import double_gene_deletion
+
+# Warning: O(n^2) complexity - can be slow for large models
+# For full E. coli (~1500 genes), this is ~1M combinations
+
+# Subset to genes of interest
+genes_of_interest = [g.id for g in model.genes[:50]]
+
+# Run double deletions
+double_results = double_gene_deletion(
+    model,
+    gene_list1=genes_of_interest,
+    gene_list2=genes_of_interest
+)
+
+# Find synthetic lethal pairs
+# Synthetic lethal: double KO is lethal when singles are viable
+
+# Get single deletion results first
+single_results = single_gene_deletion(model, gene_list=genes_of_interest)
+single_dict = {list(ids)[0]: growth for ids, growth in
+               zip(single_results['ids'], single_results['growth'])}
+```
+
+## Identify Synthetic Lethal Pairs
+
+```python
+def find_synthetic_lethal_pairs(model, genes=None, growth_threshold=0.01):
+    '''Find synthetic lethal gene pairs
+
+    Synthetic lethality criteria:
+    - Single KO of gene A: viable (growth > threshold)
+    - Single KO of gene B: viable (growth > threshold)
+    - Double KO of A+B: lethal (growth < threshold)
+
+    Useful for:
+    - Drug combination targets
+    - Genetic interaction networks
+    - Backup pathway identification
+    '''
+    from cobra.flux_analysis import single_gene_deletion, double_gene_deletion
+
+    if genes is None:
+        genes = [g.id for g in model.genes]
+
+    # Single deletions
+    single = single_gene_deletion(model, gene_list=genes)
+    viable_singles = single[single['growth'] > growth_threshold]
+    viable_genes = [list(ids)[0] for ids in viable_singles['ids']]
+
+    # Double deletions (only for viable single KOs)
+    double = double_gene_deletion(model, gene_list1=viable_genes,
+                                  gene_list2=viable_genes)
+
+    # Find synthetic lethal pairs
+    sl_pairs = []
+    for _, row in double.iterrows():
+        genes_in_pair = list(row['ids'])
+        if len(genes_in_pair) == 2 and row['growth'] < growth_threshold:
+            sl_pairs.append({
+                'gene1': genes_in_pair[0],
+                'gene2': genes_in_pair[1],
+                'double_ko_growth': row['growth']
+            })
+
+    return sl_pairs
+```
+
+## Condition-Specific Essentiality
+
+```python
+def compare_essentiality_conditions(model, conditions):
+    '''Compare gene essentiality across conditions
+
+    Args:
+        conditions: dict mapping condition name to media setup function
+
+    Example:
+        conditions = {
+            'aerobic': lambda m: m.reactions.EX_o2_e.lower_bound = -20,
+            'anaerobic': lambda m: m.reactions.EX_o2_e.lower_bound = 0
+        }
+    '''
+    from cobra.flux_analysis import single_gene_deletion
+
+    essentiality_by_condition = {}
+
+    for condition_name, setup_func in conditions.items():
+        with model:
+            setup_func(model)
+            results = single_gene_deletion(model)
+            essential = set(list(ids)[0] for ids in
+                          results[results['growth'] < 0.01]['ids'])
+            essentiality_by_condition[condition_name] = essential
+
+    # Find condition-specific essential genes
+    all_essential = set.union(*essentiality_by_condition.values())
+    core_essential = set.intersection(*essentiality_by_condition.values())
+    condition_specific = {cond: ess - core_essential
+                         for cond, ess in essentiality_by_condition.items()}
+
+    return {
+        'core_essential': core_essential,
+        'condition_specific': condition_specific,
+        'total_essential': len(all_essential)
+    }
+```
+
+## Robustness Analysis
+
+```python
+def gene_robustness_analysis(model, gene_id, flux_levels=10):
+    '''Analyze growth as function of gene expression level
+
+    Instead of complete knockout, simulate reduced expression
+    by constraining reactions associated with the gene.
+    '''
+    from cobra.flux_analysis import flux_variability_analysis
+
+    gene = model.genes.get_by_id(gene_id)
+
+    # Get reactions associated with this gene
+    rxns = list(gene.reactions)
+
+    results = []
+    for level in [i/flux_levels for i in range(flux_levels + 1)]:
+        with model:
+            for rxn in rxns:
+                # Get FVA bounds at wild-type
+                fva = flux_variability_analysis(model, reaction_list=[rxn])
+                max_flux = fva.loc[rxn.id, 'maximum']
+                min_flux = fva.loc[rxn.id, 'minimum']
+
+                # Constrain to fraction of wild-type
+                rxn.upper_bound = max_flux * level
+                rxn.lower_bound = min_flux * level
+
+            sol = model.optimize()
+            results.append({
+                'expression_level': level,
+                'growth': sol.objective_value
+            })
+
+    return results
+```
+
+## Related Skills
+
+- systems-biology/flux-balance-analysis - Base FBA methods
+- pathway-analysis/go-enrichment - Enrich essential gene sets
+- clinical-databases/variant-prioritization - Link to disease genes
+
+
+<!-- AUTHOR_SIGNATURE: 9a7f3c2e-MD-BABU-MIA-2026-MSSM-SECURE -->