tskit 1.0.4__cp315-cp315-win32.whl

tskit/__init__.py

@@ -0,0 +1,99 @@
+# MIT License
+#
+# Copyright (c) 2018-2025 Tskit Developers
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+import _tskit
+
+#: Special reserved value representing a null ID.
+NULL = _tskit.NULL
+
+#: Special value representing missing data in a genotype array
+MISSING_DATA = _tskit.MISSING_DATA
+
+#: Node flag value indicating that it is a sample.
+NODE_IS_SAMPLE = _tskit.NODE_IS_SAMPLE
+
+#: Constant representing the forward direction of travel (i.e.,
+#: increasing genomic coordinate values).
+FORWARD = _tskit.FORWARD
+
+#: Constant representing the reverse direction of travel (i.e.,
+#: decreasing genomic coordinate values).
+REVERSE = _tskit.REVERSE
+
+#: The allele mapping where the strings "0" and "1" map to genotype
+#: values 0 and 1.
+ALLELES_01 = ("0", "1")
+
+#: The allele mapping where the four nucleotides A, C, G and T map to
+#: the genotype integers 0, 1, 2, and 3, respectively.
+ALLELES_ACGT = ("A", "C", "G", "T")
+
+#: Special NAN value used to indicate unknown mutation times. Since this is a
+#: NAN value, you cannot use `==` to test for it. Use :func:`is_unknown_time` instead.
+UNKNOWN_TIME = _tskit.UNKNOWN_TIME
+
+#: Default value of ts.time_units
+TIME_UNITS_UNKNOWN = _tskit.TIME_UNITS_UNKNOWN
+
+#: ts.time_units value when dimension is uncalibrated
+TIME_UNITS_UNCALIBRATED = _tskit.TIME_UNITS_UNCALIBRATED
+
+#: Options for printing to strings and HTML, modify with tskit.set_print_options.
+_print_options = {"max_lines": 40}
+
+TABLE_NAMES = [
+    "individuals",
+    "nodes",
+    "edges",
+    "migrations",
+    "sites",
+    "mutations",
+    "populations",
+    "provenances",
+]
+
+#: Threshhold for warning about multiple top-level metadata use.
+#: A warning will be thrown if top-level metadata is larger than "size" bytes and is
+#: accessed more that "threshhold" times.  To disable, set threshhold to a large number,
+#: for instance: ``tskit.METADATA_ACCESS_WARNING_COUNT = 2**32``.
+METADATA_ACCESS_WARNING_COUNT = 20
+#: The minimum size of top-level metadata before a multiple access warning is produced.
+METADATA_ACCESS_WARNING_SIZE = 200_000
+
+from tskit.provenance import __version__  # NOQA
+from tskit.provenance import validate_provenance  # NOQA
+from tskit.trees import *  # NOQA
+from tskit.genotypes import Variant  # NOQA
+from tskit.tables import *  # NOQA
+from tskit.stats import *  # NOQA
+from tskit.combinatorics import (  # NOQA
+    all_trees,
+    all_tree_shapes,
+    all_tree_labellings,
+    TopologyCounter,
+    Rank,
+)
+from tskit.drawing import SVGString  # NOQA
+from tskit.exceptions import *  # NOQA
+from tskit.util import *  # NOQA
+from tskit.metadata import *  # NOQA
+from tskit.text_formats import *  # NOQA
+from tskit.intervals import RateMap  # NOQA

tskit/__main__.py

@@ -0,0 +1,4 @@
+from . import cli
+
+if __name__ == "__main__":
+    cli.tskit_main()

tskit/_version.py

@@ -0,0 +1,4 @@
+# Definitive location for the version number.
+# During development, should be x.y.z.devN
+# For beta should be x.y.zbN
+tskit_version = "1.0.4"

tskit/cli.py

