plastree 0.1.0__py3-none-any.whl

plastree/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

plastree/dotplotree.py

@@ -0,0 +1,306 @@
+# -*- coding: utf-8 -*-
+# dotplotree.py
+# Tree construction using dotplot-based similarity between DNA sequences
+
+from Bio.Seq import Seq
+from Bio.Phylo.TreeConstruction import DistanceMatrix
+from Bio.Phylo.TreeConstruction import DistanceTreeConstructor
+import numpy as np
+import math
+import os
+import matplotlib.pyplot as plt
+from concurrent.futures import ProcessPoolExecutor, as_completed
+
+
+def _replace_with_mask(sequence, mask, replacement_char='N'):
+    return Seq(''.join(replacement_char if mask_bit == '0' else char for char, mask_bit in zip(sequence, mask)))
+
+
+def _find_long_segments(points, window, gap):
+    segments = []
+    if not points:
+        return segments
+
+    current_segment = [points[0]]
+    half_window = (window) / 2
+
+    for i in range(1, len(points)):
+        distance_x = abs(points[i][0] - current_segment[-1][0])
+        distance_y = abs(points[i][1] - current_segment[-1][1])
+
+        if distance_x <= half_window and distance_y <= half_window and distance_x == distance_y:
+            current_segment.append(points[i])
+        else:
+            if len(current_segment) >= window:
+                segments.append(current_segment)
+            current_segment = [points[i]]
+
+    if len(current_segment) >= window:
+        segments.append(current_segment)
+
+    final_segments = []
+    current_final_segment = []
+
+    for segment in segments:
+        if not current_final_segment:
+            current_final_segment = segment
+        else:
+            distance_x = abs(current_final_segment[-1][0] - segment[0][0])
+            distance_y = abs(current_final_segment[-1][1] - segment[0][1])
+
+            if distance_x <= gap and distance_y <= gap and abs(distance_x - distance_y) <= round(window / 2):
+                current_final_segment.extend(segment[1:])
+            else:
+                if len(current_final_segment) >= 2 * window:
+                    final_segments.append(current_final_segment)
+                current_final_segment = segment
+
+    if current_final_segment and len(current_final_segment) >= 2 * window:
+        final_segments.append(current_final_segment)
+
+    return final_segments
+
+
+def _dot_mat_distance_core(seq1_str, seq2_str, window, gap):
+    if window == 22:
+        mask = '1110101100110010101111'
+    else:
+        mask = '1110100110010101111'
+
+    seq1 = seq1_str.upper()
+    seq2 = seq2_str.upper()
+    seq2rc = str(Seq(seq2).reverse_complement())
+    dict_one, dict_two, dict_two2 = {}, {}, {}
+
+    for seq, section_dict in [(seq1, dict_one), (seq2, dict_two), (seq2rc, dict_two2)]:
+        for i in range(len(seq) - window + 1):
+            section = _replace_with_mask(seq[i: i + window], mask)
+            section_dict.setdefault(section, []).append(i)
+
+    def get_match_coordinates(matches, one, two):
+        x, y = [], []
+        for section in matches:
+            for i in one[section]:
+                for j in two[section]:
+                    x.append(i)
+                    y.append(j)
+        return x, y
+
+    matches = set(dict_one).intersection(dict_two)
+    matches2 = set(dict_one).intersection(dict_two2)
+    x, y = get_match_coordinates(matches, dict_one, dict_two)
+    x2, y2 = get_match_coordinates(matches2, dict_one, dict_two2)
+
+    segments_direct = _find_long_segments(
+        sorted(zip(x, y), key=lambda p: (p[1] - p[0], p[0])), window, gap)
+    segments_reverse = _find_long_segments(
+        sorted(zip(x2, y2), key=lambda p: (p[1] - p[0], p[0])), window, gap)
+
+    bin_dir1 = np.zeros(len(seq1), dtype=int)
+    bin_dir2 = np.zeros(len(seq2), dtype=int)
+    bin_rev1 = np.zeros(len(seq1), dtype=int)
+    bin_rev2 = np.zeros(len(seq2), dtype=int)
+
+    for segment in segments_direct:
+        bin_dir1[segment[0][0]:segment[-1][0] + window] = 1
+        bin_dir2[segment[0][1]:segment[-1][1] + window] = 1
+
+    for segment in segments_reverse:
+        bin_rev1[segment[0][0]:segment[-1][0] + window] = 1
+        bin_rev2[segment[0][1]:segment[-1][1] + window] = 1
+
+    bin_rrev2 = bin_rev2[::-1]
+    merged_bin1 = np.logical_or(bin_dir1, bin_rev1).astype(int)
+    merged_bin2 = np.logical_or(bin_dir2, bin_rrev2).astype(int)
+
+    bin_match = np.sum(merged_bin1) + np.sum(merged_bin2)
+    return 1 - (bin_match / (len(seq1) + len(seq2)))
+
+
+def dotplot_tree(sequences, window=22, dotplot_view=False, output_dir=None, threads=1):
+    """
+    Construct a UPGMA tree based on dotplot-derived similarity between sequences.
+
+    Args:
+        sequences (list of SeqRecord): Input sequences.
+        window (int): Size of the sliding window for dotplot comparison.
+        dotplot_view (bool): Whether to render dotplots for each pair.
+        threads (int): Number of parallel worker processes for pairwise distance calculation.
+
+    Returns:
+        tuple: (Phylogenetic tree, Distance matrix)
+    """
+    def get_unique_filename(base_name, ext, max_digits=3):
+        """
+        Generate a unique filename by appending a numeric suffix if file exists.
+
+        Args:
+            base_name (str): Base filename without extension.
+            ext (str): File extension (e.g. 'tsv', 'newick').
+            max_digits (int): Number of digits for numbering.
+
+        Returns:
+            str: Unique filename with extension.
+        """
+        if not os.path.exists(f"{base_name}.{ext}"):
+            return f"{base_name}.{ext}"
+        i = 1
+        while True:
+            candidate = f"{base_name}{str(i).zfill(max_digits)}.{ext}"
+            if not os.path.exists(candidate):
+                return candidate
+            i += 1
+            
+    def dotplotxy_segments(x, y, x2, y2, segments, segments2, window, mask):
+        """
+        Visualize the dotplot and matching segments.
+
+        Args:
+            x, y, x2, y2 (list): Match coordinates.
+            segments, segments2 (list): Direct and reverse matching segments.
+            window (int): Window size.
+            mask (str): Binary mask used for filtering.
+        """
+        plt.scatter(x, y, color='black', marker='.', linewidths=0.05)
+        plt.scatter(x2, len(rec_two)-np.array(y2), color='gray', marker='.', linewidths=0.05)
+
+        for segment in segments:
+            x_segment = [point[0] for point in segment]
+            y_segment = [point[1] for point in segment]
+            plt.plot(x_segment, y_segment, color='red')
+
+        for segment in segments2:
+            x_segment = [point[0] for point in segment]
+            y_segment = [point[1] for point in segment]
+            plt.plot(x_segment, len(rec_two)-np.array(y_segment), color='#00FF00')
+
+        plt.xlabel("%s (length %i bp)" % (rec_one.id, len(rec_one)))
+        plt.ylabel("%s (length %i bp)" % (rec_two.id, len(rec_two)))
+        plt.grid(True)
+        plt.xlim(0, len(rec_one) - window)
+        plt.ylim(0, len(rec_two) - window)
+        plt.gca().set_aspect('equal', adjustable='box')
+        plt.tight_layout()
+        plt.savefig(get_unique_filename(os.path.join(output_dir, "dotplot"), "png"), dpi=150)
+        plt.close()
+
+    def dot_mat_distance(seq1, seq2, window, gap, dotplot):
+        """
+        Calculate dotplot-based distance between two sequences.
+
+        Args:
+            seq1, seq2 (SeqRecord): DNA sequences.
+            window (int): Size of sliding window.
+            gap (int): Gap threshold for segment merging.
+            dotplot (bool): Whether to visualize.
+
+        Returns:
+            float: Dotplot-based distance.
+        """
+        if window == 22:
+            mask = '1110101100110010101111'
+        else:
+            mask = '1110100110010101111'
+
+        seq2rc = seq2.seq.reverse_complement()
+        dict_one, dict_two, dict_two2 = {}, {}, {}
+
+        for seq, section_dict in [(seq1.seq.upper(), dict_one),
+                                  (seq2.seq.upper(), dict_two),
+                                  (seq2rc, dict_two2)]:
+            for i in range(len(seq) - window + 1):
+                section = _replace_with_mask(seq[i: i + window], mask)
+                section_dict.setdefault(section, []).append(i)
+
+        def get_match_coordinates(matches, dict_one, dict_two):
+            x, y = [], []
+            for section in matches:
+                for i in dict_one[section]:
+                    for j in dict_two[section]:
+                        x.append(i)
+                        y.append(j)
+            return x, y
+
+        matches = set(dict_one).intersection(dict_two)
+        matches2 = set(dict_one).intersection(dict_two2)
+        x, y = get_match_coordinates(matches, dict_one, dict_two)
+        x2, y2 = get_match_coordinates(matches2, dict_one, dict_two2)
+
+        segments_direct = _find_long_segments(
+            sorted(zip(x, y), key=lambda p: (p[1] - p[0], p[0])), window, gap)
+        segments_reverse = _find_long_segments(
+            sorted(zip(x2, y2), key=lambda p: (p[1] - p[0], p[0])), window, gap)
+
+        if dotplot:
+            dotplotxy_segments(x, y, x2, y2, segments_direct, segments_reverse, window, mask)
+
+        bin_dir1 = np.zeros(len(seq1), dtype=int)
+        bin_dir2 = np.zeros(len(seq2), dtype=int)
+        bin_rev1 = np.zeros(len(seq1), dtype=int)
+        bin_rev2 = np.zeros(len(seq2), dtype=int)
+
+        for segment in segments_direct:
+            bin_dir1[segment[0][0]:segment[-1][0]+window] = 1
+            bin_dir2[segment[0][1]:segment[-1][1]+window] = 1
+
+        for segment in segments_reverse:
+            bin_rev1[segment[0][0]:segment[-1][0]+window] = 1
+            bin_rev2[segment[0][1]:segment[-1][1]+window] = 1
+
+        bin_rrev2 = bin_rev2[::-1]
+        merged_bin1 = np.logical_or(bin_dir1, bin_rev1).astype(int)
+        merged_bin2 = np.logical_or(bin_dir2, bin_rrev2).astype(int)
+
+        bin_match = np.sum(merged_bin1) + np.sum(merged_bin2)
+        bin_dist = 1 - (bin_match / (len(seq1) + len(seq2)))
+        return bin_dist
+
+    gap = 2 * window
+    names = [s.id for s in sequences]
+    dist_mat = DistanceMatrix(names)
+    n = len(sequences)
+    total_pairs = n * (n - 1) // 2
+    done_pairs = 0
+    progress_step = max(1, math.ceil(total_pairs / 100)) if total_pairs else 1
+
+    if threads < 1:
+        raise ValueError("threads must be >= 1")
+
+    if dotplot_view and len(sequences) > 20:
+        dotplot_view = False
+        print("Too many sequences. Dot plot rendering has been disabled. Maximum 20 sequences.")
+
+    if threads > 1 and dotplot_view:
+        dotplot_view = False
+        print("Dot plot rendering has been disabled for parallel execution (threads > 1).")
+
+    if total_pairs:
+        print(f"Dotplot progress: 0/{total_pairs} pairs", flush=True)
+
+    if threads == 1:
+        for i, rec_one in enumerate(sequences):
+            for j in range(i + 1, len(sequences)):
+                rec_two = sequences[j]
+                dist_mat[i, j] = dot_mat_distance(rec_one, rec_two, window, gap, dotplot_view)
+                done_pairs += 1
+                if done_pairs % progress_step == 0 or done_pairs == total_pairs:
+                    print(f"Dotplot progress: {done_pairs}/{total_pairs} pairs", flush=True)
+    else:
+        future_to_pair = {}
+        with ProcessPoolExecutor(max_workers=threads) as executor:
+            for i, rec_one in enumerate(sequences):
+                for j in range(i + 1, len(sequences)):
+                    rec_two = sequences[j]
+                    future = executor.submit(_dot_mat_distance_core, str(rec_one.seq), str(rec_two.seq), window, gap)
+                    future_to_pair[future] = (i, j)
+
+            for future in as_completed(future_to_pair):
+                i, j = future_to_pair[future]
+                dist_mat[i, j] = future.result()
+                done_pairs += 1
+                if done_pairs % progress_step == 0 or done_pairs == total_pairs:
+                    print(f"Dotplot progress: {done_pairs}/{total_pairs} pairs", flush=True)
+
+    constructor = DistanceTreeConstructor()
+    tree = constructor.upgma(dist_mat)
+    return tree, dist_mat

