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

smftools/informatics/helpers/bed_to_bigwig.py

@@ -1,39 +0,0 @@
-# bed_to_bigwig
-
-def bed_to_bigwig(fasta, bed):
-    """
-    Takes a bed file of reads and makes a bedgraph plus a bigwig
-
-    Parameters:
-        fasta (str): File path to the reference genome to align to.
-        bed (str): File path to the input bed.
-    Returns:
-        None
-    """
-    import os
-    import subprocess
-
-    bed_basename = os.path.basename(bed)
-    parent_dir = os.path.dirname(bed)
-    bed_basename_minus_suffix = bed_basename.split('.bed')[0]
-    fasta_basename = os.path.basename(fasta)
-    fasta_dir = os.path.dirname(fasta)
-    fasta_basename_minus_suffix = fasta_basename.split('.fa')[0]
-    chrom_basename = fasta_basename_minus_suffix + '.chrom.sizes'
-    chrom_path = os.path.join(fasta_dir, chrom_basename)
-    bedgraph_basename = bed_basename_minus_suffix + '_bedgraph.bedgraph'
-    bedgraph_output = os.path.join(parent_dir, bedgraph_basename)
-    bigwig_basename = bed_basename_minus_suffix + '_bigwig.bw'
-    bigwig_output = os.path.join(parent_dir, bigwig_basename)
-
-    # Make the bedgraph
-    with open(bedgraph_output, 'w') as outfile:
-        # Command as a list
-        command = ["bedtools", "genomecov", "-i", bed, "-g", chrom_path, "-bg"]
-        print(f'Making bedgraph from {bed_basename}')
-        subprocess.run(command, stdout=outfile)
-
-    # Make the bigwig
-    command = ["bedGraphToBigWig", bedgraph_output, chrom_path, bigwig_output]
-    print(f'Making bigwig from {bedgraph_basename}')
-    subprocess.run(command)

smftools/informatics/helpers/binarize_converted_base_identities.py

@@ -1,79 +0,0 @@
-def binarize_converted_base_identities(base_identities, strand, modification_type, bam, device='cpu'):
-    """
-    Efficiently binarizes conversion SMF data within a sequence string using NumPy arrays.
-
-    Parameters:
-        base_identities (dict): A dictionary returned by extract_base_identities. Keyed by read name. Points to a list of base identities.
-        strand (str): A string indicating which strand was converted in the experiment (options are 'top' and 'bottom').
-        modification_type (str): A string indicating the modification type of interest (options are '5mC' and '6mA').
-        bam (str): The bam file path
-
-    Returns:
-        dict: A dictionary where 1 represents a methylated site, 0 represents an unmethylated site, and NaN represents a site without methylation info.
-    """
-    import numpy as np
-
-    # If the modification type is 'unconverted', return NaN for all positions
-    if modification_type == "unconverted":
-        #print(f"Skipping binarization for unconverted {strand} reads on bam: {bam}.")
-        return {key: np.full(len(bases), np.nan) for key, bases in base_identities.items()}
-
-    # Define mappings for binarization based on strand and modification type
-    binarization_maps = {
-        ('top', '5mC'): {'C': 1, 'T': 0},
-        ('top', '6mA'): {'A': 1, 'G': 0},
-        ('bottom', '5mC'): {'G': 1, 'A': 0},
-        ('bottom', '6mA'): {'T': 1, 'C': 0}
-    }
-
-    if (strand, modification_type) not in binarization_maps:
-        raise ValueError(f"Invalid combination of strand='{strand}' and modification_type='{modification_type}'")
-
-    # Fetch the appropriate mapping
-    base_map = binarization_maps[(strand, modification_type)]
-
-    binarized_base_identities = {}
-    for key, bases in base_identities.items():
-        arr = np.array(bases, dtype='<U1')
-        binarized = np.vectorize(lambda x: base_map.get(x, np.nan))(arr)  # Apply mapping with fallback to NaN
-        binarized_base_identities[key] = binarized
-
-    return binarized_base_identities
-    # import torch
-
-    # # If the modification type is 'unconverted', return NaN for all positions
-    # if modification_type == "unconverted":
-    #     print(f"Skipping binarization for unconverted {strand} reads on bam: {bam}.")
-    #     return {key: torch.full((len(bases),), float('nan'), device=device) for key, bases in base_identities.items()}
-
-    # # Define mappings for binarization based on strand and modification type
-    # binarization_maps = {
-    #     ('top', '5mC'): {'C': 1, 'T': 0},
-    #     ('top', '6mA'): {'A': 1, 'G': 0},
-    #     ('bottom', '5mC'): {'G': 1, 'A': 0},
-    #     ('bottom', '6mA'): {'T': 1, 'C': 0}
-    # }
-
-    # if (strand, modification_type) not in binarization_maps:
-    #     raise ValueError(f"Invalid combination of strand='{strand}' and modification_type='{modification_type}'")
-
-    # # Fetch the appropriate mapping
-    # base_map = binarization_maps[(strand, modification_type)]
-    
-    # # Convert mapping to tensor
-    # base_keys = list(base_map.keys())
-    # base_values = torch.tensor(list(base_map.values()), dtype=torch.float32, device=device)
-
-    # # Create a lookup dictionary (ASCII-based for fast mapping)
-    # lookup_table = torch.full((256,), float('nan'), dtype=torch.float32, device=device)
-    # for k, v in zip(base_keys, base_values):
-    #     lookup_table[ord(k)] = v
-
-    # # Process reads
-    # binarized_base_identities = {}
-    # for key, bases in base_identities.items():
-    #     bases_tensor = torch.tensor([ord(c) for c in bases], dtype=torch.uint8, device=device)  # Convert chars to ASCII
-    #     binarized = lookup_table[bases_tensor]  # Efficient lookup
-    #     binarized_base_identities[key] = binarized
-
-    # return binarized_base_identities

