agglovar 0.0.1.dev12__tar.gz → 0.0.1.dev14__tar.gz

{agglovar-0.0.1.dev12/src/agglovar.egg-info → agglovar-0.0.1.dev14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agglovar
-Version: 0.0.1.dev12
+Version: 0.0.1.dev14
 Summary: Toolkit for fast genomic variant transformations and intersects
 License-Expression: MIT
 Requires-Python: >=3.12
@@ -8,10 +8,10 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: biopython>=1.85
 Requires-Dist: edlib>=1.3.9.post1
-Requires-Dist: intervaltree>=3.1.0
 Requires-Dist: numpy>=2.3.0
 Requires-Dist: ply>=3.11
 Requires-Dist: polars[numpy,pandas,pyarrow]>=1.35.2
+Requires-Dist: pysam>=0.23.3
 Provides-Extra: plot
 Requires-Dist: matplotlib>=3.10.3; extra == "plot"
 Provides-Extra: all

{agglovar-0.0.1.dev12 → agglovar-0.0.1.dev14}/pyproject.toml

@@ -13,10 +13,10 @@ requires-python = ">=3.12"
 dependencies = [
     "biopython>=1.85",
     "edlib>=1.3.9.post1",
-    "intervaltree>=3.1.0",
     "numpy>=2.3.0",
     "ply>=3.11",
     "polars[numpy,pandas,pyarrow]>=1.35.2",
+    "pysam>=0.23.3",
 ]
 
 [agglovar.urls]
@@ -107,6 +107,8 @@ max-line-length = 120
 max-line-length = 120
 docstring-convention = "pep257"
 per-file-ignores = [
-    "src/agglovar/join/config/parser.py: D200, D205, D212, D300, D403, D415"
+    "src/agglovar/merge/config/parser.py: D200, D205, D212, D300, D400, D401, D403, D415",
+    "src/agglovar/vcf/__init__.py: DALL002, F401, F403",
+    "src/agglovar/pairwise/overlap/__init__.py: DALL002, F401, F403",
 ]
-rst-roles = ["class", "meth", "const", "ref", "func", "mod"]
+rst-roles = ["class", "meth", "const", "ref", "func", "mod", "attr", "data"]

{agglovar-0.0.1.dev12 → agglovar-0.0.1.dev14}/src/agglovar/__init__.py

@@ -1,6 +1,6 @@
 """Agglovar: A toolkit for fast genomic variant transformations and intersects."""
 
-__version__ = '0.0.1.dev12'
+__version__ = '0.0.1.dev14'
 
 __all__ = [
     'align',
@@ -13,6 +13,7 @@ __all__ = [
     'meta',
     'schema',
     'seqmatch',
+    'vcf',
     'util',
 ]
 
@@ -26,4 +27,5 @@ from . import merge
 from . import meta
 from . import schema
 from . import seqmatch
-from . import util
+from . import vcf
+from . import util

{agglovar-0.0.1.dev12 → agglovar-0.0.1.dev14}/src/agglovar/align/score.py

@@ -128,7 +128,7 @@ class ScoreModel(ABC):
             self,
             op_arr: np.ndarray,
     ) -> float:
-        """A vectorized implementation of summing scores for affine models.
+        """Sum scores for affine models using a vectorized implementation.
 
         :param op_arr: Array of alignment operations (op_code: first column, op_len: second column).
 
@@ -285,7 +285,7 @@ class AffineScoreModel(ScoreModel):
             self,
             op_arr: np.ndarray,
     ) -> float:
-        """A vectorized implementation of summing scores for affine models.
+        """Sum scores for affine models using a A vectorized implementation.
 
         :param op_arr: Array of alignment operations (op_code: first column, op_len: second column).
 

{agglovar-0.0.1.dev12 → agglovar-0.0.1.dev14}/src/agglovar/bed/col.py

@@ -14,6 +14,7 @@ from typing import Optional, Self, Any
 
 import polars as pl
 
+
 @dataclass(frozen=True)
 class CoordColExpr(Iterable[pl.Expr]):
     """Represents coordinate column expressions.
@@ -22,6 +23,7 @@ class CoordColExpr(Iterable[pl.Expr]):
     :ivar pos: Position column expression.
     :ivar end: End column expression.
     """
+
     chrom: pl.Expr
     pos: pl.Expr
     end: pl.Expr
@@ -49,11 +51,14 @@ class CoordColExpr(Iterable[pl.Expr]):
         return self.end.meta.output_name()
 
     def __iter__(self):
+        """Iterate over chrom, pos, and end expressions."""
         return iter((self.chrom, self.pos, self.end))
 
     def __repr__(self):