@@ -0,0 +1,281 @@
+#
+# MIT License
+#
+# Copyright (c) 2018-2026 Tskit Developers
+# Copyright (c) 2015-2018 University of Oxford
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+"""
+Command line utilities for tskit.
+"""
+
+import argparse
+import json
+import os
+import signal
+import sys
+
+import tskit
+
+
+def set_sigpipe_handler():
+    if os.name == "posix":
+        # Set signal handler for SIGPIPE to quietly kill the program.
+        signal.signal(signal.SIGPIPE, signal.SIG_DFL)
+
+
+def sys_exit(message):
+    sys.exit(message)
+
+
+def load_tree_sequence(path):
+    if path is None:
+        path = sys.stdin
+    try:
+        return tskit.load(path)
+    except (OSError, EOFError, tskit.FileFormatError) as e:
+        sys_exit(f"Load error: {e}")
+
+
+def run_info(args):
+    print(load_tree_sequence(args.tree_sequence))
+
+
+def run_trees(args):
+    ts = load_tree_sequence(args.tree_sequence)
+    for tree in ts.trees():
+        print(f"tree {tree.index}:")
+        print(f"  num_sites: {tree.num_sites}")
+        print(
+            "  interval:  ({0:.{2}f}, {1:.{2}f})".format(
+                tree.interval.left, tree.interval.right, args.precision
+            )
+        )
+        if args.draw:
+            print(tree.draw(format="unicode"))
+
+
+def run_individuals(args):
+    tree_sequence = load_tree_sequence(args.tree_sequence)
+    tree_sequence.dump_text(individuals=sys.stdout, precision=args.precision)
+
+
+def run_nodes(args):
+    tree_sequence = load_tree_sequence(args.tree_sequence)
+    tree_sequence.dump_text(nodes=sys.stdout, precision=args.precision)
+
+
+def run_edges(args):
+    tree_sequence = load_tree_sequence(args.tree_sequence)
+    tree_sequence.dump_text(edges=sys.stdout, precision=args.precision)
+
+
+def run_sites(args):
+    tree_sequence = load_tree_sequence(args.tree_sequence)
+    tree_sequence.dump_text(sites=sys.stdout, precision=args.precision)
+
+
+def run_mutations(args):
+    tree_sequence = load_tree_sequence(args.tree_sequence)
+    tree_sequence.dump_text(mutations=sys.stdout, precision=args.precision)
+
+
+def run_populations(args):
+    tree_sequence = load_tree_sequence(args.tree_sequence)
+    tree_sequence.dump_text(populations=sys.stdout)
+
+
+def run_migrations(args):
+    tree_sequence = load_tree_sequence(args.tree_sequence)
+    tree_sequence.dump_text(migrations=sys.stdout, precision=args.precision)
+
+
+def run_provenances(args):
+    tree_sequence = load_tree_sequence(args.tree_sequence)
+    if args.human:
+        for provenance in tree_sequence.provenances():
+            d = json.loads(provenance.record)
+            print(
+                "id={}, timestamp={}, record={}".format(
+                    provenance.id, provenance.timestamp, json.dumps(d, indent=4)
+                )
+            )
+    else:
+        tree_sequence.dump_text(provenances=sys.stdout)
+
+
+def run_fasta(args):
+    tree_sequence = load_tree_sequence(args.tree_sequence)
+    tree_sequence.write_fasta(sys.stdout, wrap_width=args.wrap)
+
+
+def run_vcf(args):
+    tree_sequence = load_tree_sequence(args.tree_sequence)
+    tree_sequence.write_vcf(
+        sys.stdout,
+        ploidy=args.ploidy,
+        contig_id=args.contig_id,
+        allow_position_zero=args.allow_position_zero,
+    )
+
+
+def add_tree_sequence_argument(parser):
+    parser.add_argument(
+        "tree_sequence",
+        help="The tskit tree sequence file. If not provided, read from stdin.",
+        default=None,
+        nargs="?",
+    )
+
+
+def add_precision_argument(parser):
+    parser.add_argument(
+        "--precision",
+        "-p",
+        type=int,
+        default=6,
+        help="The number of decimal places to print in records",
+    )
+
+
+def get_tskit_parser():
+    top_parser = argparse.ArgumentParser(
+        prog="python3 -m tskit", description="Command line interface for tskit."
+    )
+    top_parser.add_argument(
+        "-V", "--version", action="version", version=f"%(prog)s {tskit.__version__}"
+    )
+    subparsers = top_parser.add_subparsers(dest="subcommand")
+    subparsers.required = True
+
+    parser = subparsers.add_parser(
+        "info", help="Print summary information about a tree sequence."
+    )
+    add_tree_sequence_argument(parser)
+    parser.set_defaults(runner=run_info)
+
+    parser = subparsers.add_parser("trees", help="Print information about trees.")
+    add_tree_sequence_argument(parser)
+    add_precision_argument(parser)
+    parser.add_argument(
+        "--draw", "-d", action="store_true", default=False, help="Draw the trees"
+    )
+    parser.set_defaults(runner=run_trees)
+
+    # suppress fasta visibility until we have a reference sequence
+    # See https://github.com/tskit-dev/tskit/issues/1888
+    # parser = subparsers.add_parser(
+    #    "fasta",
+    #     help="Convert the tree sequence haplotypes to fasta format")
+    # add_tree_sequence_argument(parser)
+    # parser.add_argument(
+    #     "--wrap", "-w", type=int, default=60,
+    #     help=("line-wrapping width for printed sequences"))
+    # parser.set_defaults(runner=run_fasta)
+    parser = subparsers.add_parser(
+        "vcf", help="Convert the tree sequence genotypes to VCF format."
+    )
+    add_tree_sequence_argument(parser)
+    parser.add_argument(
+        "--ploidy",
+        "-P",
+        type=int,
+        default=None,
+        help=(
+            "If the tree sequence does not contain information about "
+            "individuals, create them by combining adjacent samples nodes "
+            "into individuals of the specified ploidy. It is an error "
+            "to provide this argument if the tree sequence does contain "
+            "individuals"
+        ),
+    )
+    parser.add_argument(
+        "--contig-id", "-c", type=str, default="1", help="Specify the contig id"
+    )
+    parser.add_argument(
+        "--allow-position-zero",
+        "-0",
+        action="store_true",
+        default=False,
+        help="Allow position 0 sites",
+    )
+    parser.set_defaults(runner=run_vcf)
+
+    parser = subparsers.add_parser(
+        "individuals", help="Output individuals in tabular format."
+    )
+    add_tree_sequence_argument(parser)
+    add_precision_argument(parser)
+    parser.set_defaults(runner=run_individuals)
+
+    parser = subparsers.add_parser("nodes", help="Output nodes in tabular format.")
+    add_tree_sequence_argument(parser)
+    add_precision_argument(parser)
+    parser.set_defaults(runner=run_nodes)
+
+    parser = subparsers.add_parser("edges", help="Output edges in tabular format.")
+    add_tree_sequence_argument(parser)
+    add_precision_argument(parser)
+    parser.set_defaults(runner=run_edges)
+
+    parser = subparsers.add_parser("sites", help="Output sites in tabular format.")
+    add_tree_sequence_argument(parser)
+    add_precision_argument(parser)
+    parser.set_defaults(runner=run_sites)
+
+    parser = subparsers.add_parser(
+        "mutations", help="Output mutations in tabular format."
+    )
+    add_tree_sequence_argument(parser)
+    add_precision_argument(parser)
+    parser.set_defaults(runner=run_mutations)
+
+    parser = subparsers.add_parser(
+        "populations", help="Output population information in tabular format."
+    )
+    add_tree_sequence_argument(parser)
+    parser.set_defaults(runner=run_populations)
+
+    parser = subparsers.add_parser(
+        "migrations", help="Output migration information in tabular format."
+    )
+    add_tree_sequence_argument(parser)
+    add_precision_argument(parser)
+    parser.set_defaults(runner=run_migrations)
+
+    parser = subparsers.add_parser(
+        "provenances", help="Output provenance information in tabular format."
+    )
+    add_tree_sequence_argument(parser)
+    parser.add_argument(
+        "-H",
+        "--human",
+        action="store_true",
+        help="Print out the provenances in a human readable format",
+    )
+    parser.set_defaults(runner=run_provenances)
+
+    return top_parser
+
+
+def tskit_main(arg_list=None):
+    set_sigpipe_handler()
+    parser = get_tskit_parser()
+    args = parser.parse_args(arg_list)
+    args.runner(args)