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

smftools/tools/archived/classify_methylated_features.py

@@ -0,0 +1,66 @@
+# classify_methylated_features
+
+def classify_methylated_features(read, model, coordinates, classification_mapping={}):
+    """
+    Classifies methylated features (accessible features or CpG methylated features)
+
+    Parameters:
+        read (np.ndarray) : An array of binarized SMF data representing a read
+        model (): a trained pomegranate HMM
+        coordinates (list): a list of postional coordinates corresponding to the positions in the read
+        classification_mapping (dict): A dictionary keyed by classification name that points to a 2-element list containing size boundary constraints for that feature.
+    Returns:
+        final_classifications (list): A list of tuples, where each tuple is an instance of a non-methylated feature in the read. The tuple contains: feature start, feature length, feature classification, and HMM probability.
+    """
+    import numpy as np
+
+    sequence = list(read)
+    # Get the predicted states using the MAP algorithm
+    predicted_states = model.predict(sequence, algorithm='map')
+    
+    # Get the probabilities for each state using the forward-backward algorithm
+    probabilities = model.predict_proba(sequence)
+    
+    # Initialize lists to store the classifications and their probabilities
+    classifications = []
+    current_start = None
+    current_length = 0
+    current_probs = []
+    
+    for i, state_index in enumerate(predicted_states):
+        state_name = model.states[state_index].name
+        state_prob = probabilities[i][state_index]
+        
+        if state_name == "Methylated":
+            if current_start is None:
+                current_start = i
+            current_length += 1
+            current_probs.append(state_prob)
+        else:
+            if current_start is not None:
+                avg_prob = np.mean(current_probs)
+                classifications.append((current_start, current_length, "Methylated", avg_prob))
+                current_start = None
+                current_length = 0
+                current_probs = []
+    
+    if current_start is not None:
+        avg_prob = np.mean(current_probs)
+        classifications.append((current_start, current_length, "Methylated", avg_prob))
+
+    final_classifications = []
+    for start, length, classification, prob in classifications:
+        final_classification = None
+        feature_length = int(coordinates[start + length - 1]) - int(coordinates[start]) + 1
+        for feature_type, size_range in classification_mapping.items():
+            if size_range[0] <= feature_length < size_range[1]:
+                final_classification = feature_type
+                break
+            else:
+                pass
+        if not final_classification:
+            final_classification = classification
+
+        final_classifications.append((int(coordinates[start]) + 1, feature_length, final_classification, prob))
+    
+    return final_classifications

smftools/tools/archived/classify_non_methylated_features.py

@@ -0,0 +1,75 @@
+# classify_non_methylated_features
+
+def classify_non_methylated_features(read, model, coordinates, classification_mapping={}):
+    """
+    Classifies non-methylated features (inaccessible features)
+
+    Parameters:
+        read (np.ndarray) : An array of binarized SMF data representing a read
+        model (): a trained pomegranate HMM
+        coordinates (list): a list of postional coordinates corresponding to the positions in the read
+        classification_mapping (dict): A dictionary keyed by classification name that points to a 2-element list containing size boundary constraints for that feature.
+    Returns:
+        final_classifications (list): A list of tuples, where each tuple is an instance of a non-methylated feature in the read. The tuple contains: feature start, feature length, feature classification, and HMM probability.
+    """
+    import numpy as np
+
+    sequence = list(read)
+    # Get the predicted states using the MAP algorithm
+    predicted_states = model.predict(sequence, algorithm='map')
+    
+    # Get the probabilities for each state using the forward-backward algorithm
+    probabilities = model.predict_proba(sequence)
+    
+    # Initialize lists to store the classifications and their probabilities
+    classifications = []
+    current_start = None
+    current_length = 0
+    current_probs = []
+    
+    for i, state_index in enumerate(predicted_states):
+        state_name = model.states[state_index].name
+        state_prob = probabilities[i][state_index]
+        
+        if state_name == "Non-Methylated":
+            if current_start is None:
+                current_start = i
+            current_length += 1
+            current_probs.append(state_prob)
+        else:
+            if current_start is not None:
+                avg_prob = np.mean(current_probs)
+                classifications.append((current_start, current_length, "Non-Methylated", avg_prob))
+                current_start = None
+                current_length = 0
+                current_probs = []
+    
+    if current_start is not None:
+        avg_prob = np.mean(current_probs)
+        classifications.append((current_start, current_length, "Non-Methylated", avg_prob))
+
+    final_classifications = []
+    for start, length, classification, prob in classifications:
+        final_classification = None
+        feature_length = int(coordinates[start + length - 1]) - int(coordinates[start]) + 1
+        for feature_type, size_range in classification_mapping.items():
+            if size_range[0] <= feature_length < size_range[1]:
+                final_classification = feature_type
+                break
+            else:
+                pass
+        if not final_classification:
+            final_classification = classification
+
+        final_classifications.append((int(coordinates[start]) + 1, feature_length, final_classification, prob))
+    
+    return final_classifications
+
+            # if feature_length < 80:
+            #     final_classification = 'small_bound_stretch'
+            # elif 80 <= feature_length <= 200:
+            #     final_classification = 'Putative_Nucleosome'
+            # elif 200 < feature_length:
+            #     final_classification = 'large_bound_stretch'
+            # else:
+            #     pass

smftools/tools/archived/subset_adata_v1.py

@@ -0,0 +1,32 @@
+# subset_adata
+
+def subset_adata(adata, obs_columns):
+    """
+    Subsets an AnnData object based on categorical values in specified `.obs` columns.
+    
+    Parameters:
+        adata (AnnData): The AnnData object to subset.
+        obs_columns (list of str): List of `.obs` column names to subset by. The order matters.
+
+    Returns:
+        dict: A dictionary where keys are tuples of category values and values are corresponding AnnData subsets.
+    """
+
+    def subset_recursive(adata_subset, columns):
+        if not columns:
+            return {(): adata_subset}
+        
+        current_column = columns[0]
+        categories = adata_subset.obs[current_column].cat.categories
+        
+        subsets = {}
+        for cat in categories:
+            subset = adata_subset[adata_subset.obs[current_column] == cat]
+            subsets.update(subset_recursive(subset, columns[1:]))
+        
+        return subsets
+    
+    # Start the recursive subset process
+    subsets_dict = subset_recursive(adata, obs_columns)
+    
+    return subsets_dict

smftools/tools/archived/subset_adata_v2.py

@@ -0,0 +1,46 @@
+# subset_adata
+
+def subset_adata(adata, columns, cat_type='obs'):
+    """
+    Subsets an AnnData object based on categorical values in specified .obs or .var columns.
+    
+    Parameters:
+        adata (AnnData): The AnnData object to subset.
+        columns (list of str): List of .obs or .var column names to subset by. The order matters.
+        cat_type (str): obs or var. Default is obs
+
+    Returns:
+        dict: A dictionary where keys are tuples of category values and values are corresponding AnnData subsets.
+    """
+
+    def subset_recursive(adata_subset, columns, cat_type, key_prefix=()):
+        # Returns when the bottom of the stack is reached
+        if not columns:
+            # If there's only one column, return the key as a single value, not a tuple
+            if len(key_prefix) == 1:
+                return {key_prefix[0]: adata_subset}
+            return {key_prefix: adata_subset}
+        
+        current_column = columns[0]
+        subsets = {}
+
+        if 'obs' in cat_type:
+            categories = adata_subset.obs[current_column].cat.categories
+            for cat in categories:
+                subset = adata_subset[adata_subset.obs[current_column] == cat].copy()
+                new_key = key_prefix + (cat,)
+                subsets.update(subset_recursive(subset, columns[1:], cat_type, new_key))
+
+        elif 'var' in cat_type:
+            categories = adata_subset.var[current_column].cat.categories
+            for cat in categories:
+                subset = adata_subset[:, adata_subset.var[current_column] == cat].copy()
+                new_key = key_prefix + (cat,)
+                subsets.update(subset_recursive(subset, columns[1:], cat_type, new_key))            
+        
+        return subsets
+    
+    # Start the recursive subset process
+    subsets_dict = subset_recursive(adata, columns, cat_type)
+    
+    return subsets_dict

smftools/tools/calculate_umap.py

@@ -0,0 +1,62 @@
+def calculate_umap(adata, layer='nan_half', var_filters=None, n_pcs=15, knn_neighbors=100, overwrite=True, threads=8):
+    import scanpy as sc
+    import numpy as np
+    import os
+    from scipy.sparse import issparse
+
+    os.environ["OMP_NUM_THREADS"] = str(threads)
+
+    # Step 1: Apply var filter
+    if var_filters:
+        subset_mask = np.logical_or.reduce([adata.var[f].values for f in var_filters])
+        adata_subset = adata[:, subset_mask].copy()
+        print(f"Subsetting adata: Retained {adata_subset.shape[1]} features based on filters {var_filters}")
+    else:
+        adata_subset = adata.copy()
+        print("No var filters provided. Using all features.")
+
+    # Step 2: NaN handling inside layer
+    if layer:
+        data = adata_subset.layers[layer]
+        if not issparse(data):
+            if np.isnan(data).any():
+                print("⚠ NaNs detected, filling with 0.5 before PCA + neighbors.")
+                data = np.nan_to_num(data, nan=0.5)
+                adata_subset.layers[layer] = data
+            else:
+                print("No NaNs detected.")
+        else:
+            print("Sparse matrix detected; skipping NaN check (sparse formats typically do not store NaNs).")
+
+    # Step 3: PCA + neighbors + UMAP on subset
+    if "X_umap" not in adata_subset.obsm or overwrite:
+        n_pcs = min(adata_subset.shape[1], n_pcs)
+        print(f"Running PCA with n_pcs={n_pcs}")
+        sc.pp.pca(adata_subset, layer=layer)
+        print('Running neighborhood graph')
+        sc.pp.neighbors(adata_subset, use_rep="X_pca", n_pcs=n_pcs, n_neighbors=knn_neighbors)
+        print('Running UMAP')
+        sc.tl.umap(adata_subset)
+
+    # Step 4: Store results in original adata
+    adata.obsm["X_pca"] = adata_subset.obsm["X_pca"]
+    adata.obsm["X_umap"] = adata_subset.obsm["X_umap"]
+    adata.obsp["distances"] = adata_subset.obsp["distances"]
+    adata.obsp["connectivities"] = adata_subset.obsp["connectivities"]
+    adata.uns["neighbors"] = adata_subset.uns["neighbors"]
+
+
+    # Fix varm["PCs"] shape mismatch
+    pc_matrix = np.zeros((adata.shape[1], adata_subset.varm["PCs"].shape[1]))
+    if var_filters:
+        subset_mask = np.logical_or.reduce([adata.var[f].values for f in var_filters])
+        pc_matrix[subset_mask, :] = adata_subset.varm["PCs"]
+    else:
+        pc_matrix = adata_subset.varm["PCs"]  # No subsetting case
+
+    adata.varm["PCs"] = pc_matrix
+
+
+    print(f"Stored: adata.obsm['X_pca'] and adata.obsm['X_umap']")
+
+    return adata

smftools/tools/cluster_adata_on_methylation.py

@@ -0,0 +1,105 @@
+# cluster_adata_on_methylation
+
+def cluster_adata_on_methylation(adata, obs_columns, method='hierarchical', n_clusters=3, layer=None, site_types = ['GpC_site', 'CpG_site']):
+    """
+    Adds cluster groups to the adata object as an observation column
+
+    Parameters:
+        adata
+        obs_columns
+        method
+        n_clusters
+        layer
+        site_types
+
+    Returns:
+        None
+    """
+    import pandas as pd
+    import numpy as np
+    from . import subset_adata
+    from ..readwrite import adata_to_df
+
+    # Ensure obs_columns are categorical
+    for col in obs_columns:
+        adata.obs[col] = adata.obs[col].astype('category')
+
+    references = adata.obs['Reference'].cat.categories
+
+    # Add subset metadata to the adata
+    subset_adata(adata, obs_columns)
+
+    subgroup_name = '_'.join(obs_columns)
+    subgroups = adata.obs[subgroup_name].cat.categories
+
+    subgroup_to_reference_map = {}
+    for subgroup in subgroups:
+        for reference in references:
+            if reference in subgroup:
+                subgroup_to_reference_map[subgroup] = reference
+            else:
+                pass
+
+    if method == 'hierarchical':
+        for site_type in site_types:
+            adata.obs[f'{site_type}_{layer}_hierarchical_clustering_index_within_{subgroup_name}'] = pd.Series(-1, index=adata.obs_names, dtype=int)
+    elif method == 'kmeans':
+        for site_type in site_types:
+            adata.obs[f'{site_type}_{layer}_kmeans_clustering_index_within_{subgroup_name}'] = pd.Series(-1, index=adata.obs_names, dtype=int)
+        
+    for subgroup in subgroups:
+        subgroup_subset = adata[adata.obs[subgroup_name] == subgroup].copy()
+        reference = subgroup_to_reference_map[subgroup]
+        for site_type in site_types:
+            site_subset = subgroup_subset[:, np.array(subgroup_subset.var[f'{reference}_{site_type}'])].copy()
+            df = adata_to_df(site_subset, layer=layer)
+            df2 = df.reset_index(drop=True)
+            if method == 'hierarchical':
+                try:
+                    from scipy.cluster.hierarchy import linkage, dendrogram
+                    # Perform hierarchical clustering on rows using the average linkage method and Euclidean metric
+                    row_linkage = linkage(df2.values, method='average', metric='euclidean')
+
+                    # Generate the dendrogram to get the ordered indices
+                    dendro = dendrogram(row_linkage, no_plot=True)
+                    reordered_row_indices = np.array(dendro['leaves']).astype(int)
+
+                    # Get the reordered observation names
+                    reordered_obs_names = [df.index[i] for i in reordered_row_indices]
+
+                    temp_obs_data = pd.DataFrame({f'{site_type}_{layer}_hierarchical_clustering_index_within_{subgroup_name}': np.arange(0, len(reordered_obs_names), 1)}, index=reordered_obs_names, dtype=int)
+                    adata.obs.update(temp_obs_data)
+                except:
+                    print(f'Error found in {subgroup} of {site_type}_{layer}_hierarchical_clustering_index_within_{subgroup_name}')
+            elif method == 'kmeans':
+                try:
+                    from sklearn.cluster import KMeans
+                    kmeans = KMeans(n_clusters=n_clusters)
+                    kmeans.fit(site_subset.layers[layer])
+                    # Get the cluster labels for each data point
+                    cluster_labels = kmeans.labels_
+                    # Add the kmeans cluster data as an observation to the anndata object
+                    site_subset.obs[f'{site_type}_{layer}_kmeans_clustering_index_within_{subgroup_name}'] = cluster_labels.astype(str)
+                    # Calculate the mean of each observation categoty of each cluster
+                    cluster_means = site_subset.obs.groupby(f'{site_type}_{layer}_kmeans_clustering_index_within_{subgroup_name}').mean()
+                    # Sort the cluster indices by mean methylation value
+                    sorted_clusters = cluster_means.sort_values(by=f'{site_type}_row_methylation_means', ascending=False).index
+                    # Create a mapping of the old cluster values to the new cluster values
+                    sorted_cluster_mapping = {old: new for new, old in enumerate(sorted_clusters)}
+                    # Apply the mapping to create a new observation value: kmeans_labels_reordered
+                    site_subset.obs[f'{site_type}_{layer}_kmeans_clustering_index_within_{subgroup_name}'] = site_subset.obs[f'{site_type}_{layer}_kmeans_clustering_index_within_{subgroup_name}'].map(sorted_cluster_mapping)
+                    temp_obs_data = pd.DataFrame({f'{site_type}_{layer}_kmeans_clustering_index_within_{subgroup_name}': site_subset.obs[f'{site_type}_{layer}_kmeans_clustering_index_within_{subgroup_name}']}, index=site_subset.obs_names, dtype=int)
+                    adata.obs.update(temp_obs_data)      
+                except:
+                        print(f'Error found in {subgroup} of {site_type}_{layer}_kmeans_clustering_index_within_{subgroup_name}')   
+
+    if method == 'hierarchical':             
+        # Ensure that the observation values are type int
+        for site_type in site_types:
+            adata.obs[f'{site_type}_{layer}_hierarchical_clustering_index_within_{subgroup_name}'] = adata.obs[f'{site_type}_{layer}_hierarchical_clustering_index_within_{subgroup_name}'].astype(int)
+    elif method == 'kmeans':
+        # Ensure that the observation values are type int
+        for site_type in site_types:
+            adata.obs[f'{site_type}_{layer}_kmeans_clustering_index_within_{subgroup_name}'] = adata.obs[f'{site_type}_{layer}_kmeans_clustering_index_within_{subgroup_name}'].astype(int)
+
+    return None   

