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

smftools/informatics/helpers/extract_read_lengths_from_bed.py

@@ -0,0 +1,25 @@
+# extract_read_lengths_from_bed
+
+def extract_read_lengths_from_bed(file_path):
+    """
+    Load a dict of read names that points to the read length
+
+    Params:
+        file_path (str): file path to a bed file
+    Returns:
+        read_dict (dict)
+    """
+    import pandas as pd
+    columns = ['chrom', 'start', 'end', 'length', 'name']
+    df = pd.read_csv(file_path, sep='\t', header=None, names=columns, comment='#')
+    read_dict = {}
+    for _, row in df.iterrows():
+        chrom = row['chrom']
+        start = row['start']
+        end = row['end']
+        name = row['name']
+        length = row['length']
+        read_dict[name] = length
+
+    return read_dict
+        

smftools/informatics/helpers/find_conversion_sites.py

@@ -1,61 +1,50 @@
-## find_conversion_sites
-
 def find_conversion_sites(fasta_file, modification_type, conversion_types):
     """
-    A function to find genomic coordinates in every unconverted record contained within a FASTA file of every cytosine.
-    If searching for adenine conversions, it will find coordinates of all adenines.
+    Finds genomic coordinates of modified bases (5mC or 6mA) in a reference FASTA file.
 
     Parameters:
-        fasta_file (str): A string representing the file path to the converted reference FASTA.
-        modification_type (str): A string representing the modification type of interest (options are '5mC' and '6mA').
-        conversion_types (list): A list of strings of the conversion types to use in the analysis. Used here to pass the unconverted record name.
+        fasta_file (str): Path to the converted reference FASTA.
+        modification_type (str): Modification type ('5mC' or '6mA') or 'unconverted'.
+        conversion_types (list): List of conversion types. The first element is the unconverted record type.
 
     Returns: 
-        record_dict (dict): A dictionary keyed by unconverted record ids contained within the FASTA. Points to a list containing: 1) sequence length of the record, 2) top strand coordinate list, 3) bottom strand coorinate list, 4) sequence string, 5) Complement sequence
+        dict: Dictionary where keys are **both unconverted & converted record names**.
+              Values contain:
+              [sequence length, top strand coordinates, bottom strand coordinates, sequence, complement sequence].
     """
-    from .. import readwrite
+    import numpy as np
     from Bio import SeqIO
-    from Bio.SeqRecord import SeqRecord
-    from Bio.Seq import Seq
-    
-    #print('{0}: Finding positions of interest in reference FASTA: {1}'.format(readwrite.time_string(), fasta_file))
-    # Initialize lists to hold top and bottom strand positional coordinates of interest
-    top_strand_coordinates = []
-    bottom_strand_coordinates = []
     unconverted = conversion_types[0]
     record_dict = {}
-    #print('{0}: Opening FASTA file {1}'.format(readwrite.time_string(), fasta_file))
-    # Open the FASTA record as read only
+
+    # Define base mapping based on modification type
+    base_mappings = {
+        '5mC': ('C', 'G'),  # Cytosine and Guanine
+        '6mA': ('A', 'T')   # Adenine and Thymine
+    }
+
+    # Read FASTA file and process records
     with open(fasta_file, "r") as f:
-        # Iterate over records in the FASTA
         for record in SeqIO.parse(f, "fasta"):
-            # Only iterate over the unconverted records for the reference
             if unconverted in record.id:
-                #print('{0}: Iterating over record {1} in FASTA file {2}'.format(readwrite.time_string(), record, fasta_file))
-                # Extract the sequence string of the record
                 sequence = str(record.seq).upper()
                 complement = str(record.seq.complement()).upper()
                 sequence_length = len(sequence)
