assemblytics 2.0.0__py3-none-any.whl

assemblytics/dotplot.py

@@ -0,0 +1,116 @@
+#!/usr/bin/env python3
+
+import sys
+import pandas as pd
+import matplotlib
+matplotlib.use('Agg')
+import matplotlib.pyplot as plt
+import numpy as np
+import os
+
+def run(output_dir):
+    filename = os.path.join(output_dir, "assemblytics_oriented_coords.csv")
+    plot_output_filename = os.path.join(output_dir, "assemblytics_dotplot_filtered")
+    plot_title = "Dot plot of Assemblytics filtered alignments"
+
+    if not os.path.exists(filename):
+        print(f"File {filename} not found.")
+        return
+
+    coords = pd.read_csv(filename)
+
+    if len(coords) > 100000:
+        coords = coords.head(100000)
+
+    coords['ref'] = coords['ref'].astype(str)
+    coords['query'] = coords['query'].astype(str)
+
+    # Ordering chromosomes
+    ordered_common_names = [str(i) for i in range(1, 101)] + \
+                           [f"chr{i}" for i in range(1, 101)] + \
+                           [f"Chr{i}" for i in range(1, 101)] + \
+                           ["X", "Y", "M", "MT", "Chr0", "chr0", "0"]
+    
+    unique_refs = coords['ref'].unique()
+    all_refs_ordered = [r for r in ordered_common_names if r in unique_refs] + \
+                       [r for r in unique_refs if r not in ordered_common_names]
+    
+    coords['ref'] = pd.Categorical(coords['ref'], categories=all_refs_ordered, ordered=True)
+    coords = coords.sort_values('ref')
+
+    # Get chromosome lengths and calculate offsets
+    chr_lengths = coords.groupby('ref', observed=False)['ref_length'].max().reindex(all_refs_ordered).fillna(0)
+    chr_offsets = chr_lengths.cumsum().shift(1).fillna(0)
+
+    def get_ref_loc(chrom, pos):
+        return chr_offsets[chrom] + pos
+
+    coords['ref_loc_start'] = coords.apply(lambda row: get_ref_loc(row['ref'], row['ref_start']), axis=1)
+    coords['ref_loc_stop'] = coords.apply(lambda row: get_ref_loc(row['ref'], row['ref_end']), axis=1)
+
+    # Calculate alignment length for query ordering
+    coords['alignment_length'] = abs(coords['query_start'] - coords['query_end'])
+
+    # Pick longest alignment for each query to decide query ordering
+    longest_alignments = coords.loc[coords.groupby('query')['alignment_length'].idxmax()]
+    ordered_queries = longest_alignments.sort_values('ref_loc_start')['query'].tolist()
+
+    # Get query lengths and calculate offsets
+    query_lengths = coords.groupby('query')['query_length'].max().reindex(ordered_queries).fillna(0)
+    query_offsets = query_lengths.cumsum().shift(1).fillna(0)
+
+    def get_query_loc(query, pos):
+        return query_offsets[query] + pos
+
+    coords['query_loc_start'] = coords.apply(lambda row: get_query_loc(row['query'], row['query_start']), axis=1)
+    coords['query_loc_stop'] = coords.apply(lambda row: get_query_loc(row['query'], row['query_end']), axis=1)
+
+    # Labels (hide for small chromosomes/queries)
+    total_ref_length = chr_lengths.sum()
+    chr_labels = [name if length >= 0.02 * total_ref_length else "" for name, length in chr_lengths.items()]
+    chr_breaks = chr_lengths.cumsum().tolist()
+
+    total_query_length = query_lengths.sum()
+    query_labels = [name if length >= 0.02 * total_query_length else "" for name, length in query_lengths.items()]
+    query_breaks = query_lengths.cumsum().tolist()
+
+    # Plotting
+    plt.figure(figsize=(10, 10))
+    
+    colors = {"unique": "black", "repetitive": "red"}
+    
+    for tag in ["unique", "repetitive"]:
+        df = coords[coords['tag'] == tag]
+        if not df.empty:
+            for _, row in df.iterrows():
+                plt.plot([row['ref_loc_start'], row['ref_loc_stop']], 
+                         [row['query_loc_start'], row['query_loc_stop']], 
+                         color=colors[tag], linewidth=1.5, solid_capstyle='butt')
+
+    plt.title(plot_title, fontsize=16)
+    plt.xlabel("Reference", fontsize=14)
+    plt.ylabel("Query", fontsize=14)
+
+    plt.xticks(chr_breaks, chr_labels, rotation=90, fontsize=8)
+    plt.yticks(query_breaks, query_labels, fontsize=8)
+
+    plt.xlim(0, total_ref_length)
+    plt.ylim(0, total_query_length)
+
+    plt.grid(True, linestyle='-', linewidth=0.1, color='black')
+    
+    # Custom legend
+    from matplotlib.lines import Line2D
+    legend_elements = [Line2D([0], [0], color='black', lw=2, label='unique'),
+                       Line2D([0], [0], color='red', lw=2, label='repetitive')]
+    plt.legend(handles=legend_elements, title="Filter", loc='upper right')
+
+    plt.tight_layout()
+    plt.savefig(plot_output_filename + ".png", dpi=200)
+    plt.close()
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print("Usage: dotplot.py output_dir")
+        sys.exit(1)
+    run(sys.argv[1])

