Python API
Contents
Python API¶
This page documents the full tskit Python API. Brief thematic summaries of common classes and methods are presented first. The Reference documentation section at the end then contains full details which aim to be concise, precise and exhaustive. Note that this may not therefore be the best place to start if you are new to a particular piece of functionality.
Trees and tree sequences¶
The TreeSequence
class represents a sequence of correlated
evolutionary trees along a genome. The Tree
class represents a
single tree in this sequence. These classes are the interfaces used to
interact with the trees and mutational information stored in a tree sequence,
for example as returned from a simulation or inferred from a set of DNA
sequences.
TreeSequence
API¶
General properties¶
String describing the units of the time dimension for this TreeSequence. 

Returns the total number of bytes required to store the data in this tree sequence. 

Returns the sequence length in this tree sequence. 

Returns the time of the oldest root in any of the trees in this tree sequence. 

Returns True if all genome coordinates in this TreeSequence are discrete integer values. 

Returns True if all time coordinates in this TreeSequence are discrete integer values. 

The decoded metadata for this TreeSequence. 

The 

The 
Loading and saving¶
There are several methods for loading data into a TreeSequence
instance. The simplest and most convenient is the use the tskit.load()
function to load a tree sequence file. For small
scale data and debugging, it is often convenient to use the tskit.load_text()
function to read data in the text file format.
The TableCollection.tree_sequence()
function
efficiently creates a TreeSequence
object from a
collection of tables
using the Tables API.
 Load a tree sequence
load
(file, *[, skip_tables, ...])Return a
TreeSequence
instance loaded from the specified file object or path.load_text
(nodes, edges[, sites, mutations, ...])Return a
TreeSequence
instance parsed from tabulated text data contained in the specified filelike objects.Returns a
TreeSequence
instance from the tables defined in thisTableCollection
. Save a tree sequence
TreeSequence.dump
(file_or_path[, ...])Writes the tree sequence to the specified path or file object.
See also
Tree sequences with a single simple topology can also be created from scratch by
generating a Tree
and accessing its
tree_sequence
property.
Obtaining trees¶
The following properties and methods return information about the
trees
that are generated along a tree sequence.
Returns the number of distinct trees in this tree sequence. 


Returns an iterator over the trees in this tree sequence. 

Returns the breakpoints that separate trees along the chromosome, including the two extreme points 0 and L. 

Returns an iterator over the pairs of trees for each distinct interval in the specified pair of tree sequences. 

Returns the first tree in this 

Returns the last tree in this 

Returns the trees in this tree sequence as a list. 

Returns the tree covering the specified genomic location. 

Returns the tree at the specified index. 
Obtaining other objects¶
Various components make up a tree sequence, such as nodes and edges, sites and mutations, and populations and individuals. These can be counted or converted into Python objects using the following classes, properties, and methods.
Tree topology¶
 Nodes
Node
(*args[, metadata_decoder])A node in a tree sequence, corresponding to a single genome.
Returns the number of nodes in this tree sequence.
Returns an iterable sequence of all the nodes in this tree sequence.
TreeSequence.node
(id_)Returns the node in this tree sequence with the specified ID.
Returns the number of sample nodes in this tree sequence.
TreeSequence.samples
([population, ...])Returns an array of the sample node IDs in this tree sequence.
 Edges
Edge
(*args[, metadata_decoder])An edge in a tree sequence.
Returns the number of edges in this tree sequence.
Returns an iterable sequence of all the edges in this tree sequence.
TreeSequence.edge
(id_)Returns the edge in this tree sequence with the specified ID.
Genetic variation¶
 Sites
Site
(*args[, metadata_decoder])A site in a tree sequence.
Returns the number of sites in this tree sequence.
Returns an iterable sequence of all the sites in this tree sequence.
TreeSequence.site
(id_)Returns the site in this tree sequence with the specified ID.
Variant
(site, alleles, genotypes)A variant in a tree sequence, describing the observed genetic variation among samples for a given site.
TreeSequence.variants
(*[, as_bytes, ...])Returns an iterator over the variants (each site with its genotypes and alleles) in this tree sequence.
TreeSequence.genotype_matrix
(*[, ...])Returns an \(m \times n\) numpy array of the genotypes in this tree sequence, where \(m\) is the number of sites and \(n\) the number of samples.
TreeSequence.haplotypes
(*[, ...])Returns an iterator over the strings of haplotypes that result from the trees and mutations in this tree sequence.
TreeSequence.alignments
(*[, ...])Returns an iterator over the full sequence alignments for the samples in this tree sequence.
 Mutations
Mutation
(*args[, metadata_decoder])A mutation in a tree sequence.
Returns the number of mutations in this tree sequence.
Returns an iterator over all the mutations in this tree sequence.
Returns the mutation in this tree sequence with the specified ID.
Demography¶
 Populations
Population
(*args[, metadata_decoder])A population in a tree sequence.
Returns the number of populations in this tree sequence.
Returns an iterable sequence of all the populations in this tree sequence.
Returns the population in this tree sequence with the specified ID.
 Migrations
Migration
(*args[, metadata_decoder])A migration in a tree sequence.
Returns the number of migrations in this tree sequence.
Returns an iterable sequence of all the migrations in this tree sequence.
Returns the migration in this tree sequence with the specified ID.
Other¶
 Individuals
Individual
(*args[, metadata_decoder])An individual in a tree sequence.
Returns the number of individuals in this tree sequence.
Returns an iterable sequence of all the individuals in this tree sequence.
Returns the individual in this tree sequence with the specified ID.
 Provenance entries (also see Provenance)
Provenance
(id, timestamp, record)A provenance entry in a tree sequence, detailing how this tree sequence was generated, or subsequent operations on it (see Provenance).
Returns the number of provenances in this tree sequence.
Returns an iterable sequence of all the provenances in this tree sequence.
Returns the provenance in this tree sequence with the specified ID.
Tree sequence modification¶
Although tree sequences are immutable, several methods will taken an existing tree
sequence and return a modifed version. These are thin wrappers around the
identically named methods of a TableCollection,
which perform the same actions but modify the TableCollection
in place.

Returns a simplified tree sequence that retains only the history of the nodes given in the list 

Returns a tree sequence containing only information directly referencing the provided list of nodes to retain. 

Returns an expanded tree sequence which contains the nodewise union of 

Returns a copy of this tree sequence which includes only information in the specified list of genomic intervals. 

Returns a copy of this tree sequence for which information in the specified list of genomic intervals has been deleted. 

Returns a copy of this tree sequence with the specified sites (and their associated mutations) entirely removed. 

Returns a copy of this tree sequence with any empty regions (i.e., those not covered by any edge) on the right and left trimmed away. 
Identity by descent¶
The TreeSequence.ibd_segments()
method allows us to compute
identity relationships between pairs of samples. See the
Identity by descent section for more details and examples
and the Identity classes section for
API documentation on the associated classes.

Finds pairs of samples that are identical by descent (IBD) and returns the result as an 
Tables¶
The underlying data in a tree sequence is stored in a collection of tables. The following methods give access to tables and associated functionality. Since tables can be modified, this allows tree sequences to be edited: see the Tables and editing tutorial for an introduction.
Returns the 

Returns a modifiable copy of the 

The set of metadata schemas for the tables in this tree sequence. 

Returns a dictionary mapping names to tables in the underlying 
Statistics¶
 Single site
Computes the allele frequency spectrum (AFS) in windows across the genome for with respect to the specified
sample_sets
.TreeSequence.divergence
(sample_sets[, ...])Computes mean genetic divergence between (and within) pairs of sets of nodes from
sample_sets
.TreeSequence.diversity
([sample_sets, ...])Computes mean genetic diversity (also known as "pi") in each of the sets of nodes from
sample_sets
.TreeSequence.f2
(sample_sets[, indexes, ...])Computes Patterson's f3 statistic between two groups of nodes from
sample_sets
.TreeSequence.f3
(sample_sets[, indexes, ...])Computes Patterson's f3 statistic between three groups of nodes from
sample_sets
.TreeSequence.f4
(sample_sets[, indexes, ...])Computes Patterson's f4 statistic between four groups of nodes from
sample_sets
.TreeSequence.Fst
(sample_sets[, indexes, ...])Computes "windowed" Fst between pairs of sets of nodes from
sample_sets
.Return the genealogical nearest neighbours (GNN) proportions for the given focal nodes, with reference to two or more sets of interest, averaged over all trees in the tree sequence.
TreeSequence.genetic_relatedness
(sample_sets)Computes genetic relatedness between (and within) pairs of sets of nodes from
sample_sets
.TreeSequence.general_stat
(W, f, output_dim)Compute a windowed statistic from weights and a summary function.
Computes the density of segregating sites for each of the sets of nodes from
sample_sets
, and related quantities.TreeSequence.sample_count_stat
(sample_sets, ...)Compute a windowed statistic from sample counts and a summary function.
TreeSequence.mean_descendants
(sample_sets)Computes for every node the mean number of samples in each of the sample_sets that descend from that node, averaged over the portions of the genome for which the node is ancestral to any sample.
TreeSequence.Tajimas_D
([sample_sets, ...])Computes Tajima's D of sets of nodes from
sample_sets
in windows.TreeSequence.trait_correlation
(W[, windows, ...])Computes the mean squared correlations between each of the columns of
W
(the "phenotypes") and inheritance along the tree sequence.TreeSequence.trait_covariance
(W[, windows, ...])Computes the mean squared covariances between each of the columns of
W
(the "phenotypes") and inheritance along the tree sequence.TreeSequence.trait_linear_model
(W[, Z, ...])Finds the relationship between trait and genotype after accounting for covariates.
TreeSequence.Y2
(sample_sets[, indexes, ...])Computes the 'Y2' statistic between pairs of sets of nodes from
sample_sets
.TreeSequence.Y3
(sample_sets[, indexes, ...])Computes the 'Y' statistic between triples of sets of nodes from
sample_sets
. Comparative
TreeSequence.kc_distance
(other[, lambda_])Returns the average
Tree.kc_distance()
between pairs of trees along the sequence whose intervals overlap.
Topological analysis¶
The topology of a tree in a tree sequence refers to the relationship among samples ignoring branch lengths. Functionality as described in Topological analysis is mainly provided via methods on trees, but more efficient methods sometimes exist for entire tree sequences:

Returns a generator that produces the same distribution of topologies as 
Display¶

Return an SVG representation of a tree sequence. 

Create a text representation of a tree sequence. 
Return a plain text summary of the contents of a tree sequence 

Return an html summary of a tree sequence. 
Export¶

Return the result of 

Return the result of 

Writes a text representation of the tables underlying the tree sequence to the specified connections. 
Return a macs encoding of this tree sequence. 


Writes the 

Returns a nexus encoding of this tree sequence. 

Writes a VCF formatted file to the specified filelike object. 
Tree
API¶
A tree is an instance of the Tree
class. These trees cannot exist
independently of the TreeSequence
from which they are generated.
Usually, therefore, a Tree
instance is created by
Obtaining trees from an existing tree
sequence (although it is also possible to generate a new instance of a
Tree
belonging to the same tree sequence using Tree.copy()
).
Note
For efficiency, each instance of a Tree
is a statemachine
whose internal state corresponds to one of the trees in the parent tree sequence:
Moving to other trees in the tree sequence does not require a
new instance to be created, but simply the internal state to be changed.
General properties¶
Returns the tree sequence that this tree is from. 

Returns the sum of all the branch lengths in this tree (in units of time). 

Returns the minimum number of samples that a node must be an ancestor of to be considered a potential root. 

The ID of the virtual root in this tree. 

The total number of edges in this tree. 

The number of roots in this tree, as defined in the 





The root of this tree. 

The list of roots in this tree. 

Returns the index this tree occupies in the parent tree sequence. 

Returns the coordinates of the genomic interval that this tree represents the history of. 

Returns the genomic distance that this tree spans. 
Creating new trees¶
It is sometimes useful to create an entirely new tree sequence consisting
of just a single tree (a “onetree sequence”). The follow methods create such an
object and return a Tree
instance corresponding to that tree.
The new tree sequence to which the tree belongs is available through the
tree_sequence
property.
 Creating a new tree
Tree.generate_balanced
(num_leaves, *[, ...])Generate a
Tree
with the specified number of leaves that is maximally balanced.Tree.generate_comb
(num_leaves, *[, span, ...])Generate a
Tree
in which all internal nodes have two children and the left child is a leaf.Tree.generate_random_binary
(num_leaves, *[, ...])Generate a random binary
Tree
with \(n\) =num_leaves
leaves with an equal probability of returning any topology and leaf label permutation among the \((2n  3)! / (2^{n  2} (n  2)!)\) leaflabelled binary trees.Tree.generate_star
(num_leaves, *[, span, ...])Generate a
Tree
whose leaf nodes all have the same parent (i.e., a "star" tree). Creating a new tree from an existing tree
Tree.split_polytomies
(*[, epsilon, method, ...])Return a new
Tree
where extra nodes and edges have been inserted so that any any nodeu
with greater than 2 children  a multifurcation or "polytomy"  is resolved into successive bifurcations.
See also
Tree.unrank()
for creating a new onetree sequence from its
topological rank.
Node measures¶
Often it is useful to access information pertinant to a specific node or set of nodes
but which might also change from tree to tree in the tree sequence. Examples include
the encoding of the tree via parent
, left_child
, etc.
(see Tree structure), the number of samples under a node,
or the most recent common ancestor (MRCA) of two nodes. This sort of information is
available via simple and high performance Tree
methods
Simple measures¶
These return a simple number, or (usually) short list of numbers relevant to a specific node or limited set of nodes.
 Node information
Returns True if the specified node is a sample.
Returns True if the specified node is isolated in this tree: that is it has no parents and no children (note that all isolated nodes in the tree are therefore also
leaves
).Tree.is_leaf
(u)Returns True if the specified node is a leaf.
Returns True if the specified node is not a leaf.
Tree.parent
(u)Returns the parent of the specified node.
Returns the number of children of the specified node (i.e.,
len(tree.children(u))
)Tree.time
(u)Returns the time of the specified node.
Returns the length of the branch (in units of time) joining the specified node to its parent.
Tree.depth
(u)Returns the number of nodes on the path from
u
to a root, not includingu
.Returns the population associated with the specified node.
Returns the sibling node to the right of u, or
tskit.NULL
if u does not have a right sibling.Returns the sibling node to the left of u, or
tskit.NULL
if u does not have a left sibling.Returns the rightmost child of the specified node.
Returns the leftmost child of the specified node.
Returns the children of the specified node
u
as a tuple of integer node IDs. Descendant nodes
Tree.leaves
([u])Returns an iterator over all the leaves in this tree that descend from the specified node.
Tree.samples
([u])Returns an iterator over the numerical IDs of all the sample nodes in this tree that are underneath node
u
.Tree.num_samples
([u])Returns the number of sample nodes in this tree underneath the specified node (including the node itself).
Returns the number of samples in the set specified in the
tracked_samples
parameter of theTreeSequence.trees()
method underneath the specified node. Multiple nodes
Tree.is_descendant
(u, v)Returns True if the specified node u is a descendant of node v and False otherwise.
Tree.mrca
(u, v)Returns the most recent common ancestor of the specified nodes.
Tree.tmrca
(u, v)Returns the time of the most recent common ancestor of the specified nodes. This is equivalent to::.
Array access¶
These all return a numpy array whose length corresponds to the total number of nodes in the tree sequence. They provide direct access to the underlying memory structures, and are thus very efficient, providing a high performance interface which can be used in conjunction with the equivalent traversal methods.
A numpy array (dtype=np.int32) encoding the parent of each node in this tree, such that 

A numpy array (dtype=np.int32) encoding the left child of each node in this tree, such that 

A numpy array (dtype=np.int32) encoding the right child of each node in this tree, such that 

A numpy array (dtype=np.int32) encoding the left sib of each node in this tree, such that 

A numpy array (dtype=np.int32) encoding the right sib of each node in this tree, such that 
Tree traversal¶
Moving around within a tree usually involves visiting the tree nodes in some sort of
order. Often, given a particular order, it is convenient to iterate over each node
using the Tree.nodes()
method. However, for high performance algorithms, it
may be more convenient to access the node indices for a particular order as
an array, and use this, for example, to index into one of the node arrays (see
Visiting nodes).
 Iterator access
Tree.nodes
([root, order])Returns an iterator over the node IDs reachable from the specified node in this tree in the specified traversal order.
 Array access
Tree.postorder
([u])Returns a numpy array of node ids in postorder <https://en.wikipedia.org/wiki/Tree_traversal##Postorder_(LRN)>.
Tree.preorder
([u])Returns a numpy array of node ids in preorder <https://en.wikipedia.org/wiki/Tree_traversal#Preorder_(NLR)>.
Tree.timeasc
([u])Returns a numpy array of node ids.
Tree.timedesc
([u])Returns a numpy array of node ids.
Topological analysis¶
The topology of a tree refers to the simple relationship among samples (i.e. ignoring branch lengths), see Identifying and counting topologies for more details. These methods provide ways to enumerate and count tree topologies.
Briefly, the position of a tree in the enumeration all_trees
can be obtained using
the tree’s rank()
method. Inversely, a Tree
can be constructed
from a position in the enumeration with Tree.unrank()
.
 Methods of a tree
Produce the rank of this tree in the enumeration of all leaflabelled trees of n leaves.
Tree.count_topologies
([sample_sets])Calculates the distribution of embedded topologies for every combination of the sample sets in
sample_sets
. Functions and static methods
Tree.unrank
(num_leaves, rank, *[, span, ...])Reconstruct the tree of the given
rank
(seetskit.Tree.rank()
) withnum_leaves
leaves.all_tree_shapes
(num_leaves[, span])Generates all unique shapes of trees with
num_leaves
leaves.all_tree_labellings
(tree[, span])Generates all unique labellings of the leaves of a
tskit.Tree
.all_trees
(num_leaves[, span])Generates all unique leaflabelled trees with
num_leaves
leaves.
Comparing trees¶

Returns the KendallColijn distance between the specified pair of trees. 
Sites and mutations¶
Returns an iterator over all the sites in this tree. 

Returns the number of sites on this tree. 

Returns an iterator over all the mutations in this tree. 

Returns the total number of mutations across all sites on this tree. 


