geney 1.4.40__tar.gz → 1.4.45__tar.gz

{geney-1.4.40 → geney-1.4.45}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geney
-Version: 1.4.40
+Version: 1.4.45
 Summary: A Python package for gene expression modeling.
 Home-page: https://github.com/nicolaslynn/geney
 Author: Nicolas Lynn
@@ -18,9 +18,8 @@ Requires-Dist: pandas==2.1.4
 Requires-Dist: biopython>=1.81
 Requires-Dist: matplotlib
 Requires-Dist: seaborn
-Requires-Dist: tensorflow>=2.8.0
-Requires-Dist: keras>=2.8.0
 Requires-Dist: torch
+Requires-Dist: openspliceai
 Requires-Dist: seqmat
 Dynamic: author
 Dynamic: author-email

{geney-1.4.40 → geney-1.4.45}/geney/__init__.py

@@ -4,12 +4,17 @@ from .engines import (
     sai_predict_probs,
     run_spliceai_seq,
     run_splicing_engine,
+    predict_splicing,
+    adjoin_splicing_outcomes,
 )
 from .transcripts import TranscriptLibrary
-from .splicing_table import adjoin_splicing_outcomes
 from .splice_graph import SpliceSimulator
-from .pipelines import oncosplice_pipeline_single_transcript
-from .samples import *
+from .pipelines import (
+    oncosplice_pipeline,
+    oncosplice_top_isoform,
+    max_splicing_delta,
+    oncosplice_pipeline_single_transcript,  # backwards compat
+)
 
 __all__ = [
     "Mutation",
@@ -18,8 +23,16 @@ __all__ = [
     "sai_predict_probs",
     "run_spliceai_seq",
     "run_splicing_engine",
-    "TranscriptLibrary",
+    "predict_splicing",
     "adjoin_splicing_outcomes",
+    "TranscriptLibrary",
     "SpliceSimulator",
+    "oncosplice_pipeline",
+    "oncosplice_top_isoform",
+    "max_splicing_delta",
     "oncosplice_pipeline_single_transcript",
-]
+]
+
+
+mut_id = 'KRAS:12:25227343:G:T'
+epistasis_id = 'KRAS:12:25227343:G:T|KRAS:12:25227344:A:T'

geney-1.4.45/geney/engines.py