smftools/informatics/helpers/concatenate_fastqs_to_bam.py

@@ -1,55 +0,0 @@
-# concatenate_fastqs_to_bam
-
-def concatenate_fastqs_to_bam(fastq_files, output_bam, barcode_tag='BC', gzip_suffix='.gz'):
-    """
-    Concatenate multiple demultiplexed FASTQ (.fastq or .fq) files into an unaligned BAM and add the FASTQ barcode suffix to the BC tag.
-
-    Parameters:
-        fastq_files (list): List of paths to demultiplexed FASTQ files.
-        output_bam (str): Path to the output BAM file.
-        barcode_tag (str): The SAM tag for storing the barcode (default: 'BC').
-        gzip_suffix (str): Suffix to use for input gzip files (Defaul: '.gz')
-
-    Returns:
-        None
-    """
-    import os
-    import pysam
-    import gzip
-    from Bio import SeqIO
-    from tqdm import tqdm
-
-    n_fastqs = len(fastq_files)
-
-    with pysam.AlignmentFile(output_bam, "wb", header={"HD": {"VN": "1.0"}, "SQ": []}) as bam_out:
-        for fastq_file in tqdm(fastq_files, desc="Processing FASTQ files"):
-            # Extract barcode from the FASTQ filename (handles .fq, .fastq, .fq.gz, and .fastq.gz extensions)
-            base_name = os.path.basename(fastq_file)
-            if n_fastqs > 1:
-                if base_name.endswith('.fastq.gz'):
-                    barcode = base_name.split('_')[-1].replace(f'.fastq{gzip_suffix}', '')
-                elif base_name.endswith('.fq.gz'):
-                    barcode = base_name.split('_')[-1].replace(f'.fq{gzip_suffix}', '')
-                elif base_name.endswith('.fastq'):
-                    barcode = base_name.split('_')[-1].replace('.fastq', '')
-                elif base_name.endswith('.fq'):
-                    barcode = base_name.split('_')[-1].replace('.fq', '')
-                else:
-                    raise ValueError(f"Unexpected file extension for {fastq_file}. Only .fq, .fastq, .fq{gzip_suffix}, and .fastq{gzip_suffix} are supported.")
-            else:
-                barcode = 'barcode0'
-
-            # Read the FASTQ file (handle gzipped and non-gzipped files)
-            open_func = gzip.open if fastq_file.endswith(gzip_suffix) else open
-            with open_func(fastq_file, 'rt') as fq_in:
-                for record in SeqIO.parse(fq_in, 'fastq'):
-                    # Create an unaligned BAM entry for each FASTQ record
-                    aln = pysam.AlignedSegment()
-                    aln.query_name = record.id
-                    aln.query_sequence = str(record.seq)
-                    aln.flag = 4  # Unmapped
-                    aln.query_qualities = pysam.qualitystring_to_array(record.letter_annotations["phred_quality"])
-                    # Add the barcode to the BC tag
-                    aln.set_tag(barcode_tag, barcode)
-                    # Write to BAM file
-                    bam_out.write(aln)

