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

smftools/preprocessing/calculate_coverage.py

@@ -1,4 +1,4 @@
-def calculate_coverage(adata, obs_column='Reference_strand', position_nan_threshold=0.05):
+def calculate_coverage(adata, obs_column='Reference_strand', position_nan_threshold=0.00001, uns_flag='positional_coverage_calculated'):
     """
     Append position-level metadata regarding whether the position is informative within the given observation category.
 
@@ -13,6 +13,12 @@ def calculate_coverage(adata, obs_column='Reference_strand', position_nan_thresh
     import numpy as np
     import pandas as pd
     import anndata as ad
+
+    # Only run if not already performed
+    already = bool(adata.uns.get(uns_flag, False))
+    if already:
+        # QC already performed; nothing to do
+        return
     
     categories = adata.obs[obs_column].cat.categories
     n_categories_with_position = np.zeros(adata.shape[1])
@@ -40,3 +46,6 @@ def calculate_coverage(adata, obs_column='Reference_strand', position_nan_thresh
 
     # Store final category count
     adata.var[f'N_{obs_column}_with_position'] = n_categories_with_position.astype(int)
+
+    # mark as done
+    adata.uns[uns_flag] = True

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

@@ -0,0 +1,101 @@
+def calculate_read_modification_stats(adata, 
+                                      reference_column, 
+                                      sample_names_col, 
+                                      mod_target_bases,
+                                      uns_flag="read_modification_stats_calculated",
+                                      bypass=False,
+                                      force_redo=False
+):
+    """
+    Adds methylation/deamination statistics for each read. 
+    Indicates the read GpC and CpG methylation ratio to other_C methylation (background false positive metric for Cytosine MTase SMF).
+
+    Parameters:
+        adata (AnnData): An adata object
+        reference_column (str): String representing the name of the Reference column to use
+        sample_names_col (str): String representing the name of the sample name column to use
+        mod_target_bases:
+
+    Returns:
+        None 
+    """
+    import numpy as np
+    import anndata as ad
+    import pandas as pd
+
+    # Only run if not already performed
+    already = bool(adata.uns.get(uns_flag, False))
+    if (already and not force_redo) or bypass:
+        # QC already performed; nothing to do
+        return
+
+    print('Calculating read level Modification statistics')
+
+    references = set(adata.obs[reference_column])
+    sample_names = set(adata.obs[sample_names_col])
+    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', 'C_site']
+    
+    if 'A' in mod_target_bases:
+        site_types += ['A_site']
+
+    for site_type in site_types:
+        adata.obs[f'Modified_{site_type}_count'] = pd.Series(0, index=adata.obs_names, dtype=int)
+        adata.obs[f'Total_{site_type}_in_read'] = pd.Series(0, index=adata.obs_names, dtype=int)
+        adata.obs[f'Fraction_{site_type}_modified'] = pd.Series(np.nan, index=adata.obs_names, dtype=float)
+        adata.obs[f'Total_{site_type}_in_reference'] = pd.Series(np.nan, index=adata.obs_names, dtype=int)
+        adata.obs[f'Valid_{site_type}_in_read_vs_reference'] = pd.Series(np.nan, index=adata.obs_names, dtype=float)
+
+
+    for ref in references:
+        ref_subset = adata[adata.obs[reference_column] == ref]
+        for site_type in site_types:
+            print(f'Iterating over {ref}_{site_type}')
+            observation_matrix = ref_subset.obsm[f'{ref}_{site_type}']
+            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 = total_positions_in_read / total_positions_in_reference
+            number_mods_in_read = np.nansum(observation_matrix, axis=1)
+            fraction_modified = number_mods_in_read / total_positions_in_read
+
+            fraction_modified = np.divide(
+                number_mods_in_read,
+                total_positions_in_read,
+                out=np.full_like(number_mods_in_read, np.nan, dtype=float),
+                where=total_positions_in_read != 0
+            )
+
+            temp_obs_data = pd.DataFrame({f'Total_{site_type}_in_read': total_positions_in_read,
+                                        f'Modified_{site_type}_count': number_mods_in_read,
+                                        f'Fraction_{site_type}_modified': fraction_modified,
+                                        f'Total_{site_type}_in_reference': total_positions_in_reference,
+                                        f'Valid_{site_type}_in_read_vs_reference': fraction_valid_positions_in_read_vs_ref}, 
+                                        index=ref_subset.obs.index)
+            
+            adata.obs.update(temp_obs_data)
+
+    if any(base in mod_target_bases for base in ['GpC', 'CpG', 'C']):
+        with np.errstate(divide='ignore', invalid='ignore'):
+            gpc_to_c_ratio = np.divide(
+                adata.obs[f'Fraction_GpC_site_modified'],
+                adata.obs[f'Fraction_other_C_site_modified'],
+                out=np.full_like(adata.obs[f'Fraction_GpC_site_modified'], np.nan, dtype=float),
+                where=adata.obs[f'Fraction_other_C_site_modified'] != 0
+            )
+
+            cpg_to_c_ratio = np.divide(
+                adata.obs[f'Fraction_CpG_site_modified'],
+                adata.obs[f'Fraction_other_C_site_modified'],
+                out=np.full_like(adata.obs[f'Fraction_CpG_site_modified'], np.nan, dtype=float),
+                where=adata.obs[f'Fraction_other_C_site_modified'] != 0
+                )
+            
+        adata.obs['GpC_to_other_C_mod_ratio'] = gpc_to_c_ratio
+        adata.obs['CpG_to_other_C_mod_ratio'] = cpg_to_c_ratio
+
+    # mark as done
+    adata.uns[uns_flag] = True
+
+    return

smftools/preprocessing/clean_NaN.py

@@ -1,4 +1,9 @@
-def clean_NaN(adata, layer=None):
+def clean_NaN(adata, 
+            layer=None,
+            uns_flag='clean_NaN_performed',
+            bypass=False,
+            force_redo=True
+):
     """
     Append layers to adata that contain NaN cleaning strategies.
 
