smftools 0.2.5__py3-none-any.whl → 0.3.1__py3-none-any.whl

smftools/plotting/hmm_plotting.py

@@ -1,9 +1,21 @@
+from __future__ import annotations
+
 import math
-from typing import Optional, Tuple, Union
+from typing import Optional, Sequence, Tuple, Union
 
-import matplotlib.pyplot as plt
 import numpy as np
-from matplotlib.backends.backend_pdf import PdfPages
+import pandas as pd
+
+from smftools.optional_imports import require
+
+plt = require("matplotlib.pyplot", extra="plotting", purpose="HMM plots")
+mpl_colors = require("matplotlib.colors", extra="plotting", purpose="HMM plots")
+pdf_backend = require(
+    "matplotlib.backends.backend_pdf",
+    extra="plotting",
+    purpose="PDF output",
+)
+PdfPages = pdf_backend.PdfPages
 
 
 def plot_hmm_size_contours(
@@ -22,6 +34,9 @@ def plot_hmm_size_contours(
     dpi: int = 150,
     vmin: Optional[float] = None,
     vmax: Optional[float] = None,
+    feature_ranges: Optional[Sequence[Tuple[int, int, str]]] = None,
+    zero_color: str = "#f5f1e8",
+    nan_color: str = "#E6E6E6",
     # ---------------- smoothing params ----------------
     smoothing_sigma: Optional[Union[float, Tuple[float, float]]] = None,
     normalize_after_smoothing: bool = True,
@@ -30,6 +45,9 @@ def plot_hmm_size_contours(
     """
     Create contour/pcolormesh plots of P(length | position) using a length-encoded HMM layer.
     Optional Gaussian smoothing applied to the 2D probability grid before plotting.
+    When feature_ranges is provided, each length row is assigned a base color based
+    on the matching (min_len, max_len) range and the probability value modulates
+    the color intensity.
 
     smoothing_sigma: None or 0 -> no smoothing.
         float -> same sigma applied to (length_axis, position_axis)
@@ -38,6 +56,51 @@ def plot_hmm_size_contours(
 
     Other args are the same as prior function.
     """
+    feature_ranges = tuple(feature_ranges or ())
+
+    def _resolve_length_color(length: int, fallback: str) -> Tuple[float, float, float, float]:
+        for min_len, max_len, color in feature_ranges:
+            if min_len <= length <= max_len:
+                return mpl_colors.to_rgba(color)
+        return mpl_colors.to_rgba(fallback)
+
+    def _build_length_facecolors(
+        Z_values: np.ndarray,
+        lengths: np.ndarray,
+        fallback_color: str,
+        *,
+        vmin_local: Optional[float],
+        vmax_local: Optional[float],
+    ) -> np.ndarray:
+        zero_rgba = np.array(mpl_colors.to_rgba(zero_color))
+        nan_rgba = np.array(mpl_colors.to_rgba(nan_color))
+        base_colors = np.array(
+            [_resolve_length_color(int(length), fallback_color) for length in lengths],
+            dtype=float,
+        )
+        base_colors[:, 3] = 1.0
+
+        scale = np.array(Z_values, copy=True, dtype=float)
+        finite_mask = np.isfinite(scale)
+        if not finite_mask.any():
+            facecolors = np.zeros(scale.shape + (4,), dtype=float)
+            facecolors[:] = nan_rgba
+            return facecolors.reshape(-1, 4)
+
+        vmin_use = np.nanmin(scale) if vmin_local is None else vmin_local
+        vmax_use = np.nanmax(scale) if vmax_local is None else vmax_local
+        denom = vmax_use - vmin_use
+        if denom <= 0:
+            norm = np.zeros_like(scale)
+        else:
+            norm = (scale - vmin_use) / denom
+        norm = np.clip(norm, 0, 1)
+
+        row_colors = base_colors[:, None, :]
+        facecolors = zero_rgba + norm[..., None] * (row_colors - zero_rgba)
+        facecolors[..., 3] = 1.0
+        facecolors[~finite_mask] = nan_rgba
+        return facecolors.reshape(-1, 4)
 
     # --- helper: gaussian smoothing (scipy fallback -> numpy separable conv) ---
     def _gaussian_1d_kernel(sigma: float, eps: float = 1e-12):
@@ -140,7 +203,8 @@ def plot_hmm_size_contours(
     figs = []
 
     # decide global max length to allocate y axis (cap to avoid huge memory)
-    observed_max_len = int(np.max(full_layer)) if full_layer.size > 0 else 0
+    finite_lengths = full_layer[np.isfinite(full_layer) & (full_layer > 0)]
+    observed_max_len = int(np.nanmax(finite_lengths)) if finite_lengths.size > 0 else 0
     if max_length_cap is None:
         max_len = observed_max_len
     else:
@@ -195,10 +259,15 @@ def plot_hmm_size_contours(
                     ax.text(0.5, 0.5, "no data", ha="center", va="center")
                     ax.set_title(f"{sample} / {ref}")
                     continue
+                valid_lengths = sub[np.isfinite(sub) & (sub > 0)]
+                if valid_lengths.size == 0:
+                    ax.text(0.5, 0.5, "no data", ha="center", va="center")
+                    ax.set_title(f"{sample} / {ref}")
+                    continue
 
                 # compute counts per length per position
                 n_positions = sub.shape[1]
-                max_len_local = int(sub.max()) if sub.size > 0 else 0
+                max_len_local = int(valid_lengths.max()) if valid_lengths.size > 0 else 0
                 max_len_here = min(max_len, max_len_local)
 
                 lengths_range = np.arange(1, max_len_here + 1, dtype=int)
@@ -209,7 +278,7 @@ def plot_hmm_size_contours(
                 # fill Z by efficient bincount across columns
                 for j in range(n_positions):
                     col_vals = sub[:, j]
-                    pos_vals = col_vals[col_vals > 0].astype(int)
+                    pos_vals = col_vals[np.isfinite(col_vals) & (col_vals > 0)].astype(int)
                     if pos_vals.size == 0:
                         continue
                     clipped = np.clip(pos_vals, 1, max_len_here)
@@ -248,9 +317,28 @@ def plot_hmm_size_contours(
                 dy = 1.0
                 y_edges = np.concatenate([y - 0.5, [y[-1] + 0.5]])
 
-                pcm = ax.pcolormesh(
-                    x_edges, y_edges, Z_plot, cmap=cmap, shading="auto", vmin=vmin, vmax=vmax
-                )
+                if feature_ranges:
+                    fallback_color = mpl_colors.to_rgba(plt.get_cmap(cmap)(1.0))
+                    facecolors = _build_length_facecolors(
+                        Z_plot,
+                        lengths_range,
+                        fallback_color,
+                        vmin_local=vmin,
+                        vmax_local=vmax,
+                    )
+                    pcm = ax.pcolormesh(
+                        x_edges,
+                        y_edges,
+                        Z_plot,
+                        shading="auto",
+                        vmin=vmin,
+                        vmax=vmax,
+                        facecolors=facecolors,
+                    )
+                else:
+                    pcm = ax.pcolormesh(
+                        x_edges, y_edges, Z_plot, cmap=cmap, shading="auto", vmin=vmin, vmax=vmax
+                    )
                 ax.set_title(f"{sample} / {ref}")
                 ax.set_ylabel("length")
                 if i_row == rows_on_page - 1:

smftools/plotting/position_stats.py

@@ -1,3 +1,8 @@
+from __future__ import annotations
+
+from smftools.optional_imports import require
+
+
 def plot_volcano_relative_risk(
     results_dict,
     save_path=None,
@@ -22,7 +27,7 @@ def plot_volcano_relative_risk(
     """
     import os
 
-    import matplotlib.pyplot as plt
+    plt = require("matplotlib.pyplot", extra="plotting", purpose="relative risk plots")
 
     for ref, group_results in results_dict.items():
         for group_label, (results_df, _) in group_results.items():
@@ -124,7 +129,7 @@ def plot_bar_relative_risk(
     """
     import os
 
-    import matplotlib.pyplot as plt
+    plt = require("matplotlib.pyplot", extra="plotting", purpose="relative risk plots")
 
     for ref, group_data in results_dict.items():
         for group_label, (df, _) in group_data.items():
@@ -229,10 +234,11 @@ def plot_positionwise_matrix(
     """
     import os
 
-    import matplotlib.pyplot as plt
     import numpy as np
     import pandas as pd
-    import seaborn as sns
+
+    plt = require("matplotlib.pyplot", extra="plotting", purpose="position stats plots")
+    sns = require("seaborn", extra="plotting", purpose="position stats plots")
 
     def find_closest_index(index, target):
         """Find the index value closest to a target value."""
@@ -408,12 +414,14 @@ def plot_positionwise_matrix_grid(
     """
     import os
 
-    import matplotlib.pyplot as plt
     import numpy as np
     import pandas as pd
-    import seaborn as sns
     from joblib import Parallel, delayed
-    from matplotlib.gridspec import GridSpec
+
+    plt = require("matplotlib.pyplot", extra="plotting", purpose="position stats plots")
+    sns = require("seaborn", extra="plotting", purpose="position stats plots")
+    grid_spec = require("matplotlib.gridspec", extra="plotting", purpose="position stats plots")
+    GridSpec = grid_spec.GridSpec
 
     matrices = adata.uns[key]
     group_labels = list(matrices.keys())

smftools/plotting/qc_plotting.py

@@ -1,9 +1,14 @@
+from __future__ import annotations
+
 import os
 
-import matplotlib.pyplot as plt
 import numpy as np
 import pandas as pd
 
+from smftools.optional_imports import require
+
+plt = require("matplotlib.pyplot", extra="plotting", purpose="QC plots")
+
 
 def plot_read_qc_histograms(
     adata,

smftools/preprocessing/__init__.py

@@ -1,38 +1,37 @@
-from .append_base_context import append_base_context
-from .append_binary_layer_by_base_context import append_binary_layer_by_base_context
-from .binarize import binarize_adata
-from .binarize_on_Youden import binarize_on_Youden
-from .calculate_complexity_II import calculate_complexity_II
-from .calculate_coverage import calculate_coverage
-from .calculate_position_Youden import calculate_position_Youden
-from .calculate_read_length_stats import calculate_read_length_stats
-from .calculate_read_modification_stats import calculate_read_modification_stats
-from .clean_NaN import clean_NaN
-from .filter_adata_by_nan_proportion import filter_adata_by_nan_proportion
-from .filter_reads_on_length_quality_mapping import filter_reads_on_length_quality_mapping
-from .filter_reads_on_modification_thresholds import filter_reads_on_modification_thresholds
-from .flag_duplicate_reads import flag_duplicate_reads
-from .invert_adata import invert_adata
-from .load_sample_sheet import load_sample_sheet
-from .reindex_references_adata import reindex_references_adata
-from .subsample_adata import subsample_adata
+from __future__ import annotations
 
-__all__ = [
-    "append_base_context",
-    "append_binary_layer_by_base_context",
-    "binarize_on_Youden",
-    "binarize_adata",
-    "calculate_complexity_II",
-    "calculate_read_modification_stats",
-    "calculate_coverage",
-    "calculate_position_Youden",
-    "calculate_read_length_stats",
-    "clean_NaN",
-    "filter_adata_by_nan_proportion",
-    "filter_reads_on_modification_thresholds",
-    "filter_reads_on_length_quality_mapping",
-    "invert_adata",
-    "load_sample_sheet",
-    "flag_duplicate_reads",
-    "subsample_adata",
-]
+from importlib import import_module
+
+_LAZY_ATTRS = {
+    "append_base_context": "smftools.preprocessing.append_base_context",
+    "append_binary_layer_by_base_context": "smftools.preprocessing.append_binary_layer_by_base_context",
+    "append_mismatch_frequency_sites": "smftools.preprocessing.append_mismatch_frequency_sites",
+    "binarize_adata": "smftools.preprocessing.binarize",
+    "binarize_on_Youden": "smftools.preprocessing.binarize_on_Youden",
+    "calculate_complexity_II": "smftools.preprocessing.calculate_complexity_II",
+    "calculate_coverage": "smftools.preprocessing.calculate_coverage",
+    "calculate_position_Youden": "smftools.preprocessing.calculate_position_Youden",
+    "calculate_read_length_stats": "smftools.preprocessing.calculate_read_length_stats",
+    "calculate_read_modification_stats": "smftools.preprocessing.calculate_read_modification_stats",
+    "clean_NaN": "smftools.preprocessing.clean_NaN",
+    "filter_adata_by_nan_proportion": "smftools.preprocessing.filter_adata_by_nan_proportion",
+    "filter_reads_on_length_quality_mapping": "smftools.preprocessing.filter_reads_on_length_quality_mapping",
+    "filter_reads_on_modification_thresholds": "smftools.preprocessing.filter_reads_on_modification_thresholds",
+    "flag_duplicate_reads": "smftools.preprocessing.flag_duplicate_reads",
+    "invert_adata": "smftools.preprocessing.invert_adata",
+    "load_sample_sheet": "smftools.preprocessing.load_sample_sheet",
+    "reindex_references_adata": "smftools.preprocessing.reindex_references_adata",
+    "subsample_adata": "smftools.preprocessing.subsample_adata",
+}
+
+
+def __getattr__(name: str):
+    if name in _LAZY_ATTRS:
+        module = import_module(_LAZY_ATTRS[name])
+        attr = getattr(module, name)
+        globals()[name] = attr
+        return attr
+    raise AttributeError(f"module '{__name__}' has no attribute '{name}'")
+
+
+__all__ = list(_LAZY_ATTRS.keys())

smftools/preprocessing/append_base_context.py

@@ -133,23 +133,23 @@ def append_base_context(
                 adata.var[f"{ref}_{site_type}_valid_coverage"] = (
                     (adata.var[f"{ref}_{site_type}"]) & (adata.var[f"position_in_{ref}"])
                 )
-                if native:
-                    adata.obsm[f"{ref}_{site_type}_valid_coverage"] = adata[
-                        :, adata.var[f"{ref}_{site_type}_valid_coverage"]
-                    ].layers["binarized_methylation"]
-                else:
-                    adata.obsm[f"{ref}_{site_type}_valid_coverage"] = adata[
-                        :, adata.var[f"{ref}_{site_type}_valid_coverage"]
-                    ].X
-            else:
-                pass
-
-            if native:
-                adata.obsm[f"{ref}_{site_type}"] = adata[:, adata.var[f"{ref}_{site_type}"]].layers[
-                    "binarized_methylation"
-                ]
-            else:
-                adata.obsm[f"{ref}_{site_type}"] = adata[:, adata.var[f"{ref}_{site_type}"]].X
+            #     if native:
+            #         adata.obsm[f"{ref}_{site_type}_valid_coverage"] = adata[
+            #             :, adata.var[f"{ref}_{site_type}_valid_coverage"]
+            #         ].layers["binarized_methylation"]
+            #     else:
+            #         adata.obsm[f"{ref}_{site_type}_valid_coverage"] = adata[
+            #             :, adata.var[f"{ref}_{site_type}_valid_coverage"]
+            #         ].X
+            # else:
+            #     pass
+
+            # if native:
+            #     adata.obsm[f"{ref}_{site_type}"] = adata[:, adata.var[f"{ref}_{site_type}"]].layers[
+            #         "binarized_methylation"
+            #     ]
+            # else:
+            #     adata.obsm[f"{ref}_{site_type}"] = adata[:, adata.var[f"{ref}_{site_type}"]].X
 
     # mark as done
     adata.uns[uns_flag] = True

smftools/preprocessing/append_mismatch_frequency_sites.py

@@ -0,0 +1,158 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Iterable, Sequence
+
+import numpy as np
+import pandas as pd
+
+from smftools.constants import MODKIT_EXTRACT_SEQUENCE_BASE_TO_INT
+from smftools.logging_utils import get_logger
+
+if TYPE_CHECKING:
+    import anndata as ad
+
+logger = get_logger(__name__)
+
+
+def append_mismatch_frequency_sites(
+    adata: "ad.AnnData",
+    ref_column: str = "Reference_strand",
+    mismatch_layer: str = "mismatch_integer_encoding",
+    read_span_layer: str = "read_span_mask",
+    mismatch_frequency_range: Sequence[float] | None = (0.05, 0.95),
+    uns_flag: str = "append_mismatch_frequency_sites_performed",
+    force_redo: bool = False,
+    bypass: bool = False,
+) -> None:
+    """Append mismatch frequency metadata and variable-site flags per reference.
+
+    Args:
+        adata: AnnData object.
+        ref_column: Obs column defining reference categories.
+        mismatch_layer: Layer containing mismatch integer encodings.
+        read_span_layer: Layer containing read span masks (1=covered, 0=not covered).
+        mismatch_frequency_range: Lower/upper bounds (inclusive) for variable site flagging.
+        uns_flag: Flag in ``adata.uns`` indicating prior completion.
+        force_redo: Whether to rerun even if ``uns_flag`` is set.
+        bypass: Whether to skip running this step.
+    """
+    if bypass:
+        return
+
+    already = bool(adata.uns.get(uns_flag, False))
+    if already and not force_redo:
+        return
+
+    if mismatch_layer not in adata.layers:
+        logger.debug(
+            "Mismatch layer '%s' not found; skipping mismatch frequency step.", mismatch_layer
+        )
+        return
+
+    mismatch_map = adata.uns.get("mismatch_integer_encoding_map", {})
+    if not mismatch_map:
+        logger.debug("Mismatch encoding map not found; skipping mismatch frequency step.")
+        return
+
+    n_value = mismatch_map.get("N", MODKIT_EXTRACT_SEQUENCE_BASE_TO_INT["N"])
+    pad_value = mismatch_map.get("PAD", MODKIT_EXTRACT_SEQUENCE_BASE_TO_INT["PAD"])
+
+    base_int_to_label = {
+        int(value): str(base)
+        for base, value in mismatch_map.items()
+        if base not in {"N", "PAD"} and isinstance(value, (int, np.integer))
+    }
+    if not base_int_to_label:
+        logger.debug("Mismatch encoding map missing base labels; skipping mismatch frequency step.")
+        return
+
+    has_span_mask = read_span_layer in adata.layers
+    if not has_span_mask:
+        logger.debug(
+            "Read span mask '%s' not found; mismatch frequencies will be computed over all reads.",
+            read_span_layer,
+        )
+
+    references = adata.obs[ref_column].cat.categories
+    n_vars = adata.shape[1]
+
+    if mismatch_frequency_range is None:
+        mismatch_frequency_range = (0.0, 1.0)
+
+    lower_bound, upper_bound = mismatch_frequency_range
+
+    for ref in references:
+        ref_mask = adata.obs[ref_column] == ref
+        ref_position_mask = adata.var.get(f"position_in_{ref}")
+        if ref_position_mask is None:
+            ref_position_mask = pd.Series(np.ones(n_vars, dtype=bool), index=adata.var.index)
+        else:
+            ref_position_mask = ref_position_mask.astype(bool)
+
+        frequency_values = np.full(n_vars, np.nan, dtype=float)
+        variable_flags = np.zeros(n_vars, dtype=bool)
+        mismatch_base_frequencies: list[list[tuple[str, float]]] = [[] for _ in range(n_vars)]
+
+        if ref_mask.sum() == 0:
+            adata.var[f"{ref}_mismatch_frequency"] = pd.Series(
+                frequency_values, index=adata.var.index
+            )
+            adata.var[f"{ref}_variable_sequence_site"] = pd.Series(
+                variable_flags, index=adata.var.index
+            )
+            adata.var[f"{ref}_mismatch_base_frequencies"] = pd.Series(
+                mismatch_base_frequencies, index=adata.var.index
+            )
+            continue
+
+        mismatch_matrix = np.asarray(adata.layers[mismatch_layer][ref_mask])
+        if has_span_mask:
+            span_matrix = np.asarray(adata.layers[read_span_layer][ref_mask])
+            coverage_mask = span_matrix > 0
+            coverage_counts = coverage_mask.sum(axis=0).astype(float)
+        else:
+            coverage_mask = np.ones_like(mismatch_matrix, dtype=bool)
+            coverage_counts = np.full(n_vars, ref_mask.sum(), dtype=float)
+
+        mismatch_mask = (~np.isin(mismatch_matrix, [n_value, pad_value])) & coverage_mask
+        mismatch_counts = mismatch_mask.sum(axis=0)
+
+        frequency_values = np.divide(
+            mismatch_counts,
+            coverage_counts,
+            out=np.full(n_vars, np.nan, dtype=float),
+            where=coverage_counts > 0,
+        )
+        frequency_values = np.where(ref_position_mask.values, frequency_values, np.nan)
+
+        variable_flags = (
+            (frequency_values >= lower_bound)
+            & (frequency_values <= upper_bound)
+            & ref_position_mask.values
+        )
+
+        base_counts_by_int: dict[int, np.ndarray] = {}
+        for base_int in base_int_to_label:
+            base_counts_by_int[base_int] = ((mismatch_matrix == base_int) & coverage_mask).sum(
+                axis=0
+            )
+
+        for idx in range(n_vars):
+            if not ref_position_mask.iloc[idx] or coverage_counts[idx] == 0:
+                continue
+            base_freqs: list[tuple[str, float]] = []
+            for base_int, base_label in base_int_to_label.items():
+                count = base_counts_by_int[base_int][idx]
+                if count > 0:
+                    base_freqs.append((base_label, float(count / coverage_counts[idx])))
+            mismatch_base_frequencies[idx] = base_freqs
+
+        adata.var[f"{ref}_mismatch_frequency"] = pd.Series(frequency_values, index=adata.var.index)
+        adata.var[f"{ref}_variable_sequence_site"] = pd.Series(
+            variable_flags, index=adata.var.index
+        )
+        adata.var[f"{ref}_mismatch_base_frequencies"] = pd.Series(
+            mismatch_base_frequencies, index=adata.var.index
+        )
+
+    adata.uns[uns_flag] = True

smftools/preprocessing/archived/add_read_length_and_mapping_qc.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import numpy as np
 import pandas as pd
 import scipy.sparse as sp

smftools/preprocessing/archived/calculate_complexity.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 ## calculate_complexity
 
 def calculate_complexity(adata, output_directory='', obs_column='Reference', sample_col='Sample_names', plot=True, save_plot=False):

smftools/preprocessing/archived/mark_duplicates.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 ## mark_duplicates
 
 def mark_duplicates(adata, layers, obs_column='Reference', sample_col='Sample_names', method='N_masked_distances', distance_thresholds={}):

smftools/preprocessing/archived/preprocessing.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 ## preprocessing
 from .. import readwrite
 

smftools/preprocessing/archived/remove_duplicates.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 # remove_duplicates
 
 def remove_duplicates(adata):

smftools/preprocessing/binary_layers_to_ohe.py

@@ -1,5 +1,6 @@
-## binary_layers_to_ohe
+from __future__ import annotations
 
+## binary_layers_to_ohe
 from smftools.logging_utils import get_logger
 
 logger = get_logger(__name__)

smftools/preprocessing/calculate_complexity_II.py

@@ -3,6 +3,8 @@ from __future__ import annotations
 from pathlib import Path
 from typing import TYPE_CHECKING, Optional
 
+from smftools.optional_imports import require
+
 if TYPE_CHECKING:
     import anndata as ad
 
@@ -46,11 +48,12 @@ def calculate_complexity_II(
     """
     import os
 
-    import matplotlib.pyplot as plt
     import numpy as np
     import pandas as pd
     from scipy.optimize import curve_fit
 
+    plt = require("matplotlib.pyplot", extra="plotting", purpose="complexity plots")
+
     # early exits
     already = bool(adata.uns.get(uns_flag, False))
     if already and not force_redo:

smftools/preprocessing/calculate_consensus.py

@@ -53,4 +53,4 @@ def calculate_consensus(
     else:
         adata.var[f"{reference}_consensus_across_samples"] = consensus_sequence_list
 
-    adata.uns[f"{reference}_consensus_sequence"] = consensus_sequence_list
+    adata.uns[f"{reference}_consensus_sequence"] = str(consensus_sequence_list)

smftools/preprocessing/calculate_pairwise_differences.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 # calculate_pairwise_differences
 
 

smftools/preprocessing/calculate_pairwise_hamming_distances.py

@@ -1,5 +1,8 @@
+from __future__ import annotations
+
 ## calculate_pairwise_hamming_distances
 
+
 ## Conversion SMF Specific
 def calculate_pairwise_hamming_distances(arrays):
     """

smftools/preprocessing/calculate_position_Youden.py

@@ -6,6 +6,7 @@ from pathlib import Path
 from typing import TYPE_CHECKING
 
 from smftools.logging_utils import get_logger
+from smftools.optional_imports import require
 
 if TYPE_CHECKING:
     import anndata as ad
@@ -40,9 +41,15 @@ def calculate_position_Youden(
         save: Whether to save ROC plots to disk.
         output_directory: Output directory for ROC plots.
     """
-    import matplotlib.pyplot as plt
     import numpy as np
-    from sklearn.metrics import roc_curve
+
+    plt = require("matplotlib.pyplot", extra="plotting", purpose="Youden ROC plots")
+    sklearn_metrics = require(
+        "sklearn.metrics",
+        extra="ml-base",
+        purpose="Youden ROC curve calculation",
+    )
+    roc_curve = sklearn_metrics.roc_curve
 
     control_samples = [positive_control_sample, negative_control_sample]
     references = adata.obs[ref_column].cat.categories

smftools/preprocessing/calculate_read_modification_stats.py

@@ -20,6 +20,7 @@ def calculate_read_modification_stats(
     force_redo: bool = False,
     valid_sites_only: bool = False,
     valid_site_suffix: str = "_valid_coverage",
+    smf_modality: str = "conversion",
 ) -> None:
     """Add methylation/deamination statistics for each read.
 
@@ -80,8 +81,12 @@ def calculate_read_modification_stats(
     for ref in references:
         ref_subset = adata[adata.obs[reference_column] == ref]
         for site_type in site_types:
+            site_subset = ref_subset[:, ref_subset.var[f"{ref}_{site_type}{valid_site_suffix}"]]
             logger.info("Iterating over %s_%s", ref, site_type)
-            observation_matrix = ref_subset.obsm[f"{ref}_{site_type}{valid_site_suffix}"]
+            if smf_modality == "native":
+                observation_matrix = site_subset.layers["binarized_methylation"]
+            else:
+                observation_matrix = site_subset.X
             total_positions_in_read = np.nansum(~np.isnan(observation_matrix), axis=1)
             total_positions_in_reference = observation_matrix.shape[1]
             fraction_valid_positions_in_read_vs_ref = (

smftools/preprocessing/filter_reads_on_length_quality_mapping.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from typing import Optional, Sequence, Union
 
 import anndata as ad

smftools/preprocessing/filter_reads_on_modification_thresholds.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import gc
 from typing import List, Optional, Sequence