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

smftools/informatics/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/informatics/subsample_pod5.py

@@ -0,0 +1,48 @@
+# subsample_pod5
+
+def subsample_pod5(pod5_path, read_name_path, output_directory):
+    """
+    Takes a POD5 file and a text file containing read names of interest and writes out a subsampled POD5 for just those reads.
+    This is a useful function when you have a list of read names that mapped to a region of interest that you want to reanalyze from the pod5 level.
+
+    Parameters:
+        pod5_path (str): File path to the POD5 to subsample.
+        read_name_path (str | int): File path to a text file of read names. One read name per line. If an int value is passed, a random subset of that many reads will occur
+        output_directory (str): A file path to the directory to output the file.
+
+    Returns:
+        None
+    """
+    import pod5 as p5
+    import os
+
+    input_pod5_base = os.path.basename(pod5_path)
+
+    if type(read_name_path) == str:
+        input_read_name_base = os.path.basename(read_name_path)
+        output_base = input_pod5_base.split('.pod5')[0] + '_' + input_read_name_base.split('.txt')[0] + '_subsampled.pod5'
+        # extract read names into a list of strings
+        with open(read_name_path, 'r') as file:
+            read_names = [line.strip() for line in file]
+        with p5.Reader(pod5_path) as reader:
+            read_records = []
+            for read_record in reader.reads(selection=read_names):
+                read_records.append(read_record.to_read())
+
+    elif type(read_name_path) == int:
+        import random
+        output_base = input_pod5_base.split('.pod5')[0] + f'_{read_name_path}_randomly_subsampled.pod5'
+        with p5.Reader(pod5_path) as reader:
+            all_read_records = []
+            for read_record in reader.reads():
+                all_read_records.append(read_record.to_read())
+        if read_name_path <= len(all_read_records):
+            read_records = random.sample(all_read_records, read_name_path)
+        else:
+            print('Trying to sample more reads than are contained in the input pod5, please try a lower value.')
+
+    output_pod5 = os.path.join(output_directory, output_base)
+
+    # Write the subsampled POD5
+    with p5.Writer(output_pod5) as writer:
+        writer.add_reads(read_records)

smftools/preprocessing/__init__.py

@@ -1,10 +1,8 @@
 from .append_C_context import append_C_context
 from .binarize_on_Youden import binarize_on_Youden
-from .binary_layers_to_ohe import binary_layers_to_ohe
 from .calculate_complexity import calculate_complexity
 from .calculate_converted_read_methylation_stats import calculate_converted_read_methylation_stats
 from .calculate_coverage import calculate_coverage
-from .calculate_pairwise_hamming_distances import calculate_pairwise_hamming_distances
 from .calculate_position_Youden import calculate_position_Youden
 from .calculate_read_length_stats import calculate_read_length_stats
 from .clean_NaN import clean_NaN
@@ -12,17 +10,14 @@ from .filter_converted_reads_on_methylation import filter_converted_reads_on_met
 from .filter_reads_on_length import filter_reads_on_length
 from .invert_adata import invert_adata
 from .mark_duplicates import mark_duplicates
