smftools 0.1.0__py3-none-any.whl → 0.1.3__py3-none-any.whl

smftools/preprocessing/filter_reads_on_length.py

@@ -1,14 +1,22 @@
 ## filter_reads_on_length
-import numpy as np
-import anndata as ad
-import pandas as pd
 
 def filter_reads_on_length(adata, filter_on_coordinates=False, min_read_length=2700):
     """
+    Filters the adata object to keep a defined coordinate window, as well as reads that are over a minimum threshold in length.
+
+    Parameters:
+        adata (AnnData): An adata object.
+        filter_on_coordinates (bool | list): If False, skips filtering. Otherwise, provide a list containing integers representing the lower and upper bound coordinates to filter on. Default is False.
+        min_read_length (int): The minimum read length to keep in the filtered dataset. Default is 2700.
+
+    Returns:
+        adata (AnnData): The filtered adata object
     Input: Adata object. a list of lower and upper bound (set to False or None if not wanted), and a minimum read length integer.
-    Output: Susbets the adata object to keep a defined coordinate window, as well as reads that are over a minimum threshold in length
+ 
     """
-
+    import numpy as np
+    import anndata as ad
+    import pandas as pd
     if filter_on_coordinates:
         lower_bound, upper_bound = filter_on_coordinates
         # Extract the position information from the adata object as an np array