smftools/tools/general_tools.py

@@ -0,0 +1,69 @@
+def create_nan_mask_from_X(adata, new_layer_name="nan_mask"):
+    """
+    Generates a nan mask where 1 = NaN in adata.X and 0 = valid value.
+    """
+    import numpy as np
+    nan_mask = np.isnan(adata.X).astype(int)
+    adata.layers[new_layer_name] = nan_mask
+    print(f"Created '{new_layer_name}' layer based on NaNs in adata.X")
+    return adata
+
+def create_nan_or_non_gpc_mask(adata, obs_column, new_layer_name="nan_or_non_gpc_mask"):
+    import numpy as np
+
+    nan_mask = np.isnan(adata.X).astype(int)
+    combined_mask = np.zeros_like(nan_mask)
+
+    for idx, row in enumerate(adata.obs.itertuples()):
+        ref = getattr(row, obs_column)
+        gpc_mask = adata.var[f"{ref}_GpC_site"].astype(int).values
+        combined_mask[idx, :] = 1 - gpc_mask  # non-GpC is 1
+
+    mask = np.maximum(nan_mask, combined_mask)
+    adata.layers[new_layer_name] = mask
+
+    print(f"Created '{new_layer_name}' layer based on NaNs in adata.X and non-GpC regions using {obs_column}")
+    return adata
+
+def combine_layers(adata, input_layers, output_layer, negative_mask=None, values=None, binary_mode=False):
+    """
+    Combines layers into a single layer with specific coding:
+        - Background stays 0
+        - If binary_mode=True: any overlap = 1
+        - If binary_mode=False:
+            - Defaults to [1, 2, 3, ...] if values=None
+            - Later layers take precedence in overlaps
+    
+    Parameters:
+        adata: AnnData object
+        input_layers: list of str
+        output_layer: str, name of the output layer
+        negative_mask: str (optional), binary mask to enforce 0s
+        values: list of ints (optional), values to assign to each input layer
+        binary_mode: bool, if True, creates a simple 0/1 mask regardless of values
+    
+    Returns:
+        Updated AnnData with new layer.
+    """
+    import numpy as np
+    combined = np.zeros_like(adata.layers[input_layers[0]])
+
+    if binary_mode:
+        for layer in input_layers:
+            combined = np.logical_or(combined, adata.layers[layer] > 0)
+        combined = combined.astype(int)
+    else:
+        if values is None:
+            values = list(range(1, len(input_layers) + 1))
+        for i, layer in enumerate(input_layers):
+            arr = adata.layers[layer]
+            combined[arr > 0] = values[i]
+
+    if negative_mask:
+        mask = adata.layers[negative_mask]
+        combined[mask == 0] = 0
+
+    adata.layers[output_layer] = combined
+    print(f"Combined layers into {output_layer} {'(binary)' if binary_mode else f'with values {values}'}")
+
+    return adata