geney 1.4.40__py3-none-any.whl

geney/utils.py

@@ -0,0 +1,254 @@
+__all__ = ['is_monotonic', 'contains', 'unload_json', 'unload_pickle', 'dump_json', 'dump_pickle', 'generate_random_nucleotide_sequences', 'generate_random_sequence', 'short_hash_of_list']
+
+import pickle
+import json
+from pathlib import Path
+from bisect import bisect_left
+import hashlib
+import random
+from typing import Any, List, Sequence, Union
+
+# def is_monotonic(A):
+#     x, y = [], []
+#     x.extend(A)
+#     y.extend(A)
+#     x.sort()
+#     y.sort(reverse=True)
+#     if (x == A or y == A):
+#         return True
+#     return False
+
+
+# def available_genes(organism='hg38'):
+#     from geney import config
+#     annotation_path = config[organism]['MRNA_PATH'] / 'protein_coding'
+#     return sorted(list(set([m.stem.split('_')[-1] for m in annotation_path.glob('*')])))
+
+
+def contains(a: Sequence[Any], x: Any) -> bool:
+    """Check if sorted sequence contains value using binary search.
+    
+    Args:
+        a: Sorted sequence to search in
+        x: Value to search for
+        
+    Returns:
+        True if value is found, False otherwise
+        
+    Raises:
+        TypeError: If sequence is not sortable
+    """
+    if not hasattr(a, '__len__') or not hasattr(a, '__getitem__'):
+        raise TypeError("First argument must be a sequence")
+        
+    try:
+        i = bisect_left(a, x)
+        return i != len(a) and a[i] == x
+    except TypeError as e:
+        raise TypeError(f"Cannot compare types in sequence: {e}") from e
+
+
+def unload_json(file_path: Union[str, Path]) -> Any:
+    """Load data from JSON file.
+    
+    Args:
+        file_path: Path to JSON file
+        
+    Returns:
+        Loaded data structure
+        
+    Raises:
+        FileNotFoundError: If file doesn't exist
+        JSONDecodeError: If file contains invalid JSON
+    """
+    file_path = Path(file_path)
+    
+    if not file_path.exists():
+        raise FileNotFoundError(f"JSON file not found: {file_path}")
+        
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        return data
+    except json.JSONDecodeError as e:
+        raise json.JSONDecodeError(f"Invalid JSON in file {file_path}: {e.msg}", e.doc, e.pos) from e
+
+
+def dump_json(file_path: Union[str, Path], payload: Any, indent: int = 2) -> None:
+    """Save data to JSON file.
+    
+    Args:
+        file_path: Path to output JSON file
+        payload: Data to save
+        indent: JSON indentation level
+        
+    Raises:
+        TypeError: If payload is not JSON serializable
+        PermissionError: If cannot write to file
+    """
+    file_path = Path(file_path)
+    
+    # Create parent directory if it doesn't exist
+    file_path.parent.mkdir(parents=True, exist_ok=True)
+    
+    try:
+        with open(file_path, 'w', encoding='utf-8') as f:
+            json.dump(payload, f, indent=indent, ensure_ascii=False)
+    except TypeError as e:
+        raise TypeError(f"Cannot serialize data to JSON: {e}") from e
+
+
+def unload_pickle(file_path: Union[str, Path]) -> Any:
+    """Load data from pickle file.
+    
+    Args:
+        file_path: Path to pickle file
+        
+    Returns:
+        Loaded data structure
+        
+    Raises:
+        FileNotFoundError: If file doesn't exist
+        pickle.UnpicklingError: If file contains invalid pickle data
+    """
+    file_path = Path(file_path)
+    
+    if not file_path.exists():
+        raise FileNotFoundError(f"Pickle file not found: {file_path}")
+        
+    try:
+        with open(file_path, 'rb') as f:
+            data = pickle.load(f)
+        return data
+    except pickle.UnpicklingError as e:
+        raise pickle.UnpicklingError(f"Invalid pickle data in file {file_path}: {e}") from e
+
+
+def dump_pickle(file_path: Union[str, Path], payload: Any) -> None:
+    """Save data to pickle file.
+    
+    Args:
+        file_path: Path to output pickle file
+        payload: Data to save
+        
+    Raises:
+        PermissionError: If cannot write to file
+    """
+    file_path = Path(file_path)
+    
+    # Create parent directory if it doesn't exist
+    file_path.parent.mkdir(parents=True, exist_ok=True)
+    
+    try:
+        with open(file_path, 'wb') as f:
+            pickle.dump(payload, f)
+    except Exception as e:
+        raise RuntimeError(f"Failed to save pickle file {file_path}: {e}") from e
+
+
+
+def is_monotonic(A: Sequence[Any]) -> bool:
+    """Check if sequence is monotonic (non-decreasing or non-increasing).
+    
+    Args:
+        A: Sequence to check
+        
+    Returns:
+        True if sequence is monotonic, False otherwise
+        
+    Raises:
+        TypeError: If sequence elements are not comparable
+    """
+    if not hasattr(A, '__len__') or len(A) < 2:
+        return True
+        
+    try:
+        return (all(x <= y for x, y in zip(A, A[1:])) or 
+                all(x >= y for x, y in zip(A, A[1:])))
+    except TypeError as e:
+        raise TypeError(f"Cannot compare sequence elements: {e}") from e
+
+
+def generate_random_sequence(length: int) -> str:
+    """Generate a random DNA sequence of given length.
+    
+    Args:
+        length: Length of sequence to generate
+        
+    Returns:
+        Random DNA sequence containing only A, C, G, T
+        
+    Raises:
+        ValueError: If length is not positive
+    """
+    if not isinstance(length, int):
+        raise TypeError(f"Length must be integer, got {type(length).__name__}")
+        
+    if length <= 0:
+        raise ValueError(f"Length must be positive, got {length}")
+        
+    return ''.join(random.choices('ACGT', k=length))
+
+def generate_random_nucleotide_sequences(num_sequences: int, min_len: int = 3, max_len: int = 10) -> List[str]:
+    """
+    Generate random DNA sequences of variable lengths.
+
+    Args:
+        num_sequences: Number of sequences to generate
+        min_len: Minimum sequence length
+        max_len: Maximum sequence length
+
+    Returns:
+        List of random nucleotide sequences
+        
+    Raises:
+        ValueError: If parameters are invalid
+    """
+    if not isinstance(num_sequences, int) or num_sequences <= 0:
+        raise ValueError(f"num_sequences must be positive integer, got {num_sequences}")
+        
+    if not isinstance(min_len, int) or min_len <= 0:
+        raise ValueError(f"min_len must be positive integer, got {min_len}")
+        
+    if not isinstance(max_len, int) or max_len <= 0:
+        raise ValueError(f"max_len must be positive integer, got {max_len}")
+        
+    if min_len > max_len:
+        raise ValueError(f"min_len ({min_len}) cannot be greater than max_len ({max_len})")
+    
+    nucleotides = ['A', 'C', 'G', 'T']
+    lengths = list(range(min_len, max_len + 1))
+    
+    sequences = [
+        ''.join(random.choices(nucleotides, k=random.choice(lengths)))
+        for _ in range(num_sequences)
+    ]
+    return sequences
+
+
+
+def short_hash_of_list(numbers: List[Any], length: int = 5) -> str:
+    """Generate a short hash string from a list of numbers.
+    
+    Args:
+        numbers: List of values to hash
+        length: Length of output hash string
+        
+    Returns:
+        Short hash string
+        
+    Raises:
+        ValueError: If length is not positive
+    """
+    if not isinstance(length, int) or length <= 0:
+        raise ValueError(f"Length must be positive integer, got {length}")
+        
+    if length > 64:  # SHA256 hex digest is 64 characters
+        raise ValueError(f"Length cannot exceed 64, got {length}")
+    
+    try:
+        encoded = repr(numbers).encode('utf-8')
+        full_hash = hashlib.sha256(encoded).hexdigest()
+        return full_hash[:length]
+    except Exception as e:
+        raise RuntimeError(f"Failed to generate hash: {e}") from e