smftools/informatics/helpers/index_fasta.py

@@ -1,12 +0,0 @@
-# index_fasta
-
-def index_fasta(fasta):
-    """
-    Generate a FASTA index file for an input fasta.
-
-    Parameters:
-        fasta (str): Path to the input fasta to make an index file for.
-    """
-    import subprocess
-
-    subprocess.run(["samtools", "faidx", fasta])

smftools/informatics/helpers/make_dirs.py

@@ -1,21 +0,0 @@
-## 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/informatics/helpers/plot_read_length_and_coverage_histograms.py

@@ -1,53 +0,0 @@
-# plot_read_length_and_coverage_histograms
-
-def plot_read_length_and_coverage_histograms(bed_file, plotting_directory):
-    """
-    Plots read length and coverage statistics for each record.
-
-    Parameters:
-        bed_file (str): Path to the bed file to derive read lengths and coverage from.
-        plot_directory (str): Path to the directory to write out historgrams.
-
-    Returns:
-        None
-    """
-    import pandas as pd
-    import matplotlib.pyplot as plt
-    import numpy as np
-    import os
-
-    bed_basename = os.path.basename(bed_file).split('.bed')[0]
-    # Load the BED file into a DataFrame
-    print(f"Loading BED to plot read length and coverage histograms: {bed_file}")
-    df = pd.read_csv(bed_file, sep='\t', header=None, names=['chromosome', 'start', 'end', 'length', 'read_name'])
-    
-    # Group by chromosome
-    grouped = df.groupby('chromosome')
-
-    for chrom, group in grouped:
-        # Plot read length histogram
-        plt.figure(figsize=(12, 6))
-        plt.hist(group['length'], bins=50, edgecolor='k', alpha=0.7)
-        plt.title(f'Read Length Histogram of reads aligned to {chrom}')
-        plt.xlabel('Read Length')
-        plt.ylabel('Count')
-        plt.grid(True)
-        save_name = os.path.join(plotting_directory, f'{bed_basename}_{chrom}_read_length_histogram.png')
-        plt.savefig(save_name)
-        plt.close()
-
-        # Compute coverage
-        coverage = np.zeros(group['end'].max())
-        for _, row in group.iterrows():
-            coverage[row['start']:row['end']] += 1
-        
-        # Plot coverage histogram
-        plt.figure(figsize=(12, 6))
-        plt.plot(coverage, color='b')
-        plt.title(f'Coverage Histogram for {chrom}')
-        plt.xlabel('Position')
-        plt.ylabel('Coverage')
-        plt.grid(True)
-        save_name = os.path.join(plotting_directory, f'{bed_basename}_{chrom}_coverage_histogram.png')
-        plt.savefig(save_name)
-        plt.close()

smftools/informatics/load_adata.py

