Merge pull request #170 from CITCOM-project/JSON_frontend_issues

remove set_variables from json frontend Closes #115.

Author: christopher-wild

causal_testing/json_front/json_class.py

@@ -5,7 +5,6 @@
 import json
 import logging
 
-from abc import ABC
 from dataclasses import dataclass
 from pathlib import Path
 
@@ -26,7 +25,7 @@
 logger = logging.getLogger(__name__)
 
 
-class JsonUtility(ABC):
+class JsonUtility:
     """
     The JsonUtility Class provides the functionality to use structured JSON to setup and run causal tests on the
     CausalTestingFramework.
@@ -48,7 +47,7 @@ def __init__(self, log_path):
         self.variables = None
         self.data = []
         self.test_plan = None
-        self.modelling_scenario = None
+        self.scenario = None
         self.causal_specification = None
         self.setup_logger(log_path)
 
@@ -61,36 +60,27 @@ def set_paths(self, json_path: str, dag_path: str, data_paths: str):
         """
         self.paths = JsonClassPaths(json_path=json_path, dag_path=dag_path, data_paths=data_paths)
 
-    def set_variables(self, inputs: list[dict], outputs: list[dict], metas: list[dict]):
-        """Populate the Causal Variables
-        :param inputs:
-        :param outputs:
-        :param metas:
-        """
-
-        self.variables = CausalVariables(inputs=inputs, outputs=outputs, metas=metas)
-
-    def setup(self):
+    def setup(self, scenario: Scenario):
         """Function to populate all the necessary parts of the json_class needed to execute tests"""
