formatting

Author: SvenKlaassen

.github/workflows/apo_sim.yml

@@ -52,7 +52,7 @@ jobs:
       uses: astral-sh/setup-uv@v5
       with:
         version: "0.7.8"
-  
+
     - name: Set up Python
       uses: actions/setup-python@v5
       with:

.github/workflows/pliv_sim.yml

@@ -62,7 +62,7 @@ jobs:
         cd monte-cover
         uv venv
         uv sync
-  
+
     - name: Install DoubleML from correct branch
       run: |
         source monte-cover/.venv/bin/activate

doc/irm/irm.qmd

@@ -37,7 +37,7 @@ print(metadata_df.T.to_string(header=False))
 
 :::
 
-### ATE 
+### ATE
 
 ```{python}
 #| echo: false
@@ -264,7 +264,7 @@ print(metadata_df.T.to_string(header=False))
 
 :::
 
-### ATE 
+### ATE
 
 ```{python}
 #| echo: false
@@ -304,4 +304,4 @@ generate_and_show_styled_table(
     level_col="level",
     coverage_highlight_cols=["Coverage"]
 )
-```
+```

doc/plm/plr.qmd

@@ -254,4 +254,4 @@ generate_and_show_styled_table(
     rename_map={"Learner g": "Learner l"},
     coverage_highlight_cols=["Coverage"]
 )
-```
+```

monte-cover/src/montecover/base.py

@@ -107,7 +107,9 @@ def run_simulation(self, n_jobs=None):
 
                 rep_end_time = time.time()
                 rep_duration = rep_end_time - rep_start_time
-                self.logger.info(f"Repetition {i_rep+1} completed in {rep_duration:.2f}s")
+                self.logger.info(
+                    f"Repetition {i_rep+1} completed in {rep_duration:.2f}s"
+                )
 
         else:
             self.logger.info(f"Starting parallel execution with n_jobs={n_jobs}")
@@ -138,7 +140,9 @@ def save_results(self, output_path: str = "results", file_prefix: str = ""):
                 "Script": [self.__class__.__name__],
                 "Date": [datetime.now().strftime("%Y-%m-%d %H:%M")],
                 "Total Runtime (minutes)": [self.total_runtime / 60],
-                "Python Version": [f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"],
+                "Python Version": [
+                    f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"
+                ],
                 "Config File": [self.config_file],
             }
         )
@@ -161,7 +165,14 @@ def save_config(self, output_path: str):
             self.logger.warning(f"Adding .yaml extension to output path: {output_path}")
 
         with open(output_path, "w") as file:
-            yaml.dump(self.config, file, sort_keys=False, default_flow_style=False, indent=2, allow_unicode=True)
+            yaml.dump(
+                self.config,
+                file,
+                sort_keys=False,
+                default_flow_style=False,
+                indent=2,
+                allow_unicode=True,
+            )
 
         self.logger.info(f"Configuration saved to {output_path}")
 
@@ -174,7 +185,9 @@ def _load_config(self, config_path: str) -> Dict[str, Any]:
             with open(config_path, "r") as file:
                 config = yaml.safe_load(file)
         else:
-            raise ValueError(f"Unsupported config file format: {config_path}. Use .yaml or .yml")
+            raise ValueError(
+                f"Unsupported config file format: {config_path}. Use .yaml or .yml"
+            )
 
         return config
 
@@ -198,7 +211,9 @@ def _setup_logging(self, log_level: str, log_file: Optional[str]):
         # Console handler
         ch = logging.StreamHandler()
         ch.setLevel(level)
-        formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+        formatter = logging.Formatter(
+            "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+        )
         ch.setFormatter(formatter)
         self.logger.addHandler(ch)
 
@@ -256,7 +271,9 @@ def _process_repetition(self, i_rep):
                 dml_params = dict(zip(self.dml_parameters.keys(), dml_param_values))
                 i_param_comb += 1
 
-                comb_results = self._process_parameter_combination(i_rep, i_param_comb, dgp_params, dml_params, dml_data)
+                comb_results = self._process_parameter_combination(
+                    i_rep, i_param_comb, dgp_params, dml_params, dml_data
+                )
 
                 # Merge results
                 for result_name, result_list in comb_results.items():
@@ -266,11 +283,14 @@ def _process_repetition(self, i_rep):
 
         return rep_results
 
-    def _process_parameter_combination(self, i_rep, i_param_comb, dgp_params, dml_params, dml_data):
+    def _process_parameter_combination(
+        self, i_rep, i_param_comb, dgp_params, dml_params, dml_data
+    ):
         """Process a single parameter combination."""
         # Log parameter combination
         self.logger.debug(
-            f"Rep {i_rep+1}, Combo {i_param_comb}/{self.total_combinations}: " f"DGPs {dgp_params}, DML {dml_params}"
+            f"Rep {i_rep+1}, Combo {i_param_comb}/{self.total_combinations}: "
+            f"DGPs {dgp_params}, DML {dml_params}"
         )
         param_start_time = time.time()
 
@@ -279,7 +299,9 @@ def _process_parameter_combination(self, i_rep, i_param_comb, dgp_params, dml_pa
 
             # Log timing
             param_duration = time.time() - param_start_time
-            self.logger.debug(f"Parameter combination completed in {param_duration:.2f}s")
+            self.logger.debug(
+                f"Parameter combination completed in {param_duration:.2f}s"
+            )
 
             # Process results
             if repetition_results is None:
@@ -298,7 +320,8 @@ def _process_parameter_combination(self, i_rep, i_param_comb, dgp_params, dml_pa
 
         except Exception as e:
             self.logger.error(
-                f"Error: repetition {i_rep+1}, DGP parameters {dgp_params}, " f"DML parameters {dml_params}: {str(e)}"
+                f"Error: repetition {i_rep+1}, DGP parameters {dgp_params}, "
+                f"DML parameters {dml_params}: {str(e)}"
             )
             self.logger.exception("Exception details:")
             return {}
@@ -333,9 +356,13 @@ def _compute_coverage(thetas, oracle_thetas, confint, joint_confint=None):
         if joint_confint is not None:
             joint_lower_bound = joint_confint.iloc[:, 0]
             joint_upper_bound = joint_confint.iloc[:, 1]
-            joint_coverage_mask = (joint_lower_bound < oracle_thetas) & (oracle_thetas < joint_upper_bound)
+            joint_coverage_mask = (joint_lower_bound < oracle_thetas) & (
+                oracle_thetas < joint_upper_bound
+            )
 
             result_dict["Uniform Coverage"] = np.all(joint_coverage_mask)
-            result_dict["Uniform CI Length"] = np.mean(joint_upper_bound - joint_lower_bound)
+            result_dict["Uniform CI Length"] = np.mean(
+                joint_upper_bound - joint_lower_bound
+            )
 
         return result_dict

monte-cover/src/montecover/did/did_cs_multi.py

@@ -35,7 +35,9 @@ def __init__(
     def _process_config_parameters(self):
         """Process simulation-specific parameters from config"""
         # Process ML models in parameter grid
-        assert "learners" in self.dml_parameters, "No learners specified in the config file"
+        assert (
+            "learners" in self.dml_parameters
+        ), "No learners specified in the config file"
 
         required_learners = ["ml_g", "ml_m"]
         for learner in self.dml_parameters["learners"]:
@@ -54,19 +56,23 @@ def _calculate_oracle_values(self):
             lambda_t=self.dgp_parameters["lambda_t"][0],
         )  # does not depend on the DGP type or lambda_t
         df_oracle["ite"] = df_oracle["y1"] - df_oracle["y0"]
-        self.oracle_values["detailed"] = df_oracle.groupby(["d", "t"])["ite"].mean().reset_index()
+        self.oracle_values["detailed"] = (
+            df_oracle.groupby(["d", "t"])["ite"].mean().reset_index()
+        )
 
         # Oracle group aggregation
         df_oracle_post_treatment = df_oracle[df_oracle["t"] >= df_oracle["d"]]
-        self.oracle_values["group"] = df_oracle_post_treatment.groupby("d")["ite"].mean()
+        self.oracle_values["group"] = df_oracle_post_treatment.groupby("d")[
+            "ite"
+        ].mean()
 
         # Oracle time aggregation
         self.oracle_values["time"] = df_oracle_post_treatment.groupby("t")["ite"].mean()
 
         # Oracle eventstudy aggregation
-        df_oracle["e"] = pd.to_datetime(df_oracle["t"]).values.astype("datetime64[M]") - pd.to_datetime(
-            df_oracle["d"]
-        ).values.astype("datetime64[M]")
+        df_oracle["e"] = pd.to_datetime(df_oracle["t"]).values.astype(
+            "datetime64[M]"
+        ) - pd.to_datetime(df_oracle["d"]).values.astype("datetime64[M]")
         self.oracle_values["eventstudy"] = df_oracle.groupby("e")["ite"].mean()[1:]
 
     def run_single_rep(self, dml_data, dml_params) -> Dict[str, Any]:
@@ -96,7 +102,9 @@ def run_single_rep(self, dml_data, dml_params) -> Dict[str, Any]:
         for i, (g, _, t) in enumerate(dml_model.gt_combinations):
             group_index = self.oracle_values["detailed"]["d"] == g
             time_index = self.oracle_values["detailed"]["t"] == t
-            oracle_thetas[i] = self.oracle_values["detailed"][group_index & time_index]["ite"].iloc[0]
+            oracle_thetas[i] = self.oracle_values["detailed"][group_index & time_index][
+                "ite"
+            ].iloc[0]
 
         result = {
             "detailed": [],
@@ -121,7 +129,9 @@ def run_single_rep(self, dml_data, dml_params) -> Dict[str, Any]:
                     thetas=agg_obj.aggregated_frameworks.thetas,
                     oracle_thetas=self.oracle_values[aggregation_method].values,
                     confint=agg_obj.aggregated_frameworks.confint(level=level),
-                    joint_confint=agg_obj.aggregated_frameworks.confint(level=level, joint=True),
+                    joint_confint=agg_obj.aggregated_frameworks.confint(
+                        level=level, joint=True
+                    ),
                 )
 
             # add parameters to the result
@@ -163,14 +173,20 @@ def summarize_results(self):
 
         result_summary = dict()
         for result_name, result_df in self.results.items():
-            result_summary[result_name] = result_df.groupby(groupby_cols).agg(aggregation_dict).reset_index()
+            result_summary[result_name] = (
+                result_df.groupby(groupby_cols).agg(aggregation_dict).reset_index()
+            )
             self.logger.debug(f"Summarized {result_name} results")
 
         return result_summary
 
     def _generate_dml_data(self, dgp_params) -> dml.data.DoubleMLPanelData:
         """Generate data for the simulation."""
-        data = make_did_cs_CS2021(n_obs=dgp_params["n_obs"], dgp_type=dgp_params["DGP"], lambda_t=dgp_params["lambda_t"])
+        data = make_did_cs_CS2021(
+            n_obs=dgp_params["n_obs"],
+            dgp_type=dgp_params["DGP"],
+            lambda_t=dgp_params["lambda_t"],
+        )
         dml_data = dml.data.DoubleMLPanelData(
             data,
             y_col="y",

monte-cover/src/montecover/did/did_pa_multi.py

@@ -36,7 +36,9 @@ def _process_config_parameters(self):
         """Process simulation-specific parameters from config"""
         # Process ML models in parameter grid
         # Process ML models in parameter grid
-        assert "learners" in self.dml_parameters, "No learners specified in the config file"
+        assert (
+            "learners" in self.dml_parameters
+        ), "No learners specified in the config file"
 
         required_learners = ["ml_g", "ml_m"]
         for learner in self.dml_parameters["learners"]:

monte-cover/src/montecover/irm/__init__.py

@@ -6,8 +6,8 @@
 from montecover.irm.cvar import CVARCoverageSimulation
 from montecover.irm.iivm_late import IIVMLATECoverageSimulation
 from montecover.irm.irm_ate import IRMATECoverageSimulation
-from montecover.irm.irm_ate_tune import IRMATETuningCoverageSimulation
 from montecover.irm.irm_ate_sensitivity import IRMATESensitivityCoverageSimulation
+from montecover.irm.irm_ate_tune import IRMATETuningCoverageSimulation
 from montecover.irm.irm_atte import IRMATTECoverageSimulation
 from montecover.irm.irm_atte_sensitivity import IRMATTESensitivityCoverageSimulation
 from montecover.irm.irm_cate import IRMCATECoverageSimulation

monte-cover/src/montecover/irm/apo.py

@@ -32,7 +32,9 @@ def __init__(
     def _process_config_parameters(self):
         """Process simulation-specific parameters from config"""
         # Process ML models in parameter grid
-        assert "learners" in self.dml_parameters, "No learners specified in the config file"
+        assert (
+            "learners" in self.dml_parameters
+        ), "No learners specified in the config file"
 
         required_learners = ["ml_g", "ml_m"]
         for learner in self.dml_parameters["learners"]:
@@ -62,15 +64,19 @@ def _calculate_oracle_values(self):
         for i in range(n_levels):
             ates[i] = apos[i + 1] - apos[0]
 
-        self.logger.info(f"Levels and their counts:\n{np.unique(d, return_counts=True)}")
+        self.logger.info(
+            f"Levels and their counts:\n{np.unique(d, return_counts=True)}"
+        )
         self.logger.info(f"True APOs: {apos}")
         self.logger.info(f"True ATEs: {ates}")
 
         self.oracle_values = dict()
         self.oracle_values["apos"] = apos
         self.oracle_values["ates"] = ates
 
-    def run_single_rep(self, dml_data: dml.DoubleMLData, dml_params: Dict[str, Any]) -> Dict[str, Any]:
+    def run_single_rep(
+        self, dml_data: dml.DoubleMLData, dml_params: Dict[str, Any]
+    ) -> Dict[str, Any]:
         """Run a single repetition with the given parameters."""
         # Extract parameters
         learner_config = dml_params["learners"]
@@ -132,7 +138,9 @@ def summarize_results(self):
         # Aggregate results (possibly multiple result dfs)
         result_summary = dict()
         for result_name, result_df in self.results.items():
-            result_summary[result_name] = result_df.groupby(groupby_cols).agg(aggregation_dict).reset_index()
+            result_summary[result_name] = (
+                result_df.groupby(groupby_cols).agg(aggregation_dict).reset_index()
+            )
             self.logger.debug(f"Summarized {result_name} results")
 
         return result_summary

monte-cover/src/montecover/irm/apos.py

@@ -32,7 +32,9 @@ def __init__(
     def _process_config_parameters(self):
         """Process simulation-specific parameters from config"""
         # Process ML models in parameter grid
-        assert "learners" in self.dml_parameters, "No learners specified in the config file"
+        assert (
+            "learners" in self.dml_parameters
+        ), "No learners specified in the config file"
 
         required_learners = ["ml_g", "ml_m"]
         for learner in self.dml_parameters["learners"]:
@@ -62,15 +64,19 @@ def _calculate_oracle_values(self):
         for i in range(n_levels):
             ates[i] = apos[i + 1] - apos[0]
 
-        self.logger.info(f"Levels and their counts:\n{np.unique(d, return_counts=True)}")
+        self.logger.info(
+            f"Levels and their counts:\n{np.unique(d, return_counts=True)}"
+        )
         self.logger.info(f"True APOs: {apos}")
         self.logger.info(f"True ATEs: {ates}")
 
         self.oracle_values = dict()
         self.oracle_values["apos"] = apos
         self.oracle_values["ates"] = ates
 
-    def run_single_rep(self, dml_data: dml.DoubleMLData, dml_params: Dict[str, Any]) -> Dict[str, Any]:
+    def run_single_rep(
+        self, dml_data: dml.DoubleMLData, dml_params: Dict[str, Any]
+    ) -> Dict[str, Any]:
         """Run a single repetition with the given parameters."""
         # Extract parameters
         learner_config = dml_params["learners"]
@@ -144,7 +150,9 @@ def summarize_results(self):
         # Aggregate results (possibly multiple result dfs)
         result_summary = dict()
         for result_name, result_df in self.results.items():
-            result_summary[result_name] = result_df.groupby(groupby_cols).agg(aggregation_dict).reset_index()
+            result_summary[result_name] = (
+                result_df.groupby(groupby_cols).agg(aggregation_dict).reset_index()
+            )
             self.logger.debug(f"Summarized {result_name} results")
 
         return result_summary