geney/variants.py

@@ -0,0 +1,389 @@
+# oncosplice/variants.py
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Dict, Iterable, List, Optional, Tuple, Union
+
+import numpy as np
+import pandas as pd
+
+__all__ = ["Mutation", "MutationalEvent", "MutationLibrary"]
+
+# GENE:CHR:POS:REF:ALT
+_MUTATION_ID_RE = re.compile(
+    r"^([^:]+):([^:]+):(\d+):([ACGTN\-]+):([ACGTN\-]+)$",
+    re.IGNORECASE,
+)
+
+
+class Mutation:
+    """Represents a single mutation with genomic coordinates and alleles."""
+
+    def __init__(self, gene: str, chrom: str, pos: Union[int, str], ref: str, alt: str):
+        if not gene:
+            raise ValueError("Gene name cannot be empty")
+        if not chrom:
+            raise ValueError("Chromosome cannot be empty")
+        if not ref or not alt:
+            raise ValueError("Reference and alternate alleles cannot be empty")
+
+        self.gene = gene
+        self.chrom = chrom
+
+        try:
+            self.pos = int(pos)
+        except (ValueError, TypeError) as e:
+            raise ValueError(f"Position must be numeric, got '{pos}'") from e
+
+        if self.pos < 0:
+            raise ValueError(f"Position must be non-negative, got {self.pos}")
+
+        valid_chars = set("ACGTN-")
+        ref_u = ref.upper()
+        alt_u = alt.upper()
+        if not all(c in valid_chars for c in ref_u):
+            raise ValueError(f"Invalid characters in reference allele: {ref}")
+        if not all(c in valid_chars for c in alt_u):
+            raise ValueError(f"Invalid characters in alternate allele: {alt}")
+
+        self.ref = ref_u
+        self.alt = alt_u
+        self.mut_type = self._infer_type()
+
+    @classmethod
+    def from_id(cls, mut_id: str) -> "Mutation":
+        m = _MUTATION_ID_RE.match(mut_id.strip())
+        if not m:
+            raise ValueError(
+                f"Invalid mutation ID '{mut_id}'. Expected GENE:CHROM:POS:REF:ALT"
+            )
+        return cls(*m.groups())
+
+    def _infer_type(self) -> str:
+        if self.ref == "-" or self.alt == "-":
+            return "indel"
+        if len(self.ref) == len(self.alt) == 1:
+            return "snp"
+        return "indel"
+
+    @property
+    def span(self) -> int:
+        ref_len = 0 if self.ref == "-" else len(self.ref)
+        alt_len = 0 if self.alt == "-" else len(self.alt)
+        return max(ref_len, alt_len, 1)
+
+    @property
+    def end(self) -> int:
+        return self.pos + self.span
+
+    def overlaps_with(self, other: "Mutation") -> bool:
+        if not isinstance(other, Mutation):
+            raise TypeError(f"Expected Mutation, got {type(other).__name__}")
+        if self.chrom != other.chrom:
+            return False
+        return not (self.end <= other.pos or other.end <= self.pos)
+
+    def to_dict(self) -> Dict[str, Union[str, int]]:
+        return {
+            "gene": self.gene,
+            "chrom": self.chrom,
+            "pos": self.pos,
+            "ref": self.ref,
+            "alt": self.alt,
+            "type": self.mut_type,
+        }
+
+    def __repr__(self) -> str:
+        return f"{self.gene}:{self.chrom}:{self.pos}:{self.ref}:{self.alt}"
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Mutation):
+            return False
+        return (
+            self.gene == other.gene
+            and self.chrom == other.chrom
+            and self.pos == other.pos
+            and self.ref == other.ref
+            and self.alt == other.alt
+        )
+
+    def __hash__(self) -> int:
+        return hash((self.gene, self.chrom, self.pos, self.ref, self.alt))
+
+
+class MutationalEvent:
+    """Represents a compound mutational event (one or more mutations)."""
+
+    def __init__(self, mut_id: str):
+        if not mut_id:
+            raise ValueError("Mutation ID cannot be empty")
+
+        self.raw = mut_id.strip()
+        try:
+            self.mutations: List[Mutation] = self._parse_mutations(self.raw)
+        except Exception as e:
+            raise ValueError(f"Failed to parse mutation ID '{mut_id}': {e}") from e
+
+        if not self.mutations:
+            raise ValueError(f"No valid mutations found in '{mut_id}'")
+
+        self.gene = self._verify_same_gene()
+
+    def __len__(self) -> int:
+        return len(self.mutations)
+
+    @staticmethod
+    def _parse_mutations(mut_id: str) -> List[Mutation]:
+        parts = re.split(r"[|,]", mut_id)
+        out: List[Mutation] = []
+        for i, part in enumerate(parts):
+            part = part.strip()
+            if not part:
+                continue
+
+            m = _MUTATION_ID_RE.match(part)
+            if not m:
+                raise ValueError(
+                    f"Invalid format for mutation #{i+1}: '{part}'. "
+                    "Expected GENE:CHROM:POS:REF:ALT"
+                )
+            out.append(Mutation(*m.groups()))
+        return out
+
+    def _verify_same_gene(self) -> str:
+        genes = {m.gene for m in self.mutations}
+        if len(genes) != 1:
+            raise ValueError(
+                f"All mutations must be in the same gene, found: {', '.join(sorted(genes))}"
+            )
+        return genes.pop()
+
+    @property
+    def chrom(self) -> str:
+        chroms = {m.chrom for m in self.mutations}
+        if len(chroms) != 1:
+            raise ValueError(
+                f"Mutations span multiple chromosomes: {', '.join(sorted(chroms))}"
+            )
+        return chroms.pop()
+
+    @property
+    def positions(self) -> List[int]:
+        return [m.pos for m in self.mutations]
+
+    @property
+    def central_position(self) -> int:
+        return int(np.mean(self.positions))
+
+    @property
+    def position(self) -> int:
+        return self.central_position
+
+    @property
+    def types(self) -> List[str]:
+        return [m.mut_type for m in self.mutations]
+
+    def compatible(self) -> bool:
+        for i, m1 in enumerate(self.mutations):
+            for m2 in self.mutations[i + 1 :]:
+                if m1.overlaps_with(m2):
+                    return False
+        return True
+
+    def validate(self) -> None:
+        if not self.mutations:
+            raise ValueError("Event contains no mutations")
+
+        if not self.compatible():
+            overlapping = []
+            for i, m1 in enumerate(self.mutations):
+                for m2 in self.mutations[i + 1 :]:
+                    if m1.overlaps_with(m2):
+                        overlapping.append(f"{m1} overlaps with {m2}")
+            raise ValueError(
+                f"Mutations are not compatible: {'; '.join(overlapping)}"
+            )
+
+        chroms = {m.chrom for m in self.mutations}
+        if len(chroms) > 1:
+            raise ValueError(
+                f"Mutations span multiple chromosomes: {', '.join(sorted(chroms))}"
+            )
+
+    def to_dataframe(self) -> pd.DataFrame:
+        if not self.mutations:
+            return pd.DataFrame(
+                columns=["gene", "chrom", "pos", "ref", "alt", "type"]
+            )
+        return pd.DataFrame([m.to_dict() for m in self.mutations])
+
+    def mutation_args(self) -> List[Tuple[int, str, str]]:
+        return [(m.pos, m.ref, m.alt) for m in self.mutations]
+
+    def __iter__(self):
+        return iter(self.mutation_args())
+
+    def __repr__(self) -> str:
+        muts = ", ".join(f"{m.pos}:{m.ref}>{m.alt}" for m in self.mutations)
+        return f"MutationalEvent({self.gene} -> [{muts}])"
+
+    def __str__(self) -> str:
+        return f"{self.gene}: {len(self.mutations)} mutation(s)"
+
+
+class MutationLibrary:
+    """
+    Collection of mutational events built from IDs, text files, or VCF files.
+
+    events: mapping from raw mutation ID string -> MutationalEvent (validated)
+    """
+
+    def __init__(self, events: Optional[Dict[str, MutationalEvent]] = None):
+        self.events: Dict[str, MutationalEvent] = events or {}
+        self._errors: Dict[str, str] = {}
+
+    @classmethod
+    def from_mutation_ids(
+        cls,
+        mut_ids: Iterable[str],
+        *,
+        validate: bool = True,
+        skip_invalid: bool = True,
+    ) -> "MutationLibrary":
+        events: Dict[str, MutationalEvent] = {}
+        errors: Dict[str, str] = {}
+
+        for mid in mut_ids:
+            mid = mid.strip()
+            if not mid:
+                continue
+
+            try:
+                ev = MutationalEvent(mid)
+                if validate:
+                    ev.validate()
+                events[mid] = ev
+            except Exception as e:
+                if skip_invalid:
+                    errors[mid] = str(e)
+                    continue
+                raise
+
+        lib = cls(events)
+        lib._errors = errors
+        return lib
+
+    @classmethod
+    def from_text_file(
+        cls,
+        path: Union[str, Path],
+        comment_char: str = "#",
+        *,
+        validate: bool = True,
+        skip_invalid: bool = True,
+    ) -> "MutationLibrary":
+        p = Path(path)
+        mut_ids: List[str] = []
+        with p.open() as fh:
+            for line in fh:
+                line = line.strip()
+                if not line or line.startswith(comment_char):
+                    continue
+                mut_ids.append(line)
+        return cls.from_mutation_ids(
+            mut_ids,
+            validate=validate,
+            skip_invalid=skip_invalid,
+        )
+
+    @classmethod
+    def from_vcf(
+        cls,
+        path: Union[str, Path],
+        gene_field: Optional[str] = "GENE",
+        *,
+        validate: bool = True,
+        skip_invalid: bool = True,
+    ) -> "MutationLibrary":
+        p = Path(path)
+
+        df = pd.read_csv(
+            p,
+            sep="\t",
+            comment="#",
+            dtype={"CHROM": str},
+        )
+
+        required = {"CHROM", "POS", "REF", "ALT"}
+        missing = required - set(df.columns)
+        if missing:
+            raise ValueError(
+                f"VCF is missing required columns: {', '.join(sorted(missing))}"
+            )
+
+        mut_ids: List[str] = []
+        for _, row in df.iterrows():
+            chrom = str(row["CHROM"])
+            pos = int(row["POS"])
+            ref = str(row["REF"])
+            alts = str(row["ALT"]).split(",")
+
+            if gene_field is not None and gene_field in row and pd.notna(row[gene_field]):
+                gene = str(row[gene_field])
+            else:
+                gene = "."
+
+            for alt in alts:
+                mut_ids.append(f"{gene}:{chrom}:{pos}:{ref}:{alt}")
+
+        return cls.from_mutation_ids(
+            mut_ids,
+            validate=validate,
+            skip_invalid=skip_invalid,
+        )
+
+    def __len__(self) -> int:
+        return len(self.events)
+
+    def __iter__(self):
+        return iter(self.events.items())
+
+    def __contains__(self, mut_id: str) -> bool:
+        return mut_id in self.events
+
+    def get(self, mut_id: str) -> Optional[MutationalEvent]:
+        return self.events.get(mut_id)
+
+    def add(self, mut_id: str, *, validate: bool = True) -> Optional[MutationalEvent]:
+        mut_id = mut_id.strip()
+        if not mut_id:
+            return None
+
+        try:
+            ev = MutationalEvent(mut_id)
+            if validate:
+                ev.validate()
+            self.events[ev.raw] = ev
+            return ev
+        except Exception as e:
+            self._errors[mut_id] = str(e)
+            return None
+
+    def to_dataframe(self) -> pd.DataFrame:
+        records: List[Dict[str, Union[str, int]]] = []
+        for eid, event in self.events.items():
+            df = event.to_dataframe()
+            if not df.empty:
+                df = df.copy()
+                df["event_id"] = eid
+                records.append(df)
+        if not records:
+            return pd.DataFrame(
+                columns=["event_id", "gene", "chrom", "pos", "ref", "alt", "type"]
+            )
+        return pd.concat(records, ignore_index=True)
+
+    @property
+    def errors(self) -> Dict[str, str]:
+        return dict(self._errors)

