hdfe-stream 0.2.2__tar.gz → 0.3.0__tar.gz

{hdfe_stream-0.2.2 → hdfe_stream-0.3.0}/CHANGELOG.md

@@ -1,5 +1,76 @@
 # Changelog
 
+## 0.3.0
+
+New features.
+
+- **`connected_components`** finds the connected components of the graph of
+  two fixed-effect dimensions (either may be an interaction, `firm_id^year`)
+  by union-find over the rows as they stream, holding level-sized arrays
+  only. It returns a table per dimension giving each level its component,
+  numbered by size so that component 0 is the largest (ties go to the
+  component with the smallest level of the first dimension), and a table of
+  component sizes. `largest()` filters the data to the largest connected
+  set and `label()` adds each row's component, both lazily (on the data the
+  components were found in, or on other data passed to them). `min_degree`
+  removes levels with fewer distinct partners in the other dimension,
+  repeating until none is left, before the components are found: `(2, 1)`
+  keeps only movers, `2` the 2-core. `leave_one_out=True` prunes to the
+  leave-one-out connected set of KSS estimation instead. `rank_by` says
+  whether "largest" counts rows (the default) or the levels of one dimension.
+- **`connected=`, `min_degree=` and `connected_fe=`** in `feols_stream`,
+  `fepois_stream`, `feglm_stream` and `StreamingHDFE` restrict the fit to a
+  pair of fixed effects (`connected_fe`, by default the first two listed),
+  among the rows with no missing values and before singletons are dropped:
+  `min_degree` prunes levels with too few distinct partners, then
+  `connected="largest"` keeps the largest connected set of what is left, or
+  `connected="leave_one_out"` the leave-one-out connected set, as
+  `connected_components` does. `sample()` reports the rows they drop as
+  `"min_degree"`, `"disconnected"` and `"leave_one_out"`, and
+  `diagnostics["connected"]` and the summary count them.
+- **Python 3.15** is supported and tested in CI. pyfixest, which the
+  `formula` extra needs, has no 3.15 wheels yet (0.60.0), and building it
+  from source needs Rust and `PYO3_USE_ABI3_FORWARD_COMPATIBILITY=1`; the
+  rest of the package installs from wheels.
+
+Changes that can affect existing code.
+
+- **`leave_one_out_connected` and `LeaveOutSet` are removed.** Use
+  `connected_components(data, "worker_id + firm_id", leave_one_out=True)`,
+  whose `.largest()` is the pruned panel, or `connected="leave_one_out"`
+  in a fit. The set is the same: on simulated panels with many components,
+  workers observed once and several rounds of cut workers, the workers and
+  firms kept are identical. It is found 5-6 times faster (38s against 218s on
+  150 million rows), and a null worker or firm id no longer makes it fail.
+- **`leave_out_kss` prunes in the fit**, with `connected="leave_one_out"`, so
+  the leave-one-out connected set is that of the rows the model can use:
+  before, rows with a missing outcome or covariate were part of the network
+  being pruned. `lo.pruning` is now a dict of the pruning's counts (the
+  fit's `diagnostics["connected"]["leave_one_out"]`), and the rows it dropped
+  are those `lo.fit.sample()` labels `"leave_one_out"`.
+- **The `component` column of `fixef()` is numbered by size**, so component
+  0 is the largest (by rows in the estimation sample), as in
+  `connected_components`. Ties go to the component with the smallest level of
+  that dimension. It was numbered by each component's smallest level.
+- **Removed `hdfe_stream.iter_group_chunks` and `StreamingHDFE.from_formula`.**
+  The first read only the fit's internal row files, sorted by its internal
+  group code, and stays internal; the second duplicated `feols_stream`.
+
+Fixes.
+
+- **The leave-out operator's null space is right with several connected
+  components.** `apply_inverse` built one null vector for every number up to
+  the largest component label, which with several components left gaps, and
+  each gap added a spurious vector. Leave-out estimation runs on a connected
+  set and was not affected.
+
+Documentation.
+
+- **New example, `connected_sets.py`**, and additions to the others:
+  `sample()` and joining the residuals back on `row_id`, `fe_dof`, and CRV3
+  (`formulas.py`); `summary_json` (`quickstart.py`); `keep=` and a
+  decomposition by group (`akm_variance.py`); and `StreamingGLM` (`glm.py`).
+
 ## 0.2.2
 
 - **Polars 2.0 support.** `fit.sample()` returns the source's rows in the source's
