Software | Carlos Mendez

scspill

Tue, 28 Jul 2026 00:00:00 +0000

Synthetic control when the treatment leaks — the effect on the treated unit and the spillover received by every donor.

scspill is a Python package of synthetic control models that drop SUTVA on the donor pool. The treatment is allowed to reach the controls, and every model reports two estimands: the effect on the treated unit, purged of the contamination, and the spillover effect received by each donor — something classical synthetic control cannot express at all. The model available today, sar, routes spillovers through spatial weights you supply, scaled by a single intensity ρ that is estimated rather than assumed; it fits unconstrained horseshoe-shrunk synthetic weights, so donors may be dropped, enter negatively, or extrapolate, and it returns full Bayesian uncertainty for both estimands. At ρ = 0 it collapses exactly to the Bayesian horseshoe synthetic control. The estimator architecture follows mlsynth — a pydantic config in, a standardized results object out — and the method names match its SPILLSYNTH dispatcher, so the two libraries compose naturally.

🚀 Get started

Fit a model on California’s Proposition 99 in about ten lines: the ATT with a 95% credible interval, the spillover intensity ρ, the year-by-year spillover received by every donor, MCMC diagnostics, and counterfactual plots.

▶ Open in Colab

🧬 Models

One model ships today: sar, the Bayesian spatial-autoregressive spillover SCM of Sakaguchi & Tagawa (2026). Three further spillover-aware models are on the roadmap — Cao & Dowd, the inclusive SCM of Di Stefano & Mellace, and the partial-interference SCG of Grossi et al. They are not implemented, and SCSPILLConfig rejects their names rather than falling back silently.

🧪 Validation

Evidence that the sar sampler is correct: the Geweke (2004) joint distribution test, prior-sensitivity grids, prior predictive checks, and cross-validation against the authors’ frozen R credible intervals.

What’s inside

scspill — the model layer. SCSPILL(config).fit() returns the ATT and its credible interval, the counterfactual path, the ρ posterior, a time-by-donor spillover panel, and MCMC diagnostics.

scspill.validation — sar’s sampler validation: the Geweke joint distribution test, prior-sensitivity grids, and prior predictive checks.

scspill.simulate — sar’s Monte Carlo engine: a rook-lattice SAR data-generating process and the SCM / BSCM / SCSPILL comparison behind Tables 1–2 of the paper.

scspill.data — the bundled spillover panels below. They are model-agnostic, so any model added later can use them unchanged.

sar is validated, not just implemented — it is cross-validated against the authors’ R replication package: the California and Sudan posteriors against the frozen R credible intervals, the Monte Carlo grid against the paper’s frozen tables, and the prior predictive statistics to three decimals. The defaults are paper-correct: several documented bugs of the reference implementation are fixed, each with an escape hatch or a benchmark quantifying the difference — see the sar model page.

Bundled case studies

scspill.data ships two ready-to-estimate datasets:

California — Proposition 99, 39 states (1970–2000): per-capita cigarette sales with rook-contiguity weights, via scspill.data.load_california().
Sudan — the 2011 secession, 34 African countries (2000–2015): GDP per capita with trade-network weights, via scspill.data.load_sudan(). Worked through in the Sudan case study.

Installation

Install the latest release from PyPI (the core install is pure NumPy/SciPy; the numba extra adds JIT-compiled samplers):

pip install scspill # NumPy/SciPy sampler backend
pip install "scspill[numba]" # + JIT-compiled samplers (~10x faster)
pip install "scspill @ git+https://github.com/quarcs-lab/scspill.git" # latest

Requires Python 3.10+.

At a glance

Load a bundled case study, fit the sampler, and read off both estimands:

from scspill import SCSPILL
from scspill.data import load_california
panel = load_california() # Prop 99 panel + rook-contiguity weights
result = SCSPILL(
{**panel.config_kwargs(), "m_iter": 20_000, "burn": 10_000, "seed": 42}
).fit()
result.att, result.att_ci # treatment effect on California + 95% CrI
result.rho_hat, result.rho_ci # spillover intensity posterior
result.spillover_panel["Nevada"] # the effect received by Nevada, per year
result.diagnostics() # ESS / R-hat / MCSE per chain
result.plot(kind="panel") # counterfactual | effect | top spillovers