geney-1.4.40.dist-info/METADATA

@@ -0,0 +1,32 @@
+Metadata-Version: 2.4
+Name: geney
+Version: 1.4.40
+Summary: A Python package for gene expression modeling.
+Home-page: https://github.com/nicolaslynn/geney
+Author: Nicolas Lynn
+Author-email: nicolasalynn@gmail.com
+License: Free for non-commercial use
+Classifier: Development Status :: 1 - Planning
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: Free for non-commercial use
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3.9
+Requires-Python: >3.10
+Requires-Dist: numpy<2.0
+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: seqmat
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: home-page
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

geney-1.4.40.dist-info/RECORD

@@ -0,0 +1,14 @@
+geney/__init__.py,sha256=1V1SxqcLFPxRJOqr4VmGillv1r4_azJtbmNtf0pZ18I,684
+geney/engines.py,sha256=ZK6x0YdY8_yPRTUmhwL8GWcuS3U5OotqMJBKPE-z7cE,10548
+geney/oncosplice.py,sha256=eGQQl9ftmoFENMYBWoJtenKWmzyxR9N1of5cZst_bHQ,18014
+geney/pipelines.py,sha256=zK1zDFFAxElnxgXWeM_xZqEZtwxyF7CwmtQLCkKOq2w,3356
+geney/samples.py,sha256=3KrWNILHYql-vPC_TidkzqDuFaLx3JSJZbUoVW2RTlo,92
+geney/splice_graph.py,sha256=wCStApnnrwbej_yhk_s39p5sQatRtqg9Ve8GqH2ZfGA,14849
+geney/splicing_table.py,sha256=mXDXUr4h_q7grYQpmXO5Ex15Mt7BchieWF9lawd6src,5412
+geney/transcripts.py,sha256=I6NmBcW9QG5XtRumn6i0TeT8tKECHQycsbSSZ7e8LZo,2601
+geney/utils.py,sha256=pv4_LPIzjYAxwUgmufZJL6UhVVq2SllpF90ix_uH_-Q,7627
+geney/variants.py,sha256=vjbiBH-duZ4TJZyXwXbQ_VmJxCFafjeDwLNTZg3ubSc,11832
+geney-1.4.40.dist-info/METADATA,sha256=BiZJ2yQaYrHybVewBIQ2Cdw_qKNENiHoIEiFPp29xs8,952
+geney-1.4.40.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+geney-1.4.40.dist-info/top_level.txt,sha256=O-FuNUMb5fn9dhZ-dYCgF0aZtfi1EslMstnzhc5IIVo,6
+geney-1.4.40.dist-info/RECORD,,

geney-1.4.40.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

geney-1.4.40.dist-info/top_level.txt

@@ -0,0 +1 @@
+geney