assemblytics/index.py

@@ -0,0 +1,188 @@
+#!/usr/bin/env python3
+
+import argparse
+import os
+import numpy as np
+import re
+
+
+def run(args):
+
+    coords = args.coords
+    output_dir = args.out
+    if output_dir:
+        os.makedirs(output_dir, exist_ok=True)
+
+    f = open(coords)
+    f.readline() # ignore header
+
+    fields_by_query = {}
+    existing_query_names = set()
+    existing_reference_names = set()
+    reference_lengths = []
+    query_lengths = {}
+    for line in f:
+        fields = line.strip().split(",")
+        query_name = fields[7]
+        query_lengths[query_name] = int(fields[5])
+        if not query_name in existing_query_names:
+            fields_by_query[query_name] = []
+            existing_query_names.add(query_name)
+        fields_by_query[query_name].append(fields)
+
+        ref_name = fields[6]
+        ref_length = int(fields[4])
+        if not ref_name in existing_reference_names:
+            existing_reference_names.add(ref_name)
+            reference_lengths.append((ref_name,ref_length))
+
+    f.close()
+
+
+    #  Find the order of the reference chromosomes
+    reference_lengths.sort(key=lambda x: natural_key(x[0]))
+    
+    #  Find the cumulative sums
+    cumulative_sum = 0
+    ref_chrom_offsets = {}
+    queries_by_reference = {}
+    for ref,ref_length in reference_lengths:
+        ref_chrom_offsets[ref] = cumulative_sum
+        cumulative_sum += ref_length
+        queries_by_reference[ref] = set()
+
+    #  Calculate relative positions of each alignment in this cumulative length, and take the median of these for each query, then sort the queries by those scores
+    flip_by_query = {}
+    references_by_query = {} # for index
+    relative_ref_position_by_query = [] # for ordering
+
+
+    for query_name in fields_by_query:
+        lines = fields_by_query[query_name]
+        sum_forward = 0
+        sum_reverse = 0
+        amount_of_reference = {}
+        ref_position_scores = []
+        references_by_query[query_name] = set()
+        for ref,ref_length in reference_lengths:
+            amount_of_reference[ref] = 0
+        for fields in lines:
+            tag = fields[8]
+            if tag == "unique":
+                query_stop = int(fields[3])
+                query_start = int(fields[2])
+                ref_start = int(fields[0])
+                ref_stop = int(fields[1])
+                alignment_length = abs(int(fields[3])-int(fields[2]))
+                ref = fields[6]
+                
+                # for index:
+                references_by_query[query_name].add(ref)
+                queries_by_reference[ref].add(query_name)
+                # amount_of_reference[ref] += alignment_length 
+
+                # for ordering:
+                ref_position_scores.append(ref_chrom_offsets[ref] + (ref_start+ref_stop)/2)
+
+                # for orientation:
+                if query_stop < query_start:
+                    sum_reverse += alignment_length
+                else:
+                    sum_forward += alignment_length
+        # orientation:
+        flip_by_query[query_name] = sum_reverse > sum_forward
+
+        # ordering
+        if len(ref_position_scores) > 0:
+            relative_ref_position_by_query.append((query_name,np.median(ref_position_scores)))
+        else:
+            relative_ref_position_by_query.append((query_name,0))
+
+
+    relative_ref_position_by_query.sort(key=lambda x: x[1])
+
+    fout_ref_index = open(os.path.join(output_dir, "assemblytics_ref_index.csv"),'w')
+    fout_ref_index.write("ref,ref_length,matching_queries\n")
+
+    # reference_lengths is sorted by the reference chromosome name
+    for ref,ref_length in reference_lengths:
+        fout_ref_index.write("%s,%d,%s\n" % (ref,ref_length,"~".join(queries_by_reference[ref])))
+    fout_ref_index.close()
+
+    fout_query_index = open(os.path.join(output_dir, "assemblytics_query_index.csv"),'w')
+    fout_query_index.write("query,query_length,matching_refs\n")
+
+    # relative_ref_position_by_query is sorted by rel_pos
+    for query,rel_pos in relative_ref_position_by_query:
+        fout_query_index.write("%s,%d,%s\n" % (query,query_lengths[query],"~".join(references_by_query[query])))
+    fout_query_index.close()
+
+
+    f = open(coords)
+    fout = open(os.path.join(output_dir, "assemblytics_oriented_coords.csv"),'w')
+    header = f.readline().strip()
+    fout.write(header+",alignment_length\n") # copy the header
+
+    alignment_length_column = len(header.split(","))
+
+    uniques = []
+    repetitives = []
+
+    for line in f:
+        fields = line.strip().split(",")
+        query_name = fields[7]
+        if flip_by_query[query_name] == True:
+            fields[2] = int(fields[5]) - int(fields[2])
+            fields[3] = int(fields[5]) - int(fields[3])
+            alignment_length = abs(int(fields[2]) - int(fields[1]))
+        else:
+            alignment_length = abs(int(fields[3]) - int(fields[2]))
+        fields.append(alignment_length)
+        if fields[8] == "unique":
+            uniques.append(fields)
+        else:
+            repetitives.append(fields)
+    f.close()
+
+    uniques.sort(key=lambda x: x[alignment_length_column],reverse=True)
+    repetitives.sort(key=lambda x: x[alignment_length_column],reverse=True)
+    
+    fout_info = open(os.path.join(output_dir, "assemblytics_info.csv"),'w')
+    fout_info.write("key,value\n")
+    fout_info.write("unique alignments,%d\n" % len(uniques))
+    fout_info.write("repetitive alignments,%d\n" % len(repetitives))
+
+
+    for fields in uniques:
+        fout.write(",".join(map(str,fields)) + "\n")
+
+    if len(repetitives) < 100000:
+        for fields in repetitives:
+            fout.write(",".join(map(str,fields)) + "\n")
+        fout_info.write("showing repetitive alignments,True\n")
+    else:
+        fout_repeats = open(os.path.join(output_dir, "assemblytics_oriented_coords_repetitive.csv"),'w')
+        fout_repeats.write(header+",alignment_length\n") # copy the header
+        for fields in repetitives:
+            fout_repeats.write(",".join(map(str,fields)) + "\n")
+        fout_repeats.close()
+        fout_info.write("showing repetitive alignments,False: Too many\n")
+
+    fout.close()
+    fout_info.close()
+
+def natural_key(string_):
+    """See http://www.codinghorror.com/blog/archives/001018.html"""
+    return [int(s) if s.isdigit() else s for s in re.split(r'(\d+)', string_)]
+
+
+def main():
+    parser=argparse.ArgumentParser(description="Index and orient a coordinate file for dotplots.")
+    parser.add_argument("-coords",help="coords.csv file from uniq_anchor.py" ,dest="coords", type=str, required=True)
+    parser.add_argument("-out",help="output directory for assemblytics_* index and oriented coordinates files (default: current directory)" ,dest="out", type=str, default=".")
+    parser.set_defaults(func=run)
+    args=parser.parse_args()
+    args.func(args)
+
+if __name__=="__main__":
+    main()

