drep 4.0.2__py3-none-any.whl

drep/argumentParser.py

@@ -0,0 +1,279 @@
+#!/usr/bin/env python
+
+'''
+dRep- parse command-line arguemnts
+'''
+
+__author__ = "Matt Olm"
+__license__ = "MIT"
+__email__ = "mattolm@gmail.com"
+__status__ = "Development"
+
+import argparse
+import os
+import sys
+
+import drep
+from drep.controller import Controller
+
+
+def version():
+    versionFile = open(os.path.join(drep.__path__[0], 'VERSION'))
+    return versionFile.read().strip()
+
+
+VERSION = version()
+
+"""
+########################################
+#    Argument Parsing                  #
+########################################
+"""
+
+
+class SmartFormatter(argparse.ArgumentDefaultsHelpFormatter):
+    def _split_lines(self, text, width):
+        if text.startswith('R|'):
+            return text[2:].splitlines()
+        # this is the RawTextHelpFormatter._split_lines
+        return argparse.HelpFormatter._split_lines(self, text, width)
+
+
+def printHelp():
+    print('')
+    print('                ...::: dRep v' + VERSION + ' :::...''')
+    print('''\
+
+  Matt Olm. MIT License. Banfield Lab, UC Berkeley. 2017 (last updated 2026)
+
+  See https://drep.readthedocs.io/en/latest/index.html for documentation
+  Choose one of the operations below for more detailed help. 
+  
+  Example: dRep dereplicate -h
+
+  Commands:
+    compare            -> Compare and cluster a set of genomes
+    dereplicate        -> De-replicate a set of genomes
+    check_dependencies -> Check which dependencies are properly installed
+    ''')
+
+
+def parse_args(args):
+    parser = argparse.ArgumentParser(formatter_class=SmartFormatter)
+    subparsers = parser.add_subparsers(help='Desired operation', dest='operation')
+
+    # Make a parent parser for all of the subparsers
+    parent_parser = argparse.ArgumentParser(add_help=False)
+    parent_parser.add_argument("work_directory", help="R|Directory where data and output are stored\
+    \n*** USE THE SAME WORK DIRECTORY FOR ALL DREP OPERATIONS ***")
+
+    Bflags = parent_parser.add_argument_group('SYSTEM PARAMETERS')
+    Bflags.add_argument('-p', '--processors', help='threads', default=6, type=int)
+    Bflags.add_argument('-d', '--debug', help='make extra debugging output', default=False,
+                        action="store_true")
+    Bflags.add_argument("-h", "--help", action="help", help="show this help message and exit")
+
+    # Make a parent parser for genome input
+    genome_parser = argparse.ArgumentParser(add_help=False)
+    Gflags = genome_parser.add_argument_group('GENOME INPUT')
+    Gflags.add_argument('-g', '--genomes', nargs='*', help='genomes to filter in .fasta format.\
+                                    Not necessary if Bdb or Wdb already exist. Can also input a text file with paths to genomes, which results in fewer OS issues than wildcard expansion')
+
+    # Make a parent parser for filter operation
+    filtering_parent = argparse.ArgumentParser(add_help=False)
+    fiflags = filtering_parent.add_argument_group('GENOME FILTERING OPTIONS')
+    fiflags.add_argument("-l", "--length", help="Minimum genome length", default=50000,
+                         type=float)
+    fiflags.add_argument("-comp", "--completeness", help="Minimum genome completeness",
+                         default=75, type=float)
+    fiflags.add_argument("-con", "--contamination", help="Maximum genome contamination",
+                         default=25, type=float)
+
+    quality_parent = argparse.ArgumentParser(add_help=False)
+    Iflags = quality_parent.add_argument_group('GENOME QUALITY ASSESSMENT OPTIONS')
+    Iflags.add_argument("--ignoreGenomeQuality", help="Don't run checkM or do any \
+                quality filtering. NOT RECOMMENDED! This is useful for use with bacteriophages\
+                or eukaryotes or things where checkM scoring does not work. Will only \
+                choose genomes based on length and N50", action='store_true')
+    Iflags.add_argument('--genomeInfo', help='location of .csv or .tsv file containing quality \
+                    information on the genomes (the delimiter is detected automatically). Must contain: ["genome"(filename of .fasta file \
+                    of that genome, including extension e.g. genome.fasta), "completeness"(0-100 value for completeness of the genome), \
+                    "contamination"(0-100 value of the contamination of the genome)]. Raw CheckM2 and CheckM1 \
+                    output can also be provided directly')
+    Iflags.add_argument("--checkM_method", help="Either lineage_wf (more accurate) \
+                        or taxonomy_wf (faster)", choices={'taxonomy_wf', 'lineage_wf'}, \
+                        default='lineage_wf')
+    Iflags.add_argument("--set_recursion", help="Increases the python recursion limit. " \
+                                                + "NOT RECOMMENDED unless checkM is crashing due to recursion issues. " \
+                                                + "Recommended to set to 2000 if needed, but setting this could crash python", \
+                        default='0')
+    Iflags.add_argument("--checkm_group_size", help="The number of genomes passed to checkM at a time. Increasing this increases RAM but makes checkM faster", \
+                        default=2000, type=int)
+
+    # Make a parent parser for the cluster operation
+    cluster_parent = argparse.ArgumentParser(add_help=False)
+
+    Clustflags = cluster_parent.add_argument_group('GENOME COMPARISON OPTIONS')
+    Clustflags.add_argument("--S_algorithm", help="R|Algorithm for secondary clustering comaprisons:\n" \
+                                                  + "skani   = (DEFAULT) Kmer-based approach; fastest and most accurate.\n" \
+                                                  + "          When paired with --primary_algorithm skani, secondary reuses\n" \
+                                                  + "          the comparisons already done during primary clustering.\n" \
+                                                  + "fastANI = Kmer-based approach; very fast\n" \
+                                                  + "ANImf   = Align whole genomes with nucmer; filter alignment; compare aligned regions\n" \
+                                                  + "ANIn    = Align whole genomes with nucmer; compare aligned regions\n" \
+                                                  + "gANI    = Identify and align ORFs; compare aligned ORFS\n" \
+                                                  + "goANI   = Open source version of gANI; requires nsmimscan\n",
+                            default='skani', choices={'ANIn', 'gANI', 'ANImf', 'goANI', 'fastANI', 'skani'})
+    Clustflags.add_argument("--primary_algorithm", help="R|Program to use for primary clustering.\n" \
+                            + "skani  = (DEFAULT) skani triangle --sparse. Only above-threshold pairs\n" \
+                            + "         are produced, so there is no N^2 matrix in RAM or on disk, and\n" \
+                            + "         a skani --S_algorithm can reuse these comparisons instead of\n" \
+                            + "         recomputing them.\n" \
+                            + "MASH   = all-vs-all Mash. Pre-v4 behavior; builds the full N^2 table.",
+                            default='skani', choices={'MASH', 'skani'})
+    Clustflags.add_argument("--no_reuse_primary_comparisons", dest='reuse_primary_comparisons',
+                            help="Re-run skani during secondary clustering instead of reusing the "
+                                 "comparisons already computed during primary clustering. Only "
+                                 "relevant with --primary_algorithm skani and a skani --S_algorithm, "
+                                 "where the two stages otherwise compute the same ANI values twice. "
+                                 "Reuse is exact, so this is mostly a debugging escape hatch.",
+                            action='store_false', default=True)
+    Clustflags.add_argument("--primary_skani_min_af",
+                            help="Minimum percent of a genome that must align for a pair to form a "
+                                 "primary-clustering edge (--primary_algorithm skani only). skani's ANI "
+                                 "is measured within aligned regions only, so without this filter genomes "
+                                 "sharing just a small conserved region become edges and single linkage "
+                                 "chains them into one huge cluster. The default reproduces the MASH "
+                                 "partition closely; lower it only if you have very fragmented genomes "
+                                 "and understand the chaining risk.",
+                            default=15, type=float)
+    Clustflags.add_argument("-ms", "--MASH_sketch", help="MASH sketch size", default=1000)
+    Clustflags.add_argument("--SkipMash", help="Skip primary clustering entirely and run secondary\
+                            clustering on all genomes at once. (Named for when primary clustering was\
+                            always MASH; it applies to whichever --primary_algorithm is in use.)",
+                            action='store_true')
+    Clustflags.add_argument("--SkipSecondary", help="Skip secondary clustering, just perform MASH\
+                            clustering", action='store_true')
+    Clustflags.add_argument("--skani_extra",
+                         help="Extra arguments to pass to skani triangle",
+                         default="", type=str)
+    Clustflags.add_argument("--n_PRESET", help="R|Presets to pass to nucmer\n" \
+                                               + "tight   = only align highly conserved regions\n" \
+                                               + "normal  = default ANIn parameters", choices=['normal', 'tight'],
+                            default='normal')
+
+    Compflags = cluster_parent.add_argument_group('GENOME CLUSTERING OPTIONS')
+    Compflags.add_argument("-pa", "--P_ani", help="ANI threshold to form primary (MASH) clusters",
+                           default=0.9, type=float)
+    Compflags.add_argument("-sa", "--S_ani", help="ANI threshold to form secondary clusters",
+                           default=0.95, type=float)
+    Compflags.add_argument("-nc", "--cov_thresh", help="Minmum level of overlap between\
+        genomes when doing secondary comparisons", default=0.1, type=float)
+    Compflags.add_argument("-cm", "--coverage_method", help="R|Method to calculate coverage of an alignment\n" \
+                                                            + "(for ANIn/ANImf only; gANI and fastANI can only do larger method)\n"
+                                                            + "total   = 2*(aligned length) / (sum of total genome lengths)\n" \
+                                                            + "larger  = max((aligned length / genome 1), (aligned_length / genome2))\n",
+                           choices=['total', 'larger'], default='larger')
+    Compflags.add_argument("--clusterAlg", help="Algorithm used to cluster genomes during SECONDARY\
+                        clustering (passed to scipy.cluster.hierarchy.linkage)", default='average',
+                           choices={'single', 'complete', 'average', 'weighted', 'centroid', 'median', 'ward'})
+    Compflags.add_argument("--primary_clusterAlg", help="R|Algorithm used to cluster genomes during PRIMARY\n" \
+                        "(MASH/skani) clustering. The default 'single' is equivalent to connected\n" \
+                        "components and is computed with a fast, low-memory streaming algorithm that\n" \
+                        "scales to very large genome sets. Any other choice falls back to the classic\n" \
+                        "dense scipy path (see --classic_primary_clustering).", default='single',
+                           choices={'single', 'complete', 'average', 'weighted', 'centroid', 'median', 'ward'})
+    Compflags.add_argument("--classic_primary_clustering", help="Force the classic dense (scipy) primary\
+                        clustering path instead of the streaming single-linkage algorithm. Uses much more\
+                        RAM at scale but reproduces pre-v4 behavior and allows non-single linkage methods\
+                        and the primary dendrogram plot.",
+                          action='store_true', default=False)
+
+    GRflags = cluster_parent.add_argument_group('GREEDY CLUSTERING OPTIONS\n'
+                                                'These decrease RAM use and runtime at the expense of a minor loss in '
+                                                'accuracy.\nRecommended when clustering 5000+ genomes')
+    GRflags.add_argument("--multiround_primary_clustering",
+                         help='Cluster each primary clunk separately and '
+                              'merge at the end with single linkage. Decreases '
+                              'RAM usage and increases speed, and the cost of a minor '
+                              'loss in precision and the inability to plot '
+                              'primary_clustering_dendrograms. Especially helpful '
+                              'when clustering 5000+ genomes. Will be done with '
+                              'single linkage clustering',
+                         action='store_true')
+    GRflags.add_argument("--primary_chunksize",
+                         help="Impacts multiround_primary_clustering. If you have more than this many genomes, "
+                              "process them in chunks of this size.",
+                         default=5000, type=int)
+    GRflags.add_argument("--greedy_secondary_clustering",
+                         help="Use a heuristic to avoid pair-wise comparisons when doing secondary clustering. Will "
+                              "be done with single linkage clustering. Only works for fastANI S_algorithm option at "
+                              "the moment",
+                         action='store_true')
+    GRflags.add_argument("--run_tertiary_clustering",
+                            help="Run an additional round of clustering on the final genome set. This is especially "
+                                 "useful when greedy clustering is performed and/or to handle cases where similar genomes "
+                                 "end up in different primary clusters. Only works with dereplicate, not compare.",
+                            action='store_true')
+
+    # Make a parent parser for scoring
+    scoring_parent = argparse.ArgumentParser(add_help=False)
+    Sflags = scoring_parent.add_argument_group(
+        "SCORING CRITERIA\nBased off of the formula: \nA*Completeness - B*Contamination + C*(Contamination * ("
+        "strain_heterogeneity/100)) + D*log(N50) + E*log(size) + F*(centrality - S_ani)\n\nA = completeness_weight; B = "
+        "contamination_weight; C = strain_heterogeneity_weight; D = N50_weight; E = size_weight; F = cent_weight")
+
+    Sflags.add_argument("-comW", "--completeness_weight", default=1, type=float,
+                        help='completeness weight')
+    Sflags.add_argument("-conW", "--contamination_weight", default=5, type=float,
+                        help='contamination weight')
+    Sflags.add_argument("-strW", "--strain_heterogeneity_weight", default=1, type=float,
+                        help='strain heterogeneity weight')
+    Sflags.add_argument("-N50W", "--N50_weight", default=0.5, type=float,
+                        help='weight of log(genome N50)')
+    Sflags.add_argument("-sizeW", "--size_weight", default=0, type=float,
+                        help='weight of log(genome size)')
+    Sflags.add_argument("-centW", "--centrality_weight", default=1, type=float,
+                        help='Weight of (centrality - S_ani)')
+    Sflags.add_argument("-extraW", "--extra_weight_table", default=None, type=str,
+                        help='Path to a tab-separated file with two-columns, no headers, listing genome and extra score to apply to that genome')
+
+    # Make a parent parser for evaluate
+    evaluate_parent = argparse.ArgumentParser(add_help=False)
+    Fflags = evaluate_parent.add_argument_group('WARNINGS')
+    Fflags.add_argument("--gen_warnings", default=False, help="Generate warnings", action='store_true')
+    Fflags.add_argument("--warn_dist", default=0.25, help="How far from the threshold " + \
+                                                          " to throw cluster warnings")
+    Fflags.add_argument("--warn_sim", default=0.98, help="Similarity threshold for " + \
+                                                         " warnings between dereplicated genomes")
+    Fflags.add_argument("--warn_aln", default=0.25, help="Minimum aligned fraction for " + \
+                                                         " warnings between dereplicated genomes (ANIn)")
+
+    # Make a parent parser for analyze
+    analyze_parent = argparse.ArgumentParser(add_help=False)
+    Aflags = analyze_parent.add_argument_group('ANALYZE')
+    Aflags.add_argument("--skip_plots", default=False, help="Dont make plots", action='store_true')
+
+    dereplicate_parser = subparsers.add_parser("dereplicate", formatter_class=SmartFormatter, \
+                                               parents=[parent_parser, genome_parser, filtering_parent, quality_parent,
+                                                        cluster_parent, scoring_parent, \
+                                                        evaluate_parent, analyze_parent], add_help=False, epilog= \
+                                                   "Example: dRep dereplicate output_dir/ -g /path/to/genomes/*.fasta")
+
+    dereplicate_parser = subparsers.add_parser("compare", formatter_class=SmartFormatter, \
+                                               parents=[parent_parser, genome_parser, cluster_parent, evaluate_parent], \
+                                               add_help=False, epilog= \
+                                                   "Example: dRep compare output_dir/ -g /path/to/genomes/*.fasta")
+
+    dep_parser = subparsers.add_parser("check_dependencies", formatter_class=SmartFormatter)
+
+    '''
+    ####### PARSE THE ARGUMENTS ######
+    '''
+
+    # Handle the situation where the user wants the raw help
+    if len(args) == 0 or args[0] == '-h' or args[0] == '--help':
+        printHelp()
+        sys.exit(0)
+    else:
+        return parser.parse_args(args)