@@ -0,0 +1,354 @@
+# oncosplice/engines.py
+from __future__ import annotations
+
+from typing import Dict, List, Tuple, Optional, Union
+import numpy as np
+
+# Lazy-loaded model containers (loaded automatically on first use)
+_pang_models = None
+_pang_device = None
+
+
+def _get_torch_device():
+    """Get the best available device for PyTorch."""
+    import sys
+    import torch
+
+    if sys.platform == 'darwin' and torch.backends.mps.is_available():
+        try:
+            torch.tensor([1.0], device="mps")
+            return torch.device("mps")
+        except RuntimeError:
+            return torch.device("cpu")
+    elif torch.cuda.is_available():
+        return torch.device("cuda")
+    return torch.device("cpu")
+
+
+def _load_pangolin_models():
+    """Lazy load Pangolin models."""
+    global _pang_models, _pang_device
+
+    if _pang_models is not None:
+        return _pang_models
+
+    import torch
+    from pkg_resources import resource_filename
+    from pangolin.model import Pangolin, L, W, AR
+
+    _pang_device = _get_torch_device()
+    print(f"Pangolin loading to {_pang_device}...")
+
+    _pang_models = []
+    pang_model_nums = [0, 1, 2, 3, 4, 5, 6, 7]
+
+    for i in pang_model_nums:
+        for j in range(1, 6):
+            try:
+                model = Pangolin(L, W, AR).to(_pang_device)
+                model_path = resource_filename("pangolin", f"models/final.{j}.{i}.3")
+                weights = torch.load(model_path, weights_only=True, map_location=_pang_device)
+                model.load_state_dict(weights)
+                model.eval()
+                _pang_models.append(model)
+            except Exception as e:
+                print(f"Warning: Failed to load Pangolin model {j}.{i}: {e}")
+
+    print(f"Pangolin loaded ({len(_pang_models)} models).")
+    return _pang_models
+
+
+_OPENSPLICEAI_MODEL_DIR = None
+
+def _get_openspliceai_model_dir() -> str:
+    """Return the path to the OpenSpliceAI MANE 10000nt model directory."""
+    global _OPENSPLICEAI_MODEL_DIR
+    if _OPENSPLICEAI_MODEL_DIR is not None:
+        return _OPENSPLICEAI_MODEL_DIR
+
+    import os
+
+    # Models ship inside the package at geney/models/openspliceai-mane/10000nt
+    pkg_dir = os.path.dirname(os.path.abspath(__file__))
+    default = os.path.join(pkg_dir, 'models', 'openspliceai-mane', '10000nt')
+    default = os.path.normpath(default)
+
+    _OPENSPLICEAI_MODEL_DIR = os.environ.get('OPENSPLICEAI_MODEL_DIR', default)
+    return _OPENSPLICEAI_MODEL_DIR
+
+
+def pang_one_hot_encode(seq: str) -> np.ndarray:
+    """One-hot encode DNA sequence for Pangolin model."""
+    if not isinstance(seq, str):
+        raise TypeError(f"Expected string, got {type(seq).__name__}")
+
+    IN_MAP = np.asarray([[0, 0, 0, 0],  # N
+                         [1, 0, 0, 0],  # A
+                         [0, 1, 0, 0],  # C
+                         [0, 0, 1, 0],  # G
+                         [0, 0, 0, 1]]) # T
+
+    valid_chars = set('ACGTN')
+    if not all(c.upper() in valid_chars for c in seq):
+        raise ValueError("Sequence contains invalid characters")
+
+    seq = seq.upper().replace('A', '1').replace('C', '2')
+    seq = seq.replace('G', '3').replace('T', '4').replace('N', '0')
+
+    seq_array = np.asarray(list(map(int, list(seq))))
+    return IN_MAP[seq_array.astype('int8')]
+
+
+
+
+def pangolin_predict_probs(seq: str, models: list = None) -> Tuple[List[float], List[float]]:
+    """Predict splice site probabilities using Pangolin.
+
+    Pangolin outputs shape (1, 12, seq_len) where:
+    - 12 channels = 4 tissues × 3 prediction types
+    - For each tissue: [site_usage, acceptor_gain, donor_gain] or similar
+
+    We aggregate by taking max across tissues.
+    """
+    import torch
+
+    if models is None:
+        models = _load_pangolin_models()
+
+    if not models:
+        raise ValueError("No Pangolin models loaded")
+
+    x = pang_one_hot_encode(seq)
+    x = torch.tensor(x.T[None, :, :], dtype=torch.float32, device=_pang_device)
+
+    preds = []
+    with torch.no_grad():
+        for model in models:
+            pred = model(x)
+            preds.append(pred.cpu().numpy())
+
+    y = np.mean(preds, axis=0)  # Shape: (1, 12, seq_len)
+
+    # Pangolin has 12 channels organized as:
+    # Indices 0,3,6,9: site usage scores for 4 tissues
+    # Indices 1,4,7,10: acceptor gain scores for 4 tissues
+    # Indices 2,5,8,11: donor gain scores for 4 tissues
+    # Take max across the 4 tissues for each type
+
+    # Acceptor: max of channels 1, 4, 7, 10
+    acceptor_channels = y[0, [1, 4, 7, 10], :]  # (4, seq_len)
+    acceptor_probs = np.max(acceptor_channels, axis=0).tolist()
+
+    # Donor: max of channels 2, 5, 8, 11
+    donor_channels = y[0, [2, 5, 8, 11], :]  # (4, seq_len)
+    donor_probs = np.max(donor_channels, axis=0).tolist()
+
+    return donor_probs, acceptor_probs
+
+
+def sai_predict_probs(seq: str) -> Tuple[np.ndarray, np.ndarray]:
+    """Predict acceptor and donor probabilities using OpenSpliceAI.
+
+    Uses the OpenSpliceAI predict() function which handles encoding,
+    windowing, ensemble averaging, and softmax internally.
+
+    Returns (acceptor_probs, donor_probs) as numpy arrays matching the
+    full input sequence length.
+    """
+    from openspliceai.predict.predict import predict
+    import io, sys
+
+    model_dir = _get_openspliceai_model_dir()
+
+    # Suppress OpenSpliceAI's verbose print output
+    _stdout = sys.stdout
+    sys.stdout = io.StringIO()
+    try:
+        y = predict(seq, model_dir, flanking_size=10000)  # (seq_len, 3)
+    finally:
+        sys.stdout = _stdout
+
+    y = y.numpy()
+    return y[:, 1], y[:, 2]  # acceptor, donor
+
+
+def run_spliceai_seq(
+    seq: str,
+    indices: Union[List[int], np.ndarray],
+    threshold: float = 0.0,
+) -> Tuple[Dict[int, float], Dict[int, float]]:
+    """Run SpliceAI on seq and return donor/acceptor sites above threshold."""
+    if len(indices) != len(seq):
+        raise ValueError(f"indices length ({len(indices)}) must match sequence length ({len(seq)})")
+
+    acc_probs, don_probs = sai_predict_probs(seq)
+    acceptor = {pos: p for pos, p in zip(indices, acc_probs) if p >= threshold}
+    donor = {pos: p for pos, p in zip(indices, don_probs) if p >= threshold}
+    return donor, acceptor
+
+
+def _generate_random_sequence(length: int) -> str:
+    """Generate a random DNA sequence of given length."""
+    import random
+    return ''.join(random.choices('ACGT', k=length))
+
+
+def run_splicing_engine(
+    seq: Optional[str] = None,
+    engine: str = "spliceai",
+) -> Tuple[List[float], List[float]]:
+    """Run specified splicing engine to predict splice site probabilities."""
+    if seq is None:
+        seq = _generate_random_sequence(15_001)
+
+    if not isinstance(seq, str) or not seq:
+        raise ValueError("Sequence must be a non-empty string")
+
+    valid_chars = set("ACGTN")
+    if not all(c.upper() in valid_chars for c in seq):
+        raise ValueError("Sequence contains invalid nucleotides")
+
+    match engine:
+        case "spliceai":
+            acc, don = sai_predict_probs(seq)
+            return don.tolist(), acc.tolist()
+        case "pangolin":
+            return pangolin_predict_probs(seq)
+        case _:
+            raise ValueError(f"Engine '{engine}' not implemented. Available: 'spliceai', 'pangolin'")
+
+
+# ------------------------------------------------------------------------------
+# Higher-level prediction utilities (formerly in splicing_table.py)
+# ------------------------------------------------------------------------------
+
+def predict_splicing(s, position: int, engine: str = 'spliceai', context: int = 7500):
+    """
+    Predict splicing probabilities at a given position using the specified engine.
+
+    Args:
+        s: Sequence object with .seq, .index, .clone(), .rev attributes
+        position: The genomic position to predict splicing probabilities for.
+        engine: The prediction engine to use. Supported: 'spliceai', 'pangolin'.
+        context: The length of the target central region (default: 7500).
+
+    Returns:
+        pd.DataFrame with position index and columns: donor_prob, acceptor_prob, nucleotides
+    """
+    import pandas as pd
+
+    if position < s.index.min() or position > s.index.max():
+        raise ValueError(f"Position {position} is outside sequence bounds [{s.index.min()}, {s.index.max()}]")
+
+    target = s.clone(position - context, position + context)
+
+    if len(target.seq) == 0:
+        raise ValueError(f"No sequence data found around position {position} with context {context}")
+
+    seq, indices = target.seq, target.index
+
+    if len(indices) == 0:
+        raise ValueError(f"No indices found in sequence around position {position}")
+
+    rel_pos = np.abs(indices - position).argmin()
+    left_missing, right_missing = max(0, context - rel_pos), max(0, context - (len(seq) - rel_pos))
+
+    if left_missing > 0 or right_missing > 0:
+        step = -1 if s.rev else 1
+
+        if left_missing > 0:
+            left_pad = np.arange(indices[0] - step * left_missing, indices[0], step)
+        else:
+            left_pad = np.array([], dtype=indices.dtype)
+
+        if right_missing > 0:
+            right_pad = np.arange(indices[-1] + step, indices[-1] + step * (right_missing + 1), step)
+        else:
+            right_pad = np.array([], dtype=indices.dtype)
+
+        seq = 'N' * left_missing + seq + 'N' * right_missing
+        indices = np.concatenate([left_pad, indices, right_pad])
+
+    donor_probs, acceptor_probs = run_splicing_engine(seq=seq, engine=engine)
+
+    seq = seq[5000:-5000]
+    indices = indices[5000:-5000]
+    expected_len = len(seq)
+
+    if len(donor_probs) != expected_len:
+        if len(donor_probs) > expected_len:
+            offset = (len(donor_probs) - expected_len) // 2
+            donor_probs = donor_probs[offset:offset + expected_len]
+            acceptor_probs = acceptor_probs[offset:offset + expected_len]
+        else:
+            pad_len = expected_len - len(donor_probs)
+            donor_probs = donor_probs + [0.0] * pad_len
+            acceptor_probs = acceptor_probs + [0.0] * pad_len
+
+    df = pd.DataFrame({
+        'position': indices,
+        'donor_prob': donor_probs,
+        'acceptor_prob': acceptor_probs,
+        'nucleotides': list(seq)
+    }).set_index('position').round(3)
+
+    df.attrs['name'] = s.name
+    return df
+
+
+def adjoin_splicing_outcomes(
+    splicing_predictions: Dict[str, 'pd.DataFrame'],
+    transcript: Optional[object] = None,
+) -> 'pd.DataFrame':
+    """
+    Combine splicing predictions for multiple mutations into a multi-index DataFrame.
+
+    Args:
+        splicing_predictions: {label -> DF with 'donor_prob','acceptor_prob','nucleotides'}
+        transcript: optional transcript (must have .acceptors, .donors, .rev)
+    """
+    import pandas as pd
+
+    if not splicing_predictions:
+        raise ValueError("splicing_predictions cannot be empty")
+
+    dfs = []
+    for label, df in splicing_predictions.items():
+        if not isinstance(df, pd.DataFrame):
+            raise TypeError(f"Expected DataFrame for '{label}', got {type(df).__name__}")
+
+        required_cols = ["donor_prob", "acceptor_prob", "nucleotides"]
+        missing = [c for c in required_cols if c not in df.columns]
+        if missing:
+            raise ValueError(f"DataFrame for '{label}' missing required columns: {missing}")
+
+        var_df = df.rename(
+            columns={
+                "donor_prob": ("donors", f"{label}_prob"),
+                "acceptor_prob": ("acceptors", f"{label}_prob"),
+                "nucleotides": ("nts", f"{label}"),
+            }
+        )
+        dfs.append(var_df)
+
+    try:
+        full_df = pd.concat(dfs, axis=1)
+    except Exception as e:
+        raise ValueError(f"Failed to concatenate DataFrames: {e}") from e
+
+    if not isinstance(full_df.columns, pd.MultiIndex):
+        full_df.columns = pd.MultiIndex.from_tuples(full_df.columns)
+
+    if transcript is not None:
+        full_df[("acceptors", "annotated")] = full_df.apply(
+            lambda row: row.name in transcript.acceptors, axis=1
+        )
+        full_df[("donors", "annotated")] = full_df.apply(
+            lambda row: row.name in transcript.donors, axis=1
+        )
+        full_df.sort_index(axis=1, level=0, inplace=True)
+        full_df.sort_index(ascending=not transcript.rev, inplace=True)
+    else:
+        full_df.sort_index(axis=1, level=0, inplace=True)
+
+    return full_df

