tests pass

Author: jmafoster1

causal_testing/json_front/json_class.py

@@ -56,7 +56,7 @@ def __init__(self, output_path: str, output_overwrite: bool = False):
         self.output_path = Path(output_path)
         self.check_file_exists(self.output_path, output_overwrite)
 
-    def set_paths(self, json_path: str, dag_path: str, data_paths: str=[]):
+    def set_paths(self, json_path: str, dag_path: str, data_paths: str = []):
         """
         Takes a path of the directory containing all scenario specific files and creates individual paths for each file
         :param json_path: string path representation to .json file containing test specifications

causal_testing/testing/causal_test_outcome.py

@@ -3,6 +3,7 @@
 ExactValue, Positive, Negative, SomeEffect, NoEffect"""
 
 from abc import ABC, abstractmethod
+from collections.abc import Iterable
 import numpy as np
 
 from causal_testing.testing.causal_test_result import CausalTestResult
@@ -26,9 +27,12 @@ class SomeEffect(CausalTestOutcome):
     """An extension of TestOutcome representing that the expected causal effect should not be zero."""
 
     def apply(self, res: CausalTestResult) -> bool:
-        if res.test_value.type in {"ate", "coefficient"}:
-            return any([0 < ci_low < ci_high or ci_low < ci_high < 0 for ci_low, ci_high in zip(res.ci_low(), res.ci_high())])
-            # return (0 < res.ci_low() < res.ci_high()) or (res.ci_low() < res.ci_high() < 0)
+        if res.test_value.type == "ate":
+            return (0 < res.ci_low() < res.ci_high()) or (res.ci_low() < res.ci_high() < 0)
+        if res.test_value.type == "coefficient":
+            ci_low = res.ci_low() if isinstance(res.ci_low(), Iterable) else [res.ci_low()]
+            ci_high = res.ci_high() if isinstance(res.ci_high(), Iterable) else [res.ci_high()]
+            return any([0 < ci_low < ci_high or ci_low < ci_high < 0 for ci_low, ci_high in zip(ci_low, ci_high)])
         if res.test_value.type == "risk_ratio":
             return (1 < res.ci_low() < res.ci_high()) or (res.ci_low() < res.ci_high() < 1)
         raise ValueError(f"Test Value type {res.test_value.type} is not valid for this TestOutcome")
@@ -38,10 +42,15 @@ class NoEffect(CausalTestOutcome):
     """An extension of TestOutcome representing that the expected causal effect should be zero."""
 
     def apply(self, res: CausalTestResult, threshold: float = 1e-10) -> bool:
-        print("RESULT", res)
-        if res.test_value.type in {"ate", "coefficient"}:
-            return all([ci_low < 0< ci_high for ci_low, ci_high in zip(res.ci_low(), res.ci_high())]) or all([abs(v) < 1e-10 for v in res.test_value.value])
-            # return (res.ci_low() < 0 < res.ci_high()) or (abs(res.test_value.value) < 1e-10)
+        if res.test_value.type == "ate":
+            return (res.ci_low() < 0 < res.ci_high()) or (abs(res.test_value.value) < 1e-10)
+        if res.test_value.type == "coefficient":
+            ci_low = res.ci_low() if isinstance(res.ci_low(), Iterable) else [res.ci_low()]
+            ci_high = res.ci_high() if isinstance(res.ci_high(), Iterable) else [res.ci_high()]
+            value = res.test_value.value if isinstance(res.ci_high(), Iterable) else [res.test_value.value]
+            return all([ci_low < 0 < ci_high for ci_low, ci_high in zip(ci_low, ci_high)]) or all(
+                [abs(v) < 1e-10 for v in value]
+            )
         if res.test_value.type == "risk_ratio":
             return (res.ci_low() < 1 < res.ci_high()) or np.isclose(res.test_value.value, 1.0, atol=1e-10)
         raise ValueError(f"Test Value type {res.test_value.type} is not valid for this TestOutcome")

causal_testing/testing/causal_test_result.py

