genome-comparator 0.4.6__tar.gz

genome_comparator-0.4.6/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Marc-Olivier Duceppe
+
+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.

genome_comparator-0.4.6/PKG-INFO

@@ -0,0 +1,140 @@
+Metadata-Version: 2.4
+Name: genome-comparator
+Version: 0.4.6
+Summary: Fast genome comparison with Mash: distance matrix, UPGMA/NJ/ME trees with bootstrap support, and interactive PCoA
+Author-email: Marc-Olivier Duceppe <marc-olivier.duceppe@inspection.gc.ca>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/duceppemo/genome_comparator
+Project-URL: Documentation, https://github.com/duceppemo/genome_comparator/wiki
+Project-URL: Changelog, https://github.com/duceppemo/genome_comparator/wiki/Changelog
+Project-URL: Issues, https://github.com/duceppemo/genome_comparator/issues
+Project-URL: DOI, https://doi.org/10.5281/zenodo.22920856
+Keywords: bioinformatics,genomics,mash,minhash,phylogenetics,microbial genomics,pcoa
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24
+Requires-Dist: pandas>=2.0
+Requires-Dist: scipy>=1.10
+Requires-Dist: scikit-bio>=0.7
+Requires-Dist: plotly>=5.15
+Requires-Dist: openpyxl>=3.1
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+Requires-Dist: pytest-cov>=5; extra == "test"
+Dynamic: license-file
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/duceppemo/genome_comparator/master/assets/logo.png" width="180" alt="genome_comparator logo">
+</p>
+
+<h1 align="center">genome_comparator</h1>
+
+<p align="center">
+  <a href="https://github.com/duceppemo/genome_comparator/actions/workflows/tests.yml"><img src="https://github.com/duceppemo/genome_comparator/actions/workflows/tests.yml/badge.svg" alt="Tests"></a>
+  <a href="https://github.com/duceppemo/genome_comparator/releases/latest"><img src="https://img.shields.io/github/v/release/duceppemo/genome_comparator" alt="Release"></a>
+  <a href="https://pypi.org/project/genome-comparator/"><img src="https://img.shields.io/pypi/v/genome-comparator" alt="PyPI"></a>
+  <a href="https://codecov.io/gh/duceppemo/genome_comparator"><img src="https://codecov.io/gh/duceppemo/genome_comparator/graph/badge.svg" alt="Coverage"></a>
+  <img src="https://img.shields.io/badge/python-3.10%E2%80%933.14-blue" alt="Python 3.10–3.14">
+  <a href="LICENSE"><img src="https://img.shields.io/github/license/duceppemo/genome_comparator" alt="License"></a>
+  <a href="https://github.com/duceppemo/genome_comparator/wiki"><img src="https://img.shields.io/badge/docs-wiki-informational" alt="Documentation"></a>
+  <a href="https://doi.org/10.5281/zenodo.22920856"><img src="https://zenodo.org/badge/DOI/10.5281/zenodo.22920856.svg" alt="DOI"></a>
+</p>
+
+Quickly compare and visualize distances between genomes, from assemblies (fasta) or reads (fastq), using
+[Mash](https://github.com/marbl/Mash). Produces a distance matrix, trees (UPGMA, neighbour joining, minimum
+evolution) with optional bootstrap support, and an interactive PCoA plot.
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/duceppemo/genome_comparator/master/assets/tree.png" width="49%" alt="Neighbour joining tree of 22 Listeria genomes with bootstrap support values">
+  <img src="https://raw.githubusercontent.com/duceppemo/genome_comparator/master/assets/pcoa.png" width="49%" alt="PCoA of 22 Listeria genomes coloured by species">
+  <br>
+  <sub>22 public <i>Listeria</i> genomes from the <a href="https://github.com/duceppemo/genome_comparator/wiki/Tutorial">tutorial</a>: 3 seconds, or under 2 minutes with 100 bootstrap replicates.</sub>
+</p>
+
+## Features
+* **Assemblies or reads**: fasta or fastq (gzipped or not), paired-end reads combined per sample.
+* **Fast and scalable**: thousands of genomes; sketches are computed in parallel and reused between runs.
+* **Trees**: UPGMA, neighbour joining and minimum evolution, with optional **bootstrap support**.
+* **Interactive PCoA** with metadata on hover and colourblind-friendly colouring by any metadata column.
+* **Safe by default**: ambiguous sample names and unreadable files are reported, never silently merged or ignored.
+
+## How it works
+```mermaid
+flowchart LR
+    A[fasta / fastq files] -->|mash sketch| B[one sketch per sample]
+    B -->|mash triangle| C[pairwise distance matrix]
+    C --> D[UPGMA / NJ / ME trees]
+    C --> E[PCoA plot]
+    B -. re-sketch with other hash seeds .-> F[bootstrap replicates]
+    F -. support values .-> D
+```
+
+## Installation
+With pip. Mash is not available from PyPI: install it separately (e.g. `conda install -c bioconda mash`).
+```
+pip install genome-comparator
+```
+
+Or from source, in a conda environment that includes Mash:
+```
+git clone https://github.com/duceppemo/genome_comparator
+cd genome_comparator
+conda env create -f environment.yml
+conda activate genome_comparator
+pip install --no-deps .
+```
+
+## Quick start
+```
+genome-comparator -i /input/folder/ -o /output/folder/ --nj --pcoa
+```
+
+New to the tool? Follow the **[tutorial](https://github.com/duceppemo/genome_comparator/wiki/Tutorial)**: it downloads
+22 public genomes and walks through every output in a few minutes.
+
+## Documentation
+The **[wiki](https://github.com/duceppemo/genome_comparator/wiki)** covers
+[usage and options](https://github.com/duceppemo/genome_comparator/wiki/Usage),
+[output files](https://github.com/duceppemo/genome_comparator/wiki/Output-files),
+[interpreting the results](https://github.com/duceppemo/genome_comparator/wiki/How-it-works),
+[bootstrap support](https://github.com/duceppemo/genome_comparator/wiki/Bootstrap-support),
+[performance](https://github.com/duceppemo/genome_comparator/wiki/Performance),
+[related tools](https://github.com/duceppemo/genome_comparator/wiki/Related-tools),
+[troubleshooting](https://github.com/duceppemo/genome_comparator/wiki/Troubleshooting) and the
+[FAQ](https://github.com/duceppemo/genome_comparator/wiki/FAQ).
+
+## Citing
+If you use genome_comparator, please cite it and Mash, which computes the distances:
+
+> Duceppe M-O. genome_comparator: fast comparison and visualization of genome distances with Mash. Zenodo.
+> https://doi.org/10.5281/zenodo.22920856
+
+This DOI always points to the latest version; each release also has its own DOI, listed on
+[Zenodo](https://doi.org/10.5281/zenodo.22920856). GitHub's **"Cite this repository"** button gives the same citation
+in APA and BibTeX formats.
+
+
+> Ondov BD, Treangen TJ, Melsted P, Mallonee AB, Bergman NH, Koren S, Phillippy AM. Mash: fast genome and metagenome
+> distance estimation using MinHash. *Genome Biology* 17, 132 (2016). https://doi.org/10.1186/s13059-016-0997-x
+
+## Contributing
+Bug reports, questions and pull requests are welcome: see [CONTRIBUTING.md](CONTRIBUTING.md).
+
+## Author
+Marc-Olivier Duceppe, Canadian Food Inspection Agency (CFIA): marc-olivier.duceppe@inspection.gc.ca
+
+## License
+[MIT](LICENSE)

genome_comparator-0.4.6/README.md

@@ -0,0 +1,102 @@
+<p align="center">
+  <img src="https://raw.githubusercontent.com/duceppemo/genome_comparator/master/assets/logo.png" width="180" alt="genome_comparator logo">
+</p>
+
+<h1 align="center">genome_comparator</h1>
+
+<p align="center">
+  <a href="https://github.com/duceppemo/genome_comparator/actions/workflows/tests.yml"><img src="https://github.com/duceppemo/genome_comparator/actions/workflows/tests.yml/badge.svg" alt="Tests"></a>
+  <a href="https://github.com/duceppemo/genome_comparator/releases/latest"><img src="https://img.shields.io/github/v/release/duceppemo/genome_comparator" alt="Release"></a>
+  <a href="https://pypi.org/project/genome-comparator/"><img src="https://img.shields.io/pypi/v/genome-comparator" alt="PyPI"></a>
+  <a href="https://codecov.io/gh/duceppemo/genome_comparator"><img src="https://codecov.io/gh/duceppemo/genome_comparator/graph/badge.svg" alt="Coverage"></a>
+  <img src="https://img.shields.io/badge/python-3.10%E2%80%933.14-blue" alt="Python 3.10–3.14">
+  <a href="LICENSE"><img src="https://img.shields.io/github/license/duceppemo/genome_comparator" alt="License"></a>
+  <a href="https://github.com/duceppemo/genome_comparator/wiki"><img src="https://img.shields.io/badge/docs-wiki-informational" alt="Documentation"></a>
+  <a href="https://doi.org/10.5281/zenodo.22920856"><img src="https://zenodo.org/badge/DOI/10.5281/zenodo.22920856.svg" alt="DOI"></a>
+</p>
+
+Quickly compare and visualize distances between genomes, from assemblies (fasta) or reads (fastq), using
+[Mash](https://github.com/marbl/Mash). Produces a distance matrix, trees (UPGMA, neighbour joining, minimum
+evolution) with optional bootstrap support, and an interactive PCoA plot.
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/duceppemo/genome_comparator/master/assets/tree.png" width="49%" alt="Neighbour joining tree of 22 Listeria genomes with bootstrap support values">
+  <img src="https://raw.githubusercontent.com/duceppemo/genome_comparator/master/assets/pcoa.png" width="49%" alt="PCoA of 22 Listeria genomes coloured by species">
+  <br>
+  <sub>22 public <i>Listeria</i> genomes from the <a href="https://github.com/duceppemo/genome_comparator/wiki/Tutorial">tutorial</a>: 3 seconds, or under 2 minutes with 100 bootstrap replicates.</sub>
+</p>
+
+## Features
+* **Assemblies or reads**: fasta or fastq (gzipped or not), paired-end reads combined per sample.
+* **Fast and scalable**: thousands of genomes; sketches are computed in parallel and reused between runs.
+* **Trees**: UPGMA, neighbour joining and minimum evolution, with optional **bootstrap support**.
+* **Interactive PCoA** with metadata on hover and colourblind-friendly colouring by any metadata column.
+* **Safe by default**: ambiguous sample names and unreadable files are reported, never silently merged or ignored.
+
+## How it works
+```mermaid
+flowchart LR
+    A[fasta / fastq files] -->|mash sketch| B[one sketch per sample]
+    B -->|mash triangle| C[pairwise distance matrix]
+    C --> D[UPGMA / NJ / ME trees]
+    C --> E[PCoA plot]
+    B -. re-sketch with other hash seeds .-> F[bootstrap replicates]
+    F -. support values .-> D
+```
+
+## Installation
+With pip. Mash is not available from PyPI: install it separately (e.g. `conda install -c bioconda mash`).
+```
+pip install genome-comparator
+```
+
+Or from source, in a conda environment that includes Mash:
+```
+git clone https://github.com/duceppemo/genome_comparator
+cd genome_comparator
+conda env create -f environment.yml
+conda activate genome_comparator
+pip install --no-deps .
+```
+
+## Quick start
+```
+genome-comparator -i /input/folder/ -o /output/folder/ --nj --pcoa
+```
+
+New to the tool? Follow the **[tutorial](https://github.com/duceppemo/genome_comparator/wiki/Tutorial)**: it downloads
+22 public genomes and walks through every output in a few minutes.
+
+## Documentation
+The **[wiki](https://github.com/duceppemo/genome_comparator/wiki)** covers
+[usage and options](https://github.com/duceppemo/genome_comparator/wiki/Usage),
+[output files](https://github.com/duceppemo/genome_comparator/wiki/Output-files),
+[interpreting the results](https://github.com/duceppemo/genome_comparator/wiki/How-it-works),
+[bootstrap support](https://github.com/duceppemo/genome_comparator/wiki/Bootstrap-support),
+[performance](https://github.com/duceppemo/genome_comparator/wiki/Performance),
+[related tools](https://github.com/duceppemo/genome_comparator/wiki/Related-tools),
+[troubleshooting](https://github.com/duceppemo/genome_comparator/wiki/Troubleshooting) and the
+[FAQ](https://github.com/duceppemo/genome_comparator/wiki/FAQ).
+
+## Citing
+If you use genome_comparator, please cite it and Mash, which computes the distances:
+
+> Duceppe M-O. genome_comparator: fast comparison and visualization of genome distances with Mash. Zenodo.
+> https://doi.org/10.5281/zenodo.22920856
+
+This DOI always points to the latest version; each release also has its own DOI, listed on
+[Zenodo](https://doi.org/10.5281/zenodo.22920856). GitHub's **"Cite this repository"** button gives the same citation
+in APA and BibTeX formats.
+
+
+> Ondov BD, Treangen TJ, Melsted P, Mallonee AB, Bergman NH, Koren S, Phillippy AM. Mash: fast genome and metagenome
+> distance estimation using MinHash. *Genome Biology* 17, 132 (2016). https://doi.org/10.1186/s13059-016-0997-x
+
+## Contributing
+Bug reports, questions and pull requests are welcome: see [CONTRIBUTING.md](CONTRIBUTING.md).
+
+## Author
+Marc-Olivier Duceppe, Canadian Food Inspection Agency (CFIA): marc-olivier.duceppe@inspection.gc.ca
+
+## License
+[MIT](LICENSE)

genome_comparator-0.4.6/genome_comparator/__init__.py

@@ -0,0 +1,3 @@
+"""Quickly compare and visualize distances between genomes using Mash."""
+
+__version__ = '0.4.6'

genome_comparator-0.4.6/genome_comparator/__main__.py

@@ -0,0 +1,6 @@
+"""Allow running the main command with "python -m genome_comparator"."""
+
+from .cli import main
+
+if __name__ == '__main__':
+    main()

genome_comparator-0.4.6/genome_comparator/bootstrap.py

@@ -0,0 +1,78 @@
+"""
+Bootstrap support for trees built from Mash distances.
+
+There is no alignment to resample, so each replicate re-sketches the genomes with a different hash seed
+("mash sketch -S"), which picks a different random subset of k-mers (the approach used by mashtree).
+The support of a clade is the percentage of replicate trees that contain it.
+
+Clades are stored as integer bitmasks over the tip names (bit i set = tip i is in the clade),
+which keeps memory and comparisons cheap on trees with thousands of tips.
+"""
+
+from collections import Counter
+
+ROOTED_TREES = ('hc',)  # Hierarchical clustering trees are rooted, NJ and ME trees are not
+
+
+def clade_masks(tree, index):
+    """
+    :param index: dict {tip name: bit position}
+    :return: dict {internal node: bitmask of the tips below it}, root excluded
+    """
+    masks = dict()
+    for node in tree.postorder(include_self=False):
+        if node.is_tip():
+            masks[node] = 1 << index[node.name]
+        else:
+            mask = 0
+            for child in node.children:
+                mask |= masks[child]
+            masks[node] = mask
+    return {node: mask for node, mask in masks.items() if not node.is_tip()}
+
+
+def canonical_split(mask, n_tips):
+    """An unrooted split and its complement are the same bipartition. Keep the side without tip 0."""
+    return mask ^ ((1 << n_tips) - 1) if mask & 1 else mask
+
+
+def node_splits(tree, index, rooted):
+    """
+    :return: dict {internal node: clade (rooted) or bipartition (unrooted)}, trivial splits excluded
+    """
+    n_tips = len(index)
+    splits = dict()
+    for node, mask in clade_masks(tree, index).items():
+        if not rooted:
+            mask = canonical_split(mask, n_tips)
+        size = bin(mask).count('1')
+        if 1 < size < n_tips - (0 if rooted else 1):
+            splits[node] = mask
+    return splits
+
+
+class SupportCounter:
+    """Count how often the clades of a reference tree are found in replicate trees."""
+
+    def __init__(self, tree, rooted):
+        self.tree = tree
+        self.rooted = rooted
+        self.index = {name: i for i, name in enumerate(sorted(t.name for t in tree.tips()))}
+        self.splits = node_splits(tree, self.index, rooted)
+        self.wanted = set(self.splits.values())
+        self.counts = Counter()
+        self.replicates = 0
+
+    def add(self, replicate_tree):
+        self.add_splits(set(node_splits(replicate_tree, self.index, self.rooted).values()))
+
+    def add_splits(self, found):
+        """Add the clades (bitmasks) of one replicate tree, e.g. computed in another process."""
+        self.counts.update(found & self.wanted)
+        self.replicates += 1
+
+    def assign(self):
+        """Store the support (% of replicates) in the "support" attribute of each internal node."""
+        for node, mask in self.splits.items():
+            node.support = round(100 * self.counts[mask] / self.replicates) if self.replicates else None
+        return self.tree

genome_comparator-0.4.6/genome_comparator/cli.py

@@ -0,0 +1,240 @@
+"""Command line entry points."""
+
+import logging
+import os
+import sys
+from argparse import ArgumentParser, ArgumentTypeError, ArgumentDefaultsHelpFormatter
+from pathlib import Path
+
+from . import __version__, matrix, ordination, trees
+from .mash import MAX_KMER_SIZE, MashError
+from .matrix import MatrixError
+from .pipeline import MIN_SAMPLES, GenomeComparator, analyze_matrix, step
+from .samples import SampleError
+from .tree_tools import collapse, read_rename_table, rename_tips
+
+log = logging.getLogger('genome_comparator')
+
+# Expected errors are reported without a traceback
+USER_ERRORS = (MashError, MatrixError, SampleError, ValueError, OSError)
+
+
+def setup_logging(verbose=False, log_file=None):
+    """Configure the package logger only, so importing genome_comparator never alters the root logger."""
+    for handler in list(log.handlers):
+        log.removeHandler(handler)
+        handler.close()
+    handlers = [logging.StreamHandler(sys.stderr)]
+    if log_file:
+        handlers.append(logging.FileHandler(log_file, mode='w'))
+    formatter = logging.Formatter('%(asctime)s %(levelname)-7s %(message)s', datefmt='%H:%M:%S')
+    for handler in handlers:
+        handler.setFormatter(formatter)
+        log.addHandler(handler)
+    log.setLevel(logging.DEBUG if verbose else logging.INFO)
+
+
+def int_range(low, high=None):
+    def check(value):
+        try:
+            value = int(value)
+        except ValueError:
+            raise ArgumentTypeError('"{}" is not an integer'.format(value))
+        if value < low or (high is not None and value > high):
+            raise ArgumentTypeError('must be between {} and {}'.format(low, high) if high is not None
+                                    else 'must be >= {}'.format(low))
+        return value
+    return check
+
+
+def available_cpus():
+    try:
+        return len(os.sched_getaffinity(0))  # Respects cgroup/taskset limits on Linux (e.g. SLURM jobs)
+    except AttributeError:
+        return os.cpu_count() or 1
+
+
+def add_tree_arguments(parser):
+    group = parser.add_argument_group('trees and ordination')
+    group.add_argument('--linkage', choices=trees.LINKAGE_METHODS, default='average',
+                       help='Hierarchical clustering method for the "_hc" tree. "average" is UPGMA.')
+    group.add_argument('--nj', action='store_true',
+                       help='Also build a neighbour joining tree. Slower than --me on very large datasets.')
+    group.add_argument('--me', action='store_true',
+                       help='Also build a balanced minimum evolution tree (with NNI). '
+                            'Similar to NJ but much faster on large datasets.')
+    group.add_argument('--pcoa', '--pca', dest='pcoa', action='store_true',
+                       help='Also run a principal coordinates analysis (PCoA) and save an interactive html plot.')
+    group.add_argument('--metadata', metavar='metadata.tsv',
+                       help='Tab-separated file, first column is the sample name. '
+                            'Extra columns are shown when hovering over PCoA points.')
+    group.add_argument('--color-by', metavar='COLUMN',
+                       help='Metadata column used to colour the PCoA points.')
+
+
+def check_tree_arguments(parser, args):
+    if args.color_by and not args.metadata:
+        parser.error('--color-by requires --metadata')
+    if args.metadata and not args.pcoa:
+        parser.error('--metadata is only used with --pcoa')
+    if args.metadata:
+        try:
+            ordination.read_metadata(args.metadata, args.color_by)  # Fail now rather than after hours of work
+        except (ValueError, OSError) as e:
+            parser.error(str(e))
+
+
+def tree_kwargs(args):
+    return dict(linkage=args.linkage, nj=args.nj, me=args.me, pcoa=args.pcoa,
+                metadata=args.metadata, color_by=args.color_by)
+
+
+def run_safely(func):
+    try:
+        func()
+    except USER_ERRORS as e:
+        log.error('%s', e)
+        log.debug('Traceback:', exc_info=True)  # Shown with --verbose
+        sys.exit(1)
+    except KeyboardInterrupt:
+        log.error('Interrupted')
+        sys.exit(130)
+
+
+def main(argv=None):
+    """genome-comparator: compare genomes from a folder of fasta/fastq files."""
+    max_cpu = available_cpus()
+    parser = ArgumentParser(prog='genome-comparator', formatter_class=ArgumentDefaultsHelpFormatter,
+                            description='Compare genomes (assemblies or reads) with Mash and build '
+                                        'a distance matrix, trees and an optional PCoA plot.')
+    parser.add_argument('-i', '--input', metavar='/input/folder', required=True,
+                        help='Folder containing the fasta or fastq files (searched recursively)')
+    parser.add_argument('-o', '--output', metavar='/output/folder', required=True,
+                        help='Folder to hold the result files')
+    parser.add_argument('-t', '--threads', metavar='N', type=int_range(1), default=max_cpu,
+                        help='Number of threads')
+    parser.add_argument('-k', '--kmer-size', '--kmer_size', dest='kmer_size', type=int_range(1, MAX_KMER_SIZE),
+                        default=21, help='k-mer size used by Mash')
+    parser.add_argument('-s', '--sketch-size', '--sketch_size', dest='sketch_size', type=int_range(1),
+                        default=10000, help='Number of min-hashes per sketch')
+    parser.add_argument('-m', '--min-copies', type=int_range(1), default=2,
+                        help='Reads only: minimum copies of a k-mer to be included in the sketch '
+                             '(filters out sequencing errors)')
+    add_tree_arguments(parser)
+    parser.add_argument('-b', '--bootstrap', metavar='N', type=int_range(0), default=0,
+                        help='Number of bootstrap replicates for tree support values. Each replicate sketches all '
+                             'the samples again with a different hash seed, so N replicates take about N times '
+                             'longer than a normal run.')
+    parser.add_argument('--phylip', action='store_true',
+                        help='Also save the distance matrix in phylip format (for rapidnj, fastme, etc.)')
+    parser.add_argument('--force', action='store_true',
+                        help='Sketch all samples again, even if up-to-date sketches exist in the output folder')
+    parser.add_argument('--clean', action='store_true',
+                        help='Remove the individual sketch files at the end')
+    parser.add_argument('-v', '--verbose', action='store_true', help='Show debug messages')
+    parser.add_argument('--version', action='version', version='%(prog)s ' + __version__)
+    args = parser.parse_args(argv)
+    check_tree_arguments(parser, args)
+
+    if args.threads > max_cpu:
+        args.threads = max_cpu
+
+    output = Path(args.output).expanduser()
+    output.mkdir(parents=True, exist_ok=True)
+    setup_logging(args.verbose, output / 'genome_comparator.log')
+    log.info('genome_comparator %s: %s', __version__, ' '.join(sys.argv))
+
+    run_safely(GenomeComparator(args.input, args.output, threads=args.threads, kmer_size=args.kmer_size,
+                                sketch_size=args.sketch_size, min_copies=args.min_copies, phylip=args.phylip,
+                                force=args.force, clean=args.clean, bootstrap=args.bootstrap,
+                                **tree_kwargs(args)).run)
+
+
+def mash_phylo_main(argv=None):
+    """Deprecated name of the main command, kept so existing scripts keep working."""
+    sys.stderr.write('Warning: "mash-phylo" is deprecated and will be removed in a future version. '
+                     'Use "genome-comparator" instead (same options).\n')
+    main(argv)
+
+
+def dendrogram_main(argv=None):
+    """dendrogram-from-matrix: build trees / PCoA from an existing square distance matrix."""
+    parser = ArgumentParser(prog='dendrogram-from-matrix', formatter_class=ArgumentDefaultsHelpFormatter,
+                            description='Build trees and an optional PCoA plot from a square distance matrix. '
+                                        'First row and first column hold the sample names.')
+    parser.add_argument('-i', '--input', metavar='my_square_matrix.tsv', required=True,
+                        help='Square distance matrix (.tsv, .csv, .xlsx or .xls)')
+    parser.add_argument('-o', '--output', metavar='/output/folder', required=True,
+                        help='Folder to hold the result files')
+    add_tree_arguments(parser)
+    parser.add_argument('-v', '--verbose', action='store_true', help='Show debug messages')
+    parser.add_argument('--version', action='version', version='%(prog)s ' + __version__)
+    args = parser.parse_args(argv)
+    check_tree_arguments(parser, args)
+    setup_logging(args.verbose)
+
+    def run():
+        with step('Reading distance matrix'):
+            df = matrix.read_matrix(args.input)
+        log.info('%d x %d matrix', *df.shape)
+        if len(df) < MIN_SAMPLES:
+            raise MatrixError('At least {} samples are required to build a tree'.format(MIN_SAMPLES))
+        name = Path(args.input).stem
+        for out in analyze_matrix(df, Path(args.output).expanduser(), name, **tree_kwargs(args)):
+            log.info('Output: %s', out)
+
+    run_safely(run)
+
+
+def collapse_main(argv=None):
+    """tree-collapser: collapse clades whose tips are closer than a distance threshold."""
+    parser = ArgumentParser(prog='tree-collapser',
+                            description='Collapse clades whose average distance to their tips is smaller '
+                                        'than a threshold. Collapsed clades are replaced by a single tip '
+                                        'named "<first tip> {<other tips>}".')
+    parser.add_argument('-i', '--input', metavar='tree.nwk', required=True, help='Newick input tree')
+    parser.add_argument('-o', '--output', metavar='tree_collapsed.nwk', required=True, help='Newick output tree')
+    parser.add_argument('-d', '--distance', metavar='0.01', type=float, required=True,
+                        help='Distance threshold. Clades with an average distance to their tips smaller than '
+                             'this value are collapsed.')
+    parser.add_argument('--version', action='version', version='%(prog)s ' + __version__)
+    args = parser.parse_args(argv)
+    setup_logging()
+
+    def run():
+        tree = trees.read_newick(args.input)
+        n = collapse(tree, args.distance)
+        trees.write_newick(tree, args.output)
+        log.info('Collapsed %d clade(s)', n)
+
+    run_safely(run)
+
+
+def rename_main(argv=None):
+    """tree-renamer: rename tree tips from a two-column table."""
+    parser = ArgumentParser(prog='tree-renamer', description='Rename the tips of a Newick tree.')
+    parser.add_argument('-i', '--input', metavar='input_tree.nwk', required=True, help='Input tree in Newick format')
+    parser.add_argument('-o', '--output', metavar='renamed_tree.nwk', required=True,
+                        help='Renamed tree in Newick format')
+    parser.add_argument('-r', '--rename-table', metavar='rename_table.tsv', required=True,
+                        help='Tab-separated file with two columns: current tip name, new name')
+    parser.add_argument('--version', action='version', version='%(prog)s ' + __version__)
+    args = parser.parse_args(argv)
+    setup_logging()
+
+    def run():
+        tree = trees.read_newick(args.input)
+        not_found, duplicates = rename_tips(tree, read_rename_table(args.rename_table))
+        trees.write_newick(tree, args.output)
+        if not_found:
+            log.warning('%d name(s) from the rename table were not found in the tree: %s',
+                        len(not_found), ', '.join(sorted(not_found)[:10]))
+        if duplicates:
+            log.warning('%d name(s) are now shared by several tips: %s',
+                        len(duplicates), ', '.join(sorted(duplicates)[:10]))
+
+    run_safely(run)
+
+
+if __name__ == '__main__':
+    main()