@@ -38,11 +109,6 @@
   unchanged up to rounding.
 - **Removed `triple_budget` and `dense_max_levels`** from `StreamingHDFE`. They
   tuned the old way of building S and have no counterpart in the new one.
-- **Per-iteration CG messages are logged at DEBUG.** With `verbose=True`, the
-  "CG iter N: max rel. residual" lines go to the logger at DEBUG, whatever
-  `log_level` is, so they appear only when the logger is enabled for DEBUG.
-  Without a logger they are no longer printed. Other progress messages are
-  unchanged.
 - **Importing hdfe_stream costs a little less memory.** p-values, critical
   values and the weak-identification interval use `scipy.special`'s
   distribution functions instead of `scipy.stats`, which is no longer

{hdfe_stream-0.2.2 → hdfe_stream-0.3.0}/CITATION.cff

@@ -7,8 +7,8 @@ authors:
   - family-names: Tucker
     given-names: Lee
     email: lee.c.tucker@census.gov
-version: 0.2.2
-date-released: 2026-10-08
+version: 0.3.0
+date-released: 2026-10-14
 license: MIT
 repository-code: "https://github.com/leetucker/hdfe-stream"
 url: "https://github.com/leetucker/hdfe-stream"

{hdfe_stream-0.2.2 → hdfe_stream-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hdfe-stream
-Version: 0.2.2
+Version: 0.3.0
 Summary: Out-of-core regression with several high-dimensional fixed effects: OLS, Poisson, logit and probit, with AKM/KSS variance decompositions
 Author: Lee Tucker
 License-Expression: MIT
@@ -19,6 +19,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: Topic :: Scientific/Engineering
 Classifier: Typing :: Typed
 Requires-Python: >=3.10
@@ -139,6 +140,11 @@ pip install hdfe-stream[formula]     # formula syntax needs pyfixest
 | `all` | all of the above |
 | `test` | the test suite |
 
+On Python 3.15, pyfixest 0.60 (for the `formula` extra) has no wheels yet. It
+builds from source with a Rust toolchain and
+`PYO3_USE_ABI3_FORWARD_COMPATIBILITY=1` set; everything else installs from
+wheels.
+
 Without `formula` you still get `StreamingHDFE`, the lower-level interface that
 takes column names or Polars expressions instead of a formula string.
 
@@ -163,6 +169,47 @@ left (`fixef_rm="singleton"`, the default; `fixef_rm="none"` keeps them).
 Finding them costs a few extra passes over the fixed-effect columns and memory
 for the singleton levels, not for the rows.
 
+**Connected sets.** Worker and firm effects are only comparable within a
+connected set: firms linked, directly or through other firms, by workers who
+moved between them. `connected_components(data, "worker_id + firm_id")` finds
+the connected components of the graph of two fixed effects (either may be an
+interaction, `firm_id^year`) by union-find over the rows as they stream, and
+returns small tables, one per dimension, giving each level its component.
+Components are numbered by size, so `component == 0` is the largest.
+`.largest()` is the largest connected set and `.label()` every row with
+its component, both lazily.
+
+`min_degree` first removes levels with too few distinct partners in the other
+dimension (distinct firms for a worker, distinct workers for a firm),
+repeating until none is left, then finds the components of what remains.
+`min_degree=(2, 1)` keeps movers only: workers seen at two or more firms, and
+the firms they were seen at. `min_degree=2` also removes firms with a single
+worker, and repeats, since removing a firm can leave a worker with one firm and
+removing a worker can leave a firm with one worker, until every worker left
+was seen at two or more firms and every firm employed two or more of them (the
+network's "2-core").
+
+`leave_one_out=True` instead prunes to the **leave-one-out connected set** that
+KSS estimation needs (and `leave_out_kss` applies), so it can be found ahead of
+time: the largest connected set, without workers observed only once, and
+without any worker whose departure would split the network into pieces,
+removed repeatedly until none is left. It differs from `min_degree=2`. It keeps
+stayers with at least two observations, which `min_degree=2` removes, and it
+removes movers that `min_degree=2` keeps. Every mover and firm it keeps,
+`min_degree=2` keeps too, and on the movers and firms the two coincide only
+when no single mover holds the network together.
+
+In a fit, `min_degree=` prunes first, then `connected="largest"` keeps the
+largest connected set or `connected="leave_one_out"` the leave-one-out
+connected set, all on the first two fixed effects listed unless
+`connected_fe=` names another pair, and all before singletons are dropped, so
+the fit equals one on data restricted beforehand. `sample()` labels the rows
+they drop `"min_degree"`, `"disconnected"` and `"leave_one_out"`. The
+`component` column of `fixef()` for the first non-streamed dimension is
+numbered the same way, by rows in the estimation sample. With three or more
+fixed effects, connectedness of one pair is necessary for identification but
+not sufficient.
+
 **Covariates.** Transformations (`I(age**2)`, `log(x)`), categoricals (`C(x)`,
 string columns), interactions (`:`, `*`), event-study terms
 (`i(year, treat, ref=2009)`). Terms spanned by the fixed effects are dropped
@@ -212,7 +259,8 @@ order, not the source's, so every row carries `row_id`, its position in the
 source before any row was dropped (`row_id=` renames the column).
 `fit.resid()` joins back onto the source on it, and `fit.sample()` returns the
 source, lazily, with `row_id`, `in_sample` and `dropped_because` (null for rows
-used; otherwise `"missing"`, `"singleton"` or `"separation"`), for looking at
+used; otherwise `"missing"`, `"min_degree"`, `"disconnected"`,
+`"leave_one_out"`, `"singleton"` or `"separation"`), for looking at
 the data net of what the fit dropped:
 
 ```python
@@ -479,6 +527,7 @@ Runnable, on simulated data, no setup — see [examples/](https://github.com/lee
 | [`varying_slopes.py`](https://github.com/leetucker/hdfe-stream/blob/main/examples/varying_slopes.py) | worker-specific trends, and the low-level interface |
 | [`out_of_core.py`](https://github.com/leetucker/hdfe-stream/blob/main/examples/out_of_core.py) | memory, disk, solvers, logging |
 | [`reporting.py`](https://github.com/leetucker/hdfe-stream/blob/main/examples/reporting.py) | tables and plots via pyfixest |
+| [`connected_sets.py`](https://github.com/leetucker/hdfe-stream/blob/main/examples/connected_sets.py) | connected components, `min_degree` pruning and the leave-one-out connected set, compared |
 | [`leave_out_kss.py`](https://github.com/leetucker/hdfe-stream/blob/main/examples/leave_out_kss.py) | the KSS bias correction, checked against the effects the data was built from |
 
 ## Simulated data
@@ -546,8 +595,9 @@ print(lo.summary())
 
 It follows Saggio's reference implementation,
 [LeaveOutTwoWay](https://github.com/rsaggio87/LeaveOutTwoWay). It prunes to the
-leave-one-out connected set, leaves out a worker–firm match by default, and
-approximates leverages by random projection. It supports weights, standard
+leave-one-out connected set (which `connected_components(...,
+leave_one_out=True)` finds on its own, ahead of time), leaves out a
+worker–firm match by default, and approximates leverages by random projection. It supports weights, standard
 errors, and KSS's weak-identification diagnostic and q = 1 interval.
 
 **[docs/kss.md](https://github.com/leetucker/hdfe-stream/blob/main/docs/kss.md)** covers the options, the standard errors and their

{hdfe_stream-0.2.2 → hdfe_stream-0.3.0}/README.md

@@ -90,6 +90,11 @@ pip install hdfe-stream[formula]     # formula syntax needs pyfixest
 | `all` | all of the above |
 | `test` | the test suite |
 
+On Python 3.15, pyfixest 0.60 (for the `formula` extra) has no wheels yet. It
+builds from source with a Rust toolchain and
+`PYO3_USE_ABI3_FORWARD_COMPATIBILITY=1` set; everything else installs from
+wheels.
+
 Without `formula` you still get `StreamingHDFE`, the lower-level interface that
 takes column names or Polars expressions instead of a formula string.
 
@@ -114,6 +119,47 @@ left (`fixef_rm="singleton"`, the default; `fixef_rm="none"` keeps them).
 Finding them costs a few extra passes over the fixed-effect columns and memory
 for the singleton levels, not for the rows.
 
+**Connected sets.** Worker and firm effects are only comparable within a
+connected set: firms linked, directly or through other firms, by workers who
+moved between them. `connected_components(data, "worker_id + firm_id")` finds
+the connected components of the graph of two fixed effects (either may be an
+interaction, `firm_id^year`) by union-find over the rows as they stream, and
+returns small tables, one per dimension, giving each level its component.
+Components are numbered by size, so `component == 0` is the largest.
+`.largest()` is the largest connected set and `.label()` every row with
+its component, both lazily.
+
+`min_degree` first removes levels with too few distinct partners in the other
+dimension (distinct firms for a worker, distinct workers for a firm),
+repeating until none is left, then finds the components of what remains.
+`min_degree=(2, 1)` keeps movers only: workers seen at two or more firms, and
+the firms they were seen at. `min_degree=2` also removes firms with a single
+worker, and repeats, since removing a firm can leave a worker with one firm and
+removing a worker can leave a firm with one worker, until every worker left
+was seen at two or more firms and every firm employed two or more of them (the
+network's "2-core").
+
+`leave_one_out=True` instead prunes to the **leave-one-out connected set** that
+KSS estimation needs (and `leave_out_kss` applies), so it can be found ahead of
+time: the largest connected set, without workers observed only once, and
+without any worker whose departure would split the network into pieces,
+removed repeatedly until none is left. It differs from `min_degree=2`. It keeps
+stayers with at least two observations, which `min_degree=2` removes, and it
+removes movers that `min_degree=2` keeps. Every mover and firm it keeps,
+`min_degree=2` keeps too, and on the movers and firms the two coincide only
+when no single mover holds the network together.
+
+In a fit, `min_degree=` prunes first, then `connected="largest"` keeps the
+largest connected set or `connected="leave_one_out"` the leave-one-out
+connected set, all on the first two fixed effects listed unless
+`connected_fe=` names another pair, and all before singletons are dropped, so
+the fit equals one on data restricted beforehand. `sample()` labels the rows
+they drop `"min_degree"`, `"disconnected"` and `"leave_one_out"`. The
+`component` column of `fixef()` for the first non-streamed dimension is
+numbered the same way, by rows in the estimation sample. With three or more
+fixed effects, connectedness of one pair is necessary for identification but
+not sufficient.
+
 **Covariates.** Transformations (`I(age**2)`, `log(x)`), categoricals (`C(x)`,
 string columns), interactions (`:`, `*`), event-study terms
 (`i(year, treat, ref=2009)`). Terms spanned by the fixed effects are dropped
@@ -163,7 +209,8 @@ order, not the source's, so every row carries `row_id`, its position in the
 source before any row was dropped (`row_id=` renames the column).
 `fit.resid()` joins back onto the source on it, and `fit.sample()` returns the
 source, lazily, with `row_id`, `in_sample` and `dropped_because` (null for rows
-used; otherwise `"missing"`, `"singleton"` or `"separation"`), for looking at
+used; otherwise `"missing"`, `"min_degree"`, `"disconnected"`,
+`"leave_one_out"`, `"singleton"` or `"separation"`), for looking at
 the data net of what the fit dropped:
 
 ```python
@@ -430,6 +477,7 @@ Runnable, on simulated data, no setup — see [examples/](https://github.com/lee
 | [`varying_slopes.py`](https://github.com/leetucker/hdfe-stream/blob/main/examples/varying_slopes.py) | worker-specific trends, and the low-level interface |
 | [`out_of_core.py`](https://github.com/leetucker/hdfe-stream/blob/main/examples/out_of_core.py) | memory, disk, solvers, logging |
 | [`reporting.py`](https://github.com/leetucker/hdfe-stream/blob/main/examples/reporting.py) | tables and plots via pyfixest |
+| [`connected_sets.py`](https://github.com/leetucker/hdfe-stream/blob/main/examples/connected_sets.py) | connected components, `min_degree` pruning and the leave-one-out connected set, compared |
 | [`leave_out_kss.py`](https://github.com/leetucker/hdfe-stream/blob/main/examples/leave_out_kss.py) | the KSS bias correction, checked against the effects the data was built from |
 
 ## Simulated data
@@ -497,8 +545,9 @@ print(lo.summary())
 
 It follows Saggio's reference implementation,
 [LeaveOutTwoWay](https://github.com/rsaggio87/LeaveOutTwoWay). It prunes to the
-leave-one-out connected set, leaves out a worker–firm match by default, and
-approximates leverages by random projection. It supports weights, standard
+leave-one-out connected set (which `connected_components(...,
+leave_one_out=True)` finds on its own, ahead of time), leaves out a
+worker–firm match by default, and approximates leverages by random projection. It supports weights, standard
 errors, and KSS's weak-identification diagnostic and q = 1 interval.
 
 **[docs/kss.md](https://github.com/leetucker/hdfe-stream/blob/main/docs/kss.md)** covers the options, the standard errors and their

{hdfe_stream-0.2.2 → hdfe_stream-0.3.0}/docs/kss.md

@@ -51,8 +51,12 @@ be describing a different model, so there is no "fit then decompose it" path
 that skips this. `prune=False` checks instead of pruning, and fails if the panel
 is not already connected — for callers who pruned upstream.
 
-`leave_one_out_connected(data)` is available on its own if you want the pruned
-panel for something else.
+The pruning is the fit option `connected="leave_one_out"`, so it runs on the
+rows the model can use, and the fit's `sample()` labels the rows it drops
+`"leave_one_out"` (`lo.fit.sample()`); `lo.pruning` has the counts. To find the
+set ahead of time, or to fit other things on it,
+`connected_components(data, "worker_id + firm_id", leave_one_out=True)` returns
+it as a table of the levels kept, and its `.largest()` is the pruned panel.
 
 ## What is left out: a match, or an observation
 
@@ -116,9 +120,9 @@ out an observation reads the sorted rows and cell tables a fit otherwise deletes
 when it finishes, so that needs `keep_intermediates=True`:
 
 ```python
-panel = leave_one_out_connected("data/*.parquet")
-fit   = feols_stream(fml, panel.data, workdir="scratch")
-lo    = fit.leave_out_kss(n_draws=250)
+fit = feols_stream(fml, "data/*.parquet", workdir="scratch",
+                   connected="leave_one_out")
+lo  = fit.leave_out_kss(n_draws=250)
 ```
 
 The two give identical numbers.

{hdfe_stream-0.2.2 → hdfe_stream-0.3.0}/docs/kss_methodological_differences.md

@@ -112,7 +112,14 @@ Were W2 kept, `leave_out_components` would find leverage 1 and raise "not
 leave-one-out connected".
 
 The pruned sample matches xhdfe's row for row on three panels, with the same
-number of rounds (3, 1, 2). Diagnostics report `pruning_rounds`.
+number of rounds (3, 1, 2). Diagnostics report the rounds
+(`lo.pruning["rounds"]`).
+
+The pruning runs on the rows the model can use: it is the fit's
+`connected="leave_one_out"`, which comes after rows with a missing outcome,
+covariate or fixed effect are dropped. A row the regression cannot use connects
+nothing in it, so it cannot keep a worker or firm in the set. On complete data
+this changes nothing.
 
 ### 1.3 Workers with a single observation  ·  *agrees*
 
@@ -125,8 +132,8 @@ number of rounds (3, 1, 2). Diagnostics report `pruning_rounds`.
 A worker seen once has leverage exactly 1: the worker effect is determined by that
 observation. A pendant worker is never an articulation point, so pruning alone
 never removes it, and the leverage check would raise. Tested on a minimal
-panel. The resulting sample matches xhdfe's. Diagnostics report
-`single_observation_workers`.
+panel. The resulting sample matches xhdfe's. Diagnostics report them
+(`lo.pruning["single_observation"]`).
 
 ### 1.4 The graph searched for articulation points  ·  *Numerical*
 

{hdfe_stream-0.2.2 → hdfe_stream-0.3.0}/hdfe_stream/__init__.py

@@ -56,7 +56,9 @@ group_by a slice of whole fe[0] groups (about batch_rows rows) at a time.
 Pipeline
 --------
 Pass 0 (Polars, streaming)   evaluate the design as Polars expressions; drop
-                             rows with missing / non-finite values; factorize
+                             rows with missing / non-finite values (and, as
+                             asked, outside the largest connected set, and
+                             singletons); factorize
                              the non-streamed FE and cluster ids;
                              hash-partition rows into fe[0] buckets; sort each
                              bucket and assign dense fe[0] codes.
@@ -94,6 +96,8 @@ kernels_glm.py     numba kernels, GLM cell sums and group effects
 formula.py         pyfixest formula -> Polars expressions (input side)
 reporting.py       pyfixest etable/coefplot views (output side)
 feterms.py         'worker_id[t]' / 'firm_id^year' parsing
+connected.py       `connected_components`: components of a pair of FE
+                   dimensions, the largest connected set (also `connected=`)
 results.py         `HDFEResult`, `HDFEMulti`
 workspace.py       run directories, `cleanup()`
 report.py          logging / printing
@@ -101,14 +105,14 @@ utils.py           small shared helpers
 """
 
 from .api import feglm_stream, fepois_stream, feols_stream
+from .connected import ConnectedComponents, connected_components
 from .estimator import StreamingHDFE
 from .glm import StreamingGLM
 from .leaveout_se import ComponentSE
 from .leaveout_weakid import WeakIdDiagnostics
-from .leaveout import leave_one_out_connected, leave_out_kss
+from .leaveout import leave_out_kss
 from .reporting import etable
 from .results import HDFEMulti, HDFEResult
-from .utils import iter_group_chunks
 from .workspace import cleanup
 
 __all__ = [
@@ -123,9 +127,9 @@ __all__ = [
     "leave_out_kss",
     "ComponentSE",
     "WeakIdDiagnostics",
-    "leave_one_out_connected",
+    "connected_components",
+    "ConnectedComponents",
     "cleanup",
-    "iter_group_chunks",
 ]
 
 def _detect_version():
@@ -133,7 +137,7 @@ def _detect_version():
         from importlib.metadata import version
         return version("hdfe-stream")
     except Exception:                 # source tree without an installed dist
-        return "0.2.2"
+        return "0.3.0"
 
 
 __version__ = _detect_version()

{hdfe_stream-0.2.2 → hdfe_stream-0.3.0}/hdfe_stream/_types.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Any, Mapping, Sequence, Union
+from typing import Mapping, Sequence, Union
 
 import polars as pl
 
@@ -15,4 +15,3 @@ Vcov = Union[str, Mapping[str, str]]
 # column name, (name, expression), or a mapping / sequence of them
 Variables = Union[
     str, tuple, Sequence[Union[str, tuple]], Mapping[str, pl.Expr]]
-Options = Any

{hdfe_stream-0.2.2 → hdfe_stream-0.3.0}/hdfe_stream/api.py

@@ -17,16 +17,6 @@ from .results import HDFEMulti, HDFEResult, _vcov_key
 from .utils import _as_lazy
 
 
-class _FormulaEstimator:
-    def __init__(self, fml: str, workdir: PathLike | None, options: dict[str, Any]) -> None:
-        self.fml, self.workdir, self.options = fml, workdir, options
-
-    def fit(self, data: Source, vcov: Vcov = "iid", cluster: Sequence[str] | str = (),
-            fe_dof: str = "exact") -> HDFEResult | HDFEMulti:
-        return feols_stream(self.fml, data, self.workdir, vcov=vcov, cluster=cluster,
-                            fe_dof=fe_dof, **self.options)
-
-
 def feols_stream(fml: str, data: Source, workdir: PathLike | None = None,
                  vcov: Vcov = "iid", cluster: Sequence[str] | str = (),
                  fe_dof: str = "exact", **options: Any) -> HDFEResult | HDFEMulti:
@@ -49,7 +39,10 @@ def feols_stream(fml: str, data: Source, workdir: PathLike | None = None,
     **options : passed to StreamingHDFE (fixef_rm, stream, weights,
               weights_type, solver, precond, keep, verbose, logger, log_level,
               ...). fixef_rm='singleton' (the default, as in pyfixest) drops
-              singleton observations; 'none' keeps them.
+              singleton observations; 'none' keeps them. connected='largest'
+              keeps only the largest connected set of the first two fixed
+              effects listed, and min_degree= prunes their levels with too
+              few distinct partners first (see `connected_components`).
 
     Varying slopes on the streamed dimension: "y ~ x | worker_id[t] + firm_id".
     The worker FE file then has fe_worker_id (intercept) and fe_worker_id[t] (slope)