Head to Get started, Models and Validation to see the estimators in action.

Built on

scspill keeps its dependencies deliberately light — the modern Python scientific stack, and nothing else:

NumPy and SciPy — the sampler backend
pandas — panels and the spillover tables
pydantic — the validated estimator configuration
matplotlib — the diagnostic and counterfactual figures
numba — optional JIT-compiled samplers

Acknowledgement

scspill is authored by Carlos Mendez, Shosei Sakaguchi and Hayato Tagawa. The Python package is written and maintained by Carlos Mendez; the sar model and its original R/C++ implementation are the work of Shosei Sakaguchi and Hayato Tagawa. Their replication package is MIT-licensed, its copyright notice is retained in the library’s LICENSE, and every release of scspill is cross-validated against its frozen results. The estimator architecture follows Jared Greathouse’s mlsynth; the documentation stack follows the QuaRCS Lab’s geometrics package.

If you use scspill, please cite the software (machine-readable metadata lives in CITATION.cff):

Mendez, C., Sakaguchi, S., & Tagawa, H. (2026). Synthetic Control Models with Spillovers in Python (version 0.2.1). https://github.com/quarcs-lab/scspill

Released under the MIT license.

geometrics

Thu, 02 Jul 2026 00:00:00 +0000

Regional growth, convergence, and inequality — spatially, in Python.

geometrics builds on the PySAL family and wraps the standard analyses of the regional-convergence literature into easy-to-apply functions that return interactive Plotly figures, publication-quality Great Tables, and tidy DataFrames. It pairs an Explore / Analyze / Learn workflow with a built-in teaching layer that interprets and explains every result, and three no-code apps. It is built for students, teachers and applied researchers alike.

🗺️ Explore

Map and describe your regions: classified and animated choropleths, spatial-weights connectivity, Moran scatterplots and LISA cluster maps, and space-time views.

🚀 Launch app · ▶ Open in Colab

🧮 Analyze

Estimate the models: β-, σ- and club convergence, spatial econometric models with impacts, Markov and spatial-Markov dynamics, Gini/Theil inequality with spatial decomposition, and GWR / multiscale GWR.

🚀 Launch app · ▶ Open in Colab

📚 Learn

See the ideas behind the methods: 11 runnable concept sandboxes where you tune a known truth, a 30-topic explainer index, and a plain-language reading on every result.

🚀 Launch app · ▶ Open in Colab

Try the apps in your browser

No install, no code — the three geometrics apps run the whole workflow in your browser: point-and-click maps and models, sortable tables, and reproducible exports. Each is the no-code companion to a docs case study.

🗺️ Explore app · 🧮 Analyze app · 📚 Learn app

What’s inside

Maps & ESDA — classified / animated choropleths, spatial-weights connectivity, Moran scatterplots, LISA cluster maps, and Moran’s I over time.

Space-time dynamics — cross-sectional distribution evolution and entity-by-time heatmaps.

Convergence — β-convergence with OLS or spatial estimators, σ-convergence, and Phillips–Sul convergence clubs with club maps.

Spatial econometrics — the spreg suite, LM diagnostics with model recommendation, and alternative-weights robustness.

Distribution dynamics — Markov and spatial-Markov transition analysis.

Inequality — Gini / Theil trends with spatial decomposition, and Theil between/within decomposition.

Local models — GWR and multiscale GWR with mapped local coefficients.

Concept sandboxes — 11 teaching functions that simulate data from known data-generating processes.

Bundled case studies

geometrics.data ships two ready-to-analyze case studies:

India — 520 districts, satellite nighttime lights (1996–2010): gm.data.load_india(), load_india_states().
Bolivia — PWT-anchored local GDP (2021 PPP US\$, 2012–2022) at three geographic scales: gm.data.load_bolivia() (112 provinces), load_bolivia_departments() (9 departments), and load_bolivia_grid() (1,603 cells).