@@ -1,182 +0,0 @@
-## load_adata
-
-def load_adata(config_path):
-    """
-    High-level function to call for converting raw sequencing data to an adata object. 
-    Works for nanopore pod5, fast5, and unaligned modBAM data types for direct SMF workflows.
-    Works for nanopore pod5, fast5, unaligned BAM for conversion SMF workflows.
-    Also works for illumina fastq and unaligned BAM for conversion SMF workflows.
-
-    Parameters:
-        config_path (str): A string representing the file path to the experiment configuration csv file.
-
-    Returns:
-        None
-    """
-    # Lazy importing of packages
-    from .helpers import LoadExperimentConfig, make_dirs, concatenate_fastqs_to_bam, extract_read_features_from_bam
-    from .fast5_to_pod5 import fast5_to_pod5
-    from .subsample_fasta_from_bed import subsample_fasta_from_bed
-    import os
-    import numpy as np
-    import anndata as ad
-    from pathlib import Path
-
-    # Default params
-    bam_suffix = '.bam' # If different, change from here.
-    split_dir = 'demultiplexed_BAMs' # If different, change from here.
-    strands = ['bottom', 'top'] # If different, change from here. Having both listed generally doesn't slow things down too much.
-    conversions = ['unconverted'] # The name to use for the unconverted files. If different, change from here.
-
-    # Load experiment config parameters into global variables
-    experiment_config = LoadExperimentConfig(config_path)
-    var_dict = experiment_config.var_dict
-
-    # These below variables will point to default_value if they are empty in the experiment_config.csv or if the variable is fully omitted from the csv.
-    default_value = None
-
-    # General config variable init
-    smf_modality = var_dict.get('smf_modality', default_value) # needed for specifying if the data is conversion SMF or direct methylation detection SMF. Necessary.
-    input_data_path = var_dict.get('input_data_path', default_value) # Path to a directory of POD5s/FAST5s or to a BAM/FASTQ file. Necessary.
-    output_directory = var_dict.get('output_directory', default_value) # Path to the output directory to make for the analysis. Necessary.
-    fasta = var_dict.get('fasta', default_value) # Path to reference FASTA.
-    fasta_regions_of_interest = var_dict.get("fasta_regions_of_interest", default_value) # Path to a bed file listing coordinate regions of interest within the FASTA to include. Optional.
-    mapping_threshold = var_dict.get('mapping_threshold', default_value) # Minimum proportion of mapped reads that need to fall within a region to include in the final AnnData.
-    experiment_name = var_dict.get('experiment_name', default_value) # A key term to add to the AnnData file name.
-    model_dir = var_dict.get('model_dir', default_value) # needed for dorado basecaller
-    model = var_dict.get('model', default_value) # needed for dorado basecaller
-    barcode_kit = var_dict.get('barcode_kit', default_value) # needed for dorado basecaller
-    barcode_both_ends = var_dict.get('barcode_both_ends', default_value) # dorado demultiplexing
-    trim = var_dict.get('trim', default_value) # dorado adapter and barcode removal
-    input_already_demuxed = var_dict.get('input_already_demuxed', default_value) # If the input files are already demultiplexed.
-    threads = var_dict.get('threads', default_value) # number of cpu threads available for multiprocessing
-    # Conversion specific variable init
-    conversion_types = var_dict.get('conversion_types', default_value)
-    # Direct methylation specific variable init
-    filter_threshold = var_dict.get('filter_threshold', default_value)
-    m6A_threshold = var_dict.get('m6A_threshold', default_value)
-    m5C_threshold = var_dict.get('m5C_threshold', default_value)
-    hm5C_threshold = var_dict.get('hm5C_threshold', default_value)
-    thresholds = [filter_threshold, m6A_threshold, m5C_threshold, hm5C_threshold]
-    mod_list = var_dict.get('mod_list', default_value)
-    batch_size = var_dict.get('batch_size', default_value)
-    device = var_dict.get('device', 'auto')
-    make_bigwigs = var_dict.get('make_bigwigs', default_value)
-    skip_unclassified = var_dict.get('skip_unclassified', True)
-    delete_batch_hdfs = var_dict.get('delete_batch_hdfs', True)
-
-    # Make initial output directory
-    make_dirs([output_directory])
-    os.chdir(output_directory)
-    # Define the pathname to split BAMs into later during demultiplexing.
-    split_path = os.path.join(output_directory, split_dir)
-
-    # If fasta_regions_of_interest is passed, subsample the input FASTA on regions of interest and use the subsampled FASTA.
-    if fasta_regions_of_interest and '.bed' in fasta_regions_of_interest:
-        fasta_basename = os.path.basename(fasta).split('.fa')[0]
-        bed_basename_minus_suffix = os.path.basename(fasta_regions_of_interest).split('.bed')[0]
-        output_FASTA = fasta_basename + '_subsampled_by_' + bed_basename_minus_suffix + '.fasta'
-        subsample_fasta_from_bed(fasta, fasta_regions_of_interest, output_directory, output_FASTA)
-        fasta = os.path.join(output_directory, output_FASTA)
-
-    # If conversion_types is passed:
-    if conversion_types:
-        conversions += conversion_types
-
-    # Get the input filetype
-    if Path(input_data_path).is_file():
-        input_data_filetype = '.' + os.path.basename(input_data_path).split('.')[1].lower()
-        input_is_pod5 = input_data_filetype in ['.pod5','.p5']
-        input_is_fast5 = input_data_filetype in ['.fast5','.f5']
-        input_is_fastq = input_data_filetype in ['.fastq', '.fq']
-        input_is_bam = input_data_filetype == bam_suffix
-        if input_is_fastq:
-            fastq_paths = [input_data_path]
-    elif Path(input_data_path).is_dir():
-        # Get the file names in the input data dir
-        input_files = os.listdir(input_data_path)
-        input_is_pod5 = sum([True for file in input_files if '.pod5' in file or '.p5' in file])
-        input_is_fast5 = sum([True for file in input_files if '.fast5' in file or '.f5' in file])
-        input_is_fastq = sum([True for file in input_files if '.fastq' in file or '.fq' in file])
-        input_is_bam = sum([True for file in input_files if bam_suffix in file])
-        if input_is_fastq:
-            fastq_paths = [os.path.join(input_data_path, file) for file in input_files if '.fastq' in file or '.fq' in file]
-
-    # If the input files are not pod5 files, and they are fast5 files, convert the files to a pod5 file before proceeding.
-    if input_is_fast5 and not input_is_pod5:
-        # take the input directory of fast5 files and write out a single pod5 file into the output directory.
-        output_pod5 = os.path.join(output_directory, 'FAST5s_to_POD5.pod5')
-        print(f'Input directory contains fast5 files, converting them and concatenating into a single pod5 file in the {output_pod5}')
-        fast5_to_pod5(input_data_path, output_pod5)
-        # Reassign the pod5_dir variable to point to the new pod5 file.
-        input_data_path = output_pod5
-        input_is_pod5 = True
-        input_is_fast5 = False
-    
-    elif input_is_fastq:
-        output_bam = os.path.join(output_directory, 'FASTQs_concatenated_into_BAM.bam')
-        concatenate_fastqs_to_bam(fastq_paths, output_bam, barcode_tag='BC', gzip_suffix='.gz')
-        input_data_path = output_bam
-        input_is_bam = True
-        input_is_fastq = False
-
-    if input_is_pod5:
-        basecall = True
-    elif input_is_bam:
-        basecall = False
-    else:
-        print('Error, can not find input bam or pod5')
-
-    if smf_modality == 'conversion':
-        from .conversion_smf import conversion_smf
-        final_adata, final_adata_path, sorted_output, bam_files = conversion_smf(fasta, output_directory, conversions, strands, model_dir, model, input_data_path, split_path
-                                                         , barcode_kit, mapping_threshold, experiment_name, bam_suffix, basecall, barcode_both_ends, trim, device, make_bigwigs, threads, input_already_demuxed)
-    elif smf_modality == 'direct':
-        from .direct_smf import direct_smf
-        # need to add input_already_demuxed workflow here.
-        final_adata, final_adata_path, sorted_output, bam_files = direct_smf(fasta, output_directory, mod_list,model_dir, model, thresholds, input_data_path, split_path
-                                                     , barcode_kit, mapping_threshold, experiment_name, bam_suffix, batch_size, basecall, barcode_both_ends, trim, device, make_bigwigs, skip_unclassified, delete_batch_hdfs, threads)
-    else:
-            print("Error")
-            
-    # Read in the final adata object and append final metadata
-    #print(f'Reading in adata from {final_adata_path} to add final metadata')
-    # final_adata = ad.read_h5ad(final_adata_path)
-    
-    # Adding read query length metadata to adata object.
-    read_metrics = {}
-    for bam_file in bam_files:
-        bam_read_metrics = extract_read_features_from_bam(bam_file)
-        read_metrics.update(bam_read_metrics)
-    #read_metrics = extract_read_features_from_bam(sorted_output)
-
-    query_read_length_values = []
-    query_read_quality_values = []
-    reference_lengths = []
-    # Iterate over each row of the AnnData object
-    for obs_name in final_adata.obs_names:
-        # Fetch the value from the dictionary using the obs_name as the key
-        value = read_metrics.get(obs_name, np.nan)  # Use np.nan if the key is not found
-        if type(value) is list:
-            query_read_length_values.append(value[0])
-            query_read_quality_values.append(value[1])
-            reference_lengths.append(value[2])
-        else:
-            query_read_length_values.append(value)
-            query_read_quality_values.append(value)
-            reference_lengths.append(value) 
-                       
-    # Add the new column to adata.obs
-    final_adata.obs['query_read_length'] = query_read_length_values
-    final_adata.obs['query_read_quality'] = query_read_quality_values
-    final_adata.obs['query_length_to_reference_length_ratio'] = np.array(query_read_length_values) / np.array(reference_lengths)
-
-    final_adata.obs['Raw_methylation_signal'] = np.nansum(final_adata.X, axis=1)
-    final_adata.obs['Raw_per_base_methylation_average'] = final_adata.obs['Raw_methylation_signal'] / final_adata.obs['query_read_length']
-
-    print('Saving final adata')
-    if ".gz" in final_adata_path:
-        final_adata.write_h5ad(f"{final_adata_path}", compression='gzip')
-    else:
-        final_adata.write_h5ad(f"{final_adata_path}.gz", compression='gzip')
-    print('Final adata saved')

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_fasta_from_bed.py

