Use tskit 0.5.1 so we don't have to call SVG() explicitly

Author: hyanwong

analysing_tree_sequences.md

@@ -224,10 +224,10 @@ tskit provides a flexible and powerful approach to computing such spectra.
 Suppose we have simulated the following tree sequence:
 
 ```{code-cell} ipython3
-from IPython.display import display, SVG
+from IPython.display import display
 ts = tskit.load("data/afs.trees")
 tree = ts.first()
-display(SVG(tree.draw_svg()))
+display(tree.draw_svg())
 ts.tables.sites
 ```
 
@@ -268,7 +268,7 @@ the *joint allele frequency spectra*.
 ```{code-cell} ipython3
 node_colours = {0: "blue", 2: "blue", 3: "blue", 1: "green", 4: "green", 5: "green"}
 styles = [f".n{k} > .sym {{fill: {v}}}" for k, v in node_colours.items()]
-SVG(tree.draw_svg(style = "".join(styles)))
+tree.draw_svg(style = "".join(styles))
 ```
 
 Here we've marked the samples as either blue or green (we can imagine

analysing_trees.md

@@ -103,18 +103,21 @@ places mutations ("characters" in phylogenetic terminology) on a given tree.
 ## Tree traversals
 
 Given a single {class}`Tree`, traversals in various orders are possible using the
-{meth}`~Tree.nodes` iterator. For example, in the following tree we can visit the
-nodes in different orders:
+{meth}`~Tree.nodes` iterator. Take the following tree:
 
 
 ```{code-cell} ipython3
 import tskit
-from IPython.display import SVG, display
 
 ts = tskit.load("data/tree_traversals.trees")
 tree = ts.first()
-display(SVG(tree.draw_svg()))
+tree.draw_svg()
+```
+
+We can visit the nodes in different orders by providing an `order` parameter to
+the {meth}`Tree.nodes` iterator:
 
+```{code-cell} ipython3
 for order in ["preorder", "inorder", "postorder"]:
     print(f"{order}:\t", list(tree.nodes(order=order)))
 ```
@@ -225,7 +228,7 @@ different time points:
 ```{code-cell} ipython3
 ts = tskit.load("data/different_time_samples.trees")
 tree = ts.first()
-SVG(tree.draw_svg(y_axis=True, time_scale="rank"))
+tree.draw_svg(y_axis=True, time_scale="rank")
 ```
 
 The generation times for these nodes are as follows:
@@ -280,42 +283,55 @@ print(dict(zip(range(3), nearest_neighbor_of)))
 
 ## Parsimony
 
-The {meth}`Tree.map_mutations` method finds a parsimonious explanation for a
-set of discrete character observations on the samples in a tree using classical
-phylogenetic algorithms.
+Take a site on the following tree with three allelic states, where the
+samples are coloured by the allele they possess, but where we don't know
+the position of the mutations that caused this variation:
 
 ```{code-cell} ipython3
 tree = tskit.load("data/parsimony_simple.trees").first()
 alleles = ["red", "blue", "green"]
 genotypes = [0, 0, 0, 0, 1, 2]
 styles = [f".n{j} > .sym {{fill: {alleles[g]}}}" for j, g in enumerate(genotypes)]
-display(SVG(tree.draw_svg(style="".join(styles))))
+tree.draw_svg(style="".join(styles))
+```
 
+The {meth}`Tree.map_mutations` method finds a parsimonious explanation for a
+set of discrete character observations on the samples in a tree using classical
+phylogenetic algorithms:
+
+```{code-cell} ipython3
 ancestral_state, mutations = tree.map_mutations(genotypes, alleles)
 print("Ancestral state = ", ancestral_state)
 for mut in mutations:
     print(f"Mutation: node = {mut.node} derived_state = {mut.derived_state}")
 ```
 
-So, the algorithm has concluded, quite reasonably, that the most parsimonious
+In this case, the algorithm has concluded, quite reasonably, that the most parsimonious
 description of this state is that the ancestral state is red and there was
 a mutation to blue and green over nodes 4 and 5.
 
 ### Building tables
 