assemblytics/nchart.py

@@ -0,0 +1,95 @@
+#!/usr/bin/env python3
+
+import sys
+import pandas as pd
+import matplotlib
+matplotlib.use('Agg')
+import matplotlib.pyplot as plt
+import numpy as np
+import os
+
+def bp_format(num):
+    if num > 1000000000:
+        return "{:,.3f} Gbp".format(num / 1000000000).rstrip('0').rstrip('.')
+    elif num > 1000000:
+        return "{:,.3f} Mbp".format(num / 1000000).rstrip('0').rstrip('.')
+    elif num > 1000:
+        return "{:,.3f} Kbp".format(num / 1000).rstrip('0').rstrip('.')
+    else:
+        return "{:,} bp".format(int(num))
+
+def run(output_dir):
+    ref_genome = os.path.join(output_dir, "assemblytics_ref.genome")
+    query_genome = os.path.join(output_dir, "assemblytics_query.genome")
+    if not os.path.exists(ref_genome) or not os.path.exists(query_genome):
+        print(f"File {ref_genome} or {query_genome} not found.")
+        return
+
+    try:
+        ref_data = pd.read_csv(ref_genome, sep="\t", header=None, names=["name", "length"])
+        query_data = pd.read_csv(query_genome, sep="\t", header=None, names=["name", "length"])
+    except Exception as e:
+        print(f"Error reading {ref_genome} or {query_genome}: {e}")
+        return
+
+    ref_data = ref_data.sort_values("length", ascending=False)
+    query_data = query_data.sort_values("length", ascending=False)
+
+    genome_length = max(ref_data["length"].sum(), query_data["length"].sum())
+
+    # Calculate cumulative distributions
+    ref_cumsum = pd.DataFrame({
+        "NG": (ref_data["length"].cumsum() / genome_length * 100),
+        "contig_length": ref_data["length"],
+        "contig_source": "Reference"
+    })
+
+    query_cumsum = pd.DataFrame({
+        "NG": (query_data["length"].cumsum() / genome_length * 100),
+        "contig_length": query_data["length"],
+        "contig_source": "Query"
+    })
+
+    both_plot = pd.concat([ref_cumsum, query_cumsum])
+
+    # Add zeros for the start of the plot
+    ref_cumsum_0 = pd.concat([pd.DataFrame({"NG": [0], "contig_length": [ref_cumsum["contig_length"].max()], "contig_source": ["Reference"]}), ref_cumsum])
+    query_cumsum_0 = pd.concat([pd.DataFrame({"NG": [0], "contig_length": [query_cumsum["contig_length"].max()], "contig_source": ["Query"]}), query_cumsum])
+    
+    with_zeros = pd.concat([ref_cumsum_0, query_cumsum_0])
+
+    plt.figure(figsize=(8, 8))
+    colors = {"Reference": "limegreen", "Query": "blue"}
+
+    if len(with_zeros) > 2:
+        for source in ["Reference", "Query"]:
+            data = with_zeros[with_zeros["contig_source"] == source]
+            plt.step(data["NG"], data["contig_length"], where='post', color=colors[source], label=source, linewidth=1.5, alpha=0.5)
+            
+            points = both_plot[both_plot["contig_source"] == source]
+            plt.scatter(points["NG"], points["contig_length"], color=colors[source], s=20, alpha=0.5)
+    else:
+        for source in ["Reference", "Query"]:
+            points = both_plot[both_plot["contig_source"] == source]
+            plt.scatter(points["NG"], points["contig_length"], color=colors[source], s=40, alpha=0.5, label=source)
+
+    plt.yscale('log')
+    plt.xlim(0, 100)
+    plt.ylim(1, genome_length * 1.1)
+    
+    plt.xlabel(f"NG(x)% where 100% = {bp_format(genome_length)}")
+    plt.ylabel("Sequence length")
+    plt.title("Cumulative sequence length")
+    plt.legend(title="Assembly")
+    plt.grid(True, which="both", ls="-", alpha=0.2)
+
+    plt.tight_layout()
+    for fmt in ['png', 'pdf']:
+        plt.savefig(os.path.join(output_dir, f"assemblytics_nchart.{fmt}"), dpi=200)
+    plt.close()
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print("Usage: nchart.py output_dir")
+        sys.exit(1)
+    run(sys.argv[1])

