Fixed default behaviour of MR generation

Author: jmafoster1

causal_testing/specification/causal_dag.py

@@ -151,6 +151,14 @@ def __init__(self, dot_path: str = None, ignore_cycles: bool = False, **attr):
             else:
                 raise nx.HasACycle("Invalid Causal DAG: contains a cycle.")
 
+    @property
+    def nodes(self):
+        return self.graph.nodes
+
+    @property
+    def edges(self):
+        return self.graph.edges
+
     def check_iv_assumptions(self, treatment, outcome, instrument) -> bool:
         """
         Checks the three instrumental variable assumptions, raising a
@@ -170,7 +178,7 @@ def check_iv_assumptions(self, treatment, outcome, instrument) -> bool:
 
         # (iii) Instrument and outcome do not share causes
 
-        for cause in self.graph.nodes:
+        for cause in self.nodes:
             # Exclude self-cycles due to breaking changes in NetworkX > 3.2
             outcome_paths = (
                 list(nx.all_simple_paths(self.graph, source=cause, target=outcome)) if cause != outcome else []
@@ -222,8 +230,8 @@ def get_proper_backdoor_graph(self, treatments: list[str], outcomes: list[str])
         :return: A CausalDAG corresponding to the proper back-door graph.
         """
         for var in treatments + outcomes:
-            if var not in self.graph.nodes:
-                raise IndexError(f"{var} not a node in Causal DAG.\nValid nodes are{self.graph.nodes}.")
+            if var not in self.nodes:
+                raise IndexError(f"{var} not a node in Causal DAG.\nValid nodes are{self.nodes}.")
 
         proper_backdoor_graph = self.copy()
         nodes_on_proper_causal_path = proper_backdoor_graph.proper_causal_pathway(treatments, outcomes)
@@ -255,7 +263,7 @@ def get_ancestor_graph(self, treatments: list[str], outcomes: list[str]) -> Caus
             *[nx.ancestors(ancestor_graph.graph, outcome).union({outcome}) for outcome in outcomes]
         )
         variables_to_keep = treatment_ancestors.union(outcome_ancestors)
-        variables_to_remove = set(self.graph.nodes).difference(variables_to_keep)
+        variables_to_remove = set(self.nodes).difference(variables_to_keep)
         ancestor_graph.graph.remove_nodes_from(variables_to_remove)
         return ancestor_graph
 
@@ -273,7 +281,7 @@ def get_indirect_graph(self, treatments: list[str], outcomes: list[str]) -> Caus
         ee = []
         for s in treatments:
             for t in outcomes:
-                if (s, t) in gback.graph.edges:
+                if (s, t) in gback.edges:
                     ee.append((s, t))
         for v1, v2 in ee:
             gback.graph.remove_edge(v1, v2)
@@ -451,7 +459,7 @@ def constructive_backdoor_criterion(
                 ]
             )
 
