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

smftools/informatics/readwrite.py

@@ -1,106 +0,0 @@
-## readwrite ##
-
-######################################################################################################
-## 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:]
-    return date_string
-
-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")
-######################################################################################################
-
-######################################################################################################
-## Numpy, Pandas, Anndata functionality
-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]
-    else:
-        data_matrix = adata.X
-    # Extract observation (read) annotations
-    obs_df = adata.obs
-    # Extract variable (position) annotations
-    var_df = adata.var
-    # Convert data matrix and annotations to pandas DataFrames
-    df = pd.DataFrame(data_matrix, index=obs_df.index, columns=var_df.index)
-    return df
-
-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):
-    """
-    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
-    cwd = os.getcwd()
-    suffix = file_suffix
-    # Filter file names that contain the search string in their filename and keep them in a list
-    hdfs = [hdf for hdf in files if suffix in hdf]
-    # Sort file list by names and print the list of file names
-    hdfs.sort()
-    print('{0} sample files found: {1}'.format(len(hdfs), hdfs))
-    # Iterate over all of the hdf5 files and concatenate them.
-    final_adata = None
-    for hdf in hdfs:
-        print('{0}: Reading in {1} hdf5 file'.format(time_string(), hdf))
-        temp_adata = ad.read_h5ad(hdf)
-        if final_adata:
-            print('{0}: Concatenating final adata object with {1} hdf5 file'.format(time_string(), hdf))
-            final_adata = ad.concat([final_adata, temp_adata], join='outer', index_unique=None)
-        else:
-            print('{0}: Initializing final adata object with {1} hdf5 file'.format(time_string(), hdf))
-            final_adata = temp_adata
-    print('{0}: Writing final concatenated hdf5 file'.format(time_string()))
-    final_adata.write_h5ad(output_file, compression='gzip')
-
-    # Delete the individual h5ad files and only keep the final concatenated file
-    if delete_inputs:
-        files = os.listdir(os.getcwd())
-        hdfs = [hdf for hdf in files if suffix in hdf]
-        if output_file in hdfs:
-            hdfs.remove(output_file)
-            # Iterate over the files and delete them
-            for hdf in hdfs:
-                try:
-                    os.remove(hdf)
-                    print(f"Deleted file: {hdf}")
-                except OSError as e:
-                    print(f"Error deleting file {hdf}: {e}")
-    else:
-        print('Keeping input files')
-######################################################################################################

smftools/informatics/subsample_pod5.py

@@ -1,48 +0,0 @@
-# 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,29 +0,0 @@
-from .append_C_context import append_C_context
-from .binarize_on_Youden import binarize_on_Youden
-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_position_Youden import calculate_position_Youden
-from .calculate_read_length_stats import calculate_read_length_stats
-from .clean_NaN import clean_NaN
-from .filter_converted_reads_on_methylation import filter_converted_reads_on_methylation
-from .filter_reads_on_length import filter_reads_on_length
-from .invert_adata import invert_adata
-from .mark_duplicates import mark_duplicates
-from .remove_duplicates import remove_duplicates
-
-__all__ = [
-    "append_C_context",
-    "binarize_on_Youden",
-    "calculate_complexity",
-    "calculate_converted_read_methylation_stats",
-    "calculate_coverage",    
-    "calculate_position_Youden",
-    "calculate_read_length_stats",
-    "clean_NaN",   
-    "filter_converted_reads_on_methylation",
-    "filter_reads_on_length",
-    "invert_adata",
-    "mark_duplicates",
-    "remove_duplicates"
-]

smftools/preprocessing/append_C_context.py

@@ -1,46 +0,0 @@
-## append_C_context
-
-## 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.
-    
-    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
-    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)
-        # Iterate through the sequence and apply the criteria
-        for i in range(1, len(sequence) - 1):
-            if sequence[i] == 'C':
-                if sequence[i - 1] == 'G' and sequence[i + 1] != 'G':
-                    boolean_dict[f'{cat}_GpC_site'][i] = True
-                elif sequence[i - 1] == 'G' and sequence[i + 1] == 'G':
-                    boolean_dict[f'{cat}_ambiguous_GpC_site'][i] = True
-                elif sequence[i - 1] != 'G' and sequence[i + 1] == 'G':
-                    boolean_dict[f'{cat}_CpG_site'][i] = True
-                elif sequence[i - 1] == 'G' and sequence[i + 1] == 'G':
-                    boolean_dict[f'{cat}_ambiguous_CpG_site'][i] = True
-                elif sequence[i - 1] != 'G' and sequence[i + 1] != 'G':
-                    boolean_dict[f'{cat}_other_C'][i] = True
-        for site_type in site_types:
-            adata.var[f'{cat}_{site_type}'] = boolean_dict[f'{cat}_{site_type}'].astype(bool)
-            adata.obsm[f'{cat}_{site_type}'] = adata[:, adata.var[f'{cat}_{site_type}'] == True].copy().X
-