drep/controller.py

@@ -0,0 +1,105 @@
+#!/usr/bin/env python3
+
+###############################################################################
+#
+# dRep - main program entry point
+#
+###############################################################################
+
+'''
+Controller- takes input from argparse and calls correct modules
+'''
+
+
+__author__ = "Matt Olm"
+__license__ = "MIT"
+__email__ = "mattolm@gmail.com"
+__status__ = "Development"
+
+import argparse
+import logging
+import os
+import sys
+
+import drep
+import drep.d_cluster.controller
+from drep.WorkDirectory import WorkDirectory
+import drep.d_cluster
+import drep.d_analyze
+import drep.d_filter
+import drep.d_choose
+import drep.d_adjust
+import drep.d_bonus
+import drep.d_evaluate
+import drep.d_workflows
+
+def version():
+    versionFile = open(os.path.join(drep.__path__[0], 'VERSION'))
+    return versionFile.read().strip()
+
+VERSION = version()
+
+class Controller():
+    def __init__(self):
+        self.logger = logging.getLogger()
+
+    def dereplicate_operation(self, **kwargs):
+        logging.debug("Starting the dereplicate operation")
+        drep.d_workflows.dereplicate_wrapper(kwargs['work_directory'],**kwargs)
+        logging.debug("Finished the dereplicate operation!")
+
+    def compare_operation(self, **kwargs):
+        logging.debug("Starting the compare operation")
+        drep.d_workflows.compare_wrapper(kwargs['work_directory'],**kwargs)
+        logging.debug("!!! Finished the compare operation !!!")
+
+    def setup_logger(self,loc):
+        ''' set up logger such that DEBUG goes only to file, rest go to file and console '''
+
+        # set up logging everything to file
+        logging.basicConfig(level=logging.DEBUG,
+                           format='%(asctime)s %(levelname)-8s %(message)s',
+                           datefmt='%m-%d %H:%M',
+                           filename=loc)
+
+        # set up logging of INFO or higher to sys.stderr
+        console = logging.StreamHandler()
+        console.setLevel(logging.INFO)
+        formatter = logging.Formatter('%(message)s')
+        console.setFormatter(formatter)
+        logging.getLogger('').addHandler(console)
+
+        logging.debug("!"*80)
+        logging.debug("***Logger started up at {0}***".format(loc))
+        logging.debug("Command to run dRep was: {0}\n".format(' '.join(sys.argv)))
+        logging.debug("dRep version {0} was run \n".format(VERSION))
+        logging.debug("!"*80 + '\n')
+
+    def parseArguments(self, args):
+        ''' Parse user options and call the correct pipeline'''
+        if args.operation == 'check_dependencies':
+            drep.d_bonus.check_dependencies(print_out=True)
+            return
+
+        # Load the workDirectory
+        wd_loc = str(os.path.abspath(args.work_directory))
+        wd = WorkDirectory(wd_loc)
+
+        # Set up the logger
+        self.setup_logger(wd.get_loc('log'))
+        logging.debug(str(args))
+
+        # Do some testing
+        if args.run_tertiary_clustering:
+            if args.operation != "dereplicate":
+                raise ValueError("Can only run tertiary clustering with dereplicate")
+
+
+        # Call the appropriate workflow
+        if args.operation == "dereplicate":
+            self.dereplicate_operation(**vars(args))
+        if args.operation == "compare":
+            self.compare_operation(**vars(args))
+
+    def loadDefaultArgs(self):
+        pass