-                if modification_type == '5mC':
-                    # Iterate over the sequence string from the record
-                    for i in range(0, len(sequence)):
-                        if sequence[i] == 'C':
-                            top_strand_coordinates.append(i)  # 0-indexed coordinate
-                        if sequence[i] == 'G':
-                            bottom_strand_coordinates.append(i)  # 0-indexed coordinate      
-                    #print('{0}: Returning zero-indexed top and bottom strand FASTA coordinates for all cytosines'.format(readwrite.time_string()))
-                elif modification_type == '6mA':
-                    # Iterate over the sequence string from the record
-                    for i in range(0, len(sequence)):
-                        if sequence[i] == 'A':
-                            top_strand_coordinates.append(i)  # 0-indexed coordinate
-                        if sequence[i] == 'T':
-                            bottom_strand_coordinates.append(i)  # 0-indexed coordinate      
-                    #print('{0}: Returning zero-indexed top and bottom strand FASTA coordinates for adenines of interest'.format(readwrite.time_string()))          
+
+                # Unconverted case: store the full sequence without coordinate filtering
+                if modification_type == unconverted:
+                    record_dict[record.id] = [sequence_length, [], [], sequence, complement]
+
+                # Process converted records: extract modified base positions
+                elif modification_type in base_mappings:
+                    top_base, bottom_base = base_mappings[modification_type]
+                    seq_array = np.array(list(sequence))
+                    top_strand_coordinates = np.where(seq_array == top_base)[0].tolist()
+                    bottom_strand_coordinates = np.where(seq_array == bottom_base)[0].tolist()
+
+                    record_dict[record.id] = [sequence_length, top_strand_coordinates, bottom_strand_coordinates, sequence, complement]
+
                 else:
-                    #print('modification_type not found. Please try 5mC or 6mA') 
-                    pass   
-                record_dict[record.id] = [sequence_length, top_strand_coordinates, bottom_strand_coordinates, sequence, complement]
-            else:
-                pass  
-    return record_dict
+                    raise ValueError(f"Invalid modification_type: {modification_type}. Choose '5mC', '6mA', or 'unconverted'.")
+
+    return record_dict

smftools/informatics/helpers/generate_converted_FASTA.py

@@ -1,98 +1,99 @@
-## generate_converted_FASTA
+import numpy as np
+import gzip
+import os
+from Bio import SeqIO
+from Bio.SeqRecord import SeqRecord
+from Bio.Seq import Seq
+from concurrent.futures import ProcessPoolExecutor
+from itertools import chain
 
 def convert_FASTA_record(record, modification_type, strand, unconverted):
-    """
-    Takes a FASTA record and converts every instance of a base to the converted state.
+    """ Converts a FASTA record based on modification type and strand. """
+    conversion_maps = {
+        ('5mC', 'top'): ('C', 'T'),
+        ('5mC', 'bottom'): ('G', 'A'),
+        ('6mA', 'top'): ('A', 'G'),
+        ('6mA', 'bottom'): ('T', 'C')
+    }
 
-    Parameters:
-        record (str): The name of the record instance within the FASTA.
-        modification_type (str): The modification type to convert for (options are '5mC' and '6mA').
-        strand (str): The strand that is being converted in the experiment (options are 'top' and 'bottom').
+    sequence = str(record.seq).upper()
+
+    if modification_type == unconverted:
+        return SeqRecord(Seq(sequence), id=f"{record.id}_{modification_type}_top", description=record.description)
+
+    if (modification_type, strand) not in conversion_maps:
+        raise ValueError(f"Invalid combination: {modification_type}, {strand}")
+
+    original_base, converted_base = conversion_maps[(modification_type, strand)]
+    new_seq = sequence.replace(original_base, converted_base)
+
+    return SeqRecord(Seq(new_seq), id=f"{record.id}_{modification_type}_{strand}", description=record.description)
+
+
+def process_fasta_record(args):
+    """
+    Processes a single FASTA record for parallel execution.
+    Args:
+        args (tuple): (record, modification_types, strands, unconverted)
     Returns:
