Convert all log messages to file

Author: christopher-wild

causal_testing/json_front/json_class.py

@@ -105,12 +105,15 @@ def generate_tests(self, effects: dict, mutates: dict, estimators: dict, f_flag:
             abstract_test = self._create_abstract_test_case(test, mutates, effects)
 
             concrete_tests, dummy = abstract_test.generate_concrete_tests(5, 0.05)
-            logger.info("Executing test: %s", test["name"])
-            logger.info(abstract_test)
-            logger.info([abstract_test.treatment_variable.name, abstract_test.treatment_variable.distribution])
-            logger.info("Number of concrete tests for test case: %s", str(len(concrete_tests)))
             failures = self._execute_tests(concrete_tests, estimators, test, f_flag)
-            logger.info("%s/%s failed for %s\n", failures, len(concrete_tests), test["name"])
+            msg = f"Executing test: {test['name']} \n" + \
+                  f"abstract_test \n" + \
+                  f"{abstract_test} \n" + \
+                  f"{abstract_test.treatment_variable.name},{abstract_test.treatment_variable.distribution} \n" + \
+                  f"Number of concrete tests for test case: {str(len(concrete_tests))}"
+
+        self.append_to_file(msg, logging.INFO)
+
 
     def _execute_tests(self, concrete_tests, estimators, test, f_flag):
         failures = 0
@@ -120,6 +123,7 @@ def _execute_tests(self, concrete_tests, estimators, test, f_flag):
                 failures += 1
         return failures
 
+
     def _json_parse(self):
         """Parse a JSON input file into inputs, outputs, metas and a test plan"""
         with open(self.input_paths.json_path, encoding="utf-8") as f:
@@ -129,6 +133,7 @@ def _json_parse(self):
             self.data.append(df)
         self.data = pd.concat(self.data)
 
+
     def _populate_metas(self):
         """
         Populate data with meta-variable values and add distributions to Causal Testing Framework Variables
@@ -141,7 +146,8 @@ def _populate_metas(self):
                 fitter.fit()
                 (dist, params) = list(fitter.get_best(method="sumsquare_error").items())[0]
                 var.distribution = getattr(scipy.stats, dist)(**params)
-                logger.info(var.name + f" {dist}({params})")
+                self.append_to_file(var.name + f" {dist}({params})", logging.INFO)
+
 
     def _execute_test_case(self, causal_test_case: CausalTestCase, estimator: Estimator, f_flag: bool) -> bool:
         """Executes a singular test case, prints the results and returns the test case result
@@ -175,9 +181,11 @@ def _execute_test_case(self, causal_test_case: CausalTestCase, estimator: Estima
             )
         if not test_passes:
             failed = True
-            self.append_to_file(f"FAILED- expected {causal_test_case.expected_causal_effect}, got {result_string}", logging.WARNING)
+            self.append_to_file(f"FAILED- expected {causal_test_case.expected_causal_effect}, got {result_string}",
+                                logging.WARNING)
         return failed
 
+
     def _setup_test(self, causal_test_case: CausalTestCase, estimator: Estimator) -> tuple[CausalTestEngine, Estimator]:
         """Create the necessary inputs for a single test case
         :param causal_test_case: The concrete test case to be executed
@@ -206,23 +214,28 @@ def _setup_test(self, causal_test_case: CausalTestCase, estimator: Estimator) ->
 
         return causal_test_engine, estimation_model
 
+
     def add_modelling_assumptions(self, estimation_model: Estimator):  # pylint: disable=unused-argument
         """Optional abstract method where user functionality can be written to determine what assumptions are required
         for specific test cases
         :param estimation_model: estimator model instance for the current running test.
         """
         return
+
+
     def append_to_file(self, line: str, log_level: int = None):
         with open(self.output_path, "a") as f:
-            f.write('\n'.join(line))
+            f.write(line+"\n")
         if log_level:
             logger.log(level=log_level, msg=line)
 
+
     @staticmethod
     def check_file_exists(output_path: Path, overwrite: bool):
         if not overwrite and output_path.is_file():
             raise FileExistsError(f"Chosen file output ({output_path}) already exists")
 
+
     @staticmethod
     def get_args(test_args=None) -> argparse.Namespace:
         """Command-line arguments
@@ -298,4 +311,4 @@ def __init__(self, inputs: list[dict], outputs: list[dict], metas: list[dict]):
 
     def __iter__(self):
         for var in self.inputs + self.outputs + self.metas:
-            yield var
+            yield var