@@ -14,6 +19,12 @@ def clean_NaN(adata, layer=None):
     import anndata as ad
     from ..readwrite import adata_to_df 
 
+    # Only run if not already performed
+    already = bool(adata.uns.get(uns_flag, False))
+    if (already and not force_redo) or bypass:
+        # QC already performed; nothing to do
+        return
+
     # Ensure the specified layer exists
     if layer and layer not in adata.layers:
         raise ValueError(f"Layer '{layer}' not found in adata.layers.")
@@ -44,3 +55,8 @@ def clean_NaN(adata, layer=None):
     print('Making layer: nan_half')
     df_nan_half = df.fillna(0.5)
     adata.layers['nan_half'] = df_nan_half.values
+
+    # mark as done
+    adata.uns[uns_flag] = True
+
+    return None

smftools/preprocessing/filter_reads_on_length_quality_mapping.py

@@ -0,0 +1,158 @@
+from typing import Optional, Union, Sequence
+import numpy as np
+import pandas as pd
+import anndata as ad
+
+def filter_reads_on_length_quality_mapping(
+    adata: ad.AnnData,
+    filter_on_coordinates: Union[bool, Sequence] = False,
+    # New single-range params (preferred):
+    read_length: Optional[Sequence[float]] = None,          # e.g. [min, max]
+    length_ratio: Optional[Sequence[float]] = None,         # e.g. [min, max]
+    read_quality: Optional[Sequence[float]] = None,         # e.g. [min, max]  (commonly min only)
+    mapping_quality: Optional[Sequence[float]] = None,      # e.g. [min, max]  (commonly min only)
+    uns_flag: str = "reads_removed_failing_length_quality_mapping_qc",
+    bypass: bool = False,
+    force_redo: bool = True
+) -> ad.AnnData:
+    """
+    Filter AnnData by coordinate window, read length, length ratios, read quality and mapping quality.
+
+    New: you may pass `read_length=[min, max]` (or tuple) to set both min/max in one argument.
+    If `read_length` is given it overrides scalar min/max variants (which are not present in this signature).
+    Same behavior supported for `length_ratio`, `read_quality`, `mapping_quality`.
+
+    Returns a filtered copy of the input AnnData and marks adata.uns[uns_flag] = True.
+    """
+    # early exit
+    already = bool(adata.uns.get(uns_flag, False))
+    if bypass or (already and not force_redo):
+        return adata
+
+    adata_work = adata
+    start_n = adata_work.n_obs
+
+    # --- coordinate filtering (unchanged) ---
+    if filter_on_coordinates:
+        try:
+            low, high = tuple(filter_on_coordinates)
+        except Exception:
+            raise ValueError("filter_on_coordinates must be False or an iterable of two numbers (low, high).")
+        try:
+            var_coords = np.array([float(v) for v in adata_work.var_names])
+            if low > high:
+                low, high = high, low
+            col_mask_bool = (var_coords >= float(low)) & (var_coords <= float(high))
+            if not col_mask_bool.any():
+                start_idx = int(np.argmin(np.abs(var_coords - float(low))))
+                end_idx = int(np.argmin(np.abs(var_coords - float(high))))
+                lo_idx, hi_idx = min(start_idx, end_idx), max(start_idx, end_idx)
+                selected_cols = list(adata_work.var_names[lo_idx : hi_idx + 1])
+            else:
+                selected_cols = list(adata_work.var_names[col_mask_bool])
+            print(f"Subsetting adata to coordinates between {low} and {high}: keeping {len(selected_cols)} variables.")
+            adata_work = adata_work[:, selected_cols].copy()
+        except Exception:
+            print("Warning: could not interpret adata.var_names as numeric coordinates — skipping coordinate filtering.")
+
+    # --- helper to coerce range inputs ---
+    def _coerce_range(range_arg):
+        """
+        Given range_arg which may be None or a 2-seq [min,max], return (min_or_None, max_or_None).
+        If both present and min>max they are swapped.
+        """
+        if range_arg is None:
+            return None, None
+        if not isinstance(range_arg, (list, tuple, np.ndarray)) or len(range_arg) != 2:
+            # not a 2-element range -> treat as no restriction (or you could raise)
+            return None, None
+        lo_raw, hi_raw = range_arg[0], range_arg[1]
+        lo = None if lo_raw is None else float(lo_raw)
+        hi = None if hi_raw is None else float(hi_raw)
+        if (lo is not None) and (hi is not None) and lo > hi:
+            lo, hi = hi, lo
+        return lo, hi
+
+    # Resolve ranges using only the provided range arguments
+    rl_min, rl_max = _coerce_range(read_length)
+    lr_min, lr_max = _coerce_range(length_ratio)
+    rq_min, rq_max = _coerce_range(read_quality)
+    mq_min, mq_max = _coerce_range(mapping_quality)
+
+    # --- build combined mask ---
+    combined_mask = pd.Series(True, index=adata_work.obs.index)
+
+    # read length filter
+    if (rl_min is not None) or (rl_max is not None):
+        if "mapped_length" not in adata_work.obs.columns:
+            print("Warning: 'mapped_length' not found in adata.obs — skipping read_length filter.")
+        else:
+            vals = pd.to_numeric(adata_work.obs["mapped_length"], errors="coerce")
+            mask = pd.Series(True, index=adata_work.obs.index)
+            if rl_min is not None:
+                mask &= (vals >= rl_min)
+            if rl_max is not None:
+                mask &= (vals <= rl_max)
+            mask &= vals.notna()
+            combined_mask &= mask
+            print(f"Planned read_length filter: min={rl_min}, max={rl_max}")
+
+    # length ratio filter
+    if (lr_min is not None) or (lr_max is not None):
+        if "mapped_length_to_reference_length_ratio" not in adata_work.obs.columns:
+            print("Warning: 'mapped_length_to_reference_length_ratio' not found in adata.obs — skipping length_ratio filter.")
+        else:
+            vals = pd.to_numeric(adata_work.obs["mapped_length_to_reference_length_ratio"], errors="coerce")
+            mask = pd.Series(True, index=adata_work.obs.index)
+            if lr_min is not None:
+                mask &= (vals >= lr_min)
+            if lr_max is not None:
+                mask &= (vals <= lr_max)
+            mask &= vals.notna()
+            combined_mask &= mask
+            print(f"Planned length_ratio filter: min={lr_min}, max={lr_max}")
+
+    # read quality filter (supporting optional range but typically min only)
+    if (rq_min is not None) or (rq_max is not None):
+        if "read_quality" not in adata_work.obs.columns:
+            print("Warning: 'read_quality' not found in adata.obs — skipping read_quality filter.")
+        else:
+            vals = pd.to_numeric(adata_work.obs["read_quality"], errors="coerce")
+            mask = pd.Series(True, index=adata_work.obs.index)
+            if rq_min is not None:
+                mask &= (vals >= rq_min)
+            if rq_max is not None:
+                mask &= (vals <= rq_max)
+            mask &= vals.notna()
+            combined_mask &= mask
+            print(f"Planned read_quality filter: min={rq_min}, max={rq_max}")
+
+    # mapping quality filter (supporting optional range but typically min only)
+    if (mq_min is not None) or (mq_max is not None):
+        if "mapping_quality" not in adata_work.obs.columns:
+            print("Warning: 'mapping_quality' not found in adata.obs — skipping mapping_quality filter.")
+        else:
+            vals = pd.to_numeric(adata_work.obs["mapping_quality"], errors="coerce")
+            mask = pd.Series(True, index=adata_work.obs.index)
+            if mq_min is not None:
+                mask &= (vals >= mq_min)
+            if mq_max is not None:
+                mask &= (vals <= mq_max)
+            mask &= vals.notna()
+            combined_mask &= mask
+            print(f"Planned mapping_quality filter: min={mq_min}, max={mq_max}")
+
+    # Apply combined mask and report
+    s0 = adata_work.n_obs
+    combined_mask_bool = combined_mask.astype(bool).values
+    adata_work = adata_work[combined_mask_bool].copy()
+    s1 = adata_work.n_obs
+    print(f"Combined filters applied: kept {s1} / {s0} reads (removed {s0 - s1})")
+
+    final_n = adata_work.n_obs
+    print(f"Filtering complete: start={start_n}, final={final_n}, removed={start_n - final_n}")
+
+    # mark as done
+    adata_work.uns[uns_flag] = True
+
+    return adata_work