geney 1.3.65__py2.py3-none-any.whl → 1.3.67__py2.py3-none-any.whl

geney/splicing_utils.py

@@ -166,7 +166,7 @@ def run_splicing_engine(seq, engine='spliceai'):
     match engine:
         case 'spliceai':
             from .spliceai_utils import sai_predict_probs, sai_models
-            donor_probs, acceptor_probs = sai_predict_probs(seq, models=sai_models)
+            acceptor_probs, donor_probs = sai_predict_probs(seq, models=sai_models)
 
         case 'pangolin':
             from .pangolin_utils import pangolin_predict_probs, pang_models
@@ -214,6 +214,7 @@ def find_transcript_splicing(transcript, engine: str = 'spliceai') -> Tuple[Dict
     # Create dictionaries and sort them by probability in descending order
     donor_probs = dict(sorted(((i, p) for i, p in zip(ref_indices, ref_seq_donor_probs)),
                        key=lambda item: item[1], reverse=True))
+
     acceptor_probs = dict(sorted(((i, p) for i, p in zip(ref_indices, ref_seq_acceptor_probs)),
                           key=lambda item: item[1], reverse=True))
 
@@ -332,8 +333,8 @@ def find_transcript_missplicing_seqs(ref_seq, var_seq, donors, acceptors, thresh
     if ref_seq.seq == var_seq.seq:
         return Missplicing({'missed_acceptors': {}, 'missed_donors': {}, 'discovered_acceptors': {}, 'discovered_donors': {}})
 
-    ref_seq_acceptor_probs, ref_seq_donor_probs = run_splicing_engine(ref_seq.seq, engine)
-    mut_seq_acceptor_probs, mut_seq_donor_probs = run_splicing_engine(var_seq.seq, engine)
+    ref_seq_donor_probs, ref_seq_acceptor_probs = run_splicing_engine(ref_seq.seq, engine)
+    mut_seq_donor_probs, mut_seq_acceptor_probs = run_splicing_engine(var_seq.seq, engine)
     ref_indices = ref_seq.indices[5000:-5000]
     mut_indices = var_seq.indices[5000:-5000]
     visible_donors = np.intersect1d(donors, ref_indices)
@@ -462,49 +463,199 @@ def process_pairwise_epistasis(mids, engine='pangolin', fprint=False, db=None):
     return pd.concat(results)
 
 
+# def process_pairwise_epistasis_explicit(mid, engine='spliceai'):
+#     donor_probs, acceptor_probs = {}, {}
+#     lower_pos, upper_pos = int(mid.split(':')[2]), int(mid.split(':')[6])
+#     g = Gene.from_file(mid.split(':')[0]).transcript().generate_pre_mrna()
+#     print(g.rev)
+#     if g.rev:
+#         lower_pos, upper_pos, factor = upper_pos, lower_pos, -1
+#     else:
+#         factor = 1
+#
+#     lb, ub = lower_pos - (factor * 7500), upper_pos + (factor * 7500)
+#
+#     for m in ['wild_type'] + mid.split('|') + [mid]:
+#         transcript = g.clone().pre_mrna
+#         if m != 'wild_type':
+#             mutations = [MutSeqMat.from_mutid(cm) for cm in m.split('|')]
+#             if g.rev:
+#                 mutations = [m.reverse_complement() for m in mutations]
+#             for mutation in mutations:
+#                 if mutation in transcript:
+#                     transcript.mutate(mutation, inplace=True)
+#
+#         donors, acceptors = find_transcript_splicing(transcript[lb:ub], engine=engine)
+#         donor_probs[m] = donors
+#         acceptor_probs[m] = acceptors
+#
+#     acceptors = pd.DataFrame.from_dict(acceptor_probs).T
+#     donors = pd.DataFrame.from_dict(donor_probs).T
+#
+#     acceptors = acceptors.map(lambda x: 0 if x < 0.01 else round(x, 2) if isinstance(x, (int, float)) else x).round(2)
+#     acceptors = acceptors.loc[:, acceptors.nunique() > 1]
+#     donors = donors.map(lambda x: 0 if abs(x) < 0.01 else round(x, 2) if isinstance(x, (int, float)) else x).round(2)
+#     donors = donors.loc[:, donors.nunique() > 1]
+#
+#     donors.loc['residual'] = (donors.iloc[3] - donors.iloc[0]) - (
+#                 (donors.iloc[1] - donors.iloc[0]) + (donors.iloc[2] - donors.iloc[0]))
+#     acceptors.loc['residual'] = (acceptors.iloc[3] - acceptors.iloc[0]) - (
+#                 (acceptors.iloc[1] - acceptors.iloc[0]) + (acceptors.iloc[2] - acceptors.iloc[0]))
+#
+#     donors = donors.loc[:, donors.loc['residual'].abs() > 0.1]
+#     acceptors = acceptors.loc[:, acceptors.loc['residual'].abs() > 0.1]
+#
+#     return acceptors, donors
 def process_pairwise_epistasis_explicit(mid, engine='spliceai'):
+    """
+    Process pairwise epistasis for a given mutation identifier (mid).
+
+    This function:
+      1. Parses the input 'mid' to extract positions and loads a gene/transcript.
+      2. Adjusts bounds based on strand orientation (reverse or forward).
+      3. Iterates over several mutation scenarios (wild type, individual mutations, and combined mutations),
+         cloning and mutating the transcript as needed.
+      4. Computes splicing probabilities (donors and acceptors) for a transcript segment.
+      5. Stores these probabilities in dictionaries and converts them to DataFrames.
+      6. Applies rounding, thresholding (setting very small numbers to 0), and filters out columns with little variation.
+      7. Adds new features:
+           - residual: difference between total change and the sum of two individual deviations.
+           - deviation1: change from baseline (row 0) to row 1.
+           - deviation2: change from baseline (row 0) to row 2.
+           - total_deviation: change from baseline (row 0) to row 3.
+         and filters columns with insignificant residual (absolute value <= 0.1).
+
+    The new features persist in the returned DataFrames.
+
+    Returns:
+      acceptors_df (pd.DataFrame): Processed acceptor probabilities with extra features.
+      donors_df (pd.DataFrame): Processed donor probabilities with extra features.
+    """
+    import pandas as pd
+
     donor_probs, acceptor_probs = {}, {}
-    lower_pos, upper_pos = int(mid.split(':')[2]), int(mid.split(':')[6])
-    g = Gene.from_file(mid.split(':')[0]).transcript().generate_pre_mrna()
-    print(g.rev)
+
+    # Parse the mid string: assume the format is "file:...:lower_pos:...:upper_pos:..."
+    parts = mid.split(':')
+    lower_pos, upper_pos = int(parts[2]), int(parts[6])
+
+    # Load gene and its transcript (as pre-mRNA)
+    g = Gene.from_file(parts[0]).transcript().generate_pre_mrna()
+
+    # If gene is on the reverse strand, swap positions and set factor to -1.
     if g.rev:
-        lower_pos, upper_pos, factor = upper_pos, lower_pos, -1
+        lower_pos, upper_pos = upper_pos, lower_pos
+        factor = -1
     else:
         factor = 1
 
+    # Define bounds with a 7500 bp padding on both sides.
     lb, ub = lower_pos - (factor * 7500), upper_pos + (factor * 7500)
-
-    for m in ['wild_type'] + mid.split('|') + [mid]:
+    # Ensure lb and ub fall within the transcript indices.
+    if lb not in g.pre_mrna.indices:
+        lb = g.pre_mrna.indices.max() if g.rev else g.pre_mrna.indices.min()
+    if ub not in g.pre_mrna.indices:
+        ub = g.pre_mrna.indices.min() if g.rev else g.pre_mrna.indices.max()
+
+    # Process each mutation scenario:
+    #   - 'wild_type' (no mutations)
+    #   - individual mutations (split by '|')
+    #   - a scenario with all mutations (mid itself)
+    scenarios = ['wild_type'] + mid.split('|') + [mid]
+    for m in scenarios:
+        # Clone the transcript for independent mutation processing.
         transcript = g.clone().pre_mrna
         if m != 'wild_type':
+            # Parse mutations from the scenario string.
             mutations = [MutSeqMat.from_mutid(cm) for cm in m.split('|')]
+            # If the gene is reversed, get the reverse complement of each mutation.
             if g.rev:
-                mutations = [m.reverse_complement() for m in mutations]
+                mutations = [mutation.reverse_complement() for mutation in mutations]
+            # Apply each mutation (if present) to the transcript.
             for mutation in mutations:
                 if mutation in transcript:
                     transcript.mutate(mutation, inplace=True)
 
+        # Calculate splicing probabilities on the transcript slice defined by lb:ub.
         donors, acceptors = find_transcript_splicing(transcript[lb:ub], engine=engine)
         donor_probs[m] = donors
         acceptor_probs[m] = acceptors
 
-    acceptors = pd.DataFrame.from_dict(acceptor_probs).T
-    donors = pd.DataFrame.from_dict(donor_probs).T
-
-    acceptors = acceptors.map(lambda x: 0 if x < 0.01 else round(x, 2) if isinstance(x, (int, float)) else x).round(2)
-    acceptors = acceptors.loc[:, acceptors.nunique() > 1]
-    donors = donors.map(lambda x: 0 if abs(x) < 0.01 else round(x, 2) if isinstance(x, (int, float)) else x).round(2)
-    donors = donors.loc[:, donors.nunique() > 1]
-
-    donors.loc['residual'] = (donors.iloc[3] - donors.iloc[0]) - (
-                (donors.iloc[1] - donors.iloc[0]) + (donors.iloc[2] - donors.iloc[0]))
-    acceptors.loc['residual'] = (acceptors.iloc[3] - acceptors.iloc[0]) - (
-                (acceptors.iloc[1] - acceptors.iloc[0]) + (acceptors.iloc[2] - acceptors.iloc[0]))
-
-    donors = donors.loc[:, donors.loc['residual'].abs() > 0.1]
-    acceptors = acceptors.loc[:, acceptors.loc['residual'].abs() > 0.1]
+    # Convert the results to DataFrames (each scenario as a row)
+    acceptors_df = pd.DataFrame.from_dict(acceptor_probs, orient='index')
+    donors_df = pd.DataFrame.from_dict(donor_probs, orient='index')
+
+    # Apply rounding and thresholding:
+    #   - For acceptors: set values < 0.01 to 0, else round to 2 decimals.
+    #   - For donors: use absolute value threshold.
+    acceptors_df = acceptors_df.map(
+        lambda x: 0 if isinstance(x, (int, float)) and x < 0.01 else round(x, 2) if isinstance(x, (int, float)) else x
+    ).round(2)
+    donors_df = donors_df.map(
+        lambda x: 0 if isinstance(x, (int, float)) and abs(x) < 0.01 else round(x, 2) if isinstance(x,
+                                                                                                    (int, float)) else x
+    ).round(2)
+
+    # Drop columns that do not vary (only one unique value).
+    acceptors_df = acceptors_df.loc[:, acceptors_df.nunique() > 1]
+    donors_df = donors_df.loc[:, donors_df.nunique() > 1]
+
+    # Further filter acceptors: keep only columns where the value in the second row is < 0.1.
+    # (Assumes that the second row (iloc[1]) represents a specific measure you wish to threshold.)
+    acceptors_df = acceptors_df.loc[:, acceptors_df.iloc[1] < 0.1]
+
+    # Helper function: add new features (residual and deviations) and filter based on residual.
+    def add_features_and_filter(df):
+        if df.shape[1] == 0:
+            return df  # Nothing to process if no columns remain.
+        # Compute the residual:
+        #   (row 3 - row 0) minus ( (row 1 - row 0) + (row 2 - row 0) )
+        df.loc['residual'] = (df.iloc[3] - df.iloc[0]) - ((df.iloc[1] - df.iloc[0]) + (df.iloc[2] - df.iloc[0]))
+        # Keep only columns where the absolute residual exceeds 0.1.
+        # df = df.loc[:, df.loc['residual'].abs() > 0.1]
+        # if df.shape[1] == 0:
+        #     return df
+        # Compute deviations relative to the baseline (row 0)
+        df.loc['deviation1'] = df.iloc[1] - df.iloc[0]
+        df.loc['deviation2'] = df.iloc[2] - df.iloc[0]
+        df.loc['total_deviation'] = df.iloc[3] - df.iloc[0]
+        return df
+
+    # Apply the feature computation to both donors and acceptors.
+    donors_df = add_features_and_filter(donors_df)
+    acceptors_df = add_features_and_filter(acceptors_df)
+
+    # Return the processed dataframes with the new features persisting.
+    donors_df.loc['site_type', :] = 0
+    acceptors_df.loc['site_type', :] = 1
+    df = pd.concat([acceptors_df, donors_df], axis=1)
+
+    mask = df.apply(
+        lambda col: (
+                (abs(col['residual']) > 0.1) and
+                (abs(col['deviation1'] + col['deviation2']) < 0.1)
+        ),
+        axis=0
+    )
+    df.loc['synergistic'] = 0
+    df.loc['synergistic', mask] = 1
+
+    mask = df.apply(
+        lambda col: (
+                (abs(col['residual']) > 0.1) and
+                (abs(col['total_deviation']) <= 0.25)
+        ),
+        axis=0
+    )
 
-    return acceptors, donors
+    df.loc['antagonistic'] = 0
+    df.loc['antagonistic', mask] = 1
+    df.loc['mut_id'] = mid
+    df.loc['engine'] = engine
+    df.loc['site'] = df.columns
+    df = df.rename({mid: 'epistasis', mid.split('|')[0]: 'cv1', mid.split('|')[1]: 'cv2'})
+    df = df.T
+    return df
 
 
 class Missplicing:

{geney-1.3.65.dist-info → geney-1.3.67.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: geney
-Version: 1.3.65
+Version: 1.3.67
 Summary: A Python package for gene expression modeling.
 Home-page: https://github.com/nicolaslynn/geney
 Author: Nicolas Lynn

{geney-1.3.65.dist-info → geney-1.3.67.dist-info}/RECORD

@@ -16,7 +16,7 @@ geney/pangolin_utils.py,sha256=9jdBXlOcRaUdfi-UpUxHA0AkTMZkUF-Lt7HVZ1nEm3s,2973
 geney/power_utils.py,sha256=MehZFUdkJ2EFUot709yPEDxSkXmH5XevMebX2HD768A,7330
 geney/seqmat_utils.py,sha256=wzb3PX5it5bpIFQvcxyzlxfhoJTbHHbsjg0rzh05iVs,19753
 geney/spliceai_utils.py,sha256=tVY0T6F6l3fNoaktpn7Kq0oH5ZM0ThFYt9nPi_lfakw,3077
-geney/splicing_utils.py,sha256=W-N0ENZJv1PdnVlHuaN_2az2-7Zl6cHYe_CYR1G41U4,40766
+geney/splicing_utils.py,sha256=afnTncU607dLLfMz4Z1pj06dkO03u6Wt43cNBu7pEjU,47647
 geney/survival_utils.py,sha256=KnAzEviMuXh6SnVXId9PgsFLSbgkduTvYoIthxN7FPA,6886
 geney/tcga_utils.py,sha256=D_BNHm-D_K408dlcJm3hzH2c6QNFjQsKvUcOPiQRk7g,17612
 geney/tis_utils.py,sha256=la0CZroaKe5RgAyFd4Bf_DqQncklWgAY2823xVst98o,7813
@@ -25,7 +25,7 @@ geney/translation_initiation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NM
 geney/translation_initiation/tis_utils.py,sha256=AF3siFjuQH-Rs44EV-80zHdbxRMvN4woLFSHroWIETc,4448
 geney/translation_initiation/resources/kozak_pssm.json,sha256=pcd0Olziutq-6H3mFWDCD9cujQ_AlZO-iiOvBl82hqE,1165
 geney/translation_initiation/resources/tis_regressor_model.joblib,sha256=IXb4DUDhJ5rBDKcqMk9zE3ECTZZcdj7Jixz3KpoZ7OA,2592025
-geney-1.3.65.dist-info/METADATA,sha256=L-doIh0XdJuxs4gg1Dhs5mLoa_1zI8_bboq4cnlfvfA,990
-geney-1.3.65.dist-info/WHEEL,sha256=AHX6tWk3qWuce7vKLrj7lnulVHEdWoltgauo8bgCXgU,109
-geney-1.3.65.dist-info/top_level.txt,sha256=O-FuNUMb5fn9dhZ-dYCgF0aZtfi1EslMstnzhc5IIVo,6
-geney-1.3.65.dist-info/RECORD,,
+geney-1.3.67.dist-info/METADATA,sha256=Quhz5RoxRIVxv0VlKP9NhmIdy0NzcOi3viZ51WIBzm8,990
+geney-1.3.67.dist-info/WHEEL,sha256=AHX6tWk3qWuce7vKLrj7lnulVHEdWoltgauo8bgCXgU,109
+geney-1.3.67.dist-info/top_level.txt,sha256=O-FuNUMb5fn9dhZ-dYCgF0aZtfi1EslMstnzhc5IIVo,6
+geney-1.3.67.dist-info/RECORD,,