geney 1.4.21__py2.py3-none-any.whl → 1.4.23__py2.py3-none-any.whl

geney/utils/SeqMats.py

@@ -89,6 +89,25 @@ class SeqMat:
 
         self.insertion_counters = defaultdict(int)
 
+
+    def __len__(self) -> int:
+        return int(self.seq_array["valid_mask"].sum())
+
+    def __repr__(self):
+        return f"<SeqMat: {self.seq}>"
+
+    def __str__(self):
+        return self.seq
+
+    def get_metadata(self) -> dict:
+        """Retrieve all metadata as a dictionary."""
+        return {
+            "name": self.name,
+            "source": self.source,
+            "version": self.version,
+            "notes": self.notes
+        }
+
     @property
     def seq(self) -> str:
         return self.seq_array['nt'][self.seq_array['valid_mask']].tobytes().decode()
@@ -101,6 +120,26 @@ class SeqMat:
     def conservation(self) -> np.ndarray:
         return self.seq_array['cons'][self.seq_array['valid_mask']]
 
+    @property
+    def max_index(self) -> float:
+        return self.seq_array["index"].max()
+
+    @property
+    def min_index(self) -> float:
+        return self.seq_array["index"].min()
+
+    @property
+    def start(self) -> float:
+        return self.min_index
+
+    @property
+    def end(self) -> float:
+        return self.max_index
+
+    @property
+    def mutated_positions(self) -> np.ndarray:
+        return (self.seq_array["ref"] != self.seq_array["nt"])[self.seq_array["valid_mask"]].astype(int)
+
     def clone(self, start: Optional[float] = None, end: Optional[float] = None) -> SeqMat:
         new = SeqMat.__new__(SeqMat)
         new.name = self.name
@@ -120,37 +159,66 @@ class SeqMat:
         new.seq_array['valid_mask'] = new.seq_array['nt'] != b'-'
         return new
 
+    # def apply_mutations(
+    #         self,
+    #         mutations: Union[Tuple[float, str, str], List[Tuple[float, str, str]]],
+    #         only_snps: bool = False
+    # ) -> SeqMat:
+
     def apply_mutations(
             self,
-            mutations: Union[Tuple[float, str, str], List[Tuple[float, str, str]]],
+            mutations: Union[Tuple[float, str, str], List[Tuple[float, str, str]]] = None,
+            *,
+            pos: Optional[float] = None,
+            ref: Optional[str] = None,
+            alt: Optional[str] = None,
             only_snps: bool = False
-    ) -> SeqMat:
+        ) -> SeqMat:
         """
         Apply one or a batch of mutations (pos, ref, alt) efficiently:
         - Supports a single tuple or a list of tuples
         - Assumes mutations sorted by position for vectorized searchsorted
         """
         # Normalize to list
-        if isinstance(mutations, tuple) and len(mutations) == 3:
+        # if isinstance(mutations, tuple) and len(mutations) == 3:
+        #     mutations = [mutations]
+        # elif not isinstance(mutations, list):
+        #     raise TypeError("mutations must be a tuple or list of tuples")
+        # Input normalization
+        if mutations is None:
+            if pos is None or ref is None or alt is None:
+                raise ValueError("Either `mutations` or `pos, ref, alt` must be provided")
+            mutations = [(pos, ref, alt)]
+        elif isinstance(mutations, tuple) and len(mutations) == 3:
             mutations = [mutations]
         elif not isinstance(mutations, list):
-            raise TypeError("mutations must be a tuple or list of tuples")
-
-        # Left-normalize and bucket
+            raise TypeError("`mutations` must be a tuple or list of tuples")
+
+        # # Left-normalize and bucket
+        # subs, ins, dels = [], [], []
+        # for pos, ref, alt in mutations:
+        #     while ref and alt and ref[0] == alt[0]:
+        #         pos += 1
+        #         ref = ref[1:] or '-'
+        #         alt = alt[1:] or '-'
+        #     if ref != '-' and alt != '-':
+        #         subs.append((pos, ref, alt))
+        #     elif ref == '-' and alt != '-' and not only_snps:
+        #         ins.append((pos, alt))
+        #     elif alt == '-' and ref != '-' and not only_snps:
+        #         dels.append((pos, ref))
+        #     else:
+        #         raise ValueError(f"Unsupported mutation {pos}:{ref}:{alt}.")
+        # Bucket mutations
         subs, ins, dels = [], [], []