@@ -44,19 +44,26 @@ def __init__(
 
     def __str__(self):
         def push(s, inc="  "):
-            return inc + str(s).replace("\n", "\n"+inc)
+            return inc + str(s).replace("\n", "\n" + inc)
+
+        result_str = " " + str(self.test_value.value)
+        if "\n" in result_str:
+            result_str = "\n" + push(self.test_value.value)
         base_str = (
             f"Causal Test Result\n==============\n"
             f"Treatment: {self.estimator.treatment}\n"
             f"Control value: {self.estimator.control_value}\n"
             f"Treatment value: {self.estimator.treatment_value}\n"
             f"Outcome: {self.estimator.outcome}\n"
             f"Adjustment set: {self.adjustment_set}\n"
-            f"{self.test_value.type}:\n{push(self.test_value.value)}\n"
+            f"{self.test_value.type}:{result_str}\n"
         )
         confidence_str = ""
         if self.confidence_intervals:
-            confidence_str += f"Confidence intervals:\n{push(pd.DataFrame(self.confidence_intervals).transpose().to_string(header=False))}\n"
+            ci_str = " " + str(self.confidence_intervals)
+            if "\n" in ci_str:
+                ci_str = " " + push(pd.DataFrame(self.confidence_intervals).transpose().to_string(header=False))
+            confidence_str += f"Confidence intervals:{ci_str}\n"
         return base_str + confidence_str
 
     def to_dict(self):

causal_testing/testing/estimators.py

@@ -339,11 +339,22 @@ def estimate_unit_ate(self) -> float:
         print(model.conf_int())
         treatment = [self.treatment]
         if str(self.df.dtypes[self.treatment]) == "object":
-                reference = min(self.df[self.treatment])
-                treatment = [x.replace("[", "[T.") for x in dmatrix(f"{self.treatment}-1", self.df.query(f"{self.treatment} != '{reference}'"), return_type="dataframe").columns]
-        assert set(treatment).issubset(model.params.index.tolist()), f"{treatment} not in\n{'  '+str(model.params.index).replace(newline, newline+'  ')}"
+            reference = min(self.df[self.treatment])
+            treatment = [
+                x.replace("[", "[T.")
+                for x in dmatrix(
+                    f"{self.treatment}-1", self.df.query(f"{self.treatment} != '{reference}'"), return_type="dataframe"
+                ).columns
+            ]
+        assert set(treatment).issubset(
+            model.params.index.tolist()
+        ), f"{treatment} not in\n{'  '+str(model.params.index).replace(newline, newline+'  ')}"
         unit_effect = model.params[treatment]  # Unit effect is the coefficient of the treatment
         [ci_low, ci_high] = self._get_confidence_intervals(model, treatment)
+        if str(self.df.dtypes[self.treatment]) != "object":
+            unit_effect = unit_effect[0]
+            ci_low = ci_low[0]
+            ci_high = ci_high[0]
         return unit_effect, [ci_low, ci_high]
 
     def estimate_ate(self) -> tuple[float, list[float, float], float]:
@@ -365,7 +376,6 @@ def estimate_ate(self) -> tuple[float, list[float, float], float]:
 
         # Perform a t-test to compare the predicted outcome of the control and treated individual (ATE)
         t_test_results = model.t_test(individuals.loc["treated"] - individuals.loc["control"])
-        print("t_test_results", t_test_results.effect)
         ate = t_test_results.effect[0]
         confidence_intervals = list(t_test_results.conf_int().flatten())
         return ate, confidence_intervals

tests/testing_tests/test_estimators.py

@@ -216,6 +216,7 @@ def test_program_11_2(self):
         self.assertEqual(round(model.params["Intercept"] + 90 * model.params["treatments"], 1), 216.9)
 
         # Increasing treatments from 90 to 100 should be the same as 10 times the unit ATE
+        print("ATE", ate)
         self.assertEqual(round(model.params["treatments"], 1), round(ate, 1))
 
     def test_program_11_3(self):