-One of the main uses of {meth}`Tree.map_mutations` is to position mutations on a tree
-to encode observed data. In the following example we show how a set
-of tables can be updated using the {ref}`Tables API<tskit:sec_tables_api>`; here we
-infer the location of mutations in an simulated tree sequence of one tree,
-given a set of site positions with their genotypes and allelic states:
+Below we show how a set of tables can be updated using the
+{ref}`Tables API<tskit:sec_tables_api>`, taking advantage of the
+{meth}`Tree.map_mutations` method to identify parsimonious positions
+for mutations on a tree. Here's the tree we'll use:
 
 ```{code-cell} ipython3
 import pickle
 ts = tskit.load("data/parsimony_map.trees")
+ts.draw_svg(size=(500, 300), time_scale="rank")
+```
+
+Now we can modify the tables by adding mutations. To find the location of mutations,
+we infer them from some observed data (some site positions with associated genotypes
+and allelic states, in the conventional {class}`tskit encoding <Variant>`):
+
+
+```{code-cell} ipython3
 with open("data/parsimony_map.pickle", "rb") as file:
     data = pickle.load(file)  # Load saved variant data from a file
-display(SVG(ts.draw_svg(size=(500, 300), time_scale="rank")))
-print("Variant data: pos, genotypes & alleles as described by the ts.variants() iterator:")
+print("Variant data: each site has a position, allele list, and genotypes array:")
 for i, v in enumerate(data):
     print(f"Site {i} (pos {v['pos']:7.4f}): alleles: {v['alleles']}, genotypes: {v['genotypes']}")
 print()
@@ -333,11 +349,13 @@ for variant in data:
             parent += parent_offset
         mut_id = tables.mutations.add_row(
             site_id, node=mut.node, parent=parent, derived_state=mut.derived_state)
-        info += f", and places mutation {mut.id} to {mut.derived_state} above node {mut.node}"
+        info += f", and places mutation {mut_id} to {mut.derived_state} above node {mut.node}"
     print(info)
 new_ts = tables.tree_sequence()
 ```
 
+And here are the parsimoniously positioned mutations on the tree
+
 ```{code-cell} ipython3
 mut_labels = {}  # An array of labels for the mutations
 for mut in new_ts.mutations():  # Make pretty labels showing the change in state
@@ -346,34 +364,37 @@ for mut in new_ts.mutations():  # Make pretty labels showing the change in state
     prev = new_ts.mutation(mut.parent).derived_state if older_mut else site.ancestral_state
     mut_labels[site.id] = f"{mut.id}: {prev}→{mut.derived_state}"
 
-display(SVG(new_ts.draw_svg(size=(500, 300), mutation_labels=mut_labels, time_scale="rank")))
+new_ts.draw_svg(size=(500, 300), mutation_labels=mut_labels, time_scale="rank")
 ```
 
 
 ### Parsimony and missing data
 
-The Hartigan parsimony algorithm in {meth}`Tree.map_mutations` can also take missing data
+We can also take missing data
 into account when finding a set of parsimonious state transitions. We do this by
 specifying the special value {data}`tskit.MISSING_DATA` (-1) as the state, which is
 treated by the algorithm as "could be anything".
 
-For example, here we state that sample 0 is missing, and use the colour white to indicate
-this:
+For example, here we state that sample 0 is missing, indicated by the colour white:
 
 ```{code-cell} ipython3
 tree = tskit.load("data/parsimony_simple.trees").first()
 alleles = ["red", "blue", "green", "white"]
 genotypes = [tskit.MISSING_DATA, 0, 0, 0, 1, 2]
 styles = [f".n{j} > .sym {{fill: {alleles[g]}}}" for j, g in enumerate(genotypes)]
-display(SVG(tree.draw_svg(style="".join(styles))))
+tree.draw_svg(style="".join(styles))
+```
+
+Now we run the {meth}`Tree.map_mutations` method, which applies the Hartigan parsimony
+algorithm:
 
+```{code-cell} ipython3
 ancestral_state, mutations = tree.map_mutations(genotypes, alleles)
 print("Ancestral state = ", ancestral_state)
 for mut in mutations:
     print(f"Mutation: node = {mut.node} derived_state = {mut.derived_state}")
 ```
 
-
 The algorithm decided, again, quite reasonably, that the most parsimonious explanation
 for the input data is the same as before. Thus, if we used this information to fill
 out mutation table as above, we would impute the missing value for 0 as red.
@@ -389,7 +410,7 @@ ancestral_state, mutations = tree.map_mutations(genotypes, alleles)
 print("Ancestral state = ", ancestral_state)
 for mut in mutations:
     print(f"Mutation: node = {mut.node} derived_state = {mut.derived_state}")
