Fixes from autopep8

Author: jonchang

tact/cli_add_taxa.py

@@ -38,6 +38,7 @@
 global mrca_rates
 mrca_rates = {}
 
+
 def search_ancestors_for_valid_backbone_node(taxonomy_node, backbone_tips, ccp):
     global invalid_map
     seen = []
@@ -69,6 +70,7 @@ def search_ancestors_for_valid_backbone_node(taxonomy_node, backbone_tips, ccp):
         invalid_map[x] = taxonomy_target
     return (taxonomy_target, backbone_target)
 
+
 def get_new_branching_times(backbone_node, taxonomy_node, backbone_tree, told=None, tyoung=0, min_ccp=0.8, num_new_times=None):
     """
     Get `n_total` new branching times for a `node`.
@@ -108,6 +110,7 @@ def get_new_branching_times(backbone_node, taxonomy_node, backbone_tree, told=No
         logger.debug(("    {}: " + ", ".join(["{:.2f}" for x in times])).format(taxon, *times))
     return times
 
+
 def fill_new_taxa(namespace, node, new_taxa, times, stem=False, excluded_nodes=None):
     for new_species, new_age in zip(new_taxa, times):
         new_node = dendropy.Node()
@@ -123,6 +126,7 @@ def fill_new_taxa(namespace, node, new_taxa, times, stem=False, excluded_nodes=N
 
     return node
 
+
 def graft_node(graft_recipient, graft, stem=False):
     """
     Grafts a node `graft` randomly in the subtree below node
@@ -182,6 +186,7 @@ def filter_fn(x):
         return graft
     return graft_recipient
 
+
 def create_clade(namespace, species, ages):
     tree = dendropy.Tree(taxon_namespace=namespace)
     species = list(species)
@@ -220,6 +225,7 @@ def create_clade(namespace, species, ages):
         logger.warning("{} short branches detected".format(len(list(get_short_branches(tree.seed_node)))))
     return tree
 
+
 def lock_clade(node):
     pre = count_locked(node)
     for edge in edge_iter(node):
@@ -228,18 +234,22 @@ def lock_clade(node):
     if pre != post:
         logger.debug("locking clade: {} => {}".format(pre, post))
 
+
 def count_locked(node):
     sum([x.label == "locked" for x in edge_iter(node)])
 
+
 def is_fully_locked(node):
     return all([x.label == "locked" for x in edge_iter(node)])
 
+
 def get_min_age(node):
     try:
         return min([x.head_node.age for x in edge_iter(node) if x.label != "locked"])
     except ValueError:
         return 0.0
 
+
 def process_node(backbone_tree, backbone_bitmask, all_possible_tips, taxon_node, min_ccp, default_birth, default_death, yule=False):
     # TODO: Fix all the returns and refactor this into something sane
     global mrca_rates
