def test_label_mutability():
dummy_video = Video(backend=MediaVideo)
dummy_skeleton = Skeleton()
dummy_instance = Instance(dummy_skeleton)
dummy_frame = LabeledFrame(dummy_video, frame_idx=0, instances=[dummy_instance])
labels = Labels()
labels.append(dummy_frame)
assert dummy_video in labels.videos
assert dummy_video in labels
assert dummy_skeleton in labels.skeletons
assert dummy_skeleton in labels
assert dummy_frame in labels.labeled_frames
assert dummy_frame in labels
assert (dummy_video, 0) in labels
assert (dummy_video, 1) not in labels
dummy_video2 = Video(backend=MediaVideo)
dummy_skeleton2 = Skeleton(name="dummy2")
dummy_instance2 = Instance(dummy_skeleton2)
dummy_frame2 = LabeledFrame(dummy_video2, frame_idx=0, instances=[dummy_instance2])
assert dummy_video2 not in labels
assert dummy_skeleton2 not in labels
assert dummy_frame2 not in labels
labels.append(dummy_frame2)
assert dummy_video2 in labels
assert dummy_frame2 in labels
labels.remove_video(dummy_video2)
assert dummy_video2 not in labels
assert dummy_frame2 not in labels
assert len(labels.find(dummy_video2)) == 0
assert len(labels) == 1
labels.append(LabeledFrame(dummy_video, frame_idx=0))
assert len(labels) == 1
dummy_frames = [LabeledFrame(dummy_video, frame_idx=i) for i in range(10)]
dummy_frames2 = [LabeledFrame(dummy_video2, frame_idx=i) for i in range(10)]
for f in dummy_frames + dummy_frames2:
labels.append(f)
assert len(labels) == 20
labels.remove_video(dummy_video2)
assert len(labels) == 10
assert len(labels.find(dummy_video)) == 10
assert dummy_frame in labels
assert all([label in labels for label in dummy_frames[1:]])
assert dummy_video2 not in labels
assert len(labels.find(dummy_video2)) == 0
assert all([label not in labels for label in dummy_frames2])
labels.remove_video(dummy_video)
assert len(labels.find(dummy_video)) == 0
def test_scalar_properties():
# Scalar
dummy_video = Video(backend=MediaVideo)
dummy_skeleton = Skeleton()
dummy_instance = Instance(dummy_skeleton)
dummy_frame = LabeledFrame(dummy_video,
frame_idx=0,
instances=[dummy_instance])
labels = Labels()
labels.append(dummy_frame)
assert labels.video == dummy_video
assert labels.skeleton == dummy_skeleton
# Empty
labels = Labels()
with pytest.raises(ValueError):
labels.video
with pytest.raises(ValueError):
labels.skeleton
# More than one video
dummy_skeleton = Skeleton()
labels = Labels()
labels.append(
LabeledFrame(Video(backend=MediaVideo),
frame_idx=0,
instances=[Instance(dummy_skeleton)]))
labels.append(
LabeledFrame(Video(backend=MediaVideo),
frame_idx=0,
instances=[Instance(dummy_skeleton)]))
assert labels.skeleton == dummy_skeleton
with pytest.raises(ValueError):
labels.video
# More than one skeleton
dummy_video = Video(backend=MediaVideo)
labels = Labels()
labels.append(
LabeledFrame(dummy_video,
frame_idx=0,
instances=[Instance(Skeleton())]))
labels.append(
LabeledFrame(dummy_video,
frame_idx=1,
instances=[Instance(Skeleton())]))
assert labels.video == dummy_video
with pytest.raises(ValueError):
labels.skeleton
def test_eq():
s1 = Skeleton("s1")
s1.add_nodes(["1", "2", "3", "4", "5", "6"])
s1.add_edge("1", "2")
s1.add_edge("3", "4")
s1.add_edge("5", "6")
s1.add_symmetry("3", "6")
# Make a copy check that they are equal
s2 = copy.deepcopy(s1)
assert s1.matches(s2)
# Add an edge, check that they are not equal
s2 = copy.deepcopy(s1)
s2.add_edge("5", "1")
assert not s1.matches(s2)
# Add a symmetry edge, not equal
s2 = copy.deepcopy(s1)
s2.add_symmetry("5", "1")
assert not s1.matches(s2)
# Delete a node
s2 = copy.deepcopy(s1)
s2.delete_node("5")
assert not s1.matches(s2)
# Delete and edge, not equal
s2 = copy.deepcopy(s1)
s2.delete_edge("1", "2")
assert not s1.matches(s2)
def test_symmetry():
s1 = Skeleton("s1")
s1.add_nodes(["1", "2", "3", "4", "5", "6"])
s1.add_edge("1", "2")
s1.add_edge("3", "4")
s1.add_edge("5", "6")
s1.add_symmetry("1", "5")
s1.add_symmetry("3", "6")
assert s1.get_symmetry("1").name == "5"
assert s1.get_symmetry("5").name == "1"
assert s1.get_symmetry("3").name == "6"
# Cannot add more than one symmetry to a node
with pytest.raises(ValueError):
s1.add_symmetry("1", "6")
with pytest.raises(ValueError):
s1.add_symmetry("6", "1")
s1.delete_symmetry("1", "5")
assert s1.get_symmetry("1") is None
with pytest.raises(ValueError):
s1.delete_symmetry("1", "5")
def test_symmetry():
s1 = Skeleton("s1")
s1.add_nodes(["1", "2", "3", "4", "5", "6"])
s1.add_edge("1", "2")
s1.add_edge("3", "4")
s1.add_edge("5", "6")
s1.add_symmetry("1", "5")
s1.add_symmetry("3", "6")
assert (s1.nodes[0], s1.nodes[4]) in s1.symmetries
assert (s1.nodes[2], s1.nodes[5]) in s1.symmetries
assert len(s1.symmetries) == 2
assert (0, 4) in s1.symmetric_inds
assert (2, 5) in s1.symmetric_inds
assert len(s1.symmetric_inds) == 2
assert s1.get_symmetry("1").name == "5"
assert s1.get_symmetry("5").name == "1"
assert s1.get_symmetry("3").name == "6"
# Cannot add more than one symmetry to a node
with pytest.raises(ValueError):
s1.add_symmetry("1", "6")
with pytest.raises(ValueError):
s1.add_symmetry("6", "1")
s1.delete_symmetry("1", "5")
assert s1.get_symmetry("1") is None
with pytest.raises(ValueError):
s1.delete_symmetry("1", "5")
def test_instance_access():
labels = Labels()
dummy_skeleton = Skeleton()
dummy_video = Video(backend=MediaVideo)
dummy_video2 = Video(backend=MediaVideo)
for i in range(10):
labels.append(
LabeledFrame(
dummy_video,
frame_idx=i,
instances=[Instance(dummy_skeleton),
Instance(dummy_skeleton)],
))
for i in range(10):
labels.append(
LabeledFrame(
dummy_video2,
frame_idx=i,
instances=[
Instance(dummy_skeleton),
Instance(dummy_skeleton),
Instance(dummy_skeleton),
],
))
assert len(labels.all_instances) == 50
assert len(list(labels.instances(video=dummy_video))) == 20
assert len(list(labels.instances(video=dummy_video2))) == 30
def test_merge_predictions():
dummy_video_a = Video.from_filename("foo.mp4")
dummy_video_b = Video.from_filename("foo.mp4")
dummy_skeleton_a = Skeleton()
dummy_skeleton_a.add_node("node")
dummy_skeleton_b = Skeleton()
dummy_skeleton_b.add_node("node")
dummy_instances_a = []
dummy_instances_a.append(
Instance(skeleton=dummy_skeleton_a, points=dict(node=Point(1, 1)))
)
dummy_instances_a.append(
Instance(skeleton=dummy_skeleton_a, points=dict(node=Point(2, 2)))
)
labels_a = Labels()
labels_a.append(
LabeledFrame(dummy_video_a, frame_idx=0, instances=dummy_instances_a)
)
dummy_instances_b = []
dummy_instances_b.append(
Instance(skeleton=dummy_skeleton_b, points=dict(node=Point(1, 1)))
)
dummy_instances_b.append(
PredictedInstance(
skeleton=dummy_skeleton_b, points=dict(node=Point(3, 3)), score=1
)
)
labels_b = Labels()
labels_b.append(
LabeledFrame(dummy_video_b, frame_idx=0, instances=dummy_instances_b)
)
# Frames have one redundant instance (perfect match) and all the
# non-matching instances are different types (one predicted, one not).
merged, extra_a, extra_b = Labels.complex_merge_between(labels_a, labels_b)
assert len(merged[dummy_video_a]) == 1
assert len(merged[dummy_video_a][0]) == 1 # the predicted instance was merged
assert not extra_a
assert not extra_b
def simple_predictions():
video = Video.from_filename("video.mp4")
skeleton = Skeleton()
skeleton.add_node("a")
skeleton.add_node("b")
track_a = Track(0, "a")
track_b = Track(0, "b")
labels = Labels()
instances = []
instances.append(
PredictedInstance(
skeleton=skeleton,
score=2,
track=track_a,
points=dict(a=PredictedPoint(1, 1, score=0.5),
b=PredictedPoint(1, 1, score=0.5)),
))
instances.append(
PredictedInstance(
skeleton=skeleton,
score=5,
track=track_b,
points=dict(a=PredictedPoint(1, 1, score=0.7),
b=PredictedPoint(1, 1, score=0.7)),
))
labeled_frame = LabeledFrame(video, frame_idx=0, instances=instances)
labels.append(labeled_frame)
instances = []
instances.append(
PredictedInstance(
skeleton=skeleton,
score=3,
track=track_a,
points=dict(a=PredictedPoint(4, 5, score=1.5),
b=PredictedPoint(1, 1, score=1.0)),
))
instances.append(
PredictedInstance(
skeleton=skeleton,
score=6,
track=track_b,
points=dict(a=PredictedPoint(6, 13, score=1.7),
b=PredictedPoint(1, 1, score=1.0)),
))
labeled_frame = LabeledFrame(video, frame_idx=1, instances=instances)
labels.append(labeled_frame)
return labels
def test_basic_suggestions(small_robot_mp4_vid):
dummy_video = small_robot_mp4_vid
dummy_skeleton = Skeleton()
dummy_instance = Instance(dummy_skeleton)
dummy_frame = LabeledFrame(dummy_video, frame_idx=0, instances=[dummy_instance])
labels = Labels()
labels.append(dummy_frame)
suggestions = VideoFrameSuggestions.suggest(
labels=labels, params=dict(method="sample", per_video=13)
)
labels.set_suggestions(suggestions)
assert len(labels.get_video_suggestions(dummy_video)) == 13
def skeleton():
# Create a simple skeleton object
skeleton = Skeleton("Fly")
skeleton.add_node("head")
skeleton.add_node("thorax")
skeleton.add_node("abdomen")
skeleton.add_node("left-wing")
skeleton.add_node("right-wing")
skeleton.add_edge(source="head", destination="thorax")
skeleton.add_edge(source="thorax", destination="abdomen")
skeleton.add_edge(source="thorax", destination="left-wing")
skeleton.add_edge(source="thorax", destination="right-wing")
skeleton.add_symmetry(node1="left-wing", node2="right-wing")
return skeleton
def removal_test_labels():
skeleton = Skeleton()
video = Video(backend=MediaVideo)
lf_user_only = LabeledFrame(
video=video, frame_idx=0, instances=[Instance(skeleton=skeleton)]
)
lf_pred_only = LabeledFrame(
video=video, frame_idx=1, instances=[PredictedInstance(skeleton=skeleton)]
)
lf_both = LabeledFrame(
video=video,
frame_idx=2,
instances=[Instance(skeleton=skeleton), PredictedInstance(skeleton=skeleton)],
)
labels = Labels([lf_user_only, lf_pred_only, lf_both])
return labels
def stickman():
# Make a skeleton with a space in its name to test things.
stickman = Skeleton("Stick man")
stickman.add_nodes(
["head", "neck", "body", "right-arm", "left-arm", "right-leg", "left-leg"]
)
stickman.add_edge("neck", "head")
stickman.add_edge("body", "neck")
stickman.add_edge("body", "right-arm")
stickman.add_edge("body", "left-arm")
stickman.add_edge("body", "right-leg")
stickman.add_edge("body", "left-leg")
stickman.add_symmetry(node1="left-arm", node2="right-arm")
stickman.add_symmetry(node1="left-leg", node2="right-leg")
return stickman
def test_nms_instances_to_remove():
skeleton = Skeleton()
skeleton.add_nodes(("a", "b"))
instances = []
inst = PredictedInstance(skeleton=skeleton)
inst["a"].x = 10
inst["a"].y = 10
inst["b"].x = 20
inst["b"].y = 20
inst.score = 1
instances.append(inst)
inst = PredictedInstance(skeleton=skeleton)
inst["a"].x = 10
inst["a"].y = 10
inst["b"].x = 15
inst["b"].y = 15
inst.score = 0.3
instances.append(inst)
inst = PredictedInstance(skeleton=skeleton)
inst["a"].x = 30
inst["a"].y = 30
inst["b"].x = 40
inst["b"].y = 40
inst.score = 1
instances.append(inst)
inst = PredictedInstance(skeleton=skeleton)
inst["a"].x = 32
inst["a"].y = 32
inst["b"].x = 42
inst["b"].y = 42
inst.score = 0.5
instances.append(inst)
to_keep, to_remove = nms_instances(instances,
iou_threshold=0.5,
target_count=3)
assert len(to_remove) == 1
assert to_remove[0].matches(instances[1])
def test_labels_merge():
dummy_video = Video(backend=MediaVideo)
dummy_skeleton = Skeleton()
dummy_skeleton.add_node("node")
labels = Labels()
dummy_frames = []
# Add 10 instances with different points (so they aren't "redundant")
for i in range(10):
instance = Instance(skeleton=dummy_skeleton, points=dict(node=Point(i, i)))
dummy_frame = LabeledFrame(dummy_video, frame_idx=0, instances=[instance])
dummy_frames.append(dummy_frame)
labels.labeled_frames.extend(dummy_frames)
assert len(labels) == 10
assert len(labels.labeled_frames[0].instances) == 1
labels.merge_matching_frames()
assert len(labels) == 1
assert len(labels.labeled_frames[0].instances) == 10
def test_hdf5(skeleton, stickman, tmpdir):
filename = os.path.join(tmpdir, "skeleton.h5")
if os.path.isfile(filename):
os.remove(filename)
# Save both skeletons to the HDF5 filename
skeleton.save_hdf5(filename)
stickman.save_hdf5(filename)
# Load the all the skeletons as a list
sk_list = Skeleton.load_all_hdf5(filename)
# Lets check that they are equal to what we saved, this checks the order too.
assert skeleton.matches(sk_list[0])
assert stickman.matches(sk_list[1])
# Check load to dict as well
sk_dict = Skeleton.load_all_hdf5(filename, return_dict=True)
assert skeleton.matches(sk_dict[skeleton.name])
assert stickman.matches(sk_dict[stickman.name])
# Check individual load
assert Skeleton.load_hdf5(filename, skeleton.name).matches(skeleton)
assert Skeleton.load_hdf5(filename, stickman.name).matches(stickman)
# Check overwrite save and save list
Skeleton.save_all_hdf5(filename, [skeleton, stickman])
assert Skeleton.load_hdf5(filename, skeleton.name).matches(skeleton)
assert Skeleton.load_hdf5(filename, stickman.name).matches(stickman)
# Make sure we can't load a non-existent skeleton
with pytest.raises(KeyError):
Skeleton.load_hdf5(filename, "BadName")
# Make sure we can't save skeletons with the same name
with pytest.raises(ValueError):
Skeleton.save_all_hdf5(
filename, [skeleton, Skeleton(name=skeleton.name)])
def test_deserialize_suggestions(small_robot_mp4_vid, tmpdir):
dummy_video = small_robot_mp4_vid
dummy_skeleton = Skeleton()
dummy_instance = Instance(dummy_skeleton)
dummy_frame = LabeledFrame(dummy_video, frame_idx=0, instances=[dummy_instance])
labels = Labels()
labels.append(dummy_frame)
suggestions = VideoFrameSuggestions.suggest(
labels=labels, params=dict(method="sample", per_video=13)
)
labels.set_suggestions(suggestions)
filename = os.path.join(tmpdir, "new_suggestions.h5")
Labels.save_file(filename=filename, labels=labels)
new_suggestion_labels = Labels.load_file(filename)
assert len(suggestions) == len(new_suggestion_labels.suggestions)
assert [frame.frame_idx for frame in suggestions] == [
frame.frame_idx for frame in new_suggestion_labels.suggestions
]
def __init__(self, labels_path: Optional[str] = None, *args, **kwargs):
"""Initialize the app.
Args:
labels_path: Path to saved :class:`Labels` dataset.
Returns:
None.
"""
super(MainWindow, self).__init__(*args, **kwargs)
self.state = GuiState()
self.labels = Labels()
self.commands = CommandContext(state=self.state,
app=self,
update_callback=self.on_data_update)
self._menu_actions = dict()
self._buttons = dict()
self._child_windows = dict()
self.overlays = dict()
self.state.connect("filename", self.setWindowTitle)
self.state["skeleton"] = Skeleton()
self.state["labeled_frame"] = None
self.state["filename"] = None
self.state["show labels"] = True
self.state["show edges"] = True
self.state["edge style"] = "Line"
self.state["fit"] = False
self.state["color predicted"] = prefs["color predicted"]
self._initialize_gui()
if labels_path:
self.loadProjectFile(labels_path)
def test_skeleton_node_name_change():
"""
Test that and instance is not broken after a node on the
skeleton has its name changed.
"""
s = Skeleton("Test")
s.add_nodes(["a", "b", "c", "d", "e"])
s.add_edge("a", "b")
instance = Instance(s)
instance["a"] = Point(1, 2)
instance["b"] = Point(3, 4)
# Rename the node
s.relabel_nodes({"a": "A"})
# Reference to the old node name should raise a KeyError
with pytest.raises(KeyError):
instance["a"].x = 2
# Make sure the A now references the same point on the instance
assert instance["A"] == Point(1, 2)
assert instance["b"] == Point(3, 4)
def load_predicted_labels_json_old(
data_path: str,
parsed_json: dict = None,
adjust_matlab_indexing: bool = True,
fix_rel_paths: bool = True,
) -> List[LabeledFrame]:
"""
Load predicted instances from Talmo's old JSON format.
Args:
data_path: The path to the JSON file.
parsed_json: The parsed json if already loaded, so we can save
some time if already parsed.
adjust_matlab_indexing: Whether to adjust indexing from MATLAB.
fix_rel_paths: Whether to fix paths to videos to absolute paths.
Returns:
List of :class:`LabeledFrame` objects.
"""
if parsed_json is None:
data = json.loads(open(data_path).read())
else:
data = parsed_json
videos = pd.DataFrame(data["videos"])
predicted_instances = pd.DataFrame(data["predicted_instances"])
predicted_points = pd.DataFrame(data["predicted_points"])
if adjust_matlab_indexing:
predicted_instances.frameIdx -= 1
predicted_points.frameIdx -= 1
predicted_points.node -= 1
predicted_points.x -= 1
predicted_points.y -= 1
skeleton = Skeleton()
skeleton.add_nodes(data["skeleton"]["nodeNames"])
edges = data["skeleton"]["edges"]
if adjust_matlab_indexing:
edges = np.array(edges) - 1
for (src_idx, dst_idx) in edges:
skeleton.add_edge(
data["skeleton"]["nodeNames"][src_idx],
data["skeleton"]["nodeNames"][dst_idx],
)
if fix_rel_paths:
for i, row in videos.iterrows():
p = row.filepath
if not os.path.exists(p):
p = os.path.join(os.path.dirname(data_path), p)
if os.path.exists(p):
videos.at[i, "filepath"] = p
# Make the video objects
video_objects = {}
for i, row in videos.iterrows():
if videos.at[i, "format"] == "media":
vid = Video.from_media(videos.at[i, "filepath"])
else:
vid = Video.from_hdf5(
filename=videos.at[i, "filepath"], dataset=videos.at[i, "dataset"]
)
video_objects[videos.at[i, "id"]] = vid
track_ids = predicted_instances["trackId"].values
unique_track_ids = np.unique(track_ids)
spawned_on = {
track_id: predicted_instances.loc[predicted_instances["trackId"] == track_id][
"frameIdx"
].values[0]
for track_id in unique_track_ids
}
tracks = {
i: Track(name=str(i), spawned_on=spawned_on[i])
for i in np.unique(predicted_instances["trackId"].values).tolist()
}
# A function to get all the instances for a particular video frame
def get_frame_predicted_instances(video_id, frame_idx):
points = predicted_points
is_in_frame = (points["videoId"] == video_id) & (
points["frameIdx"] == frame_idx
)
if not is_in_frame.any():
return []
instances = []
frame_instance_ids = np.unique(points["instanceId"][is_in_frame])
for i, instance_id in enumerate(frame_instance_ids):
is_instance = is_in_frame & (points["instanceId"] == instance_id)
track_id = predicted_instances.loc[
predicted_instances["id"] == instance_id
]["trackId"].values[0]
match_score = predicted_instances.loc[
predicted_instances["id"] == instance_id
]["matching_score"].values[0]
track_score = predicted_instances.loc[
predicted_instances["id"] == instance_id
]["tracking_score"].values[0]
instance_points = {
data["skeleton"]["nodeNames"][n]: PredictedPoint(
x, y, visible=v, score=confidence
)
for x, y, n, v, confidence in zip(
*[
points[k][is_instance]
for k in ["x", "y", "node", "visible", "confidence"]
]
)
}
instance = PredictedInstance(
skeleton=skeleton,
points=instance_points,
track=tracks[track_id],
score=match_score,
)
instances.append(instance)
return instances
# Get the unique labeled frames and construct a list of LabeledFrame objects for them.
frame_keys = list(
{
(videoId, frameIdx)
for videoId, frameIdx in zip(
predicted_points["videoId"], predicted_points["frameIdx"]
)
}
)
frame_keys.sort()
labels = []
for videoId, frameIdx in frame_keys:
label = LabeledFrame(
video=video_objects[videoId],
frame_idx=frameIdx,
instances=get_frame_predicted_instances(videoId, frameIdx),
)
labels.append(label)
return labels
def test_complex_merge():
dummy_video_a = Video.from_filename("foo.mp4")
dummy_video_b = Video.from_filename("foo.mp4")
dummy_skeleton_a = Skeleton()
dummy_skeleton_a.add_node("node")
dummy_skeleton_b = Skeleton()
dummy_skeleton_b.add_node("node")
dummy_instances_a = []
dummy_instances_a.append(
Instance(skeleton=dummy_skeleton_a, points=dict(node=Point(1, 1))))
dummy_instances_a.append(
Instance(skeleton=dummy_skeleton_a, points=dict(node=Point(2, 2))))
labels_a = Labels()
labels_a.append(
LabeledFrame(dummy_video_a, frame_idx=0, instances=dummy_instances_a))
dummy_instances_b = []
dummy_instances_b.append(
Instance(skeleton=dummy_skeleton_b, points=dict(node=Point(1, 1))))
dummy_instances_b.append(
Instance(skeleton=dummy_skeleton_b, points=dict(node=Point(3, 3))))
labels_b = Labels()
labels_b.append(
LabeledFrame(dummy_video_b, frame_idx=0,
instances=dummy_instances_b)) # conflict
labels_b.append(
LabeledFrame(dummy_video_b, frame_idx=1,
instances=dummy_instances_b)) # clean
merged, extra_a, extra_b = Labels.complex_merge_between(labels_a, labels_b)
# Check that we have the cleanly merged frame
assert dummy_video_a in merged
assert len(merged[dummy_video_a]) == 1 # one merged frame
assert len(merged[dummy_video_a][1]) == 2 # with two instances
# Check that labels_a includes redundant and clean
assert len(labels_a.labeled_frames) == 2
assert len(labels_a.labeled_frames[0].instances) == 1
assert labels_a.labeled_frames[0].instances[0].points[0].x == 1
assert len(labels_a.labeled_frames[1].instances) == 2
assert labels_a.labeled_frames[1].instances[0].points[0].x == 1
assert labels_a.labeled_frames[1].instances[1].points[0].x == 3
# Check that extra_a/b includes the appropriate conflicting instance
assert len(extra_a) == 1
assert len(extra_b) == 1
assert len(extra_a[0].instances) == 1
assert len(extra_b[0].instances) == 1
assert extra_a[0].instances[0].points[0].x == 2
assert extra_b[0].instances[0].points[0].x == 3
# Check that objects were unified
assert extra_a[0].video == extra_b[0].video
# Check resolving the conflict using new
Labels.finish_complex_merge(labels_a, extra_b)
assert len(labels_a.labeled_frames) == 2
assert len(labels_a.labeled_frames[0].instances) == 2
assert labels_a.labeled_frames[0].instances[1].points[0].x == 3
def test_arborescence():
skeleton = Skeleton()
skeleton.add_node("a")
skeleton.add_node("b")
skeleton.add_node("c")
# linear: a -> b -> c
skeleton.add_edge("a", "b")
skeleton.add_edge("b", "c")
assert skeleton.is_arborescence
skeleton = Skeleton()
skeleton.add_node("a")
skeleton.add_node("b")
skeleton.add_node("c")
# two branches from a: a -> b and a -> c
skeleton.add_edge("a", "b")
skeleton.add_edge("a", "c")
assert skeleton.is_arborescence
skeleton = Skeleton()
skeleton.add_node("a")
skeleton.add_node("b")
skeleton.add_node("c")
# no edges so too many roots
assert not skeleton.is_arborescence
assert sorted((n.name for n in skeleton.root_nodes)) == ["a", "b", "c"]
# still too many roots: a and c
skeleton.add_edge("a", "b")
assert not skeleton.is_arborescence
assert sorted((n.name for n in skeleton.root_nodes)) == ["a", "c"]
skeleton = Skeleton()
skeleton.add_node("a")
skeleton.add_node("b")
skeleton.add_node("c")
# cycle
skeleton.add_edge("a", "b")
skeleton.add_edge("b", "c")
skeleton.add_edge("c", "a")
assert not skeleton.is_arborescence
assert len(skeleton.cycles) == 1
assert len(skeleton.root_nodes) == 0
skeleton = Skeleton()
skeleton.add_node("a")
skeleton.add_node("b")
skeleton.add_node("c")
skeleton.add_node("d")
# diamond, too many sources leading to d
skeleton.add_edge("a", "b")
skeleton.add_edge("a", "c")
skeleton.add_edge("b", "d")
skeleton.add_edge("c", "d")
assert not skeleton.is_arborescence
assert len(skeleton.cycles) == 0
assert len(skeleton.root_nodes) == 1
assert len(skeleton.in_degree_over_one) == 1
def test_edge_order():
"""Test is edge list order is maintained upon insertion"""
skeleton = Skeleton("Test")