-from .min_non_diagonal import min_non_diagonal
 from .remove_duplicates import remove_duplicates
 
 __all__ = [
     "append_C_context",
     "binarize_on_Youden",
-    "binary_layers_to_ohe",
     "calculate_complexity",
     "calculate_converted_read_methylation_stats",
     "calculate_coverage",    
-    "calculate_pairwise_hamming_distances",
     "calculate_position_Youden",
     "calculate_read_length_stats",
     "clean_NaN",   
@@ -30,6 +25,5 @@ __all__ = [
     "filter_reads_on_length",
     "invert_adata",
     "mark_duplicates",
-    "min_non_diagonal",
     "remove_duplicates"
 ]

smftools/preprocessing/append_C_context.py

@@ -1,22 +1,29 @@
 ## append_C_context
-import numpy as np
-import anndata as ad
-import pandas as pd
 
 ## Conversion SMF Specific 
 # Read methylation QC
 def append_C_context(adata, obs_column='Reference', use_consensus=False):
     """
+    Adds Cytosine context to the position within the given category. When use_consensus is True, it uses the consensus sequence, otherwise it defaults to the FASTA sequence.
+
+    Parameters:
+        adata (AnnData): The input adata object.
+        obs_column (str): The observation column in which to stratify on. Default is 'Reference', which should not be changed for most purposes.
+        use_consensus (bool): A truth statement indicating whether to use the consensus sequence from the reads mapped to the reference. If False, the reference FASTA is used instead.
     Input: An adata object, the obs_column of interst, and whether to use the consensus sequence from the category.
-    Output: Adds Cytosine context to the position within the given category. When use_consensus is True, it uses the consensus sequence, otherwise it defaults to the FASTA sequence.
+    
+    Returns:
+        None
     """
+    import numpy as np
+    import anndata as ad
     site_types = ['GpC_site', 'CpG_site', 'ambiguous_GpC_site', 'ambiguous_CpG_site', 'other_C']
     categories = adata.obs[obs_column].cat.categories
-    if use_consensus:
-        sequence = adata.uns[f'{cat}_consensus_sequence']
-    else:
-        sequence = adata.uns[f'{cat}_FASTA_sequence']
     for cat in categories:
+        if use_consensus:
+            sequence = adata.uns[f'{cat}_consensus_sequence']
+        else:
+            sequence = adata.uns[f'{cat}_FASTA_sequence']
         boolean_dict = {}
         for site_type in site_types:
             boolean_dict[f'{cat}_{site_type}'] = np.full(len(sequence), False, dtype=bool)

smftools/preprocessing/binarize_on_Youden.py

@@ -1,13 +1,17 @@
 ## binarize_on_Youden
-import numpy as np
-import pandas as pd
-import anndata as ad
 
 def binarize_on_Youden(adata, obs_column='Reference'):
     """
+    Add a new layer to the adata object that has binarized SMF values based on the position thresholds determined by calculate_position_Youden
+
+    Parameters:
+        adata (AnnData): The anndata object to binarize. pp.calculate_position_Youden function has to be run first.
+        obs_column (str): The obs_column to stratify on. Needs to be the same as passed in pp.calculate_position_Youden.
     Input: adata object that has had calculate_position_Youden called on it.
-    Output: Add a new layer to the adata object that has binarized SMF values based on the position thresholds determined by calculate_position_Youden
+    Output: 
     """
+    import numpy as np
+    import anndata as ad
     temp_adata = None
     categories = adata.obs[obs_column].cat.categories 
     for cat in categories:

smftools/preprocessing/binary_layers_to_ohe.py

@@ -1,14 +1,19 @@
 ## binary_layers_to_ohe
-import numpy as np
-import anndata as ad
-import pandas as pd
 
 ## Conversion SMF Specific 
 def binary_layers_to_ohe(adata, layers, stack='hstack'):
     """
+    Parameters:
+        adata (AnnData): Anndata object.
+        layers (list): a list of strings. Each string represents a layer in the adata object. The layer should encode a binary matrix
+        stack (str): Dimension to stack the one-hot-encoding. Options include 'hstack' and 'vstack'. Default is 'hstack', since this is more efficient.
+    
+    Returns:
+        ohe_dict (dict): A dictionary keyed by obs_name that points to a stacked (hstack or vstack) one-hot encoding of the binary layers
     Input: An adata object and a list of layers containing a binary encoding.
-    Output: A dictionary keyed by obs_name that points to a stacked (hstack or vstack) one-hot encoding of the binary layers
     """
+    import numpy as np
+    import anndata as ad
     # Extract the layers
     layers = [adata.layers[layer_name] for layer_name in layers]
     n_reads = layers[0].shape[0]

smftools/preprocessing/calculate_complexity.py

@@ -1,21 +1,32 @@
 ## calculate_complexity
-import numpy as np
-import pandas as pd
-from scipy.optimize import curve_fit
-import matplotlib.pyplot as plt
 
-def lander_waterman(x, C0):
-    return C0 * (1 - np.exp(-x / C0))
+def calculate_complexity(adata, obs_column='Reference', sample_col='Sample_names', plot=True, save_plot=False, output_directory=''):
+    """
+    A complexity analysis of the library.
 
-def count_unique_reads(reads, depth):
-    subsample = np.random.choice(reads, depth, replace=False)
-    return len(np.unique(subsample))
+    Parameters:
+        adata (AnnData): An adata object with mark_duplicates already run.
+        obs_column (str): String of the obs column to iterate over.
+        sample_col (str): String of the sample column to iterate over.
+        plot (bool): Whether to plot the complexity model.
+        save_plot (bool): Whether to save the complexity model.
+        output_directory (str): String representing the path to the output directory.
+
+    Returns:
+        None
 
-def calculate_complexity(adata, obs_column='Reference', sample_col='Sample_names', plot=True, save_plot=False):
-    """
-    Input: adata object with mark_duplicates already run.
-    Output: A complexity analysis of the library
     """
+    import numpy as np
+    import pandas as pd
+    from scipy.optimize import curve_fit
+
+    def lander_waterman(x, C0):
+        return C0 * (1 - np.exp(-x / C0))
+
+    def count_unique_reads(reads, depth):
+        subsample = np.random.choice(reads, depth, replace=False)
+        return len(np.unique(subsample))
+
     categories = adata.obs[obs_column].cat.categories 
     sample_names = adata.obs[sample_col].cat.categories 
 
@@ -40,6 +51,7 @@ def calculate_complexity(adata, obs_column='Reference', sample_col='Sample_names
             y_data = lander_waterman(x_data, *popt)
             adata.uns[f'Library_complexity_{sample}_on_{cat}'] = popt[0]
             if plot:
+                import matplotlib.pyplot as plt
                 # Plot the complexity curve
                 plt.figure(figsize=(6, 4))
                 plt.plot(total_reads, unique_reads, 'o', label='Observed unique reads')
@@ -52,7 +64,7 @@ def calculate_complexity(adata, obs_column='Reference', sample_col='Sample_names
                 plt.grid(True)
                 if save_plot:
                     date_string = date_string()
-                    save_name = output_directory + f'/{date_string} {title}'
+                    save_name = output_directory + f'/{date_string}_{title}'
                     plt.savefig(save_name, bbox_inches='tight', pad_inches=0.1)
                     plt.close()
                 else:

smftools/preprocessing/calculate_converted_read_methylation_stats.py

@@ -1,16 +1,23 @@
 ## calculate_converted_read_methylation_stats
-import numpy as np
-import anndata as ad
-import pandas as pd
 
 ## Conversion SMF Specific 
 # Read methylation QC
 
 def calculate_converted_read_methylation_stats(adata, obs_column='Reference'):
     """
-    Input: adata and the observation category of interest
-    Output: Adds methylation statistics for each read. Indicates whether the read GpC methylation exceeded other_C methylation (background false positives)
+    Adds methylation statistics for each read. Indicates whether the read GpC methylation exceeded other_C methylation (background false positives)
+
+    Parameters:
+        adata (AnnData): An AnnData object
+        obs_column (str): observation category of interest
+
+    Returns:
+        None 
     """
+    import numpy as np
+    import anndata as ad
+    import pandas as pd
+
     site_types = ['GpC_site', 'CpG_site', 'ambiguous_GpC_site', 'ambiguous_CpG_site', 'other_C']
     categories = adata.obs[obs_column].cat.categories
     for site_type in site_types:

smftools/preprocessing/calculate_coverage.py

@@ -1,15 +1,21 @@
 ## calculate_coverage
-from .. import readwrite
-import numpy as np
-import anndata as ad
-import pandas as pd
-
 
 def calculate_coverage(adata, obs_column='Reference', position_nan_threshold=0.05):
     """
-    Input: An adata object and an observation column of interest. Assess if the position is present in the dataset category.
-    Output: Append position level metadata indicating whether the position is informative within the given observation category.
+    Append position level metadata regarding whether the position is informative within the given observation category.
+
+    Parameters:
+        adata (AnnData): An AnnData object
+        obs_column (str): Observation column value to subset on prior to calculating position statistics for that category.
+        position_nan_threshold (float): A minimal threshold of coverage to call the position as valid.
+
+    Returns:
+        None
     """
+    import numpy as np
+    import anndata as ad
+    import pandas as pd
+
     categories = adata.obs[obs_column].cat.categories
     n_categories_with_position = np.zeros(adata.shape[1])
     # Loop over categories

smftools/preprocessing/calculate_pairwise_hamming_distances.py

@@ -1,15 +1,20 @@
 ## calculate_pairwise_hamming_distances
-import numpy as np
-import tqdm
-from scipy.spatial.distance import hamming
 
 ## Conversion SMF Specific 
 def calculate_pairwise_hamming_distances(arrays):
     """
-    Calculate the pairwise Hamming distances for a list of ndarrays.
-    Input: A list of ndarrays
-    Output: a 2D array containing the pairwise Hamming distances.
+    Calculate the pairwise Hamming distances for a list of h-stacked ndarrays.
+
+    Parameters:
+        arrays (str): A list of ndarrays.
+
+    Returns:
+        distance_matrix (ndarray): a 2D array containing the pairwise Hamming distances between all arrays.
+
     """
+    import numpy as np
+    import tqdm
+    from scipy.spatial.distance import hamming
     num_arrays = len(arrays)
     # Initialize an empty distance matrix
     distance_matrix = np.zeros((num_arrays, num_arrays))

smftools/preprocessing/calculate_position_Youden.py

@@ -1,20 +1,28 @@
 ## calculate_position_Youden
-import numpy as np
-import pandas as pd
-import anndata as ad
-import matplotlib.pyplot as plt
-from sklearn.metrics import roc_curve, roc_auc_score
-
-
 
 ## Calculating and applying position level thresholds for methylation calls to binarize the SMF data
 def calculate_position_Youden(adata, positive_control_sample, negative_control_sample, J_threshold=0.4, obs_column='Reference', save=False, output_directory=''):
     """
-    Input: An adata object, a plus MTase control, a minus MTase control, the minimal J-statistic threshold, and a categorical observation column to iterate over.
-    Input notes: The control samples are passed as string names of the samples as they appear in the 'Sample_names' obs column
-    Output: Adds new variable metadata to each position indicating whether the position provides reliable SMF methylation calls. Also outputs plots of the positional ROC curves.
-    Can optionally save the output plots of the ROC curve
+    Adds new variable metadata to each position indicating whether the position provides reliable SMF methylation calls. Also outputs plots of the positional ROC curves.
+
+    Parameters:
+        adata (AnnData): An AnnData object.
+        positive_control_sample (str): string representing the sample name corresponding to the Plus MTase control sample.
+        negative_control_sample (str): string representing the sample name corresponding to the Minus MTase control sample.
+        J_threshold (float): A float indicating the J-statistic used to indicate whether a position passes QC for methylation calls.
+        obs_column (str): The category to iterate over.
+        save (bool): Whether to save the ROC plots.
+        output_directory (str): String representing the path to the output directory to output the ROC curves.
+    
+    Returns: 
+        None
     """
+    import numpy as np
+    import pandas as pd
+    import anndata as ad
+    import matplotlib.pyplot as plt
+    from sklearn.metrics import roc_curve, roc_auc_score
+
     control_samples = [positive_control_sample, negative_control_sample]
     categories = adata.obs[obs_column].cat.categories 
     # Iterate over each category in the specified obs_column
@@ -89,7 +97,8 @@ def calculate_position_Youden(adata, positive_control_sample, negative_control_s
             plt.savefig(save_name)
             plt.close()
         else:
-            plt.show()    
+            plt.show()   
+
         adata.var[f'{cat}_position_methylation_thresholding_Youden_stats'] = probability_thresholding_list
         J_max_list = [probability_thresholding_list[i][1] for i in range(adata.shape[1])]
         adata.var[f'{cat}_position_passed_QC'] = [True if i > J_threshold else False for i in J_max_list]

smftools/preprocessing/calculate_read_length_stats.py

@@ -1,15 +1,20 @@
 ## calculate_read_length_stats
-import numpy as np
-import anndata as ad
-import pandas as pd
 
 # Read length QC
 def calculate_read_length_stats(adata):
     """
-    Input: An adata object
-    Output: Append first valid position in a read and last valid position in the read. From this determine and append the read length. 
-    Return two new variable which hold the first and last valid positions in the entire dataset
+    Append first valid position in a read and last valid position in the read. From this determine and append the read length. 
+
+    Parameters:
+        adata (AnnData): An adata object
+    
+    Returns:
+        upper_bound (int): last valid position in the dataset
+        lower_bound (int): first valid position in the dataset
     """
+    import numpy as np
+    import anndata as ad
+    import pandas as pd
     ## Add basic observation-level (read-level) metadata to the object: first valid position in a read and last valid position in the read. From this determine the read length. Save two new variable which hold the first and last valid positions in the entire dataset
 
     # Add some basic observation-level (read-level) metadata to the anndata object

smftools/preprocessing/clean_NaN.py

@@ -1,14 +1,21 @@
 ## clean_NaN
-import numpy as np
-import anndata as ad
-import pandas as pd
+from ..readwrite import adata_to_df
 
 # NaN handling
 def clean_NaN(adata, layer=None):
     """
-    Input: An adata object and the layer to fill Nan values of
-    Output: Append layers to adata that contain NaN cleaning strategies
+    Append layers to adata that contain NaN cleaning strategies.
+
+    Parameters:
+        adata (AnnData): an adata object
+        layer (str): string representing the layer to fill NaN values in
+
+    Returns:
+        None
     """
+    import numpy as np
+    import anndata as ad
+    import pandas as pd
     # Fill NaN with closest SMF value
     df = adata_to_df(adata, layer=layer)
     df = df.ffill(axis=1).bfill(axis=1)

smftools/preprocessing/filter_converted_reads_on_methylation.py

@@ -1,15 +1,22 @@
 ## filter_converted_reads_on_methylation
-import numpy as np
-import anndata as ad
-import pandas as pd
 
 ## Conversion SMF Specific 
 # Read methylation QC
 def filter_converted_reads_on_methylation(adata, valid_SMF_site_threshold=0.8, min_SMF_threshold=0.025):
     """
-    Input: Adata object. Minimum thresholds for valid SMF site fraction in read, as well as minimum methylation content in read
-    Output: A subset of the adata object
+    Filter adata object using minimum thresholds for valid SMF site fraction in read, as well as minimum methylation content in read.
+
+    Parameters:
+        adata (AnnData): An adata object.
+        valid_SMF_site_threshold (float): A minimum proportion of valid SMF sites that must be present in the read. Default is 0.8
+        min_SMF_threshold (float): A minimum read methylation level. Default is 0.025
+    Returns:
+        None
     """
+    import numpy as np
+    import anndata as ad
+    import pandas as pd
+
     if valid_SMF_site_threshold:
         # Keep reads that have over a given valid GpC site content
         adata = adata[adata.obs['fraction_valid_GpC_site_in_range'] > valid_SMF_site_threshold].copy()

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:
+        None
     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

smftools/preprocessing/invert_adata.py

@@ -1,14 +1,18 @@
 ## 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
     # 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/mark_duplicates.py

@@ -1,19 +1,28 @@
 ## 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'):
     """
-    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'.
+    
+    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 
 

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/remove_duplicates.py

@@ -1,11 +1,17 @@
 # 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:
+        None 
     """
+    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]