{geney-1.4.40 → geney-1.4.45}/geney/oncosplice.py

@@ -388,9 +388,10 @@ class Oncosplice:
         analysis_dict = {
             'reference_protein': self.reference_protein,
             'variant_protein': self.variant_protein,
+            'aligned_reference_protein': self.alignment.seqA,
+            'aligned_variant_protein': self.alignment.seqB,
             'reference_length': len(self.reference_protein),
             'variant_length': len(self.variant_protein),
-            # 'alignment_length': len(self.alignment.seqA),
             'oncosplice_score': self.score,
             'percentile': self.percentile,
             'number_of_deletions': len(self.deletions),

geney-1.4.45/geney/pipelines.py

@@ -0,0 +1,139 @@
+# oncosplice/pipelines.py
+from __future__ import annotations
+
+from datetime import datetime
+import pandas as pd
+
+from seqmat import Gene
+
+from .splice_graph import SpliceSimulator
+from .transcripts import TranscriptLibrary
+from .variants import MutationalEvent
+from .Oncosplice import Oncosplice
+
+
+def oncosplice_pipeline(
+    mut_id: str,
+    transcript_id: str | None = None,
+    splicing_engine: str = "spliceai",
+    organism: str = "hg38",
+) -> pd.DataFrame:
+    """
+    Run the full oncosplice pipeline for a mutation.
+
+    Returns DataFrame with all viable isoforms and their oncosplice scores.
+    """
+    m = MutationalEvent(mut_id)
+    assert m.compatible(), "Mutations in event are incompatible"
+
+    reference_transcript = (
+        Gene.from_file(m.gene, organism=organism)
+        .transcript(transcript_id)
+        .generate_pre_mrna()
+        .generate_mature_mrna()
+        .generate_protein()
+    )
+
+    tl = TranscriptLibrary(reference_transcript, m)
+    central_pos = m.central_position
+
+    tl.predict_splicing(central_pos, engine=splicing_engine, inplace=True)
+    splicing_results = tl.get_event_columns("event")
+
+    ss = SpliceSimulator(
+        splicing_results, tl.event, feature="event", max_distance=100_000_000
+    )
+
+    base_report = pd.Series({
+        "mut_id": mut_id,
+        "gene": m.gene,
+        "transcript_id": reference_transcript.transcript_id,
+        "primary_transcript": reference_transcript.primary_transcript,
+        "splicing_engine": splicing_engine,
+        "central_position": central_pos,
+        "mutation_count": len(m.positions),
+        "time_of_execution": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+    })
+
+    ss_metadata = ss.report(central_pos)
+    rows = []
+    for variant_transcript, isoform_metadata in ss.get_viable_transcripts(metadata=True):
+        onco = Oncosplice(
+            reference_transcript.protein,
+            variant_transcript.protein,
+            reference_transcript.cons_vector,
+        )
+        rows.append(
+            pd.concat([
+                base_report,
+                ss_metadata,
+                isoform_metadata,
+                pd.Series({
+                    "reference_mrna": reference_transcript.mature_mrna.seq,
+                    "variant_mrna": variant_transcript.mature_mrna.seq,
+                }),
+                onco.get_analysis_series(),
+            ])
+        )
+
+    return pd.DataFrame(rows)
+
+
+def oncosplice_top_isoform(
+    mut_id: str,
+    transcript_id: str | None = None,
+    splicing_engine: str = "spliceai",
+    organism: str = "hg38",
+) -> pd.Series | None:
+    """
+    Get the most likely non-reference isoform for a mutation.
+
+    Returns Series with full oncosplice analysis, or None if no missplicing detected.
+    """
+    df = oncosplice_pipeline(mut_id, transcript_id, splicing_engine, organism)
+
+    if df.empty:
+        return None
+
+    variants = df[df["summary"] != "-"]
+
+    if variants.empty:
+        return None
+
+    return variants.iloc[0]
+
+
+def max_splicing_delta(
+    mut_id: str,
+    transcript_id: str | None = None,
+    splicing_engine: str = "spliceai",
+    organism: str = "hg38",
+) -> float:
+    """
+    Get the maximum splice site probability change for a mutation.
+    """
+    m = MutationalEvent(mut_id)
+    assert m.compatible(), "Mutations in event are incompatible"
+
+    reference_transcript = (
+        Gene.from_file(m.gene, organism=organism)
+        .transcript(transcript_id)
+        .generate_pre_mrna()
+        .generate_mature_mrna()
+        .generate_protein()
+    )
+
+    tl = TranscriptLibrary(reference_transcript, m)
+    splicing_results = tl.predict_splicing(
+        m.central_position, engine=splicing_engine, inplace=True
+    ).get_event_columns("event")
+
+    ss = SpliceSimulator(
+        splicing_results, tl.event, feature="event", max_distance=100_000_000
+    )
+
+    return ss.max_splicing_delta("event_prob")
+
+
+# Keep old name for backwards compatibility
+oncosplice_pipeline_single_transcript = oncosplice_pipeline