@@ -286,6 +296,7 @@ def process_node(backbone_tree, backbone_bitmask, all_possible_tips, taxon_node,
     logger.debug("MRCA: {} b={}, d={}, sf={}, ccp={}".format(taxon, birth, death, sf, ccp))
     mrca_rates[taxon] = (birth, death, ccp, "computed")
 
+
 def run_precalcs(taxonomy_tree, backbone_tree, min_ccp=0.8, min_extant=3, yule=False):
     global mrca_rates
     tree_tips = get_tip_labels(backbone_tree)
@@ -311,12 +322,14 @@ def run_precalcs(taxonomy_tree, backbone_tree, min_ccp=0.8, min_extant=3, yule=F
         logger.debug("FastMRCA calculation time: {:.1f} seconds".format(diff))
     return mrca_rates
 
+
 def update_tree_view(tree):
     # Stuff that DendroPy needs to keep a consistent view of the phylgoeny
     tree.calc_node_ages()
     tree.update_bipartitions()
     return get_tip_labels(tree)
 
+
 def compute_node_depths(tree):
     res = dict()
     for leaf in tree.leaf_node_iter():
@@ -327,6 +340,7 @@ def compute_node_depths(tree):
         res[leaf.taxon.label] = cnt
     return res
 
+
 @click.command()
 @click.option("--taxonomy", help="a taxonomy tree", type=click.File("r"), required=True)
 @click.option("--backbone", help="the backbone tree to attach the taxonomy tree to", type=click.File("r"), required=True)
@@ -411,9 +425,9 @@ def main(taxonomy, backbone, outgroups, output, min_ccp, verbose, yule):
     initial_length = len(tree_tips)
 
     bar = click.progressbar(label="TACT",
-            length=len(all_possible_tips) - initial_length,
-            show_pos=True,
-            item_show_func=lambda x: x)
+                            length=len(all_possible_tips) - initial_length,
+                            show_pos=True,
+                            item_show_func=lambda x: x)
 
     def bar_update():
         bar.pos = len(tree_tips) - initial_length
@@ -537,5 +551,6 @@ def bar_update():
     tree.write(path=output + ".nexus.tre", schema="nexus")
     print()
 
+
 if __name__ == '__main__':
     main()

tact/cli_check_trees.py

@@ -16,6 +16,7 @@
 
 from .lib import get_monophyletic_node, get_birth_death_rates, get_tree, get_tip_labels
 
+
 def analyze_taxon(bb_tips, st_tips, backbone, simtaxed, taxon_node):
     taxon = taxon_node.label
     if not taxon:
@@ -103,5 +104,6 @@ def main(simulated, backbone, taxonomy, output, cores, chunksize):
             if result:
                 writer.writerow(result)
 
+
 if __name__ == '__main__':
     main()

tact/cli_taxonomy.py

@@ -14,6 +14,7 @@ def wc(filename):
             pass
         return ii + 1
 
+
 def build_taxonomic_tree(filename):
     """
     Builds a taxonomic tree given a filename. Last column is assumed to
@@ -60,6 +61,7 @@ def build_taxonomic_tree(filename):
         tn.is_mutable = False
         return tree
 
+
 @click.command()
 @click.argument("taxonomy", type=click.Path(exists=True, dir_okay=False, readable=True))
 @click.option("--output", help="name of the output taxonomic tree", required=True, type=click.Path(writable=True))

tact/fastmrca.py

@@ -11,13 +11,15 @@
 
 global tree
 
+
 def initialize(phy):
     """
     Initialize the fastmrca singleton with a tree.
     """
     global tree
     tree = phy
 
+
 def bitmask(labels):
     """
     Gets a bitmask for the taxa in `labels`, potentially in parallel.
@@ -26,6 +28,7 @@ def bitmask(labels):
     tn = tree.taxon_namespace
     return tn.taxa_bitmask(labels=labels)
 
+
 def get(labels):
     """Pulls a MRCA node out for the taxa in `labels`."""
     global tree
@@ -36,6 +39,7 @@ def get(labels):
     if mrca and labels.issuperset(get_tip_labels(mrca)):
         return mrca
 
+
 def fastmrca_getter(tn, x):
     """Helper function for submitting stuff."""
     taxa = tn.get_taxa(labels=x)

tact/lib.py

@@ -21,13 +21,16 @@
 deaths = np.linspace(0, 5, num=100)
 params = [(x, y) for (x, y) in itertools.product(births, deaths) if x > y]
 
+
 def get_bd(r, a):
     """Converts turnover and relative extinction to birth and death rates."""
     return -r / (a - 1), -a * r / (a - 1)
 
+
 def get_ra(b, d):
     return (b - d, d / b)
 
+
 def optim_bd_r(ages, sampling):
     """Optimizes birth death using TreePar and R"""
     script = """cat(optim(c({birth}, {death}), function(v, ...) TreePar::LikConstant(v[1], v[2], ...), x = c({ages}), sampling = {sampling}, lower=c(.Machine$double.xmin,0), method = "L-BFGS-B")$par, " dum")"""
@@ -36,18 +39,21 @@ def optim_bd_r(ages, sampling):
     b, d, _ = output.split(None, 2)
     return float(b), float(d)
 
+
 def optim_bd_grid(ages, sampling):
     """Optimizes birth death using a grid search"""
     res = [lik_constant(x, sampling, ages) for x in params]
     return params[np.argmin(res)]
 
+
 def update_multiplier_freq(q, d=1.1):
     u = np.random.uniform(0, 1, 2)
     l = 2 * log(d)
     m = np.exp(l * (u - 0.5))
     new_q = q * m
     return new_q
 
+
 def optim_bd_mcmc(ages, sampling):
     """Optimizes birth death using a cheap MCMC-like algorithm"""
     new_vec = [0, 0]
@@ -66,6 +72,7 @@ def optim_bd_mcmc(ages, sampling):
             vec = new_vec
     return vec
 
+
 def wrapped_lik_constant(x, sampling, ages):
     return lik_constant(get_bd(*x), sampling, ages)
 
@@ -80,10 +87,12 @@ def optim_bd_scipy(ages, sampling):
     bounds = ((1e-6, None), (0, 1 - 1e-6))
     return get_bd(*minimize(wrapped_lik_constant, (init_r, 0.0), args=(sampling, ages), bounds=bounds, method="TNC")["x"].tolist())
 
+
 def optim_bd(ages, sampling):
     return optim_bd_scipy(ages, sampling)
 
-def optim_yule(ages,sampling):
+
+def optim_yule(ages, sampling):
     """Optimizes a Yule model using Scipy"""
     if max(ages) < 0.000001:
         init_r = 1e-3
@@ -93,6 +102,7 @@ def optim_yule(ages,sampling):
     bounds = ((1e-6, None), (0, 0))
     return get_bd(*minimize(wrapped_lik_constant, (init_r, 0.0), args=(sampling, ages), bounds=bounds, method="TNC")["x"].tolist())
 
+
 def get_lik(vec, rho, x):
     l = vec[0]
     m = vec[1]
@@ -102,19 +112,22 @@ def get_lik(vec, rho, x):
     lik3 = - (root + 1) * np.log(1 - p0(x[0], l, m, rho))
     return lik1 + lik2 + lik3
 
+
 def p0_exact(t, l, m, rho):
     t = D(t)
     l = D(l)
     m = D(m)
     rho = D(rho)
     return D(1) - rho * (l - m) / (rho * l + (l * (D(1) - rho) - m) * (-(l - m) * t).exp())
 
+
 def p0(t, l, m, rho):
     try:
         return 1 - rho * (l - m) / (rho * l + (l * (1 - rho) - m) * exp(-(l - m) * t))
     except FloatingPointError:
         return float(p0_exact(t, l, m, rho))
 
+
 def p1_exact(t, l, m, rho):
     """Exact version of p1 using Decimal math."""
     t = D(t)
@@ -125,6 +138,7 @@ def p1_exact(t, l, m, rho):
     denom = (rho * l + (l * (1 - rho) - m) * (-(l - m) * t).exp()) ** D(2)
     return num / denom
 
+
 def p1_orig(t, l, m, rho):
     try:
         num = rho * (l - m) ** 2 * np.exp(-(l - m) * t)
@@ -133,6 +147,7 @@ def p1_orig(t, l, m, rho):
     except (OverflowError, FloatingPointError):
         return float(p1_exact(t, l, m, rho))
 
+
 def p1(t, l, m, rho):
     # Optimized version of p1 using common subexpression elimination and strength reduction from
     # exponentiation to multiplication.
@@ -144,6 +159,7 @@ def p1(t, l, m, rho):
     except (OverflowError, FloatingPointError):
         return float(p1_exact(t, l, m, rho))
 
+
 def intp1_exact(t, l, m):
     """Exact version of intp1 using Decimal math."""
     l = D(l)
@@ -153,12 +169,14 @@ def intp1_exact(t, l, m):
     denom = (l - m * (-(l - m) * t).exp())
     return num / denom
 
+
 def intp1(t, l, m):
     try:
-        return (1 - exp(-(l - m) * t))/(l - m * exp(-(l - m) * t))
+        return (1 - exp(-(l - m) * t)) / (l - m * exp(-(l - m) * t))
     except OverflowError:
         return float(intp1_exact(t, l, m))
 
+
 def lik_constant(vec, rho, t, root=1, survival=1, p1=p1):
     """
     Calculates the likelihood of a constant-rate birth-death process, conditioned
@@ -210,6 +228,7 @@ def crown_capture_probability(n, k):
         return 0  # not technically correct but it works for our purposes
     return 1 - 2 * (n - k) / ((n - 1) * (k + 1))
 
+
 def get_monophyletic_node(tree, species):
     """Returns the node or None that is the MRCA of the `species` in `tree`."""
     mrca = tree.mrca(taxon_labels=species)
@@ -218,6 +237,7 @@ def get_monophyletic_node(tree, species):
     if mrca and species.issuperset(get_tip_labels(mrca)):
         return mrca
 
+
 def get_birth_death_rates(node, sampfrac, yule=False, include_root=False):
     """
     Estimates the birth and death rates for the subtree descending from
@@ -229,18 +249,21 @@ def get_birth_death_rates(node, sampfrac, yule=False, include_root=False):
     else:
         return optim_bd(get_ages(node, include_root), sampfrac)
 
+
 def get_ages(node, include_root=False):
     ages = [x.age for x in node.ageorder_iter(include_leaves=False, descending=True)]
     if include_root:
         ages += [node.age]
     return ages
 
+
 def get_tip_labels(tree_or_node):
     try:
         return set([x.taxon.label for x in tree_or_node.leaf_node_iter()])
     except AttributeError:
         return set([x.taxon.label for x in tree_or_node.leaf_iter()])
 
+
 def edge_iter(node, filter_fn=None):
     """
     Iterates over the child edge of `node` and all its descendants.
@@ -253,6 +276,7 @@ def edge_iter(node, filter_fn=None):
             yield edge
         stack.extend(edge.head_node.child_edge_iter())
 
+
 def get_tree(path, namespace=None):
     """
     Gets a DendroPy tree from a path and precalculate its node ages and bipartition bitmask.
@@ -262,19 +286,23 @@ def get_tree(path, namespace=None):
     tree.encode_bipartitions()
     return tree
 
+
 def is_binary(node):
     """Is the subtree under `node` a fully bifurcating tree?"""
     for x in node.preorder_internal_node_iter():
         if len(x.child_nodes()) != 2:
             return False
     return True
 
+
 def get_short_branches(node):
     for edge in edge_iter(node):
         if edge.length <= 0.001:
             yield edge
 
 # TODO: This could probably be optimized
+
+
 def get_new_times(ages, birth, death, missing, told=None, tyoung=None):
     """
     Simulates new speciation events in an incomplete phylogeny assuming a