plastree/kmertree.py

@@ -0,0 +1,174 @@
+# kmertree.py
+# Tree construction based on ranked k-mer frequencies
+
+from itertools import product, combinations
+from Bio.Phylo.TreeConstruction import DistanceMatrix, DistanceTreeConstructor
+import numpy as np
+import math
+
+def kmer_tree(sequences):
+    """
+    Constructs a phylogenetic tree based on ranked k-mer frequency profiles
+    averaged across multiple k-mer lengths (3 to 8).
+
+    Args:
+        sequences (list): List of Bio.SeqRecord objects representing the plasmid sequences.
+
+    Returns:
+        tuple: A tuple (tree, distance_matrix), where tree is a UPGMA phylogenetic tree,
+               and distance_matrix is a Bio.Phylo DistanceMatrix object.
+    """
+
+    def generate_kmers(k):
+        """
+        Generate all possible k-mers of length k composed of A, C, G, T.
+
+        Args:
+            k (int): Length of the k-mers.
+
+        Returns:
+            list: All possible k-mers of given length.
+        """
+        nucleotides = ['A', 'C', 'G', 'T']
+        kmers = [''.join(p) for p in product(nucleotides, repeat=k)]
+        return kmers
+
+    def count_kmers(k, seq, kmers):
+        """
+        Count k-mer occurrences in a sequence and rank them by frequency.
+
+        Args:
+            k (int): Length of the k-mers.
+            seq (str): Nucleotide sequence.
+            kmers (list): Ordered list of all valid k-mers.
+
+        Returns:
+            list: Normalized rank values for each k-mer in original order.
+        """
+        kmer_counts = {kmer: 0 for kmer in kmers}
+        seq_len = len(seq)
+        for i in range(seq_len - k + 1):
+            kmer = seq[i: i + k]
+            if kmer in kmer_counts:
+                kmer_counts[kmer] += 1
+
+        sorted_kmer_counts = sorted(kmer_counts.items(), key=lambda item: item[1], reverse=True)
+        ranks = {}
+        current_rank = 1
+        previous_count = None
+
+        for kmer, count in sorted_kmer_counts:
+            if count != previous_count:
+                ranks[kmer] = current_rank
+                current_rank += 1
+            else:
+                ranks[kmer] = current_rank - 1
+            previous_count = count
+
+        num_kmers = len(kmers)
+        normalized_ranks = {kmer: rank / num_kmers for kmer, rank in ranks.items()}
+        output_ranks = [normalized_ranks[kmer] for kmer in kmers]
+        return output_ranks
+
+    def compute_all_kmer_ranks(sequences, k):
+        """
+        Compute normalized k-mer frequency ranks for all sequences.
+
+        Args:
+            sequences (list): List of Bio.SeqRecord objects.
+            k (int): Length of k-mers.
+        Returns:
+            dict: Mapping from sequence ID to rank vector.
+        """
+        kmers = generate_kmers(k)
+        kmer_ranks = {}
+        total = len(sequences)
+        step = max(1, math.ceil(total / 20)) if total else 1
+        for idx, seq in enumerate(sequences, start=1):
+            kmer_ranks[seq.id] = count_kmers(k, str(seq.seq) + str(seq.seq.reverse_complement()), kmers)
+            if idx % step == 0 or idx == total:
+                print(f"K-mer ranks (k={k}): {idx}/{total} sequences", flush=True)
+        return kmer_ranks
+
+    def pairwise_distance(ranks1, ranks2):
+        """
+        Compute Euclidean distance between two k-mer rank vectors.
+
+        Args:
+            ranks1 (list): Rank vector of first sequence.
+            ranks2 (list): Rank vector of second sequence.
+
+        Returns:
+            float: Euclidean distance.
+        """
+        return sum((r1 - r2) ** 2 for r1, r2 in zip(ranks1, ranks2)) ** 0.5
+
+    def distance_matrix(sequences, k):
+        """
+        Construct a distance matrix using k-mer rank vectors.
+
+        Args:
+            sequences (list): List of Bio.SeqRecord objects.
+            k (int): Length of k-mers.
+
+        Returns:
+            DistanceMatrix: Lower triangular distance matrix.
+        """
+        names = [s.id for s in sequences]
+        matrix = DistanceMatrix(names)
+        kmer_ranks = compute_all_kmer_ranks(sequences, k)
+        total_pairs = len(names) * (len(names) - 1) // 2
+        done_pairs = 0
+        step = max(1, math.ceil(total_pairs / 100)) if total_pairs else 1
+        if total_pairs:
+            print(f"K-mer distance (k={k}): 0/{total_pairs} pairs", flush=True)
+        for (tax1, tax2) in combinations(names, 2):
+            matrix[tax1, tax2] = pairwise_distance(kmer_ranks[tax1], kmer_ranks[tax2])
+            done_pairs += 1
+            if done_pairs % step == 0 or done_pairs == total_pairs:
+                print(f"K-mer distance (k={k}): {done_pairs}/{total_pairs} pairs", flush=True)
+        return matrix
+
+    def distance_matrix_to_full(dm):
+        """
+        Convert a Bio.Phylo DistanceMatrix to a symmetric NumPy matrix.
+
+        Args:
+            dm (DistanceMatrix): Input distance matrix.
+
+        Returns:
+            np.ndarray: Symmetric matrix of distances.
+        """
+        full = np.zeros((n, n))
+        for i in range(n):
+            for j in range(i):
+                dist = dm[i, j]
+                full[i][j] = dist
+                full[j][i] = dist
+        return full
+
+    normalized_matrices = []
+    names = [s.id for s in sequences]
+    n = len(names)
+
+    # Compute distance matrices for k from 3 to 8 and normalize them
+    for k in range(3, 9):
+        print(f"K-mer progress: starting k={k}", flush=True)
+        dm = distance_matrix(sequences, k)
+        full_matrix = distance_matrix_to_full(dm)
+        max_val = np.max(full_matrix)
+        normalized = full_matrix / max_val if max_val != 0 else full_matrix
+        normalized_matrices.append(normalized)
+        print(f"K-mer progress: finished k={k}", flush=True)
+
+    # Average the normalized matrices
+    average_matrix = np.mean(normalized_matrices, axis=0)
+    lower_triangle = [
+        [average_matrix[i][j] for j in range(i)] + [0]
+        for i in range(n)
+    ]
+
+    dist_mat = DistanceMatrix(names, lower_triangle)
+    constructor = DistanceTreeConstructor()
+    tree = constructor.upgma(dist_mat)
+    return tree, dist_mat

