diffindiff 2.4.1__tar.gz → 2.5.0__tar.gz

{diffindiff-2.4.1 → diffindiff-2.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: diffindiff
-Version: 2.4.1
+Version: 2.5.0
 Summary: diffindiff: Python library for convenient Difference-in-Differences analyses
 Author: Thomas Wieland
 Author-email: geowieland@googlemail.com
@@ -29,7 +29,7 @@ A research note featuring a case study that utilizes the diffindiff library is a
 
 If you use this software, please cite:
 
-Wieland, T. (2026). diffindiff: A Python library for convenient difference-in-differences analyses (Version 2.4.1) [Computer software]. Zenodo. https://doi.org/10.5281/zenodo.18656820
+Wieland, T. (2026). diffindiff: A Python library for convenient difference-in-differences analyses (Version 2.5.0) [Computer software]. Zenodo. https://doi.org/10.5281/zenodo.18656820
 
 
 ## Installation
@@ -177,7 +177,16 @@ See the /tests directory for usage examples of most of the included functions.
 This software was developed without the use of AI-generated code. The Continue Agent in Microsoft Visual Studio Code using the GPT-5 mini model (by OpenAI) was used solely to assist in drafting and refining docstrings for documentation. The corresponding guidelines and constraints defined by the author are documented in `AGENTS-docstrings.md` in the [public GitHub repository](https://github.com/geowieland/diffindiff_official).
 
 
-## What's new (v2.4.1)
+## What's new (v2.5.0)
 
-- Other:
-  - Extension of documentation
+- General
+  - Update of dependencies to be compatible with Python 3.13 (still works with Python 3.11) while avoiding incompatibility conflict of statsmodels and scipy
+  - Internal changes in some functions to be compatible with Python 3.13 (still works with Python 3.11)
+- Extensions
+  - Creating synthetic control units with DiffData.add_synthetic() and conducting a Synthetic DiD analysis
+  - didanalysis_helper.treatment_diagnostics() now additionally checks unique number of analysis units and time points
+  - didanalysis_helper.data_diagnostics() now additionally checks whether covariates are constant; didanalysis.did_analysis() and .ddd_analysis() automatically skip such variables from the model analysis
+- Bugfixes
+  - DiffData.add_own_counterfactual() now works correctly in any case (also when no. of treatments > 1)
+  - Correct internal processing of treatment data in DiffTreatment and DiffData objects when treatments were added
+  - Fixed missing treatment group definition in DiffData.add_treatment() 

{diffindiff-2.4.1 → diffindiff-2.5.0}/README.md

@@ -21,7 +21,7 @@ A research note featuring a case study that utilizes the diffindiff library is a
 
 If you use this software, please cite:
 
-Wieland, T. (2026). diffindiff: A Python library for convenient difference-in-differences analyses (Version 2.4.1) [Computer software]. Zenodo. https://doi.org/10.5281/zenodo.18656820
+Wieland, T. (2026). diffindiff: A Python library for convenient difference-in-differences analyses (Version 2.5.0) [Computer software]. Zenodo. https://doi.org/10.5281/zenodo.18656820
 
 
 ## Installation
@@ -169,7 +169,16 @@ See the /tests directory for usage examples of most of the included functions.
 This software was developed without the use of AI-generated code. The Continue Agent in Microsoft Visual Studio Code using the GPT-5 mini model (by OpenAI) was used solely to assist in drafting and refining docstrings for documentation. The corresponding guidelines and constraints defined by the author are documented in `AGENTS-docstrings.md` in the [public GitHub repository](https://github.com/geowieland/diffindiff_official).
 
 
-## What's new (v2.4.1)
+## What's new (v2.5.0)
 
-- Other:
-  - Extension of documentation
+- General
+  - Update of dependencies to be compatible with Python 3.13 (still works with Python 3.11) while avoiding incompatibility conflict of statsmodels and scipy
+  - Internal changes in some functions to be compatible with Python 3.13 (still works with Python 3.11)
+- Extensions
+  - Creating synthetic control units with DiffData.add_synthetic() and conducting a Synthetic DiD analysis
+  - didanalysis_helper.treatment_diagnostics() now additionally checks unique number of analysis units and time points
+  - didanalysis_helper.data_diagnostics() now additionally checks whether covariates are constant; didanalysis.did_analysis() and .ddd_analysis() automatically skip such variables from the model analysis
+- Bugfixes
+  - DiffData.add_own_counterfactual() now works correctly in any case (also when no. of treatments > 1)
+  - Correct internal processing of treatment data in DiffTreatment and DiffData objects when treatments were added
+  - Fixed missing treatment group definition in DiffData.add_treatment() 

{diffindiff-2.4.1 → diffindiff-2.5.0}/diffindiff/config.py

@@ -4,15 +4,15 @@
 # Author:      Thomas Wieland 
 #              ORCID: 0000-0001-5168-9846
 #              mail: geowieland@googlemail.com              
-# Version:     1.0.19
-# Last update: 2026-05-22 07:52
+# Version:     1.0.21
+# Last update: 2026-07-03 17:50
 # Copyright (c) 2025-2026 Thomas Wieland
 #-----------------------------------------------------------------------
 
 # Basic config:
 
 PACKAGE_NAME = "diffindiff"
-PACKAGE_VERSION = "2.4.1"
+PACKAGE_VERSION = "2.5.0"
 
 VERBOSE = False
 
@@ -21,6 +21,11 @@ ROUND_PERCENT = 2
 
 AUTO_SWITCH_TO_PREPOST = True
 
+AUTO_SWITCH_TO_FIXED_EFFECTS = True
+FIXED_EFFECTS_THRESHOLD = 3
+
+AUTO_SKIP_CONSTANT_COLUMNS = True
+
 ACCEPT_CONTINUOUS_TREATMENTS = True
 
 # Description texts:
@@ -96,6 +101,7 @@ LOG_PREFIX = "log"
 OBSERVED_SUFFIX = "observed"
 EXPECTED_SUFFIX = "expected"
 DEMEAN_SUFFIX = "demean"
+WEIGHTED_SUFFIX = "_weighted"
 PREDICTED_SUFFIX = "pred"
 CI_LOWER_SUFFIX = "CI_lower"
 CI_UPPER_SUFFIX = "CI_upper"
@@ -500,7 +506,11 @@ DATA_DIAGNOSTICS = {
         "description": N_DESCRIPTION,
         "show_in_summary": True
         },
-    }
+    "cols_constants": {
+        "description": "Columns with constant values",
+        "show_in_summary": False
+    },
+}
 
 DIAGNOSTICS_COLUMN = "Result"
 

{diffindiff-2.4.1 → diffindiff-2.5.0}/diffindiff/didanalysis.py

@@ -4,8 +4,8 @@
 # Author:      Thomas Wieland 
 #              ORCID: 0000-0001-5168-9846
 #              mail: geowieland@googlemail.com              
-# Version:     2.4.0
-# Last update: 2026-05-01 09:52
+# Version:     2.4.1
+# Last update: 2026-07-02 20:17
 # Copyright (c) 2024-2026 Thomas Wieland
 #-----------------------------------------------------------------------
 
@@ -735,16 +735,20 @@ class DiffModel:
         treatment_effects_df = self.treatment_effects()        
         
         width = treatment_effects_df[""].str.len().max()
-        treatment_effects_df[""] = treatment_effects_df[""].str.ljust(width)
-        total_width = (sum(treatment_effects_df.astype(str).map(len).max()) + len(treatment_effects_df.columns) * 2)
+        treatment_effects_df[""] = treatment_effects_df[""].str.ljust(width)        
         
-        print("=" * total_width)
+        total_width = (
+            treatment_effects_df.apply(lambda col: col.astype(str).str.len().max()).sum()
+            + len(treatment_effects_df.columns) * 2
+        )
+        
+        print("=" * int(total_width))
         print(model_config["analysis_description"]) 
-        print("-" * total_width)
+        print("-" * int(total_width))
 
         print(config.TREATMENT_EFFECTS_DESCRIPTION)
         print(treatment_effects_df.to_string(index=False))        
-        print("-" * total_width)
+        print("-" * int(total_width))
 
         covariates_effects_df = pd.DataFrame(
             [
@@ -761,7 +765,7 @@ class DiffModel:
         covariates_effects_df[config.COVARIATES_DESCRIPTION] = covariates_effects_df[config.COVARIATES_DESCRIPTION].str.ljust(width)
 
         print(covariates_effects_df.to_string(index=False, header=False))
-        print("-" * total_width)        
+        print("-" * int(total_width))        
 
         treatment_diagnostics = self.treatment_diagnostics()
         treatment_diagnostics_df = treatment_diagnostics[0]
@@ -782,7 +786,7 @@ class DiffModel:
             else:
                 print(f"NOTE: Treatments {', '.join(no_control_conditions)} have no control conditions.")  
 
-        print("-" * total_width)        
+        print("-" * int(total_width))        
 
         data_diagnostics_df = self.data_diagnostics()
 
@@ -792,7 +796,7 @@ class DiffModel:
         print(config.DATA_DIAGNOSTICS_DESCRIPTION)
         print(data_diagnostics_df.to_string(index=False, header=False))
 
-        print("-" * total_width)        
+        print("-" * int(total_width))        
 
         model_fit_metrics = self.fit_metrics()
 
@@ -804,7 +808,7 @@ class DiffModel:
         print(f"{config.MODEL_FIT_METRICS_DESCRIPTION}s")
         print(model_fit_metrics.to_string(index=False, header=False))
         
-        print("=" * total_width)
+        print("=" * int(total_width))
 
         return self
 
@@ -2389,16 +2393,37 @@ def did_analysis(
         verbose=verbose
     )
     treatment_diagnostics = treatment_diagnostics_results[0]
-    staggered_adoption = treatment_diagnostics_results[1]    
+    staggered_adoption = treatment_diagnostics_results[1]
+    unique_units = treatment_diagnostics_results[3]
+    unique_time_points = treatment_diagnostics_results[4]
     
     if no_treatments > 1:        
         
         intercept = False
         TG_col = []        
         
-        if not FE_unit:
+        if not FE_unit and config.AUTO_SWITCH_TO_FIXED_EFFECTS:
             FE_unit = True
-            print("NOTE: Quasi-experiment includes more than one treatment. Unit fixed effects are used instead of control group baseline and treatment group deviation.")
+            print(f"NOTE: Quasi-experiment includes more than one treatment ({no_treatments}). Unit fixed effects are used instead of control group baseline and treatment group deviation.")
+    
+    if unique_units < config.FIXED_EFFECTS_THRESHOLD:
+        
+        FE_unit = False
+        FE_group = False
+        ITE = False
+        ITT = False
+        intercept = True
+        
+        print(f"NOTE: Quasi-experiment includes less than {config.FIXED_EFFECTS_THRESHOLD} units. Unit or group fixed effects are skipped.")
+        
+    if unique_time_points < config.FIXED_EFFECTS_THRESHOLD:
+        
+        FE_time = False
+        ITT = False
+        GTT = False
+        intercept = True
+        
+        print(f"NOTE: Quasi-experiment includes less than {config.FIXED_EFFECTS_THRESHOLD} time points. Time fixed effects are skipped.")
     
     if demean and FE_unit:
         
@@ -2435,7 +2460,7 @@ def did_analysis(
             GTT = False
             print("NOTE: Both group and individual time trends were stated. Switching to individual time trends only.")
             
-    if staggered_adoption:
+    if staggered_adoption and config.AUTO_SWITCH_TO_FIXED_EFFECTS:
         
         if not FE_unit or not FE_time:
             print("NOTE: Quasi-experiment includes one or more staggered treatments. Two-way fixed effects model is used.")
@@ -2562,7 +2587,15 @@ def did_analysis(
         missing_replace_by_zero = missing_replace_by_zero,
         verbose = verbose
     )
+    
+    if len(data_diagnostics["cols_constants"]) > 0:
+        
+        if config.AUTO_SKIP_CONSTANT_COLUMNS:
         
+            print(f"NOTE: The following columns are constant and dropped from the analysis: {', '.join(data_diagnostics['cols_constants'])}.")
+            
+            covariates = [col for col in covariates if col not in data_diagnostics["cols_constants"]]
+
     if data_diagnostics["is_prepost"] and config.AUTO_SWITCH_TO_PREPOST:
         
         print(f"NOTE: Input is {config.PREPOST_PANELDATA_DESCRIPTION}. Data processing and model estimation will treat data as pre-post.")
@@ -3115,7 +3148,21 @@ def ddd_analysis(
         verbose=verbose
     )
     treatment_diagnostics = treatment_diagnostics_results[0]
-               
+    unique_units = treatment_diagnostics_results[3]
+    unique_time_points = treatment_diagnostics_results[4]
+
+    if unique_units < config.FIXED_EFFECTS_THRESHOLD:
+        
+        FE_unit = False
+          
+        print(f"NOTE: Quasi-experiment includes less than {config.FIXED_EFFECTS_THRESHOLD} units. Unit fixed effects are skipped.")
+        
+    if unique_time_points < config.FIXED_EFFECTS_THRESHOLD:
+        
+        FE_time = False
+        
+        print(f"NOTE: Quasi-experiment includes less than {config.FIXED_EFFECTS_THRESHOLD} time points. Time fixed effects are skipped.")
+                
     if FE_unit:
         TG_col = None
     if FE_time:
@@ -3140,7 +3187,15 @@ def ddd_analysis(
         missing_replace_by_zero = missing_replace_by_zero,
         verbose = verbose
     )
-      
+    
+    if len(data_diagnostics["cols_constants"]) > 0:
+        
+        if config.AUTO_SKIP_CONSTANT_COLUMNS:
+            
+            print(f"NOTE: The following columns are constant and dropped from the analysis: {', '.join(data_diagnostics['cols_constants'])}.")
+            
+            covariates = [col for col in covariates if col not in data_diagnostics["cols_constants"]]
+    
     if data_diagnostics["is_prepost"] and config.AUTO_SWITCH_TO_PREPOST:
         
         print("NOTE: Panel data is pre-post. Data processing and model estimation will treat data as pre-post")

{diffindiff-2.4.1 → diffindiff-2.5.0}/diffindiff/didanalysis_helper.py

@@ -4,8 +4,8 @@
 # Author:      Thomas Wieland 
 #              ORCID: 0000-0001-5168-9846
 #              mail: geowieland@googlemail.com              
-# Version:     1.2.0
-# Last update: 2025-05-01 09:28
+# Version:     1.2.2
+# Last update: 2026-07-02 20:18
 # Copyright (c) 2025-2026 Thomas Wieland
 #-----------------------------------------------------------------------
 
@@ -876,6 +876,12 @@ def data_diagnostics(
     outcome_mean = np.mean(data[outcome_col])
     outcome_sd = np.std(data[outcome_col])
     
+    cols_constants = []
+    if len(other_cols_relevant) > 0:
+        for col in other_cols_relevant:
+           if data[col].nunique() == 1:
+                cols_constants.append(col)
+    
     data_diagnostics_results = {
         list(config.DATA_DIAGNOSTICS)[0]: bool(modeldata_isbalanced),
         list(config.DATA_DIAGNOSTICS)[1]: bool(modeldata_ismissing[0]),
@@ -885,7 +891,8 @@ def data_diagnostics(
         list(config.DATA_DIAGNOSTICS)[5]: data_type,
         list(config.DATA_DIAGNOSTICS)[6]: outcome_col, 
         list(config.DATA_DIAGNOSTICS)[7]: f"Mean={round(outcome_mean, config.ROUND_STATISTIC)} SD={round(outcome_sd, config.ROUND_STATISTIC)}",
-        list(config.DATA_DIAGNOSTICS)[8]: observations,        
+        list(config.DATA_DIAGNOSTICS)[8]: observations,
+        list(config.DATA_DIAGNOSTICS)[9]: cols_constants
         }
     
     return data_diagnostics_results
@@ -927,7 +934,7 @@ def treatment_diagnostics(
     Returns
     -------
     list
-        [treatment_diagnostics_results (dict), staggered_adoption (bool), untreated (list)]
+        [treatment_diagnostics_results (dict), staggered_adoption (bool), untreated (list), unique_units (int), unique_timepoints (int)]
 
     Examples
     --------
@@ -1020,6 +1027,15 @@ def treatment_diagnostics(
         verbose = verbose
         )
     
+    groups_units_list = []
+    for key, value in treatment_diagnostics_results.items():
+        groups_units_list.extend(value["treatment_group"])
+        groups_units_list.extend(value["control_group"])
+    groups_units_list = list(set(groups_units_list))
+    unique_units = len(groups_units_list)
+    
+    unique_timepoints = data[time_col].nunique()
+    
     if verbose:
         
         if no_treatments > 1:
@@ -1030,7 +1046,9 @@ def treatment_diagnostics(
     return [
         treatment_diagnostics_results,
         staggered_adoption,
-        untreated
+        untreated,
+        unique_units,
+        unique_timepoints
     ]
 
 def ols_fit(
@@ -1547,16 +1565,19 @@ def extract_model_results(
         covariates_effects = {}
         
         for i, covariate in enumerate(covariates):
-            covariates_effects[i] = {
-                config.OLS_MODEL_RESULTS["coef_name"]["model_results_key"]: covariate,
-                config.OLS_MODEL_RESULTS["coef"]["model_results_key"]: coefficients[covariate],
-                "SE": float(coef_standarderrors[covariate]),
-                "t": float(coef_t[covariate]),
-                "p": float(coef_p[covariate]),
-                "CI_lower": float(coef_conf_intervals.loc[covariate, 0]),
-                "CI_upper": float(coef_conf_intervals.loc[covariate, 1]),
-                }
-            
+
+            if covariate in coefficients:
+
+                covariates_effects[i] = {
+                    config.OLS_MODEL_RESULTS["coef_name"]["model_results_key"]: covariate,
+                    config.OLS_MODEL_RESULTS["coef"]["model_results_key"]: coefficients[covariate],
+                    "SE": float(coef_standarderrors[covariate]),
+                    "t": float(coef_t[covariate]),
+                    "p": float(coef_p[covariate]),
+                    "CI_lower": float(coef_conf_intervals.loc[covariate, 0]),
+                    "CI_upper": float(coef_conf_intervals.loc[covariate, 1]),
+                    }
+                
         model_results["covariates_effects"] = covariates_effects    
 
     if (len(TG_x_BG_x_TT_col) > 0) and (any(col in coefficients for col in TG_x_BG_x_TT_col)):

{diffindiff-2.4.1 → diffindiff-2.5.0}/diffindiff/diddata.py

@@ -4,14 +4,15 @@
 # Author:      Thomas Wieland 
 #              ORCID: 0000-0001-5168-9846
 #              mail: geowieland@googlemail.com              
-# Version:     2.2.6
-# Last update: 2026-04-30 21:19
+# Version:     2.3.0
+# Last update: 2026-07-03 18:00
 # Copyright (c) 2024-2026 Thomas Wieland
 #-----------------------------------------------------------------------
 
 
 import pandas as pd
 import numpy as np
+from scipy.optimize import minimize
 from datetime import datetime, timedelta
 import diffindiff.didanalysis as didanalysis
 import diffindiff.didtools as tools
@@ -362,8 +363,8 @@ class DiffTreatment:
 
         Parameters
         ----------
-        treatment_data_df : pandas.DataFrame
-            Data frame describing treatment timing (TT/ATT).
+        treatment_data_df : list
+            List with data frames describing treatment timing (TT/ATT).
         treatment_config_dict : dict
             Configuration dictionary for the treatment.
         treatment_meta : dict
@@ -375,7 +376,6 @@ class DiffTreatment:
         -------
         None
             Constructor does not return a value; instance is initialized in-place.
-
         """
 
         self.data = [
@@ -542,7 +542,6 @@ def create_treatment(
     ): 
        
     """
-
     Create a DiffTreatment object describing treatment timepoints.
 
     Parameters
@@ -647,7 +646,10 @@ def create_treatment(
             study_period_range
             )
 
-        treatment_data = treatment_period_range.merge(TT_data, how = "left")
+        treatment_data_df = treatment_period_range.merge(
+            TT_data, 
+            how = "left"
+            )
 
     else:
 
@@ -680,12 +682,12 @@ def create_treatment(
             }
         TT_data = pd.DataFrame(TT_data)
     
-        treatment_data = study_period_range.merge(
+        treatment_data_df = study_period_range.merge(
             TT_data, 
             how = "left"
             )
 
-    treatment_data[TT_col] = treatment_data[TT_col].fillna(0)
+    treatment_data_df[TT_col] = treatment_data_df[TT_col].fillna(0)
 
     if after_treatment_period:
         
@@ -710,17 +712,20 @@ def create_treatment(
             }
         ATT_data = pd.DataFrame(ATT_data)
 
-        after_treatment_data = study_period_range.merge(ATT_data, how = "left")
-        after_treatment_data[ATT_col] = after_treatment_data[ATT_col].fillna(0)
-        after_treatment_data = after_treatment_data.drop(columns=[config.TIME_COL, config.TIME_COUNTER_COL])
+        after_treatment_data_df = study_period_range.merge(ATT_data, how = "left")
+        after_treatment_data_df[ATT_col] = after_treatment_data_df[ATT_col].fillna(0)
+        after_treatment_data_df = after_treatment_data_df.drop(columns=[config.TIME_COL, config.TIME_COUNTER_COL])
 
-        treatment_data = pd.concat([treatment_data, after_treatment_data], axis=1)
+        treatment_data_df = pd.concat([treatment_data_df, after_treatment_data_df], axis=1)
 
     else:
         after_treatment_period_N = 0
     
     no_treatments = 1
 
+    treatment_data = [0] * no_treatments
+    treatment_data[0] = treatment_data_df
+
     treatment_meta = {
         "no_treatments": 1,
         "study_period_start": study_period[0],
@@ -732,19 +737,18 @@ def create_treatment(
         }
 
     treatment_config = {
-        0:
-            {
-                "treatment_name": treatment_name,
-                "treatment_period_start": treatment_period[0],
-                "treatment_period_end": treatment_period[1],
-                "treatment_period": treatment_period_N,
-                "after_treatment_period": after_treatment_period,
-                "after_treatment_period_N": after_treatment_period_N,
-                "no_treatments": no_treatments,
-                "TT_col": TT_col,
-                "ATT_col": ATT_col,
-                }
+        0: {
+            "treatment_name": treatment_name,
+            "treatment_period_start": treatment_period[0],
+            "treatment_period_end": treatment_period[1],
+            "treatment_period": treatment_period_N,
+            "after_treatment_period": after_treatment_period,
+            "after_treatment_period_N": after_treatment_period_N,
+            "no_treatments": no_treatments,
+            "TT_col": TT_col,
+            "ATT_col": ATT_col,
             }
+        }
 
     treatment = DiffTreatment(
         treatment_data, 
@@ -1249,6 +1253,7 @@ class DiffData:
         did_treatment_old = self.get_did_treatment()
         treatment_config_old = did_treatment_old.get_config()
         treatment_meta_old = did_treatment_old.get_metadata()
+        treatment_data_old = did_treatment_old.get_data()
         if treatment_meta_old["pre_post"]:
             raise ValueError ("Adding treatments in a pre-post design is currently not possible.")
         no_treatments_old = treatment_meta_old["no_treatments"]
@@ -1288,7 +1293,8 @@ class DiffData:
             after_treatment_period = after_treatment_period,
             verbose=False
             )
-        new_treatment_data_df = new_treatment.get_data()
+        new_treatment_data = new_treatment.get_data()
+        new_treatment_data_df = new_treatment_data[0]
         
         new_treatment_config = new_treatment.get_config()        
         TT_col = new_treatment_config[0]["TT_col"]
@@ -1336,7 +1342,8 @@ class DiffData:
         
         treatment_cols_new[key_counter] = {
             "TT_col": TT_col, 
-            "ATT_col": ATT_col, 
+            "ATT_col": ATT_col,
+            "TG_col": TG_col,
             "treatment_name": treatment_name, 
             "after_treatment_name": after_treatment_name                
             }
@@ -1355,9 +1362,12 @@ class DiffData:
         treatment_meta_new["no_treatments"] = no_treatments
         treatment_config_new = treatment_config_old
         treatment_config_new[key_counter] = new_treatment_config[0]
+
+        treatment_data_new = treatment_data_old.copy()
+        treatment_data_new.append(new_treatment_data_df)
         
         treatment_new = DiffTreatment(
-            new_treatment_data_df, 
+            treatment_data_new, 
             treatment_config_new,
             treatment_meta_new,
             timestamp = helper.create_timestamp(function="add_treatment")
@@ -1647,81 +1657,342 @@ class DiffData:
         if time_col is None or counterfactual_outcome_col is None:
             raise ValueError("Parameters 'time_col' and 'counterfactual_outcome_col' must be stated")
         
+        necessary_cols = [time_col, counterfactual_outcome_col]
+        covariates = self.data[5].copy()
+        if len(covariates) > 0:
+            necessary_cols.extend(covariates)
+
         tools.check_columns(
             df = additional_df,
-            columns = [counterfactual_outcome_col, time_col]
+            columns = necessary_cols,
+            verbose = verbose
             )
+        
+        additional_df = additional_df[necessary_cols].copy()
 
-        did_modeldata = self.data[0]
-        groups_data = self.data[1].get_data()
-        groups_config = self.data[1].get_config()
-        treatment_group = groups_data.loc[groups_data[config.TG_COL] == 1, config.UNIT_COL].values
-        treatment_config = self.data[2].get_config()        
-        outcome_col_original = self.data[3]        
-        treatment_data = self.data[2].get_data()
+        did_modeldata = self.data[0].copy()
 
-        additional_df = additional_df[[time_col, counterfactual_outcome_col]].copy()
+        treatment_cols = self.get_treatment_cols().copy()
+        TG_col = treatment_cols[0]["TG_col"]
+        TT_col = treatment_cols[0]["TT_col"]
+        treatment_name = treatment_cols[0]["treatment_name"]
+
+        if len(treatment_cols) > 1:
+            print(f"NOTE: Treatment data contains {len(treatment_cols)} treatments. Taking first treatment '{treatment_name}' for identifying treatment group and time.")
         
-        did_modeldata_TG = did_modeldata[did_modeldata[config.UNIT_COL].astype(str).isin(treatment_group)].copy()        
+        if verbose:
+            print("Collecting treatment information", end = " ... ")
+
+        groups_data = self.data[1].get_data().copy()        
+        groups_config = self.data[1].get_config().copy()
+
+        treatment_data = self.data[2].get_data().copy()
+        treatment_data_df = treatment_data[0]
+        treatment_config = self.data[2].get_config().copy()
+        
+        treatment_group = (did_modeldata.loc[did_modeldata[TG_col] == 1, config.UNIT_COL].astype(str).unique()).tolist()
+        did_modeldata_TG = did_modeldata[did_modeldata[config.UNIT_COL].astype(str).isin(treatment_group)].copy()
+
+        outcome_col_original = self.data[3]
         
-        did_modeldata_counterfac = pd.DataFrame(columns=did_modeldata_TG.columns, index=range(len(treatment_data)))
+        if verbose:
+            print("OK")
+            print("Compiling and merging counterfactual data", end = " ... ")
+        
+        did_modeldata_counterfac = pd.DataFrame(columns=did_modeldata_TG.columns, index=range(len(treatment_data_df)))
+
         did_modeldata_counterfac[config.UNIT_COL] = counterfactual_UID
-        did_modeldata_counterfac[config.TG_COL] = 0
-        did_modeldata_counterfac[config.TIME_COL] = treatment_data[config.TIME_COL].values
-        did_modeldata_counterfac[config.TIME_COUNTER_COL] = treatment_data[config.TIME_COUNTER_COL].values
-        did_modeldata_counterfac[config.TT_COL] = treatment_data[config.TT_COL].values
-        did_modeldata_counterfac[config.TREATMENT_COL] = did_modeldata_counterfac[config.TG_COL] * did_modeldata_counterfac[config.TT_COL]
-
-        did_modeldata_counterfac = tools.panel_index(
-            data=did_modeldata_counterfac,
-            unit_col=config.UNIT_COL,
-            time_col=config.TIME_COL,
-            verbose=verbose
-            )
+        did_modeldata_counterfac[config.UNIT_COL] = did_modeldata_counterfac[config.UNIT_COL].astype(str)
+        
+        did_modeldata_counterfac[TG_col] = 0
+        
+        did_modeldata_counterfac[config.TIME_COL] = treatment_data_df[config.TIME_COL].values
+        did_modeldata_counterfac[config.TIME_COL] = did_modeldata_counterfac[config.TIME_COL].astype(str)
         
-        if treatment_config["after_treatment_period"]:
-            did_modeldata_counterfac["ATT"] = treatment_data["ATT"].values
+        did_modeldata_counterfac[config.TIME_COUNTER_COL] = treatment_data_df[config.TIME_COUNTER_COL].values
+        
+        for treatment_col_key, treatment_col_data in treatment_cols.items():
+            did_modeldata_counterfac[treatment_cols[treatment_col_key]["treatment_name"]] = 0
+            if treatment_col_data["TG_col"] in did_modeldata_counterfac.columns:
+                did_modeldata_counterfac[treatment_col_data["TG_col"]] = 0
+            if treatment_col_data["TT_col"] in did_modeldata_counterfac.columns:
+                did_modeldata_counterfac[treatment_col_data["TT_col"]] = treatment_data_df[TT_col].values
+                    
+        did_modeldata_counterfac[config.UNIT_TIME_COL] = did_modeldata_counterfac[config.UNIT_COL]+config.DELIMITER+did_modeldata_counterfac[config.TIME_COL]
+
+        if treatment_config[0]["after_treatment_period"]:
+            did_modeldata_counterfac["ATT"] = treatment_data_df["ATT"].values
 
         if counterfactual_outcome_col == outcome_col_original:
             additional_df = additional_df.rename(columns={counterfactual_outcome_col: counterfactual_outcome_col+"_cf"})
             counterfactual_outcome_col = counterfactual_outcome_col+"_cf"
         
-        did_modeldata_counterfac = pd.merge(
-            did_modeldata_counterfac,
-            additional_df,
-            left_on = config.TIME_COL,
-            right_on = time_col,
-            how = "left"
-            )
-
-        did_modeldata_counterfac[outcome_col_original] = did_modeldata_counterfac[counterfactual_outcome_col]        
-        did_modeldata_counterfac = did_modeldata_counterfac.drop(counterfactual_outcome_col, axis = 1) 
+        did_modeldata_counterfac[outcome_col_original] = additional_df[counterfactual_outcome_col]        
+        for covariate in covariates:
+            did_modeldata_counterfac[covariate] = additional_df[covariate]
+       
+        if time_col in did_modeldata_counterfac.columns and time_col != config.TIME_COL:
+            did_modeldata_counterfac = did_modeldata_counterfac.drop(time_col, axis = 1)
 
         did_modeldata_TG_with_counterfac = pd.concat(
-            [did_modeldata_TG, did_modeldata_counterfac], 
+            [
+                did_modeldata_TG, 
+                did_modeldata_counterfac
+                ], 
             ignore_index=True
             )       
+    
+        groups_config_new = groups_config.copy()
+        for groups_key in groups_config.keys():
      
-        groups_config["counterfactual"] = True
-        
-        groups_data = groups_data[groups_data[config.TG_COL] == 1]
-        groups_data_cf = {
-            config.UNIT_COL: counterfactual_UID, 
-            config.TG_COL: 0
-            }
-        groups_data = pd.concat([groups_data, pd.DataFrame([groups_data_cf])], ignore_index=True)
+            groups_config_new[groups_key]["own_counterfactual"] = True
+            groups_config_new[groups_key]["treatment_group"] = len(treatment_group)
+            groups_config_new[groups_key]["control_group"] = 1
+            groups_config_new[groups_key]["full_sample"] = len(treatment_group)+1
+
+        groups_data_new = groups_data.copy()
         
+        for groups_key, entry in enumerate(groups_data_new):
+
+            groups_data_new[groups_key] = groups_data[groups_key][groups_data[groups_key].iloc[:, 1] == 1].copy()
+            groups_data_new[groups_key].loc[len(groups_data_new[groups_key])] = [counterfactual_UID, 0]
+
         groups = DiffGroups(
-            groups_data, 
-            groups_config,
+            groups_data = groups_data_new, 
+            groups_config_dict = groups_config_new,
             timestamp = helper.create_timestamp(function="add_own_counterfactual")
             )
         
         self.data[0] = did_modeldata_TG_with_counterfac
         self.data[1] = groups
+
+        if verbose:
+            print("OK")
         
+        print("NOTE: DiffData object was changed with counterfactual.")
+
         return self
 
+    def add_synthetic(
+        self,
+        process_unit: str = None,
+        SCU_UID: str = "synthetic_control",
+        log_outcome: bool = False,
+        log_outcome_add = 0.01,
+        verbose: bool = False
+        ):
+
+        """
+        Create a synthetic control unit (SCU) and add it as a counterfactual.
+
+        Parameters
+        ----------
+        process_unit : str, optional
+            Identifier of the treatment unit for which the synthetic control unit must be created.
+        SCU_UID : str, optional
+            Identifier assigned to the synthetic control unit in the counterfactual data.
+        log_outcome : bool, optional
+            If True, transform the outcome by natural logarithm before fitting the synthetic control weights.
+        log_outcome_add : float, optional
+            Constant added before applying the natural logarithm when log_outcome is True.
+        verbose : bool, optional
+            If True, print progress messages.
+
+        Returns
+        -------
+        DiffData
+            The updated DiffData object including the synthetic control unit as counterfactual.
+
+        Raises
+        ------
+        ValueError
+            If the treatment group contains multiple analysis units and no process unit is specified, if the specified process unit is not part of the model data, or if the control group contains fewer than two units.
+
+        Examples
+        --------
+        >>> curfew_data_prepost = create_data(
+        ...     outcome_data=curfew_DE,
+        ...     unit_id_col="county",
+        ...     time_col="infection_date",
+        ...     outcome_col="infections_cum_per100000",
+        ...     treatment_group=curfew_DE.loc[curfew_DE["Bundesland"].isin([9,10,14])]["county"],
+        ...     control_group=curfew_DE.loc[~curfew_DE["Bundesland"].isin([9,10,14])]["county"],
+        ...     study_period=["2020-03-01", "2020-05-15"],
+        ...     treatment_period=["2020-03-21", "2020-05-05"],
+        ...     freq="D",
+        ...     pre_post=True,
+        ...     after_treatment_period=True
+        ...     )
+        >>> curfew_data_prepost.add_synthetic(process_unit="Aachen")
+        """
+
+        did_modeldata = self.data[0].copy()
+
+        covariates = self.data[5].copy()
+        if len(covariates) > 0:
+            tools.check_columns(
+                df = did_modeldata,
+                columns = covariates,
+                verbose = verbose
+                )
+            
+        treatment_cols = self.get_treatment_cols().copy()
+        treatment_name = treatment_cols[0]["treatment_name"]
+        TG_col = treatment_cols[0]["TG_col"]
+        
+        if len(treatment_cols) > 1:
+            print(f"NOTE: Treatment data contains {len(treatment_cols)} treatments. Taking first treatment '{treatment_name}' for identifying treatment group and time.")
+        
+        if verbose:
+            print("Collecting treatment information", end = " ... ")
+
+        groups_config = self.data[1].get_config().copy()
+        treatment_group_size = groups_config[0]["treatment_group"]
+        control_group_size = groups_config[0]["control_group"]
+
+        if verbose:
+            print("OK")
+
+        if treatment_group_size > 1 and process_unit is None:
+            raise ValueError(f"Treatment group contains {treatment_group_size} analysis units and process_unit is set to None. Specify for which unit the SCU must be created.")
+        if control_group_size < 2:
+            raise ValueError(f"Control group contains only {control_group_size} units, which does not allow for creating a SCU.")
+
+        if verbose:
+            print("Extracting control group data", end = " ... ")
+
+        units = list(did_modeldata[config.UNIT_COL].unique())
+
+        process_unit = did_modeldata.loc[did_modeldata[TG_col] == 1, config.UNIT_COL][0]
+
+        if treatment_group_size > 1 and process_unit is not None:
+            
+            if process_unit not in units:
+                raise ValueError(f"Diff-in-diff model data does not contain specified treatment unit '{process_unit}'.")
+
+        units.remove(process_unit)
+        units_size = len(units)
+
+        if verbose:
+            print("OK")
+
+        outcome_col_original = self.data[3]
+        outcome_col = outcome_col_original
+
+        if log_outcome:
+        
+            print(f"Compiling outcome data for natural logarithm of outcome '{outcome_col}'", end = " ... ")
+            
+            outcome_col = f"{config.LOG_PREFIX}{config.DELIMITER}{outcome_col_original}"
+            did_modeldata[outcome_col] = np.log(did_modeldata[outcome_col_original]+log_outcome_add)
+        
+        else:
+            if verbose:
+                print(f"Compiling outcome data for outcome '{outcome_col}'", end = " ... ")
+        
+        process_unit_time = pd.Series(did_modeldata.loc[did_modeldata[config.UNIT_COL] == process_unit, config.TIME_COL])
+        process_unit_outcome = pd.Series(did_modeldata.loc[did_modeldata[config.UNIT_COL] == process_unit, outcome_col])
+
+        outcome_matrix = pd.DataFrame(
+            {
+                config.TIME_COL: process_unit_time.reset_index(drop=True),
+                tools.clean_column_name(process_unit): process_unit_outcome.reset_index(drop=True)
+                }
+            )
+
+        units_not_included = []
+
+        for unit in units:
+            
+            did_modeldata_unit = did_modeldata.loc[
+                (did_modeldata[config.UNIT_COL].astype(str) == str(unit))
+                & (did_modeldata[outcome_col].notna()),
+                outcome_col
+            ]
+
+            if len(did_modeldata_unit) != len(outcome_matrix):
+                units_not_included.append(unit)
+                units.remove(unit)
+            else:
+                outcome_matrix[tools.clean_column_name(unit)] = did_modeldata_unit.reset_index(drop=True)
+
+        if len(units_not_included) > 0:
+            print(f"WARNING: {len(units_not_included)} analysis units were not included due to NaN data.")
+
+        if verbose:
+            print("OK")
+            print(f"Calculating weights based on {len(units)} analysis units", end = " ... ")
+
+        outcome_matrix_Y = outcome_matrix.iloc[:, :2]
+        outcome_matrix_X = outcome_matrix.iloc[:, 2:]
+
+        y = outcome_matrix_Y[tools.clean_column_name(process_unit)]
+        X = outcome_matrix_X.values
+
+        def objective(w):
+            return np.sum((y - X @ w)**2)
+
+        n = X.shape[1]
+        w0 = np.ones(n) / n
+        constraints = {"type": "eq", "fun": lambda w: np.sum(w) - 1}
+        bounds = [(0, 1)] * n
+
+        result = minimize(
+            objective, 
+            w0,
+            bounds=bounds,
+            constraints=constraints
+            )
+
+        weights = result.x
+        weights_pd = pd.Series(weights, index=units)
+       
+        synthetic_pre = X @ weights
+
+        synthetic_fit_metrics = tools.fit_metrics(
+            observed = y, 
+            expected = synthetic_pre
+        )
+
+        if verbose:
+            print("OK")
+            print(f"Creating synthetic control unit", end = " ... ")
+
+        control_units_data = did_modeldata[did_modeldata[config.UNIT_COL].isin(weights_pd.index)].copy()
+        control_units_data["weights"] = control_units_data[config.UNIT_COL].map(weights_pd)
+        control_units_data[outcome_col] = control_units_data[outcome_col].astype(float)
+        control_units_data.loc[:, outcome_col] = (control_units_data[outcome_col] * control_units_data["weights"])
+        
+        variables_dict = {
+            outcome_col: "sum"
+        }
+        for covariate in covariates:
+            control_units_data[covariate] = control_units_data[covariate].astype(float)
+            control_units_data.loc[:, covariate] = control_units_data[covariate]*control_units_data["weights"]
+            variables_dict[covariate] = "sum"
+
+        synthetic = (
+            control_units_data
+            .groupby(config.TIME_COL, as_index=False)
+            .agg(variables_dict)
+        )
+
+        if log_outcome:
+            synthetic[outcome_col_original] = np.exp(synthetic[outcome_col])
+
+        if verbose:
+            print("OK")
+
+        self.add_own_counterfactual(
+            additional_df=synthetic, 
+            counterfactual_outcome_col=outcome_col_original, 
+            counterfactual_UID=SCU_UID,
+            time_col=config.TIME_COL,
+            verbose = False
+            )
+        
+        return self
+ 
     def summary(self):
 
         """
@@ -2076,7 +2347,8 @@ def merge_data(
     groups_config = diff_groups.get_config()
     groups_config = groups_config[0]
     
-    treatment_data_df = diff_treatment.get_data()
+    treatment_data = diff_treatment.get_data()
+    treatment_data_df = treatment_data[0]
     treatment_config = diff_treatment.get_config()
     treatment_config = treatment_config[0]    
 

{diffindiff-2.4.1 → diffindiff-2.5.0}/diffindiff/tests/tests_diffindiff.py

@@ -74,7 +74,8 @@ curfew_data_prepost=create_data(
     study_period=["2020-03-01", "2020-05-15"],
     treatment_period=["2020-03-21", "2020-05-05"],
     freq="D",
-    pre_post=True
+    pre_post=True,
+    after_treatment_period = True
     )
 # Creating DiD treatement dataset by defining groups and
 # treatment time at once

{diffindiff-2.4.1 → diffindiff-2.5.0}/diffindiff.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: diffindiff
-Version: 2.4.1
+Version: 2.5.0
 Summary: diffindiff: Python library for convenient Difference-in-Differences analyses
 Author: Thomas Wieland
 Author-email: geowieland@googlemail.com
@@ -29,7 +29,7 @@ A research note featuring a case study that utilizes the diffindiff library is a
 
 If you use this software, please cite:
 
-Wieland, T. (2026). diffindiff: A Python library for convenient difference-in-differences analyses (Version 2.4.1) [Computer software]. Zenodo. https://doi.org/10.5281/zenodo.18656820
+Wieland, T. (2026). diffindiff: A Python library for convenient difference-in-differences analyses (Version 2.5.0) [Computer software]. Zenodo. https://doi.org/10.5281/zenodo.18656820
 
 
 ## Installation
@@ -177,7 +177,16 @@ See the /tests directory for usage examples of most of the included functions.
 This software was developed without the use of AI-generated code. The Continue Agent in Microsoft Visual Studio Code using the GPT-5 mini model (by OpenAI) was used solely to assist in drafting and refining docstrings for documentation. The corresponding guidelines and constraints defined by the author are documented in `AGENTS-docstrings.md` in the [public GitHub repository](https://github.com/geowieland/diffindiff_official).
 
 
-## What's new (v2.4.1)
+## What's new (v2.5.0)
 
-- Other:
-  - Extension of documentation
+- General
+  - Update of dependencies to be compatible with Python 3.13 (still works with Python 3.11) while avoiding incompatibility conflict of statsmodels and scipy
+  - Internal changes in some functions to be compatible with Python 3.13 (still works with Python 3.11)
+- Extensions
+  - Creating synthetic control units with DiffData.add_synthetic() and conducting a Synthetic DiD analysis
+  - didanalysis_helper.treatment_diagnostics() now additionally checks unique number of analysis units and time points
+  - didanalysis_helper.data_diagnostics() now additionally checks whether covariates are constant; didanalysis.did_analysis() and .ddd_analysis() automatically skip such variables from the model analysis
+- Bugfixes
+  - DiffData.add_own_counterfactual() now works correctly in any case (also when no. of treatments > 1)
+  - Correct internal processing of treatment data in DiffTreatment and DiffData objects when treatments were added
+  - Fixed missing treatment group definition in DiffData.add_treatment() 

diffindiff-2.5.0/diffindiff.egg-info/requires.txt

@@ -0,0 +1,14 @@
+geopandas
+pandas
+numpy
+statsmodels>=0.14.5
+scipy>=1.17
+scikit-learn
+xgboost
+lightgbm
+shapely
+requests<3.0
+contextily
+openpyxl
+matplotlib
+patsy

{diffindiff-2.4.1 → diffindiff-2.5.0}/setup.py

@@ -7,7 +7,7 @@ def read_README():
     
 setup(
     name='diffindiff',
-    version='2.4.1',
+    version='2.5.0',
     description='diffindiff: Python library for convenient Difference-in-Differences analyses',
     packages=find_packages(include=["diffindiff", "diffindiff.tests"]),
     include_package_data=True,
@@ -20,15 +20,20 @@ setup(
         'diffindiff': ['tests/data/*'],
     },
     install_requires=[
-        'numpy>=1.26.1,<=1.26.4',
-        'pandas>=2.2.2,<3.0',
-        'statsmodels==0.14.2',
-        'scipy==1.15.3',
+        'geopandas',
+        'pandas',
+        'numpy',
+        'statsmodels>=0.14.5',
+        'scipy>=1.17',
+        'scikit-learn',
+        'xgboost',
+        'lightgbm',
+        'shapely',
+        'requests<3.0',
+        'contextily',
+        'openpyxl',
         'matplotlib',
-        'scikit-learn>=1.3,<1.6',
-        'xgboost>=1.7,<2.1',
-        'lightgbm>=4.0,<4.5',
-        'patsy>=0.5.6',
+        'patsy',
     ],
     test_suite='tests',
 )

diffindiff-2.4.1/diffindiff.egg-info/requires.txt

@@ -1,9 +0,0 @@
-numpy<=1.26.4,>=1.26.1
-pandas<3.0,>=2.2.2
-statsmodels==0.14.2
-scipy==1.15.3
-matplotlib
-scikit-learn<1.6,>=1.3
-xgboost<2.1,>=1.7
-lightgbm<4.5,>=4.0
-patsy>=0.5.6