smftools 0.2.1__py3-none-any.whl → 0.2.3__py3-none-any.whl

smftools/preprocessing/__init__.py

@@ -2,6 +2,7 @@ from .add_read_length_and_mapping_qc import add_read_length_and_mapping_qc
 from .append_base_context import append_base_context
 from .append_binary_layer_by_base_context import append_binary_layer_by_base_context
 from .binarize_on_Youden import binarize_on_Youden
+from .binarize import binarize_adata
 from .calculate_complexity import calculate_complexity
 from .calculate_complexity_II import calculate_complexity_II
 from .calculate_read_modification_stats import calculate_read_modification_stats
@@ -22,6 +23,7 @@ __all__ = [
     "append_base_context",
     "append_binary_layer_by_base_context",
     "binarize_on_Youden",
+    "binarize_adata",
     "calculate_complexity",
     "calculate_read_modification_stats",
     "calculate_coverage",    

smftools/preprocessing/append_base_context.py

@@ -34,7 +34,7 @@ def append_base_context(adata,
     site_types = []
     
     if any(base in mod_target_bases for base in ['GpC', 'CpG', 'C']):
-        site_types += ['GpC_site', 'CpG_site', 'ambiguous_GpC_CpG_site', 'other_C_site', 'any_C_site']
+        site_types += ['GpC_site', 'CpG_site', 'ambiguous_GpC_CpG_site', 'other_C_site', 'C_site']
     
     if 'A' in mod_target_bases:
         site_types += ['A_site']
@@ -70,7 +70,7 @@ def append_base_context(adata,
                 # Iterate through the sequence and apply the criteria
                 for i in range(1, len(sequence) - 1):
                     if sequence[i] == 'C':
-                        boolean_dict[f'{cat}_any_C_site'][i] = True
+                        boolean_dict[f'{cat}_C_site'][i] = True
                         if sequence[i - 1] == 'G' and sequence[i + 1] != 'G':
                             boolean_dict[f'{cat}_GpC_site'][i] = True
                         elif sequence[i - 1] == 'G' and sequence[i + 1] == 'G':
@@ -83,7 +83,7 @@ def append_base_context(adata,
                 # Iterate through the sequence and apply the criteria
                 for i in range(1, len(sequence) - 1):
                     if sequence[i] == 'G':
-                        boolean_dict[f'{cat}_any_C_site'][i] = True
+                        boolean_dict[f'{cat}_C_site'][i] = True
                         if sequence[i + 1] == 'C' and sequence[i - 1] != 'C':
                             boolean_dict[f'{cat}_GpC_site'][i] = True
                         elif sequence[i - 1] == 'C' and sequence[i + 1] == 'C':

smftools/preprocessing/append_binary_layer_by_base_context.py

@@ -15,7 +15,7 @@ def append_binary_layer_by_base_context(
       - GpC_site_binary
       - CpG_site_binary
       - GpC_CpG_combined_site_binary (numeric sum where present; NaN where neither present)
-      - any_C_site_binary
+      - C_site_binary
       - other_C_site_binary
 
     Behavior:
@@ -48,7 +48,7 @@ def append_binary_layer_by_base_context(
     references = adata.obs[reference_column].astype("category").cat.categories
     reference_to_gpc_column = {ref: f"{ref}_GpC_site" for ref in references}
     reference_to_cpg_column = {ref: f"{ref}_CpG_site" for ref in references}
-    reference_to_c_column = {ref: f"{ref}_any_C_site" for ref in references}
+    reference_to_c_column = {ref: f"{ref}_C_site" for ref in references}
     reference_to_other_c_column = {ref: f"{ref}_other_C_site" for ref in references}
 
     # verify var columns exist and build boolean masks per ref (len = n_vars)
@@ -124,7 +124,7 @@ def append_binary_layer_by_base_context(
     adata.layers['GpC_site_binary'] = masked_gpc
     adata.layers['CpG_site_binary'] = masked_cpg
     adata.layers['GpC_CpG_combined_site_binary'] = combined_sum
-    adata.layers['any_C_site_binary'] = masked_any_c
+    adata.layers['C_site_binary'] = masked_any_c
     adata.layers['other_C_site_binary'] = masked_other_c
 
     if verbose:
@@ -134,7 +134,7 @@ def append_binary_layer_by_base_context(
         print(f"  GpC: {_filled_positions(masked_gpc)}")
         print(f"  CpG: {_filled_positions(masked_cpg)}")
         print(f"  GpC+CpG combined: {_filled_positions(combined_sum)}")
-        print(f"  any_C: {_filled_positions(masked_any_c)}")
+        print(f"  C: {_filled_positions(masked_any_c)}")
         print(f"  other_C: {_filled_positions(masked_other_c)}")
 
     # mark as done

smftools/preprocessing/binarize.py

@@ -0,0 +1,17 @@
+import numpy as np
+
+def binarize_adata(adata, source="X", target_layer="binary", threshold=0.8):
+    """
+    Binarize a dense matrix and preserve NaN.
+    source: "X" or layer name
+    """
+    X = adata.X if source == "X" else adata.layers[source]
+
+    # Copy to avoid modifying original in-place
+    X_bin = X.copy()
+
+    # Where not NaN: apply threshold
+    mask = ~np.isnan(X_bin)
+    X_bin[mask] = (X_bin[mask] > threshold).astype(np.int8)
+
+    adata.layers[target_layer] = X_bin

smftools/preprocessing/binarize_on_Youden.py

@@ -1,4 +1,4 @@
-def binarize_on_Youden(adata, obs_column='Reference'):
+def binarize_on_Youden(adata, obs_column='Reference', output_layer_name='binarized_methylation'):
     """
     Binarize SMF values based on position thresholds determined by calculate_position_Youden.
 
@@ -42,4 +42,4 @@ def binarize_on_Youden(adata, obs_column='Reference'):
         binarized_methylation[cat_mask, :] = binarized_matrix
 
     # Store the binarized matrix in a new layer
-    adata.layers['binarized_methylation'] = binarized_methylation
+    adata.layers[output_layer_name] = binarized_methylation

smftools/preprocessing/calculate_position_Youden.py

@@ -103,7 +103,7 @@ def calculate_position_Youden(adata, positive_control_sample='positive', negativ
                     probability_thresholding_list[position] = (0.8, np.nan)
         title = f'ROC Curve for {n_passed_positions} positions with J-stat greater than {J_threshold}\n out of {n_total_positions} total positions on {cat}'
         plt.title(title)
-        save_name = output_directory + f'/{title}'
+        save_name = output_directory / f"{title}.png"
         if save:
             plt.savefig(save_name)
             plt.close()

smftools/preprocessing/calculate_read_modification_stats.py

@@ -36,7 +36,7 @@ def calculate_read_modification_stats(adata,
     site_types = []
 
     if any(base in mod_target_bases for base in ['GpC', 'CpG', 'C']):
-        site_types += ['GpC_site', 'CpG_site', 'ambiguous_GpC_CpG_site', 'other_C_site', 'any_C_site']
+        site_types += ['GpC_site', 'CpG_site', 'ambiguous_GpC_CpG_site', 'other_C_site', 'C_site']
     
     if 'A' in mod_target_bases:
         site_types += ['A_site']

smftools/preprocessing/filter_reads_on_modification_thresholds.py

@@ -31,9 +31,9 @@ def filter_reads_on_modification_thresholds(
     - Otherwise, computes the relevant per-read metrics per-reference in batches
       and writes them into adata.obs before filtering.
 
-    Parameters of interest (same semantics as your original function):
+    Parameters of interest :
       - gpc_thresholds, cpg_thresholds, any_c_thresholds, a_thresholds:
-          each should be [min, max] (floats 0..1) or None.
+          each should be [min, max] (floats 0..1) or None. Thresholds are inclusive.
       - use_other_c_as_background: require GpC/CpG > other_C background (if present).
       - min_valid_fraction_positions_in_read_vs_ref: minimum fraction of valid sites
           in the read vs reference (0..1). If None, this check is skipped.
@@ -53,7 +53,7 @@ def filter_reads_on_modification_thresholds(
         col_pref = {
             "GpC": ("Fraction_GpC_site_modified", f"Valid_GpC_site_in_read_vs_reference"),
             "CpG": ("Fraction_CpG_site_modified", f"Valid_CpG_site_in_read_vs_reference"),
-            "C": ("Fraction_any_C_site_modified", f"Valid_any_C_site_in_read_vs_reference"),
+            "C": ("Fraction_C_site_modified", f"Valid_C_site_in_read_vs_reference"),
             "A": ("Fraction_A_site_modified", f"Valid_A_site_in_read_vs_reference"),
         }.get(mod_type, (None, None))
         return (col_pref[0] in adata.obs.columns) and (col_pref[1] in adata.obs.columns)
@@ -99,8 +99,8 @@ def filter_reads_on_modification_thresholds(
             create_cols["Valid_CpG_site_in_read_vs_reference"] = np.full((n_obs,), np.nan)
             create_cols["CpG_to_other_C_mod_ratio"] = np.full((n_obs,), np.nan)
         if "C" in mod_target_bases:
-            create_cols["Fraction_any_C_site_modified"] = np.full((n_obs,), np.nan)
-            create_cols["Valid_any_C_site_in_read_vs_reference"] = np.full((n_obs,), np.nan)
+            create_cols["Fraction_C_site_modified"] = np.full((n_obs,), np.nan)
+            create_cols["Valid_C_site_in_read_vs_reference"] = np.full((n_obs,), np.nan)
         if "A" in mod_target_bases:
             create_cols["Fraction_A_site_modified"] = np.full((n_obs,), np.nan)
             create_cols["Valid_A_site_in_read_vs_reference"] = np.full((n_obs,), np.nan)
@@ -227,7 +227,7 @@ def filter_reads_on_modification_thresholds(
         # any C
         if "C" in mod_target_bases:
             for ref in refs:
-                _compute_for_ref_and_suffix(ref, "any_C_site", create_cols["Fraction_any_C_site_modified"], create_cols["Valid_any_C_site_in_read_vs_reference"])
+                _compute_for_ref_and_suffix(ref, "C_site", create_cols["Fraction_C_site_modified"], create_cols["Valid_C_site_in_read_vs_reference"])
 
         # A
         if "A" in mod_target_bases:
@@ -283,15 +283,15 @@ def filter_reads_on_modification_thresholds(
             filtered = filtered[filtered.obs["GpC_to_other_C_mod_ratio"].astype(float) > 1]
         if lo is not None:
             s0 = filtered.n_obs
-            filtered = filtered[filtered.obs["Fraction_GpC_site_modified"].astype(float) > lo]
+            filtered = filtered[filtered.obs["Fraction_GpC_site_modified"].astype(float) >= lo]
             print(f"Removed {s0 - filtered.n_obs} reads below min GpC fraction {lo}")
         if hi is not None:
             s0 = filtered.n_obs
-            filtered = filtered[filtered.obs["Fraction_GpC_site_modified"].astype(float) < hi]
+            filtered = filtered[filtered.obs["Fraction_GpC_site_modified"].astype(float) <= hi]
             print(f"Removed {s0 - filtered.n_obs} reads above max GpC fraction {hi}")
         if (min_valid_fraction_positions_in_read_vs_ref is not None) and ("Valid_GpC_site_in_read_vs_reference" in filtered.obs.columns):
             s0 = filtered.n_obs
-            filtered = filtered[filtered.obs["Valid_GpC_site_in_read_vs_reference"].astype(float) > float(min_valid_fraction_positions_in_read_vs_ref)]
+            filtered = filtered[filtered.obs["Valid_GpC_site_in_read_vs_reference"].astype(float) >= float(min_valid_fraction_positions_in_read_vs_ref)]
             print(f"Removed {s0 - filtered.n_obs} reads with insufficient valid GpC site fraction vs ref")
 
     # CpG thresholds
@@ -301,15 +301,15 @@ def filter_reads_on_modification_thresholds(
             filtered = filtered[filtered.obs["CpG_to_other_C_mod_ratio"].astype(float) > 1]
         if lo is not None:
             s0 = filtered.n_obs
-            filtered = filtered[filtered.obs["Fraction_CpG_site_modified"].astype(float) > lo]
+            filtered = filtered[filtered.obs["Fraction_CpG_site_modified"].astype(float) >= lo]
             print(f"Removed {s0 - filtered.n_obs} reads below min CpG fraction {lo}")
         if hi is not None:
             s0 = filtered.n_obs
-            filtered = filtered[filtered.obs["Fraction_CpG_site_modified"].astype(float) < hi]
+            filtered = filtered[filtered.obs["Fraction_CpG_site_modified"].astype(float) <= hi]
             print(f"Removed {s0 - filtered.n_obs} reads above max CpG fraction {hi}")
         if (min_valid_fraction_positions_in_read_vs_ref is not None) and ("Valid_CpG_site_in_read_vs_reference" in filtered.obs.columns):
             s0 = filtered.n_obs
-            filtered = filtered[filtered.obs["Valid_CpG_site_in_read_vs_reference"].astype(float) > float(min_valid_fraction_positions_in_read_vs_ref)]
+            filtered = filtered[filtered.obs["Valid_CpG_site_in_read_vs_reference"].astype(float) >= float(min_valid_fraction_positions_in_read_vs_ref)]
             print(f"Removed {s0 - filtered.n_obs} reads with insufficient valid CpG site fraction vs ref")
 
     # any C thresholds
@@ -317,15 +317,15 @@ def filter_reads_on_modification_thresholds(
         lo, hi = _unpack_minmax(any_c_thresholds)
         if lo is not None:
             s0 = filtered.n_obs
-            filtered = filtered[filtered.obs["Fraction_any_C_site_modified"].astype(float) > lo]
+            filtered = filtered[filtered.obs["Fraction_C_site_modified"].astype(float) >= lo]
             print(f"Removed {s0 - filtered.n_obs} reads below min any-C fraction {lo}")
         if hi is not None:
             s0 = filtered.n_obs
-            filtered = filtered[filtered.obs["Fraction_any_C_site_modified"].astype(float) < hi]
+            filtered = filtered[filtered.obs["Fraction_C_site_modified"].astype(float) <= hi]
             print(f"Removed {s0 - filtered.n_obs} reads above max any-C fraction {hi}")
-        if (min_valid_fraction_positions_in_read_vs_ref is not None) and ("Valid_any_C_site_in_read_vs_reference" in filtered.obs.columns):
+        if (min_valid_fraction_positions_in_read_vs_ref is not None) and ("Valid_C_site_in_read_vs_reference" in filtered.obs.columns):
             s0 = filtered.n_obs
-            filtered = filtered[filtered.obs["Valid_any_C_site_in_read_vs_reference"].astype(float) > float(min_valid_fraction_positions_in_read_vs_ref)]
+            filtered = filtered[filtered.obs["Valid_C_site_in_read_vs_reference"].astype(float) >= float(min_valid_fraction_positions_in_read_vs_ref)]
             print(f"Removed {s0 - filtered.n_obs} reads with insufficient valid any-C site fraction vs ref")
 
     # A thresholds
@@ -333,15 +333,15 @@ def filter_reads_on_modification_thresholds(
         lo, hi = _unpack_minmax(a_thresholds)
         if lo is not None:
             s0 = filtered.n_obs
-            filtered = filtered[filtered.obs["Fraction_A_site_modified"].astype(float) > lo]
+            filtered = filtered[filtered.obs["Fraction_A_site_modified"].astype(float) >= lo]
             print(f"Removed {s0 - filtered.n_obs} reads below min A fraction {lo}")
         if hi is not None:
             s0 = filtered.n_obs
-            filtered = filtered[filtered.obs["Fraction_A_site_modified"].astype(float) < hi]
+            filtered = filtered[filtered.obs["Fraction_A_site_modified"].astype(float) <= hi]
             print(f"Removed {s0 - filtered.n_obs} reads above max A fraction {hi}")
         if (min_valid_fraction_positions_in_read_vs_ref is not None) and ("Valid_A_site_in_read_vs_reference" in filtered.obs.columns):
             s0 = filtered.n_obs
-            filtered = filtered[filtered.obs["Valid_A_site_in_read_vs_reference"].astype(float) > float(min_valid_fraction_positions_in_read_vs_ref)]
+            filtered = filtered[filtered.obs["Valid_A_site_in_read_vs_reference"].astype(float) >= float(min_valid_fraction_positions_in_read_vs_ref)]
             print(f"Removed {s0 - filtered.n_obs} reads with insufficient valid A site fraction vs ref")
 
     filtered = filtered.copy()

smftools/preprocessing/flag_duplicate_reads.py

@@ -13,7 +13,7 @@ import pandas as pd
 import matplotlib.pyplot as plt
 from tqdm import tqdm
 
-from ..informatics.helpers import make_dirs
+from ..readwrite import make_dirs
 
 # optional imports for clustering / PCA / KDE
 try: