def test_unknown_time_scalar(self):
assert math.isnan(UNKNOWN_TIME)
assert util.is_unknown_time(UNKNOWN_TIME)
assert not util.is_unknown_time(math.nan)
assert not util.is_unknown_time(np.nan)
assert not util.is_unknown_time(0)
assert not util.is_unknown_time(math.inf)
assert not util.is_unknown_time(1)
assert not util.is_unknown_time(None)
assert not util.is_unknown_time([None])
def test_unknown_time_array(self):
test_arrays = (
[],
[True],
[False],
[True, False] * 5,
[[True], [False]],
[[[True, False], [True, False]], [[False, True], [True, False]]],
)
for spec in test_arrays:
spec = np.asarray(spec, dtype=bool)
array = np.zeros(shape=spec.shape)
array[spec] = UNKNOWN_TIME
assert_array_equal(spec, util.is_unknown_time(array))
weird_array = [0, UNKNOWN_TIME, np.nan, 1, math.inf]
assert_array_equal([False, True, False, False, False],
util.is_unknown_time(weird_array))
def test_unknown_time_bad_types(self):
with pytest.raises(ValueError):
util.is_unknown_time("bad")
with pytest.raises(ValueError):
util.is_unknown_time(np.array(["bad"]))
with pytest.raises(ValueError):
util.is_unknown_time(["bad"])
def test_mutations(self, tables):
self.verify_required_columns(
tables,
"mutations",
["site", "node", "derived_state", "derived_state_offset"],
)
self.verify_offset_pair(tables, len(tables.mutations), "mutations", "metadata")
self.verify_metadata_schema(tables, "mutations")
# Verify optional time column
d = tables.asdict()
d["mutations"]["time"] = None
lwt = lwt_module.LightweightTableCollection()
lwt.fromdict(d)
out = lwt.asdict()
assert all(util.is_unknown_time(val) for val in out["mutations"]["time"])
def dump_text(
ts,
*,
nodes,
edges,
sites,
mutations,
individuals,
populations,
provenances,
precision,
encoding,
base64_metadata,
):
if nodes is not None:
print(
"id",
"is_sample",
"time",
"population",
"individual",
"metadata",
sep="\t",
file=nodes,
)
for node in ts.nodes():
metadata = text_metadata(base64_metadata, encoding, node)
row = ("{id:d}\t"
"{is_sample:d}\t"
"{time:.{precision}f}\t"
"{population:d}\t"
"{individual:d}\t"
"{metadata}").format(
precision=precision,
id=node.id,
is_sample=node.is_sample(),
time=node.time,
population=node.population,
individual=node.individual,
metadata=metadata,
)
print(row, file=nodes)
if edges is not None:
print("left",
"right",
"parent",
"child",
"metadata",
sep="\t",
file=edges)
for edge in ts.edges():
metadata = text_metadata(base64_metadata, encoding, edge)
row = ("{left:.{precision}f}\t"
"{right:.{precision}f}\t"
"{parent:d}\t"
"{child:d}\t"
"{metadata}").format(
precision=precision,
left=edge.left,
right=edge.right,
parent=edge.parent,
child=edge.child,
metadata=metadata,
)
print(row, file=edges)
if sites is not None:
print("position", "ancestral_state", "metadata", sep="\t", file=sites)
for site in ts.sites():
metadata = text_metadata(base64_metadata, encoding, site)
row = ("{position:.{precision}f}\t"
"{ancestral_state}\t"
"{metadata}").format(
precision=precision,
position=site.position,
ancestral_state=site.ancestral_state,
metadata=metadata,
)
print(row, file=sites)
if mutations is not None:
print(
"site",
"node",
"time",
"derived_state",
"parent",
"metadata",
sep="\t",
file=mutations,
)
for site in ts.sites():
for mutation in site.mutations:
metadata = text_metadata(base64_metadata, encoding, mutation)
row = ("{site}\t"
"{node}\t"
"{time}\t"
"{derived_state}\t"
"{parent}\t"
"{metadata}").format(
site=mutation.site,
node=mutation.node,
time="unknown" if util.is_unknown_time(
mutation.time) else mutation.time,
derived_state=mutation.derived_state,
parent=mutation.parent,
metadata=metadata,
)
print(row, file=mutations)
if individuals is not None:
print(
"id",
"flags",
"location",
"parents",
"metadata",
sep="\t",
file=individuals,
)
for individual in ts.individuals():
metadata = text_metadata(base64_metadata, encoding, individual)
location = ",".join(map(str, individual.location))
parents = ",".join(map(str, individual.parents))
row = ("{id}\t"
"{flags}\t"
"{location}\t"
"{parents}\t"
"{metadata}").format(
id=individual.id,
flags=individual.flags,
location=location,
parents=parents,
metadata=metadata,
)
print(row, file=individuals)
if populations is not None:
print("id", "metadata", sep="\t", file=populations)
for population in ts.populations():
metadata = text_metadata(base64_metadata, encoding, population)
row = ("{id}\t"
"{metadata}").format(id=population.id, metadata=metadata)
print(row, file=populations)
if provenances is not None:
print("id", "timestamp", "record", sep="\t", file=provenances)
for provenance in ts.provenances():
row = ("{id}\t"
"{timestamp}\t"
"{record}\t").format(
id=provenance.id,
timestamp=provenance.timestamp,
record=provenance.record,
)
print(row, file=provenances)