-        new_seq (str): Converted sequence string.
-        new_id (str): Record id for the converted sequence string.
+        list of modified SeqRecord objects.
     """
-    if modification_type == '5mC':
-        if strand == 'top':
-            # Replace every 'C' with 'T' in the sequence
-            new_seq = record.seq.upper().replace('C', 'T')
-        elif strand == 'bottom':
-            # Replace every 'G' with 'A' in the sequence
-            new_seq = record.seq.upper().replace('G', 'A')
-        else:
-            print('need to provide a valid strand string: top or bottom')
-        new_id = '{0}_{1}_{2}'.format(record.id, modification_type, strand)        
-    elif modification_type == '6mA':
-        if strand == 'top':
-            # Replace every 'A' with 'G' in the sequence
-            new_seq = record.seq.upper().replace('A', 'G')
-        elif strand == 'bottom':
-            # Replace every 'T' with 'C' in the sequence
-            new_seq = record.seq.upper().replace('T', 'C')
-        else:
-            print('need to provide a valid strand string: top or bottom')
-        new_id = '{0}_{1}_{2}'.format(record.id, modification_type, strand)
-    elif modification_type == unconverted:
-        new_seq = record.seq.upper()
-        new_id = '{0}_{1}_top'.format(record.id, modification_type)
-    else:
-        print(f'need to provide a valid modification_type string: 5mC, 6mA, or {unconverted}')   
-          
-    return new_seq, new_id
-
-def generate_converted_FASTA(input_fasta, modification_types, strands, output_fasta):
+    record, modification_types, strands, unconverted = args
+    modified_records = []
+    
+    for modification_type in modification_types:
+        for i, strand in enumerate(strands):
+            if i > 0 and modification_type == unconverted:
+                continue  # Ensure unconverted is added only once
+
+            modified_records.append(convert_FASTA_record(record, modification_type, strand, unconverted))
+
+    return modified_records
+
+
+def generate_converted_FASTA(input_fasta, modification_types, strands, output_fasta, num_threads=4, chunk_size=500):
     """
-    Uses modify_sequence_and_id function on every record within the FASTA to write out a converted FASTA.
+    Converts an input FASTA file and writes a new converted FASTA file efficiently.
 
     Parameters:
-        input_FASTA (str): A string representing the path to the unconverted FASTA file.
-        modification_types (list): A list of modification types to use in the experiment.
-        strands (list): A list of converstion strands to use in the experiment.
-        output_FASTA (str): A string representing the path to the converted FASTA output file.
+        input_fasta (str): Path to the unconverted FASTA file.
+        modification_types (list): List of modification types ('5mC', '6mA', or unconverted).
+        strands (list): List of strands ('top', 'bottom').
+        output_fasta (str): Path to the converted FASTA output file.
+        num_threads (int): Number of parallel threads to use.
+        chunk_size (int): Number of records to process per write batch.
+
     Returns:
-        None
-        Writes out a converted FASTA reference for the experiment.
+        None (Writes the converted FASTA file).
     """
-    from .. import readwrite
-    from Bio import SeqIO
-    from Bio.SeqRecord import SeqRecord
-    from Bio.Seq import Seq
-    import gzip
-    modified_records = []
     unconverted = modification_types[0]
-    # Iterate over each record in the input FASTA
-    if '.gz' in input_fasta:
-        with gzip.open(input_fasta, 'rt') as handle:    
+
+    # Detect if input is gzipped
+    open_func = gzip.open if input_fasta.endswith('.gz') else open
+    file_mode = 'rt' if input_fasta.endswith('.gz') else 'r'
+
+    def fasta_record_generator():
+        """ Lazily yields FASTA records from file. """
+        with open_func(input_fasta, file_mode) as handle:
             for record in SeqIO.parse(handle, 'fasta'):
-                record_description = record.description
-                # Iterate over each modification type of interest
-                for modification_type in modification_types:
-                    # Iterate over the strands of interest
-                    for i, strand in enumerate(strands):
-                        if i > 0 and modification_type == unconverted: # This ensures that the unconverted is only added once.
-                            pass
-                        else:
-                            # Add the modified record to the list of modified records
-                            print(f'converting {modification_type} on the {strand} strand of record {record}')
-                            new_seq, new_id = convert_FASTA_record(record, modification_type, strand, unconverted)
-                            new_record = SeqRecord(Seq(new_seq), id=new_id, description=record_description)
-                            modified_records.append(new_record)
-    else:
-        for record in SeqIO.parse(input_fasta, 'fasta'):
-            record_description = record.description
-            # Iterate over each modification type of interest
-            for modification_type in modification_types:
-                # Iterate over the strands of interest
-                for i, strand in enumerate(strands):
-                    if i > 0 and modification_type == unconverted: # This ensures that the unconverted is only added once.
-                        pass
-                    else:
-                        # Add the modified record to the list of modified records
-                        print(f'converting {modification_type} on the {strand} strand of record {record}')
-                        new_seq, new_id = convert_FASTA_record(record, modification_type, strand, unconverted)
-                        new_record = SeqRecord(Seq(new_seq), id=new_id, description=record_description)
-                        modified_records.append(new_record)
-                        
-    with open(output_fasta, 'w') as output_handle:
-        # write out the concatenated FASTA file of modified sequences
-        SeqIO.write(modified_records, output_handle, 'fasta')
+                yield record
+
+    with open(output_fasta, 'w') as output_handle, ProcessPoolExecutor(max_workers=num_threads) as executor:
+        # Process records in parallel using a named function (avoiding lambda)
+        results = executor.map(
+            process_fasta_record,
+            ((record, modification_types, strands, unconverted) for record in fasta_record_generator())
+        )
+
+        buffer = []
+        for modified_records in results:
+            buffer.extend(modified_records)
+
+            # Write out in chunks to save memory
+            if len(buffer) >= chunk_size:
+                SeqIO.write(buffer, output_handle, 'fasta')
+                buffer.clear()
+
+        # Write any remaining records
+        if buffer:
+            SeqIO.write(buffer, output_handle, 'fasta')

smftools/informatics/helpers/modcall.py

@@ -1,17 +1,21 @@
 ## modcall
 
 # Direct methylation specific
-def modcall(model, pod5_dir, barcode_kit, mod_list, bam, bam_suffix):
+def modcall(model_dir, model, pod5_dir, barcode_kit, mod_list, bam, bam_suffix, barcode_both_ends=True, trim=False, device='auto'):
     """
     Wrapper function for dorado modified base calling.
 
     Parameters:
-        model (str): a string representing the file path to the dorado basecalling model.
+        model_dir (str): a string representing the file path to the dorado basecalling model directory.
+        model (str): a string representing the the dorado basecalling model.
         pod5_dir (str): a string representing the file path to the experiment directory containing the POD5 files.
         barcode_kit (str): A string representing the barcoding kit used in the experiment.
         mod_list (list): A list of modification types to use in the analysis.
         bam (str): File path to the BAM file to output.
         bam_suffix (str): The suffix to use for the BAM file.
+        barcode_both_ends (bool): Whether to require a barcode detection on both ends for demultiplexing.
+        trim (bool): Whether to trim barcodes, adapters, and primers from read ends
+        device (str): Device to use for basecalling. auto, metal, cpu, cuda.
     
     Returns:
         None
@@ -19,10 +23,14 @@ def modcall(model, pod5_dir, barcode_kit, mod_list, bam, bam_suffix):
     """
     import subprocess
     output = bam + bam_suffix
-    command = [
-    "dorado", "basecaller", model, pod5_dir, "--kit-name", barcode_kit, "-Y",
-    "--modified-bases"]
+    command = ["dorado", "basecaller", "--models-directory", model_dir, "--kit-name", barcode_kit, "--modified-bases"]
     command += mod_list
+    command += ["--device", device, "--batchsize", "0"]
+    if barcode_both_ends:
+        command.append("--barcode-both-ends")
+    if not trim:
+        command.append("--no-trim")
+    command += [model, pod5_dir]
     print(f'Running: {" ".join(command)}')
     with open(output, "w") as outfile:
         subprocess.run(command, stdout=outfile)