plastree/pangtree.py

@@ -0,0 +1,108 @@
+# pangtree.py
+# Tree construction based on binary pangenome presence/absence matrix
+# Input is a CSV file in Roary or Panaroo output format
+
+import pandas as pd
+from Bio.Phylo.TreeConstruction import DistanceTreeConstructor, DistanceMatrix
+from scipy.spatial.distance import hamming
+import math
+
+def pang_tree(input_file, expected_samples=None, expected_format=None):
+    """
+    Construct a UPGMA tree from pangenome presence/absence matrix.
+
+    This function reads a pangenome CSV file (Roary or Panaroo format),
+    extracts the binary matrix of gene presence across samples, calculates pairwise
+    Hamming distances between samples, and builds a UPGMA phylogenetic tree.
+
+    Args:
+        input_file (str): Path to pangenome CSV (Roary 'gene_presence_absence_roary.csv' 
+                          or Panaroo 'gene_presence_absence.csv').
+        expected_samples (list[str] | None): Optional ordered list of sample names
+            expected in output (typically FASTA IDs). Missing samples are added
+            as all-zero columns.
+
+    Returns:
+        tuple: (Bio.Phylo.BaseTree.Tree, DistanceMatrix)
+            - The UPGMA phylogenetic tree.
+            - The corresponding distance matrix.
+    """
+    # Load the CSV file
+    csv_file = pd.read_csv(input_file, low_memory=False)
+
+    # Identify format (Roary vs Panaroo) and find presence/absence start
+    if 'Avg group size nuc' in csv_file.columns:
+        # Roary format: find 'Avg group size nuc' and start after it
+        presence_start_idx = csv_file.columns.get_loc('Avg group size nuc') + 1
+        actual_format = 'roary'
+    elif 'Annotation' in csv_file.columns:
+        # Panaroo format: find 'Annotation' and start after it
+        presence_start_idx = csv_file.columns.get_loc('Annotation') + 1
+        actual_format = 'panaroo'
+    else:
+        raise ValueError("Could not determine pangenome format. Neither 'Avg group size nuc' (Roary) nor 'Annotation' (Panaroo) column found.")
+
+    if expected_format is not None and expected_format != actual_format:
+        raise ValueError(
+            f"Pangenome format mismatch: expected '{expected_format}' but the CSV looks like '{actual_format}'."
+        )
+
+    # Extract presence/absence matrix: columns after the metadata section
+    df = csv_file.iloc[:, presence_start_idx:]
+
+    # Convert all non-empty cells (presence) to 1, and missing values (absence) to 0
+    df = df.notna().astype(int)
+
+    if expected_samples is not None:
+        # Map Roary columns like "sample_bakta" back to FASTA IDs when possible.
+        renamed_columns = {}
+        for col in df.columns:
+            if col.endswith("_bakta"):
+                base = col[:-6]
+                if base in expected_samples:
+                    renamed_columns[col] = base
+        if renamed_columns:
+            df = df.rename(columns=renamed_columns)
+
+        # Add missing expected samples as all-zero presence/absence columns.
+        missing_samples = [name for name in expected_samples if name not in df.columns]
+        for name in missing_samples:
+            df[name] = 0
+
+        # Keep only expected samples and in FASTA order for cross-method consistency.
+        df = df[[name for name in expected_samples]]
+
+    # Extract sample names
+    names = df.columns.tolist()
+    total_pairs = len(names) * (len(names) - 1) // 2
+    done_pairs = 0
+    progress_step = max(1, math.ceil(total_pairs / 100)) if total_pairs else 1
+
+    if total_pairs:
+        print(f"Pang progress: 0/{total_pairs} pairs", flush=True)
+
+    # Compute lower-triangular Hamming distance matrix
+    matrix = []
+    for i in range(len(names)):
+        row = []
+        for j in range(i):
+            vec1 = df[names[i]].values
+            vec2 = df[names[j]].values
+            dist = hamming(vec1, vec2)
+            row.append(dist)
+            done_pairs += 1
+            if done_pairs % progress_step == 0 or done_pairs == total_pairs:
+                print(f"Pang progress: {done_pairs}/{total_pairs} pairs", flush=True)
+        matrix.append(row)
+
+    # Add diagonal (0s)
+    lower_triangle = [
+        [matrix[i][j] for j in range(i)] + [0]  # Diagonal value = 0
+        for i in range(len(names))
+    ]
+
+    # Build and return the tree
+    dist_mat = DistanceMatrix(names, lower_triangle)
+    constructor = DistanceTreeConstructor()
+    tree = constructor.upgma(dist_mat)
+    return tree, dist_mat