Installation

Install the latest release from PyPI (the core install covers most workflows; extras add the Markov dynamics, the no-code apps, and PNG export):

pip install geometrics # core
pip install "geometrics[dynamics]" # + Markov / spatial Markov (giddy)
pip install "geometrics[streamlit]" # + the three no-code apps
pip install "geometrics[all]" # everything, incl. PNG export

Requires Python 3.11+.

At a glance

Load a bundled case study, attach its variable labels, and map it — every figure is an interactive Plotly object:

import geometrics as gm
# India — 520 districts, satellite nighttime lights (1996–2010)
gdf, df, df_dict = gm.data.load_india()
df = gm.set_labels(df, df_dict, set_panel=True)
# A classified choropleth of nighttime lights in 2010
gm.explore_choropleth_map(df, "ntl_total", gdf=gdf, period=2010).fig

Estimate convergence and let it explain itself — β- and σ-convergence, each with a plain-language reading:

beta = gm.analyze_beta_convergence(df, "ntl_total", model="ols")
print(beta.interpret()) # plain-language, associational reading
sigma = gm.analyze_sigma_convergence(df, "ntl_total")

Learn as you go — concept sandboxes and explainers:

gm.learn_beta_convergence(convergence_rate=0.02) # a runnable concept sandbox
print(gm.explain("spatial_autocorrelation")) # a concept explainer; gm.list_topics() lists all 30

Head to Explore, Analyze and Learn to see every function in action.

Built on

geometrics stands on the PySAL spatial-analysis ecosystem and the modern Python data stack:

PySAL — libpysal (weights), esda (Moran’s I / LISA), giddy (distribution dynamics), inequality (Gini / Theil), mapclassify (choropleth classification), spreg (spatial regression), and mgwr (multiscale GWR)
geopandas — geospatial dataframes
Plotly — interactive figures
Great Tables — publication-quality tables

Acknowledgement

geometrics is developed at the QuaRCS Lab (Quantitative Regional and Computational Science) and stands on the shoulders of the PySAL project, geopandas, Plotly and Great Tables. If you use geometrics in your research, please cite the repository (see CITATION.cff) and the underlying PySAL packages.

expdpy

Thu, 18 Jun 2026 00:00:00 +0000

Explore, analyze and learn panel data — interactively, in Python.

expdpy pairs composable functions that return interactive Plotly figures and publication-quality Great Tables with fixest-style econometrics, a built-in teaching layer that interprets and explains every result, and three no-code apps. It is built for students, teachers and applied researchers alike.

🔍 Explore

Describe and visualize your panel: tables, distributions, missing-value maps, time trends, group comparisons, scatter plots, within/between variation and panel dynamics.

🚀 Launch app · ▶ Open in Colab

🧮 Analyze

Estimate models: fixed / random / correlated random effects, FWL, the Hausman test, robust inference, event-study / DiD, β/σ/club convergence and the Kuznets-waves curve.

🚀 Launch app · ▶ Open in Colab

📚 Learn

See the ideas behind the methods: 9 runnable concept sandboxes where you tune a known truth, a 27-topic explainer index, and a plain-language reading on every result.

🚀 Launch app · ▶ Open in Colab

Try the apps in your browser

No install, no code — the three ExPdPy apps run the whole workflow in your browser: a sample pipeline, point-and-click analysis, sortable tables, and reproducible notebook export. Each is the no-code companion to a docs case study.

🔍 Explore app · 🧮 Analyze app · 📚 Learn app

What’s inside

Explore — descriptive / correlation / extreme-observation tables, histograms and bar charts, time and quantile trends, by-group bar / violin / trend views, a missing-value heatmap, scatter plots with an optional LOESS smoother, the within/between (xtsum) decomposition, per-unit trajectories, panel-structure diagnostics, distribution & transition dynamics, and treat_outliers.