Given observations for the samples in this tree described by the specified set of genotypes and alleles, return a parsimonious set of state transitions explaining these observations. 
Moving to other trees¶
Seeks to the next tree in the sequence. If the tree is in the initial null state we seek to the first tree (equivalent to calling 

Seeks to the previous tree in the sequence. If the tree is in the initial null state we seek to the last tree (equivalent to calling 

Seeks to the first tree in the sequence. 

Seeks to the last tree in the sequence. 


Sets the state to represent the tree that covers the specified position in the parent tree sequence. 

Sets the state to represent the tree at the specified index in the parent tree sequence. 
Resets this tree back to the initial null state. 
Display¶

Return an SVG representation of a single tree. 

Create a text representation of a tree. 
Return a plain text summary of a tree in a tree sequence 

Return an html summary of a tree in a tree sequence. 
Export¶
Convert tree to dict of dicts for conversion to a networkx graph. 


Returns a newick encoding of this tree. For example, a binary tree with 3 leaves generated by 
Tables and Table Collections¶
The information required to construct a tree sequence is stored in a collection of tables, each defining a different aspect of the structure of a tree sequence. These tables are described individually in the next section. However, these are interrelated, and so many operations work on the entire collection of tables, known as a table collection.
TableCollection
API¶
The TableCollection
and TreeSequence
classes are
deeply related. A TreeSequence
instance is based on the information
encoded in a TableCollection
. Tree sequences are immutable, and
provide methods for obtaining trees from the sequence. A TableCollection
is mutable, and does not have any methods for obtaining trees.
The TableCollection
class thus allows creation and modification of
tree sequences (see the Tables and editing tutorial).
General properties¶
Specific tables in the TableCollection
are be accessed using the plural version of their name, so that, for instance, the
individual table can be accessed using table_collection.individuals
. A table
collection also has other properties containing, for example, number of bytes taken
to store it and the toplevel metadata associated with the tree sequence as a whole.
 Table access
The Individual Table in this collection.
The Node Table in this collection.
The Edge Table in this collection.
The Migration Table in this collection
The Site Table in this collection.
The Mutation Table in this collection.
The Population Table in this collection.
The Provenance Table in this collection.
 Other properties
The UUID for the file this TableCollection is derived from, or None if not derived from a file.
The edge insertion and removal indexes.
Returns the total number of bytes required to store the data in this table collection.
Returns a dictionary mapping table names to the corresponding table instances.
The decoded metadata for this object.
The raw bytes of metadata for this TableCollection
The
tskit.MetadataSchema
for this object.The sequence length defining the coordinate space.
The units used for the time dimension of this TableCollection
Transformation¶
These methods act inplace to transform the contents of a TableCollection
,
either by modifying the underlying tables (removing, editing, or adding to them) or
by adjusting the table collection so that it meets the
Valid tree sequence requirements.
Modification¶
These methods modify the data stored in a TableCollection
. They also have
equivalant TreeSequence versions
(unlike the methods described below those do not operate in place, but rather act in
a functional way, returning a new tree sequence while leaving the original unchanged).

Remove all rows of the data tables, optionally remove provenance, metadata schemas and tslevel metadata. 

Simplifies the tables in place to retain only the information necessary to reconstruct the tree sequence describing the given 

Modifies the tables in place to contain only the entries referring to the provided list of node IDs, with nodes reordered according to the order they appear in the list. 

Delete all information from this set of tables which lies within the specified list of genomic intervals. 

Delete all information from this set of tables which lies outside the specified list of genomic intervals. 

Remove the specified sites entirely from the sites and mutations tables in this collection. 

Trim away any empty regions on the right and left of the tree sequence encoded by these tables. 

Modifies the table collection in place by adding the nonshared portions of 
Creating a valid tree sequence¶
These methods can be used to help reorganise or rationalise the
TableCollection
so that it is in the form
required for
it to be converted
into a TreeSequence
. This may require sorting the tables,
ensuring they are logically consistent, and adding Table indexes.
Note
These methods are not guaranteed to make valid a TableCollection
which is
logically inconsistent, for example if multiple edges have the same child at a
given position on the genome or if nonexistent node IDs are referenced.
 Sorting
TableCollection.sort
([edge_start, ...])Sorts the tables in place.
Sorts the individual table in place, so that parents come before children, and the parent column is remapped as required.
TableCollection.canonicalise
([...])This puts the tables in canonical form  to do this, the individual and population tables are sorted by the first node that refers to each (see
TreeSequence.subset()
) Then, the remaining tables are sorted as insort()
, with the modification that mutations are sorted by site, then time, then number of descendant mutations (ensuring that parent mutations occur before children), then node, then original order in the tables. Logical consistency
Modifies the tables in place, computing the
parent
column of the mutation table.Modifies the tables in place, computing valid values for the
time
column of the mutation table.Modifies the tables in place, removing entries in the site table with duplicate
position
(and keeping only the first entry for each site), and renumbering thesite
column of the mutation table appropriately. Indexing
Returns True if this TableCollection is indexed.
Builds an index on this TableCollection.
Drops any indexes present on this table collection.
Miscellaneous methods¶
Returns a deep copy of this TableCollection. 


Returns True if self and other are equal. 

Returns an 
Export¶
Returns a 


Writes the table collection to the specified path or file object. 
Table APIs¶
Here we outline the table classes and the common methods and variables available for each. For description and definition of each table’s meaning and use, see the table definitions.

A table defining the individuals in a tree sequence. 

A table defining the nodes in a tree sequence. 

A table defining the edges in a tree sequence. 

A table defining the migrations in a tree sequence. 

A table defining the sites in a tree sequence. 

A table defining the mutations in a tree sequence. 

A table defining the populations referred to in a tree sequence. 

A table recording the provenance (i.e., history) of this table, so that the origin of the underlying data and sequence of subsequent operations can be traced. 
Accessing table data¶
The tables API provides an efficient way of working
with and interchanging tree sequence data. Each table class
(e.g, NodeTable
, EdgeTable
, SiteTable
) has a specific set
of columns with fixed types, and a set of methods for setting and getting the data
in these columns. The number of rows in the table t
is given by len(t)
.
import tskit
t = tskit.EdgeTable()
t.add_row(left=0, right=1, parent=10, child=11)
t.add_row(left=1, right=2, parent=9, child=11)
print("The table contains", len(t), "rows")
print(t)
The table contains 2 rows
╔══╤══════════╤══════════╤══════╤═════╤════════╗
║id│left │right │parent│child│metadata║
╠══╪══════════╪══════════╪══════╪═════╪════════╣
║0 │0.00000000│1.00000000│ 10│ 11│ b''║
║1 │1.00000000│2.00000000│ 9│ 11│ b''║
╚══╧══════════╧══════════╧══════╧═════╧════════╝
Each table supports accessing the data either by row or column. To access the data in a column, we can use standard attribute access which will return a copy of the column data as a numpy array:
t.left
array([0., 1.])
t.parent
array([10, 9], dtype=int32)
To access the data in a row, say row number j
in table t
, simply use t[j]
:
t[0]
EdgeTableRow(left=0.0, right=1.0, parent=10, child=11, metadata=b'')
This also works as expected with negative j
, counting rows from the end of the table
t[1]
EdgeTableRow(left=1.0, right=2.0, parent=9, child=11, metadata=b'')
The returned row has attributes allowing contents to be accessed by name, e.g.
site_table[0].position
, site_table[0].ancestral_state
, site_table[0].metadata
etc.:
t[1].right
2.0
Row attributes cannot be modified directly. Instead, the replace
method of a row
object can be used to create a new row with one or more changed column
values, which can then be used to replace the original. For example:
t[1] = t[1].replace(child=4, right=3)
print(t)
╔══╤══════════╤══════════╤══════╤═════╤════════╗
║id│left │right │parent│child│metadata║
╠══╪══════════╪══════════╪══════╪═════╪════════╣
║0 │0.00000000│1.00000000│ 10│ 11│ b''║
║1 │1.00000000│3.00000000│ 9│ 4│ b''║
╚══╧══════════╧══════════╧══════╧═════╧════════╝
Tables also support the pickle
protocol, and so can be easily serialised and
deserialised. This can be useful, for example, when performing parallel computations
using the multiprocessing
module (however, pickling will not be as efficient
as storing tables in the native format).
import pickle
serialised = pickle.dumps(t)
t2 = pickle.loads(serialised)
print(t2)
╔══╤══════════╤══════════╤══════╤═════╤════════╗
║id│left │right │parent│child│metadata║
╠══╪══════════╪══════════╪══════╪═════╪════════╣
║0 │0.00000000│1.00000000│ 10│ 11│ b''║
║1 │1.00000000│3.00000000│ 9│ 4│ b''║
╚══╧══════════╧══════════╧══════╧═════╧════════╝
Tables support the equality operator ==
based on the data
held in the columns:
t == t2
True
t is t2
False
t2.add_row(0, 1, 2, 3)
print(t2)
t == t2
╔══╤══════════╤══════════╤══════╤═════╤════════╗
║id│left │right │parent│child│metadata║
╠══╪══════════╪══════════╪══════╪═════╪════════╣
║0 │0.00000000│1.00000000│ 10│ 11│ b''║
║1 │1.00000000│3.00000000│ 9│ 4│ b''║
║2 │0.00000000│1.00000000│ 2│ 3│ b''║
╚══╧══════════╧══════════╧══════╧═════╧════════╝
False
Todo
Move some or all of these examples into a suitable alternative chapter.
Text columns¶
As described in the Encoding ragged columns, working with variable length columns is somewhat more involved. Columns encoding text data store the encoded bytes of the flattened strings, and the offsets into this column in two separate arrays.
Consider the following example:
t = tskit.SiteTable()
t.add_row(0, "A")
t.add_row(1, "BB")
t.add_row(2, "")
t.add_row(3, "CCC")
print(t)
print(t[0])
print(t[1])
print(t[2])
print(t[3])
╔══╤══════════╤═══════════════╤════════╗
║id│position │ancestral_state│metadata║
╠══╪══════════╪═══════════════╪════════╣
║0 │0.00000000│ A│ b''║
║1 │1.00000000│ BB│ b''║
║2 │2.00000000│ │ b''║
║3 │3.00000000│ CCC│ b''║
╚══╧══════════╧═══════════════╧════════╝
SiteTableRow(position=0.0, ancestral_state='A', metadata=b'')
SiteTableRow(position=1.0, ancestral_state='BB', metadata=b'')
SiteTableRow(position=2.0, ancestral_state='', metadata=b'')
SiteTableRow(position=3.0, ancestral_state='CCC', metadata=b'')
Here we create a SiteTable
and add four rows, each with a different
ancestral_state
. We can then access this information from each
row in a straightforward manner. Working with columns of text data
is a little trickier, however:
print(t.ancestral_state)
print(t.ancestral_state_offset)
[65 66 66 67 67 67]
[0 1 3 3 6]
tskit.unpack_strings(t.ancestral_state, t.ancestral_state_offset)
['A', 'BB', '', 'CCC']
Here, the ancestral_state
array is the UTF8 encoded bytes of the flattened
strings, and the ancestral_state_offset
is the offset into this array
for each row. The tskit.unpack_strings()
function, however, is a convient
way to recover the original strings from this encoding. We can also use the
tskit.pack_strings()
to insert data using this approach:
a, off = tskit.pack_strings(["0", "12", ""])
t.set_columns(position=[0, 1, 2], ancestral_state=a, ancestral_state_offset=off)
print(t)
╔══╤══════════╤═══════════════╤════════╗
║id│position │ancestral_state│metadata║
╠══╪══════════╪═══════════════╪════════╣
║0 │0.00000000│ 0│ b''║
║1 │1.00000000│ 12│ b''║
║2 │2.00000000│ │ b''║
╚══╧══════════╧═══════════════╧════════╝
When inserting many rows with standard infinite sites mutations (i.e.,
ancestral state is “0”), it is more efficient to construct the
numpy arrays directly than to create a list of strings and use
pack_strings()
. When doing this, it is important to note that
it is the encoded byte values that are stored; by default, we
use UTF8 (which corresponds to ASCII for simple printable characters).:
import numpy as np
t_s = tskit.SiteTable()
m = 10
a = ord("0") + np.zeros(m, dtype=np.int8)
off = np.arange(m + 1, dtype=np.uint32)
t_s.set_columns(position=np.arange(m), ancestral_state=a, ancestral_state_offset=off)
print(t_s)
print("ancestral state data", t_s.ancestral_state)
print("ancestral state offsets", t_s.ancestral_state_offset)
╔══╤══════════╤═══════════════╤════════╗
║id│position │ancestral_state│metadata║
╠══╪══════════╪═══════════════╪════════╣
║0 │0.00000000│ 0│ b''║
║1 │1.00000000│ 0│ b''║
║2 │2.00000000│ 0│ b''║
║3 │3.00000000│ 0│ b''║
║4 │4.00000000│ 0│ b''║
║5 │5.00000000│ 0│ b''║
║6 │6.00000000│ 0│ b''║
║7 │7.00000000│ 0│ b''║
║8 │8.00000000│ 0│ b''║
║9 │9.00000000│ 0│ b''║
╚══╧══════════╧═══════════════╧════════╝
ancestral state data [48 48 48 48 48 48 48 48 48 48]
ancestral state offsets [ 0 1 2 3 4 5 6 7 8 9 10]
In the mutation table, the derived state of each mutation can be handled similarly:
t_m = tskit.MutationTable()
site = np.arange(m, dtype=np.int32)
d, off = tskit.pack_strings(["1"] * m)
node = np.zeros(m, dtype=np.int32)
t_m.set_columns(site=site, node=node, derived_state=d, derived_state_offset=off)
print(t_m)
╔══╤════╤════╤════╤═════════════╤══════╤════════╗
║id│site│node│time│derived_state│parent│metadata║
╠══╪════╪════╪════╪═════════════╪══════╪════════╣
║0 │ 0│ 0│ nan│ 1│ 1│ b''║
║1 │ 1│ 0│ nan│ 1│ 1│ b''║
║2 │ 2│ 0│ nan│ 1│ 1│ b''║
║3 │ 3│ 0│ nan│ 1│ 1│ b''║
║4 │ 4│ 0│ nan│ 1│ 1│ b''║
║5 │ 5│ 0│ nan│ 1│ 1│ b''║
║6 │ 6│ 0│ nan│ 1│ 1│ b''║
║7 │ 7│ 0│ nan│ 1│ 1│ b''║
║8 │ 8│ 0│ nan│ 1│ 1│ b''║
║9 │ 9│ 0│ nan│ 1│ 1│ b''║
╚══╧════╧════╧════╧═════════════╧══════╧════════╝
Todo
Move some or all of these examples into a suitable alternative chapter.
Binary columns¶
Columns storing binary data take the same approach as
Text columns to encoding
variable length data.
The difference between the two is only raw bytes
values are accepted: no
character encoding or decoding is done on the data. Consider the following example
where a table has no metadata_schema
such that arbitrary bytes can be stored and
no automatic encoding or decoding of objects is performed by the Python API and we can
store and retrieve raw bytes
. (See Metadata for details):
Below, we add two rows to a NodeTable
, with different
metadata. The first row contains a simple
byte string, and the second contains a Python dictionary serialised using
pickle
.
t = tskit.NodeTable()
t.add_row(metadata=b"these are raw bytes")
t.add_row(metadata=pickle.dumps({"x": 1.1}))
print(t)
╔══╤═════╤══════════╤══════════╤══════════╤════════════════════════════════════════╗
║id│flags│population│individual│time │metadata ║
╠══╪═════╪══════════╪══════════╪══════════╪════════════════════════════════════════╣
║0 │ 0│ 1│ 1│0.00000000│ b'these are raw bytes'║
║1 │ 0│ 1│ 1│0.00000000│b'\x80\x04\x95\x11\x00\x00\x00\x00\x0...║
╚══╧═════╧══════════╧══════════╧══════════╧════════════════════════════════════════╝
Note that the pickled dictionary is encoded in 24 bytes containing unprintable characters. It appears to be unrelated to the original contents, because the binary data is base64 encoded to ensure that it is printsafe (and doesn’t break your terminal). (See the Metadata section for more information on the use of base64 encoding.).
We can access the metadata in a row (e.g., t[0].metadata
) which returns a Python
bytes object containing precisely the bytes that were inserted.
print(t[0].metadata)
print(t[1].metadata)
b'these are raw bytes'
b'\x80\x04\x95\x11\x00\x00\x00\x00\x00\x00\x00}\x94\x8c\x01x\x94G?\xf1\x99\x99\x99\x99\x99\x9as.'
The metadata containing the pickled dictionary can be unpickled using
pickle.loads()
:
print(pickle.loads(t[1].metadata))
{'x': 1.1}
As previously, the replace
method can be used to change the metadata,
by overwriting an existing row with an updated one:
t[0] = t[0].replace(metadata=b"different raw bytes")
print(t)
╔══╤═════╤══════════╤══════════╤══════════╤════════════════════════════════════════╗
║id│flags│population│individual│time │metadata ║
╠══╪═════╪══════════╪══════════╪══════════╪════════════════════════════════════════╣
║0 │ 0│ 1│ 1│0.00000000│ b'different raw bytes'║
║1 │ 0│ 1│ 1│0.00000000│b'\x80\x04\x95\x11\x00\x00\x00\x00\x0...║
╚══╧═════╧══════════╧══════════╧══════════╧════════════════════════════════════════╝
Finally, when we print the metadata
column, we see the raw byte values
encoded as signed integers. As for Text columns,
the metadata_offset
column encodes the offsets into this array. So, we
see that the first metadata value is 9 bytes long and the second is 24.
print(t.metadata)
print(t.metadata_offset)
[ 100 105 102 102 101 114 101 110 116 32 114 97 119 32
98 121 116 101 115 128 4 107 17 0 0 0 0 0
0 0 125 108 116 1 120 108 71 63 15 103 103 103
103 103 102 115 46]
[ 0 19 47]
The tskit.pack_bytes()
and tskit.unpack_bytes()
functions are
also useful for encoding data in these columns.
Todo
Move some or all of these examples into a suitable alternative chapter.
Table functions¶

Parse the specified filelike object containing a whitespace delimited description of a node table and returns the corresponding 

Parse the specified filelike object containing a whitespace delimited description of a edge table and returns the corresponding 

Parse the specified filelike object containing a whitespace delimited description of a site table and returns the corresponding 

Parse the specified filelike object containing a whitespace delimited description of a mutation table and returns the corresponding 

Parse the specified filelike object containing a whitespace delimited description of an individual table and returns the corresponding 

Parse the specified filelike object containing a whitespace delimited description of a population table and returns the corresponding 

Packs the specified list of strings into a flattened numpy array of 8 bit integers and corresponding offsets using the specified text encoding. 

Unpacks a list of strings from the specified numpy arrays of packed byte data and corresponding offsets using the specified text encoding. 

Packs the specified list of bytes into a flattened numpy array of 8 bit integers and corresponding offsets. 

Unpacks a list of bytes from the specified numpy arrays of packed byte data and corresponding offsets. 
Metadata API¶
The metadata
module provides validation, encoding and decoding of metadata
using a schema. See Metadata, Python Metadata API Overview and
Working with Metadata.

Class for validating, encoding and decoding metadata. 

Register a metadata codec class. 
See also
Refer to the top level metadatarelated properties of TreeSequences and TableCollections,
such as TreeSequence.metadata
and TreeSequence.metadata_schema
. Also the
metadata fields of
objects accessed through
the TreeSequence
API.
Provenance¶
We provide some preliminary support for validating JSON documents against the provenance schema. Programmatic access to provenance information is planned for future versions.

Validates the specified dictlike object against the tskit provenance schema. 
Utility functions¶
Miscellaneous toplevel utility functions.

As the default unknown mutation time ( 

Returns a random string of nucleotides of the specified length. 
Reference documentation¶
Constants¶
The following constants are used throughout the tskit
API.
 tskit.NULL = 1¶
Special reserved value representing a null ID.
 tskit.MISSING_DATA = 1¶
Special value representing missing data in a genotype array
 tskit.NODE_IS_SAMPLE = 1¶
Node flag value indicating that it is a sample.
 tskit.FORWARD = 1¶
Constant representing the forward direction of travel (i.e., increasing genomic coordinate values).
 tskit.REVERSE = 1¶
Constant representing the reverse direction of travel (i.e., decreasing genomic coordinate values).
 tskit.ALLELES_01 = ('0', '1')¶
The allele mapping where the strings “0” and “1” map to genotype values 0 and 1.
 tskit.ALLELES_ACGT = ('A', 'C', 'G', 'T')¶
The allele mapping where the four nucleotides A, C, G and T map to the genotype integers 0, 1, 2, and 3, respectively.
 tskit.UNKNOWN_TIME = nan¶
Special NAN value used to indicate unknown mutation times. Since this is a NAN value, you cannot use == to test for it. Use
is_unknown_time()
instead.
 tskit.TIME_UNITS_UNKNOWN = 'unknown'¶
Default value of ts.time_units
 tskit.TIME_UNITS_UNCALIBRATED = 'uncalibrated'¶
ts.time_units value when dimension is uncalibrated
Exceptions¶
 exception tskit.MetadataEncodingError[source]¶
A metadata object was of a type that could not be encoded
 exception tskit.MetadataSchemaValidationError[source]¶
A metadata schema object did not validate against the metaschema.
Toplevel functions¶
 tskit.all_trees(num_leaves, span=1)[source]¶
Generates all unique leaflabelled trees with
num_leaves
leaves. See Identifying and counting topologies on the details of this enumeration. The leaf labels are selected from the set[0, num_leaves)
. The times and labels on internal nodes are chosen arbitrarily. Parameters
 Return type
 tskit.all_tree_shapes(num_leaves, span=1)[source]¶
Generates all unique shapes of trees with
num_leaves
leaves. Parameters
 Return type
 tskit.all_tree_labellings(tree, span=1)[source]¶
Generates all unique labellings of the leaves of a
tskit.Tree
. Leaves are labelled from the set[0, n)
wheren
is the number of leaves oftree
. Parameters
tree (tskit.Tree) – The tree used to generate labelled trees of the same shape.
span (float) – The genomic span of each returned tree.
 Return type
 tskit.is_unknown_time(time)[source]¶
As the default unknown mutation time (
UNKNOWN_TIME
) is a specific NAN value, equality always fails (A NAN value is not equal to itself by definition). This method compares the bitfield such that unknown times can be detected. Either single floats can be passed or lists/arrays.Note that NANs are a set of floatingpoint values. tskit.UNKNOWN_TIME is a specific value in this set. np.nan is a differing value, but both are NAN. See https://en.wikipedia.org/wiki/NaN
This function only returns true for
tskit.is_unknown_time(tskit.UNKNOWN_TIME)
and will return false fortskit.is_unknown_time(np.nan)
or any other NAN or nonNAN value. Parameters
time (Union[float, arraylike]) – Value or array to check.
 Returns
A single boolean or array of booleans the same shape as
time
. Return type
Union[bool, numpy.ndarray[bool]]
 tskit.load(file, *, skip_tables=False, skip_reference_sequence=False)[source]¶
Return a
TreeSequence
instance loaded from the specified file object or path. The file must be in the tree sequence file format produced by theTreeSequence.dump()
method.Warning
With any of the
skip_tables
orskip_reference_sequence
options set, it is not possible to load data from a nonseekable stream (e.g. a socket or STDIN) of multiple tree sequences using consecutive calls totskit.load()
. Parameters
file (str) – The file object or path of the
.trees
file containing the tree sequence we wish to load.skip_tables (bool) – If True, no tables are read from the
.trees
file and only the toplevel information is populated in the tree sequence object.skip_reference_sequence (bool) – If True, the tree sequence is read without loading its reference sequence.
 Returns
The tree sequence object containing the information stored in the specified file path.
 Return type
 tskit.load_text(nodes, edges, sites=None, mutations=None, individuals=None, populations=None, sequence_length=0, strict=True, encoding='utf8', base64_metadata=True)[source]¶
Return a
TreeSequence
instance parsed from tabulated text data contained in the specified filelike objects. The format for these files is documented in the Text file formats section, and is produced by theTreeSequence.dump_text()
method. Further properties required for an input tree sequence are described in the Valid tree sequence requirements section. This method is intended as a convenient interface for importing external data into tskit; the binary file format using bytskit.load()
is many times more efficient than this text format.The
nodes
andedges
parameters are mandatory and must be filelike objects containing text with whitespace delimited columns, parsable byparse_nodes()
andparse_edges()
, respectively.sites
,mutations
,individuals
andpopulations
are optional, and must be parsable byparse_sites()
,parse_individuals()
,parse_populations()
, andparse_mutations()
, respectively. For convenience, if the node table refers to populations, but thepopulations
parameter is not provided, a minimal set of rows are added to the population table, so that a valid tree sequence can be returned.The
sequence_length
parameter determines theTreeSequence.sequence_length
of the returned tree sequence. If it is 0 or not specified, the value is taken to be the maximum right coordinate of the input edges. This parameter is useful in degenerate situations (such as when there are zero edges), but can usually be ignored.The
strict
parameter controls the field delimiting algorithm that is used. Ifstrict
is True (the default), we require exactly one tab character separating each field. Ifstrict
is False, a more relaxed whitespace delimiting algorithm is used, such that any run of whitespace is regarded as a field separator. In most situations,strict=False
is more convenient, but it can lead to error in certain situations. For example, if a deletion is encoded in the mutation table this will not be parseable whenstrict=False
.After parsing the tables,
TableCollection.sort()
is called to ensure that the loaded tables satisfy the tree sequence ordering requirements. Note that this may result in the IDs of various entities changing from their positions in the input file. Parameters
nodes (io.TextIOBase) – The filelike object containing text describing a
NodeTable
.edges (io.TextIOBase) – The filelike object containing text describing an
EdgeTable
.sites (io.TextIOBase) – The filelike object containing text describing a
SiteTable
.mutations (io.TextIOBase) – The filelike object containing text describing a
MutationTable
.individuals (io.TextIOBase) – The filelike object containing text describing a
IndividualTable
.populations (io.TextIOBase) – The filelike object containing text describing a
PopulationTable
.sequence_length (float) – The sequence length of the returned tree sequence. If not supplied or zero this will be inferred from the set of edges.
strict (bool) – If True, require strict tab delimiting (default). If False, a relaxed whitespace splitting algorithm is used.
encoding (str) – Encoding used for text representation.
base64_metadata (bool) – If True, metadata is encoded using Base64 encoding; otherwise, as plain text.
 Returns
The tree sequence object containing the information stored in the specified file paths.
 Return type
 tskit.pack_bytes(data)[source]¶
Packs the specified list of bytes into a flattened numpy array of 8 bit integers and corresponding offsets. See Encoding ragged columns for details of this encoding.
 Parameters
 Returns
The tuple (packed, offset) of numpy arrays representing the flattened input data and offsets.
 Return type
numpy.ndarray (dtype=np.int8), numpy.ndarray (dtype=np.uint32)
 tskit.pack_strings(strings, encoding='utf8')[source]¶
Packs the specified list of strings into a flattened numpy array of 8 bit integers and corresponding offsets using the specified text encoding. See Encoding ragged columns for details of this encoding of columns of variable length data.
 Parameters
 Returns
The tuple (packed, offset) of numpy arrays representing the flattened input data and offsets.
 Return type
numpy.ndarray (dtype=np.int8), numpy.ndarray (dtype=np.uint32)
 tskit.parse_edges(source, strict=True, table=None)[source]¶
Parse the specified filelike object containing a whitespace delimited description of a edge table and returns the corresponding
EdgeTable
instance. See the edge text format section for the details of the required format and the edge table definition section for the required properties of the contents.See
tskit.load_text()
for a detailed explanation of thestrict
parameter. Parameters
source (io.TextIOBase) – The filelike object containing the text.
strict (bool) – If True, require strict tab delimiting (default). If False, a relaxed whitespace splitting algorithm is used.
table (EdgeTable) – If specified, write the edges into this table. If not, create a new
EdgeTable
instance and return.
 tskit.parse_individuals(source, strict=True, encoding='utf8', base64_metadata=True, table=None)[source]¶
Parse the specified filelike object containing a whitespace delimited description of an individual table and returns the corresponding
IndividualTable
instance. See the individual text format section for the details of the required format and the individual table definition section for the required properties of the contents.See
tskit.load_text()
for a detailed explanation of thestrict
parameter. Parameters
source (io.TextIOBase) – The filelike object containing the text.
strict (bool) – If True, require strict tab delimiting (default). If False, a relaxed whitespace splitting algorithm is used.
encoding (str) – Encoding used for text representation.
base64_metadata (bool) – If True, metadata is encoded using Base64 encoding; otherwise, as plain text.
table (IndividualTable) – If specified write into this table. If not, create a new
IndividualTable
instance.
 tskit.parse_mutations(source, strict=True, encoding='utf8', base64_metadata=True, table=None)[source]¶
Parse the specified filelike object containing a whitespace delimited description of a mutation table and returns the corresponding
MutationTable
instance. See the mutation text format section for the details of the required format and the mutation table definition section for the required properties of the contents. Note that if thetime
column is missing its entries are filled withUNKNOWN_TIME
.See
tskit.load_text()
for a detailed explanation of thestrict
parameter. Parameters
source (io.TextIOBase) – The filelike object containing the text.
strict (bool) – If True, require strict tab delimiting (default). If False, a relaxed whitespace splitting algorithm is used.
encoding (str) – Encoding used for text representation.
base64_metadata (bool) – If True, metadata is encoded using Base64 encoding; otherwise, as plain text.
table (MutationTable) – If specified, write mutations into this table. If not, create a new
MutationTable
instance.
 tskit.parse_nodes(source, strict=True, encoding='utf8', base64_metadata=True, table=None)[source]¶
Parse the specified filelike object containing a whitespace delimited description of a node table and returns the corresponding
NodeTable
instance. See the node text format section for the details of the required format and the node table definition section for the required properties of the contents.See
tskit.load_text()
for a detailed explanation of thestrict
parameter. Parameters
source (io.TextIOBase) – The filelike object containing the text.
strict (bool) – If True, require strict tab delimiting (default). If False, a relaxed whitespace splitting algorithm is used.
encoding (str) – Encoding used for text representation.
base64_metadata (bool) – If True, metadata is encoded using Base64 encoding; otherwise, as plain text.
table (NodeTable) – If specified write into this table. If not, create a new
NodeTable
instance.
 tskit.parse_populations(source, strict=True, encoding='utf8', base64_metadata=True, table=None)[source]¶
Parse the specified filelike object containing a whitespace delimited description of a population table and returns the corresponding
PopulationTable
instance. See the population text format section for the details of the required format and the population table definition section for the required properties of the contents.See
tskit.load_text()
for a detailed explanation of thestrict
parameter. Parameters
source (io.TextIOBase) – The filelike object containing the text.
strict (bool) – If True, require strict tab delimiting (default). If False, a relaxed whitespace splitting algorithm is used.
encoding (str) – Encoding used for text representation.
base64_metadata (bool) – If True, metadata is encoded using Base64 encoding; otherwise, as plain text.
table (PopulationTable) – If specified write into this table. If not, create a new
PopulationTable
instance.
 tskit.parse_sites(source, strict=True, encoding='utf8', base64_metadata=True, table=None)[source]¶
Parse the specified filelike object containing a whitespace delimited description of a site table and returns the corresponding
SiteTable
instance. See the site text format section for the details of the required format and the site table definition section for the required properties of the contents.See
tskit.load_text()
for a detailed explanation of thestrict
parameter. Parameters
source (io.TextIOBase) – The filelike object containing the text.
strict (bool) – If True, require strict tab delimiting (default). If False, a relaxed whitespace splitting algorithm is used.
encoding (str) – Encoding used for text representation.
base64_metadata (bool) – If True, metadata is encoded using Base64 encoding; otherwise, as plain text.
table (SiteTable) – If specified write site into this table. If not, create a new
SiteTable
instance.
 tskit.random_nucleotides(length, *, seed=None)[source]¶
Returns a random string of nucleotides of the specified length. Characters are drawn uniformly from the alphabet “ACTG”.
 tskit.register_metadata_codec(codec_cls, codec_id)[source]¶
Register a metadata codec class. This function maintains a mapping from metadata codec identifiers used in schemas to codec classes. When a codec class is registered, it will replace any class previously registered under the same codec identifier, if present.
 Parameters
codec_id (str) – String to use to refer to the codec in the schema.
 tskit.validate_provenance(provenance)[source]¶
Validates the specified dictlike object against the tskit provenance schema. If the input does not represent a valid instance of the schema an exception is raised.
 Parameters
provenance (dict) – The dictionary representing a JSON document to be validated against the schema.
 Raises
 tskit.unpack_bytes(packed, offset)[source]¶
Unpacks a list of bytes from the specified numpy arrays of packed byte data and corresponding offsets. See Encoding ragged columns for details of this encoding.
 Parameters
packed (numpy.ndarray) – The flattened array of byte values.
offset (numpy.ndarray) – The array of offsets into the
packed
array.
 Returns
The list of bytes values unpacked from the parameter arrays.
 Return type
 tskit.unpack_strings(packed, offset, encoding='utf8')[source]¶
Unpacks a list of strings from the specified numpy arrays of packed byte data and corresponding offsets using the specified text encoding. See Encoding ragged columns for details of this encoding of columns of variable length data.
 Parameters
packed (numpy.ndarray) – The flattened array of byte values.
offset (numpy.ndarray) – The array of offsets into the
packed
array.encoding (str) – The text encoding to use when converting string data to bytes. See the
codecs
module for information on available string encodings.
 Returns
The list of strings unpacked from the parameter arrays.
 Return type
Tree and tree sequence classes¶
The Tree
class¶
Also see the Tree API summary.
 class tskit.Tree[source]¶
A single tree in a
TreeSequence
. Please see the Processing trees section for information on how efficiently access trees sequentially or obtain a list of individual trees in a tree sequence.The
sample_lists
parameter controls the features that are enabled for this tree. Ifsample_lists
is True a more efficient algorithm is used in theTree.samples()
method.The
tracked_samples
parameter can be used to efficiently count the number of samples in a given set that exist in a particular subtree using theTree.num_tracked_samples()
method.The
Tree
class is a statemachine which has a state corresponding to each of the trees in the parent tree sequence. We transition between these states by using the seek functions likeTree.first()
,Tree.last()
,Tree.seek()
andTree.seek_index()
. There is one more state, the socalled “null” or “cleared” state. This is the state that aTree
is in immediately after initialisation; it has an index of 1, and no edges. We can also enter the null state by callingTree.next()
on the last tree in a sequence, callingTree.prev()
on the first tree in a sequence or calling calling theTree.clear()
method at any time.The highlevel TreeSequence seeking and iterations methods (e.g,
TreeSequence.trees()
) are built on these lowlevel statemachine seek operations. We recommend these higher level operations for most users. Parameters
tree_sequence (TreeSequence) – The parent tree sequence.
tracked_samples (list) – The list of samples to be tracked and counted using the
Tree.num_tracked_samples()
method.sample_lists (bool) – If True, provide more efficient access to the samples beneath a give node using the
Tree.samples()
method.root_threshold (int) – The minimum number of samples that a node must be ancestral to for it to be in the list of roots. By default this is 1, so that isolated samples (representing missing data) are roots. To efficiently restrict the roots of the tree to those subtending meaningful topology, set this to 2. This value is only relevant when trees have multiple roots.
sample_counts (bool) – Deprecated since 0.2.4.
 copy()[source]¶
Returns a deep copy of this tree. The returned tree will have identical state to this tree.
 Returns
A copy of this tree.
 Return type
 property tree_sequence¶
Returns the tree sequence that this tree is from.
 Returns
The parent tree sequence for this tree.
 Return type
 property root_threshold¶
Returns the minimum number of samples that a node must be an ancestor of to be considered a potential root.
 Returns
The root threshold.
 Return type
 first()[source]¶
Seeks to the first tree in the sequence. This can be called whether the tree is in the null state or not.
 last()[source]¶
Seeks to the last tree in the sequence. This can be called whether the tree is in the null state or not.
 next()[source]¶
Seeks to the next tree in the sequence. If the tree is in the initial null state we seek to the first tree (equivalent to calling
first()
). Callingnext
on the last tree in the sequence results in the tree being cleared back into the null initial state (equivalent to callingclear()
). The return value of the function indicates whether the tree is in a nonnull state, and can be used to loop over the trees:# Iterate over the trees from lefttoright tree = tskit.Tree(tree_sequence) while tree.next() # Do something with the tree. print(tree.index) # tree is now back in the null state.
 Returns
True if the tree has been transformed into one of the trees in the sequence; False if the tree has been transformed into the null state.
 Return type
 prev()[source]¶
Seeks to the previous tree in the sequence. If the tree is in the initial null state we seek to the last tree (equivalent to calling
last()
). Callingprev
on the first tree in the sequence results in the tree being cleared back into the null initial state (equivalent to callingclear()
). The return value of the function indicates whether the tree is in a nonnull state, and can be used to loop over the trees:# Iterate over the trees from righttoleft tree = tskit.Tree(tree_sequence) while tree.prev() # Do something with the tree. print(tree.index) # tree is now back in the null state.
 Returns
True if the tree has been transformed into one of the trees in the sequence; False if the tree has been transformed into the null state.
 Return type
 clear()[source]¶
Resets this tree back to the initial null state. Calling this method on a tree already in the null state has no effect.
 seek_index(index)[source]¶
Sets the state to represent the tree at the specified index in the parent tree sequence. Negative indexes following the standard Python conventions are allowed, i.e.,
index=1
will seek to the last tree in the sequence.Warning
The current implementation of this operation is linear in the number of trees, so may be inefficient for large tree sequences. See this issue for more information.
 Parameters
index (int) – The tree index to seek to.
 Raises
IndexError – If an index outside the acceptable range is provided.
 seek(position)[source]¶
Sets the state to represent the tree that covers the specified position in the parent tree sequence. After a successful return of this method we have
tree.interval.left
<=position
<tree.interval.right
.Warning
The current implementation of this operation is linear in the number of trees, so may be inefficient for large tree sequences. See this issue for more information.
 Parameters
position (float) – The position along the sequence length to seek to.
 Raises
ValueError – If 0 < position or position >=
TreeSequence.sequence_length
.
 rank()[source]¶
Produce the rank of this tree in the enumeration of all leaflabelled trees of n leaves. See the Interpreting Tree Ranks section for details on ranking and unranking trees.
 Return type
 Raises
ValueError – If the tree has multiple roots.
 static unrank(num_leaves, rank, *, span=1, branch_length=1)[source]¶
Reconstruct the tree of the given
rank
(seetskit.Tree.rank()
) withnum_leaves
leaves. The labels and times of internal nodes are assigned by a postorder traversal of the nodes, such that the time of each internal node is the maximum time of its children plus the specifiedbranch_length
. The time of each leaf is 0.See the Interpreting Tree Ranks section for details on ranking and unranking trees and what constitutes valid ranks.
 Parameters
num_leaves (int) – The number of leaves of the tree to generate.
span (float) – The genomic span of the returned tree. The tree will cover the interval \([0, \text{span})\) and the
tree_sequence
from which the tree is taken will have itssequence_length
equal tospan
.
 Param
float branch_length: The minimum length of a branch in this tree.
 Return type
 Raises
ValueError: If the given rank is out of bounds for trees with
num_leaves
leaves.
 count_topologies(sample_sets=None)[source]¶
Calculates the distribution of embedded topologies for every combination of the sample sets in
sample_sets
.sample_sets
defaults to all samples in the tree grouped by population.sample_sets
need not include all samples but must be pairwise disjoint.The returned object is a
tskit.TopologyCounter
that contains counts of topologies per combination of sample sets. For example,>>> topology_counter = tree.count_topologies() >>> rank, count = topology_counter[0, 1, 2].most_common(1)[0]
produces the most common tree topology, with populations 0, 1 and 2 as its tips, according to the genealogies of those populations’ samples in this tree.
The counts for each topology in the
tskit.TopologyCounter
are absolute counts that we would get if we were to select all combinations of samples from the relevant sample sets. For sample sets \([s_0, s_1, ..., s_n]\), the total number of topologies for those sample sets is equal to \(s_0 * s_1 * ... * s_n\), so the counts in the countertopology_counter[0, 1, ..., n]
should sum to \(s_0 * s_1 * ... * s_n\).To convert the topology counts to probabilities, divide by the total possible number of sample combinations from the sample sets in question:
>>> set_sizes = [len(sample_set) for sample_set in sample_sets] >>> p = count / (set_sizes[0] * set_sizes[1] * set_sizes[2])
Warning
The interface for this method is preliminary and may be subject to backwards incompatible changes in the near future.
 Parameters
sample_sets (list) – A list of lists of Node IDs, specifying the groups of nodes to compute the statistic with. Defaults to all samples grouped by population.
 Return type
 Raises
ValueError – If nodes in
sample_sets
are invalid or are internal samples.
 branch_length(u)[source]¶
Returns the length of the branch (in units of time) joining the specified node to its parent. This is equivalent to
>>> tree.time(tree.parent(u))  tree.time(u)
The branch length for a node that has no parent (e.g., a root) is defined as zero.
Note that this is not related to the property .length which is a deprecated alias for the genomic
span
covered by a tree.
 property total_branch_length¶
Returns the sum of all the branch lengths in this tree (in units of time). This is equivalent to
>>> sum(tree.branch_length(u) for u in tree.nodes())
Note that the branch lengths for root nodes are defined as zero.
As this is defined by a traversal of the tree, technically we return the sum of all branch lengths that are reachable from roots. Thus, this is the total length of all branches that are connected to at least one sample. This distinction is only important in tree sequences that contain ‘dead branches’, i.e., those that define topology that is not connected to a tree root (see Dead leaves and branches)
 Returns
The sum of lengths of branches in this tree.
 Return type
 tmrca(u, v)[source]¶
Returns the time of the most recent common ancestor of the specified nodes. This is equivalent to:
>>> tree.time(tree.mrca(u, v))
Note
If you are using this method to calculate average tmrca values along the genome between pairs of sample nodes, for efficiency reasons you should instead consider the
mode="branch"
option of theTreeSequence.divergence()
orTreeSequence.diversity()
methods. Since these calculate the average branch length between pairs of sample nodes, for samples at time 0 the resulting statistics will be exactly twice the tmrca value.
 parent(u)[source]¶
Returns the parent of the specified node. Returns
tskit.NULL
if u is a root or is not a node in the current tree.
 property parent_array¶
A numpy array (dtype=np.int32) encoding the parent of each node in this tree, such that
tree.parent_array[u] == tree.parent(u)
for all0 <= u <= ts.num_nodes
. See theparent()
method for details on the semantics of tree parents and the Tree structure section for information on the quintuply linked tree encoding.Note
The length of these arrays is equal to the number of nodes in the tree sequence plus 1, with the final element corresponding to the tree’s
virtual_root()
. Please see the tree roots section for more details.Warning
This is a highperformance interface which provides zerocopy access to memory used in the C library. As a consequence, the values stored in this array will change as the Tree state is modified as we move along the tree sequence. See the
Tree
documentation for more details. Therefore, if you want to compare arrays representing different trees along the sequence, you must take copies of the arrays.
 left_child(u)[source]¶
Returns the leftmost child of the specified node. Returns
tskit.NULL
if u is a leaf or is not a node in the current tree. The lefttoright ordering of children is arbitrary and should not be depended on; see the data model section for details.This is a lowlevel method giving access to the quintuply linked tree structure in memory; the
children()
method is a more convenient way to obtain the children of a given node.
 property left_child_array¶
A numpy array (dtype=np.int32) encoding the left child of each node in this tree, such that
tree.left_child_array[u] == tree.left_child(u)
for all0 <= u <= ts.num_nodes
. See theleft_child()
method for details on the semantics of tree left_child and the Tree structure section for information on the quintuply linked tree encoding.Note
The length of these arrays is equal to the number of nodes in the tree sequence plus 1, with the final element corresponding to the tree’s
virtual_root()
. Please see the tree roots section for more details.Warning
This is a highperformance interface which provides zerocopy access to memory used in the C library. As a consequence, the values stored in this array will change as the Tree state is modified as we move along the tree sequence. See the
Tree
documentation for more details. Therefore, if you want to compare arrays representing different trees along the sequence, you must take copies of the arrays.
 right_child(u)[source]¶
Returns the rightmost child of the specified node. Returns
tskit.NULL
if u is a leaf or is not a node in the current tree. The lefttoright ordering of children is arbitrary and should not be depended on; see the data model section for details.This is a lowlevel method giving access to the quintuply linked tree structure in memory; the
children()
method is a more convenient way to obtain the children of a given node.
 property right_child_array¶
A numpy array (dtype=np.int32) encoding the right child of each node in this tree, such that
tree.right_child_array[u] == tree.right_child(u)
for all0 <= u <= ts.num_nodes
. See theright_child()
method for details on the semantics of tree right_child and the Tree structure section for information on the quintuply linked tree encoding.Note
The length of these arrays is equal to the number of nodes in the tree sequence plus 1, with the final element corresponding to the tree’s
virtual_root()
. Please see the tree roots section for more details.Warning
This is a highperformance interface which provides zerocopy access to memory used in the C library. As a consequence, the values stored in this array will change as the Tree state is modified as we move along the tree sequence. See the
Tree
documentation for more details. Therefore, if you want to compare arrays representing different trees along the sequence, you must take copies of the arrays.
 left_sib(u)[source]¶
Returns the sibling node to the left of u, or
tskit.NULL
if u does not have a left sibling. The lefttoright ordering of children is arbitrary and should not be depended on; see the data model section for details.
 property left_sib_array¶
A numpy array (dtype=np.int32) encoding the left sib of each node in this tree, such that
tree.left_sib_array[u] == tree.left_sib(u)
for all0 <= u <= ts.num_nodes
. See theleft_sib()
method for details on the semantics of tree left_sib and the Tree structure section for information on the quintuply linked tree encoding.Note
The length of these arrays is equal to the number of nodes in the tree sequence plus 1, with the final element corresponding to the tree’s
virtual_root()
. Please see the tree roots section for more details.Warning
This is a highperformance interface which provides zerocopy access to memory used in the C library. As a consequence, the values stored in this array will change as the Tree state is modified as we move along the tree sequence. See the
Tree
documentation for more details. Therefore, if you want to compare arrays representing different trees along the sequence, you must take copies of the arrays.
 right_sib(u)[source]¶
Returns the sibling node to the right of u, or
tskit.NULL
if u does not have a right sibling. The lefttoright ordering of children is arbitrary and should not be depended on; see the data model section for details.
 property right_sib_array¶
A numpy array (dtype=np.int32) encoding the right sib of each node in this tree, such that
tree.right_sib_array[u] == tree.right_sib(u)
for all0 <= u <= ts.num_nodes
. See theright_sib()
method for details on the semantics of tree right_sib and the Tree structure section for information on the quintuply linked tree encoding.Note
The length of these arrays is equal to the number of nodes in the tree sequence plus 1, with the final element corresponding to the tree’s
virtual_root()
. Please see the tree roots section for more details.Warning
This is a highperformance interface which provides zerocopy access to memory used in the C library. As a consequence, the values stored in this array will change as the Tree state is modified as we move along the tree sequence. See the
Tree
documentation for more details. Therefore, if you want to compare arrays representing different trees along the sequence, you must take copies of the arrays.
 property virtual_root¶
The ID of the virtual root in this tree. This is equal to
TreeSequence.num_nodes
.Please see the tree roots section for more details.
 property num_edges¶
The total number of edges in this tree. This is equal to the number of tree sequence edges that intersect with this tree’s genomic interval.
Note that this may be greater than the number of branches that are reachable from the tree’s roots, since we can have topology that is not associated with any samples.
 property left_root¶
The leftmost root in this tree. If there are multiple roots in this tree, they are siblings of this node, and so we can use
right_sib()
to iterate over all roots:u = tree.left_root while u != tskit.NULL: print("Root:", u) u = tree.right_sib(u)
The lefttoright ordering of roots is arbitrary and should not be depended on; see the data model section for details.
This is a lowlevel method giving access to the quintuply linked tree structure in memory; the
roots
attribute is a more convenient way to obtain the roots of a tree. If you are assuming that there is a single root in the tree you should use theroot
property.Warning
Do not use this property if you are assuming that there is a single root in trees that are being processed. The
root
property should be used in this case, as it will raise an error when multiple roots exists. Return type
 children(u)[source]¶
Returns the children of the specified node
u
as a tuple of integer node IDs. Ifu
is a leaf, return the empty tuple. The ordering of children is arbitrary and should not be depended on; see the data model section for details.
 time(u)[source]¶
Returns the time of the specified node. This is equivalently to
tree.tree_sequence.node(u).time
except for the special case of the tree’s virtual root, which is defined as positive infinity.
 depth(u)[source]¶
Returns the number of nodes on the path from
u
to a root, not includingu
. Thus, the depth of a root is zero.As a special case, the depth of the virtual root is defined as 1.
 population(u)[source]¶
Returns the population associated with the specified node. Equivalent to
tree.tree_sequence.node(u).population
.
 is_internal(u)[source]¶
Returns True if the specified node is not a leaf. A node is internal if it has one or more children in the current tree.
 is_leaf(u)[source]¶
Returns True if the specified node is a leaf. A node \(u\) is a leaf if it has zero children.
Note
\(u\) can be any node in the entire tree sequence, including ones which are not connected via branches to a root node of the tree (and which are therefore not conventionally considered part of the tree). Indeed, if there are many trees in the tree sequence, it is common for the majority of nonsample nodes to be
isolated
in any one tree. By the definition above, this method will returnTrue
for such a tree when a node of this sort is specified. Such nodes can be thought of as “dead leaves”, see Dead leaves and branches.
 is_isolated(u)[source]¶
Returns True if the specified node is isolated in this tree: that is it has no parents and no children (note that all isolated nodes in the tree are therefore also
leaves
). Sample nodes that are isolated and have no mutations above them are used to represent missing data.
 is_sample(u)[source]¶
Returns True if the specified node is a sample. A node \(u\) is a sample if it has been marked as a sample in the parent tree sequence.
 is_descendant(u, v)[source]¶
Returns True if the specified node u is a descendant of node v and False otherwise. A node \(u\) is a descendant of another node \(v\) if \(v\) is on the path from \(u\) to root. A node is considered to be a descendant of itself, so
tree.is_descendant(u, u)
will be True for any valid node. Parameters
 Returns
True if u is a descendant of v.
 Return type
 Raises
ValueError – If u or v are not valid node IDs.
 property num_nodes¶
Returns the number of nodes in the
TreeSequence
this tree is in. Equivalent totree.tree_sequence.num_nodes
.Deprecated since version 0.4: Use
Tree.tree_sequence.num_nodes
if you want the number of nodes in the entire tree sequence, orlen(tree.preorder())
to find the number of nodes that are reachable from all roots in this tree. Return type
 property num_roots¶
The number of roots in this tree, as defined in the
roots
attribute.Only requires O(number of roots) time.
 Return type
 property has_single_root¶
True
if this tree has a single root,False
otherwise. Equivalent to tree.num_roots == 1. This is a O(1) operation. Return type
 property has_multiple_roots¶
True
if this tree has more than one root,False
otherwise. Equivalent to tree.num_roots > 1. This is a O(1) operation. Return type
 property roots¶
The list of roots in this tree. A root is defined as a unique endpoint of the paths starting at samples. We can define the set of roots as follows:
roots = set() for u in tree_sequence.samples(): while tree.parent(u) != tskit.NULL: u = tree.parent(u) roots.add(u) # roots is now the set of all roots in this tree. assert sorted(roots) == sorted(tree.roots)
The roots of the tree are returned in a list, in no particular order.
Only requires O(number of roots) time.
 Returns
The list of roots in this tree.
 Return type
 property root¶
The root of this tree. If the tree contains multiple roots, a ValueError is raised indicating that the
roots
attribute should be used instead. Returns
The root node.
 Return type
 Raises
ValueError
if this tree contains more than one root.
 property index¶
Returns the index this tree occupies in the parent tree sequence. This index is zero based, so the first tree in the sequence has index 0.
 Returns
The index of this tree.
 Return type
 property interval¶
Returns the coordinates of the genomic interval that this tree represents the history of. The interval is returned as a tuple \((l, r)\) and is a halfopen interval such that the left coordinate is inclusive and the right coordinate is exclusive. This tree therefore applies to all genomic locations \(x\) such that \(l \leq x < r\).
 Returns
A named tuple (l, r) representing the leftmost (inclusive) and rightmost (exclusive) coordinates of the genomic region covered by this tree. The coordinates can be accessed by index (
0
or1
) or equivalently by name (.left
or.right
) Return type
 property span¶
Returns the genomic distance that this tree spans. This is defined as \(r  l\), where \((l, r)\) is the genomic interval returned by
interval
. Returns
The genomic distance covered by this tree.
 Return type
 draw_text(orientation=None, *, node_labels=None, max_time=None, use_ascii=False, order=None)[source]¶
Create a text representation of a tree.
 Parameters
orientation (str) – one of
"top"
,"left"
,"bottom"
, or"right"
, specifying the margin on which the root is placed. Specifying"left"
or"right"
will lead to time being shown on the x axis (i.e. a “horizontal” tree. IfNone
(default) use the standard coalescent arrangement of a vertical tree with recent nodes at the bottom of the plot and older nodes above.node_labels (dict) – If specified, show custom labels for the nodes that are present in the map. Any nodes not specified in the map will not have a node label.
max_time (str) – If equal to
"tree"
(the default), the maximum time is set to be that of the oldest root in the tree. If equal to"ts"
the maximum time is set to be the time of the oldest root in the tree sequence; this is useful when drawing trees from the same tree sequence as it ensures that node heights are consistent.use_ascii (bool) – If
False
(default) then use unicode box drawing characters to render the tree. IfTrue
, use plain ascii characters, which look cruder but are less susceptible to misalignment or font substitution. Alternatively, if you are having alignment problems with Unicode, you can try out the solution documented here.order (str) – The lefttoright ordering of child nodes in the drawn tree. This can be either:
"minlex"
, which minimises the differences between adjacent trees (see also the"minlex_postorder"
traversal order for thenodes()
method); or"tree"
which draws trees in the lefttoright order defined by the quintuply linked tree structure. If not specified or None, this defaults to"minlex"
.
 Returns
A text representation of a tree.
 Return type
 draw_svg(path=None, *, size=None, time_scale=None, tree_height_scale=None, max_time=None, max_tree_height=None, node_labels=None, mutation_labels=None, root_svg_attributes=None, style=None, order=None, force_root_branch=None, symbol_size=None, x_axis=None, x_label=None, y_axis=None, y_label=None, y_ticks=None, y_gridlines=None, all_edge_mutations=None, **kwargs)[source]¶
Return an SVG representation of a single tree. By default, numeric labels are drawn beside nodes and mutations: these can be altered using the
node_labels
andmutation_labels
parameters. See the visualization tutorial for more details. Parameters
path (str) – The path to the file to write the output. If None, do not write to file.
size (tuple(int, int)) – A tuple of (width, height) giving the width and height of the produced SVG drawing in abstract user units (usually interpreted as pixels on initial display).
time_scale (str) – Control how height values for nodes are computed. If this is equal to
"time"
(the default), node heights are proportional to their time values. If this is equal to"log_time"
, node heights are proportional to their log(time) values. If it is equal to"rank"
, node heights are spaced equally according to their ranked times.tree_height_scale (str) – Deprecated alias for time_scale. (Deprecated in 0.3.6)
max_time (str,float) – The maximum time value in the current scaling system (see
time_scale
). Can be either a string or a numeric value. If equal to"tree"
(the default), the maximum time is set to be that of the oldest root in the tree. If equal to"ts"
the maximum time is set to be the time of the oldest root in the tree sequence; this is useful when drawing trees from the same tree sequence as it ensures that node heights are consistent. If a numeric value, this is used as the maximum time by which to scale other nodes.max_tree_height (str,float) – Deprecated alias for max_time. (Deprecated in 0.3.6)
node_labels (dict(int, str)) – If specified, show custom labels for the nodes (specified by ID) that are present in this map; any nodes not present will not have a label.
mutation_labels (dict(int, str)) – If specified, show custom labels for the mutations (specified by ID) that are present in the map; any mutations not present will not have a label.
root_svg_attributes (dict) – Additional attributes, such as an id, that will be embedded in the root
<svg>
tag of the generated drawing.style (str) – A css style string that will be included in the
<style>
tag of the generated svg.order (str) – The lefttoright ordering of child nodes in the drawn tree. This can be either:
"minlex"
, which minimises the differences between adjacent trees (see also the"minlex_postorder"
traversal order for thenodes()
method); or"tree"
which draws trees in the lefttoright order defined by the quintuply linked tree structure. If not specified or None, this defaults to"minlex"
.force_root_branch (bool) – If
True
always plot a branch (edge) above the root(s) in the tree. IfNone
(default) then only plot such root branches if there is a mutation above a root of the tree.symbol_size (float) – Change the default size of the node and mutation plotting symbols. If
None
(default) use a standard size.x_axis (bool) – Should the plot have an X axis line, showing the start and end position of this tree along the genome. If
None
(default) do not plot an X axis.x_label (str) – Place a label under the plot. If
None
(default) and there is an X axis, create and place an appropriate label.y_axis (bool) – Should the plot have an Y axis line, showing time (or ranked node time if
time_scale="rank"
). IfNone
(default) do not plot a Y axis.y_label (str) – Place a label to the left of the plot. If
None
(default) and there is a Y axis, create and place an appropriate label.y_ticks (list) – A list of Y values at which to plot tickmarks (
[]
gives no tickmarks). IfNone
, plot one tickmark for each unique node value.y_gridlines (bool) – Whether to plot horizontal lines behind the tree at each y tickmark.
all_edge_mutations (bool) – The edge on which a mutation occurs may span multiple trees. If
False
orNone
(default) mutations are only drawn on an edge if their site position exists within the genomic interval covered by this tree. IfTrue
, all mutations on each edge of the tree are drawn, even if the their genomic position is to the left or right of the tree itself. Note that this means that independent drawings of different trees from the same tree sequence may share some plotted mutations.
 Returns
An SVG representation of a tree.
 Return type
 draw(path=None, width=None, height=None, node_labels=None, node_colours=None, mutation_labels=None, mutation_colours=None, format=None, edge_colours=None, time_scale=None, tree_height_scale=None, max_time=None, max_tree_height=None, order=None)[source]¶
Returns a drawing of this tree.
When working in a Jupyter notebook, use the
IPython.display.SVG
function to display the SVG output from this function inline in the notebook:>>> SVG(tree.draw())
The unicode format uses unicode box drawing characters to render the tree. This allows rendered trees to be printed out to the terminal:
>>> print(tree.draw(format="unicode")) 6 ┏━┻━┓ ┃ 5 ┃ ┏━┻┓ ┃ ┃ 4 ┃ ┃ ┏┻┓ 3 0 1 2
The
node_labels
argument allows the user to specify custom labels for nodes, or no labels at all:>>> print(tree.draw(format="unicode", node_labels={})) ┃ ┏━┻━┓ ┃ ┃ ┃ ┏━┻┓ ┃ ┃ ┃ ┃ ┃ ┏┻┓ ┃ ┃ ┃ ┃
Note: in some environments such as Jupyter notebooks with Windows or Mac, users have observed that the Unicode box drawings can be misaligned. In these cases, we recommend using the SVG or ASCII display formats instead. If you have a strong preference for aligned Unicode, you can try out the solution documented here.
 Parameters
path (str) – The path to the file to write the output. If None, do not write to file.
width (int) – The width of the image in pixels. If not specified, either defaults to the minimum size required to depict the tree (text formats) or 200 pixels.
height (int) – The height of the image in pixels. If not specified, either defaults to the minimum size required to depict the tree (text formats) or 200 pixels.
node_labels (dict) – If specified, show custom labels for the nodes that are present in the map. Any nodes not specified in the map will not have a node label.
node_colours (dict) – If specified, show custom colours for the nodes given in the map. Any nodes not specified in the map will take the default colour; a value of
None
is treated as transparent and hence the node symbol is not plotted. (Only supported in the SVG format.)mutation_labels (dict) – If specified, show custom labels for the mutations (specified by ID) that are present in the map. Any mutations not in the map will not have a label. (Showing mutations is currently only supported in the SVG format)
mutation_colours (dict) – If specified, show custom colours for the mutations given in the map (specified by ID). As for
node_colours
, mutations not present in the map take the default colour, and those mapping toNone
are not drawn. (Only supported in the SVG format.)format (str) – The format of the returned image. Currently supported are ‘svg’, ‘ascii’ and ‘unicode’. Note that the
Tree.draw_svg()
method provides more comprehensive functionality for creating SVGs.edge_colours (dict) – If specified, show custom colours for the edge joining each node in the map to its parent. As for
node_colours
, unspecified edges take the default colour, andNone
values result in the edge being omitted. (Only supported in the SVG format.)time_scale (str) – Control how height values for nodes are computed. If this is equal to
"time"
, node heights are proportional to their time values. If this is equal to"log_time"
, node heights are proportional to their log(time) values. If it is equal to"rank"
, node heights are spaced equally according to their ranked times. For SVG output the default is ‘time’scale whereas for text output the default is ‘rank’scale. Time scaling is not currently supported for text output.tree_height_scale (str) – Deprecated alias for time_scale. (Deprecated in 0.3.6)
max_time (str,float) – The maximum time value in the current scaling system (see
time_scale
). Can be either a string or a numeric value. If equal to"tree"
, the maximum time is set to be that of the oldest root in the tree. If equal to"ts"
the maximum time is set to be the time of the oldest root in the tree sequence; this is useful when drawing trees from the same tree sequence as it ensures that node heights are consistent. If a numeric value, this is used as the maximum time by which to scale other nodes. This parameter is not currently supported for text output.max_tree_height (str) – Deprecated alias for max_time. (Deprecated in 0.3.6)
order (str) – The lefttoright ordering of child nodes in the drawn tree. This can be either:
"minlex"
, which minimises the differences between adjacent trees (see also the"minlex_postorder"
traversal order for thenodes()
method); or"tree"
which draws trees in the lefttoright order defined by the quintuply linked tree structure. If not specified or None, this defaults to"minlex"
.
 Returns
A representation of this tree in the requested format.
 Return type
 property num_mutations¶
Returns the total number of mutations across all sites on this tree.
 Returns
The total number of mutations over all sites on this tree.
 Return type
 property num_sites¶
Returns the number of sites on this tree.
 Returns
The number of sites on this tree.
 Return type
 sites()[source]¶
Returns an iterator over all the sites in this tree. Sites are returned in order of increasing ID (and also position). See the
Site
class for details on the available fields for each site. Returns
An iterator over all sites in this tree.
 mutations()[source]¶
Returns an iterator over all the mutations in this tree. Mutations are returned in their order in the mutations table, that is, by nondecreasing site ID, and within a site, by decreasing mutation time with parent mutations before their children. See the
Mutation
class for details on the available fields for each mutation.The returned iterator is equivalent to iterating over all sites and all mutations in each site, i.e.:
>>> for site in tree.sites(): >>> for mutation in site.mutations: >>> yield mutation
 leaves(u=None)[source]¶
Returns an iterator over all the leaves in this tree that descend from the specified node. If \(u\) is not specified, return all leaves on the tree (i.e. all leaves reachable from the tree root(s), see note below).
Note
\(u\) can be any node in the entire tree sequence, including ones which are not connected via branches to a root node of the tree. If called on such a node, the iterator will return “dead” leaves (see Dead leaves and branches) which cannot be reached from a root of this tree. However, dead leaves will never be returned if \(u\) is left unspecified.
 Parameters
u (int) – The node of interest.
 Returns
An iterator over all leaves in the subtree rooted at u.
 Return type
 samples(u=None)[source]¶
Returns an iterator over the numerical IDs of all the sample nodes in this tree that are underneath node
u
. Ifu
is a sample, it is included in the returned iterator. If u is not specified, return all sample node IDs in the tree.If the
TreeSequence.trees()
method is called withsample_lists=True
, this method uses an efficient algorithm to find the sample nodes. If not, a simple traversal based method is used.Note
The iterator is not guaranteed to return the sample node IDs in numerical or any other particular order.
 Parameters
u (int) – The node of interest.
 Returns
An iterator over all sample node IDs in the subtree rooted at u.
 Return type
 num_children(u)[source]¶
Returns the number of children of the specified node (i.e.,
len(tree.children(u))
)
 num_samples(u=None)[source]¶
Returns the number of sample nodes in this tree underneath the specified node (including the node itself). If u is not specified return the total number of samples in the tree.
This is a constant time operation.
 num_tracked_samples(u=None)[source]¶
Returns the number of samples in the set specified in the
tracked_samples
parameter of theTreeSequence.trees()
method underneath the specified node. If the input node is not specified, return the total number of tracked samples in the tree.This is a constant time operation.
 preorder(u= 1)[source]¶
Returns a numpy array of node ids in preorder <https://en.wikipedia.org/wiki/Tree_traversal#Preorder_(NLR)>. If the node u is specified the traversal is rooted at this node (and it will be the first element in the returned array). Otherwise, all nodes reachable from the tree roots will be returned. See Tree traversals for examples.
 Parameters
u (int) – If specified, return all nodes in the subtree rooted at u (including u) in traversal order.
 Returns
Array of node ids
 Return type
numpy.ndarray (dtype=np.int32)
 postorder(u= 1)[source]¶
Returns a numpy array of node ids in postorder <https://en.wikipedia.org/wiki/Tree_traversal##Postorder_(LRN)>. If the node u is specified the traversal is rooted at this node (and it will be the last element in the returned array). Otherwise, all nodes reachable from the tree roots will be returned. See Tree traversals for examples.
 Parameters
u (int) – If specified, return all nodes in the subtree rooted at u (including u) in traversal order.
 Returns
Array of node ids
 Return type
numpy.ndarray (dtype=np.int32)
 timeasc(u= 1)[source]¶
Returns a numpy array of node ids. Starting at u, returns the reachable descendant nodes in order of increasing time (most recent first), falling back to increasing ID if times are equal. Also see Tree traversals for examples of how to use traversals.
 Parameters
u (int) – If specified, return all nodes in the subtree rooted at u (including u) in traversal order.
 Returns
Array of node ids
 Return type
numpy.ndarray (dtype=np.int32)
 timedesc(u= 1)[source]¶
Returns a numpy array of node ids. Starting at u, returns the reachable descendant nodes in order of decreasing time (least recent first), falling back to decreasing ID if times are equal. Also see Tree traversals for examples of how to use traversals.
 Parameters
u (int) – If specified, return all nodes in the subtree rooted at u (including u) in traversal order.
 Returns
Array of node ids
 Return type
numpy.ndarray (dtype=np.int32)
 nodes(root=None, order='preorder')[source]¶
Returns an iterator over the node IDs reachable from the specified node in this tree in the specified traversal order.
Note
Unlike the
TreeSequence.nodes()
method, this iterator produces integer node IDs, notNode
objects.If the
root
parameter is not provided orNone
, iterate over all nodes reachable from the roots (seeTree.roots
for details on which nodes are considered roots). If theroot
parameter is provided, only the nodes in the subtree rooted at this node (including the specified node) will be iterated over. If thevirtual_root
is specified as the traversal root, it will be included in the traversed nodes in the appropriate position for the given ordering. (See the tree roots section for more information on the virtual root.)The
order
parameter defines the order in which tree nodes are visited in the iteration (also see the Tree traversals section in the tutorials). The available orders are:‘preorder’: starting at root, yield the current node, then recurse and do a preorder on each child of the current node. See also Wikipedia.
‘inorder’: starting at root, assuming binary trees, recurse and do an inorder on the first child, then yield the current node, then recurse and do an inorder on the second child. In the case of
n
child nodes (not necessarily 2), the firstn // 2
children are visited in the first stage, and the remainingn  n // 2
children are visited in the second stage. See also Wikipedia.‘postorder’: starting at root, recurse and do a postorder on each child of the current node, then yield the current node. See also Wikipedia.
‘levelorder’ (‘breadthfirst’): visit the nodes under root (including the root) in increasing order of their depth from root. See also Wikipedia.
‘timeasc’: visits the nodes in order of increasing time, falling back to increasing ID if times are equal.
‘timedesc’: visits the nodes in order of decreasing time, falling back to decreasing ID if times are equal.
‘minlex_postorder’: a usual postorder has ambiguity in the order in which children of a node are visited. We constrain this by outputting a postorder such that the leaves visited, when their IDs are listed out, have minimum lexicographic order out of all valid traversals. This traversal is useful for drawing multiple trees of a
TreeSequence
, as it leads to more consistency between adjacent trees. Note that internal nonleaf nodes are not counted in assessing the lexicographic order.
 Parameters
 Returns
An iterator over the node IDs in the tree in some traversal order.
 Return type
 as_newick(*, root=None, precision=None, node_labels=None, include_branch_lengths=None)[source]¶
Returns a newick encoding of this tree. For example, a binary tree with 3 leaves generated by
Tree.generate_balanced(3)
encodes as:(n0:2,(n1:1,n2:1):1);
By default sample nodes are labelled using the form
f"n{node_id}"
, i.e. the sample node’s ID prefixed with the string"n"
. Node labels can be specified explicitly using thenode_labels
argument, which is a mapping from integer node IDs to the corresponding string label. If a node is not present in the mapping, no label is associated with the node in output.Warning
Node labels are not Newick escaped, so care must be taken to provide labels that will not break the encoding.
Note
Specifying a
node_labels
dictionary or settinginclude_branch_lengths=False
results in a less efficient method being used to generate the newick output. The performance difference can be substantial for large trees.By default, branch lengths are printed out with sufficient precision for them to be recovered exactly in double precision (although note that this does not necessarily mean that we can precisely recover the corresponding node times, since branch lengths are obtained by subtraction). If all times on the tree sequence are discrete, then branch lengths are printed as integers. Otherwise, branch lengths are printed with 17 digits of precision (i.e.,
"%.17f"
in printfnotation).The precision for branch lengths can be specified using the
precision
argument. Branch lengths can be omitted entirely by settinginclude_branch_lengths=False
.If the
root
argument is specified, we return the newick encoding of the specified subtree, otherwise the full tree is returned. If the tree has multiple roots and a root node is not explicitly specified, we raise aValueError
. This is because most libraries and downstream software consider a newick string that contains multiple disconnected subtrees an error, and it is therefore best to consider how such topologies should be interchanged on a casebybase basis. A list of the newick strings for each root can be obtained by[tree.as_newick(root=root) for root in tree.roots]
. Parameters
precision (int) – The numerical precision with which branch lengths are printed. If not specified or None default to 0 if the tree sequence contains only integer node times, or 17 otherwise.
root (int) – If specified, return the tree rooted at this node.
node_labels (dict) – If specified, show custom labels for the nodes that are present in the map. Any nodes not specified in the map will not have a node label.
include_branch_lengths – If True (default), output branch lengths in the Newick string. If False, only output the topology, without branch lengths.
 Returns
A newick representation of this tree.
 Return type
 newick(precision=14, *, root=None, node_labels=None, include_branch_lengths=True)[source]¶
Warning
This method is deprecated and may be removed in future versions of tskit. Please use the
as_newick()
method in new code.This method is a deprecated version of the
as_newick()
method. Functionality is equivalent, except for the default node labels.By default, leaf nodes are labelled with their numerical ID + 1, and internal nodes are not labelled. This default strategy was originally used to mimic the output of the
ms
simulator. However, the choice of labelling leaf nodes rather than samples is problematic, and this behaviour is only retained to avoid breaking existing code which may rely on it.Other parameters behave as documented in the
as_newick()
method. Parameters
precision (int) – The numerical precision with which branch lengths are printed. Defaults to 14.
root (int) – If specified, return the tree rooted at this node.
node_labels (dict) – If specified, show custom labels for the nodes that are present in the map. Any nodes not specified in the map will not have a node label.
include_branch_lengths – If True (default), output branch lengths in the Newick string. If False, only output the topology, without branch lengths.
 Returns
A newick representation of this tree.
 Return type
 as_dict_of_dicts()[source]¶
Convert tree to dict of dicts for conversion to a networkx graph.
For example:
>>> import networkx as nx >>> nx.DiGraph(tree.as_dict_of_dicts()) >>> # undirected graphs work as well >>> nx.Graph(tree.as_dict_of_dicts())
 Returns
Dictionary of dictionaries of dictionaries where the first key is the source, the second key is the target of an edge, and the third key is an edge annotation. At this point the only annotation is “branch_length”, the length of the branch (in units of time).
 _repr_html_()[source]¶
Return an html summary of a tree in a tree sequence. Called by jupyter notebooks to render trees
 map_mutations(genotypes, alleles, ancestral_state=None)[source]¶
Given observations for the samples in this tree described by the specified set of genotypes and alleles, return a parsimonious set of state transitions explaining these observations. The genotypes array is interpreted as indexes into the alleles list in the same manner as described in the
TreeSequence.variants()
method. Thus, if samplej
carries the allele at indexk
, then we havegenotypes[j] = k
. Missing observations can be specified for a sample using the valuetskit.MISSING_DATA
(1), in which case the state at this sample does not influence the ancestral state or the position of mutations returned. At least one nonmissing observation must be provided. A maximum of 64 alleles are supported.The current implementation uses the Hartigan parsimony algorithm to determine the minimum number of state transitions required to explain the data. In this model, transitions between any of the nonmissing states is equally likely.
The returned values correspond directly to the data model for describing variation at sites using mutations. See the Site Table and Mutation Table definitions for details and background.
The state reconstruction is returned as twotuple,
(ancestral_state, mutations)
, whereancestral_state
is the allele assigned to the tree root(s) andmutations
is a list ofMutation
objects, ordered as required in a mutation table. For each mutation,derived_state
is the new state after this mutation andnode
is the tree node immediately beneath the mutation (if there are unary nodes between two branch points, hence multiple nodes above which the mutation could be parsimoniously placed, the oldest node is used). Theparent
property contains the index in the returned list of the previous mutation on the path to root, ortskit.NULL
if there are no previous mutations (see the Mutation Table for more information on the concept of mutation parents). All other attributes of theMutation
object are undefined and should not be used.Note
Sample states observed as missing in the input
genotypes
need not correspond to samples whose nodes are actually “missing” (i.e., isolated) in the tree. In this case, mapping the mutations returned by this method onto the tree will result in these missing observations being imputed to the most parsimonious state.See the Parsimony section in the tutorial for examples of how to use this method.
 Parameters
genotypes (array_like) – The input observations for the samples in this tree.
alleles (tuple(str)) – The alleles for the specified
genotypes
. Each positive value in thegenotypes
array is treated as an index into this list of alleles.ancestral_state (Union[int, str]) – A fixed ancestral state, specified either as a nonnegative integer less than the number of alleles, or a string which must be one of the
alleles
provided above. IfNone
(default) then an ancestral state is chosen arbitrarily from among those that provide the most parsimonious placement of mutations. Note that if the ancestral state is specified, the placement of mutations may not be as parsimonious as that which could be achieved by leaving the ancestral state unspecified; additionally it may lead to mutations being placed above the root node(s) of the tree (for example if all the samples have a genotype of 1 but the ancestral state is fixed to be 0).
 Returns
The inferred ancestral state and list of mutations on this tree that encode the specified observations.
 Return type
(str, list(tskit.Mutation))
 kc_distance(other, lambda_=0.0)[source]¶
Returns the KendallColijn distance between the specified pair of trees. The
lambda_
parameter determines the relative weight of topology vs branch lengths in calculating the distance. Iflambda_
is 0 (the default) we only consider topology, and if it is 1 we only consider branch lengths. See Kendall & Colijn (2016) for details.The trees we are comparing to must have identical lists of sample nodes (i.e., the same IDs in the same order). The metric operates on samples, not leaves, so internal samples are treated identically to sample tips. Subtrees with no samples do not contribute to the metric.
 split_polytomies(*, epsilon=None, method=None, record_provenance=True, random_seed=None, **kwargs)[source]¶
Return a new
Tree
where extra nodes and edges have been inserted so that any any nodeu
with greater than 2 children — a multifurcation or “polytomy” — is resolved into successive bifurcations. New nodes are inserted at times fractionally less than than the time of nodeu
. Times are allocated to different levels of the tree, such that any newly inserted sibling nodes will have the same time.By default, the times of the newly generated children of a particular node are the minimum representable distance in floating point arithmetic from their parents (using the nextafter function). Thus, the generated branches have the shortest possible nonzero length. A fixed branch length between inserted nodes and their parents can also be specified by using the
epsilon
parameter.Note
A tree sequence requires that parents be older than children and that mutations are younger than the parent of the edge on which they lie. If a fixed
epsilon
is specifed and is not small enough compared to the distance between a polytomy and its oldest child (or oldest child mutation) these requirements may not be met. In this case an error will be raised.If the
method
is"random"
(currently the only option, and the default when no method is specified), then for a node with \(n\) children, the \((2n  3)! / (2^(n  2) (n  2!))\) possible binary trees with equal probability.The returned
Tree
will have the same genomic span as this tree, and node IDs will be conserved (that is, nodeu
in this tree will be the same node in the returned tree). The returned tree is derived from a tree sequence that contains only one nondegenerate tree, that is, where edges cover only the interval spanned by this tree. Parameters
epsilon – If specified, the fixed branch length between inserted nodes and their parents. If None (the default), the minimal possible nonzero branch length is generated for each node.
method (str) – The method used to break polytomies. Currently only “random” is supported, which can also be specified by
method=None
(Default:None
).record_provenance (bool) – If True, add details of this operation to the provenance information of the returned tree sequence. (Default: True).
random_seed (int) – The random seed. If this is None, a random seed will be automatically generated. Valid random seeds must be between 1 and \(2^32 − 1\).
**kwargs – Further arguments used as parameters when constructing the returned
Tree
. For exampletree.split_polytomies(sample_lists=True)
will return aTree
created withsample_lists=True
.
 Returns
A new tree with polytomies split into random bifurcations.
 Return type
 static generate_star(num_leaves, *, span=1, branch_length=1, record_provenance=True, **kwargs)[source]¶
Generate a
Tree
whose leaf nodes all have the same parent (i.e., a “star” tree). The leaf nodes are all at time 0 and are marked as sample nodes.The tree produced by this method is identical to
tskit.Tree.unrank(n, (0, 0))
, but generated more efficiently for largen
. Parameters
num_leaves (int) – The number of leaf nodes in the returned tree (must be 2 or greater).
span (float) – The span of the tree, and therefore the
sequence_length
of thetree_sequence
property of the returnedTree
.branch_length (float) – The length of every branch in the tree (equivalent to the time of the root node).
record_provenance (bool) – If True, add details of this operation to the provenance information of the returned tree sequence. (Default: True).
**kwargs – Further arguments used as parameters when constructing the returned
Tree
. For exampletskit.Tree.generate_star(sample_lists=True)
will return aTree
created withsample_lists=True
.
 Returns
A starshaped tree. Its corresponding
TreeSequence
is available via thetree_sequence
attribute. Return type
 static generate_balanced(num_leaves, *, arity=2, span=1, branch_length=1, record_provenance=True, **kwargs)[source]¶
Generate a
Tree
with the specified number of leaves that is maximally balanced. By default, the tree returned is binary, such that for each node that subtends \(n\) leaves, the left child will subtend \(\lfloor{n / 2}\rfloor\) leaves and the right child the remainder. Balanced trees with higher arity can also generated using thearity
parameter, where the leaves subtending a node are distributed among its children analogously.In the returned tree, the leaf nodes are all at time 0, marked as samples, and labelled 0 to n from lefttoright. Internal node IDs are assigned sequentially from n in a postorder traversal, and the time of an internal node is the maximum time of its children plus the specified
branch_length
. Parameters
num_leaves (int) – The number of leaf nodes in the returned tree (must be be 2 or greater).
arity (int) – The maximum number of children a node can have in the returned tree.
span (float) – The span of the tree, and therefore the
sequence_length
of thetree_sequence
property of the returnedTree
.branch_length (float) – The minimum length of a branch in the tree (see above for details on how internal node times are assigned).
record_provenance (bool) – If True, add details of this operation to the provenance information of the returned tree sequence. (Default: True).
**kwargs – Further arguments used as parameters when constructing the returned
Tree
. For exampletskit.Tree.generate_balanced(sample_lists=True)
will return aTree
created withsample_lists=True
.
 Returns
A balanced tree. Its corresponding
TreeSequence
is available via thetree_sequence
attribute. Return type
 static generate_comb(num_leaves, *, span=1, branch_length=1, record_provenance=True, **kwargs)[source]¶
Generate a
Tree
in which all internal nodes have two children and the left child is a leaf. This is a “comb”, “ladder” or “pectinate” phylogeny, and also known as a caterpillar tree.The leaf nodes are all at time 0, marked as samples, and labelled 0 to n from lefttoright. Internal node IDs are assigned sequentially from n as we ascend the tree, and the time of an internal node is the maximum time of its children plus the specified
branch_length
. Parameters
num_leaves (int) – The number of leaf nodes in the returned tree (must be 2 or greater).
span (float) – The span of the tree, and therefore the
sequence_length
of thetree_sequence
property of the returnedTree
.branch_length (float) – The branch length between each internal node; the root node is therefore placed at time
branch_length * (num_leaves  1)
.record_provenance (bool) – If True, add details of this operation to the provenance information of the returned tree sequence. (Default: True).
**kwargs – Further arguments used as parameters when constructing the returned
Tree
. For exampletskit.Tree.generate_comb(sample_lists=True)
will return aTree
created withsample_lists=True
.
 Returns
A combshaped bifurcating tree. Its corresponding
TreeSequence
is available via thetree_sequence
attribute. Return type
 static generate_random_binary(num_leaves, *, span=1, branch_length=1, random_seed=None, record_provenance=True, **kwargs)[source]¶
Generate a random binary
Tree
with \(n\) =num_leaves
leaves with an equal probability of returning any topology and leaf label permutation among the \((2n  3)! / (2^{n  2} (n  2)!)\) leaflabelled binary trees.The leaf nodes are marked as samples, labelled 0 to n, and placed at time 0. Internal node IDs are assigned sequentially from n as we ascend the tree, and the time of an internal node is the maximum time of its children plus the specified
branch_length
.Note
The returned tree has not been created under any explicit model of evolution. In order to simulate such trees, additional software such as msprime <https://github.com/tskitdev/msprime>` is required.
 Parameters
num_leaves (int) – The number of leaf nodes in the returned tree (must be 2 or greater).
span (float) – The span of the tree, and therefore the
sequence_length
of thetree_sequence
property of the returnedTree
.branch_length (float) – The minimum time between parent and child nodes.
random_seed (int) – The random seed. If this is None, a random seed will be automatically generated. Valid random seeds must be between 1 and \(2^32 − 1\).
record_provenance (bool) – If True, add details of this operation to the provenance information of the returned tree sequence. (Default: True).
**kwargs – Further arguments used as parameters when constructing the returned
Tree
. For exampletskit.Tree.generate_comb(sample_lists=True)
will return aTree
created withsample_lists=True
.
 Returns
A random binary tree. Its corresponding
TreeSequence
is available via thetree_sequence
attribute. Return type
The TreeSequence
class¶
Also see the TreeSequence API summary.
 class tskit.TreeSequence[source]¶
A single tree sequence, as defined by the data model. A TreeSequence instance can be created from a set of tables using
TableCollection.tree_sequence()
, or loaded from a set of text files usingtskit.load_text()
, or loaded from a native binary file usingtskit.load()
.TreeSequences are immutable. To change the data held in a particular tree sequence, first get the table information as a
TableCollection
instance (usingdump_tables()
), edit those tables using the tables api, and create a new tree sequence usingTableCollection.tree_sequence()
.The
trees()
method iterates over all trees in a tree sequence, and thevariants()
method iterates over all sites and their genotypes. equals(other, *, ignore_metadata=False, ignore_ts_metadata=False, ignore_provenance=False, ignore_timestamps=False, ignore_tables=False, ignore_reference_sequence=False)[source]¶
Returns True if self and other are equal. Uses the underlying table equality, see
TableCollection.equals()
for details and options.
 aslist(**kwargs)[source]¶
Returns the trees in this tree sequence as a list. Each tree is represented by a different instance of
Tree
. As such, this method is inefficient and may use a large amount of memory, and should not be used when performance is a consideration. Thetrees()
method is the recommended way to efficiently iterate over the trees in a tree sequence.
 dump(file_or_path, zlib_compression=False)[source]¶
Writes the tree sequence to the specified path or file object.
 property reference_sequence¶
The
ReferenceSequence
associated with thisTreeSequence
if one is defined (seeTreeSequence.has_reference_sequence()
), or None otherwise.
 has_reference_sequence()[source]¶
Returns True if this
TreeSequence
has an associated reference sequence.
 property tables_dict¶
Returns a dictionary mapping names to tables in the underlying
TableCollection
. Equivalent to callingts.tables.table_name_map
.
 property tables¶
Returns the
tables
underlying this tree sequence, intended for readonly access. Seedump_tables()
if you wish to modify the tables.Warning
This property currently returns a copy of the tables underlying a tree sequence but it may return a readonly view in the future. Thus, if the tables will subsequently be updated, please use the
dump_tables()
method instead as this will always return a new copy of the TableCollection. Returns
A
TableCollection
containing all a copy of the tables underlying this tree sequence. Return type
 property nbytes¶
Returns the total number of bytes required to store the data in this tree sequence. Note that this may not be equal to the actual memory footprint.
 dump_tables()[source]¶
Returns a modifiable copy of the
tables
defining this tree sequence. Returns
A
TableCollection
containing all tables underlying the tree sequence. Return type
 dump_text(nodes=None, edges=None, sites=None, mutations=None, individuals=None, populations=None, provenances=None, precision=6, encoding='utf8', base64_metadata=True)[source]¶
Writes a text representation of the tables underlying the tree sequence to the specified connections.
If Base64 encoding is not used, then metadata will be saved directly, possibly resulting in errors reading the tables back in if metadata includes whitespace.
 Parameters
nodes (io.TextIOBase) – The filelike object (having a .write() method) to write the NodeTable to.
edges (io.TextIOBase) – The filelike object to write the EdgeTable to.
sites (io.TextIOBase) – The filelike object to write the SiteTable to.
mutations (io.TextIOBase) – The filelike object to write the MutationTable to.
individuals (io.TextIOBase) – The filelike object to write the IndividualTable to.
populations (io.TextIOBase) – The filelike object to write the PopulationTable to.
provenances (io.TextIOBase) – The filelike object to write the ProvenanceTable to.
precision (int) – The number of digits of precision.
encoding (str) – Encoding used for text representation.
base64_metadata (bool) – Only used if a schema is not present on each table being dumped. If True, metadata is encoded using Base64 encoding; otherwise, as plain text.
 _repr_html_()[source]¶
Return an html summary of a tree sequence. Called by jupyter notebooks to render a TreeSequence.
 property num_samples¶
Returns the number of sample nodes in this tree sequence. This is also the number of sample nodes in each tree.
 Returns
The number of sample nodes in this tree sequence.
 Return type
 property table_metadata_schemas¶
The set of metadata schemas for the tables in this tree sequence.
 property discrete_genome¶
Returns True if all genome coordinates in this TreeSequence are discrete integer values. This is true iff all the following are true:
The sequence length is discrete
All site positions are discrete
All left and right edge coordinates are discrete
All migration left and right coordinates are discrete
 Returns
True if this TreeSequence uses discrete genome coordinates.
 Return type
 property discrete_time¶
Returns True if all time coordinates in this TreeSequence are discrete integer values. This is true iff all the following are true:
All node times are discrete
All mutation times are discrete
All migration times are discrete
Note that
tskit.UNKNOWN_TIME
counts as discrete. Returns
True if this TreeSequence uses discrete time coordinates.
 Return type
 property sequence_length¶
Returns the sequence length in this tree sequence. This defines the genomic scale over which tree coordinates are defined. Given a tree sequence with a sequence length \(L\), the constituent trees will be defined over the halfclosed interval \([0, L)\). Each tree then covers some subset of this interval — see
tskit.Tree.interval
for details. Returns
The length of the sequence in this tree sequence in bases.
 Return type
 property metadata¶
The decoded metadata for this TreeSequence.
 property metadata_schema¶
The
tskit.MetadataSchema
for this TreeSequence.
 property time_units¶
String describing the units of the time dimension for this TreeSequence.
 property num_edges¶
Returns the number of edges in this tree sequence.
 Returns
The number of edges in this tree sequence.
 Return type
 property num_trees¶
Returns the number of distinct trees in this tree sequence. This is equal to the number of trees returned by the
trees()
method. Returns
The number of trees in this tree sequence.
 Return type
 property num_sites¶
Returns the number of sites in this tree sequence.
 Returns
The number of sites in this tree sequence.
 Return type
 property num_mutations¶
Returns the number of mutations in this tree sequence.
 Returns
The number of mutations in this tree sequence.
 Return type
 property num_individuals¶
Returns the number of individuals in this tree sequence.
 Returns
The number of individuals in this tree sequence.
 Return type
 property num_nodes¶
Returns the number of nodes in this tree sequence.
 Returns
The number of nodes in this tree sequence.
 Return type
 property num_provenances¶
Returns the number of provenances in this tree sequence.
 Returns
The number of provenances in this tree sequence.
 Return type
 property num_populations¶
Returns the number of populations in this tree sequence.
 Returns
The number of populations in this tree sequence.
 Return type
 property num_migrations¶
Returns the number of migrations in this tree sequence.
 Returns
The number of migrations in this tree sequence.
 Return type
 property max_root_time¶
Returns the time of the oldest root in any of the trees in this tree sequence. This is usually equal to
np.max(ts.tables.nodes.time)
but may not be since there can be nonsample nodes that are not present in any tree. Note that isolated samples are also defined as roots (so there can be a max_root_time even in a tree sequence with no edges). Returns
The maximum time of a root in this tree sequence.
 Return type
 Raises
ValueError – If there are no samples in the tree, and hence no roots (as roots are defined by the ends of the upward paths from the set of samples).
 migrations()[source]¶
Returns an iterable sequence of all the migrations in this tree sequence.
Migrations are returned in nondecreasing order of the
time
value. Returns
An iterable sequence of all migrations.
 Return type
Sequence(
Migration
)
 individuals()[source]¶
Returns an iterable sequence of all the individuals in this tree sequence.
 Returns
An iterable sequence of all individuals.
 Return type
Sequence(
Individual
)
 nodes()[source]¶
Returns an iterable sequence of all the nodes in this tree sequence.
 Returns
An iterable sequence of all nodes.
 Return type
Sequence(
Node
)
 edges()[source]¶
Returns an iterable sequence of all the edges in this tree sequence. Edges are returned in the order required for a valid tree sequence. So, edges are guaranteed to be ordered such that (a) all parents with a given ID are contiguous; (b) edges are returned in nondecreasing order of parent time ago; (c) within the edges for a given parent, edges are sorted first by child ID and then by left coordinate.
 Returns
An iterable sequence of all edges.
 Return type
Sequence(
Edge
)
 edge_diffs(include_terminal=False)[source]¶
Returns an iterator over all the edges that are inserted and removed to build the trees as we move from lefttoright along the tree sequence. Each iteration yields a named tuple consisting of 3 values,
(interval, edges_out, edges_in)
. The first value,interval
, is the genomic interval(left, right)
covered by the incoming tree (seeTree.interval
). The second,edges_out
is a list of the edges that were justremoved to create the tree covering the interval (henceedges_out
will always be empty for the first tree). The last value,edges_in
, is a list of edges that were just inserted to construct the tree covering the current interval.The edges returned within each
edges_in
list are ordered by ascending time of the parent node, then ascending parent id, then ascending child id. The edges within eachedges_out
list are the reverse order (e.g. descending parent time, parent id, then child_id). This means that within each list, edges with the same parent appear consecutively. Parameters
include_terminal (bool) – If False (default), the iterator terminates after the final interval in the tree sequence (i.e., it does not report a final removal of all remaining edges), and the number of iterations will be equal to the number of trees in the tree sequence. If True, an additional iteration takes place, with the last
edges_out
value reporting all the edges contained in the final tree (with bothleft
andright
equal to the sequence length). Returns
An iterator over the (interval, edges_out, edges_in) tuples. This is a named tuple, so the 3 values can be accessed by position (e.g.
returned_tuple[0]
) or name (e.g.returned_tuple.interval
). Return type
 sites()[source]¶
Returns an iterable sequence of all the sites in this tree sequence. Sites are returned in order of increasing ID (and also position). See the
Site
class for details on the available fields for each site. Returns
An iterable sequence of all sites.
 Return type
Sequence(
Site
)
 mutations()[source]¶
Returns an iterator over all the mutations in this tree sequence. Mutations are returned in order of nondecreasing site ID. See the
Mutation
class for details on the available fields for each mutation.The returned iterator is equivalent to iterating over all sites and all mutations in each site, i.e.:
>>> for site in tree_sequence.sites(): >>> for mutation in site.mutations: >>> yield mutation
 Returns
An iterator over all mutations in this tree sequence.
 Return type
iter(
Mutation
)
 populations()[source]¶
Returns an iterable sequence of all the populations in this tree sequence.
 Returns
An iterable sequence of all populations.
 Return type
Sequence(
Population
)
 provenances()[source]¶
Returns an iterable sequence of all the provenances in this tree sequence.
 Returns
An iterable sequence of all provenances.
 Return type
Sequence(
Provenance
)
 breakpoints(as_array=False)[source]¶
Returns the breakpoints that separate trees along the chromosome, including the two extreme points 0 and L. This is equivalent to
>>> iter([0] + [t.interval.right for t in self.trees()])
By default we return an iterator over the breakpoints as Python float objects; if
as_array
is True we return them as a numpy array.Note that the
as_array
form will be more efficient and convenient in most cases; the default iterator behaviour is mainly kept to ensure compatibility with existing code. Parameters
as_array (bool) – If True, return the breakpoints as a numpy array.
 Returns
The breakpoints defined by the tree intervals along the sequence.
 Return type
 at(position, **kwargs)[source]¶
Returns the tree covering the specified genomic location. The returned tree will have
tree.interval.left
<=position
<tree.interval.right
. See alsoTree.seek()
.Warning
The current implementation of this operation is linear in the number of trees, so may be inefficient for large tree sequences. See this issue for more information.
 Parameters
 Returns
A new instance of
Tree
positioned to cover the specified genomic location. Return type
 at_index(index, **kwargs)[source]¶
Returns the tree at the specified index. See also
Tree.seek_index()
.Warning
The current implementation of this operation is linear in the number of trees, so may be inefficient for large tree sequences. See this issue for more information.
 Parameters
 Returns
A new instance of
Tree
positioned at the specified index. Return type
 first(**kwargs)[source]¶
Returns the first tree in this
TreeSequence
. To iterate over all trees in the sequence, use thetrees()
method.
 last(**kwargs)[source]¶
Returns the last tree in this
TreeSequence
. To iterate over all trees in the sequence, use thetrees()
method.
 trees(tracked_samples=None, *, sample_lists=False, root_threshold=1, sample_counts=None, tracked_leaves=None, leaf_counts=None, leaf_lists=None)[source]¶
Returns an iterator over the trees in this tree sequence. Each value returned in this iterator is an instance of
Tree
. Upon successful termination of the iterator, the tree will be in the “cleared” null state.The
sample_lists
andtracked_samples
parameters are passed to theTree
constructor, and control the options that are set in the returned tree instance.Warning
Do not store the results of this iterator in a list! For performance reasons, the same underlying object is used for every tree returned which will most likely lead to unexpected behaviour. If you wish to obtain a list of trees in a tree sequence please use
ts.aslist()
instead. Parameters
tracked_samples (list) – The list of samples to be tracked and counted using the
Tree.num_tracked_samples()
method.sample_lists (bool) – If True, provide more efficient access to the samples beneath a given node using the
Tree.samples()
method.root_threshold (int) – The minimum number of samples that a node must be ancestral to for it to be in the list of roots. By default this is 1, so that isolated samples (representing missing data) are roots. To efficiently restrict the roots of the tree to those subtending meaningful topology, set this to 2. This value is only relevant when trees have multiple roots.
sample_counts (bool) – Deprecated since 0.2.4.
 Returns
An iterator over the Trees in this tree sequence.
 Return type
collections.abc.Iterable,
Tree
 coiterate(other, **kwargs)[source]¶
Returns an iterator over the pairs of trees for each distinct interval in the specified pair of tree sequences.
 Parameters
other (TreeSequence) – The other tree sequence from which to take trees. The sequence length must be the same as the current tree sequence.
**kwargs – Further named arguments that will be passed to the
trees()
method when constructing the returned trees.
 Returns
An iterator returning successive tuples of the form
(interval, tree_self, tree_other)
. For example, the first item returned will consist of an tuple of the initial interval, the first tree of the current tree sequence, and the first tree of theother
tree sequence; the.left
attribute of the initial interval will be 0 and the.right
attribute will be the smallest nonzero breakpoint of the 2 tree sequences. Return type
 haplotypes(*, isolated_as_missing=None, missing_data_character=None, impute_missing_data=None)[source]¶
Returns an iterator over the strings of haplotypes that result from the trees and mutations in this tree sequence. Each haplotype string is guaranteed to be of the same length. A tree sequence with \(n\) samples and \(s\) sites will return a total of \(n\) strings of \(s\) alleles concatenated together, where an allele consists of a single ascii character (tree sequences that include alleles which are not a single character in length, or where the character is nonascii, will raise an error). The first string returned is the haplotype for sample
0
, and so on.The alleles at each site must be represented by single byte characters, (i.e., variants must be single nucleotide polymorphisms, or SNPs), hence the strings returned will all be of length \(s\), and for a haplotype
h
, the value ofh[j]
will be the observed allelic state at sitej
.If
isolated_as_missing
is True (the default), isolated samples without mutations directly above them will be treated as missing data and will be represented in the string by themissing_data_character
. If instead it is set to False, missing data will be assigned the ancestral state (unless they have mutations directly above them, in which case they will take the most recent derived mutational state for that node). This was the default behaviour in versions prior to 0.2.0. Prior to 0.3.0 the impute_missing_data argument controlled this behaviour.See also the
variants()
iterator for sitecentric access to sample genotypes.Warning
For large datasets, this method can consume a very large amount of memory! To output all the sample data, it is more efficient to iterate over sites rather than over samples. If you have a large dataset but only want to output the haplotypes for a subset of samples, it may be worth calling
simplify()
to reduce tree sequence down to the required samples before outputting haplotypes. Returns
An iterator over the haplotype strings for the samples in this tree sequence.
 Parameters
isolated_as_missing (bool) – If True, the allele assigned to missing samples (i.e., isolated samples without mutations) is the
missing_data_character
. If False, missing samples will be assigned the ancestral state. Default: True.missing_data_character (str) – A single ascii character that will be used to represent missing data. If any normal allele contains this character, an error is raised. Default: ‘N’.
impute_missing_data (bool) – Deprecated in 0.3.0. Use ``isolated_as_missing``, but inverting value. Will be removed in a future version
 Return type
 Raises
TypeError if the
missing_data_character
or any of the alleles at a site are not a single ascii character. Raises
ValueError if the
missing_data_character
exists in one of the alleles
 variants(*, as_bytes=False, samples=None, isolated_as_missing=None, alleles=None, impute_missing_data=None)[source]¶
Returns an iterator over the variants (each site with its genotypes and alleles) in this tree sequence. See the
Variant
class for details on the fields of each returned object. Thegenotypes
for the variants are numpy arrays, corresponding to indexes into thealleles
attribute in theVariant
object. By default, thealleles
for each site are generated automatically, such that the ancestral state is at the zeroth index and subsequent alleles are listed in no particular order. This means that the encoding of alleles in terms of genotype values can vary from sitetosite, which is sometimes inconvenient. It is possible to specify a fixed mapping from allele strings to genotype values using thealleles
parameter. For example, if we setalleles=("A", "C", "G", "T")
, this will map allele “A” to 0, “C” to 1 and so on (theALLELES_ACGT
constant provides a shortcut for this common mapping).By default, genotypes are generated for all samples. The
samples
parameter allows us to specify the nodes for which genotypes are generated; output order of genotypes in the returned variants corresponds to the order of the samples in this list. It is also possible to provide nonsample nodes as an argument here, if you wish to generate genotypes for (e.g.) internal nodes. However,isolated_as_missing
must be False in this case, as it is not possible to detect missing data for nonsample nodes.If isolated samples are present at a given site without mutations above them, they are interpreted by default as missing data, and the genotypes array will contain a special value
MISSING_DATA
(1) to identify them while thealleles
tuple will end with the valueNone
(note that this will be the case whether or not we specify a fixed mapping using thealleles
parameter; see theVariant
class for more details). Alternatively, ifisolated_as_missing
is set to to False, such isolated samples will not be treated as missing, and instead assigned the ancestral state (this was the default behaviour in versions prior to 0.2.0). Prior to 0.3.0 the impute_missing_data argument controlled this behaviour.Note
The
as_bytes
parameter is kept as a compatibility option for older code. It is not the recommended way of accessing variant data, and will be deprecated in a later release. Parameters
as_bytes (bool) – If True, the genotype values will be returned as a Python bytes object. Legacy use only.
samples (array_like) – An array of node IDs for which to generate genotypes, or None for all sample nodes. Default: None.
isolated_as_missing (bool) – If True, the genotype value assigned to missing samples (i.e., isolated samples without mutations) is
MISSING_DATA
(1). If False, missing samples will be assigned the allele index for the ancestral state. Default: True.alleles (tuple) – A tuple of strings defining the encoding of alleles as integer genotype values. At least one allele must be provided. If duplicate alleles are provided, output genotypes will always be encoded as the first occurrence of the allele. If None (the default), the alleles are encoded as they are encountered during genotype generation.
impute_missing_data (bool) – Deprecated in 0.3.0. Use ``isolated_as_missing``, but inverting value. Will be removed in a future version
 Returns
An iterator over all variants in this tree sequence.
 Return type
iter(
Variant
)
 genotype_matrix(*, isolated_as_missing=None, alleles=None, impute_missing_data=None)[source]¶
Returns an \(m \times n\) numpy array of the genotypes in this tree sequence, where \(m\) is the number of sites and \(n\) the number of samples. The genotypes are the indexes into the array of
alleles
, as described for theVariant
class.If isolated samples are present at a given site without mutations above them, they will be interpreted as missing data the genotypes array will contain a special value
MISSING_DATA
(1) to identify these missing samples.Such samples are treated as missing data by default, but if
isolated_as_missing
is set to to False, they will not be treated as missing, and so assigned the ancestral state. This was the default behaviour in versions prior to 0.2.0. Prior to 0.3.0 the impute_missing_data argument controlled this behaviour.Warning
This method can consume a very large amount of memory! If all genotypes are not needed at once, it is usually better to access them sequentially using the
variants()
iterator. Parameters
isolated_as_missing (bool) – If True, the genotype value assigned to missing samples (i.e., isolated samples without mutations) is
MISSING_DATA
(1). If False, missing samples will be assigned the allele index for the ancestral state. Default: True.alleles (tuple) – A tuple of strings describing the encoding of alleles to genotype values. At least one allele must be provided. If duplicate alleles are provided, output genotypes will always be encoded as the first occurrence of the allele. If None (the default), the alleles are encoded as they are encountered during genotype generation.
impute_missing_data (bool) – Deprecated in 0.3.0. Use ``isolated_as_missing``, but inverting value. Will be removed in a future version
 Returns
The full matrix of genotypes.
 Return type
numpy.ndarray (dtype=np.int8)
 alignments(*, reference_sequence=None, missing_data_character=None)[source]¶
Returns an iterator over the full sequence alignments for the samples in this tree sequence. Each alignment
a
is a string of lengthL
whereL
is thesequence_length
of this tree sequence (which must havediscrete_genome
equal to True), anda[j]
is the nucleotide value for positionj
on the sequence.Note
This is inherently a zerobased representation of the sequence coordinate space. Care will be needed when interacting with other libraries and upstream coordinate spaces.
The sites in a tree sequence will usually only define the variation for a subset of the
L
nucleotide positions along the genome, and the remaining positions are filled using a reference sequence. The reference sequence data is defined either via thereference_sequence
parameter to this method, or embedded within with the tree sequence itself via theTreeSequence.reference_sequence
.Site information from the tree sequence takes precedence over the reference sequence so that, for example, at a site with no mutations all samples will have the site’s ancestral state.
The reference sequence bases are determined in the following way:
If the
reference_sequence
parameter is supplied this will be used, regardless of whether the tree sequence has an embedded reference sequence.Otherwise, if the tree sequence has an embedded reference sequence, this will be used.
If the
reference_sequence
parameter is not specified and there is no embedded reference sequence,L
copies of themissing_data_character
(which defaults to ‘N’) are used instead.
Warning
The
ReferenceSequence
API is preliminary and some behaviours may change in the future. In particular, a tree sequence is currently regarded as having an embedded reference sequence even if it only has some metadata defined. In this case thereference_sequence
parameter will need to be explicitly set.Note
Two common options for setting a reference sequence are:
Mark them as missing data, by setting
reference_sequence="N" * int(ts.sequence_length)
Fill the gaps with random nucleotides, by setting
reference_sequence=tskit.random_nucleotides(ts.sequence_length)
. See therandom_nucleotides()
function for more information.
Warning
Insertions and deletions are not currently supported and the alleles at each site must be represented by single byte characters, (i.e., variants must be single nucleotide polymorphisms, or SNPs).
Warning
Missing data is not currently supported by this method and it will raise a ValueError if called on tree sequences containing isolated samples. See https://github.com/tskitdev/tskit/issues/1896 for more information.
See also the
variants()
iterator for sitecentric access to sample genotypes andhaplotypes()
for access to sample sequences at just the sites in the tree sequence. Returns
An iterator over the alignment strings for the samples in this tree sequence.
 Parameters
 Return type
 Raises
ValueError if any genome coordinate in this tree sequence is not discrete, or if the
reference_sequence
is not of the correct length. Raises
TypeError if any of the alleles at a site are not a single ascii character.
 individual(id_)[source]¶
Returns the individual in this tree sequence with the specified ID.
 Return type
 migration(id_)[source]¶
Returns the migration in this tree sequence with the specified ID.
 Return type
 mutation(id_)[source]¶
Returns the mutation in this tree sequence with the specified ID.
 Return type
 population(id_)[source]¶
Returns the population in this tree sequence with the specified ID.
 Return type
 provenance(id_)[source]¶
Returns the provenance in this tree sequence with the specified ID.
 samples(population=None, *, population_id=None, time=None)[source]¶
Returns an array of the sample node IDs in this tree sequence. If population is specified, only return sample IDs from that population. It is also possible to restrict samples by time using the parameter time. If time is a numeric value, only return sample IDs whose node time is approximately equal to the specified time. If time is a pair of values of the form (min_time, max_time), only return sample IDs whose node time t is in this interval such that min_time <= t < max_time.
 Parameters
 Returns
A numpy array of the node IDs for the samples of interest, listed in numerical order.
 Return type
numpy.ndarray (dtype=np.int32)
 write_vcf(output, ploidy=None, contig_id='1', individuals=None, individual_names=None, position_transform=None)[source]¶
Writes a VCF formatted file to the specified filelike object. If there is individual information present in the tree sequence (see Individual Table), the values for sample nodes associated with these individuals are combined into phased multiploid individuals and output.
If there is no individual data present in the tree sequence, synthetic individuals are created by combining adjacent samples, and the number of samples combined is equal to the specified ploidy value (1 by default). For example, if we have a ploidy of 2 and a sample of size 6, then we will have 3 diploid samples in the output, consisting of the combined genotypes for samples [0, 1], [2, 3] and [4, 5]. If we had genotypes 011110 at a particular variant, then we would output the diploid genotypes 01, 11 and 10 in VCF.
Each individual in the output is identified by a string; these are the VCF “sample” names. By default, these are of the form
tsk_0
,tsk_1
etc, up to the number of individuals, but can be manually specified using theindividual_names
argument. We do not check for duplicates in this array, or perform any checks to ensure that the output VCF is wellformed.Note
Warning to
plink
users:As the default first individual name is
tsk_0
,plink
will throw this error when loading the VCF:Error: Sample ID ends with "_0", which induces an invalid IID of '0'.
This can be fixed by using the
individual_names
argument to set the names to anything where the first name doesn’t end with_0
. An example implementation for diploid individuals is:n_dip_indv = int(ts.num_samples / 2) indv_names = [f"tsk_{str(i)}indv" for i in range(n_dip_indv)] with open("output.vcf", "w") as vcf_file: ts.write_vcf(vcf_file, ploidy=2, individual_names=indv_names)
Adding a second
_
(eg:tsk_0_indv
) is not recommended asplink
uses_
as the default separator for separating family id and individual id, and two_
will throw an error.The REF value in the output VCF is the ancestral allele for a site and ALT values are the remaining alleles. It is important to note, therefore, that for real data this means that the REF value for a given site may not be equal to the reference allele. We also do not check that the alleles result in a valid VCF—for example, it is possible to use the tab character as an allele, leading to a broken VCF.
The
position_transform
argument provides a way to flexibly translate the genomic location of sites in tskit to the appropriate value in VCF. There are two fundamental differences in the way that tskit and VCF define genomic coordinates. The first is that tskit uses floating point values to encode positions, whereas VCF uses integers. Thus, if the tree sequence contains positions at nonintegral locations there is an information loss incurred by translating to VCF. By default, we round the site positions to the nearest integer, such that there may be several sites with the same integer position in the output. The second difference between VCF and tskit is that VCF is defined to be a 1based coordinate system, whereas tskit uses 0based. However, how coordinates are transformed depends on the VCF parser, and so we do not account for this change in coordinate system by default.Example usage:
with open("output.vcf", "w") as vcf_file: tree_sequence.write_vcf(vcf_file, ploidy=2)
The VCF output can also be compressed using the
gzip
module, if you wish:import gzip with gzip.open("output.vcf.gz", "wt") as f: ts.write_vcf(f)
However, this gzipped VCF may not be fully compatible with downstream tools such as tabix, which may require the VCF use the specialised bgzip format. A general way to convert VCF data to various formats is to pipe the text produced by
tskit
intobcftools
, as done here:import os import subprocess read_fd, write_fd = os.pipe() write_pipe = os.fdopen(write_fd, "w") with open("output.bcf", "w") as bcf_file: proc = subprocess.Popen( ["bcftools", "view", "O", "b"], stdin=read_fd, stdout=bcf_file ) ts.write_vcf(write_pipe) write_pipe.close() os.close(read_fd) proc.wait() if proc.returncode != 0: raise RuntimeError("bcftools failed with status:", proc.returncode)
This can also be achieved on the command line use the
tskit vcf
command, e.g.:$ tskit vcf example.trees  bcftools view O b > example.bcf
 Parameters
output (io.IOBase) – The filelike object to write the VCF output.
ploidy (int) – The ploidy of the individuals to be written to VCF. This sample size must be evenly divisible by ploidy.
contig_id (str) – The value of the CHROM column in the output VCF.
individuals (list(int)) – A list containing the individual IDs to write out to VCF. Defaults to all individuals in the tree sequence.
individual_names (list(str)) – A list of string names to identify individual columns in the VCF. In VCF nomenclature, these are the sample IDs. If specified, this must be a list of strings of length equal to the number of individuals to be output. Note that we do not check the form of these strings in any way, so that is is possible to output malformed VCF (for example, by embedding a tab character within on of the names). The default is to output
tsk_j
for the jth individual.position_transform – A callable that transforms the site position values into integer valued coordinates suitable for VCF. The function takes a single positional parameter x and must return an integer numpy array the same dimension as x. By default, this is set to
numpy.round()
which will round values to the nearest integer. If the string “legacy” is provided here, the pre 0.2.0 legacy behaviour of rounding values to the nearest integer (starting from 1) and avoiding the output of identical positions by incrementing is used.
 write_fasta(file_or_path, *, wrap_width=60, reference_sequence=None, missing_data_character=None)[source]¶
Writes the
alignments()
for this tree sequence to file in FASTA format. Please see thealignments()
method for details on how reference sequences are handled.Alignments are returned for the sample nodes in this tree sequence, and a sample with node id
u
is given the labelf"n{u}"
, following the same convention as thewrite_nexus()
andTree.as_newick()
methods.The
wrap_width
parameter controls the maximum width of lines of sequence data in the output. By default this is 60 characters in accordance with fasta standard outputs. To turn off linewrapping of sequences, setwrap_width
= 0.Example usage:
ts.write_fasta("output.fa")
Warning
Missing data is not currently supported by this method and it will raise a ValueError if called on tree sequences containing isolated samples. See https://github.com/tskitdev/tskit/issues/1896 for more information.
 Parameters
file_or_path – The file object or path to write the output. Paths can be either strings or
pathlib.Path
objects.wrap_width (int) – The number of sequence characters to include on each line in the fasta file, before wrapping to the next line for each sequence, or 0 to turn off line wrapping. (Default=60).
reference_sequence (str) – As for the
alignments()
method.missing_data_character (str) – As for the
alignments()
method.
 as_fasta(**kwargs)[source]¶
Return the result of
write_fasta()
as a string. Keyword parameters are as defined inwrite_fasta()
. Returns
A FASTA encoding of the alignments in this tree sequence as a string.
 Return type
 write_nexus(file_or_path, *, precision=None, include_trees=None, include_alignments=None, reference_sequence=None, missing_data_character=None)[source]¶
Returns a nexus encoding of this tree sequence. By default, tree topologies are included in the output, and sequence data alignments are included by default if this tree sequence has discrete genome coordinates and one or more sites. Inclusion of these sections can be controlled manually using the
include_trees
andinclude_alignments
parameters.Tree topologies and branch lengths are listed sequentially in the TREES block and the spatial location of each tree encoded within the tree name labels. Specifically, a tree spanning the interval \([x, y)\) is given the name
f"t{x}^{y}"
(See below for a description of the precision at which these spatial coordinates are printed out).The sample nodes in this tree sequence are regarded as taxa, and a sample with node id
u
is given the labelf"n{u}"
, following the same convention as theTree.as_newick()
method.By default, genome positions are printed out with with sufficient precision for them to be recovered exactly in double precision. If the tree sequence is defined on a
discrete_genome
, then positions are written out as integers. Otherwise, 17 digits of precision is used. Branch length precision defaults are handled in the same way asTree.as_newick()
.If the
precision
argument is provided, genome positions and branch lengths are printed out with this many digits of precision.For example, here is the nexus encoding of a simple tree sequence with integer times and genome coordinates with three samples and two trees:
#NEXUS BEGIN TAXA; DIMENSIONS NTAX=3; TAXLABELS n0 n1 n2; END; BEGIN TREES; TREE t0^2 = [&R] (n0:3,(n1:2,n2:2):1); TREE t2^10 = [&R] (n1:2,(n0:1,n2:1):1); END;
If sequence data
alignments()
are defined for this tree sequence and there is at least one site present, sequence alignment data will also be included by default (this can be suppressed by settinginclude_alignments=False
). For example, this tree sequence has a sequence length of 10, two variable sites and no reference sequence:#NEXUS BEGIN TAXA; DIMENSIONS NTAX=3; TAXLABELS n0 n1 n2; END; BEGIN DATA; DIMENSIONS NCHAR=10; FORMAT DATATYPE=DNA MISSING=?; MATRIX n0 ??G??????T n1 ??A??????C n2 ??A??????C ; END; BEGIN TREES; TREE t0^10 = [&R] (n0:2,(n1:1,n2:1):1); END;
Please see the
alignments()
method for details on how reference sequences are handled.Note
Note the default
missing_data_character
for this method is “?” rather then “N”, in keeping with common conventions for nexus data. This can be changed using themissing_data_character
parameter.Warning
Missing data is not supported for encoding tree topology information as our convention of using trees with multiple roots is not often supported by newick parsers. Thus, the method will raise a ValueError if we try to output trees with multiple roots. Additionally, missing data is not currently supported for alignment data. See https://github.com/tskitdev/tskit/issues/1896 for more information.
 Parameters
precision (int) – The numerical precision with which branch lengths and tree positions are printed.
include_trees (bool) – True if the tree topology information should be included; False otherwise (default=True).
include_alignments (bool) – True if the sequence data alignment information should be included; False otherwise (default=True if sequence alignments are welldefined and the tree sequence contains at least one site).
reference_sequence (str) – As for the
alignments()
method.missing_data_character (str) – As for the
alignments()
method, but defaults to “?”.
 Returns
A nexus representation of this
TreeSequence
 Return type
 as_nexus(**kwargs)[source]¶
Return the result of
write_nexus()
as a string. Keyword parameters are as defined inwrite_nexus()
. Returns
A nexus encoding of the alignments in this tree sequence as a string.
 Return type
 to_macs()[source]¶
Return a macs encoding of this tree sequence.
 Returns
The macs representation of this TreeSequence as a string.
 Return type
 simplify(samples=None, *, map_nodes=False, reduce_to_site_topology=False, filter_populations=True, filter_individuals=True, filter_sites=True, keep_unary=False, keep_unary_in_individuals=None, keep_input_roots=False, record_provenance=True, filter_zero_mutation_sites=None)[source]¶
Returns a simplified tree sequence that retains only the history of the nodes given in the list
samples
. Ifmap_nodes
is true, also return a numpy array whoseu
th element is the ID of the node in the simplified tree sequence that corresponds to nodeu
in the original tree sequence, ortskit.NULL
(1) ifu
is no longer present in the simplified tree sequence.In the returned tree sequence, the node with ID
0
corresponds tosamples[0]
, node1
corresponds tosamples[1]
etc., and all the passedin nodes are flagged as samples. The remaining node IDs in the returned tree sequence are allocated sequentially in time order and are not flagged as samples.If you wish to simplify a set of tables that do not satisfy all requirements for building a TreeSequence, then use
TableCollection.simplify()
.If the
reduce_to_site_topology
parameter is True, the returned tree sequence will contain only topological information that is necessary to represent the trees that contain sites. If there are zero sites in this tree sequence, this will result in an output tree sequence with zero edges. When the number of sites is greater than zero, every tree in the output tree sequence will contain at least one site. For a given site, the topology of the tree containing that site will be identical (up to node ID remapping) to the topology of the corresponding tree in the input tree sequence.If
filter_populations
,filter_individuals
orfilter_sites
is True, any of the corresponding objects that are not referenced elsewhere are filtered out. As this is the default behaviour, it is important to realise IDs for these objects may change through simplification. By setting these parameters to False, however, the corresponding tables can be preserved without changes. Parameters
samples (list[int]) – A list of node IDs to retain as samples. They need not be nodes marked as samples in the original tree sequence, but will constitute the entire set of samples in the returned tree sequence. If not specified or None, use all nodes marked with the IS_SAMPLE flag. The list may be provided as a numpy array (or arraylike) object (dtype=np.int32).
map_nodes (bool) – If True, return a tuple containing the resulting tree sequence and a numpy array mapping node IDs in the current tree sequence to their corresponding node IDs in the returned tree sequence. If False (the default), return only the tree sequence object itself.
reduce_to_site_topology (bool) – Whether to reduce the topology down to the trees that are present at sites. (Default: False)
filter_populations (bool) – If True, remove any populations that are not referenced by nodes after simplification; new population IDs are allocated sequentially from zero. If False, the population table will not be altered in any way. (Default: True)
filter_individuals (bool) – If True, remove any individuals that are not referenced by nodes after simplification; new individual IDs are allocated sequentially from zero. If False, the individual table will not be altered in any way. (Default: True)
filter_sites (bool) – If True, remove any sites that are not referenced by mutations after simplification; new site IDs are allocated sequentially from zero. If False, the site table will not be altered in any way. (Default: True)
keep_unary (bool) – If True, preserve unary nodes (i.e., nodes with exactly one child) that exist on the path from samples to root. (Default: False)
keep_unary_in_individuals (bool) – If True, preserve unary nodes that exist on the path from samples to root, but only if they are associated with an individual in the individuals table. Cannot be specified at the same time as
keep_unary
. (Default:None
, equivalent to False)keep_input_roots (bool) – Whether to retain history ancestral to the MRCA of the samples. If
False
, no topology older than the MRCAs of the samples will be included. IfTrue
the roots of all trees in the returned tree sequence will be the same roots as in the original tree sequence. (Default: False)record_provenance (bool) – If True, record details of this call to simplify in the returned tree sequence’s provenance information (Default: True).
filter_zero_mutation_sites (bool) – Deprecated alias for
filter_sites
.
 Returns
The simplified tree sequence, or (if
map_nodes
is True) a tuple consisting of the simplified tree sequence and a numpy array mapping source node IDs to their corresponding IDs in the new tree sequence. Return type
 delete_sites(site_ids, record_provenance=True)[source]¶
Returns a copy of this tree sequence with the specified sites (and their associated mutations) entirely removed. The site IDs do not need to be in any particular order, and specifying the same ID multiple times does not have any effect (i.e., calling
tree_sequence.delete_sites([0, 1, 1])
has the same effect as callingtree_sequence.delete_sites([0, 1])
.
 delete_intervals(intervals, simplify=True, record_provenance=True)[source]¶
Returns a copy of this tree sequence for which information in the specified list of genomic intervals has been deleted. Edges spanning these intervals are truncated or deleted, and sites and mutations falling within them are discarded. Note that it is the information in the intervals that is deleted, not the intervals themselves, so in particular, all samples will be isolated in the deleted intervals.
Note that node IDs may change as a result of this operation, as by default
simplify()
is called on the returned tree sequence to remove redundant nodes. If you wish to map node IDs onto the same nodes before and after this method has been called, specifysimplify=False
.See also
keep_intervals()
,ltrim()
,rtrim()
, and missing data. Parameters
intervals (array_like) – A list (start, end) pairs describing the genomic intervals to delete. Intervals must be nonoverlapping and in increasing order. The list of intervals must be interpretable as a 2D numpy array with shape (N, 2), where N is the number of intervals.
simplify (bool) – If True, return a simplified tree sequence where nodes no longer used are discarded. (Default: True).
record_provenance (bool) – If
True
, add details of this operation to the provenance information of the returned tree sequence. (Default:True
).
 Return type
 keep_intervals(intervals, simplify=True, record_provenance=True)[source]¶
Returns a copy of this tree sequence which includes only information in the specified list of genomic intervals. Edges are truncated to lie within these intervals, and sites and mutations falling outside these intervals are discarded. Note that it is the information outside the intervals that is deleted, not the intervals themselves, so in particular, all samples will be isolated outside of the retained intervals.
Note that node IDs may change as a result of this operation, as by default
simplify()
is called on the returned tree sequence to remove redundant nodes. If you wish to map node IDs onto the same nodes before and after this method has been called, specifysimplify=False
.See also
keep_intervals()
,ltrim()
,rtrim()
, and missing data. Parameters
intervals (array_like) – A list (start, end) pairs describing the genomic intervals to keep. Intervals must be nonoverlapping and in increasing order. The list of intervals must be interpretable as a 2D numpy array with shape (N, 2), where N is the number of intervals.
simplify (bool) – If True, return a simplified tree sequence where nodes no longer used are discarded. (Default: True).
record_provenance (bool) – If True, add details of this operation to the provenance information of the returned tree sequence. (Default: True).
 Return type
 ltrim(record_provenance=True)[source]¶
Returns a copy of this tree sequence with a potentially changed coordinate system, such that empty regions (i.e., those not covered by any edge) at the start of the tree sequence are trimmed away, and the leftmost edge starts at position 0. This affects the reported position of sites and edges. Additionally, sites and their associated mutations to the left of the new zero point are thrown away.
 Parameters
record_provenance (bool) – If True, add details of this operation to the provenance information of the returned tree sequence. (Default: True).
 rtrim(record_provenance=True)[source]¶
Returns a copy of this tree sequence with the
sequence_length
property reset so that the sequence ends at the end of the rightmost edge. Additionally, sites and their associated mutations at positions greater than the newsequence_length
are thrown away. Parameters
record_provenance (bool) – If True, add details of this operation to the provenance information of the returned tree sequence. (Default: True).
 trim(record_provenance=True)[source]¶
Returns a copy of this tree sequence with any empty regions (i.e., those not covered by any edge) on the right and left trimmed away. This may reset both the coordinate system and the
sequence_length
property. It is functionally equivalent tortrim()
followed byltrim()
. Sites and their associated mutations in the empty regions are thrown away. Parameters
record_provenance (bool) – If True, add details of this operation to the provenance information of the returned tree sequence. (Default: True).
 subset(nodes, record_provenance=True, reorder_populations=True, remove_unreferenced=True)[source]¶
Returns a tree sequence containing only information directly referencing the provided list of nodes to retain. The result will retain only the nodes whose IDs are listed in
nodes
, only edges for which both parent and child are innodes`
, only mutations whose node is innodes
, and only individuals that are referred to by one of the retained nodes. Note that this does not retain the ancestry of these nodes  for that, seesimplify()
.This has the side effect of reordering the nodes, individuals, and populations in the tree sequence: the nodes in the new tree sequence will be in the order provided in
nodes
, and both individuals and populations will be ordered by the earliest retained node that refers to them. (However,reorder_populations
may be set to False to keep the population table unchanged.)By default, the method removes all individuals and populations not referenced by any nodes, and all sites not referenced by any mutations. To retain these unreferenced individuals, populations, and sites, pass
remove_unreferenced=False
. If this is done, the site table will remain unchanged, unreferenced individuals will appear at the end of the individuals table (and in their original order), and unreferenced populations will appear at the end of the population table (unlessreorder_populations=False
).See also
keep_intervals()
for subsetting a given portion of the genome;simplify()
for retaining the ancestry of a subset of nodes. Parameters
nodes (list) – The list of nodes for which to retain information. This may be a numpy array (or arraylike) object (dtype=np.int32).
record_provenance (bool) – Whether to record a provenance entry in the provenance table for this operation.
reorder_populations (bool) – Whether to reorder populations (default: True). If False, the population table will not be altered in any way.
remove_unreferenced (bool) – Whether sites, individuals, and populations that are not referred to by any retained entries in the tables should be removed (default: True). See the description for details.
 Return type
 union(other, node_mapping, check_shared_equality=True, add_populations=True, record_provenance=True)[source]¶
Returns an expanded tree sequence which contains the nodewise union of
self
andother
, obtained by adding the nonshared portions ofother
ontoself
. The “shared” portions are specified using a map that specifies which nodes inother
are equivalent to those inself
: thenode_mapping
argument should be an array of length equal to the number of nodes inother
and whose entries are the ID of the matching node inself
, ortskit.NULL
if there is no matching node. Those nodes inother
that map totskit.NULL
will be added toself
, along with:Individuals whose nodes are new to
self
.Edges whose parent or child are new to
self
.Mutations whose nodes are new to
self
.Sites which were not present in
self
, if the site contains a newly added mutation.
By default, populations of newly added nodes are assumed to be new populations, and added to the population table as well.
Note that this operation also sorts the resulting tables, so the resulting tree sequence may not be equal to
self
even if nothing new was added (although it would differ only in ordering of the tables). Parameters
other (TableCollection) – Another table collection.
node_mapping (list) – An array of node IDs that relate nodes in
other
to nodes inself
.check_shared_equality (bool) – If True, the shared portions of the tree sequences will be checked for equality. It does so by subsetting both
self
andother
on the equivalent nodes specified innode_mapping
, and then checking for equality of the subsets.add_populations (bool) – If True, nodes new to
self
will be assigned new population IDs.record_provenance (bool) – Whether to record a provenance entry in the provenance table for this operation.
 draw_svg(path=None, *, size=None, x_scale=None, time_scale=None, tree_height_scale=None, node_labels=None, mutation_labels=None, root_svg_attributes=None, style=None, order=None, force_root_branch=None, symbol_size=None, x_axis=None, x_label=None, x_lim=None, y_axis=None, y_label=None, y_ticks=None, y_gridlines=None, **kwargs)[source]¶
Return an SVG representation of a tree sequence. See the visualization tutorial for more details.
 Parameters
path (str) – The path to the file to write the output. If None, do not write to file.
size (tuple(int, int)) – A tuple of (width, height) giving the width and height of the produced SVG drawing in abstract user units (usually interpreted as pixels on display).
x_scale (str) – Control how the X axis is drawn. If “physical” (the default) the axis scales linearly with physical distance along the sequence, background shading is used to indicate the position of the trees along the X axis, and sites (with associated mutations) are marked at the appropriate physical position on axis line. If “treewise”, each axis tick corresponds to a tree boundary, which are positioned evenly along the axis, so that the X axis is of variable scale, no background scaling is required, and site positions are not marked on the axis.
time_scale (str) – Control how height values for nodes are computed. If this is equal to
"time"
, node heights are proportional to their time values (this is the default). If this is equal to"log_time"
, node heights are proportional to their log(time) values. If it is equal to"rank"
, node heights are spaced equally according to their ranked times.tree_height_scale (str) – Deprecated alias for time_scale. (Deprecated in 0.3.6)
node_labels (dict(int, str)) – If specified, show custom labels for the nodes (specified by ID) that are present in this map; any nodes not present will not have a label.
mutation_labels (dict(int, str)) – If specified, show custom labels for the mutations (specified by ID) that are present in the map; any mutations not present will not have a label.
root_svg_attributes (dict) – Additional attributes, such as an id, that will be embedded in the root
<svg>
tag of the generated drawing.style (str) – A css string that will be included in the
<style>
tag of the generated svg.order (str) – The lefttoright ordering of child nodes in each drawn tree. This can be either:
"minlex"
, which minimises the differences between adjacent trees (see also the"minlex_postorder"
traversal order for theTree.nodes()
method); or"tree"
which draws trees in the lefttoright order defined by the quintuply linked tree structure. If not specified or None, this defaults to"minlex"
.force_root_branch (bool) – If
True
plot a branch (edge) above every tree root in the tree sequence. IfNone
(default) then only plot such root branches if any root in the tree sequence has a mutation above it.symbol_size (float) – Change the default size of the node and mutation plotting symbols. If
None
(default) use a standard size.x_axis (bool) – Should the plot have an X axis line, showing the positions of trees along the genome. The scale used is determined by the
x_scale
parameter. IfNone
(default) plot an X axis.x_label (str) – Place a label under the plot. If
None
(default) and there is an X axis, create and place an appropriate label.x_lim (list) – A list of size two giving the genomic positions between which trees should be plotted. If the first is
None
, then plot from the first nonempty region of the tree sequence. If the second isNone
, then plot up to the end of the last nonempty region of the tree sequence. The default valuex_lim=None
is shorthand for the list [None
,None
]. If numerical values are given, then regions outside the interval have all information discarded: this means that mutations outside the interval will not be shown. To force display of the entire tree sequence, including empty flanking regions, specifyx_lim=[0, ts.sequence_length]
.y_axis (bool) – Should the plot have an Y axis line, showing time (or ranked node time if
time_scale="rank"
. IfNone
(default) do not plot a Y axis.y_label (str) – Place a label to the left of the plot. If
None
(default) and there is a Y axis, create and place an appropriate label.y_ticks (list) – A list of Y values at which to plot tickmarks (
[]
gives no tickmarks). IfNone
, plot one tickmark for each unique node value.y_gridlines (bool) – Whether to plot horizontal lines behind the tree at each y tickmark.
 Returns
An SVG representation of a tree sequence.
 Return type
Note
Technically, x_lim[0] specifies a minimum value for the start of the X axis, and x_lim[1] specifies a maximum value for the end. This is only relevant if the tree sequence contains “empty” regions with no edges or mutations. In this case if x_lim[0] lies strictly within an empty region (i.e.,
empty_tree.interval.left < x_lim[0] < empty_tree.interval.right
) then that tree will not be plotted on the left hand side, and the X axis will start atempty_tree.interval.right
. Similarly, if x_lim[1] lies strictly within an empty region then that tree will not be plotted on the right hand side, and the X axis will end atempty_tree.interval.left
 draw_text(*, node_labels=None, use_ascii=False, time_label_format=None, position_label_format=None, order=None, **kwargs)[source]¶
Create a text representation of a tree sequence.
 Parameters
node_labels (dict) – If specified, show custom labels for the nodes that are present in the map. Any nodes not specified in the map will not have a node label.
use_ascii (bool) – If
False
(default) then use unicode box drawing characters to render the tree. IfTrue
, use plain ascii characters, which look cruder but are less susceptible to misalignment or font substitution. Alternatively, if you are having alignment problems with Unicode, you can try out the solution documented here.time_label_format (str) – A python format string specifying the format (e.g. number of decimal places or significant figures) used to print the numerical time values on the time axis. If
None
, this defaults to"{:.2f}"
.position_label_format (str) – A python format string specifying the format (e.g. number of decimal places or significant figures) used to print genomic positions. If
None
, this defaults to"{:.2f}"
.order (str) – The lefttoright ordering of child nodes in the drawn tree. This can be either:
"minlex"
, which minimises the differences between adjacent trees (see also the"minlex_postorder"
traversal order for theTree.nodes()
method); or"tree"
which draws trees in the lefttoright order defined by the quintuply linked tree structure. If not specified or None, this defaults to"minlex"
.
 Returns
A text representation of a tree sequence.
 Return type
 general_stat(W, f, output_dim, windows=None, polarised=False, mode=None, span_normalise=True, strict=True)[source]¶
Compute a windowed statistic from weights and a summary function. See the statistics interface section for details on windows, mode, span normalise, and return value. On each tree, this propagates the weights
W
up the tree, so that the “weight” of each node is the sum of the weights of all samples at or below the node. Then the summary functionf
is applied to the weights, giving a summary for each node in each tree. How this is then aggregated depends onmode
: “site”
Adds together the total summary value across all alleles in each window.
 “branch”
Adds together the summary value for each node, multiplied by the length of the branch above the node and the span of the tree.
 “node”
Returns each node’s summary value added across trees and multiplied by the span of the tree.
Both the weights and the summary can be multidimensional: if
W
hask
columns, andf
takes ak
vector and returns anm
vector, then the output will bem
dimensional for each node or window (depending on “mode”).Note
The summary function
f
should return zero when given both 0 and the total weight (i.e.,f(0) = 0
andf(np.sum(W, axis=0)) = 0
), unlessstrict=False
. This is necessary for the statistic to be unaffected by parts of the tree sequence ancestral to none or all of the samples, respectively. Parameters
W (numpy.ndarray) – An array of values with one row for each sample and one column for each weight.
f – A function that takes a onedimensional array of length equal to the number of columns of
W
and returns a onedimensional array.output_dim (int) – The length of
f
’s return value.windows (list) – An increasing list of breakpoints between the windows to compute the statistic in.
polarised (bool) – Whether to leave the ancestral state out of computations: see Statistics for more details.
mode (str) – A string giving the “type” of the statistic to be computed (defaults to “site”).
span_normalise (bool) – Whether to divide the result by the span of the window (defaults to True).
strict (bool) – Whether to check that f(0) and f(total weight) are zero.
 Returns
A ndarray with shape equal to (num windows, num statistics).
 sample_count_stat(sample_sets, f, output_dim, windows=None, polarised=False, mode=None, span_normalise=True, strict=True)[source]¶
Compute a windowed statistic from sample counts and a summary function. This is a wrapper around
general_stat()
for the common case in which the weights are all either 1 or 0, i.e., functions of the joint allele frequency spectrum. See the statistics interface section for details on sample sets, windows, mode, span normalise, and return value. Ifsample_sets
is a list ofk
sets of samples, thenf
should be a function that takes an argument of lengthk
and returns a onedimensional array. Thej
th element of the argument tof
will be the number of samples insample_sets[j]
that lie below the node thatf
is being evaluated for. Seegeneral_stat()
for more details.Here is a contrived example: suppose that
A
andB
are two sets of samples withnA
andnB
elements, respectively. Passing these as sample sets will givef
an argument of length two, giving the number of samples inA
andB
below the node in question. So, if we definedef f(x): pA = x[0] / nA pB = x[1] / nB return np.array([pA * pB])
then if all sites are biallelic,
ts.sample_count_stat([A, B], f, 1, windows="sites", polarised=False, mode="site")
would compute, for each site, the product of the derived allele frequencies in the two sample sets, in a (num sites, 1) array. If instead
f
returnsnp.array([pA, pB, pA * pB])
, then the output would be a (num sites, 3) array, with the first two columns giving the allele frequencies inA
andB
, respectively.Note
The summary function
f
should return zero when given both 0 and the sample size (i.e.,f(0) = 0
andf(np.array([len(x) for x in sample_sets])) = 0
). This is necessary for the statistic to be unaffected by parts of the tree sequence ancestral to none or all of the samples, respectively. Parameters
sample_sets (list) – A list of lists of Node IDs, specifying the groups of nodes to compute the statistic with.
f – A function that takes a onedimensional array of length equal to the number of sample sets and returns a onedimensional array.
output_dim (int) – The length of
f
’s return value.windows (list) – An increasing list of breakpoints between the windows to compute the statistic in.
polarised (bool) – Whether to leave the ancestral state out of computations: see Statistics for more details.
mode (str) – A string giving the “type” of the statistic to be computed (defaults to “site”).
span_normalise (bool) – Whether to divide the result by the span of the window (defaults to True).
strict (bool) – Whether to check that f(0) and f(total weight) are zero.
 Returns
A ndarray with shape equal to (num windows, num statistics).
 diversity(sample_sets=None, windows=None, mode='site', span_normalise=True)[source]¶
Computes mean genetic diversity (also known as “pi”) in each of the sets of nodes from
sample_sets
. The statistic is also known as “sample heterozygosity”; a common citation for the definition is Nei and Li (1979) (equation 22), so it is sometimes called called “Nei’s pi” (but also sometimes “Tajima’s pi”).Please see the oneway statistics section for details on how the
sample_sets
argument is interpreted and how it interacts with the dimensions of the output array. See the statistics interface section for details on windows, mode, span normalise, and return value.Note that this quantity can also be computed by the
divergence
method.What is computed depends on
mode
: “site”
Mean pairwise genetic diversity: the average over all n choose 2 pairs of sample nodes, of the density of sites at which the two carry different alleles, per unit of chromosome length.
 “branch”
Mean distance in the tree: the average across over all n choose 2 pairs of sample nodes and locations in the window, of the mean distance in the tree between the two samples (in units of time).
 “node”
For each node, the proportion of genome on which the node is an ancestor to only one of a pair of sample nodes from the sample set, averaged over over all n choose 2 pairs of sample nodes.
 Parameters
sample_sets (list) – A list of lists of Node IDs, specifying the groups of nodes for which the statistic is computed. If any of the sample sets contain only a single node, the returned diversity will be NaN. If
None
(default), average over all n choose 2 pairs of distinct sample nodes in the tree sequence.windows (list) – An increasing list of breakpoints between the windows to compute the statistic in.
mode (str) – A string giving the “type” of the statistic to be computed (defaults to “site”).
span_normalise (bool) – Whether to divide the result by the span of the window (defaults to True).
 Returns
A numpy array whose length is equal to the number of sample sets.
 divergence(sample_sets, indexes=None, windows=None, mode='site', span_normalise=True)[source]¶
Computes mean genetic divergence between (and within) pairs of sets of nodes from
sample_sets
. This is the “average number of differences”, usually referred to as “dxy”; a common citation for this definition is Nei and Li (1979), who called it \(\pi_{XY}\). Note that the mean pairwise nucleotide diversity of a sample set to itself (computed by passing an index of the form (j,j)) is itsdiversity
(see the note below).Operates on
k = 2
sample sets at a time; please see the multiway statistics section for details on how thesample_sets
andindexes
arguments are interpreted and how they interact with the dimensions of the output array. See the statistics interface section for details on windows, mode, span normalise, and return value.Note
To avoid unexpected results, sample sets should be nonoverlapping, since comparisons of individuals to themselves are not removed when computing divergence between distinct sample sets. (However, specifying an index
(j, j)
computes thediversity
ofsample_set[j]
, which removes self comparisons to provide an unbiased estimate.)What is computed depends on
mode
: “site”
Mean pairwise genetic divergence: the average across every possible pair of chromosomes (one from each sample set), of the density of sites at which the two carry different alleles, per unit of chromosome length.
 “branch”
Mean distance in the tree: the average across every possible pair of chromosomes (one from each sample set) and locations in the window, of the mean distance in the tree between the two samples (in units of time).
 “node”
For each node, the proportion of genome on which the node is an ancestor to only one of a pair of chromosomes from the sample set, averaged over all possible pairs.
 Parameters
sample_sets (list) – A list of lists of Node IDs, specifying the groups of nodes to compute the statistic with.
indexes (list) – A list of 2tuples, or None.
windows (list) – An increasing list of breakpoints between the windows to compute the statistic in.
mode (str) – A string giving the “type” of the statistic to be computed (defaults to “site”).
span_normalise (bool) – Whether to divide the result by the span of the window (defaults to True).
 Returns
A ndarray with shape equal to (num windows, num statistics).
Computes genetic relatedness between (and within) pairs of sets of nodes from
sample_sets
. Operates onk = 2
sample sets at a time; please see the multiway statistics section for details on how thesample_sets
andindexes
arguments are interpreted and how they interact with the dimensions of the output array. See the statistics interface section for details on windows, mode, span normalise, polarised, and return value.What is computed depends on
mode
: “site”
Number of pairwise allelic matches in the window between two sample sets relative to the rest of the sample sets. To be precise, let m(u,v) denote the total number of alleles shared between nodes u and v, and let m(I,J) be the sum of m(u,v) over all nodes u in sample set I and v in sample set J. Let S and T be independently chosen sample sets. Then, for sample sets I and J, this computes E[m(I,J)  m(I,S)  m(J,T) + m(S,T)]. This can also be seen as the covariance of a quantitative trait determined by additive contributions from the genomes in each sample set. Let each allele be associated with an effect drawn from a N(0,1/2) distribution, and let the trait value of a sample set be the sum of its allele effects. Then, this computes the covariance between the trait values of two sample sets. For example, to compute covariance between the traits of diploid individuals, each sample set would be the pair of genomes of each individual; if
proportion=True
, this then corresponds to \(K_{c0}\) in Speed & Balding (2014). “branch”
Total area of branches in the window ancestral to pairs of samples in two sample sets relative to the rest of the sample sets. To be precise, let B(u,v) denote the total area of all branches ancestral to nodes u and v, and let B(I,J) be the sum of B(u,v) over all nodes u in sample set I and v in sample set J. Let S and T be two independently chosen sample sets. Then for sample sets I and J, this computes E[B(I,J)  B(I,S)  B(J,T) + B(S,T)].
 “node”
For each node, the proportion of the window over which pairs of samples in two sample sets are descendants, relative to the rest of the sample sets. To be precise, for each node n, let N(u,v) denote the proportion of the window over which samples u and v are descendants of n, and let and let N(I,J) be the sum of N(u,v) over all nodes u in sample set I and v in sample set J. Let S and T be two independently chosen sample sets. Then for sample sets I and J, this computes E[N(I,J)  N(I,S)  N(J,T) + N(S,T)].
 Parameters
sample_sets (list) – A list of lists of Node IDs, specifying the groups of nodes to compute the statistic with.
indexes (list) – A list of 2tuples, or None.
windows (list) – An increasing list of breakpoints between the windows to compute the statistic in.
mode (str) – A string giving the “type” of the statistic to be computed (defaults to “site”).
span_normalise (bool) – Whether to divide the result by the span of the window (defaults to True).
proportion (bool) – Whether to divide the result by
segregating_sites()
, called with the samewindows
andmode
(defaults to True). Note that this counts sites that are segregating between any of the samples of any of the sample sets (rather than segregating between all of the samples of the tree sequence).
 Returns
A ndarray with shape equal to (num windows, num statistics).
 trait_covariance(W, windows=None, mode='site', span_normalise=True)[source]¶
Computes the mean squared covariances between each of the columns of
W
(the “phenotypes”) and inheritance along the tree sequence. See the statistics interface section for details on windows, mode, span normalise, and return value. Operates on all samples in the tree sequence.Concretely, if g is a binary vector that indicates inheritance from an allele, branch, or node and w is a column of W, normalised to have mean zero, then the covariance of g and w is \(\sum_i g_i w_i\), the sum of the weights corresponding to entries of g that are 1. Since weights sum to zero, this is also equal to the sum of weights whose entries of g are 0. So, \(cov(g,w)^2 = ((\sum_i g_i w_i)^2 + (\sum_i (1g_i) w_i)^2)/2\).
What is computed depends on
mode
: “site”
The sum of squared covariances between presence/absence of each allele and phenotypes, divided by length of the window (if
span_normalise=True
). This is computed as sum_a (sum(w[a])^2 / 2), where w is a column of W with the average subtracted off, and w[a] is the sum of all entries of w corresponding to samples carrying allele “a”, and the first sum is over all alleles. “branch”
The sum of squared covariances between the split induced by each branch and phenotypes, multiplied by branch length, averaged across trees in the window. This is computed as above: a branch with total weight w[b] below b contributes (branch length) * w[b]^2 to the total value for a tree. (Since the sum of w is zero, the total weight below b and not below b are equal, canceling the factor of 2 above.)
 “node”
For each node, the squared covariance between the property of inheriting from this node and phenotypes, computed as in “branch”.
 Parameters
W (numpy.ndarray) – An array of values with one row for each sample and one column for each “phenotype”.
windows (list) – An increasing list of breakpoints between the windows to compute the statistic in.
mode (str) – A string giving the “type” of the statistic to be computed (defaults to “site”).
span_normalise (bool) – Whether to divide the result by the span of the window (defaults to True).
 Returns
A ndarray with shape equal to (num windows, num statistics).
 trait_correlation(W, windows=None, mode='site', span_normalise=True)[source]¶
Computes the mean squared correlations between each of the columns of
W
(the “phenotypes”) and inheritance along the tree sequence. See the statistics interface section for details on windows, mode, span normalise, and return value. Operates on all samples in the tree sequence.This is computed as squared covariance in
trait_covariance
, but divided by \(p (1p)\), where p is the proportion of samples inheriting from the allele, branch, or node in question.What is computed depends on
mode
: “site”
The sum of squared correlations between presence/absence of each allele and phenotypes, divided by length of the window (if
span_normalise=True
). This is computed as thetrait_covariance
divided by the variance of the relevant column of W and by ;math:p * (1  p), where \(p\) is the allele frequency. “branch”
The sum of squared correlations between the split induced by each branch and phenotypes, multiplied by branch length, averaged across trees in the window. This is computed as the
trait_covariance
, divided by the variance of the column of w and by \(p * (1  p)\), where \(p\) is the proportion of the samples lying below the branch. “node”
For each node, the squared correlation between the property of inheriting from this node and phenotypes, computed as in “branch”.
Note that above we divide by the sample variance, which for a vector x of length n is
np.var(x) * n / (n1)
. Parameters
W (numpy.ndarray) – An array of values with one row for each sample and one column for each “phenotype”. Each column must have positive standard deviation.
windows (list) – An increasing list of breakpoints between the windows to compute the statistic in.
mode (str) – A string giving the “type” of the statistic to be computed (defaults to “site”).
span_normalise (bool) – Whether to divide the result by the span of the window (defaults to True).
 Returns
A ndarray with shape equal to (num windows, num statistics).
 trait_regression(*args, **kwargs)[source]¶
Deprecated synonym for
trait_linear_model
.
 trait_linear_model(W, Z=None, windows=None, mode='site', span_normalise=True)[source]¶
Finds the relationship between trait and genotype after accounting for covariates. Concretely, for each trait w (i.e., each column of W), this does a leastsquares fit of the linear model \(w \sim g + Z\), where \(g\) is inheritance in the tree sequence (e.g., genotype) and the columns of \(Z\) are covariates, and returns the squared coefficient of \(g\) in this linear model. See the statistics interface section for details on windows, mode, span normalise, and return value. Operates on all samples in the tree sequence.
To do this, if g is a binary vector that indicates inheritance from an allele, branch, or node and w is a column of W, there are \(k\) columns of \(Z\), and the \(k+2\)vector \(b\) minimises \(\sum_i (w_i  b_0  b_1 g_i  b_2 z_{2,i}  ... b_{k+2} z_{k+2,i})^2\) then this returns the number \(b_1^2\). If \(g\) lies in the linear span of the columns of \(Z\), then \(b_1\) is set to 0. To fit the linear model without covariates (only the intercept), set Z = None.
What is computed depends on
mode
: “site”
Computes the sum of \(b_1^2/2\) for each allele in the window, as above with \(g\) indicating presence/absence of the allele, then divided by the length of the window if
span_normalise=True
. (For biallelic loci, this number is the same for both alleles, and so summing over each cancels the factor of two.) “branch”
The squared coefficient b_1^2, computed for the split induced by each branch (i.e., with \(g\) indicating inheritance from that branch), multiplied by branch length and tree span, summed over all trees in the window, and divided by the length of the window if
span_normalise=True
. “node”
For each node, the squared coefficient b_1^2, computed for the property of inheriting from this node, as in “branch”.
 Parameters
W (numpy.ndarray) – An array of values with one row for each sample and one column for each “phenotype”.
Z (numpy.ndarray) – An array of values with one row for each sample and one column for each “covariate”, or None. Columns of Z must be linearly independent.
windows (list) – An increasing list of breakpoints between the windows to compute the statistic in.
mode (str) – A string giving the “type” of the statistic to be computed (defaults to “site”).
span_normalise (bool) – Whether to divide the result by the span of the window (defaults to True).
 Returns
A ndarray with shape equal to (num windows, num statistics).
 segregating_sites(sample_sets=None, windows=None, mode='site', span_normalise=True)[source]¶
Computes the density of segregating sites for each of the sets of nodes from
sample_sets
, and related quantities. Please see the oneway statistics section for details on how thesample_sets
argument is interpreted and how it interacts with the dimensions of the output array. See the statistics interface section for details on windows, mode, span normalise, and return value.What is computed depends on
mode
. For a sample setA
, computes: “site”
The sum over sites of the number of alleles found in
A
at each site minus one, per unit of chromosome length. If all sites have at most two alleles, this is the density of sites that are polymorphic inA
. To get the number of segregating minor alleles per window, passspan_normalise=False
. “branch”
The total length of all branches in the tree subtended by the samples in
A
, averaged across the window. “node”
The proportion of the window on which the node is ancestral to some, but not all, of the samples in
A
.
 Parameters
sample_sets (list) – A list of lists of Node IDs, specifying the groups of nodes to compute the statistic with.
windows (list) – An increasing list of breakpoints between the windows to compute the statistic in.
mode (str) – A string giving the “type” of the statistic to be computed (defaults to “site”).
span_normalise (bool) – Whether to divide the result by the span of the window (defaults to True).
 Returns
A ndarray with shape equal to (num windows, num statistics).
 allele_frequency_spectrum(sample_sets=None, windows=None, mode='site', span_normalise=True, polarised=False)[source]¶
Computes the allele frequency spectrum (AFS) in windows across the genome for with respect to the specified
sample_sets
. See the statistics interface section for details on sample sets, windows, mode, span normalise, polarised, and return value. and see Allele frequency spectra for examples of how to use this method.Similar to other windowed stats, the first dimension in the returned array corresponds to windows, such that
result[i]
is the AFS in the ith window. The AFS in each window is a kdimensional numpy array, where k is the number of input sample sets, such thatresult[i, j0, j1, ...]
is the value associated with frequencyj0
insample_sets[0]
,j1
insample_sets[1]
, etc, in windowi
. From here, we will assume thatafs
corresponds to the result in a single window, i.e.,afs = result[i]
.If a single sample set is specified, the allele frequency spectrum within this set is returned, such that
afs[j]
is the value associated with frequencyj
. Thus, singletons are counted inafs[1]
, doubletons inafs[2]
, and so on. The zeroth entry counts alleles or branches not seen in the samples but that are polymorphic among the rest of the samples of the tree sequence; likewise, the last entry counts alleles fixed in the sample set but polymorphic in the entire set of samples. Please see the Zeroth and final entries in the AFS for an illustration.Warning
Please note that singletons are not counted in the initial entry in each AFS array (i.e.,
afs[0]
), but inafs[1]
.If
sample_sets
is None (the default), the allele frequency spectrum for all samples in the tree sequence is returned.If more than one sample set is specified, the joint allele frequency spectrum within windows is returned. For example, if we set
sample_sets = [S0, S1]
, then afs[1, 2] counts the number of sites that are singletons within S0 and doubletons in S1. The dimensions of the output array will be[num_windows] + [1 + len(S) for S in sample_sets]
.If
polarised
is False (the default) the AFS will be folded, so that the counts do not depend on knowing which allele is ancestral. If folded, the frequency spectrum for a single sample setS
hasafs[j] = 0
for allj > len(S) / 2
, so that alleles at frequencyj
andlen(S)  j
both add to the same entry. If there is more than one sample set, the returned array is “lower triangular” in a similar way. For more details, especially about handling of multiallelic sites, see Allele frequency spectrum.What is computed depends on
mode
: “site”
The number of alleles at a given frequency within the specified sample sets for each window, per unit of sequence length. To obtain the total number of alleles, set
span_normalise
to False. “branch”
The total length of branches in the trees subtended by subsets of the specified sample sets, per unit of sequence length. To obtain the total, set
span_normalise
to False. “node”
Not supported for this method (raises a ValueError).
For example, suppose that S0 is a list of 5 sample IDs, and S1 is a list of 3 other sample IDs. Then afs = ts.allele_frequency_spectrum([S0, S1], mode=”site”, span_normalise=False) will be a 5x3 numpy array, and if there are six alleles that are present in only one sample of S0 but two samples of S1, then afs[1,2] will be equal to 6. Similarly, branch_afs = ts.allele_frequency_spectrum([S0, S1], mode=”branch”, span_normalise=False) will also be a 5x3 array, and branch_afs[1,2] will be the total area (i.e., length times span) of all branches that are above exactly one sample of S0 and two samples of S1.
 Parameters
sample_sets (list) – A list of lists of Node IDs, specifying the groups of samples to compute the joint allele frequency
windows (list) – An increasing list of breakpoints between windows along the genome.
mode (str) – A string giving the “type” of the statistic to be computed (defaults to “site”).
span_normalise (bool) – Whether to divide the result by the span of the window (defaults to True).
 Returns
A (k + 1) dimensional numpy array, where k is the number of sample sets specified.
 Tajimas_D(sample_sets=None, windows=None, mode='site')[source]¶
Computes Tajima’s D of sets of nodes from
sample_sets
in windows. Please see the oneway statistics section for details on how thesample_sets
argument is interpreted and how it interacts with the dimensions of the output array. See the statistics interface section for details on windows, mode, and return value. Operates onk = 1
sample sets at a time. For a sample setX
ofn
nodes, if andT
is the mean number of pairwise differing sites inX
andS
is the number of sites segregating inX
(computed withdiversity
andsegregating sites
, respectively, both not span normalised), then Tajima’s D isD = (T  S / h) / sqrt(a * S + (b / c) * S * (S  1)) h = 1 + 1 / 2 + ... + 1 / (n  1) g = 1 + 1 / 2 ** 2 + ... + 1 / (n  1) ** 2 a = (n + 1) / (3 * (n  1) * h)  1 / h ** 2 b = 2 * (n ** 2 + n + 3) / (9 * n * (n  1))  (n + 2) / (h * n) + g / h ** 2 c = h ** 2 + g
What is computed for diversity and divergence depends on
mode
; see those functions for more details. Parameters
sample_sets (list) – A list of lists of Node IDs, specifying the groups of nodes to compute the statistic with.
indexes (list) – A list of 2tuples, or None.
windows (list) – An increasing list of breakpoints between the windows to compute the statistic in.
mode (str) – A string giving the “type” of the statistic to be computed (defaults to “site”).
 Returns
A ndarray with shape equal to (num windows, num statistics).
 Fst(sample_sets, indexes=None, windows=None, mode='site', span_normalise=True)[source]¶
Computes “windowed” Fst between pairs of sets of nodes from
sample_sets
. Operates onk = 2
sample sets at a time; please see the multiway statistics section for details on how thesample_sets
andindexes
arguments are interpreted and how they interact with the dimensions of the output array. See the statistics interface section for details on windows, mode, span normalise, and return value.For sample sets
X
andY
, ifd(X, Y)
is thedivergence
betweenX
andY
, andd(X)
is thediversity
ofX
, then what is computed isFst = 1  2 * (d(X) + d(Y)) / (d(X) + 2 * d(X, Y) + d(Y))
What is computed for diversity and divergence depends on
mode
; see those functions for more details. Parameters
sample_sets (list) – A list of lists of Node IDs, specifying the groups of nodes to compute the statistic with.
indexes (list) – A list of 2tuples.
windows (list) – An increasing list of breakpoints between the windows to compute the statistic in.
mode (str) – A string giving the “type” of the statistic to be computed (defaults to “site”).
span_normalise (bool) – Whether to divide the result by the span of the window (defaults to True).
 Returns
A ndarray with shape equal to (num windows, num statistics).
 Y3(sample_sets, indexes=None, windows=None, mode='site', span_normalise=True)[source]¶
Computes the ‘Y’ statistic between triples of sets of nodes from
sample_sets
. Operates onk = 3
sample sets at a time; please see the multiway statistics section for details on how thesample_sets
andindexes
arguments are interpreted and how they interact with the dimensions of the output array. See the statistics interface section for details on windows, mode, span normalise, and return value.What is computed depends on
mode
. Each is an average across every combination of trios of samples(a, b, c)
, one chosen from each sample set: “site”
The average density of sites at which
a
differs fromb
andc
, per unit of chromosome length. “branch”
The average length of all branches that separate
a
fromb
andc
(in units of time). “node”
For each node, the average proportion of the window on which
a
inherits from that node butb
andc
do not, or viceversa.
 Parameters
sample_sets (list) – A list of lists of Node IDs, specifying the groups of nodes to compute the statistic with.
indexes (list) – A list of 3tuples, or None.
windows (list) – An increasing list of breakpoints between the windows to compute the statistic in.
mode (str) – A string giving the “type” of the statistic to be computed (defaults to “site”).
span_normalise (bool) – Whether to divide the result by the span of the window (defaults to True).
 Returns
A ndarray with shape equal to (num windows, num statistics).
 Y2(sample_sets, indexes=None, windows=None, mode='site', span_normalise=True)[source]¶
Computes the ‘Y2’ statistic between pairs of sets of nodes from
sample_sets
. Operates onk = 2
sample sets at a time; please see the multiway statistics section for details on how thesample_sets
andindexes
arguments are interpreted and how they interact with the dimensions of the output array. See the statistics interface section for details on windows, mode, span normalise, and return value.What is computed depends on
mode
. Each is computed exactly asY3
, except that the average is across every possible trio of samples(a, b1, b2)
, wherea
is chosen from the first sample set, andb1, b2
are chosen (without replacement) from the second sample set. SeeY3
for more details. Parameters
sample_sets (list) – A list of lists of Node IDs, specifying the groups of nodes to compute the statistic with.
indexes (list) – A list of 2tuples, or None.
windows (list) – An increasing list of breakpoints between the windows to compute the statistic in.
mode (str) – A string giving the “type” of the statistic to be computed (defaults to “site”).
span_normalise (bool) – Whether to divide the result by the span of the window (defaults to True).
 Returns
A ndarray with shape equal to (num windows, num statistics).
 Y1(sample_sets, windows=None, mode='site', span_normalise=True)[source]¶
Computes the ‘Y1’ statistic within each of the sets of nodes given by
sample_sets
. Please see the oneway statistics section for details on how thesample_sets
argument is interpreted and how it interacts with the dimensions of the output array. See the statistics interface section for details on windows, mode, span normalise, and return value. Operates onk = 1
sample set at a time.What is computed depends on
mode
. Each is computed exactly asY3
, except that the average is across every possible trio of samples samples(a1, a2, a3)
all chosen without replacement from the same sample set. SeeY3
for more details. Parameters
sample_sets (list) – A list of lists of Node IDs, specifying the groups of nodes to compute the statistic with.
windows (list) – An increasing list of breakpoints between the windows to compute the statistic in.
mode (str) – A string giving the “type” of the statistic to be computed (defaults to “site”).
span_normalise (bool) – Whether to divide the result by the span of the window (defaults to True).
 Returns
A ndarray with shape equal to (num windows, num statistics).
 f4(sample_sets, indexes=None, windows=None, mode='site', span_normalise=True)[source]¶
Computes Patterson’s f4 statistic between four groups of nodes from
sample_sets
. Operates onk = 4
sample sets at a time; please see the multiway statistics section for details on how thesample_sets
andindexes
arguments are interpreted and how they interact with the dimensions of the output array. See the statistics interface section for details on windows, mode, span normalise, and return value.What is computed depends on
mode
. Each is an average across every possible combination of four samples(a, b; c, d)
, one chosen from each sample set: “site”
The average density of sites at which
a
andc
agree but differs fromb
andd
, minus the average density of sites at whicha
andd
agree but differs fromb
andc
, per unit of chromosome length. “branch”
The average length of all branches that separate
a
andc
fromb
andd
, minus the average length of all branches that separatea
andd
fromb
andc
(in units of time). “node”
For each node, the average proportion of the window on which
a
andc
inherit from that node butb
andd
do not, or viceversa, minus the average proportion of the window on whicha
andd
inherit from that node butb
andc
do not, or viceversa.
 Parameters
sample_sets (list) – A list of lists of Node IDs, specifying the groups of nodes to compute the statistic with.
indexes (list) – A list of 4tuples, or None.
windows (list) – An increasing list of breakpoints between the windows to compute the statistic in.
mode (str) – A string giving the “type” of the statistic to be computed (defaults to “site”).
span_normalise (bool) – Whether to divide the result by the span of the window (defaults to True).
 Returns
A ndarray with shape equal to (num windows, num statistics).
 f3(sample_sets, indexes=None, windows=None, mode='site', span_normalise=True)[source]¶
Computes Patterson’s f3 statistic between three groups of nodes from
sample_sets
. Note that the order of the arguments of f3 differs across the literature: here,f3([A, B, C])
for sample setsA
,B
, andC
will estimate \(f_3(A; B, C) = \mathbb{E}[(p_A  p_B) (p_A  p_C)]\), where \(p_A\) is the allele frequency inA
. When used as a test for admixture, the putatively admixed population is usually placed as populationA
(see Peter (2016) for more discussion).Operates on
k = 3
sample sets at a time; please see the multiway statistics section for details on how thesample_sets
andindexes
arguments are interpreted and how they interact with the dimensions of the output array. See the statistics interface section for details on windows, mode, span normalise, and return value.What is computed depends on
mode
. Each works exactly asf4
, except the average is across every possible combination of four samples(a1, b; a2, c)
where a1 and a2 have both been chosen (without replacement) from the first sample set. Seef4
for more details. Parameters
sample_sets (list) – A list of lists of Node IDs, specifying the groups of nodes to compute the statistic with.
indexes (list) – A list of 3tuples, or None.
windows (list) – An increasing list of breakpoints between the windows to compute the statistic in.
mode (str) – A string giving the “type” of the statistic to be computed (defaults to “site”).
span_normalise (bool) – Whether to divide the result by the span of the window (defaults to True).
 Returns
A ndarray with shape equal to (num windows, num statistics).
 f2(sample_sets, indexes=None, windows=None, mode='site', span_normalise=True)[source]¶
Computes Patterson’s f3 statistic between two groups of nodes from
sample_sets
. Operates onk = 2
sample sets at a time; please see the multiway statistics section for details on how thesample_sets
andindexes
arguments are interpreted and how they interact with the dimensions of the output array. See the statistics interface section for details on windows, mode, span normalise, and return value.What is computed depends on
mode
. Each works exactly asf4
, except the average is across every possible combination of four samples(a1, b1; a2, b2)
where a1 and a2 have both been chosen (without replacement) from the first sample set, andb1
andb2
have both been chosen (without replacement) from the second sample set. Seef4
for more details. Parameters
sample_sets (list) – A list of lists of Node IDs, specifying the groups of nodes to compute the statistic with.
indexes (list) – A list of 2tuples, or None.
windows (list) – An increasing list of breakpoints between the windows to compute the statistic in.
mode (str) – A string giving the “type” of the statistic to be computed (defaults to “site”).
span_normalise (bool) – Whether to divide the result by the span of the window (defaults to True).
 Returns
A ndarray with shape equal to (num windows, num statistics).
 mean_descendants(sample_sets)[source]¶
Computes for every node the mean number of samples in each of the sample_sets that descend from that node, averaged over the portions of the genome for which the node is ancestral to any sample. The output is an array, C[node, j], which reports the total span of all genomes in sample_sets[j] that inherit from node, divided by the total span of the genome on which node is an ancestor to any sample in the tree sequence.
Warning
The interface for this method is preliminary and may be subject to backwards incompatible changes in the near future. The longterm stable API for this method will be consistent with other Statistics. In particular, the normalization by proportion of the genome that node is an ancestor to anyone may not be the default behaviour in the future.
 Parameters
sample_sets (list) – A list of lists of node IDs.
 Returns
An array with dimensions (number of nodes in the tree sequence, number of reference sets)
 genealogical_nearest_neighbours(focal, sample_sets, num_threads=0)[source]¶
Return the genealogical nearest neighbours (GNN) proportions for the given focal nodes, with reference to two or more sets of interest, averaged over all trees in the tree sequence.
The GNN proportions for a focal node in a single tree are given by first finding the most recent common ancestral node \(a\) between the focal node and any other node present in the reference sets. The GNN proportion for a specific reference set, \(S\) is the number of nodes in \(S\) that descend from \(a\), as a proportion of the total number of descendant nodes in any of the reference sets.
For example, consider a case with 2 sample sets, \(S_1\) and \(S_2\). For a given tree, \(a\) is the node that includes at least one descendant in \(S_1\) or \(S_2\) (not including the focal node). If the descendants of \(a\) include some nodes in \(S_1\) but no nodes in \(S_2\), then the GNN proportions for that tree will be 100% \(S_1\) and 0% \(S_2\), or \([1.0, 0.0]\).
For a given focal node, the GNN proportions returned by this function are an average of the GNNs for each tree, weighted by the genomic distance spanned by that tree.
For an precise mathematical definition of GNN, see https://doi.org/10.1101/458067
Note
The reference sets need not include all the samples, hence the most recent common ancestral node of the reference sets, \(a\), need not be the immediate ancestor of the focal node. If the reference sets only comprise sequences from relatively distant individuals, the GNN statistic may end up as a measure of comparatively distant ancestry, even for tree sequences that contain many closely related individuals.
Warning
The interface for this method is preliminary and may be subject to backwards incompatible changes in the near future. The longterm stable API for this method will be consistent with other Statistics.
 Parameters
 Returns
An \(n\) by \(m\) array of focal nodes by GNN proportions. Every focal node corresponds to a row. The numbers in each row corresponding to the GNN proportion for each of the passedin reference sets. Rows therefore sum to one.
 Return type
 kc_distance(other, lambda_=0.0)[source]¶
Returns the average
Tree.kc_distance()
between pairs of trees along the sequence whose intervals overlap. The average is weighted by the fraction of the sequence on which each pair of trees overlap. Parameters
other (TreeSequence) – The other tree sequence to compare to.
lambda (float) – The KC metric lambda parameter determining the relative weight of topology and branch length.
 Returns
The computed KC distance between this tree sequence and other.
 Return type
 count_topologies(sample_sets=None)[source]¶
Returns a generator that produces the same distribution of topologies as
Tree.count_topologies()
but sequentially for every tree in a tree sequence. For use on a tree sequence this method is much faster than computing the result independently per tree.Warning
The interface for this method is preliminary and may be subject to backwards incompatible changes in the near future.
 Parameters
sample_sets (list) – A list of lists of Node IDs, specifying the groups of nodes to compute the statistic with.
 Return type
iter(
tskit.TopologyCounter
) Raises
ValueError – If nodes in
sample_sets
are invalid or are internal samples.
 ibd_segments(*, within=None, between=None, max_time=None, min_span=None, store_pairs=None, store_segments=None)[source]¶
Finds pairs of samples that are identical by descent (IBD) and returns the result as an
IdentitySegments
instance. The information stored in this object is controlled by thestore_pairs
andstore_segments
parameters. By default only total counts and other statistics of the IBD segments are stored (i.e.,store_pairs=False
), since storing pairs and segments has a substantial CPU and memory overhead. Please see the Identity by descent section for more details on how to access the information stored in theIdentitySegments
.If
within
is specified, only IBD segments for pairs of nodes within that set will be recorded. Ifbetween
is specified, only IBD segments from pairs that are in one or other of the specified sample sets will be reported. Note thatwithin
andbetween
are mutually exclusive.A pair of nodes
(u, v)
has an IBD segment with a left and right coordinate[left, right)
and ancestral nodea
iff the most recent common ancestor of the segment[left, right)
in nodesu
andv
isa
, and the segment has been inherited along the same genealogical path (ie. it has not been broken by recombination). The segments returned are the longest possible ones.Note that this definition is purely genealogical — allelic states are not considered here. If used without time or length thresholds, the segments returned for a given pair will partition the span of the contig represented by the tree sequence.
 Parameters
within (list) – A list of node IDs defining set of nodes that we finding IBD segments for. If not specified, this defaults to all samples in the tree sequence.
between (list[list]) – A list of lists of sample node IDs. Given two sample sets A and B, only IBD segments will be returned such that one of the samples is an element of A and the other is an element of B. Cannot be specified with
within
.max_time (float) – Only segments inherited from common ancestors whose node times are more recent than the specified time will be returned. Specifying a maximum time is strongly recommended when working with large tree sequences.
min_span (float) – Only segments in which the difference between the right and left genome coordinates (i.e., the span of the segment) is greater than this value will be included. (Default=0)
store_pairs (bool) – If True store information separately for each pair of samples
(a, b)
that are found to be IBD. Otherwise store summary information about all sample apirs. (Default=False)store_segments (bool) – If True store each IBD segment
(left, right, c)
and associate it with the corresponding sample pair(a, b)
. If True, impliesstore_pairs
. (Default=False).
 Returns
An
IdentitySegments
object containing the recorded IBD information. Return type
 pairwise_diversity(samples=None)[source]¶
Returns the pairwise nucleotide site diversity, the average number of sites that differ between a every possible pair of distinct samples. If samples is specified, calculate the diversity within this set.
Deprecated since version 0.2.0: please use
diversity()
instead. Since version 0.2.0 the error semantics have also changed slightly. It is no longer an error when there is one sample and a tskit.LibraryError is raised when nonsample IDs are provided rather than a ValueError. It is also no longer an error to compute pairwise diversity at sites with multiple mutations.
Simple container classes¶
The Individual
class¶
 class tskit.Individual[source]¶
An individual in a tree sequence. Since nodes correspond to genomes, individuals are associated with a collection of nodes (e.g., two nodes per diploid). See Nodes, Genomes, or Individuals? for more discussion of this distinction.
Modifying the attributes in this class will have no effect on the underlying tree sequence data.
 id¶
The integer ID of this individual. Varies from 0 to
TreeSequence.num_individuals
 1.
 flags¶
The bitwise flags for this individual.
 location¶
The spatial location of this individual as a numpy array. The location is an empty array if no spatial location is defined.
 parents¶
The parent individual ids of this individual as a numpy array. The parents is an empty array if no parents are defined.
 nodes¶
The IDs of the nodes that are associated with this individual as a numpy array (dtype=np.int32). If no nodes are associated with the individual this array will be empty.
The Node
class¶
 class tskit.Node[source]¶
A node in a tree sequence, corresponding to a single genome. The
time
andpopulation
are attributes of theNode
, rather than theIndividual
, as discussed in Nodes, Genomes, or Individuals?.Modifying the attributes in this class will have no effect on the underlying tree sequence data.
 id¶
The integer ID of this node. Varies from 0 to
TreeSequence.num_nodes
 1.
 flags¶
The bitwise flags for this node.
 time¶
The birth time of this node.
 population¶
The integer ID of the population that this node was born in.
 individual¶
The integer ID of the individual that this node was a part of.
The Edge
class¶
 class tskit.Edge[source]¶
An edge in a tree sequence.
Modifying the attributes in this class will have no effect on the underlying tree sequence data.
 id¶
The integer ID of this edge. Varies from 0 to
TreeSequence.num_edges
 1.
 left¶
The left coordinate of this edge.
 right¶
The right coordinate of this edge.
 parent¶
The integer ID of the parent node for this edge. To obtain further information about a node with a given ID, use
TreeSequence.node()
.
 child¶
The integer ID of the child node for this edge. To obtain further information about a node with a given ID, use
TreeSequence.node()
.
The Site
class¶
 class tskit.Site[source]¶
A site in a tree sequence.
Modifying the attributes in this class will have no effect on the underlying tree sequence data.
 id¶
The integer ID of this site. Varies from 0 to
TreeSequence.num_sites
 1.
 position¶
The floating point location of this site in genome coordinates. Ranges from 0 (inclusive) to
TreeSequence.sequence_length
(exclusive).
 ancestral_state¶
The ancestral state at this site (i.e., the state inherited by nodes, unless mutations occur).
 mutations¶
The list of mutations at this site. Mutations within a site are returned in the order they are specified in the underlying
MutationTable
.
The Mutation
class¶
 class tskit.Mutation[source]¶
A mutation in a tree sequence.
Modifying the attributes in this class will have no effect on the underlying tree sequence data.
 id¶
The integer ID of this mutation. Varies from 0 to
TreeSequence.num_mutations
 1.Modifying the attributes in this class will have no effect on the underlying tree sequence data.
 site¶
The integer ID of the site that this mutation occurs at. To obtain further information about a site with a given ID use
TreeSequence.site()
.
 node¶
The integer ID of the first node that inherits this mutation. To obtain further information about a node with a given ID, use
TreeSequence.node()
.
 time¶
The occurrence time of this mutation.
 derived_state¶
The derived state for this mutation. This is the state inherited by nodes in the subtree rooted at this mutation’s node, unless another mutation occurs.
 parent¶
The integer ID of this mutation’s parent mutation. When multiple mutations occur at a site along a path in the tree, mutations must record the mutation that is immediately above them. If the mutation does not have a parent, this is equal to the
NULL
(1). To obtain further information about a mutation with a given ID, useTreeSequence.mutation()
.
The Variant
class¶
 class tskit.Variant[source]¶
A variant in a tree sequence, describing the observed genetic variation among samples for a given site. A variant consists (a) of a reference to the
Site
instance in question; (b) the alleles that may be observed at the samples for this site; and (c) the genotypes mapping sample IDs to the observed alleles.Each element in the
alleles
tuple is a string, representing the actual observed state for a given sample. Thealleles
tuple is generated in one of two ways. The first (and default) way is fortskit
to generate the encoding on the fly as alleles are encountered while generating genotypes. In this case, the first element of this tuple is guaranteed to be the same as the site’sancestral_state
value and the list of alleles is also guaranteed not to contain any duplicates. Note that allelic values may be listed that are not referred to by any samples. For example, if we have a site that is fixed for the derived state (i.e., we have a mutation over the tree root), all genotypes will be 1, but the alleles list will be equal to('0', '1')
. Other than the ancestral state being the first allele, the alleles are listed in no particular order, and the ordering should not be relied upon (but see the notes on missing data below).The second way is for the user to define the mapping between genotype values and allelic state strings using the
alleles
parameter to theTreeSequence.variants()
method. In this case, there is no indication of which allele is the ancestral state, as the ordering is determined by the user.The
genotypes
represent the observed allelic states for each sample, such thatvar.alleles[var.genotypes[j]]
gives the string allele for sample IDj
. Thus, the elements of the genotypes array are indexes into thealleles
list. The genotypes are provided in this way via a numpy array to enable efficient calculations.When missing data is present at a given site, the property
has_missing_data
will be True, at least one element of thegenotypes
array will be equal totskit.MISSING_DATA
, and the last element of thealleles
array will beNone
. Note that in this casevariant.num_alleles
will not be equal tolen(variant.alleles)
. The rationale for addingNone
to the end of thealleles
list is to help code that does not handle missing data correctly fail early rather than introducing subtle and hardtofind bugs. Astskit.MISSING_DATA
is equal to 1, code that decodes genotypes into allelic values without taking missing data into account would otherwise incorrectly output the last allele in the list.Modifying the attributes in this class will have no effect on the underlying tree sequence data.
 site¶
The site object for this variant.
 alleles¶
A tuple of the allelic values that may be observed at the samples at the current site. The first element of this tuple is always the site’s ancestral state.
 genotypes¶
An array of indexes into the list
alleles
, giving the state of each sample at the current site.
 property has_missing_data¶
True if there is missing data for any of the samples at the current site.
 property num_alleles¶
The number of distinct alleles at this site. Note that this may be greater than the number of distinct values in the genotypes array.
The Migration
class¶
 class tskit.Migration[source]¶
A migration in a tree sequence.
Modifying the attributes in this class will have no effect on the underlying tree sequence data.
 left¶
The left end of the genomic interval covered by this migration (inclusive).
 right¶
The right end of the genomic interval covered by this migration (exclusive).
 node¶
The integer ID of the node involved in this migration event. To obtain further information about a node with a given ID, use
TreeSequence.node()
.
 source¶
The source population ID.
 dest¶
The destination population ID.
 time¶
The time at which this migration occurred at.
 id¶
The integer ID of this mutation. Varies from 0 to
TreeSequence.num_mutations
 1.
The Population
class¶
 class tskit.Population[source]¶
A population in a tree sequence.
Modifying the attributes in this class will have no effect on the underlying tree sequence data.
 id¶
The integer ID of this population. Varies from 0 to
TreeSequence.num_populations
 1.
The Provenance
class¶
 class tskit.Provenance[source]¶
A provenance entry in a tree sequence, detailing how this tree sequence was generated, or subsequent operations on it (see Provenance).
 timestamp¶
The time that this entry was made
The Interval
class¶
 class tskit.Interval[source]¶
A tuple of 2 numbers,
[left, right)
, defining an interval over the genome. Variables
left (float) – The left hand end of the interval. By convention this value is included in the interval.
right (float) – The right hand end of the interval. By convention this value is not included in the interval, i.e., the interval is halfopen.
span (float) – The span of the genome covered by this interval, simply
rightleft
.
 left¶
Alias for field number 0
 right¶
Alias for field number 1
TableCollection and Table classes¶
The TableCollection
class¶
Also see the TableCollection API summary.
 class tskit.TableCollection(sequence_length=0)[source]¶
A collection of mutable tables defining a tree sequence. See the Data model section for definition on the various tables and how they together define a
TreeSequence
. Arbitrary data can be stored in a TableCollection, but there are certain requirements that must be satisfied for these tables to be interpreted as a tree sequence.To obtain an immutable
TreeSequence
instance corresponding to the current state of aTableCollection
, please use thetree_sequence()
method. property individuals¶
The Individual Table in this collection.
 property nodes¶
The Node Table in this collection.
 property edges¶
The Edge Table in this collection.
 property migrations¶
The Migration Table in this collection
 property sites¶
The Site Table in this collection.
 property mutations¶
The Mutation Table in this collection.
 property populations¶
The Population Table in this collection.
 property provenances¶
The Provenance Table in this collection.
 property indexes¶
The edge insertion and removal indexes.
 property sequence_length¶
The sequence length defining the coordinate space.
 property file_uuid¶
The UUID for the file this TableCollection is derived from, or None if not derived from a file.
 property metadata¶
The decoded metadata for this object.
 property metadata_bytes¶
The raw bytes of metadata for this TableCollection
 property metadata_schema¶
The
tskit.MetadataSchema
for this object.
 property time_units¶
The units used for the time dimension of this TableCollection
 has_reference_sequence()[source]¶
Returns True if this
TableCollection
has an associated reference sequence.
 property reference_sequence¶
The
ReferenceSequence
associated with thisTableCollection
.Note
Note that the behaviour of this attribute differs from
TreeSequence.reference_sequence
in that we return a valid instance ofReferenceSequence
even whenTableCollection.has_reference_sequence
is False. This is to allow us to update the state of the reference sequence.
 asdict(force_offset_64=False)[source]¶
Returns the nested dictionary representation of this TableCollection used for interchange.
Note: the semantics of this method changed at tskit 0.1.0. Previously a map of table names to the tables themselves was returned.
 Parameters
force_offset_64 (bool) – If True, all offset columns will have dtype np.uint64. If False (the default) the offset array columns will have a dtype of either np.uint32 or np.uint64, depending on the size of the corresponding data array.
 Returns
The dictionary representation of this table collection.
 Return type
 property table_name_map¶
Returns a dictionary mapping table names to the corresponding table instances. For example, the returned dictionary will contain the key “edges” that maps to an
EdgeTable
instance.
 property nbytes¶
Returns the total number of bytes required to store the data in this table collection. Note that this may not be equal to the actual memory footprint.
 equals(other, *, ignore_metadata=False, ignore_ts_metadata=False, ignore_provenance=False, ignore_timestamps=False, ignore_tables=False, ignore_reference_sequence=False)[source]¶
Returns True if self and other are equal. By default, two table collections are considered equal if their
sequence_length
properties are identical;toplevel tree sequence metadata and metadata schemas are bytewise identical;
constituent tables are bytewise identical.
Some of the requirements in this definition can be relaxed using the parameters, which can be used to remove certain parts of the data model from the comparison.
Table indexes are not considered in the equality comparison.
 Parameters
other (TableCollection) – Another table collection.
ignore_metadata (bool) – If True all metadata and metadata schemas will be excluded from the comparison. This includes the toplevel tree sequence and constituent table metadata (default=False).
ignore_ts_metadata (bool) – If True the toplevel tree sequence metadata and metadata schemas will be excluded from the comparison. If
ignore_metadata
is True, this parameter has no effect.ignore_provenance (bool) – If True the provenance tables are not included in the comparison.
ignore_timestamps (bool) – If True the provenance timestamp column is ignored in the comparison. If
ignore_provenance
is True, this parameter has no effect.ignore_tables (bool) – If True no tables are included in the comparison, thus comparing only the toplevel information.
ignore_reference_sequence (bool) – If True the reference sequence is not included in the comparison.
 Returns
True if other is equal to this table collection; False otherwise.
 Return type
 assert_equals(other, *, ignore_metadata=False, ignore_ts_metadata=False, ignore_provenance=False, ignore_timestamps=False, ignore_tables=False, ignore_reference_sequence=False)[source]¶
Raise an AssertionError for the first found difference between this and another table collection. Note that table indexes are not checked.
 Parameters
other (TableCollection) – Another table collection.
ignore_metadata (bool) – If True all metadata and metadata schemas will be excluded from the comparison. This includes the toplevel tree sequence and constituent table metadata (default=False).
ignore_ts_metadata (bool) – If True the toplevel tree sequence metadata and metadata schemas will be excluded from the comparison. If
ignore_metadata
is True, this parameter has no effect.ignore_provenance (bool) – If True the provenance tables are not included in the comparison.
ignore_timestamps (bool) – If True the provenance timestamp column is ignored in the comparison. If
ignore_provenance
is True, this parameter has no effect.ignore_tables (bool) – If True no tables are included in the comparison, thus comparing only the toplevel information.
ignore_reference_sequence (bool) – If True the reference sequence is not included in the comparison.
 dump(file_or_path)[source]¶
Writes the table collection to the specified path or file object.
 Parameters
file_or_path (str) – The file object or path to write the TreeSequence to.
 copy()[source]¶
Returns a deep copy of this TableCollection.
 Returns
A deep copy of this TableCollection.
 Return type
 tree_sequence()[source]¶
Returns a
TreeSequence
instance from the tables defined in thisTableCollection
. If the table collection is not in canonical form (i.e., does not meet sorting requirements) or cannot be interpreted as a tree sequence an exception is raised. Thesort()
method may be used to ensure that input sorting requirements are met. If the table collection does not have indexes they will be built. Returns
A
TreeSequence
instance reflecting the structures defined in this set of tables. Return type
 simplify(samples=None, *, reduce_to_site_topology=False, filter_populations=True, filter_individuals=True, filter_sites=True, keep_unary=False, keep_unary_in_individuals=None, keep_input_roots=False, record_provenance=True, filter_zero_mutation_sites=None)[source]¶
Simplifies the tables in place to retain only the information necessary to reconstruct the tree sequence describing the given
samples
. This will change the ID of the nodes, so that the nodesamples[k]
will have IDk
in the result. The resulting NodeTable will have only the firstlen(samples)
nodes marked as samples. The mapping from node IDs in the current set of tables to their equivalent values in the simplified tables is also returned as a numpy array. If an arraya
is returned by this function andu
is the ID of a node in the input table, thena[u]
is the ID of this node in the output table. For any nodeu
that is not mapped into the output tables, this mapping will equal1
.Tables operated on by this function must: be sorted (see
TableCollection.sort()
), have children be born strictly after their parents, and the intervals on which any node is a child must be disjoint. Other than this the tables need not satisfy remaining requirements to specify a valid tree sequence (but the resulting tables will).This is identical to
TreeSequence.simplify()
but acts in place to alter the data in thisTableCollection
. Please see theTreeSequence.simplify()
method for a description of the remaining parameters. Parameters
samples (list[int]) – A list of node IDs to retain as samples. They need not be nodes marked as samples in the original tree sequence, but will constitute the entire set of samples in the returned tree sequence. If not specified or None, use all nodes marked with the IS_SAMPLE flag. The list may be provided as a numpy array (or arraylike) object (dtype=np.int32).
reduce_to_site_topology (bool) – Whether to reduce the topology down to the trees that are present at sites. (Default: False).
filter_populations (bool) – If True, remove any populations that are not referenced by nodes after simplification; new population IDs are allocated sequentially from zero. If False, the population table will not be altered in any way. (Default: True)
filter_individuals (bool) – If True, remove any individuals that are not referenced by nodes after simplification; new individual IDs are allocated sequentially from zero. If False, the individual table will not be altered in any way. (Default: True)
filter_sites (bool) – If True, remove any sites that are not referenced by mutations after simplification; new site IDs are allocated sequentially from zero. If False, the site table will not be altered in any way. (Default: True)
keep_unary (bool) – If True, preserve unary nodes (i.e. nodes with exactly one child) that exist on the path from samples to root. (Default: False)
keep_unary_in_individuals (bool) – If True, preserve unary nodes that exist on the path from samples to root, but only if they are associated with an individual in the individuals table. Cannot be specified at the same time as
keep_unary
. (Default:None
, equivalent to False)keep_input_roots (bool) – Whether to retain history ancestral to the MRCA of the samples. If
False
, no topology older than the MRCAs of the samples will be included. IfTrue
the roots of all trees in the returned tree sequence will be the same roots as in the original tree sequence. (Default: False)record_provenance (bool) – If True, record details of this call to simplify in the returned tree sequence’s provenance information (Default: True).
filter_zero_mutation_sites (bool) – Deprecated alias for
filter_sites
.
 Returns
A numpy array mapping node IDs in the input tables to their corresponding node IDs in the output tables.
 Return type
numpy.ndarray (dtype=np.int32)
 link_ancestors(samples, ancestors)[source]¶
Returns an
EdgeTable
instance describing a subset of the genealogical relationships between the nodes insamples
andancestors
.Each row
parent, child, left, right
in the output table indicates thatchild
has inherited the segment[left, right)
fromparent
more recently than from any other node in these lists.In particular, suppose
samples
is a list of nodes such thattime
is 0 for each node, andancestors
is a list of nodes such thattime
is greater than 0.0 for each node. Then each row of the output table will show an interval[left, right)
over which a node insamples
has inherited most recently from a node inancestors
, or an interval over which one of theseancestors
has inherited most recently from another node inancestors
.The following table shows which
parent>child
pairs will be shown in the output oflink_ancestors
. A node is a relevant descendant on a given interval if it also appears somewhere in theparent
column of the outputted table.Type of relationship
Shown in output of
link_ancestors
ancestor>sample
Always
ancestor1>ancestor2
Only if
ancestor2
has a relevant descendantsample1>sample2
Always
sample>ancestor
Only if
ancestor
has a relevant descendantThe difference between
samples
andancestors
is that information about the ancestors of a node inancestors
will only be retained if it also has a relevant descendant, while information about the ancestors of a node insamples
will always be retained. The node IDs inparent
andchild
refer to the IDs in the node table of the inputted tree sequence.The supplied nodes must be nonempty lists of the node IDs in the tree sequence: in particular, they do not have to be samples of the tree sequence. The lists of
samples
andancestors
may overlap, although adding a node fromsamples
toancestors
will not change the output. So, settingsamples
andancestors
to the same list of nodes will find all genealogical relationships within this list.If none of the nodes in
ancestors
orsamples
are ancestral tosamples
anywhere in the tree sequence, an empty table will be returned.
 sort(edge_start=0, *, site_start=0, mutation_start=0)[source]¶
Sorts the tables in place. This ensures that all tree sequence ordering requirements listed in the Valid tree sequence requirements section are met, as long as each site has at most one mutation (see below).
If the
edge_start
parameter is provided, this specifies the index in the edge table where sorting should start. Only rows with index greater than or equal toedge_start
are sorted; rows before this index are not affected. This parameter is provided to allow for efficient sorting when the user knows that the edges up to a given index are already sorted.If both
site_start
andmutation_start
are equal to the number of rows in their retrospective tables then neither is sorted. Note that a partial nonsorting is not possible, and both or neither must be skipped.The node, population and provenance tables are not affected by this method.
Edges are sorted as follows:
time of parent, then
parent node ID, then
child node ID, then
left endpoint.
Note that this sorting order exceeds the edge sorting requirements for a valid tree sequence. For a valid tree sequence, we require that all edges for a given parent ID are adjacent, but we do not require that they be listed in sorted order.
Individuals are not sorted.
Sites are sorted by position, and sites with the same position retain their relative ordering.
Mutations are sorted by site ID, and within the same site are sorted by time. Those with equal or unknown time retain their relative ordering. This does not currently rearrange tables so that mutations occur after their mutation parents, which is a requirement for valid tree sequences.
Migrations are sorted by
time
,source
,dest
,left
andnode
values. This defines a total sort order, such that any permutation of a valid migration table will be sorted into the same output order. Note that this sorting order exceeds the migration sorting requirements for a valid tree sequence, which only requires that migrations are sorted by time value. Parameters
edge_start (int) – The index in the edge table where sorting starts (default=0; must be <= len(edges)).
site_start (int) – The index in the site table where sorting starts (default=0; must be one of [0, len(sites)]).
mutation_start (int) – The index in the mutation table where sorting starts (default=0; must be one of [0, len(mutations)]).
 sort_individuals()[source]¶
Sorts the individual table in place, so that parents come before children, and the parent column is remapped as required. Node references to individuals are also updated.
 canonicalise(remove_unreferenced=None)[source]¶
This puts the tables in canonical form  to do this, the individual and population tables are sorted by the first node that refers to each (see
TreeSequence.subset()
) Then, the remaining tables are sorted as insort()
, with the modification that mutations are sorted by site, then time, then number of descendant mutations (ensuring that parent mutations occur before children), then node, then original order in the tables. This ensures that any two tables with the same information should be identical after canonical sorting.By default, the method removes sites, individuals, and populations that are not referenced (by mutations and nodes, respectively). If you wish to keep these, pass
remove_unreferenced=False
, but note that unreferenced individuals and populations are put at the end of the tables in their original order.See also
sort()
for sorting edges, mutations, and sites, andsubset()
for reordering nodes, individuals, and populations. Parameters
remove_unreferenced (bool) – Whether to remove unreferenced sites, individuals, and populations (default=True).
 compute_mutation_parents()[source]¶
Modifies the tables in place, computing the
parent
column of the mutation table. For this to work, the node and edge tables must be valid, and the site and mutation tables must be sorted (seeTableCollection.sort()
). This will produce an error if mutations are not sorted (i.e., if a mutation appears before its mutation parent) unless the two mutations occur on the same branch, in which case there is no way to detect the error.The
parent
of a given mutation is the ID of the next mutation encountered traversing the tree upwards from that mutation, orNULL
if there is no such mutation.
 compute_mutation_times()[source]¶
Modifies the tables in place, computing valid values for the
time
column of the mutation table. For this to work, the node and edge tables must be valid, and the site and mutation tables must be sorted and indexed(seeTableCollection.sort()
andTableCollection.build_index()
).For a single mutation on an edge at a site, the
time
assigned to a mutation by this method is the midpoint between the times of the nodes above and below the mutation. In the case where there is more than one mutation on an edge for a site, the times are evenly spread along the edge. For mutations that are above a root node, the time of the root node is assigned.The mutation table will be sorted if the new times mean that the original order is no longer valid.
 deduplicate_sites()[source]¶
Modifies the tables in place, removing entries in the site table with duplicate
position
(and keeping only the first entry for each site), and renumbering thesite
column of the mutation table appropriately. This requires the site table to be sorted by position.Warning
This method does not sort the tables afterwards, so mutations may no longer be sorted by time.
 delete_sites(site_ids, record_provenance=True)[source]¶
Remove the specified sites entirely from the sites and mutations tables in this collection. This is identical to
TreeSequence.delete_sites()
but acts in place to alter the data in thisTableCollection
.
 delete_intervals(intervals, simplify=True, record_provenance=True)[source]¶
Delete all information from this set of tables which lies within the specified list of genomic intervals. This is identical to
TreeSequence.delete_intervals()
but acts in place to alter the data in thisTableCollection
. Parameters
intervals (array_like) – A list (start, end) pairs describing the genomic intervals to delete. Intervals must be nonoverlapping and in increasing order. The list of intervals must be interpretable as a 2D numpy array with shape (N, 2), where N is the number of intervals.
simplify (bool) – If True, run simplify on the tables so that nodes no longer used are discarded. (Default: True).
record_provenance (bool) – If
True
, add details of this operation to the provenance table in this TableCollection. (Default:True
).
 keep_intervals(intervals, simplify=True, record_provenance=True)[source]¶
Delete all information from this set of tables which lies outside the specified list of genomic intervals. This is identical to
TreeSequence.keep_intervals()
but acts in place to alter the data in thisTableCollection
. Parameters
intervals (array_like) – A list (start, end) pairs describing the genomic intervals to keep. Intervals must be nonoverlapping and in increasing order. The list of intervals must be interpretable as a 2D numpy array with shape (N, 2), where N is the number of intervals.
simplify (bool) – If True, run simplify on the tables so that nodes no longer used are discarded. Must be
False
if input tree sequence includes migrations. (Default: True).record_provenance (bool) – If
True
, add details of this operation to the provenance table in this TableCollection. (Default:True
).
 ltrim(record_provenance=True)[source]¶
Reset the coordinate system used in these tables, changing the left and right genomic positions in the edge table such that the leftmost edge now starts at position 0. This is identical to
TreeSequence.ltrim()
but acts in place to alter the data in thisTableCollection
. Parameters
record_provenance (bool) – If
True
, add details of this operation to the provenance table in this TableCollection. (Default:True
).
 rtrim(record_provenance=True)[source]¶
Reset the
sequence_length
property so that the sequence ends at the end of the last edge. This is identical toTreeSequence.rtrim()
but acts in place to alter the data in thisTableCollection
. Parameters
record_provenance (bool) – If
True
, add details of this operation to the provenance table in this TableCollection. (Default:True
).
 trim(record_provenance=True)[source]¶
Trim away any empty regions on the right and left of the tree sequence encoded by these tables. This is identical to
TreeSequence.trim()
but acts in place to alter the data in thisTableCollection
. Parameters
record_provenance (bool) – If
True
, add details of this operation to the provenance table in this TableCollection. (Default:True
).
 clear(clear_provenance=False, clear_metadata_schemas=False, clear_ts_metadata_and_schema=False)[source]¶
Remove all rows of the data tables, optionally remove provenance, metadata schemas and tslevel metadata.
 Parameters
clear_provenance (bool) – If
True
, remove all rows of the provenance table. (Default:False
).clear_metadata_schemas (bool) – If
True
, clear the table metadata schemas. (Default:False
).clear_ts_metadata_and_schema (bool) – If
True
, clear the treesequence level metadata and schema (Default:False
).
 has_index()[source]¶
Returns True if this TableCollection is indexed. See Table indexes for information on indexes.
 build_index()[source]¶
Builds an index on this TableCollection. Any existing indexes are automatically dropped. See Table indexes for information on indexes.
 drop_index()[source]¶
Drops any indexes present on this table collection. If the tables are not currently indexed this method has no effect. See Table indexes for information on indexes.
 subset(nodes, record_provenance=True, *, reorder_populations=None, remove_unreferenced=None)[source]¶
Modifies the tables in place to contain only the entries referring to the provided list of node IDs, with nodes reordered according to the order they appear in the list. See
TreeSequence.subset()
for a more detailed description.Note: there are no sortedness requirements on the tables.
 Parameters
nodes (list) – The list of nodes for which to retain information. This may be a numpy array (or arraylike) object (dtype=np.int32).
record_provenance (bool) – Whether to record a provenance entry in the provenance table for this operation.
reorder_populations (bool) – Whether to reorder the population table (default: True). If False, the population table will not be altered in any way.
remove_unreferenced (bool) – Whether sites, individuals, and populations that are not referred to by any retained entries in the tables should be removed (default: True). See the description for details.
 union(other, node_mapping, check_shared_equality=True, add_populations=True, record_provenance=True)[source]¶
Modifies the table collection in place by adding the nonshared portions of
other
to itself. To perform the nodewise union, the method relies on anode_mapping
array, that maps nodes inother
to its equivalent node inself
ortskit.NULL
if the node is exclusive toother
. SeeTreeSequence.union()
for a more detailed description. Parameters
other (TableCollection) – Another table collection.
node_mapping (list) – An array of node IDs that relate nodes in
other
to nodes inself
: the kth element ofnode_mapping
should be the index of the equivalent node inself
, ortskit.NULL
if the node is not present inself
(in which case it will be added to self).check_shared_equality (bool) – If True, the shared portions of the table collections will be checked for equality.
add_populations (bool) – If True, nodes new to
self
will be assigned new population IDs.record_provenance (bool) – Whether to record a provenance entry in the provenance table for this operation.
 ibd_segments(*, within=None, between=None, max_time=None, min_span=None, store_pairs=None, store_segments=None)[source]¶
Equivalent to the
TreeSequence.ibd_segments()
method; please see its documentation for more details, and use this method only if you specifically need to work with aTableCollection
object.This method has the same input data requirements as
TableCollection.simplify()
. In particular, the table collection must be sorted in the canonical order. To find out if this is needed, seeTableCollection.sort()
. If the edge table contains any edges with identical parents and children over adjacent genomic intervals, any IBD intervals underneath the edges will also be split across the breakpoint(s). To prevent this behaviour in this situation, useEdgeTable.squash()
beforehand. Parameters
within (list) – As for the
TreeSequence.ibd_segments()
method.between (list[list]) – As for the
TreeSequence.ibd_segments()
method.max_time (float) – As for the
TreeSequence.ibd_segments()
method.min_span (float) – As for the
TreeSequence.ibd_segments()
method.store_pairs (bool) – As for the
TreeSequence.ibd_segments()
method.store_segments (bool) – As for the
TreeSequence.ibd_segments()
method.
 Returns
An
IdentitySegments
object containing the recorded IBD information. Return type
IndividualTable
classes¶
 class tskit.IndividualTable[source]¶
A table defining the individuals in a tree sequence. Note that although each Individual has associated nodes, reference to these is not stored in the individual table, but rather reference to the individual is stored for each node in the
NodeTable
. This is similar to the way in which the relationship between sites and mutations is modelled.Warning
The numpy arrays returned by table attribute accesses are copies of the underlying data. In particular, this means that editing individual values in the arrays will not change the table data Instead, you should set entire columns or rows at once (see Accessing table data).
 Variables
flags (numpy.ndarray, dtype=np.uint32) – The array of flags values.
location (numpy.ndarray, dtype=np.float64) – The flattened array of floating point location values. See Encoding ragged columns for more details.
location_offset (numpy.ndarray, dtype=np.uint32) – The array of offsets into the location column. See Encoding ragged columns for more details.
parents (numpy.ndarray, dtype=np.int32) – The flattened array of parent individual ids. See Encoding ragged columns for more details.
parents_offset (numpy.ndarray, dtype=np.uint32) – The array of offsets into the parents column. See Encoding ragged columns for more details.
metadata (numpy.ndarray, dtype=np.int8) – The flattened array of binary metadata values. See Binary columns for more details.
metadata_offset (numpy.ndarray, dtype=np.uint32) – The array of offsets into the metadata column. See Binary columns for more details.
metadata_schema (tskit.MetadataSchema) – The metadata schema for this table’s metadata column
 add_row(flags=0, location=None, parents=None, metadata=None)[source]¶
Adds a new row to this
IndividualTable
and returns the ID of the corresponding individual. Metadata, if specified, will be validated and encoded according to the table’smetadata_schema
. Parameters
flags (int) – The bitwise flags for the new node.
location (arraylike) – A list of numeric values or onedimensional numpy array describing the location of this individual. If not specified or None, a zerodimensional location is stored.
parents (arraylike) – A list or array of ids of parent individuals. If not specified an empty array is stored.
metadata (object) – Any object that is valid metadata for the table’s schema. Defaults to the default metadata value for the table’s schema. This is typically
{}
. For no schema,None
.
 Returns
The ID of the newly added individual.
 Return type
 set_columns(flags=None, location=None, location_offset=None, parents=None, parents_offset=None, metadata=None, metadata_offset=None, metadata_schema=None)[source]¶
Sets the values for each column in this
IndividualTable
using the values in the specified arrays. Overwrites any data currently stored in the table.The
flags
array is mandatory and defines the number of individuals the table will contain. Thelocation
andlocation_offset
parameters must be supplied together, and meet the requirements for Encoding ragged columns. Theparents
andparents_offset
parameters must be supplied together, and meet the requirements for Encoding ragged columns. Themetadata
andmetadata_offset
parameters must be supplied together, and meet the requirements for Encoding ragged columns. See Binary columns for more information and Metadata for bulk table methods for an example of how to prepare metadata. Parameters
flags (numpy.ndarray, dtype=np.uint32) – The bitwise flags for each individual. Required.
location (numpy.ndarray, dtype=np.float64) – The flattened location array. Must be specified along with
location_offset
. If not specified or None, an empty location value is stored for each individual.location_offset (numpy.ndarray, dtype=np.uint32.) – The offsets into the
location
array.parents (numpy.ndarray, dtype=np.int32) – The flattened parents array. Must be specified along with
parents_offset
. If not specified or None, an empty parents array is stored for each individual.parents_offset (numpy.ndarray, dtype=np.uint32.) – The offsets into the
parents
array.metadata (numpy.ndarray, dtype=np.int8) – The flattened metadata array. Must be specified along with
metadata_offset
. If not specified or None, an empty metadata value is stored for each individual.metadata_offset (numpy.ndarray, dtype=np.uint32.) – The offsets into the
metadata
array.metadata_schema – The encoded metadata schema.
 append_columns(flags=None, location<