-SVG(tree.draw(node_colours=node_colours))
+tree.draw(node_colours=node_colours)
 ```
 
 

bottlenecks.md

@@ -45,7 +45,7 @@ bottB = 2
 
 ts = run_bott_sims(12, time=bottT, strength=bottB)
 
-SVG(ts.draw_svg(y_axis=True, size=(400, 400)))
+ts.draw_svg(y_axis=True, size=(400, 400))
 ```
 
 The genealogy shows several simultaneous coalescence events at the time of the bottleneck

completing-forward-sims.md

@@ -34,7 +34,6 @@ import tskit
 import msprime
 import random
 import numpy as np
-from IPython.display import SVG
 
 
 def wright_fisher(N, T, L=100, random_seed=None):
@@ -86,7 +85,7 @@ for 5 generations, and print out the resulting trees:
 num_loci = 2
 N = 10
 wf_ts = wright_fisher(N, 5, L=num_loci, random_seed=3)
-SVG(wf_ts.draw_svg())
+wf_ts.draw_svg()
 ```
 
 Because our Wright Fisher simulation ran for only 5 generations, there has not
@@ -136,7 +135,7 @@ coalesced_ts = msprime.sim_ancestry(
     recombination_rate=1 / num_loci, 
     ploidy=1,
     random_seed=7)
-SVG(coalesced_ts.draw_svg())
+coalesced_ts.draw_svg()
 ```
 
 The trees have fully coalesced and we've successfully combined a forwards-time
@@ -192,9 +191,8 @@ computed tree sequence which is easily done using the
 {meth}`simplify <tskit.TreeSequence.simplify>` method:
 
 ```{code-cell} ipython3
-
-    final_ts = coalesced_ts.simplify()
-    SVG(coalesced_ts.draw_svg())
+final_ts = coalesced_ts.simplify()
+coalesced_ts.draw_svg()
 ```
 
 This final tree sequence is topologically identical to the original tree sequence,

demography.md

@@ -25,7 +25,6 @@ models of demography and population history with a simple Python API.
 ```{code-cell}
 import msprime
 import numpy as np
-from IPython.display import SVG
 ```
 
 ## Population structure
@@ -141,11 +140,9 @@ with nodes coloured by population label using SVG:
 
 ```{code-cell} 
 colour_map = {0:"red", 1:"blue"}
-node_colours = {u.id: colour_map[u.population] for u in ts.nodes()}
-for tree in ts.trees():
-    print("Tree on interval:", tree.interval)
-    # The code below will only work in a Jupyter notebook with SVG output enabled.
-    display(SVG(tree.draw(node_colours=node_colours)))
+styles = [f".node.p{p} > .sym {{fill: {col} }}" for p, col in colour_map.items()]
+# The code below will only work in a Jupyter notebook with SVG output enabled.
+ts.draw_svg(style="".join(styles))
 ```
 
 More coalescences are happening in population 1 than population 0.
@@ -394,7 +391,7 @@ The effect of the census is to add nodes onto each branch of the tree sequence a
 ```{code-cell} 
 print("IDs of census nodes:")
 print([u.id for u in ts.nodes() if u.flags==msprime.NODE_IS_CEN_EVENT])
-SVG(ts.draw_svg())
+ts.draw_svg()
 ```
 
 By extracting these node IDs, you can perform further analyses using the ancestral haplotypes.

getting_started.md

@@ -172,13 +172,11 @@ $5\ 000\ 000$ --- the position of the sweep --- drawn using the
 {meth}`Tree.draw_svg` method.
 
 ```{code-cell} ipython3
-from IPython.display import SVG
-
 swept_tree = ts.at(5_000_000)  # or you can get e.g. the nth tree using ts.at_index(n)
 intvl = swept_tree.interval
 print(f"Tree number {swept_tree.index}, which runs from position {intvl.left} to {intvl.right}:")
 # Draw it at a wide size, to make room for all 40 tips
-SVG(swept_tree.draw_svg(size=(1000, 200)))
+swept_tree.draw_svg(size=(1000, 200))
 ```
 :::{margin}
 The {ref}`visualization tutorial <sec_tskit_viz>` gives more drawing possibilities
@@ -203,7 +201,7 @@ more than one tree: either the entire tree sequence, or
 ```{code-cell} ipython3
 reduced_ts = ts.simplify([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])  # simplify to the first 10 samples
 print("Genealogy of the first 10 samples for the first 5kb of the genome")
-display(SVG(reduced_ts.draw_svg(x_lim=(0, 5000))))
+reduced_ts.draw_svg(x_lim=(0, 5000))
 ```
 
 These are much more standard-looking coalescent trees, with far longer branches higher