Analyze — OLS with multi-way fixed effects and clustered standard errors via pyfixest; a richer analyze_estimation (stepwise / multiple-outcome, Newey–West & Driscoll–Kraay SEs); pooled / between / fixed / random effects and the correlated-random-effects (Mundlak) estimator; the Hausman test; post-estimation (fixed-effect plots, predictions, Wald joint tests); robust inference (randomization inference, wild cluster bootstrap); Frisch–Waugh–Lovell and coefficient plots; modern event-study / staggered difference-in-differences (did2s, Sun–Abraham, LP-DiD, dynamic TWFE); β-, σ- and club convergence; and the Kuznets-waves curve under pooled / between / within estimators.

Learn — every result speaks plain language: .interpret() gives an associational reading (never a causal claim unless the design supports it) and .explain() / explain(topic) / list_topics() browse 27 concept explainers. Nine concept sandboxes simulate data so you can see and tune a known truth — the first-differences ≈ demeaning ≈ dummies identity, fixed effects, clustering, omitted-variable bias, β/σ/club convergence, and the Kuznets wave.

Bundled datasets — expdpy.data ships ready-to-explore panels: kuznets (the flagship N-shaped Kuznets-curve demo), gapminder, staggered_did (event-study / DiD), productivity and bolivia112_gdppc (convergence). See the kuznets dataset page for the data dictionary.

Installation

Install the latest release from PyPI (random effects, CRE and the Hausman test work out of the box; the apps need the streamlit extra):

pip install expdpy
pip install "expdpy[streamlit]" # the no-code ExPdPy apps (Streamlit)

Using uv:

uv pip install expdpy
uv pip install "expdpy[streamlit]"

For the latest unreleased version, install straight from the main branch:

pip install "git+https://github.com/cmg777/expdpy.git"

Requires Python 3.10+.

At a glance

The lead example throughout these docs is the bundled kuznets panel (80 countries × 2015–2025): a synthetic dataset whose regional inequality traces an N-shaped Kuznets curve in income — rising, falling, then rising again at very high income.

import expdpy as ex
from expdpy.data import load_kuznets
df = load_kuznets()
# The N-shaped regional Kuznets curve: regional inequality vs (log) GDP per capita
ex.explore_scatter_plot(
df, x="log_gdp_pc", y="gini_regional", color="continent", size="population", loess=1
).fig

Run a regression and let it explain itself — two-way fixed effects, clustered standard errors, a plain-language reading, and a coefficient plot:

res = ex.analyze_regression_table(
df,
dvs="gini_regional",
idvs=["log_gdp_pc", "log_gdp_pc_sq", "log_gdp_pc_cu"],
feffects=["country", "year"],
clusters=["country"],
)
print(res.interpret()) # plain-language, associational reading
ex.analyze_coefficient_plot(res) # themed coefficient plot with confidence intervals

Learn as you go — concept sandboxes and explainers:

ex.learn_first_differences() # first differences ≈ demeaning ≈ dummy variables
print(ex.explain("fixed_effects")) # a concept explainer; ex.list_topics() lists all 27

Head to Explore, Analyze and Learn to see every function in action, or the kuznets dataset page for the data dictionary.

Built on

expdpy stands on the modern Python data and econometrics stack:

Plotly — interactive figures
pyfixest — fixed-effects and difference-in-differences estimators
Great Tables — publication-quality tables
linearmodels — random / between / correlated random effects and the Hausman test
Streamlit — the no-code ExPdPy apps

Acknowledgement

expdpy began as a Python port of the excellent ExPanDaR R package by Joachim Gassen and the TRR 266 Accounting for Transparency project, and its foundations remain deeply inspired by that work. Over time, expdpy has grown well beyond the original — fixest-style estimators, event-study / difference-in-differences tools, random- and correlated-random-effects panel models, convergence analysis, and a built-in teaching layer that interprets and explains results — and it will keep evolving.

We are grateful to the ExPanDaR authors. Please cite the original work when using expdpy in research (see CITATION.cff).