-        for pos, ref, alt in mutations:
-            while ref and alt and ref[0] == alt[0]:
-                pos += 1
-                ref = ref[1:] or '-'
-                alt = alt[1:] or '-'
-            if ref != '-' and alt != '-':
-                subs.append((pos, ref, alt))
-            elif ref == '-' and alt != '-' and not only_snps:
-                ins.append((pos, alt))
-            elif alt == '-' and ref != '-' and not only_snps:
-                dels.append((pos, ref))
-            else:
-                raise ValueError(f"Unsupported mutation {pos}:{ref}:{alt}.")
+        for p, r, a in mutations:
+            # left-normalize
+            while r and a and r[0] == a[0]:
+                p += 1; r = r[1:] or '-'; a = a[1:] or '-'
+            if r != '-' and a != '-': subs.append((p, r, a))
+            elif r == '-' and a != '-' and not only_snps: ins.append((p, a))
+            elif a == '-' and r != '-' and not only_snps: dels.append((p, r))
+            else: raise ValueError(f"Unsupported mutation {p}:{r}:{a}")
 
         # Ensure seq_array indices sorted
         coords = self.seq_array['index']
@@ -225,3 +293,137 @@ class SeqMat:
             mask = (coords >= start) & (coords <= stop)
             return self.seq_array[mask]
         raise TypeError("Invalid index type.")
+
+    def cut_out(self, introns: List[Tuple[int, int]]) -> "SeqMat":
+        """
+        Splices out regions from the sequence corresponding to the given intron boundaries.
+
+        Handles reverse-complemented sequences by interpreting introns in reverse as well.
+
+        Args:
+            introns (List[Tuple[int, int]]): List of (start, end) intron boundaries.
+                                             These are always genomic (absolute) coordinates,
+                                             regardless of strand direction.
+
+        Returns:
+            SeqMat: A new instance with the intron regions removed.
+        """
+        # In reverse orientation, flip intron direction for comparison
+        if self.rev:
+            introns = [(end, start) if start > end else (start, end) for (start, end) in introns]
+
+        mask = np.ones(len(self.seq_array), dtype=bool)
+
+        for start, end in introns:
+            lo, hi = min(start, end) + 1, max(start, end) - 1
+            mask &= ~((self.seq_array["index"] >= lo) & (self.seq_array["index"] <= hi))
+
+        new_instance = self.clone()
+        new_instance.seq_array = self.seq_array[mask].copy()
+        return new_instance
+
+    def open_reading_frame(self, tis: int) -> "SeqMat":
+        """
+        Extracts the open reading frame starting from the translation initiation site (TIS)
+        until the first in-frame stop codon.
+
+        Args:
+            tis (int): Genomic position of the translation initiation site (start codon).
+
+        Returns:
+            SeqMat: A new SeqMat instance containing the ORF (from TIS to stop codon inclusive).
+        """
+        if tis not in self.seq_array["index"]:
+            print(f"Warning: TIS position {tis} not found, returning default.")
+            return self.clone(start=0, end=3)
+
+        # Extract nucleotide sequence and indices starting from TIS
+        mask = self.seq_array["index"] >= tis if not self.rev else self.seq_array["index"] <= tis
+        coding_part = self.seq_array[mask]
+        coding_seq = coding_part["nt"].tobytes().decode()
+
+        # Read codons in-frame
+        for i in range(0, len(coding_seq) - 2, 3):
+            codon = coding_seq[i:i + 3]
+            if codon in {"TAA", "TAG", "TGA"}:
+                # Determine index range for this ORF
+                start = coding_part["index"][0]
+                stop = coding_part["index"][i + 2]
+                lo, hi = sorted((start, stop))
+                return self.clone(start=lo, end=hi)
+
+        raise ValueError("No in-frame stop codon found after the TIS.")
+
+    def predict_splicing(self, position: int, engine='spliceai', context=7500, inplace=False): #, reference_donors=None, reference_acceptors=None) -> pd.DataFrame:
+        """
+        Predict splicing probabilities at a given position using the specified engine.
+
+        Args:
+            position (int): The genomic position to predict splicing probabilities for.
+            engine (str): The prediction engine to use. Supported: 'spliceai', 'pangolin'.
+            context (int): The length of the target central region (default: 7500).
+            format (str): Output format for the splicing engine results.
+
+        Returns:
+            pd.DataFrame: A DataFrame containing:
+                - position: The genomic position
+                - donor_prob: Probability of being a donor splice site
+                - acceptor_prob: Probability of being an acceptor splice site
+                - nucleotides: The nucleotide sequence at that position
+
+        Raises:
+            ValueError: If an unsupported engine is provided.
+            IndexError: If the position is not found in the sequence.
+        """
+        # Retrieve extended context (includes flanks) around the position.
+        # seq, indices = self.get_context(position, context=context, padding='N')
+        target = self.clone(position - context, position + context)
+        # print(len(target.seq))
+        seq, indices = target.seq, target.index
+        # print(len(seq))
+        # rel_pos = np.where(indices == position)[0][0]
+        # print(rel_pos)
+        rel_pos = np.abs(indices - position).argmin()
+        # print(rel_pos, len(seq))
+        left_missing, right_missing = max(0, context - rel_pos), max(0, context - (len(seq) - rel_pos))
+        # print(left_missing, right_missing)
+        if left_missing > 0 or right_missing > 0:
+            step = -1 if self.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])
+
+        # Run the splicing prediction engine (function assumed to be defined externally)
+        from .splicing_utils import run_splicing_engine
+        donor_probs, acceptor_probs = run_splicing_engine(seq, engine)
+        # Trim off the fixed flanks before returning results.
+        seq = seq[5000:-5000]
+        indices = indices[5000:-5000]
+        df = pd.DataFrame({
+            'position': indices,
+            'donor_prob': donor_probs,
+            'acceptor_prob': acceptor_probs,
+            'nucleotides': list(seq)
+        }).set_index('position').round(3)
+        # if reference_donors is not None:
+        #     df['ref_donor'] = df.index.isin(reference_donors).astype(int)
+        # if reference_acceptors is not None:
+        #     df['ref_acceptor'] = df.index.isin(reference_acceptors).astype(int)
+
+        df.attrs['name'] = self.name
+        if inplace:
+            self.predicted_splicing = df
+            return self
+        else:
+            return df
+