+        """Return a string representation."""
         return f"CoordColExpr({self.chrom!r}, {self.pos!r}, {self.end!r})"
 
+
 @dataclass(frozen=True, order=True)
 class CoordCol(Iterable[str], Container[str]):
     """Represents coordinate columns to use.
@@ -62,6 +67,7 @@ class CoordCol(Iterable[str], Container[str]):
     :ivar pos: Position column name.
     :ivar end: End column name.
     """
+
     chrom: str
     pos: str
     end: str
@@ -89,25 +95,30 @@ class CoordCol(Iterable[str], Container[str]):
         return CoordColExpr(
             *(
                 pl.col(col).alias(alias + suffix)
-                    for col, alias in zip(self, alias)
+                for col, alias in zip(self, alias)
             )
         )
 
     def __iter__(self):
+        """Iterate over chrom, pos, and end column names."""
         return iter((self.chrom, self.pos, self.end))
 
     def __contains__(self, o: Optional[Any]):
+        """Test whether ``o`` is one of the coordinate column names."""
         return o in (self.chrom, self.pos, self.end)
 
     def __repr__(self):
+        """Return a string representation."""
         return f"CoordCol({self.chrom!r}, {self.pos!r}, {self.end!r})"
 
+
 COL_CHROM: CoordCol = CoordCol('chrom', 'pos', 'end')
 """Standard chromosome columns."""
 
 COL_QRY: CoordCol = CoordCol('qry_id', 'qry_pos', 'qry_end')
 """Standard query columns."""
 
+
 def get_coord_cols(
         col_names: Optional[CoordCol | str | Iterable[str]] = None,
 ) -> CoordCol:
@@ -123,7 +134,6 @@ def get_coord_cols(
 
     :return: An object with column names.
     """
-
     if isinstance(col_names, CoordCol):
         return col_names
 
@@ -137,14 +147,16 @@ def get_coord_cols(
     else:
         col_names_tuple = tuple((
             col.strip() if col is not None else None
-                for col in col_names
+            for col in col_names
         ))
 
         if len(col_names_tuple) != 3:
-            raise ValueError(f'Invalid cols: Expected 3 elements, found {len(col_names_tuple)}: {col_names:r}')
+            raise ValueError(
+                f'Invalid cols: Expected 3 elements, found {len(col_names_tuple)}: {col_names!r}'
+            )
 
         if any(col is None or col == '' for col in col_names_tuple):
-            raise ValueError(f'Columns is missing values: {col_names:r}')
+            raise ValueError(f'Columns is missing values: {col_names!r}')
 
         return CoordCol(*col_names_tuple)
 
@@ -181,7 +193,6 @@ def make_unique_col(
 
     :return: Unique column name.
     """
-
     new_col = col
     i = 0
 
@@ -189,5 +200,4 @@ def make_unique_col(
         i += 1
         new_col = f'{col}_{i}'
 
-
     return new_col

agglovar-0.0.1.dev14/src/agglovar/bed/intersect.py

@@ -0,0 +1,186 @@
+"""Table intersects."""
+
+from pathlib import Path
+from typing import Iterable, Optional
+
+import polars as pl
+
+from .join import pairwise_join, pairwise_join_iter
+from .merge import merge_depth
+from .col import CoordCol, get_coord_cols
+
+__all__ = [
+    'as_bool',
+    'as_proportion',
+]
+
+
+def as_bool(
+        df_a: pl.LazyFrame | pl.DataFrame,
+        df_b: pl.LazyFrame | pl.DataFrame,
+        name: str,
+        distance: int = 0,
+        negate: bool = False,
+        col_names_a: Optional[CoordCol | Iterable[str] | str] = None,
+        col_names_b: Optional[CoordCol | Iterable[str] | str] = None,
+        temp_dir: bool | str | Path = False,
+) -> pl.LazyFrame:
+    """Add a boolean column to df_a indicating whether each record intersects with df_b.
+
+    :param df_a: Table a.
+    :param df_b: Table b.
+    :param name: Name of the column to add.
+    :param distance: Maximum distance between two records. May be negative to require overlap.
+    :param negate: If True, negate the boolean column to annotate misses instead of hits.
+    :param col_names_a: Columns in a (chromosome or query ID, pos, end).
+    :param col_names_b: Columns in b (chromosome or query ID, pos, end).
+    :param temp_dir: How to materialise the prepared tables before iterating. See
+        :func:`agglovar.bed.join.pairwise_join`.
+
+    :return: A LazyFrame with two columns: ``_index`` and ``name``.
+    """
+    if name is None or not (name := name.strip()):
+        raise ValueError('Name must be a non-empty string')
+
+    col_names_a = get_coord_cols(col_names_a)
+    col_names_b = get_coord_cols(col_names_b)
+
+    if isinstance(df_a, pl.DataFrame):
+        df_a = df_a.lazy()
+
+    if isinstance(df_b, pl.DataFrame):
+        df_b = df_b.lazy()
+
+    hit_val = not negate
+
+    join_list = []
+
+    for df_join in pairwise_join_iter(
+            df_a=df_a,
+            df_b=df_b,
+            distance=distance,
+            col_names_a=col_names_a,
+            col_names_b=col_names_b,
+            temp_dir=temp_dir,
+    ):
+        join_list.append(
+            df_join
+            .select(pl.col('index_a').alias('_index'))
+            .collect()
+            .lazy()
+        )
+
+    if '_index' in df_a.collect_schema().names():
+        df_a_indexed = df_a
+    else:
+        df_a_indexed = df_a.with_row_index('_index').with_columns(pl.col('_index').cast(pl.UInt64))
+
+    if not join_list:
+        return (
+            df_a_indexed
+            .select(
+                '_index',
+                pl.lit(not hit_val).alias(name),
+            )
+        )
+
+    hits = pl.concat(join_list).unique('_index')
+
+    return (
+        df_a_indexed
+        .select('_index')
+        .join(
+            hits.with_columns(pl.lit(hit_val).alias(name)),
+            on='_index', how='left',
+        )
+        .select(
+            '_index',
+            pl.col(name).fill_null(not hit_val),
+        )
+    )
+
+
+def as_proportion(
+        df_a: pl.LazyFrame | pl.DataFrame,
+        df_b: pl.LazyFrame | pl.DataFrame,
+        name: str,
+        col_names_a: Optional[CoordCol | Iterable[str] | str] = None,
+        col_names_b: Optional[CoordCol | Iterable[str] | str] = None,
+        temp_dir: bool | str | Path = False,
+) -> pl.LazyFrame:
+    """Compute the proportion of each interval in ``df_a`` covered by intervals in ``df_b``.
+
+    Rows in ``df_a`` with null ``pos`` or ``end`` are preserved in the output with a null
+    proportion. Zero-length intervals (``pos == end``) produce ``NaN`` (0 / 0).
+
+    :param df_a: Table a.
+    :param df_b: Table b.
+    :param name: Name of the column to add.
+    :param col_names_a: Columns in a (chromosome or query ID, pos, end).
+    :param col_names_b: Columns in b (chromosome or query ID, pos, end).
+    :param temp_dir: How to materialise the prepared tables before iterating. See
+        :func:`agglovar.bed.join.pairwise_join`.
+
+    :return: A LazyFrame with two columns: ``_index`` and ``name``.
+    """
+    if name is None or not (name := name.strip()):
+        raise ValueError('Name must be a non-empty string')
+
+    col_names_a = get_coord_cols(col_names_a)
+    col_names_b = get_coord_cols(col_names_b)
+
+    col_expr_a = col_names_a.exprs()
+
+    if isinstance(df_a, pl.DataFrame):
+        df_a = df_a.lazy()
+
+    if isinstance(df_b, pl.DataFrame):
+        df_b = df_b.lazy()
+
+    if '_index' not in df_a.collect_schema().names():
+        df_a = df_a.with_row_index('_index').with_columns(pl.col('_index').cast(pl.UInt64))
+
+    # Records with null pos/end are kept and assigned a null proportion at the end.
+    df_a_clean = df_a.filter(
+        pl.col(col_names_a.pos).is_not_null(),
+        pl.col(col_names_a.end).is_not_null(),
+    )
+
+    # Collapse overlapping b intervals so coverage is not double-counted.
+    df_b_nr = (
+        merge_depth(df_b, 0, col_names_b)
+        .select(*col_names_b.exprs())
+        .collect()
+    )
+
+    df_join = pairwise_join(
+        df_a=df_a_clean,
+        df_b=df_b_nr,
+        col_names_a=col_names_a,
+        col_names_b=col_names_b,
+        temp_dir=temp_dir,
+    )
+
+    df_overlap = (
+        df_join
+        .filter(pl.col('end') > pl.col('pos'))
+        .select(
+            pl.col('index_a').alias('_index'),
+            (pl.col('end') - pl.col('pos')).alias('_overlap'),
+        )
+        .group_by('_index')
+        .agg(pl.col('_overlap').sum())
+    )
+
+    return (
+        df_a
+        .select(
+            '_index',
+            (col_expr_a.end - col_expr_a.pos).alias('_len'),
+        )
+        .join(df_overlap.lazy(), on='_index', how='left')
+        .select(
+            '_index',
+            (pl.col('_overlap').fill_null(0.0) / pl.col('_len')).alias(name),
+        )
+    )