-        self.modelling_scenario = Scenario(self.variables.inputs + self.variables.outputs + self.variables.metas, None)
-        self.modelling_scenario.setup_treatment_variables()
+        self.scenario = scenario
+        self.scenario.setup_treatment_variables()
         self.causal_specification = CausalSpecification(
-            scenario=self.modelling_scenario, causal_dag=CausalDAG(self.paths.dag_path)
+            scenario=self.scenario, causal_dag=CausalDAG(self.paths.dag_path)
         )
         self._json_parse()
         self._populate_metas()
 
     def _create_abstract_test_case(self, test, mutates, effects):
         assert len(test["mutations"]) == 1
         abstract_test = AbstractCausalTestCase(
-            scenario=self.modelling_scenario,
+            scenario=self.scenario,
             intervention_constraints=[mutates[v](k) for k, v in test["mutations"].items()],
-            treatment_variable=next(self.modelling_scenario.variables[v] for v in test["mutations"]),
+            treatment_variable=next(self.scenario.variables[v] for v in test["mutations"]),
             expected_causal_effect={
-                self.modelling_scenario.variables[variable]: effects[effect]
+                self.scenario.variables[variable]: effects[effect]
                 for variable, effect in test["expectedEffect"].items()
             },
-            effect_modifiers={self.modelling_scenario.variables[v] for v in test["effect_modifiers"]}
+            effect_modifiers={self.scenario.variables[v] for v in test["effect_modifiers"]}
             if "effect_modifiers" in test
             else {},
             estimate_type=test["estimate_type"],
@@ -141,10 +131,9 @@ def _populate_metas(self):
         """
         Populate data with meta-variable values and add distributions to Causal Testing Framework Variables
         """
-        for meta in self.variables.metas:
+        for meta in self.scenario.variables_of_type(Meta):
             meta.populate(self.data)
-
-        for var in self.variables.metas + self.variables.outputs:
+        for var in self.scenario.variables_of_type(Meta).union(self.scenario.variables_of_type(Output)):
             if not var.distribution:
                 fitter = Fitter(self.data[var.name], distributions=get_common_distributions())
                 fitter.fit()
@@ -195,7 +184,7 @@ def _setup_test(self, causal_test_case: CausalTestCase, estimator: Estimator) ->
                 - estimation_model - Estimator instance for the test being run
         """
 
-        data_collector = ObservationalDataCollector(self.modelling_scenario, self.data)
+        data_collector = ObservationalDataCollector(self.scenario, self.data)
         causal_test_engine = CausalTestEngine(self.causal_specification, data_collector, index_col=0)
 
         minimal_adjustment_set = self.causal_specification.causal_dag.identification(causal_test_case.base_test_case)
@@ -289,17 +278,17 @@ def __init__(self, json_path: str, dag_path: str, data_paths: str):
         self.data_paths = [Path(path) for path in data_paths]
 
 
-@dataclass()
+@dataclass
 class CausalVariables:
     """
-    A dataclass that converts
+    A dataclass that converts lists of dictionaries into lists of Causal Variables
     """
 
-    inputs: list[Input]
-    outputs: list[Output]
-    metas: list[Meta]
-
     def __init__(self, inputs: list[dict], outputs: list[dict], metas: list[dict]):
         self.inputs = [Input(**i) for i in inputs]
         self.outputs = [Output(**o) for o in outputs]
         self.metas = [Meta(**m) for m in metas] if metas else []
+
+    def __iter__(self):
+        for var in self.inputs + self.outputs + self.metas:
+            yield var

causal_testing/specification/metamorphic_relation.py

@@ -191,7 +191,6 @@ def generate_metamorphic_relations(dag: CausalDAG) -> list[MetamorphicRelation]:
 
         # 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):
-
             # Case 1: U --> ... --> V
             if u in nx.ancestors(dag.graph, v):
                 adj_set = list(dag.direct_effect_adjustment_sets([u], [v])[0])

examples/poisson/example_run_causal_tests.py

@@ -135,7 +135,7 @@ def populate_num_shapes_unit(data):
 modelling_inputs = (
     [Input(i["name"], i["datatype"], i["distribution"]) for i in inputs]
     + [Output(i["name"], i["datatype"]) for i in outputs]
-    + ([Meta(i["name"], i["datatype"], [i["populate"]]) for i in metas] if metas else list())
+    + ([Meta(i["name"], i["datatype"], i["populate"]) for i in metas] if metas else list())
 )
 
 # Create modelling scenario to access z3 variable mirrors
@@ -172,8 +172,7 @@ def test_run_causal_tests():
     )  # Set the path to the data.csv, dag.dot and causal_tests.json file
 
     # Load the Causal Variables into the JsonUtility class ready to be used in the tests
-    json_utility.set_variables(inputs, outputs, metas)
-    json_utility.setup()  # Sets up all the necessary parts of the json_class needed to execute tests
+    json_utility.setup(scenario=modelling_scenario)  # Sets up all the necessary parts of the json_class needed to execute tests
 
     json_utility.generate_tests(effects, mutates, estimators, False)
 
@@ -186,7 +185,6 @@ def test_run_causal_tests():
     )  # Set the path to the data.csv, dag.dot and causal_tests.json file
 
     # Load the Causal Variables into the JsonUtility class ready to be used in the tests
-    json_utility.set_variables(inputs, outputs, metas)
-    json_utility.setup()  # Sets up all the necessary parts of the json_class needed to execute tests
+    json_utility.setup(scenario=modelling_scenario)  # Sets up all the necessary parts of the json_class needed to execute tests
 
     json_utility.generate_tests(effects, mutates, estimators, args.f)

tests/json_front_tests/test_json_class.py

@@ -7,7 +7,7 @@
 from causal_testing.testing.estimators import LinearRegressionEstimator
 from causal_testing.testing.causal_test_outcome import NoEffect
 from tests.test_helpers import create_temp_dir_if_non_existent, remove_temp_dir_if_existent
-from causal_testing.json_front.json_class import JsonUtility
+from causal_testing.json_front.json_class import JsonUtility, CausalVariables
 from causal_testing.specification.variable import Input, Output, Meta
 from causal_testing.specification.scenario import Scenario
 from causal_testing.specification.causal_specification import CausalSpecification
@@ -24,7 +24,7 @@ class TestJsonClass(unittest.TestCase):
     def setUp(self) -> None:
         json_file_name = "tests.json"
         dag_file_name = "dag.dot"
-        data_file_name = "data.csv"
+        data_file_name = "data_with_meta.csv"
         test_data_dir_path = Path("tests/resources/data")
         self.json_path = str(test_data_dir_path / json_file_name)
         self.dag_path = str(test_data_dir_path / dag_file_name)
@@ -34,8 +34,11 @@ def setUp(self) -> None:
         self.input_dict_list = [{"name": "test_input", "datatype": float, "distribution": self.example_distribution}]
         self.output_dict_list = [{"name": "test_output", "datatype": float}]
         self.meta_dict_list = [{"name": "test_meta", "datatype": float, "populate": populate_example}]
-        self.json_class.set_variables(self.input_dict_list, self.output_dict_list, None)
+        variables = CausalVariables(inputs=self.input_dict_list, outputs=self.output_dict_list,
+                                    metas=self.meta_dict_list)
+        self.scenario = Scenario(variables=variables, constraints=None)
         self.json_class.set_paths(self.json_path, self.dag_path, self.data_path)
+        self.json_class.setup(self.scenario)
 
     def test_setting_paths(self):
         self.assertEqual(self.json_class.paths.json_path, Path(self.json_path))
@@ -44,33 +47,30 @@ def test_setting_paths(self):
 
     def test_set_inputs(self):
         ctf_input = [Input("test_input", float, self.example_distribution)]
-        self.assertEqual(ctf_input[0].name, self.json_class.variables.inputs[0].name)
-        self.assertEqual(ctf_input[0].datatype, self.json_class.variables.inputs[0].datatype)
-        self.assertEqual(ctf_input[0].distribution, self.json_class.variables.inputs[0].distribution)
+        self.assertEqual(ctf_input[0].name, self.json_class.scenario.variables['test_input'].name)
+        self.assertEqual(ctf_input[0].datatype, self.json_class.scenario.variables['test_input'].datatype)
+        self.assertEqual(ctf_input[0].distribution, self.json_class.scenario.variables['test_input'].distribution)
 
     def test_set_outputs(self):
         ctf_output = [Output("test_output", float)]
-        self.assertEqual(ctf_output[0].name, self.json_class.variables.outputs[0].name)
-        self.assertEqual(ctf_output[0].datatype, self.json_class.variables.outputs[0].datatype)
+        self.assertEqual(ctf_output[0].name, self.json_class.scenario.variables['test_output'].name)
+        self.assertEqual(ctf_output[0].datatype, self.json_class.scenario.variables['test_output'].datatype)
 
     def test_set_metas(self):
-        self.json_class.set_variables(self.input_dict_list, self.output_dict_list, self.meta_dict_list)
         ctf_meta = [Meta("test_meta", float, populate_example)]
-        self.assertEqual(ctf_meta[0].name, self.json_class.variables.metas[0].name)
-        self.assertEqual(ctf_meta[0].datatype, self.json_class.variables.metas[0].datatype)
+        self.assertEqual(ctf_meta[0].name, self.json_class.scenario.variables['test_meta'].name)
+        self.assertEqual(ctf_meta[0].datatype, self.json_class.scenario.variables['test_meta'].datatype)
 
     def test_argparse(self):
         args = self.json_class.get_args(["--data_path=data.csv", "--dag_path=dag.dot", "--json_path=tests.json"])
         self.assertEqual(args.data_path, ["data.csv"])
         self.assertEqual(args.dag_path, "dag.dot")
         self.assertEqual(args.json_path, "tests.json")
 
-    def test_setup_modelling_scenario(self):
-        self.json_class.setup()
-        self.assertIsInstance(self.json_class.modelling_scenario, Scenario)
+    def test_setup_scenario(self):
+        self.assertIsInstance(self.json_class.scenario, Scenario)
 
     def test_setup_causal_specification(self):
-        self.json_class.setup()
         self.assertIsInstance(self.json_class.causal_specification, CausalSpecification)
 
     def test_generate_tests_from_json(self):
@@ -87,12 +87,11 @@ def test_generate_tests_from_json(self):
                 }
             ]
         }
-        self.json_class.setup()
         self.json_class.test_plan = example_test
         effects = {"NoEffect": NoEffect()}
         mutates = {
-            "Increase": lambda x: self.json_class.modelling_scenario.treatment_variables[x].z3
-            > self.json_class.modelling_scenario.variables[x].z3
+            "Increase": lambda x: self.json_class.scenario.treatment_variables[x].z3
+                                  > self.json_class.scenario.variables[x].z3
         }
         estimators = {"LinearRegressionEstimator": LinearRegressionEstimator}
 

tests/resources/data/data_with_meta.csv

@@ -0,0 +1,2 @@
+index,test_input,test_output,test_meta
+0,1,2,3