antecedent 0.3.0

Identification-first causal inference: identify → estimate → refute, with uncertainty about causal structure preserved
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

//! graph interchange conformance (DOT/JSON/GML/NetworkX).
//!
//! SPDX-License-Identifier: MIT OR Apache-2.0

use std::fs;
use std::path::PathBuf;

use antecedent::io::{
    dag_from_dot, dag_from_gml, dag_from_json, dag_from_networkx_node_link, dag_to_dot, dag_to_gml,
    dag_to_json, dag_to_networkx_node_link,
};
use antecedent_graph::DenseNodeId;
use serde_json::Value;

fn fixture_dir() -> PathBuf {
    PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../../conformance/interchange/graph_dot_json")
}

fn gml_fixture_dir() -> PathBuf {
    PathBuf::from(env!("CARGO_MANIFEST_DIR"))
        .join("../../conformance/interchange/graph_gml_networkx")
}

#[test]
fn conformance_dot_json_round_trip() {
    let raw = fs::read_to_string(fixture_dir().join("expected.json")).unwrap();
    let v: Value = serde_json::from_str(&raw).unwrap();
    let dot = v["dot"].as_str().unwrap();
    let expected_n = usize::try_from(v["expected_node_count"].as_u64().unwrap()).unwrap();
    let dag = dag_from_dot(dot).unwrap();
    assert_eq!(dag.node_count(), expected_n);
    assert!(dag.reaches(DenseNodeId::from_raw(0), DenseNodeId::from_raw(2)));

    let json = serde_json::to_string(&v["json"]).unwrap();
    let dag_j = dag_from_json(&json).unwrap();
    assert_eq!(dag_j.node_count(), expected_n);
    assert!(dag_j.reaches(DenseNodeId::from_raw(0), DenseNodeId::from_raw(2)));

    let names = vec!["a".into(), "b".into(), "c".into()];
    let out_dot = dag_to_dot(&dag, Some(&names)).unwrap();
    let again = dag_from_dot(&out_dot).unwrap();
    assert_eq!(again.node_count(), expected_n);

    let out_json = dag_to_json(&dag, Some(&names)).unwrap();
    let again_j = dag_from_json(&out_json).unwrap();
    assert_eq!(again_j.node_count(), expected_n);
}

#[test]
fn conformance_gml_networkx_round_trip() {
    let raw = fs::read_to_string(gml_fixture_dir().join("expected.json")).unwrap();
    let v: Value = serde_json::from_str(&raw).unwrap();
    let gml = v["gml"].as_str().unwrap();
    let expected_n = usize::try_from(v["expected_node_count"].as_u64().unwrap()).unwrap();
    let dag = dag_from_gml(gml).unwrap();
    assert_eq!(dag.node_count(), expected_n);

    let nx = serde_json::to_string(&v["networkx_node_link"]).unwrap();
    let dag_nx = dag_from_networkx_node_link(&nx).unwrap();
    assert_eq!(dag_nx.node_count(), expected_n);

    let names = vec!["Z".into(), "X".into(), "Y".into()];
    let out_gml = dag_to_gml(&dag, Some(&names)).unwrap();
    assert_eq!(dag_from_gml(&out_gml).unwrap().node_count(), expected_n);
    let out_nx = dag_to_networkx_node_link(&dag, Some(&names)).unwrap();
    assert_eq!(dag_from_networkx_node_link(&out_nx).unwrap().node_count(), expected_n);
}