@@ -514,8 +512,9 @@ in rough order of importance:
     * {meth}`~TreeSequence.keep_intervals()` (or its complement,
         {meth}`~TreeSequence.delete_intervals()`) removes genetic information from
         specific regions of the genome
-    * {meth}`~TreeSequence.draw_svg()` plots tree sequences (and {meth}`Tree.draw_svg()`
-        plots trees)
+    * {meth}`~TreeSequence.draw_svg()` returns an SVG representation of a tree sequence
+        (and plots it if in a Jupyter notebook). Similarly, {meth}`Tree.draw_svg()`
+        plots individual trees.
     * {meth}`~TreeSequence.at()` returns a tree at a particular genomic position
         (but using {meth}`~TreeSequence.trees` is usually preferable)
     * Various population genetic statistics can be calculated using methods on a tree

introgression.md

@@ -36,7 +36,6 @@ import collections
 import matplotlib.pyplot as plt
 import msprime
 import numpy as np
-from IPython.display import SVG
 
 def run_simulation(sequence_length, random_seed=None):
     time_units = 1000 / 25  # Conversion factor for kya to generations
@@ -260,7 +259,7 @@ css += "".join([
     for k, v in enumerate(mutation_population)])
 y_ticks = {0: "0", 30: "30", 50: "Introgress", 70: "Eur origin", 300: "Nea origin", 1000: "1000"}
 y_ticks = {y * time_units: lab for y, lab in y_ticks.items()}
-SVG(ts.draw_svg(
+ts.draw_svg(
     size=(1200, 500),
     x_lim=(0, 25_000),
     time_scale="log_time",
@@ -270,7 +269,8 @@ SVG(ts.draw_svg(
     x_label="Genomic position (bp)",
     y_ticks=y_ticks,
     y_gridlines=True,
-    style=css))
+    style=css,
+)
 ```
 
 The depth of the trees indicates that most coalescences occur well before the origin of

requirements.txt

@@ -7,5 +7,5 @@ scikit-allel
 tqdm
 numpy
 networkx
-tskit>=0.5
+tskit>=0.5.1
 msprime>=1.0

tables_and_editing.md

@@ -166,8 +166,7 @@ ts = tskit.load("data/tables_example.trees")
 
 ```{code-cell} ipython3
 :"tags": ["hide-input"]
-from IPython.display import SVG
-SVG(ts.draw_svg(y_axis=True))
+ts.draw_svg(y_axis=True)
 ```
 
 Ancestral recombination events have produced three different trees
@@ -238,7 +237,7 @@ for mut in ts.mutations():  # This entire loop is just to make pretty labels
     older_mut = mut.parent >= 0  # is there an older mutation at the same position?
     prev = ts.mutation(mut.parent).derived_state if older_mut else site.ancestral_state
     mut_labels[mut.id] = "{}→{} @{:g}".format(prev, mut.derived_state, site.position)
-SVG(ts.draw_svg(y_axis=True, mutation_labels=mut_labels))
+ts.draw_svg(y_axis=True, mutation_labels=mut_labels)
 ```
 
 There are four mutations in the depiction above,
@@ -553,7 +552,7 @@ Now that it had been turned into a tree sequence, we can plot it:
 
 ```{code-cell} ipython3
 # Plot without mutation labels, for clarity 
-SVG(altered_ts.draw_svg(y_axis=True, y_gridlines=True, mutation_labels={}))
+altered_ts.draw_svg(y_axis=True, y_gridlines=True, mutation_labels={})
 ```
 
 You can see that the new tree sequence has been modified as expected: there is a new
@@ -570,7 +569,7 @@ understand how tables work. We'll build an extremely simple tree sequence, consi
 a single tree that looks like this:
 
 ```{code-cell} ipython3
-SVG(tskit.load("data/construction_example.trees").draw_svg(y_axis=True))
+tskit.load("data/construction_example.trees").draw_svg(y_axis=True)
 ```
 
 Starting with an empty set of tables, we can fill, say, the node information by using
@@ -612,7 +611,7 @@ site_id = tables.sites.add_row(position=500.0, ancestral_state='0')
 tables.mutations.add_row(site=site_id, node=2, derived_state='1')
 ts = tables.tree_sequence()
 print("A hand-built tree sequence!")
-SVG(ts.draw_svg(y_axis=True))
+ts.draw_svg(y_axis=True)
 ```
 
 :::{note}