@@ -28,4 +36,6 @@ def filter_reads_on_length(adata, filter_on_coordinates=False, min_read_length=2
 
     if min_read_length:
         print(f'Subsetting adata to keep reads longer than {min_read_length}')
-        adata = adata[adata.obs['read_length'] > min_read_length].copy()
+        adata = adata[adata.obs['read_length'] > min_read_length].copy()
+
+    return adata

smftools/preprocessing/invert_adata.py

@@ -1,14 +1,19 @@
 ## invert_adata
-import numpy as np
-import anndata as ad
-import pandas as pd
 
 # Optional inversion of the adata
 def invert_adata(adata):
     """
-    Input: An adata object
-    Output: Inverts the adata object along the variable axis
+    Inverts the adata object along the variable axis
+
+    Parameters:
+        adata (AnnData): An adata object.
+
+    Returns:
+        None
     """
+    import numpy as np
+    import anndata as ad
+    print('Inverting adata')
     # Reassign var_names with new names
     old_var_names = adata.var_names.astype(int).to_numpy()
     new_var_names = np.sort(old_var_names)[::-1].astype(str)

smftools/preprocessing/load_sample_sheet.py

@@ -0,0 +1,24 @@
+# load_sample_sheet
+
+def load_sample_sheet(adata, sample_sheet_path, mapping_key_column):
+    """
+    Loads a sample sheet csv and uses one of the columns to map sample information into the AnnData object.
+
+    Parameters:
+        adata (AnnData): The Anndata object to append sample information to.
+        sample_sheet_path (str):
+        mapping_key_column (str):
+
+    Returns:
+        None
+    """
+    import pandas as pd
+    import anndata as ad
+    df = pd.read_csv(sample_sheet_path)
+    key_column = mapping_key_column
+    df[key_column] = df[key_column].astype(str)
+    value_columns = [column for column in df.columns if column != key_column]
+    mapping_dict = df.set_index(key_column)[value_columns].to_dict(orient='index')
+    for column in value_columns:
+        column_map = {key: value[column] for key, value in mapping_dict.items()}
+        adata.obs[column] = adata.obs[key_column].map(column_map)

smftools/preprocessing/make_dirs.py

@@ -0,0 +1,21 @@
+## make_dirs
+
+# General
+def make_dirs(directories):
+    """
+    Takes a list of file paths and makes new directories if the directory does not already exist.
+
+    Parameters:
+        directories (list): A list of directories to make
+    
+    Returns:
+        None
+    """
+    import os
+
+    for directory in directories:
+        if not os.path.isdir(directory):
+            os.mkdir(directory)
+            print(f"Directory '{directory}' created successfully.")
+        else:
+            print(f"Directory '{directory}' already exists.")

smftools/preprocessing/mark_duplicates.py

@@ -1,19 +1,29 @@
 ## mark_duplicates
-import numpy as np
-import pandas as pd
-import matplotlib.pyplot as plt
-from scipy.signal import find_peaks
-import networkx as nx
-from .binary_layers_to_ohe import binary_layers_to_ohe
-from .calculate_pairwise_hamming_distances import calculate_pairwise_hamming_distances
-from .min_non_diagonal import min_non_diagonal
 
-
-def mark_duplicates(adata, layers, obs_column='Reference', sample_col='Sample_names'):
+def mark_duplicates(adata, layers, obs_column='Reference', sample_col='Sample_names', hamming_distance_thresholds={}):
     """
-    Input: adata object, list of binary layers, column names to use.
-    Output: Marks duplicates in the adata object
+    Marks duplicates in the adata object.
+
+    Parameters:
+        adata (AnnData): An adata object.
+        layers (list): A list of strings representing the layers to use.
+        obs_column (str): A string representing the obs column name to first subset on. Default is 'Reference'.
+        sample_col (str):L A string representing the obs column name to second subset on. Default is 'Sample_names'.
+        hamming_distance_thresholds (dict): A dictionary keyed by obs_column categories that points to a float corresponding to the distance threshold to apply. Default is an empty dict.
+    
+    Returns:
+        None
     """
+
+    import numpy as np
+    import pandas as pd
+    import matplotlib.pyplot as plt
+    from scipy.signal import find_peaks
+    import networkx as nx
+    from .binary_layers_to_ohe import binary_layers_to_ohe
+    from .calculate_pairwise_hamming_distances import calculate_pairwise_hamming_distances
+    from .min_non_diagonal import min_non_diagonal
+
     categories = adata.obs[obs_column].cat.categories 
     sample_names = adata.obs[sample_col].cat.categories 
 
@@ -39,22 +49,32 @@ def mark_duplicates(adata, layers, obs_column='Reference', sample_col='Sample_na
             distance_df = pd.DataFrame(distance_matrix, index=read_names, columns=read_names)
             # Save the distance dataframe into an unstructured component of the adata object
             adata.uns[f'Pairwise_Hamming_distance_within_{cat}_{sample}'] = distance_df
-            # Calculate the minimum non-self distance for every read in the reference and sample
-            min_distance_values = min_non_diagonal(distance_matrix)
-            min_distance_df = pd.DataFrame({'Nearest_neighbor_Hamming_distance': min_distance_values}, index=read_names)
-            adata.obs.update(min_distance_df)
-            # Generate a histogram of minimum non-self distances for each read
-            min_distance_bins = plt.hist(min_distance_values, bins=n_reads//4)
-            # Normalize the max value in any histogram bin to 1
-            normalized_min_distance_counts = min_distance_bins[0] / np.max(min_distance_bins[0])
-            # Extract the bin index of peak centers in the histogram
-            peak_centers, _ = find_peaks(normalized_min_distance_counts, prominence=0.2, distance=5)
-            first_peak_index = peak_centers[0]
-            offset_index = first_peak_index-1
-            # Use the distance corresponding to the first peak as the threshold distance in graph construction
-            first_peak_distance = min_distance_bins[1][first_peak_index]
-            offset_distance = min_distance_bins[1][offset_index]
-            adata.uns[f'Hamming_distance_threshold_for_{cat}_{sample}'] = offset_distance
+            if n_reads > 1:
+                # Calculate the minimum non-self distance for every read in the reference and sample
+                min_distance_values = min_non_diagonal(distance_matrix)
+                min_distance_df = pd.DataFrame({'Nearest_neighbor_Hamming_distance': min_distance_values}, index=read_names)
+                adata.obs.update(min_distance_df)
+                # Generate a histogram of minimum non-self distances for each read
+                if n_reads > 3:
+                    n_bins = n_reads // 4
+                else:
+                    n_bins = 1
+                min_distance_bins = plt.hist(min_distance_values, bins=n_bins)
+                if cat in hamming_distance_thresholds: 
+                    adata.uns[f'Hamming_distance_threshold_for_{cat}_{sample}'] = hamming_distance_thresholds[cat]
+                else: # eventually this should be written to use known PCR duplicate controls for thresholding.
+                    # Normalize the max value in any histogram bin to 1
+                    normalized_min_distance_counts = min_distance_bins[0] / np.max(min_distance_bins[0])
+                    # Extract the bin index of peak centers in the histogram
+                    peak_centers, _ = find_peaks(normalized_min_distance_counts, prominence=0.2, distance=5)
+                    first_peak_index = peak_centers[0]
+                    offset_index = first_peak_index-1
+                    # Use the distance corresponding to the first peak as the threshold distance in graph construction
+                    first_peak_distance = min_distance_bins[1][first_peak_index]
+                    offset_distance = min_distance_bins[1][offset_index]
+                    adata.uns[f'Hamming_distance_threshold_for_{cat}_{sample}'] = offset_distance
+            else:
+                adata.uns[f'Hamming_distance_threshold_for_{cat}_{sample}'] = 0
 
     ## Detect likely duplicate reads and mark them in the adata object.
     adata.obs['Marked_duplicate'] = pd.Series(False, index=adata.obs_names, dtype=bool)
@@ -82,7 +102,11 @@ def mark_duplicates(adata, layers, obs_column='Reference', sample_col='Sample_na
             clusters = [list(cluster) for cluster in clusters]
             # Get the number of clusters
             cluster_count = len(clusters)
-            adata.uns[f'Hamming_distance_clusters_within_{cat}_{sample}'] = [cluster_count, n_reads, cluster_count / n_reads, clusters]
+            if n_reads > 0:
+                fraction_unique = cluster_count / n_reads
+            else:
+                fraction_unique = 0
+            adata.uns[f'Hamming_distance_clusters_within_{cat}_{sample}'] = [cluster_count, n_reads, fraction_unique, clusters]
             # Update the adata object
             read_cluster_map = {}
             read_duplicate_map = {}
@@ -107,4 +131,4 @@ def mark_duplicates(adata, layers, obs_column='Reference', sample_col='Sample_na
             adata.obs.update(df_combined)
             adata.obs['Marked_duplicate'] = adata.obs['Marked_duplicate'].astype(bool)
             adata.obs['Unique_in_final_read_set'] = adata.obs['Unique_in_final_read_set'].astype(bool)
-            print(f'Hamming clusters for {sample} on {cat}\nThreshold: {first_peak_distance}\nNumber clusters: {cluster_count}\nNumber reads: {n_reads}\nFraction unique: {cluster_count / n_reads}')   
+            print(f'Hamming clusters for {sample} on {cat}\nThreshold: {distance_threshold}\nNumber clusters: {cluster_count}\nNumber reads: {n_reads}\nFraction unique: {fraction_unique}')   

smftools/preprocessing/min_non_diagonal.py

@@ -1,12 +1,17 @@
 ## min_non_diagonal
-import numpy as np
 
 def min_non_diagonal(matrix):
     """
-    Takes a matrix and returns the smallest value from each row with the diagonal masked
-    Input: A data matrix
-    Output: A list of minimum values from each row of the matrix
+    Takes a matrix and returns the smallest value from each row with the diagonal masked.
+
+    Parameters:
+        matrix (ndarray): A 2D ndarray.
+
+    Returns:
+        min_values (list): A list of minimum values from each row of the matrix
     """
+    import numpy as np
+
     n = matrix.shape[0]
     min_values = []
     for i in range(n):

smftools/preprocessing/recipes.py

@@ -0,0 +1,125 @@
+# recipes
+
+def recipe_1_Kissiov_and_McKenna_2025(adata, sample_sheet_path, output_directory, mapping_key_column='Sample', reference_column = 'Reference', sample_names_col='Sample_names', invert=False):
+    """
+    The first part of the preprocessing workflow applied to the smf.inform.pod_to_adata() output derived from Kissiov_and_McKenna_2025.
+
+    Performs the following tasks:
+    1) Loads a sample CSV to append metadata mappings to the adata object.
+    2) Appends a boolean indicating whether each position in var_names is within a given reference.
+    3) Appends the cytosine context to each position from each reference.
+    4) Calculate read level methylation statistics.
+    5) Optionally inverts the adata to flip the position coordinate orientation.
+    6) Calculates read length statistics (start position, end position, read length)
+    7) Returns a dictionary to pass the variable namespace to the parent scope.
+
+    Parameters:
+        adata (AnnData): The AnnData object to use as input.
+        sample_sheet_path (str): String representing the path to the sample sheet csv containing the sample metadata.
+        output_directory (str): String representing the path to the output directory for plots.
+        mapping_key_column (str): The column name to use as the mapping keys for applying the sample sheet metadata.
+        reference_column (str): The name of the reference column to use.
+        sample_names_col (str): The name of the sample name column to use.
+        invert (bool): Whether to invert the positional coordinates of the adata object.
+
+    Returns:
+        variables (dict): A dictionary of variables to append to the parent scope.
+    """
+    import anndata as ad
+    import pandas as pd
+    import numpy as np
+    from .load_sample_sheet import load_sample_sheet
+    from .calculate_coverage import calculate_coverage
+    from .append_C_context import append_C_context
+    from .calculate_converted_read_methylation_stats import calculate_converted_read_methylation_stats
+    from .invert_adata import invert_adata
+    from .calculate_read_length_stats import calculate_read_length_stats
+
+    # Clean up some of the Reference metadata and save variable names that point to sets of values in the column.
+    adata.obs[reference_column] = adata.obs[reference_column].astype('category')
+    references = adata.obs[reference_column].cat.categories
+    split_references = [(reference, reference.split('_')[0][1:]) for reference in references]
+    reference_mapping = {k: v for k, v in split_references}
+    adata.obs[f'{reference_column}_short'] = adata.obs[reference_column].map(reference_mapping)
+    short_references = set(adata.obs[f'{reference_column}_short'])
+    binary_layers = adata.layers.keys()
+
+    # load sample sheet metadata
+    load_sample_sheet(adata, sample_sheet_path, mapping_key_column)
+
+    # hold sample names set
+    adata.obs[sample_names_col] = adata.obs[sample_names_col].astype('category')
+    sample_names = adata.obs[sample_names_col].cat.categories
+
+    # Add position level metadata
+    calculate_coverage(adata, obs_column=reference_column)
+    adata.var['SNP_position'] = (adata.var[f'N_{reference_column}_with_position'] > 0) & (adata.var[f'N_{reference_column}_with_position'] < len(references)).astype(bool)
+
+    # Append cytosine context to the reference positions based on the conversion strand.
+    append_C_context(adata, obs_column=reference_column, use_consensus=False)
+
+    # Calculate read level methylation statistics. Assess if GpC methylation level is above other_C methylation level as a QC.
+    calculate_converted_read_methylation_stats(adata, reference_column, sample_names_col, output_directory, show_methylation_histogram=False, save_methylation_histogram=False)
+
+    # Invert the adata object (ie flip the strand orientation for visualization)
+    if invert:
+        invert_adata(adata)
+    else:
+        pass
+
+    # Calculate read length statistics, with options to display or save the read length histograms
+    upper_bound, lower_bound = calculate_read_length_stats(adata, reference_column, sample_names_col, output_directory, show_read_length_histogram=False, save_read_length_histogram=False)
+
+    variables = {
+        "short_references": short_references,
+        "binary_layers": binary_layers,
+        "sample_names": sample_names,
+        "upper_bound": upper_bound,
+        "lower_bound": lower_bound,
+        "references": references
+    }
+    return variables
+
+def recipe_2_Kissiov_and_McKenna_2025(adata, output_directory, binary_layers, hamming_distance_thresholds={}, reference_column = 'Reference', sample_names_col='Sample_names'):
+    """
+    The second part of the preprocessing workflow applied to the adata that has already been preprocessed by recipe_1_Kissiov_and_McKenna_2025.
+
+    Performs the following tasks:
+    1) Adds new layers containing NaN replaced variants of adata.X (fill_closest, nan0_0minus1, nan1_12).
+    2) Marks putative PCR duplicates using pairwise hamming distance metrics.
+    3) Performs a complexity analysis of the library based on the PCR duplicate detection rate.
+    4) Removes PCR duplicates from the adata.
+    5) Returns two adata object: one for the filtered adata and one for the duplicate adata.
+
+    Parameters:
+        adata (AnnData): The AnnData object to use as input.
+        output_directory (str): String representing the path to the output directory for plots.
+        binary_layers (list): A list of layers to used for the binary encoding of read sequences. Used for duplicate detection.
+        hamming_distance_thresholds (dict): A dictionary keyed by obs_column categories that points to a float corresponding to the distance threshold to apply. Default is an empty dict.
+        reference_column (str): The name of the reference column to use.
+        sample_names_col (str): The name of the sample name column to use.
+
+    Returns:
+        filtered_adata (AnnData): An AnnData object containing the filtered reads
+        duplicates (AnnData): An AnnData object containing the duplicate reads
+    """
+    import anndata as ad
+    import pandas as pd
+    import numpy as np
+    from .clean_NaN import clean_NaN
+    from .mark_duplicates import mark_duplicates
+    from .calculate_complexity import calculate_complexity
+    from .remove_duplicates import remove_duplicates
+
+    # NaN replacement strategies stored in additional layers. Having layer=None uses adata.X
+    clean_NaN(adata, layer=None)
+
+    # Duplicate detection using pairwise hamming distance across reads
+    mark_duplicates(adata, binary_layers, obs_column=reference_column, sample_col=sample_names_col, hamming_distance_thresholds=hamming_distance_thresholds)
+
+    # Complexity analysis using the marked duplicates and the lander-watermann algorithm
+    calculate_complexity(adata, output_directory, obs_column=reference_column, sample_col=sample_names_col, plot=True, save_plot=False)
+
+    # Remove duplicate reads and store the duplicate reads in a new AnnData object named duplicates.
+    filtered_adata, duplicates = remove_duplicates(adata)
+    return filtered_adata, duplicates

smftools/preprocessing/remove_duplicates.py

@@ -1,12 +1,21 @@
 # remove_duplicates
-import anndata as ad
 
 def remove_duplicates(adata):
     """
-    Input: adata object with marked duplicates
-    Output: Remove duplicates from the adata object
+    Remove duplicates from the adata object
+
+    Parameters:
+        adata (Anndata): An adata object.
+
+    Returns:
+        filtered_adata (AnnData): An AnnData object of the filtered reads 
+        duplicates (AnnData): An AnnData object of the duplicate reads 
     """
+    import anndata as ad
+
     initial_size = adata.shape[0]
-    adata = adata[adata.obs['Unique_in_final_read_set'] == True].copy()
-    final_size = adata.shape[0]
-    print(f'Removed {initial_size-final_size} reads from the dataset')
+    filtered_adata = adata[adata.obs['Unique_in_final_read_set'] == True].copy()
+    final_size = filtered_adata.shape[0]
+    print(f'Removed {initial_size-final_size} reads from the dataset')
+    duplicates = adata[adata.obs['Unique_in_final_read_set'] == False].copy()
+    return filtered_adata, duplicates

smftools/readwrite.py

@@ -1,27 +1,12 @@
 ## readwrite ##
 
-# Basic I/O
-import os
-# Datetime
-from datetime import datetime
-# Data structures and basic operations
-import math
-import numpy as np
-import pandas as pd
-import anndata as ad
-import scipy.sparse as sp
-
-# Runtime warnings
-import warnings
-warnings.filterwarnings('ignore', category=UserWarning, module='anndata')
-warnings.filterwarnings('ignore', category=FutureWarning, module='anndata')
-
 ######################################################################################################
 ## Datetime functionality
 def date_string():
     """
     Each time this is called, it returns the current date string
     """
+    from datetime import datetime
     current_date = datetime.now()
     date_string = current_date.strftime("%Y%m%d")
     date_string = date_string[2:]
@@ -31,6 +16,7 @@ def time_string():
     """
     Each time this is called, it returns the current time string
     """
+    from datetime import datetime
     current_time = datetime.now()
     return current_time.strftime("%H:%M:%S")
 ######################################################################################################
@@ -42,6 +28,9 @@ def adata_to_df(adata, layer=None):
     Input: An adata object with a specified layer.
     Output: A dataframe for the specific layer.
     """
+    import pandas as pd
+    import anndata as ad
+
     # Extract the data matrix from the given layer
     if layer:
         data_matrix = adata.layers[layer]
@@ -60,6 +49,7 @@ def save_matrix(matrix, save_name):
     Input: A numpy matrix and a save_name
     Output: A txt file representation of the data matrix
     """
+    import numpy as np
     np.savetxt(f'{save_name}.txt', matrix)
 
 def concatenate_h5ads(output_file, file_suffix='h5ad.gz', delete_inputs=True):
@@ -67,6 +57,13 @@ def concatenate_h5ads(output_file, file_suffix='h5ad.gz', delete_inputs=True):
     Concatenate all h5ad files in a directory and delete them after the final adata is written out.
     Input: an output file path relative to the directory in which the function is called
     """
+    import os
+    import anndata as ad
+    # Runtime warnings
+    import warnings
+    warnings.filterwarnings('ignore', category=UserWarning, module='anndata')
+    warnings.filterwarnings('ignore', category=FutureWarning, module='anndata')
+    
     # List all files in the directory
     files = os.listdir(os.getcwd())
     # get current working directory

smftools/tools/apply_HMM.py

@@ -0,0 +1 @@
+# apply_HMM

smftools/tools/read_HMM.py

@@ -0,0 +1 @@
+# read_HMM

smftools/tools/subset_adata.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/train_HMM.py

@@ -0,0 +1,43 @@
+# train_HMM
+
+def train_HMM(adata, model_name='trained_HMM', save_hmm=False):
+    """
+
+    Parameters:
+        adata (AnnData): Input AnnData object
+        model_name (str): Name of the model
+        save_hmm (bool): Whether to save the model
+    
+    """
+    import numpy as np
+    import anndata as ad
+    from pomegranate.distributions import Categorical
+    from pomegranate.hmm import DenseHMM
+
+    bound = Categorical([[0.95, 0.05]])
+    unbound = Categorical([[0.05, 0.95]])
+
+    edges = [[0.9, 0.1], [0.1, 0.9]]
+    starts = [0.5, 0.5]
+    ends = [0.5, 0.5]
+
+    model = DenseHMM([bound, unbound], edges=edges, starts=starts, ends=ends, max_iter=5, verbose=True)
+
+    # define training sets and labels
+    # Determine the number of reads to sample
+    n_sample = round(0.7 * adata.X.shape[0])
+    # Generate random indices
+    np.random.seed(0)
+    random_indices = np.random.choice(adata.shape[0], size=n_sample, replace=False)
+    # Subset the AnnData object using the random indices
+    training_adata_subsampled = adata[random_indices, :]
+    training_sequences = training_adata_subsampled.X
+
+    # Train the HMM without labeled data
+    model.fit(training_sequences, algorithm='baum-welch')
+
+    if save_hmm:
+        # Save the model to a file
+        model_json = model.to_json()
+        with open(f'{model_name}.json', 'w') as f:
+                f.write(model_json)

smftools-0.1.3.dist-info/METADATA

@@ -0,0 +1,94 @@
+Metadata-Version: 2.3
+Name: smftools
+Version: 0.1.3
+Summary: Single Molecule Footprinting Analysis in Python.
+Project-URL: Source, https://github.com/jkmckenna/smftools
+Project-URL: Documentation, https://smftools.readthedocs.io/
+Author: Joseph McKenna
+Maintainer-email: Joseph McKenna <jkmckenna@berkeley.edu>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: anndata,chromatin-accessibility,machine-learning,nanopore,protein-dna-binding,single-locus,single-molecule-footprinting
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Requires-Python: >=3.9
+Requires-Dist: anndata>=0.10.0
+Requires-Dist: biopython>=1.79
+Requires-Dist: cython>=0.29.28
+Requires-Dist: networkx>=3.2
+Requires-Dist: numpy<2,>=1.22.0
+Requires-Dist: pandas>=1.4.2
+Requires-Dist: pod5>=0.1.21
+Requires-Dist: pomegranate>1.0.0
+Requires-Dist: pyfaidx>=0.8.0
+Requires-Dist: pysam>=0.19.1
+Requires-Dist: scanpy>=1.9
+Requires-Dist: scikit-learn>=1.0.2
+Requires-Dist: scipy>=1.7.3
+Requires-Dist: seaborn>=0.11
+Requires-Dist: torch>=1.9.0
+Requires-Dist: tqdm
+Provides-Extra: docs
+Requires-Dist: ipython>=7.20; extra == 'docs'
+Requires-Dist: matplotlib!=3.6.1; extra == 'docs'
+Requires-Dist: myst-nb>=1; extra == 'docs'
+Requires-Dist: myst-parser>=2; extra == 'docs'
+Requires-Dist: nbsphinx>=0.9; extra == 'docs'
+Requires-Dist: readthedocs-sphinx-search; extra == 'docs'
+Requires-Dist: setuptools; extra == 'docs'
+Requires-Dist: sphinx-autodoc-typehints>=1.25.2; extra == 'docs'
+Requires-Dist: sphinx-book-theme>=1.1.0; extra == 'docs'
+Requires-Dist: sphinx-copybutton; extra == 'docs'
+Requires-Dist: sphinx-design; extra == 'docs'
+Requires-Dist: sphinx>=7; extra == 'docs'
+Requires-Dist: sphinxcontrib-bibtex; extra == 'docs'
+Requires-Dist: sphinxext-opengraph; extra == 'docs'
+Provides-Extra: tests
+Requires-Dist: pytest; extra == 'tests'
+Requires-Dist: pytest-cov; extra == 'tests'
+Description-Content-Type: text/markdown
+
+[![PyPI](https://img.shields.io/pypi/v/smftools.svg)](https://pypi.org/project/smftools)
+[![Docs](https://readthedocs.org/projects/smftools/badge/?version=latest)](https://smftools.readthedocs.io/en/latest/?badge=latest)
+
+# smftools
+A Python tool for processing raw sequencing data derived from single molecule footprinting experiments into [anndata](https://anndata.readthedocs.io/en/latest/) objects. Additional functionality for preprocessing, analysis, and visualization.
+
+## Philosophy
+While most genomic data structures handle low-coverage data (<100X) along large references, smftools prioritizes high-coverage data (scalable to at least 1 million X coverage) of a few genomic loci at a time. This enables efficient data storage, rapid data operations, hierarchical metadata handling, seamless integration with various machine-learning packages, and ease of visualization. Furthermore, functionality is modularized, enabling analysis sessions to be saved, reloaded, and easily shared with collaborators. Analyses are centered around the [anndata](https://anndata.readthedocs.io/en/latest/) object, and are heavily inspired by the work conducted within the single-cell genomics community.
+
+## Dependencies
+The following CLI tools need to be installed and configured before using the informatics (smftools.inform) module of smftools:
+1) [Dorado](https://github.com/nanoporetech/dorado) -> For standard/modified basecalling and alignment. Can be attained by downloading and configuring nanopore MinKnow software.
+2) [Samtools](https://github.com/samtools/samtools) -> For working with SAM/BAM files
+3) [Minimap2](https://github.com/lh3/minimap2) -> The aligner used by Dorado
+4) [Modkit](https://github.com/nanoporetech/modkit) -> Extracting summary statistics and read level methylation calls from modified BAM files
+5) [Bedtools](https://github.com/arq5x/bedtools2) -> For generating Bedgraphs from BAM alignment files.
+6) [BedGraphToBigWig](https://genome.ucsc.edu/goldenPath/help/bigWig.html) -> For converting BedGraphs to BigWig files for IGV sessions.
+
+## Modules
+### Informatics: Processes raw Nanopore/Illumina data from SMF experiments into an AnnData object.
+![](docs/source/_static/smftools_informatics_diagram.png)
+### Preprocessing: Appends QC metrics to the AnnData object and perfroms filtering.
+![](docs/source/_static/smftools_preprocessing_diagram.png)
+- Tools: Appends various analyses to the AnnData object.
+- Plotting: Visualization of analyses stored within the AnnData object.
+
+## Announcements
+### 09/09/24 - The pre-alpha phase package ([smftools-0.1.1](https://pypi.org/project/smftools/))
+The informatics module has been bumped to alpha-phase status. This module can deal with POD5s and unaligned BAMS from nanopore conversion and direct SMF experiments, as well as FASTQs from Illumina conversion SMF experiments. Primary output from this module is an AnnData object containing all relevant SMF data, which is compatible with all downstream smftools modules. The other modules are still in pre-alpha phase. Preprocessing, Tools, and Plotting modules should be promoted to alpha-phase within the next month or so.
+
+### 08/30/24 - The pre-alpha phase package ([smftools-0.1.0](https://pypi.org/project/smftools/)) is installable through pypi!
+Currently, this package (smftools-0.1.0) is going through rapid improvement (dependency handling accross Linux and Mac OS, testing, documentation, debugging) and is still too early in development for standard use. The underlying functionality was originally developed as a collection of scripts for single molecule footprinting (SMF) experiments in our lab, but is being packaged/developed to facilitate the expansion of SMF to any lab that is interested in performing these styles of experiments/analyses. The alpha-phase package is expected to be available within a couple months, so stay tuned!