-            if not set(covariates).issubset(set(self.graph.nodes).difference(descendents_of_proper_casual_paths)):
+            if not set(covariates).issubset(set(self.nodes).difference(descendents_of_proper_casual_paths)):
                 logger.info(
                     "Failed Condition 1: Z=%s **is** a descendent of some variable on a proper causal "
                     "path between X=%s and Y=%s.",
@@ -566,9 +574,9 @@ def to_dot_string(self) -> str:
         :return DOT string of the DAG.
         """
         dotstring = "digraph G {\n"
-        dotstring += "".join([f"{a} -> {b};\n" for a, b in self.graph.edges])
+        dotstring += "".join([f"{a} -> {b};\n" for a, b in self.edges])
         dotstring += "}"
         return dotstring
 
     def __str__(self):
-        return f"Nodes: {self.graph.nodes}\nEdges: {self.graph.edges}"
+        return f"Nodes: {self.nodes}\nEdges: {self.edges}"

causal_testing/surrogate/causal_surrogate_assisted.py

@@ -121,7 +121,7 @@ def generate_surrogates(
         """
         surrogate_models = []
 
-        for u, v in specification.causal_dag.graph.edges:
+        for u, v in specification.causal_dag.edges:
             edge_metadata = specification.causal_dag.graph.adj[u][v]
             if "included" in edge_metadata:
                 from_var = specification.scenario.variables.get(u)

causal_testing/testing/causal_test_adequacy.py

@@ -38,11 +38,11 @@ def measure_adequacy(self):
         """
         Calculate the adequacy measurement, and populate the `dag_adequacy` field.
         """
-        self.pairs_to_test = set(combinations(self.causal_dag.graph.nodes(), 2))
+        self.pairs_to_test = set(combinations(self.causal_dag.nodes, 2))
         self.tested_pairs = set()
 
         for n1, n2 in self.pairs_to_test:
-            if (n1, n2) in self.causal_dag.graph.edges():
+            if (n1, n2) in self.causal_dag.edges():
                 if any((t.treatment_variable, t.outcome_variable) == (n1, n2) for t in self.test_suite):
                     self.tested_pairs.add((n1, n2))
             else:

causal_testing/testing/metamorphic_relation.py

@@ -108,7 +108,7 @@ def generate_metamorphic_relation(
     metamorphic_relations = []
 
     # Create a ShouldNotCause relation for each pair of nodes that are not directly connected
-    if ((u, v) not in dag.graph.edges) and ((v, u) not in dag.graph.edges):
+    if ((u, v) not in dag.edges) and ((v, u) not in dag.edges):
         # Case 1: U --> ... --> V
         if u in nx.ancestors(dag.graph, v):
             adj_sets = dag.direct_effect_adjustment_sets([u], [v], nodes_to_ignore=nodes_to_ignore)
@@ -129,7 +129,7 @@ def generate_metamorphic_relation(
                 metamorphic_relations.append(ShouldNotCause(BaseTestCase(u, v), list(adj_sets[0])))
 
     # Create a ShouldCause relation for each edge (u, v) or (v, u)
-    elif (u, v) in dag.graph.edges:
+    elif (u, v) in dag.edges:
         adj_sets = dag.direct_effect_adjustment_sets([u], [v], nodes_to_ignore=nodes_to_ignore)
         if adj_sets:
             metamorphic_relations.append(ShouldCause(BaseTestCase(u, v), list(adj_sets[0])))
@@ -160,7 +160,7 @@ def generate_metamorphic_relations(
         nodes_to_ignore = {}
 
     if nodes_to_test is None:
-        nodes_to_test = dag.graph.nodes
+        nodes_to_test = dag.nodes
 
     if not threads:
         metamorphic_relations = [
@@ -205,9 +205,9 @@ def generate_metamorphic_relations(
 
     causal_dag = CausalDAG(args.dag_path, ignore_cycles=args.ignore_cycles)
 
-    dag_nodes_to_test = set(
-        k for k, v in nx.get_node_attributes(causal_dag.graph, "test", default=True).items() if v == "True"
-    )
+    dag_nodes_to_test = [
+        node for node in causal_dag.nodes if nx.get_node_attributes(causal_dag.graph, "test", default=True)[node]
+    ]
 
     if not causal_dag.is_acyclic() and args.ignore_cycles:
         logger.warning(

tests/specification_tests/test_causal_dag.py

@@ -86,7 +86,7 @@ def test_valid_causal_dag(self):
         """Test whether the Causal DAG is valid."""
         causal_dag = CausalDAG(self.dag_dot_path)
         print(causal_dag)
-        assert list(causal_dag.graph.nodes) == ["A", "B", "C", "D"] and list(causal_dag.graph.edges) == [
+        assert list(causal_dag.nodes) == ["A", "B", "C", "D"] and list(causal_dag.edges) == [
             ("A", "B"),
             ("B", "C"),
             ("D", "A"),
@@ -101,7 +101,7 @@ def test_invalid_causal_dag(self):
     def test_empty_casual_dag(self):
         """Test whether an empty dag can be created."""
         causal_dag = CausalDAG()
-        assert list(causal_dag.graph.nodes) == [] and list(causal_dag.graph.edges) == []
+        assert list(causal_dag.nodes) == [] and list(causal_dag.edges) == []
 
     def test_to_dot_string(self):
         causal_dag = CausalDAG(self.dag_dot_path)
@@ -174,10 +174,10 @@ def setUp(self) -> None:
     def test_get_indirect_graph(self):
         causal_dag = CausalDAG(self.dag_dot_path)
         indirect_graph = causal_dag.get_indirect_graph(["D1"], ["Y"])
-        original_edges = list(causal_dag.graph.edges)
+        original_edges = list(causal_dag.edges)
         original_edges.remove(("D1", "Y"))
-        self.assertEqual(list(indirect_graph.graph.edges), original_edges)
-        self.assertEqual(indirect_graph.graph.nodes, causal_dag.graph.nodes)
+        self.assertEqual(list(indirect_graph.edges), original_edges)
+        self.assertEqual(indirect_graph.nodes, causal_dag.nodes)
 
     def test_proper_backdoor_graph(self):
         """Test whether converting a Causal DAG to a proper back-door graph works correctly."""
@@ -195,7 +195,7 @@ def test_proper_backdoor_graph(self):
                 ("Z", "Y"),
             ]
         )
-        self.assertTrue(set(proper_backdoor_graph.graph.edges).issubset(edges))
+        self.assertTrue(set(proper_backdoor_graph.edges).issubset(edges))
 
     def test_constructive_backdoor_criterion_should_hold(self):
         """Test whether the constructive criterion holds when it should."""
@@ -246,9 +246,9 @@ def test_get_ancestor_graph_of_causal_dag(self):
         causal_dag = CausalDAG(self.dag_dot_path)
         xs, ys = ["X1", "X2"], ["Y"]
         ancestor_graph = causal_dag.get_ancestor_graph(xs, ys)
-        self.assertEqual(list(ancestor_graph.graph.nodes), ["X1", "X2", "D1", "Y", "Z"])
+        self.assertEqual(list(ancestor_graph.nodes), ["X1", "X2", "D1", "Y", "Z"])
         self.assertEqual(
-            list(ancestor_graph.graph.edges),
+            list(ancestor_graph.edges),
             [("X1", "X2"), ("X2", "D1"), ("D1", "Y"), ("Z", "X2"), ("Z", "Y")],
         )
 
@@ -258,9 +258,9 @@ def test_get_ancestor_graph_of_proper_backdoor_graph(self):
         xs, ys = ["X1", "X2"], ["Y"]
         proper_backdoor_graph = causal_dag.get_proper_backdoor_graph(xs, ys)
         ancestor_graph = proper_backdoor_graph.get_ancestor_graph(xs, ys)
-        self.assertEqual(list(ancestor_graph.graph.nodes), ["X1", "X2", "D1", "Y", "Z"])
+        self.assertEqual(list(ancestor_graph.nodes), ["X1", "X2", "D1", "Y", "Z"])
         self.assertEqual(
-            list(ancestor_graph.graph.edges),
+            list(ancestor_graph.edges),
             [("X1", "X2"), ("D1", "Y"), ("Z", "X2"), ("Z", "Y")],
         )