{geney-1.4.21.dist-info → geney-1.4.23.dist-info}/METADATA

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

{geney-1.4.21.dist-info → geney-1.4.23.dist-info}/RECORD

@@ -37,7 +37,7 @@ geney/translation_initiation/tis_utils.py,sha256=AF3siFjuQH-Rs44EV-80zHdbxRMvN4w
 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/utils/Fasta_segment.py,sha256=weB5NJ65P0XiyAJCiCHx4T9sHC1pWLpuQeOy0B85gyg,11364
-geney/utils/SeqMats.py,sha256=q858gWPsSoS4HUr6FD1CHYuUh5AE5u9KePHYT7FQw7g,8777
+geney/utils/SeqMats.py,sha256=4NJMXNDw6XQAaKVpNuEIft1Xa1sSxPSFwnIeMzjI3eE,17058
 geney/utils/SeqMatsOld.py,sha256=syRU5DAuTh3xUfGW_qP9wlcBO5pHsG_y5PlrfXTIxUY,18502
 geney/utils/TranscriptLibrary.py,sha256=ma_ZVPgglxXDDneEvdqxxeqxG8eSFL-zgLUXyC6BqY8,2070
 geney/utils/__init__.py,sha256=-nJ-DMx1JzP-ZCe_QuQCeM0ZYIT_16jxoXDhUaO_4Oc,714
@@ -46,7 +46,7 @@ geney/utils/pangolin_utils.py,sha256=JQSPbWxdzqGFYfWQktkfLMaMSGR28eGQhNzO7MLMe5M
 geney/utils/spliceai_utils.py,sha256=VtrIbjyQxk_3lw86eWjftRYyal9OzxArJ0GV5u_ymTg,2721
 geney/utils/splicing_utils.py,sha256=vPCGnCPR1ooEZEHR79yFHLmRQXEJHXEQjjxpBR-YWOs,20635
 geney/utils/utils.py,sha256=m51Vd0cEbrcIHo6_8BAuI9YSPcKRs22e5LfVd2Qj6Is,2181
-geney-1.4.21.dist-info/METADATA,sha256=m-32P-otBh8Nj1P_rBrqgE6wYPEA04pcTV1tGxuTkWM,990
-geney-1.4.21.dist-info/WHEEL,sha256=AHX6tWk3qWuce7vKLrj7lnulVHEdWoltgauo8bgCXgU,109
-geney-1.4.21.dist-info/top_level.txt,sha256=O-FuNUMb5fn9dhZ-dYCgF0aZtfi1EslMstnzhc5IIVo,6
-geney-1.4.21.dist-info/RECORD,,
+geney-1.4.23.dist-info/METADATA,sha256=cRWawSdfae-X2F-k7AFedHrQd_OhD2zBLjkA2zzNLrs,990
+geney-1.4.23.dist-info/WHEEL,sha256=AHX6tWk3qWuce7vKLrj7lnulVHEdWoltgauo8bgCXgU,109
+geney-1.4.23.dist-info/top_level.txt,sha256=O-FuNUMb5fn9dhZ-dYCgF0aZtfi1EslMstnzhc5IIVo,6
+geney-1.4.23.dist-info/RECORD,,