@@ -1,47 +0,0 @@
-# subsample_fasta_from_bed
-
-def subsample_fasta_from_bed(input_FASTA, input_bed, output_directory, output_FASTA):
-    """
-    Take a genome-wide FASTA file and a bed file containing coordinate windows of interest. Outputs a subsampled FASTA.
-
-    Parameters:
-        input_FASTA (str): String representing the path to the input FASTA file.
-        input_bed (str): String representing the path to the input BED file.
-        output_directory (str): String representing the path to the output directory for the new FASTA file.
-        output_FASTA (str): Name of the output FASTA.
-    
-    Returns:
-        None
-    """
-    from pyfaidx import Fasta
-    import os
-
-    # Load the FASTA file using pyfaidx
-    fasta = Fasta(input_FASTA)
-
-    output_FASTA_path = os.path.join(output_directory, output_FASTA)
-    
-    # Open the BED file
-    with open(input_bed, 'r') as bed, open(output_FASTA_path, 'w') as out_fasta:
-        for line in bed:
-            # Each line in BED file contains: chrom, start, end (and possibly more columns)
-            fields = line.strip().split()
-            n_fields = len(fields)
-            chrom = fields[0]
-            start = int(fields[1])  # BED is 0-based
-            end = int(fields[2])    # BED is 0-based and end is exclusive
-            if n_fields > 3:
-                description = " ".join(fields[3:])
-            
-            # Check if the chromosome exists in the FASTA file
-            if chrom in fasta:
-                # pyfaidx is 1-based, so convert coordinates accordingly
-                sequence = fasta[chrom][start:end].seq
-                # Write the sequence to the output FASTA file
-                if n_fields > 3:
-                    out_fasta.write(f">{chrom}:{start}-{end}    {description}\n")
-                else:
-                    out_fasta.write(f">{chrom}:{start}-{end}\n")
-                out_fasta.write(f"{sequence}\n")
-            else:
-                print(f"Warning: {chrom} not found in the FASTA file")