assemblytics/summary.py

@@ -0,0 +1,147 @@
+#!/usr/bin/env python3
+
+import argparse
+import os
+import numpy as np
+
+def SVtable(args):
+    filename = args.file
+    minimum_variant_size = args.minimum_variant_size
+    maximum_variant_size = args.maximum_variant_size
+    simplify_types = False
+
+    f=open(filename)
+    typeList = []
+    sizeList = []
+    rawTypes = []
+    linecounter = 0
+    for line in f:
+        fields = line.strip().split()
+        if not fields[4].isdigit():
+            continue
+        svType = fields[6]
+        rawTypes.append(svType)
+        if simplify_types == True:
+            if svType == "Insertion" or svType == "Expansion":
+                typeList.append("Insertion/Expansion")
+            elif svType == "Deletion" or svType == "Contraction":
+                typeList.append("Deletion/Contraction")
+            else:
+                typeList.append(svType)
+        else:
+            typeList.append(svType)
+        sizeList.append(int(fields[4]))
+        linecounter += 1
+    f.close()
+    
+    size_thresholds = [10,50,500,10000,50000,100000,500000,1000000]
+
+    sizeArray = np.array(sizeList)
+    typeArray = np.array(typeList)
+    svTypes = ["Insertion","Deletion","Repeat_expansion","Repeat_contraction","Tandem_expansion","Tandem_contraction"]
+    if simplify_types == True:
+        svTypes = ["Insertion/Expansion","Deletion/Contraction"]
+    overall_total = 0
+    overall_total_bases = 0
+    overall_total_SVs = 0
+    overall_total_SV_bases = 0
+
+    SV_size = 50
+
+    all_SV_types = svTypes + list(set(rawTypes)-set(svTypes))
+
+    base, _ = os.path.splitext(filename)
+    f_output_csv = open(base + "_summary.csv",'w')
+
+    if linecounter > 0:
+        for svType in all_SV_types:
+            sizes = sizeArray[typeArray==svType]
+            overall_total += len(sizes)
+            overall_total_bases += sum(sizes)
+            overall_total_SVs += len(sizes[sizes>=SV_size])
+            overall_total_SV_bases += sum(sizes[sizes>=SV_size])
+            print(svType)
+            f_output_csv.write(svType + "\n")
+            
+            format = "%20s%10s%15s"
+
+            print(format % ("", "Count","Total bp"))
+            f_output_csv.write("Size range,Count,Total bp\n")
+
+            previous_size = minimum_variant_size
+            for threshold in size_thresholds:
+                if threshold <= minimum_variant_size or previous_size >= maximum_variant_size:
+                    continue
+                subset = sizes[np.logical_and(sizes>=previous_size,sizes<threshold)]; 
+                print(format % ("%s-%s bp: " % (intWithCommas(previous_size),intWithCommas(threshold)), str(len(subset)), str(sum(subset))))
+                f_output_csv.write("%s,%s,%s\n" % ("%s-%s bp" % (previous_size,threshold), str(len(subset)), str(sum(subset))))
+                previous_size = threshold
+
+            if previous_size < maximum_variant_size:
+                subset = sizes[sizes>=previous_size];    
+                print(format % ("> %s bp: " % (intWithCommas(previous_size)), str(len(subset)), str(sum(subset))))
+                f_output_csv.write("%s,%s,%s\n" % ("> %s bp" % (previous_size), str(len(subset)), str(sum(subset))))
+
+            print(format % ("Total: ",str(len(sizes)),str(sum(sizes))) + "\n")
+            f_output_csv.write("%s,%s,%s\n\n" % ("Total",str(len(sizes)),str(sum(sizes))))
+    else:
+        print("No variants found. Plots depicting variant size distributions will also be missing.\n")
+
+    print("Total number of all variants: %s" % (intWithCommas(overall_total)))
+    f_output_csv.write("Total for all variants,%s,%s bp\n" % (overall_total,int(overall_total_bases)))
+    print("Total bases affected by all variants: %s" % (gig_meg(int(overall_total_bases))))
+
+    print("Total number of structural variants: %s" % (intWithCommas(overall_total_SVs)))
+    f_output_csv.write("Total for all structural variants,%s,%s bp\n" % (overall_total_SVs,int(overall_total_SV_bases))  )
+    print("Total bases affected by structural variants: %s" % (gig_meg(int(overall_total_SV_bases))))
+
+    f_output_csv.close()
+
+def gig_meg(number,digits = 2):
+    gig = 1000000000.
+    meg = 1000000.
+    kil = 1000.
+
+    if number > gig:
+        return str(round(number/gig,digits)) + " Gbp"
+    elif number > meg:
+        return str(round(number/meg,digits)) + " Mbp"
+    elif number > kil:
+        return str(round(number/kil,digits)) + " Kbp"
+    else:
+        return str(number) + " bp"
+
+
+def intWithCommas(x):
+    if type(x) != int:
+        raise TypeError("Parameter must be an integer.")
+    if x < 0:
+        return '-' + intWithCommas(-x)
+    result = ''
+    while x >= 1000:
+        x, r = divmod(x, 1000)
+        result = ",%03d%s" % (r, result)
+    return "%d%s" % (x, result)
+
+def main():
+    parser=argparse.ArgumentParser(description='Output a summary table of variants from Assemblytics',formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+    parser.add_argument('-i',help='bed file of variants from Assemblytics',dest='file',type=str,required=True)
+    parser.add_argument('-min',help='minimum variant size',dest='minimum_variant_size',type=int,required=True)
+    parser.add_argument('-max',help='maximum variant size',dest='maximum_variant_size',type=int,required=True)
+
+    args=parser.parse_args()
+    SVtable(args)
+    
+if __name__=="__main__":
+    main()
+
+
+
+
+
+
+
+
+
+
+