agglovar 0.0.1.dev12__tar.gz → 0.0.1.dev13__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agglovar
-Version: 0.0.1.dev12
+Version: 0.0.1.dev13
 Summary: Toolkit for fast genomic variant transformations and intersects
 License-Expression: MIT
 Requires-Python: >=3.12
@@ -12,6 +12,7 @@ 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.dev13}/pyproject.toml

@@ -17,6 +17,7 @@ dependencies = [
     "numpy>=2.3.0",
     "ply>=3.11",
     "polars[numpy,pandas,pyarrow]>=1.35.2",
+    "pysam>=0.23.3",
 ]
 
 [agglovar.urls]

{agglovar-0.0.1.dev12 → agglovar-0.0.1.dev13}/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.dev13'
 
 __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.dev13}/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.dev13}/src/agglovar/bed/col.py

@@ -123,7 +123,6 @@ def get_coord_cols(
 
     :return: An object with column names.
     """
-
     if isinstance(col_names, CoordCol):
         return col_names
 
@@ -137,7 +136,7 @@ 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:
@@ -181,7 +180,6 @@ def make_unique_col(
 
     :return: Unique column name.
     """
-
     new_col = col
     i = 0
 
@@ -189,5 +187,4 @@ def make_unique_col(
         i += 1
         new_col = f'{col}_{i}'
 
-
     return new_col

{agglovar-0.0.1.dev12 → agglovar-0.0.1.dev13}/src/agglovar/bed/join.py

@@ -192,6 +192,8 @@ def _join_chunks(
     col_a = join_resources.col_a
     col_b = join_resources.col_b
 
+    yield_count = 0
+
     for chrom, last_index_a in (
         df_a
         .group_by(col_a.chrom)
@@ -275,8 +277,38 @@ def _join_chunks(
 
                 start_index_b = end_index_b
 
+                yield_count += 1
+
             start_index_a = end_index_a
 
+    if yield_count == 0:
+        # Iterator should always return at least one chunk, even if empty. Prevents pl.concat from failing.
+        yield (
+            df_a.filter(False)
+            .join(
+                df_b.filter(False),
+                left_on=col_a.chrom,
+                right_on=col_b.chrom,
+                how='inner',
+            )
+            .filter(
+                pl.col(col_b.pos) - distance <= pl.col(col_a.end),
+                pl.col(col_b.end) + distance >= pl.col(col_a.pos),
+            )
+            .select(
+                pl.col('_index_a').alias('index_a'),
+                pl.col('_index_b').alias('index_b'),
+                pl.col(col_a.chrom).alias('chrom'),
+                pl.max_horizontal(col_a.pos, col_b.pos).alias('pos'),
+                pl.min_horizontal(col_a.end, col_b.end).alias('end'),
+            )
+            .with_columns(
+                pl.min_horizontal('pos', 'end').alias('pos'),
+                pl.max_horizontal('pos', 'end').alias('end'),
+                (pl.col('pos') - pl.col('end')).alias('distance')
+            )
+        ).collect().lazy()
+
 
 def pairwise_join_tree(
         df_a: pl.LazyFrame | pl.DataFrame,

agglovar-0.0.1.dev13/src/agglovar/expr/__init__.py

@@ -0,0 +1,7 @@
+"""Commonly used expressions."""
+
+__all__ = [
+    'variant',
+]
+
+from . import variant

agglovar-0.0.1.dev13/src/agglovar/expr/variant.py

@@ -0,0 +1,61 @@
+"""Polars expressions used by variant calling routines."""
+
+__all__ = [
+    'id_snv_expr',
+    'id_nonsnv_expr',
+    'sort_cols',
+    'id_expr_noalias',
+    'id_expr',
+]
+
+import polars as pl
+
+id_snv_expr = (
+    pl.concat_str(
+        pl.col('chrom'),
+        pl.lit('-'),
+        pl.col('pos') + 1,
+        pl.lit('-SNV-'),
+        pl.col('ref').str.to_uppercase(),
+        pl.col('alt').str.to_uppercase(),
+    )
+)
+"""Expression for generating SNV IDs."""
+
+
+id_nonsnv_expr = (
+    pl.concat_str(
+        pl.col('chrom'),
+        pl.lit('-'),
+        (pl.col('pos') + 1).cast(pl.String),
+        pl.lit('-'),
+        pl.col('vartype').str.to_uppercase(),
+        pl.lit('-'),
+        pl.col('varlen').cast(pl.String)
+    )
+)
+"""Expression for generating non-SNV IDs."""
+
+
+sort_cols = (
+    pl.col('chrom'),
+    pl.col('pos'),
+    pl.col('end'),
+    pl.col('filter').list.len(),
+    pl.coalesce(
+        pl.col('^id$'),
+        pl.lit(None),
+    )
+)
+"""Sort columns for variant tables."""
+
+
+id_expr_noalias = (
+    pl.when(pl.col('vartype').str.to_uppercase() == 'SNV')
+    .then(id_snv_expr)
+    .otherwise(id_nonsnv_expr)
+)
+"""Expression for generating variant IDs."""
+
+id_expr = id_expr_noalias.alias('id')
+"""Expression for generating variant IDs including alias "id" for the result (ideal for `with_column()`)."""

{agglovar-0.0.1.dev12 → agglovar-0.0.1.dev13}/src/agglovar/merge/base.py

@@ -58,7 +58,7 @@ class MergeBase(ABC):
     def get_intersect_tuples(
             callsets: Iterable[CallsetDefType],
             retain_index: bool = False,
-            pre_filter: Optional[Iterable[pl.Expr]] = None,
+            pre_filter: Optional[Iterable[pl.Expr] | pl.Expr] = None,
     ) -> list[tuple[pl.LazyFrame, str, int]]:
         """
         Transform input arguments to a list of tuples with set fields.
@@ -92,7 +92,10 @@ class MergeBase(ABC):
 
         i = 0
 
-        pre_filter = list(pre_filter if pre_filter is not None else [])
+        if isinstance(pre_filter, pl.Expr):
+            pre_filter = [pre_filter]
+        else:
+            pre_filter = list(pre_filter if pre_filter is not None else [])
 
         if callsets is None:
             raise ValueError('Missing callsets')
@@ -143,15 +146,13 @@ class MergeBase(ABC):
                 .with_columns(
                     pl.coalesce(
                         pl.col(r'^id$'),  # Existing ID if present
-                        pl.concat_str(pl.lit('var'), pl.col('_mg_src_index'))  # Fill missing/null
-                    ).cast(pl.String).alias('id')
-                )
-                .with_columns(
-                    (
-                        pl.when(pl.col('id').is_null())
-                        .then(pl.concat_str(pl.lit('var'),  pl.col('_mg_src_index')))
-                        .otherwise(pl.col('id'))
-                    ).cast(pl.String).alias('id')
+                        pl.lit(None)
+                    )
+                    .cast(pl.String)
+                    .fill_null(
+                        pl.concat_str(pl.lit('var'),  pl.col('_mg_src_index'))
+                    )
+                    .alias('id')
                 )
                 .filter(
                     *pre_filter

{agglovar-0.0.1.dev12 → agglovar-0.0.1.dev13}/src/agglovar/merge/cumulative.py

@@ -114,7 +114,12 @@ def _get_match(
         df_cumulative
         .with_row_index('_index')
         .join(
-            df_join.lazy().select(pl.all().name.prefix('_mg_join_')),
+            (
+                df_join.lazy()
+                .select(
+                    pl.all().name.prefix('_mg_join_')
+                )
+            ),
             left_on='_index', right_on='_mg_join_index_a', how='inner'
         )
         .with_columns(
@@ -164,7 +169,7 @@ class MergeCumulative(MergeBase):
             self,
             callsets: Iterable[CallsetDefType],
             retain_index: bool = False,
-            pre_filter: Optional[Iterable[pl.Expr]] = None,
+            pre_filter: Optional[Iterable[pl.Expr] | pl.Expr] = None,
             sort: bool = True,
             add_id: bool = True,
     ) -> pl.LazyFrame:
@@ -196,21 +201,20 @@ class MergeCumulative(MergeBase):
                 if col not in all_col_dict:
                     all_col_dict[col] = dtype
 
-        required_cols = [col for col in all_col_dict.keys() if col in required_cols]  # To list in order found in tables
-
-        # Initialize cumulative table
-        df_next, src_name, src_index = callsets[0]
-
-        merge_stat_cols = {  # Empty join, gets names of columns this join will return
-            col: dtype for col, dtype in self.pairwise_join.join(df_next.head(0), df_next.head(0)).collect_schema().items()
-                if col not in {'index_a', 'index_b', 'id_a', 'id_b'}
-        }
+        # Build reqired_cols from expected columns (includes optional columns), preserve order found in tables
+        required_cols = [col for col in all_col_dict.keys() if col in set(self.pairwise_join.expected_cols)]
 
         # Cumulative merge
         df_cumulative = None
+        merge_stat_cols = None
 
         for df_next, src_name, src_index in callsets:
             if df_cumulative is None:
+                merge_stat_cols = {  # Empty join, gets names of columns this join will return
+                    col: dtype for col, dtype in self.pairwise_join.join(df_next.head(0), df_next.head(0)).collect_schema().items()
+                        if col not in {'index_a', 'index_b', 'id_a', 'id_b'}
+                }
+
                 df_cumulative = (
                     _init_cumulative(df_next, src_index, src_name, required_cols, merge_stat_cols)
                     .sort('chrom', 'pos', 'end', 'id')
@@ -224,6 +228,7 @@ class MergeCumulative(MergeBase):
             df_join = (
                 (
                     self.pairwise_join.join(df_cumulative, df_next)
+                    .sort('weight', descending=True)
                     .unique('index_a', keep='first')
                     .unique('index_b', keep='first')
                     .sort('index_a', 'index_b')
@@ -266,6 +271,9 @@ class MergeCumulative(MergeBase):
                 _init_cumulative(
                     (
                         df_next
+                        # .with_columns(
+                        #     pl.col('index_b').alias('_mg_src_index')
+                        # )
                         .join(
                             df_join.lazy(),
                             left_on='_mg_src_index', right_on='index_b', how='anti'
@@ -276,13 +284,8 @@ class MergeCumulative(MergeBase):
             )
 
             df_cumulative = (
-                pl.concat([
-                    df_match.drop('_mg_src_index', strict=False),
-                    df_nomatch.drop('_mg_src_index', strict=False),
-                    df_new.drop('_mg_src_index', strict=False),
-                ])
+                pl.concat([df_match, df_nomatch, df_new])
                 .sort('chrom', 'pos', 'end')
-                .with_row_index('_mg_src_index')
                 .collect()
                 .lazy()
             )

{agglovar-0.0.1.dev12 → agglovar-0.0.1.dev13}/src/agglovar/pairwise/overlap/_const.py

@@ -33,8 +33,9 @@ AUTOGEN_COLS: frozenset[str] = frozenset({
 
 DEFAULT_CHUNK_SIZE: int = 1_500
 """
-Default size to chunk tables before joining. A value of 10,000 works well to balance combinatorial
-explosion without exploding the number of chunks to merge when overlapping large variant tables.
+Default number of df_a variants per chunk. Chunking controls peak memory and determines the batch
+size presented to the sequence-alignment thread pool — larger values amortize thread-pool overhead
+better but use more memory. Tune alongside ``n_threads`` based on available RAM and CPU count.
 """
 
 EXPR_OVERLAP_RO = (