plastree/plasmid_tree_tool.py

@@ -0,0 +1,263 @@
+# plasmid_tree_tool.py
+# Unified script to compute plasmid phylogenetic trees using dotplot, k-mer, and pangenome presence/absence methods
+# Generates individual and consensus trees and identifies clusters
+
+import os
+import argparse
+import matplotlib
+matplotlib.use('Agg')  # Use non-interactive backend for headless environments
+import matplotlib.pyplot as plt
+import pandas as pd
+from Bio import SeqIO, Phylo
+from Bio.Phylo.TreeConstruction import DistanceMatrix
+from Bio.Phylo.Consensus import majority_consensus
+from .dotplotree import dotplot_tree
+from .pangtree import pang_tree
+from .kmertree import kmer_tree
+
+def get_unique_filename(base_name, ext, max_digits=2):
+    """
+    Generate a unique filename by appending a numeric suffix if file exists.
+
+    Args:
+        base_name (str): Base filename without extension.
+        ext (str): File extension (e.g. 'tsv', 'newick').
+        max_digits (int): Number of digits for numbering.
+
+    Returns:
+        str: Unique filename with extension.
+    """
+    if not os.path.exists(f"{base_name}.{ext}"):
+        return f"{base_name}.{ext}"
+    i = 1
+    while True:
+        candidate = f"{base_name}{str(i).zfill(max_digits)}.{ext}"
+        if not os.path.exists(candidate):
+            return candidate
+        i += 1
+
+def get_sequences(fasta_path):
+    """
+    Load sequences from FASTA file.
+
+    Args:
+        fasta_path (str): Path to FASTA file.
+
+    Returns:
+        list: List of SeqRecord objects.
+    """
+    return list(SeqIO.parse(fasta_path, "fasta"))
+
+def save_tree(tree, filename):
+    """
+    Save phylogenetic tree to Newick file.
+
+    Args:
+        tree (Tree): Bio.Phylo tree object.
+        filename (str): Path to output file.
+    """
+    Phylo.write(tree, filename, "newick")
+
+def save_distance_matrix(dist_mat, filename):
+    """
+    Save distance matrix to TSV file.
+
+    Args:
+        dist_mat (DistanceMatrix): Bio.Phylo DistanceMatrix object.
+        filename (str): Path to output file.
+    """
+    with open(filename, "w") as f:
+        f.write("\t" + "\t".join(dist_mat.names) + "\n")
+        for i, row_name in enumerate(dist_mat.names):
+            row = [str(dist_mat[i, j]) if j < i else "" for j in range(len(dist_mat.names))]
+            f.write(row_name + "\t" + "\t".join(row) + "\n")
+
+def largest_distant_nodes_with_table(tree, max_branches_in_cluster=None, max_branch_length=0.2):
+    """
+    Identify and group most distinct clusters from a tree.
+
+    Args:
+        tree (Tree): Bio.Phylo tree object.
+        max_branches_in_cluster (int): Max OTUs per cluster.
+        max_branch_length (float): Maximum allowed branch length within a cluster (0–1). None disables the check.
+
+    Returns:
+        tuple: (DataFrame with cluster IDs, list of cluster OTUs)
+    """
+    def get_sorted_branches(tree):
+        branches = []
+        for node in tree.get_nonterminals():
+            branch = [leaf.name for leaf in node.get_terminals()]
+            branch.sort()
+            branches.append(branch)
+        return set(tuple(branch) for branch in branches)
+
+    def max_branch_length_in_cluster(tree, cluster):
+        leaves = set(cluster)
+        for clade in tree.get_nonterminals(order="preorder"):
+            if {leaf.name for leaf in clade.get_terminals()} == leaves:
+                branches = [c.branch_length for c in clade.find_clades() if c.branch_length and c is not clade]
+                return max(branches) if branches else 0.0
+        return 0.0
+
+    branches_t1 = get_sorted_branches(tree)
+    total_branches = len(branches_t1) + 1
+
+    if max_branches_in_cluster is None:
+        max_branches_in_cluster = total_branches // 2
+
+    sorted_clusters = sorted(branches_t1, key=len, reverse=True)
+    selected_clusters = []
+    selected_branches = set()
+    cluster_to_branch_map = {}
+    cluster_id = 1
+
+    for cluster in sorted_clusters:
+        if (
+            len(cluster) <= max_branches_in_cluster
+            and not selected_branches.intersection(cluster)
+            and (max_branch_length is None or max_branch_length_in_cluster(tree, cluster) <= max_branch_length)
+        ):
+            selected_clusters.append(cluster)
+            selected_branches.update(cluster)
+            for branch in cluster:
+                cluster_to_branch_map[branch] = cluster_id
+            cluster_id += 1
+
+    all_branches = {branch for cluster in branches_t1 for branch in cluster}
+    unassigned_branches = all_branches - selected_branches
+    for branch in unassigned_branches:
+        cluster_to_branch_map[branch] = 0
+
+    table = [{"OTU": branch, "Cluster ID": cluster_to_branch_map[branch]} for branch in all_branches]
+    df = pd.DataFrame(table).sort_values(by="Cluster ID")
+    return df, list(selected_clusters)
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Plasmid Tree Tool: Build phylogenetic trees from plasmid sequences using dotplot, pangenome, and k-mer methods."
+    )
+    parser.add_argument("--fasta", required=True, help="Path to input FASTA file with plasmid sequences.")
+    parser.add_argument("--pang_format", choices=["roary", "panaroo"], default=None, help="Format expected in the pangenome CSV: 'roary' or 'panaroo'. Required when using --methods pang.")
+    parser.add_argument("--pang_csv", default=None, help="Path to the pangenome presence/absence CSV file. Required when using --methods pang.")
+    parser.add_argument("--methods", nargs="*", choices=["dotplot", "pang", "kmer"], default=["dotplot"], help="Tree construction methods to apply. Default: dotplot only.")
+    parser.add_argument("--outdir", default="output", help="Directory to store output files. Default: /output.")
+    parser.add_argument("--max_cluster_size", type=int, default=None, help="Maximum OTUs per cluster in consensus tree. Default: 1/2 number of sequences.")
+    parser.add_argument("--max_branch_length", type=float, nargs="+", default=[0.2], help="Maximum allowed branch length(s) within a cluster (0–1). Accepts one or more values (e.g. --max_branch_length 0.1 0.2 0.05); one plasmid_clusters TSV is produced per value. Default: 0.2.")
+    parser.add_argument("--dotplot_window", type=int, default=22, help="Size of the sliding window for dotplot comparison. Supported values: 19 or 22. Default: 22.")
+    parser.add_argument("--dotplot_threads", type=int, default=1, help="Number of parallel worker processes for dotplot pairwise distance computation. Default: 1.")
+    parser.add_argument("--dotplot_png", action='store_true', help="Save dotplots for all pairwise comparisons as PNGs. Only for ≤20 sequences. Default: off.")
+    parser.add_argument("--result_tree_png", action='store_true', help="Save consensus/result tree as PNG with node support and cluster coloring. Default: off.")
+    args = parser.parse_args()
+
+    if "pang" in args.methods:
+        if args.pang_format is None:
+            parser.error("When using --methods pang, you must specify --pang_format (roary or panaroo).")
+        if args.pang_csv is None:
+            parser.error("When using --methods pang, you must specify --pang_csv.")
+        if not os.path.exists(args.pang_csv):
+            parser.error(f"Pangenome file not found: {args.pang_csv}.")
+
+    if args.dotplot_window not in (19, 22):
+        parser.error("Unsupported value for --dotplot_window. Use 19 or 22.")
+
+    if args.dotplot_threads < 1:
+        parser.error("Unsupported value for --dotplot_threads. Use an integer >= 1.")
+
+    os.makedirs(args.outdir, exist_ok=True)
+    sequences = get_sequences(args.fasta)
+    trees = []
+
+    def color_cluster_tree(tree, common_clusters, filename_suffix=None):
+        """
+        Render and save tree with colored clusters.
+
+        Args:
+            tree (Tree): Bio.Phylo tree object.
+            common_clusters (list): List of clusters (lists of OTU names).
+            filename_suffix (str): Optional suffix to distinguish output files (e.g. per max_branch_length value).
+        """
+        # colors = ["#FF0000", "#0000FF", "#00FF00", "#800080", "#008080", "#FFA500", "#00FF85", "#FF00A5"]
+        colors = ["#FF0000", "#0000FF", "#00FF00", "#800080", "#008080", "#FFA500", "#00FF85", "#FF00A5", "#A52A2A", "#FFFF00", "#00CED1", "#FF1493", "#7FFF00", "#DC143C", "#000080", "#FFD700", "#20B2AA", "#C71585", "#ADFF2F", "#FF6347", "#1E90FF", "#B22222", "#DA70D6", "#5F9EA0", "#40E0D0", "#FF4500", "#9ACD32", "#BA55D3", "#3CB371", "#8B4513"]
+        for i, cluster in enumerate(common_clusters):
+            if len(cluster) > 1:
+                nodes = [{"name": name} for name in cluster]
+                mrca = tree.common_ancestor(*nodes)
+                mrca.color = colors[i % len(colors)]
+        import warnings
+        warnings.filterwarnings("ignore", category=UserWarning, module="Bio.Phylo._utils")
+        num_leaves = tree.count_terminals()
+        fig_height = max(15, num_leaves * 0.25)
+        fig_width = max(10, num_leaves * 0.06)
+        fig = plt.figure(figsize=(fig_width, fig_height))
+        axes = fig.add_subplot(1, 1, 1)
+        Phylo.draw(tree, axes=axes, branch_labels=lambda c: "{:.2f}".format(c.confidence) if c.confidence else '')
+        # Save to PNG instead of showing
+        plt.tight_layout()
+        base_name = "cluster_tree" if filename_suffix is None else f"cluster_tree_{filename_suffix}"
+        plt.savefig(get_unique_filename(os.path.join(args.outdir, base_name), "png"), dpi=300)
+        plt.close()
+
+    # DOTPLOT METHOD
+    if "dotplot" in args.methods:
+        print("Running dotplot method...")
+        dotmat_tree, dotmat_dist = dotplot_tree(sequences, args.dotplot_window, args.dotplot_png, args.outdir, args.dotplot_threads)
+        trees.append(dotmat_tree)
+        save_tree(dotmat_tree, get_unique_filename(os.path.join(args.outdir, "dotplot_tree"), "newick"))
+        save_distance_matrix(dotmat_dist, get_unique_filename(os.path.join(args.outdir, "dotplot_distmat"), "tsv"))
+
+    # PANGTREE METHOD
+    if "pang" in args.methods:
+        if args.pang_csv:
+            print("Running pangenome binary method...")
+            pang_tree_result, pang_dist = pang_tree(args.pang_csv, expected_samples=[s.id for s in sequences], expected_format=args.pang_format)
+            trees.append(pang_tree_result)
+            if 'dotmat_tree' in locals() and dotmat_tree is not None:
+                trees.append(dotmat_tree)
+            save_tree(pang_tree_result, get_unique_filename(os.path.join(args.outdir, "pang_tree"), "newick"))
+            save_distance_matrix(pang_dist, get_unique_filename(os.path.join(args.outdir, "pang_distmat"), "tsv"))
+        else:
+            print("Warning: Method 'pang' was selected but no --pang_csv provided. Skipping pangtree method.")
+
+    # K-MER METHOD
+    if "kmer" in args.methods:
+        print("Running k-mer method...")
+        kmer_result_tree, kmer_dist = kmer_tree(sequences)
+        trees.append(kmer_result_tree)
+        if 'dotmat_tree' in locals() and dotmat_tree is not None:
+            trees.append(dotmat_tree)
+        if 'pang_tree_result' in locals() and pang_tree_result is not None:
+            trees.append(pang_tree_result)
+        save_tree(kmer_result_tree, get_unique_filename(os.path.join(args.outdir, "kmer_tree"), "newick"))
+        save_distance_matrix(kmer_dist, get_unique_filename(os.path.join(args.outdir, "kmer_distmat"), "tsv"))
+
+    # CONSENSUS TREE
+    if len(trees) > 1:
+        print("Computing consensus tree...")
+        result_tree = majority_consensus(trees)
+        save_tree(result_tree, get_unique_filename(os.path.join(args.outdir, "consensus_tree"), "newick"))
+        print("Consensus tree:")
+    else:
+        print("Only one method used — consensus tree not computed.")
+        print(", ".join(args.methods) + " tree:")
+        result_tree = trees[0]
+
+    Phylo.draw_ascii(result_tree)
+
+    # CLUSTERING + SAVE
+    multiple_thresholds = len(args.max_branch_length) > 1
+    for max_branch_length in args.max_branch_length:
+        cluster_table, clusters = largest_distant_nodes_with_table(result_tree, args.max_cluster_size, max_branch_length)
+        if multiple_thresholds:
+            suffix = str(max_branch_length).replace(".", "_")
+            base_name = f"plasmid_clusters_bl{suffix}"
+        else:
+            suffix = None
+            base_name = "plasmid_clusters"
+        cluster_table.to_csv(get_unique_filename(os.path.join(args.outdir, base_name), "tsv"), sep="\t", index=False)
+
+        if args.result_tree_png:
+            color_cluster_tree(result_tree, clusters, filename_suffix=suffix)
+
+if __name__ == "__main__":
+    main()