drep/d_adjust.py

@@ -0,0 +1,272 @@
+#!/usr/bin/env python3
+
+import logging
+import glob
+import pandas as pd
+import os
+import shutil
+import numpy as np
+import pickle
+import sys
+
+import drep.WorkDirectory
+import drep as dm
+import drep.d_cluster as dClust
+import drep.d_cluster.cluster_utils
+import drep.d_cluster.compare_utils
+import drep.d_cluster.controller
+import drep.d_filter as d_filter
+import drep.d_choose as dChoose
+
+def d_adjust_wrapper(wd,**kwargs):
+    # Load the WorkDirectory.
+    logging.info("Loading work directory")
+    wd = drep.WorkDirectory.WorkDirectory(wd)
+    logging.debug(str(wd))
+
+    if kwargs.get('cluster') != None:
+        logging.info('adjusting cluster {0}'.format(kwargs.get('cluster')))
+        adjust_cluster_wrapper(wd, **kwargs)
+
+    elif kwargs.get('rm_cluster') != None:
+        logging.info('removing cluster(s) {0}'.format(' '.join(kwargs.get('rm_cluster'))))
+        remove_cluster_wrapper(wd, **kwargs)
+
+def remove_cluster_wrapper(wd, **kwargs):
+    # Get information
+    Cdb = wd.get_db('Cdb')
+    Wdb = wd.get_db('Wdb')
+
+    for cluster in kwargs.get('rm_cluster'):
+        type = cluster_type(cluster)
+
+        if type == 'primary_cluster':
+            # Make sure cluster is in Cdb
+            if int(cluster) not in Cdb[type].tolist():
+                logging.error("{0} is not in Cdb- quitting".format(cluster))
+                sys.exit()
+
+            # Make sure cluster is Wdb
+            W_Pclusters = [x.split('_')[0] for x in Wdb['cluster'].tolist()]
+            if cluster not in W_Pclusters:
+                logging.error("{0} is not in Wdb- quitting".format(cluster))
+                sys.exit()
+
+            # Remove the cluster
+            remove_primary_cluster(cluster, wd, **kwargs)
+
+        elif type == 'secondary_cluster':
+
+            # Make sure cluster is in Cdb
+            if cluster not in Cdb[type].tolist():
+                logging.error("{0} is not in Cdb- quitting".format(cluster))
+                sys.exit()
+
+            # Make sure cluster is in Wdb
+            if cluster not in Wdb['cluster'].tolist():
+                logging.error("{0} is not in Wdb- quitting".format(cluster))
+                sys.exit()
+
+            # Remove the cluster
+            remove_secondary_cluster(cluster, wd, **kwargs)
+
+
+def remove_primary_cluster(Rcluster, wd, **kwargs):
+    # Get things to alter
+    Cdb = wd.get_db('Cdb')
+    Wdb = wd.get_db('Wdb')
+
+    # If this is a singleton, just remove the associated secondary cluster
+    if len(Cdb['genome'][Cdb['primary_cluster'] == int(Rcluster)].unique()) == 1:
+        Rsecondary = "{0}_0".format(Rcluster)
+        logging.error("{0} is a primary singleton- will remove {1} instead".format(Rcluster, Rsecondary))
+        remove_secondary_cluster(Rsecondary, wd, **kwargs)
+        return
+
+    # Find the genome(s) to remove
+    Wdb['pclust'] = [x.split('_')[0] for x in Wdb['cluster'].tolist()]
+    Rgenomes = Wdb['genome'][Wdb['pclust'] == Rcluster].tolist()
+    for Rgenome in Rgenomes:
+        if not os.path.isfile('{0}/dereplicated_genomes/{1}'.format(wd.location, Rgenome)):
+            raise ValueError()
+
+    # Find the pickle to remove
+    Rpickle = "{0}/data/Clustering_files/secondary_linkage_cluster_{1}.pickle".format(\
+            wd.location, Rcluster)
+    if not os.path.isfile(Rpickle):
+        raise ValueError()
+
+    logging.info("will remove cluster {0}, genomes {1}, and pickle {2}".format(Rcluster, \
+            ' '.join(Rgenomes), os.path.basename(Rpickle)))
+
+    # Remove cluster from Wdb
+    newWdb = Wdb[Wdb['pclust'] != Rcluster]
+    del newWdb['pclust']
+
+    # Remove cluster from Cdb
+    newCdb = Cdb[Cdb['primary_cluster'] != int(Rcluster)]
+
+    # Remove genomes
+    for Rgenome in Rgenomes:
+        os.remove('{0}/dereplicated_genomes/{1}'.format(wd.location, Rgenome))
+
+    # Remove pickle
+    os.remove(Rpickle)
+
+    # Save removed stuff
+    wd.store_db(newCdb,'Cdb',overwrite=True)
+    wd.store_db(newWdb,'Wdb',overwrite=True)
+
+    logging.info("done")
+
+
+def remove_secondary_cluster(Rcluster, wd, **kwargs):
+    # Get things to alter
+    Cdb = wd.get_db('Cdb')
+    Wdb = wd.get_db('Wdb')
+
+    # Find the genome to remove
+    Rgenome = Wdb['genome'][Wdb['cluster'] == Rcluster].tolist()[0]
+    if not os.path.isfile('{0}/dereplicated_genomes/{1}'.format(wd.location, Rgenome)):
+        raise ValueError('Bug')
+
+    logging.info("will remove {0} and genome {1}".format(Rcluster, Rgenome))
+
+    # Remove cluster from Wdb
+    newWdb = Wdb[Wdb['cluster'] != Rcluster]
+
+    # Remove cluster from Cdb
+    newCdb = Cdb[Cdb['secondary_cluster'] != Rcluster]
+
+    # Remove genome
+    os.remove('{0}/dereplicated_genomes/{1}'.format(wd.location, Rgenome))
+
+    # Save removed stuff
+    wd.store_db(newCdb,'Cdb',overwrite=True)
+    wd.store_db(newWdb,'Wdb',overwrite=True)
+
+    logging.info("done")
+
+def cluster_type(cluster):
+    if '_' in cluster:
+        return 'secondary_cluster'
+    else:
+        return 'primary_cluster'
+
+def adjust_cluster_wrapper(wd, **kwargs):
+    # Validate arguments
+    cluster = kwargs.get('cluster')
+    if cluster == None:
+        logging.error("Must specify a cluster")
+        sys.exit()
+    comp_method = kwargs.get('clustering_method')
+    clust_method = kwargs.get('clusterAlg')
+    threshold = kwargs.pop('threshold',None)
+    cov_thresh = float(kwargs.get('minimum_coverage'))
+    if threshold != None: threshold = 1- float(threshold)
+
+    # Make a bdb listing the genomes to cluster
+    Cdb = wd.get_db('Cdb')
+    Bdb = wd.get_db('Bdb')
+    genomes = Cdb['genome'][Cdb['primary_cluster'] == int(cluster)].tolist()
+    bdb = Bdb[Bdb['genome'].isin(genomes)]
+
+    # Make the comparison database
+    Xdb = drep.d_cluster.compare_utils.compare_genomes(bdb, comp_method, wd, **kwargs)
+
+    # Remove values without enough coverage
+    Xdb.loc[Xdb['alignment_coverage'] <= cov_thresh, 'ani'] = 0
+
+    # Make it symmetrical
+    Xdb['av_ani'] = Xdb.apply(lambda row: dClust.average_ani (row,Xdb),axis=1)
+    Xdb['dist'] = 1 - Xdb['av_ani']
+    db = Xdb.pivot(index="reference", columns="querry", values="dist")
+
+    # Cluster it
+    if threshold == None:
+        threshold = float(0)
+    cdb, linkage = drep.d_cluster.cluster_utils.cluster_hierarchical(db, linkage_method = clust_method, \
+                                                                     linkage_cutoff = threshold)
+
+    # Save the pickle
+    data_folder = wd.location + '/data/Clustering_files/'
+    arguments = {'linkage_method':clust_method,'linkage_cutoff':threshold,\
+                        'comparison_algorithm':comp_method,'minimum_coverage':cov_thresh}
+    pickle_name = "secondary_linkage_cluster_{0}.pickle".format(cluster)
+    logging.debug('Saving secondary_linkage pickle {1} to {0}'.format(data_folder,\
+                                                        pickle_name))
+    with open(data_folder + pickle_name, 'wb') as handle:
+        pickle.dump(linkage, handle)
+        pickle.dump(db,handle)
+        pickle.dump(arguments,handle)
+
+    # Change the cdb
+    cdb['cluster_method'] = clust_method
+    cdb['comparison_algorithm'] = comp_method
+    cdb['threshold'] = str(threshold)
+    cdb['primary_cluster'] = int(cluster)
+    cdb['secondary_cluster'] = ["{0}_{1}".format(cluster, x) for x in cdb['cluster']]
+    del cdb['cluster']
+
+    # Incorporate it into the existing Cdb
+    Cdb = Cdb[Cdb['primary_cluster'] != int(cluster)]
+    Cdb = pd.concat([Cdb,cdb], ignore_index=True)
+
+    # Save it
+    wd.store_db(Cdb,'Cdb',overwrite=True)
+
+    if (not kwargs.get('skip_winner',False)) and wd.hasDb('Wdb'):
+
+        # Remake Wdb based on Sdb
+        oriWdb = wd.get_db('Wdb')
+        newWdb = dChoose.pick_winners(wd.get_db('Sdb'),Cdb)
+        change = accounce_changes(newWdb, oriWdb)
+        wd.store_db(newWdb,'Wdb',overwrite=True)
+
+        if change:
+            # Change the ./dereplicated genomes thing
+            logging.info("Remaking ./dereplicated genomes...")
+            output_folder = wd.location + '/dereplicated_genomes/'
+            dm.clobber_dir(output_folder,dry=kwargs.get('dry',False),\
+                            overwrite=True)
+
+            for genome in newWdb['genome'].unique():
+                loc = Bdb['location'][Bdb['genome'] == genome].tolist()[0]
+                shutil.copy2(loc, "{0}{1}".format(output_folder,genome))
+
+def accounce_changes(newWdb, oriWdb):
+    changes = False
+
+    for cluster in newWdb['cluster'].unique():
+        w1 = newWdb['genome'][newWdb['cluster'] == cluster].unique()[0]
+        if cluster not in oriWdb['cluster'].tolist():
+            change = "{0} is the winner of the new cluster {1}".format(w1,cluster)
+            logging.info(change)
+            changes = True
+            continue
+        w2 = oriWdb['genome'][oriWdb['cluster'] == cluster].unique()[0]
+        if w1 != w2:
+            change = "the winner of cluster {0} is now {1} (was {2})".format(\
+                        cluster, w1, w2)
+            logging.info(change)
+            changes = True
+            continue
+
+    for cluster in oriWdb['cluster'].unique():
+        if cluster not in newWdb['cluster'].tolist():
+            change = "cluster {0} no longer exists".format(cluster)
+            logging.info(change)
+            changes = True
+
+    if not changes:
+        change = "No secondary clusters were made or destroyed, and none have new winners"
+        logging.info(change)
+
+    return changes
+
+
+def test_adjust():
+    print("Write this you lazy bum")
+
+if __name__ == '__main__':
+	test_adjust()