plastree-0.1.0.dist-info/METADATA

@@ -0,0 +1,196 @@
+Metadata-Version: 2.4
+Name: plastree
+Version: 0.1.0
+Summary: Build plasmid phylogenetic trees from dotplot, pangenome presence/absence, and k-mer methods, with cluster detection.
+Author: Helena Vitkova, Matej Bezdicek, Ema Holubova, Martina Lengerova
+Author-email: Marketa Jakubickova <jakubickova@vut.cz>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/BioSys-BUT/PlasTree
+Project-URL: Repository, https://github.com/BioSys-BUT/PlasTree
+Project-URL: Issues, https://github.com/BioSys-BUT/PlasTree/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: biopython==1.87
+Requires-Dist: numpy==2.4.6
+Requires-Dist: pandas==2.3.3
+Requires-Dist: scipy==1.17.1
+Requires-Dist: matplotlib==3.10.9
+Dynamic: license-file
+
+# PlasTree
+
+A tree-based pipeline for clustering complete bacterial plasmids from long-read assemblies, combining structural, k-mer, and gene-content similarity into a single weighted consensus tree.
+
+![PlasTree overview](plastree_overview.png "PlasTree pipeline and an example consensus tree with color-coded clusters")
+
+## Overview
+
+PlasTree integrates three complementary similarity methods, DotPloTree (pairwise dotplot-based structural similarity), KmerTree (ranked k-mer frequency similarity), and PanGTree (pangenome presence/absence similarity), and combines them into a single weighted consensus tree. Plasmids are then automatically grouped into clusters based on branch length and cluster size thresholds. PlasTree is intended for complete plasmid assemblies from long-read sequencing (e.g. Oxford Nanopore Technologies), where rearrangements, recombination, and accessory gene turnover can obscure relationships found by a single similarity measure.
+
+## Content
+
+- [Key Features](#key-features)
+- [Requirements](#requirements)
+- [Installation](#installation)
+- [Usage](#usage)
+  - [Parameters](#parameters)
+  - [Example](#example)
+  - [Output](#output)
+- [Generating pangenome input (Bakta + Roary/Panaroo)](#generating-pangenome-input-bakta--roarypanaroo)
+- [License](#license)
+- [Citation](#citation)
+- [Contact](#contact)
+
+## Key Features
+
+- **Three independent tree-building methods**: DotPloTree (structural), KmerTree (nucleotide composition), and PanGTree (gene content, Roary or Panaroo format)
+- **Weighted consensus tree** (3:2:1 DotPloTree:PanGTree:KmerTree) when two or more methods are combined
+- **Automatic clustering** of plasmids by branch length, with support for multiple thresholds computed in a single run
+- **Installable as a standard Python package**, exposing a single `plastree` command
+- Optional PNG rendering of pairwise dotplots and the final cluster-colored consensus tree
+
+## Requirements
+
+- Python 3.10+
+- All other dependencies (Biopython, NumPy, Pandas, SciPy, Matplotlib) are installed automatically with the package.
+
+## Installation
+
+First create an isolated environment named `plastree` (pick one option below), then install PlasTree into it.
+
+**Option A: venv**
+```bash
+python3 -m venv plastree
+source plastree/bin/activate
+pip install --upgrade pip
+```
+
+**Option B: conda / miniforge**
+```bash
+conda create -n plastree python=3.12
+conda activate plastree
+```
+
+With the environment active, install PlasTree directly from GitHub:
+```bash
+pip install git+https://github.com/BioSys-BUT/PlasTree.git
+```
+
+Or, if you want a local copy of the source:
+```bash
+git clone https://github.com/BioSys-BUT/PlasTree.git
+cd PlasTree
+pip install .
+```
+
+Verify the install:
+```bash
+plastree --help
+```
+
+## Usage
+
+```bash
+plastree --fasta <fasta_path> [--pang_format {roary,panaroo}] [--pang_csv <csv_path>] [--methods dotplot kmer pang] [--outdir <out_dir>] [--max_cluster_size <int>] [--max_branch_length <float> [<float> ...]] [--dotplot_window {19,22}] [--dotplot_threads <int>] [--dotplot_png] [--result_tree_png]
+```
+
+### Parameters
+
+- `--fasta`: Path to a single FASTA file containing all plasmid sequences (one record per plasmid). **Required.**
+- `--pang_format {roary,panaroo}`: Format of the pangenome CSV. Required when using `--methods pang`.
+- `--pang_csv`: Path to the pangenome presence/absence CSV file. Required when using `--methods pang`.
+- `--methods [dotplot pang kmer ...]`: Tree construction methods to apply. Default: `dotplot` only.
+- `--outdir`: Directory to store output files. Default: `output`.
+- `--max_cluster_size`: Maximum OTUs (plasmids) per cluster. Default: half the number of input sequences.
+- `--max_branch_length`: Maximum allowed branch length within a cluster (0-1). Accepts one or more values (e.g. `0.1 0.2 0.05`); one cluster-assignment table is produced per value. Default: `0.2`.
+- `--dotplot_window {19,22}`: Sliding window size for dotplot comparison. Default: `22`.
+- `--dotplot_threads`: Number of parallel worker processes for dotplot pairwise distance computation. Default: `1`.
+- `--dotplot_png`: Save pairwise dotplots as PNGs. Only for <=20 sequences. Default: off.
+- `--result_tree_png`: Save the consensus tree as a PNG with node support and cluster coloring. Default: off.
+
+### Example
+
+```bash
+plastree \
+  --fasta sequences.fasta \
+  --methods dotplot kmer pang \
+  --pang_format panaroo \
+  --pang_csv gene_presence_absence.csv \
+  --dotplot_window 22 \
+  --dotplot_threads 8 \
+  --max_cluster_size 30 \
+  --max_branch_length 0.05 0.1 0.2 0.4 \
+  --result_tree_png \
+  --outdir output
+```
+
+with example data (8 small real plasmids from *Enterococcus faecium*, included in [`examples/`](examples)):
+```bash
+plastree \
+  --fasta examples/plasmids.fasta \
+  --methods dotplot kmer pang \
+  --pang_format panaroo \
+  --pang_csv examples/gene_presence_absence.csv \
+  --result_tree_png \
+  --outdir examples/output
+```
+
+### Output
+
+All output files are written to `--outdir`.
+
+| File | Description |
+|---|---|
+| `dotplot_tree.newick` | DotPloTree structural similarity tree (`--methods dotplot`) |
+| `dotplot_distmat.tsv` | DotPloTree distance matrix |
+| `kmer_tree.newick` | KmerTree nucleotide composition tree (`--methods kmer`) |
+| `kmer_distmat.tsv` | KmerTree distance matrix |
+| `pang_tree.newick` | PanGTree gene content tree (`--methods pang`) |
+| `pang_distmat.tsv` | PanGTree distance matrix |
+| `consensus_tree.newick` | weighted consensus tree (only when 2+ methods are used) |
+| `plasmid_clusters.tsv` | cluster assignment per plasmid (cluster 0 = outlier) |
+| `cluster_tree.png` | consensus tree rendered with clusters color-coded (only with `--result_tree_png`) |
+
+If multiple `--max_branch_length` values are given, `plasmid_clusters.tsv` and `cluster_tree.png` are produced once per threshold, suffixed with the value (dots replaced by underscores), e.g. `plasmid_clusters_bl0_2.tsv` and `cluster_tree_0_2.png` for threshold `0.2`.
+
+## Generating pangenome input (Bakta + Roary/Panaroo)
+
+The `--pang_csv` file used by `--methods pang` is not produced by PlasTree itself. It comes from annotating the same plasmid FASTA files and clustering the predicted genes into orthologous groups, using external tools:
+
+1. Annotate each plasmid with [Bakta](https://github.com/oschwengers/bakta) (or another tool that outputs GFF3 annotations), producing one GFF3 file per plasmid.
+2. Collect all resulting GFF3 files into one directory.
+3. Run [Roary](https://sanger-pathogens.github.io/Roary/) and/or [Panaroo](https://github.com/gtonkinhill/panaroo) on the collected GFF3 files:
+```bash
+roary *.gff3 -f roary_out
+```
+```bash
+panaroo -i *.gff3 -o panaroo_out
+```
+
+Both produce a `gene_presence_absence.csv`. Pass this file as `--pang_csv`, together with the matching `--pang_format roary` or `--pang_format panaroo`. See each tool's own documentation for annotation database setup, threading, and other options. Bakta, Roary, and Panaroo have their own, sometimes conflicting, dependencies, so it is common to install them into separate environments (e.g. separate conda environments).
+
+## License
+
+See [LICENSE](LICENSE) for details (MIT).
+
+## Citation
+
+The manuscript describing PlasTree is currently in submission. Until it is published, if you use PlasTree in your research, please cite this repository:
+
+```bibtex
+@software{plastree2026,
+  title={PlasTree},
+  author={Vitkova, Helena and Jakubickova, Marketa and Bezdicek, Matej and Holubova, Ema and Lengerova, Martina},
+  year={2026},
+  url={https://github.com/BioSys-BUT/PlasTree}
+}
+```
+
+## Contact
+
+For questions and feedback, please open an issue on GitHub or contact us via email at [jakubickova@vut.cz](mailto:jakubickova@vut.cz).

plastree-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+plastree/__init__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+plastree/dotplotree.py,sha256=wDbfbcao-aiP7P0ZecPS1hH9_BTQrqOUU3trl8QMWbk,11879
+plastree/kmertree.py,sha256=JqneV2ZpAhoysLucpynLZKFampE9mfyHog2ZoPNslB8,6010
+plastree/pangtree.py,sha256=S-vDcneDzUKVQZwGHAVO2Y3vfzJqgAVnp8-XRj0YgeQ,4381
+plastree/plasmid_tree_tool.py,sha256=5gfqwIaDRLnfBF-hfbdi3kGevmz6J4iKGD4gfVqcEEw,12529
+plastree-0.1.0.dist-info/licenses/LICENSE,sha256=f-nJkRhjOdWF0SVNgtzYXZvBR2cwFHGN3L7MnjQa4-g,1067
+plastree-0.1.0.dist-info/METADATA,sha256=EkOf_f9j0SL5o1NhfHdAxE7QerZ0EDpIwcpbQ7vdOrQ,8683
+plastree-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+plastree-0.1.0.dist-info/entry_points.txt,sha256=EJsbiOY2O2-zU9w695xPtHIZKvALcxXgC4p0Q1FdL0E,61
+plastree-0.1.0.dist-info/top_level.txt,sha256=fAC2aiwSxp6sJTktiWTgVAuqQLc49xaGydfquBc3Pso,9
+plastree-0.1.0.dist-info/RECORD,,

plastree-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

plastree-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+plastree = plastree.plasmid_tree_tool:main

plastree-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 BioSys_BUT
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

plastree-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+plastree