diff --git a/Examples/Pooling/PartialPoolingExample.ipynb b/Examples/Pooling/PartialPoolingExample.ipynb
new file mode 100644
index 0000000..a19a978
--- /dev/null
+++ b/Examples/Pooling/PartialPoolingExample.ipynb
@@ -0,0 +1,875 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "from plotnine import *\n",
+    "\n",
+    "from vtreat.partial_pooling_estimator import pooled_effect_estimate, standard_effect_estimate\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "rng = np.random.default_rng(2024)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>location_id</th>\n",
+       "      <th>observation</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>loc_48</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>loc_135</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>loc_18</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>loc_42</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>loc_63</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>395</th>\n",
+       "      <td>loc_190</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>396</th>\n",
+       "      <td>loc_133</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>397</th>\n",
+       "      <td>loc_39</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>398</th>\n",
+       "      <td>loc_38</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>399</th>\n",
+       "      <td>loc_38</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>400 rows × 2 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "    location_id  observation\n",
+       "0        loc_48            1\n",
+       "1       loc_135            1\n",
+       "2        loc_18            1\n",
+       "3        loc_42            1\n",
+       "4        loc_63            1\n",
+       "..          ...          ...\n",
+       "395     loc_190            0\n",
+       "396     loc_133            1\n",
+       "397      loc_39            0\n",
+       "398      loc_38            0\n",
+       "399      loc_38            1\n",
+       "\n",
+       "[400 rows x 2 columns]"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "d = pd.DataFrame({\n",
+    "    'location_id': rng.choice([\n",
+    "        f'loc_{i}' for i in range(200)],\n",
+    "        size=400,\n",
+    "        replace=True)\n",
+    "})\n",
+    "d['observation'] = rng.binomial(n=1, p=0.5, size=d.shape[0])\n",
+    "d"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>location_id</th>\n",
+       "      <th>mean</th>\n",
+       "      <th>var</th>\n",
+       "      <th>size</th>\n",
+       "      <th>estimate</th>\n",
+       "      <th>grand_mean</th>\n",
+       "      <th>impact</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>loc_0</td>\n",
+       "      <td>0.500000</td>\n",
+       "      <td>0.500000</td>\n",
+       "      <td>2</td>\n",
+       "      <td>0.500000</td>\n",
+       "      <td>0.5325</td>\n",
+       "      <td>-0.032500</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>loc_1</td>\n",
+       "      <td>0.250000</td>\n",
+       "      <td>0.250000</td>\n",
+       "      <td>4</td>\n",
+       "      <td>0.250000</td>\n",
+       "      <td>0.5325</td>\n",
+       "      <td>-0.282500</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>loc_10</td>\n",
+       "      <td>0.666667</td>\n",
+       "      <td>0.333333</td>\n",
+       "      <td>3</td>\n",
+       "      <td>0.666667</td>\n",
+       "      <td>0.5325</td>\n",
+       "      <td>0.134167</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>loc_101</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>3</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.5325</td>\n",
+       "      <td>-0.532500</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>loc_102</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>1</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>0.5325</td>\n",
+       "      <td>0.467500</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>172</th>\n",
+       "      <td>loc_94</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.5325</td>\n",
+       "      <td>-0.532500</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>173</th>\n",
+       "      <td>loc_95</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.5325</td>\n",
+       "      <td>-0.532500</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>174</th>\n",
+       "      <td>loc_96</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>1</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>0.5325</td>\n",
+       "      <td>0.467500</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>175</th>\n",
+       "      <td>loc_97</td>\n",
+       "      <td>0.625000</td>\n",
+       "      <td>0.267857</td>\n",
+       "      <td>8</td>\n",
+       "      <td>0.625000</td>\n",
+       "      <td>0.5325</td>\n",
+       "      <td>0.092500</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>176</th>\n",
+       "      <td>loc_98</td>\n",
+       "      <td>0.500000</td>\n",
+       "      <td>0.500000</td>\n",
+       "      <td>2</td>\n",
+       "      <td>0.500000</td>\n",
+       "      <td>0.5325</td>\n",
+       "      <td>-0.032500</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>177 rows × 7 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "    location_id      mean       var  size  estimate  grand_mean    impact\n",
+       "0         loc_0  0.500000  0.500000     2  0.500000      0.5325 -0.032500\n",
+       "1         loc_1  0.250000  0.250000     4  0.250000      0.5325 -0.282500\n",
+       "2        loc_10  0.666667  0.333333     3  0.666667      0.5325  0.134167\n",
+       "3       loc_101  0.000000  0.000000     3  0.000000      0.5325 -0.532500\n",
+       "4       loc_102  1.000000       NaN     1  1.000000      0.5325  0.467500\n",
+       "..          ...       ...       ...   ...       ...         ...       ...\n",
+       "172      loc_94  0.000000       NaN     1  0.000000      0.5325 -0.532500\n",
+       "173      loc_95  0.000000       NaN     1  0.000000      0.5325 -0.532500\n",
+       "174      loc_96  1.000000       NaN     1  1.000000      0.5325  0.467500\n",
+       "175      loc_97  0.625000  0.267857     8  0.625000      0.5325  0.092500\n",
+       "176      loc_98  0.500000  0.500000     2  0.500000      0.5325 -0.032500\n",
+       "\n",
+       "[177 rows x 7 columns]"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "r = standard_effect_estimate(d)\n",
+    "\n",
+    "r"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>location_id</th>\n",
+       "      <th>mean</th>\n",
+       "      <th>var</th>\n",
+       "      <th>size</th>\n",
+       "      <th>estimate</th>\n",
+       "      <th>grand_mean</th>\n",
+       "      <th>impact</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>loc_101</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>3</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.5325</td>\n",
+       "      <td>-0.5325</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>loc_102</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>1</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.5325</td>\n",
+       "      <td>0.4675</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>loc_105</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>1</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.5325</td>\n",
+       "      <td>0.4675</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>10</th>\n",
+       "      <td>loc_11</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>1</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.5325</td>\n",
+       "      <td>0.4675</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>12</th>\n",
+       "      <td>loc_111</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>2</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.5325</td>\n",
+       "      <td>-0.5325</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>164</th>\n",
+       "      <td>loc_85</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.5325</td>\n",
+       "      <td>-0.5325</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>170</th>\n",
+       "      <td>loc_92</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>1</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.5325</td>\n",
+       "      <td>0.4675</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>172</th>\n",
+       "      <td>loc_94</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.5325</td>\n",
+       "      <td>-0.5325</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>173</th>\n",
+       "      <td>loc_95</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.5325</td>\n",
+       "      <td>-0.5325</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>174</th>\n",
+       "      <td>loc_96</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>1</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.5325</td>\n",
+       "      <td>0.4675</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>99 rows × 7 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "    location_id  mean  var  size  estimate  grand_mean  impact\n",
+       "3       loc_101   0.0  0.0     3       0.0      0.5325 -0.5325\n",
+       "4       loc_102   1.0  NaN     1       1.0      0.5325  0.4675\n",
+       "6       loc_105   1.0  NaN     1       1.0      0.5325  0.4675\n",
+       "10       loc_11   1.0  NaN     1       1.0      0.5325  0.4675\n",
+       "12      loc_111   0.0  0.0     2       0.0      0.5325 -0.5325\n",
+       "..          ...   ...  ...   ...       ...         ...     ...\n",
+       "164      loc_85   0.0  NaN     1       0.0      0.5325 -0.5325\n",
+       "170      loc_92   1.0  NaN     1       1.0      0.5325  0.4675\n",
+       "172      loc_94   0.0  NaN     1       0.0      0.5325 -0.5325\n",
+       "173      loc_95   0.0  NaN     1       0.0      0.5325 -0.5325\n",
+       "174      loc_96   1.0  NaN     1       1.0      0.5325  0.4675\n",
+       "\n",
+       "[99 rows x 7 columns]"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "r.loc[\n",
+    "    (r['impact'] >= np.max(r['impact']))\n",
+    "    | (r['impact'] <= np.min(r['impact'])),\n",
+    "    :]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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"
+     },
+     "metadata": {
+      "image/png": {
+       "height": 480,
+       "width": 640
+      }
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "(\n",
+    "    ggplot(\n",
+    "        data=r,\n",
+    "        mapping=aes(x='impact'),\n",
+    "    )\n",
+    "    + geom_density()\n",
+    "    + geom_rug()\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>location_id</th>\n",
+       "      <th>mean</th>\n",
+       "      <th>var</th>\n",
+       "      <th>size</th>\n",
+       "      <th>estimate</th>\n",
+       "      <th>grand_mean</th>\n",
+       "      <th>impact</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>loc_0</td>\n",
+       "      <td>0.500000</td>\n",
+       "      <td>0.500000</td>\n",
+       "      <td>2</td>\n",
+       "      <td>0.519000</td>\n",
+       "      <td>0.5325</td>\n",
+       "      <td>-0.013500</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>loc_1</td>\n",
+       "      <td>0.250000</td>\n",
+       "      <td>0.250000</td>\n",
+       "      <td>4</td>\n",
+       "      <td>0.333864</td>\n",
+       "      <td>0.5325</td>\n",
+       "      <td>-0.198636</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>loc_10</td>\n",
+       "      <td>0.666667</td>\n",
+       "      <td>0.333333</td>\n",
+       "      <td>3</td>\n",
+       "      <td>0.611252</td>\n",
+       "      <td>0.5325</td>\n",
+       "      <td>0.078752</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>loc_101</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>3</td>\n",
+       "      <td>0.065500</td>\n",
+       "      <td>0.5325</td>\n",
+       "      <td>-0.467000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>loc_102</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0.786364</td>\n",
+       "      <td>0.5325</td>\n",
+       "      <td>0.253864</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>172</th>\n",
+       "      <td>loc_94</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0.243339</td>\n",
+       "      <td>0.5325</td>\n",
+       "      <td>-0.289161</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>173</th>\n",
+       "      <td>loc_95</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0.243339</td>\n",
+       "      <td>0.5325</td>\n",
+       "      <td>-0.289161</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>174</th>\n",
+       "      <td>loc_96</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0.786364</td>\n",
+       "      <td>0.5325</td>\n",
+       "      <td>0.253864</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>175</th>\n",
+       "      <td>loc_97</td>\n",
+       "      <td>0.625000</td>\n",
+       "      <td>0.267857</td>\n",
+       "      <td>8</td>\n",
+       "      <td>0.608035</td>\n",
+       "      <td>0.5325</td>\n",
+       "      <td>0.075535</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>176</th>\n",
+       "      <td>loc_98</td>\n",
+       "      <td>0.500000</td>\n",
+       "      <td>0.500000</td>\n",
+       "      <td>2</td>\n",
+       "      <td>0.519000</td>\n",
+       "      <td>0.5325</td>\n",
+       "      <td>-0.013500</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>177 rows × 7 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "    location_id      mean       var  size  estimate  grand_mean    impact\n",
+       "0         loc_0  0.500000  0.500000     2  0.519000      0.5325 -0.013500\n",
+       "1         loc_1  0.250000  0.250000     4  0.333864      0.5325 -0.198636\n",
+       "2        loc_10  0.666667  0.333333     3  0.611252      0.5325  0.078752\n",
+       "3       loc_101  0.000000  0.000000     3  0.065500      0.5325 -0.467000\n",
+       "4       loc_102  1.000000       NaN     1  0.786364      0.5325  0.253864\n",
+       "..          ...       ...       ...   ...       ...         ...       ...\n",
+       "172      loc_94  0.000000       NaN     1  0.243339      0.5325 -0.289161\n",
+       "173      loc_95  0.000000       NaN     1  0.243339      0.5325 -0.289161\n",
+       "174      loc_96  1.000000       NaN     1  0.786364      0.5325  0.253864\n",
+       "175      loc_97  0.625000  0.267857     8  0.608035      0.5325  0.075535\n",
+       "176      loc_98  0.500000  0.500000     2  0.519000      0.5325 -0.013500\n",
+       "\n",
+       "[177 rows x 7 columns]"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "r2 = pooled_effect_estimate(d)\n",
+    "\n",
+    "r2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>location_id</th>\n",
+       "      <th>mean</th>\n",
+       "      <th>var</th>\n",
+       "      <th>size</th>\n",
+       "      <th>estimate</th>\n",
+       "      <th>grand_mean</th>\n",
+       "      <th>impact</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>41</th>\n",
+       "      <td>loc_14</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>5</td>\n",
+       "      <td>0.975165</td>\n",
+       "      <td>0.5325</td>\n",
+       "      <td>0.442665</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>65</th>\n",
+       "      <td>loc_165</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>5</td>\n",
+       "      <td>0.028288</td>\n",
+       "      <td>0.5325</td>\n",
+       "      <td>-0.504212</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>155</th>\n",
+       "      <td>loc_74</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>5</td>\n",
+       "      <td>0.975165</td>\n",
+       "      <td>0.5325</td>\n",
+       "      <td>0.442665</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "    location_id  mean  var  size  estimate  grand_mean    impact\n",
+       "41       loc_14   1.0  0.0     5  0.975165      0.5325  0.442665\n",
+       "65      loc_165   0.0  0.0     5  0.028288      0.5325 -0.504212\n",
+       "155      loc_74   1.0  0.0     5  0.975165      0.5325  0.442665"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "r2.loc[\n",
+    "    (r2['impact'] >= np.max(r2['impact']))\n",
+    "    | (r2['impact'] <= np.min(r2['impact'])),\n",
+    "    :]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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"
+     },
+     "metadata": {
+      "image/png": {
+       "height": 480,
+       "width": 640
+      }
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "(\n",
+    "    ggplot(\n",
+    "        data=r2,\n",
+    "        mapping=aes(x='impact'),\n",
+    "    )\n",
+    "    + geom_density()\n",
+    "    + geom_rug()\n",
+    ")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "vtreat_dev_env",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/coverage.txt b/coverage.txt
index fe938bd..e69de29 100644
--- a/coverage.txt
+++ b/coverage.txt
@@ -1,105 +0,0 @@
-============================= test session starts ==============================
-platform darwin -- Python 3.11.5, pytest-7.4.0, pluggy-1.0.0
-rootdir: /Users/johnmount/Documents/work/pyvtreat/pkg
-plugins: anyio-3.5.0, cov-4.1.0
-collected 45 items
-
-pkg/tests/test_KDD2009.py .                                              [  2%]
-pkg/tests/test_ai200_examples.py ..                                      [  6%]
-pkg/tests/test_classification.py ...                                     [ 13%]
-pkg/tests/test_col_name_issues.py ...                                    [ 20%]
-pkg/tests/test_cross_plan_issues.py ..                                   [ 24%]
-pkg/tests/test_db_adapter.py ...                                         [ 31%]
-pkg/tests/test_dup.py .                                                  [ 33%]
-pkg/tests/test_effect_scaler.py ..                                       [ 37%]
-pkg/tests/test_grouped_stats.py .                                        [ 40%]
-pkg/tests/test_id_column_check.py .                                      [ 42%]
-pkg/tests/test_imputation_controls.py .                                  [ 44%]
-pkg/tests/test_logistic_small.py .                                       [ 46%]
-pkg/tests/test_max_levels.py .                                           [ 48%]
-pkg/tests/test_multinomial.py .                                          [ 51%]
-pkg/tests/test_nan_inf.py .                                              [ 53%]
-pkg/tests/test_outcome_name_required.py .                                [ 55%]
-pkg/tests/test_pipeparams.py .                                           [ 57%]
-pkg/tests/test_pooled_calc.py ..                                         [ 62%]
-pkg/tests/test_r1_issue.py .                                             [ 64%]
-pkg/tests/test_range.py .                                                [ 66%]
-pkg/tests/test_regression.py .                                           [ 68%]
-pkg/tests/test_result_restriction.py .                                   [ 71%]
-pkg/tests/test_stats.py .....                                            [ 82%]
-pkg/tests/test_unexepcted_nan.py .                                       [ 84%]
-pkg/tests/test_unsup_perf.py .                                           [ 86%]
-pkg/tests/test_unsupervised.py .                                         [ 88%]
-pkg/tests/test_user_coders.py .                                          [ 91%]
-pkg/tests/test_util.py ..                                                [ 95%]
-pkg/tests/test_xicor.py ..                                               [100%]
-
-=============================== warnings summary ===============================
-../../../opt/anaconda3/envs/vtreat_dev_env/lib/python3.11/site-packages/lark/utils.py:116
-  /Users/johnmount/opt/anaconda3/envs/vtreat_dev_env/lib/python3.11/site-packages/lark/utils.py:116: DeprecationWarning: module 'sre_parse' is deprecated
-    import sre_parse
-
-../../../opt/anaconda3/envs/vtreat_dev_env/lib/python3.11/site-packages/lark/utils.py:117
-  /Users/johnmount/opt/anaconda3/envs/vtreat_dev_env/lib/python3.11/site-packages/lark/utils.py:117: DeprecationWarning: module 'sre_constants' is deprecated
-    import sre_constants
-
-../../../opt/anaconda3/envs/vtreat_dev_env/lib/python3.11/site-packages/google/rpc/__init__.py:18
-  /Users/johnmount/opt/anaconda3/envs/vtreat_dev_env/lib/python3.11/site-packages/google/rpc/__init__.py:18: DeprecationWarning: pkg_resources is deprecated as an API. See https://setuptools.pypa.io/en/latest/pkg_resources.html
-    import pkg_resources
-
-../../../opt/anaconda3/envs/vtreat_dev_env/lib/python3.11/site-packages/pkg_resources/__init__.py:2871
-../../../opt/anaconda3/envs/vtreat_dev_env/lib/python3.11/site-packages/pkg_resources/__init__.py:2871
-../../../opt/anaconda3/envs/vtreat_dev_env/lib/python3.11/site-packages/pkg_resources/__init__.py:2871
-../../../opt/anaconda3/envs/vtreat_dev_env/lib/python3.11/site-packages/pkg_resources/__init__.py:2871
-  /Users/johnmount/opt/anaconda3/envs/vtreat_dev_env/lib/python3.11/site-packages/pkg_resources/__init__.py:2871: DeprecationWarning: Deprecated call to `pkg_resources.declare_namespace('google')`.
-  Implementing implicit namespace packages (as specified in PEP 420) is preferred to `pkg_resources.declare_namespace`. See https://setuptools.pypa.io/en/latest/references/keywords.html#keyword-namespace-packages
-    declare_namespace(pkg)
-
-../../../opt/anaconda3/envs/vtreat_dev_env/lib/python3.11/site-packages/pkg_resources/__init__.py:2871
-../../../opt/anaconda3/envs/vtreat_dev_env/lib/python3.11/site-packages/pkg_resources/__init__.py:2871
-  /Users/johnmount/opt/anaconda3/envs/vtreat_dev_env/lib/python3.11/site-packages/pkg_resources/__init__.py:2871: DeprecationWarning: Deprecated call to `pkg_resources.declare_namespace('google.cloud')`.
-  Implementing implicit namespace packages (as specified in PEP 420) is preferred to `pkg_resources.declare_namespace`. See https://setuptools.pypa.io/en/latest/references/keywords.html#keyword-namespace-packages
-    declare_namespace(pkg)
-
-../../../opt/anaconda3/envs/vtreat_dev_env/lib/python3.11/site-packages/pkg_resources/__init__.py:2350
-../../../opt/anaconda3/envs/vtreat_dev_env/lib/python3.11/site-packages/pkg_resources/__init__.py:2350
-../../../opt/anaconda3/envs/vtreat_dev_env/lib/python3.11/site-packages/pkg_resources/__init__.py:2350
-  /Users/johnmount/opt/anaconda3/envs/vtreat_dev_env/lib/python3.11/site-packages/pkg_resources/__init__.py:2350: DeprecationWarning: Deprecated call to `pkg_resources.declare_namespace('google')`.
-  Implementing implicit namespace packages (as specified in PEP 420) is preferred to `pkg_resources.declare_namespace`. See https://setuptools.pypa.io/en/latest/references/keywords.html#keyword-namespace-packages
-    declare_namespace(parent)
-
-../../../opt/anaconda3/envs/vtreat_dev_env/lib/python3.11/site-packages/pkg_resources/__init__.py:2871
-  /Users/johnmount/opt/anaconda3/envs/vtreat_dev_env/lib/python3.11/site-packages/pkg_resources/__init__.py:2871: DeprecationWarning: Deprecated call to `pkg_resources.declare_namespace('google.logging')`.
-  Implementing implicit namespace packages (as specified in PEP 420) is preferred to `pkg_resources.declare_namespace`. See https://setuptools.pypa.io/en/latest/references/keywords.html#keyword-namespace-packages
-    declare_namespace(pkg)
-
-../../../opt/anaconda3/envs/vtreat_dev_env/lib/python3.11/site-packages/pkg_resources/__init__.py:2871
-  /Users/johnmount/opt/anaconda3/envs/vtreat_dev_env/lib/python3.11/site-packages/pkg_resources/__init__.py:2871: DeprecationWarning: Deprecated call to `pkg_resources.declare_namespace('mpl_toolkits')`.
-  Implementing implicit namespace packages (as specified in PEP 420) is preferred to `pkg_resources.declare_namespace`. See https://setuptools.pypa.io/en/latest/references/keywords.html#keyword-namespace-packages
-    declare_namespace(pkg)
-
-../../../opt/anaconda3/envs/vtreat_dev_env/lib/python3.11/site-packages/google/rpc/__init__.py:20
-  /Users/johnmount/opt/anaconda3/envs/vtreat_dev_env/lib/python3.11/site-packages/google/rpc/__init__.py:20: DeprecationWarning: Deprecated call to `pkg_resources.declare_namespace('google.rpc')`.
-  Implementing implicit namespace packages (as specified in PEP 420) is preferred to `pkg_resources.declare_namespace`. See https://setuptools.pypa.io/en/latest/references/keywords.html#keyword-namespace-packages
-    pkg_resources.declare_namespace(__name__)
-
--- Docs: https://docs.pytest.org/en/stable/how-to/capture-warnings.html
-
----------- coverage: platform darwin, python 3.11.5-final-0 ----------
-Name                                      Stmts   Miss  Cover
--------------------------------------------------------------
-pkg/vtreat/__init__.py                        6      0   100%
-pkg/vtreat/cross_plan.py                     50      1    98%
-pkg/vtreat/effect_scaler.py                  59      4    93%
-pkg/vtreat/partial_pooling_estimator.py      34      0   100%
-pkg/vtreat/stats_utils.py                   132      0   100%
-pkg/vtreat/test_util.py                      84     18    79%
-pkg/vtreat/transform.py                      14      0   100%
-pkg/vtreat/util.py                          149      8    95%
-pkg/vtreat/vtreat_api.py                    285     34    88%
-pkg/vtreat/vtreat_db_adapter.py              69      0   100%
-pkg/vtreat/vtreat_impl.py                   711     61    91%
--------------------------------------------------------------
-TOTAL                                      1593    126    92%
-
-================= 45 passed, 15 warnings in 163.97s (0:02:43) ==================
diff --git a/pkg/build/lib/vtreat/__init__.py b/pkg/build/lib/vtreat/__init__.py
index 3403c9f..8b44a97 100644
--- a/pkg/build/lib/vtreat/__init__.py
+++ b/pkg/build/lib/vtreat/__init__.py
@@ -8,7 +8,14 @@
 # noinspection PyUnresolvedReferences
 import numpy
 
-from vtreat.vtreat_api import unsupervised_parameters, vtreat_parameters, BinomialOutcomeTreatment, MultinomialOutcomeTreatment, NumericOutcomeTreatment, UnsupervisedTreatment
+from vtreat.vtreat_api import (
+    unsupervised_parameters,
+    vtreat_parameters,
+    BinomialOutcomeTreatment,
+    MultinomialOutcomeTreatment,
+    NumericOutcomeTreatment,
+    UnsupervisedTreatment,
+)
 
 
 __docformat__ = "restructuredtext"
diff --git a/pkg/build/lib/vtreat/da_adapter.py b/pkg/build/lib/vtreat/da_adapter.py
new file mode 100644
index 0000000..32c99c6
--- /dev/null
+++ b/pkg/build/lib/vtreat/da_adapter.py
@@ -0,0 +1,296 @@
+"""
+Convert the description of a vtreat variable treatment into a data algebra pipeline.
+"""
+
+from typing import Dict, Iterable, List, Optional, Tuple
+import numpy
+import pandas
+
+from vtreat.vtreat_impl import bad_sentinel, replace_bad_with_sentinel
+
+from data_algebra import pivot_specification, unpivot_specification
+from data_algebra.data_ops import (
+    data,
+    descr,
+    describe_table,
+
+    TableDescription,
+    ViewRepresentation,
+)
+
+
+def def_multi_column_map(
+    d: ViewRepresentation,
+    *,
+    mapping_table: ViewRepresentation,
+    row_keys: Iterable[str],
+    col_name_key: str = "column_name",
+    col_value_key: str = "column_value",
+    mapped_value_key: str = "mapped_value",
+    cols_to_map: Iterable[str],
+    coalesce_value=None,
+    cols_to_map_back: Optional[Iterable[str]] = None,
+) -> ViewRepresentation:
+    """
+    Map all columns in list cols_to_map through the mapping in mapping table (key by column name and value).
+    d should be uniquely keyed by row_keys, and mapping table should be uniquely keyed by [col_name_key, col_value_key].
+
+    :param d: view to re-map
+    :param mapping_table: view to get mappings from
+    :param row_keys: columns that uniquely identify rows in d
+    :param col_name_key: column name specifying columns in mapping_table
+    :param col_value_key: column name specifying pre-map values in mapping table
+    :param mapped_value_key: column name specifying post-map values in mapping table
+    :param cols_to_map: columns to re-map.
+    :param coalesce_value: if not None, coalesce to this value
+    :param cols_to_map_back: if not None new names for resulting columns
+    :return: operations specifying how to re-map DataFrame
+    """
+    assert not isinstance(row_keys, str)
+    row_keys = list(row_keys)
+    assert len(row_keys) > 0
+    assert not isinstance(cols_to_map, str)
+    cols_to_map = list(cols_to_map)
+    assert len(cols_to_map) > 0
+    assert isinstance(col_name_key, str)
+    assert isinstance(col_value_key, str)
+    assert isinstance(mapped_value_key, str)
+    if cols_to_map_back is not None:
+        assert not isinstance(cols_to_map_back, str)
+        cols_to_map_back = list(cols_to_map_back)
+        assert len(cols_to_map_back) == len(cols_to_map)
+    pre_col_names = row_keys + cols_to_map
+    assert len(pre_col_names) == len(set(pre_col_names))
+    mid_col_names = row_keys + [col_name_key, col_value_key, mapped_value_key]
+    assert len(mid_col_names) == len(set(mid_col_names))
+    if cols_to_map_back is None:
+        post_col_names = row_keys + cols_to_map
+    else:
+        post_col_names = row_keys + cols_to_map_back
+    assert len(post_col_names) == len(set(post_col_names))
+    record_map_to = None
+    record_map_back = None
+    if len(cols_to_map) > 1:
+        record_map_to = unpivot_specification(
+            row_keys=row_keys,
+            col_name_key=col_name_key,
+            col_value_key=col_value_key,
+            value_cols=cols_to_map,
+        )
+        record_map_back = pivot_specification(
+            row_keys=row_keys,
+            col_name_key=col_name_key,
+            col_value_key=mapped_value_key,
+            value_cols=cols_to_map,
+        )
+    ops = d.select_columns(row_keys + cols_to_map)
+    if record_map_to is not None:
+        ops = ops.convert_records(record_map_to)
+    else:
+        ops = (
+            ops
+                .map_columns({cols_to_map[0]: col_value_key})
+                .extend({'orig_var': repr(cols_to_map[0])})
+        )
+    ops = (
+        ops
+            .natural_join(
+                b=mapping_table.select_columns(
+                    [col_name_key, col_value_key, mapped_value_key]
+                ),
+                jointype="left",
+                on=[col_name_key, col_value_key],
+            )
+    )
+    if coalesce_value is not None:
+        ops = ops.extend(
+            {mapped_value_key: f"{mapped_value_key}.coalesce({coalesce_value})"}
+        )
+    if record_map_back is not None:
+        ops = ops.convert_records(record_map_back)
+    else:
+        ops = (
+            ops
+                .drop_columns(['value', 'orig_var'])
+                .map_columns({'replacement': cols_to_map[0]})
+        )
+    if cols_to_map_back is not None:
+        # could do this in the record mapping, but this seems easier to read
+        ops = ops.rename_columns(
+            {
+                new_name: old_name
+                for new_name, old_name in zip(cols_to_map_back, cols_to_map)
+            }
+        )
+    return ops
+
+
+def _check_treatment_table(vtreat_descr: pandas.DataFrame):
+    """
+    Assert if expected invariants don't hold for vtreat_descr.
+
+    :param vtreat_descr: .description_matrix() description of a transform to check.
+    :return: no return, assert on failure
+    """
+
+    # belt and suspenders replace missing with sentinel
+    vtreat_descr = vtreat_descr.copy()
+    vtreat_descr["value"] = replace_bad_with_sentinel(vtreat_descr["value"])
+    # check our expected invariants
+    assert isinstance(vtreat_descr, pandas.DataFrame)
+    # numeric is a function of original variable only
+    check_fn_relnn = (
+        data(vtreat_descr=vtreat_descr)
+        .project({}, group_by=["orig_var", "orig_was_numeric"])
+        .extend({"one": 1})
+        .project({"count": "one.sum()"}, group_by=["orig_var"])
+    ).ex()
+    assert numpy.all(check_fn_relnn["count"] == 1)
+    # variable consumed is function of variable produced and treatment only
+    check_fn_reln2 = (
+        data(vtreat_descr=vtreat_descr)
+        .project({}, group_by=["treatment", "orig_var", "variable"])
+        .extend({"one": 1})
+        .project({"count": "one.sum()"}, group_by=["treatment", "variable"])
+    ).ex()
+    assert numpy.all(check_fn_reln2["count"] == 1)
+    # clean copies don't change variable names
+    cn_rows = vtreat_descr.loc[
+        vtreat_descr["treatment_class"] == "CleanNumericTransform", :
+    ].reset_index(inplace=False, drop=True)
+    assert numpy.all(cn_rows["variable"] == cn_rows["orig_var"])
+    # operations other than clean copy produce new variable names
+    ot_rows = vtreat_descr.loc[
+        vtreat_descr["treatment_class"] != "CleanNumericTransform", :
+    ].reset_index(inplace=False, drop=True)
+    assert len(set(ot_rows["variable"]).intersection(vtreat_descr["orig_var"])) == 0
+    # clean copy and re-mapping take disjoint inputs (one alters input as a prep-step, so they would interfere)
+    mp_rows = (
+        data(vtreat_descr=vtreat_descr)
+        .select_rows("treatment_class == 'MappedCodeTransform'")
+        .project({}, group_by=["orig_var", "variable"])
+        .order_rows(["orig_var", "variable"])
+    ).ex()
+    assert len(set(mp_rows["orig_var"]).intersection(cn_rows["orig_var"])) == 0
+
+
+def as_data_algebra_pipeline(
+    *,
+    source: TableDescription,
+    vtreat_descr: pandas.DataFrame,
+    treatment_table_name: str,
+    row_keys: Iterable[str],
+) -> ViewRepresentation:
+    """
+    Convert the description of a vtreat transform (gotten via .description_matrix())
+    into a data algebra pipeline.
+    See: https://github.com/WinVector/data_algebra and https://github.com/WinVector/pyvtreat .
+    Missing and nan are treated as synonyms for '_NA_'.
+    Assembling the entire pipeline can be expensive. If one is willing to instantiate tables
+    it can be better to sequence operations instead of composing them.
+    Another way to use this methodology would be to port this code as a stored procedure
+    in a target database of choice, meaning only the vtreat_descr table would be needed on such systems.
+
+    :param source: input data.
+    :param vtreat_descr: .description_matrix() description of transform.
+                         Expected invariant: CleanNumericTransform doesn't change variable names,
+                         all other operations produce new names.
+    :param treatment_table_name: name to use for the vtreat_descr table.
+    :param row_keys: list of columns uniquely keying rows
+    :return: data algebra pipeline implementing specified vtreat treatment
+    """
+
+    assert isinstance(source, TableDescription)
+    assert isinstance(vtreat_descr, pandas.DataFrame)
+    assert isinstance(treatment_table_name, str)
+    assert row_keys is not None
+    assert not isinstance(row_keys, str)
+    row_keys = list(row_keys)
+    assert len(row_keys) > 0
+    assert numpy.all([isinstance(v, str) for v in row_keys])
+
+    _check_treatment_table(vtreat_descr)
+    # belt and suspenders replace missing with sentinel
+    vtreat_descr = vtreat_descr.copy()
+    vtreat_descr["value"] = replace_bad_with_sentinel(vtreat_descr["value"])
+    # start building up operator pipeline
+    ops = source
+    step_1_ops = dict()
+    # add in is_bad indicators
+    im_rows = vtreat_descr.loc[
+        vtreat_descr["treatment_class"] == "IndicateMissingTransform", :
+    ].reset_index(inplace=False, drop=True)
+    for i in range(im_rows.shape[0]):
+        if im_rows["orig_was_numeric"][i]:
+            step_1_ops[
+                im_rows["variable"][i]
+            ] = f"{im_rows['orig_var'][i]}.is_bad().where(1.0, 0.0)"
+        else:
+            step_1_ops[
+                im_rows["variable"][i]
+            ] = f"({im_rows['orig_var'][i]}.coalesce('{bad_sentinel}') == '{bad_sentinel}').where(1.0, 0.0)"
+    # add in general value indicators or dummies, all indicators are non-numeric (string)
+    ic_rows = vtreat_descr.loc[
+        vtreat_descr["treatment_class"] == "IndicatorCodeTransform", :
+    ].reset_index(inplace=False, drop=True)
+    for i in range(ic_rows.shape[0]):
+        ov = ic_rows["orig_var"].values[i]
+        vi = ic_rows["value"].values[i]
+        step_1_ops[
+            ic_rows["variable"][i]
+        ] = f"({ov}.coalesce('{bad_sentinel}') == '{vi}').where(1.0, 0.0)"
+    if len(step_1_ops) > 0:
+        ops = ops.extend(step_1_ops)
+    # mapped columns
+    mapping_table = (
+        describe_table(vtreat_descr, table_name=treatment_table_name)
+        .select_rows('treatment_class == "MappedCodeTransform"')
+        .select_columns(["orig_var", "value", "replacement", "treatment"])
+    )
+    mapping_rows = mapping_table.transform(vtreat_descr)
+    if mapping_rows.shape[0] > 0:
+        groups = list(set(mapping_rows["treatment"]))
+        mapping_rows = mapping_rows.groupby("treatment")
+        for group_name in groups:
+            mg = mapping_rows.get_group(group_name)
+            if mg.shape[0] > 0:
+                cols_to_map = list(set(mg["orig_var"]))
+                cols_to_map_back = [f"{c}_{group_name}" for c in cols_to_map]
+                ops_g = def_multi_column_map(
+                    source.extend(
+                        {v: f"{v}.coalesce('{bad_sentinel}')" for v in cols_to_map}
+                    ),
+                    mapping_table=mapping_table.select_rows(
+                        f'treatment == "{group_name}"'
+                    ),
+                    row_keys=row_keys,
+                    cols_to_map=cols_to_map,
+                    cols_to_map_back=cols_to_map_back,
+                    coalesce_value=0.0,
+                    col_name_key="orig_var",
+                    col_value_key="value",
+                    mapped_value_key="replacement",
+                )
+                ops = ops.natural_join(
+                    b=ops_g,
+                    by=row_keys,
+                    jointype="left",
+                )
+    # add in any clean numeric copies, inputs are numeric- so disjoint of categorical processing
+    cn_rows = vtreat_descr.loc[
+        vtreat_descr["treatment_class"] == "CleanNumericTransform", :
+    ].reset_index(inplace=False, drop=True)
+    if cn_rows.shape[0] > 0:
+        step_3_exprs = dict()
+        for i in range(cn_rows.shape[0]):
+            step_3_exprs[
+                cn_rows["variable"][i]
+            ] = f"{cn_rows['orig_var'][i]}.coalesce({cn_rows['replacement'][i]})"
+        ops = ops.extend(step_3_exprs)
+    # remove any input variables that are not the same name as variables we produced
+    # this prevents non-numerics from leaking forward
+    to_del = list(set(vtreat_descr["orig_var"]) - set(vtreat_descr["variable"]))
+    if len(to_del) > 0:
+        to_del.sort()
+        ops = ops.drop_columns(to_del)
+    return ops
diff --git a/pkg/build/lib/vtreat/effect_scaler.py b/pkg/build/lib/vtreat/effect_scaler.py
index a9e45df..ec52fd8 100644
--- a/pkg/build/lib/vtreat/effect_scaler.py
+++ b/pkg/build/lib/vtreat/effect_scaler.py
@@ -1,4 +1,3 @@
-
 import numpy as np
 import pandas as pd
 
@@ -80,14 +79,20 @@ def transform_col(i: int, *, xi: np.ndarray) -> np.ndarray:
         if isinstance(X, pd.DataFrame):
             if self._colnames is not None:
                 assert list(X.columns) == self._colnames
-            return pd.DataFrame({
-                c: transform_col(i, xi=np.array(X.loc[:, c], float)) for i, c in zip(range(X.shape[1]), X.columns)
-            })
+            return pd.DataFrame(
+                {
+                    c: transform_col(i, xi=np.array(X.loc[:, c], float))
+                    for i, c in zip(range(X.shape[1]), X.columns)
+                }
+            )
         else:
-            return pd.DataFrame({
-                i: transform_col(i, xi=np.array(X[:, i], float)) for i in range(X.shape[1])
-            })
-    
+            return pd.DataFrame(
+                {
+                    i: transform_col(i, xi=np.array(X[:, i], float))
+                    for i in range(X.shape[1])
+                }
+            )
+
     # noinspection PyPep8Naming
     def predict(self, X) -> pd.DataFrame:
         return self.transform(X)
diff --git a/pkg/build/lib/vtreat/partial_pooling_estimator.py b/pkg/build/lib/vtreat/partial_pooling_estimator.py
index b807cfd..61fb474 100644
--- a/pkg/build/lib/vtreat/partial_pooling_estimator.py
+++ b/pkg/build/lib/vtreat/partial_pooling_estimator.py
@@ -1,10 +1,7 @@
-
-
 import numpy as np
 import pandas as pd
 
 
-
 # define the standard estimator
 def standard_effect_estimate(observations: pd.DataFrame) -> pd.DataFrame:
     """
@@ -17,13 +14,15 @@ def standard_effect_estimate(observations: pd.DataFrame) -> pd.DataFrame:
     assert isinstance(observations, pd.DataFrame)
     means = (
         observations.loc[:, ["location_id", "observation"]]
-            .reset_index(drop=True, inplace=False)
-            .groupby(["location_id"])
-            .mean()
-            .reset_index(drop=False, inplace=False)
+        .reset_index(drop=True, inplace=False)
+        .groupby(["location_id"])
+        .agg(['mean', 'var', 'size'])
+        .reset_index(drop=False, inplace=False)
     )
+    cols = [' '.join(col).strip() for col in means.columns]
+    means.columns = [c.removeprefix('observation ') for c in cols]
     means.sort_values(["location_id"], inplace=True, ignore_index=True)
-    means.rename(columns={"observation": "estimate"}, inplace=True)
+    means['estimate'] = means['mean']
     means["grand_mean"] = np.mean(observations["observation"])
     means["impact"] = means["estimate"] - means["grand_mean"]
     means.sort_values(["location_id"], inplace=True, ignore_index=True)
@@ -40,69 +39,38 @@ def pooled_effect_estimate(observations: pd.DataFrame) -> pd.DataFrame:
     :return: pooled estimates
     """
     assert isinstance(observations, pd.DataFrame)
-    observations = observations.loc[:, ["location_id", "observation"]].reset_index(inplace=False, drop=True)
+    observations = observations.loc[:, ["location_id", "observation"]].reset_index(
+        inplace=False, drop=True
+    )
     # get the standard estimates
     estimated_centers = standard_effect_estimate(observations=observations)
     if estimated_centers.shape[0] <= 1:
         # no pooling possible
         return estimated_centers
     # get counts per group
-    obs_count_frame = (
-        pd.DataFrame({"location_id": observations["location_id"], "count": 1})
-            .groupby(["location_id"])
-            .sum()
-            .reset_index(drop=False, inplace=False)
-            .sort_values(["location_id"], inplace=False, ignore_index=True)
-    )
-    n_j = obs_count_frame["count"].values
-    # get the observed variance for each item at for each location
-    combined = (
-        observations
-            .merge(
-                estimated_centers,
-                on=["location_id"],
-                how="left",
-                )
-            .merge(
-                obs_count_frame,
-                on=["location_id"],
-                how="left",
-                )
-    )
-    combined.sort_values(["location_id"], inplace=True, ignore_index=True)
-    per_location_observation_var = (
-        np.sum((combined["observation"] - combined["estimate"])**2) 
-        / (combined.shape[0] - len(set(combined["location_id"])))
-    )
+    n_j = estimated_centers["size"]
+    per_location_observation_var = estimated_centers['var'].copy()
+    # inflate a bit
+    per_location_observation_var[pd.isnull(per_location_observation_var)] = 0
+    per_location_observation_var = (n_j * per_location_observation_var + np.var(observations['observation'])) / (n_j + 1)
     # get the observed variance between locations
     between_location_var = np.var(estimated_centers["estimate"], ddof=1)
     # get v, the pooling coefficient
     if between_location_var <= 0:
-        v = 0
-    elif per_location_observation_var <= 0:
-        v = 1
+        v = 0 * per_location_observation_var
     else:
         # as between_location_var > 0 and per_location_observation_var > 0 here
         # v will be in the range 0 to 1
         v = 1 / (1 + per_location_observation_var / (n_j * between_location_var))
-    # our estimate of the overall shared effect
-    # note we are using the mixing proportions suggested by the variance reduction ideas
-    # simpler weightings include:
-    #   combined["obs_weight"] = 1   # weights all observations equally
-    #   combined["obs_weight"] = 1 / combined["count"]  # weights all locations equally
-    # below, weights larger observations groups more, but with a diminishing return
-    # this is an ad-hoc heuristic to try to reduce square error when the number of 
-    # observations per location has a lot of variation
-    combined["obs_weight"] = 1
-    if (between_location_var > 0) and (per_location_observation_var > 0):
-        combined["obs_weight"] = 1 / (1 + per_location_observation_var / (combined["count"] * between_location_var))
     # this quantity can be improved using knowledge of the variances
-    grand_mean = np.sum(combined["observation"] * combined["obs_weight"]) / np.sum(combined["obs_weight"])
+    grand_mean = estimated_centers['grand_mean']
     # build the pooled estimate
     pooled_estimate = v * estimated_centers["estimate"] + (1 - v) * grand_mean
-    return pd.DataFrame({
-        "location_id": estimated_centers["location_id"],
-        "estimate": pooled_estimate,
-        "grand_mean": grand_mean,
-        "impact": pooled_estimate - grand_mean,
-    })
+    return pd.DataFrame(
+        {
+            "location_id": estimated_centers["location_id"],
+            "estimate": pooled_estimate,
+            "grand_mean": grand_mean,
+            "impact": pooled_estimate - grand_mean,
+        }
+    )
diff --git a/pkg/build/lib/vtreat/stats_utils.py b/pkg/build/lib/vtreat/stats_utils.py
index 1559b3f..839e164 100644
--- a/pkg/build/lib/vtreat/stats_utils.py
+++ b/pkg/build/lib/vtreat/stats_utils.py
@@ -182,7 +182,7 @@ def xicor(xvec, yvec, *, n_reps: int = 5) -> Tuple[float, float]:
         PI[perm] = PI_inv  # invert permutation, self assignment fails
         ord = numpy.argsort(PI)
         fr = fr_orig[ord]
-        A1 = numpy.sum(numpy.abs(fr[0:(n - 1)] - fr[1:n])) / (2 * n)
+        A1 = numpy.sum(numpy.abs(fr[0 : (n - 1)] - fr[1:n])) / (2 * n)
         xi = 1 - A1 / CU
         xi_s[rep_i] = xi
     return numpy.mean(xi_s), numpy.std(xi_s) / numpy.sqrt(n_reps)
@@ -207,21 +207,23 @@ def xicor_for_frame(d: pandas.DataFrame, y, *, n_reps=5):
     assert len(y) == n
     assert isinstance(n_reps, int)
     assert n_reps > 0
-    res = pandas.DataFrame({
-        'variable': d.columns,
-        'xicor': 0.0,
-        'xicor_se': 0.0,
-        'xicor_perm_mean': 0.0,
-        'xicor_perm_stddev': 0.0,
-        'xicor_perm_sum': 0.0,
-        'xicor_perm_sum_sq': 0.0,
-    })
+    res = pandas.DataFrame(
+        {
+            "variable": d.columns,
+            "xicor": 0.0,
+            "xicor_se": 0.0,
+            "xicor_perm_mean": 0.0,
+            "xicor_perm_stddev": 0.0,
+            "xicor_perm_sum": 0.0,
+            "xicor_perm_sum_sq": 0.0,
+        }
+    )
     # get the xicor estimates
     for col_i in range(len(d.columns)):
         xvec = d[d.columns[col_i]]
         xi_est, xi_est_dev = xicor(xvec, y, n_reps=n_reps)
-        res.loc[col_i, 'xicor'] = xi_est
-        res.loc[col_i, 'xicor_se'] = xi_est_dev
+        res.loc[col_i, "xicor"] = xi_est
+        res.loc[col_i, "xicor_se"] = xi_est_dev
     # score all x-columns with the same y-permutation
     # estimate stddev with expanding squares to cut down storage
     for rep_j in range(n_reps):
@@ -229,11 +231,17 @@ def xicor_for_frame(d: pandas.DataFrame, y, *, n_reps=5):
         for col_i in range(len(d.columns)):
             xvec = d[d.columns[col_i]]
             xi_perm, _ = xicor(xvec, y_perm, n_reps=1)
-            res.loc[col_i, 'xicor_perm_sum'] = res.loc[col_i, 'xicor_perm_sum'] + xi_perm
-            res.loc[col_i, 'xicor_perm_sum_sq'] = res.loc[col_i, 'xicor_perm_sum_sq'] + xi_perm * xi_perm
-    res['xicor_perm_mean'] = res['xicor_perm_sum'] / n_reps
-    res['xicor_perm_stddev'] = numpy.sqrt((1 / (n_reps - 1)) * (
-            res['xicor_perm_sum_sq'] - (1 / n_reps) * res['xicor_perm_sum']**2))
-    del res['xicor_perm_sum']
-    del res['xicor_perm_sum_sq']
+            res.loc[col_i, "xicor_perm_sum"] = (
+                res.loc[col_i, "xicor_perm_sum"] + xi_perm
+            )
+            res.loc[col_i, "xicor_perm_sum_sq"] = (
+                res.loc[col_i, "xicor_perm_sum_sq"] + xi_perm * xi_perm
+            )
+    res["xicor_perm_mean"] = res["xicor_perm_sum"] / n_reps
+    res["xicor_perm_stddev"] = numpy.sqrt(
+        (1 / (n_reps - 1))
+        * (res["xicor_perm_sum_sq"] - (1 / n_reps) * res["xicor_perm_sum"] ** 2)
+    )
+    del res["xicor_perm_sum"]
+    del res["xicor_perm_sum_sq"]
     return res
diff --git a/pkg/build/lib/vtreat/test_util.py b/pkg/build/lib/vtreat/test_util.py
index 341a34e..41699b9 100644
--- a/pkg/build/lib/vtreat/test_util.py
+++ b/pkg/build/lib/vtreat/test_util.py
@@ -6,8 +6,6 @@
 import pandas as pd
 
 
-
-
 def equivalent_frames(
     a: pd.DataFrame,
     b: pd.DataFrame,
@@ -93,9 +91,7 @@ def equivalent_frames(
                     if np.any(ca_inf != cb_inf):
                         return False
                     if np.any(ca_inf):
-                        if np.any(
-                            np.sign(ca_n[ca_inf]) != np.sign(cb_n[cb_inf])
-                        ):
+                        if np.any(np.sign(ca_n[ca_inf]) != np.sign(cb_n[cb_inf])):
                             return False
                     if np.any(np.logical_not(ca_inf)):
                         ca_f = ca_n[np.logical_not(ca_inf)]
diff --git a/pkg/build/lib/vtreat/util.py b/pkg/build/lib/vtreat/util.py
index cf7dd0e..8412961 100644
--- a/pkg/build/lib/vtreat/util.py
+++ b/pkg/build/lib/vtreat/util.py
@@ -38,7 +38,7 @@ def can_convert_v_to_numeric(x) -> bool:
     not_bad = numpy.logical_not(pandas.isnull(x))
     n_not_bad = numpy.sum(not_bad)
     if n_not_bad < 1:
-        return True   # All nan/None, can convert to numeric
+        return True  # All nan/None, can convert to numeric
     try:
         numpy.asarray(
             x[not_bad] + 0, dtype=float
@@ -152,21 +152,24 @@ def pooled_impact_estimate(x, y):
     n = len(x)
     assert n > 0
     assert n == len(y)
-    obs = pandas.DataFrame({
-        "location_id": x,
-        "observation": safe_to_numeric_array(y),
-    })
+    obs = pandas.DataFrame(
+        {
+            "location_id": x,
+            "observation": safe_to_numeric_array(y),
+        }
+    )
     res = pooled_effect_estimate(obs)
     res.rename(columns={"location_id": "x"}, inplace=True)
     return res
 
 
 def score_variables(
-        cross_frame: pandas.DataFrame,
-        *,
-        variables: Optional[Iterable[str]],
-        outcome,
-        is_classification: bool = False) -> Optional[pandas.DataFrame]:
+    cross_frame: pandas.DataFrame,
+    *,
+    variables: Optional[Iterable[str]],
+    outcome,
+    is_classification: bool = False
+) -> Optional[pandas.DataFrame]:
     """
     Score the linear relation of variables to outcome.
 
@@ -200,7 +203,7 @@ def f(v):
             and (numpy.max(outcome) > numpy.min(outcome))
         ):
             cor, sig = vtreat.stats_utils.our_corr_score(y_true=outcome, y_pred=col)
-            r2 = cor ** 2
+            r2 = cor**2
             if is_classification:
                 r2, sig = vtreat.stats_utils.our_pseudo_R2(y_true=outcome, y_pred=col)
             sfi = pandas.DataFrame(
@@ -283,7 +286,7 @@ def clean_string(s: str) -> str:
     }
     s = s.strip()
     s = re.sub(r"\s+", " ", s)
-    for (k, v) in mp.items():
+    for k, v in mp.items():
         s = s.replace(k, v)
     return s
 
diff --git a/pkg/build/lib/vtreat/vtreat_api.py b/pkg/build/lib/vtreat/vtreat_api.py
index 914ac94..6d18056 100644
--- a/pkg/build/lib/vtreat/vtreat_api.py
+++ b/pkg/build/lib/vtreat/vtreat_api.py
@@ -108,11 +108,11 @@ def __init__(
     ):
         """
 
-         :param var_list: list or tuple of column names, if empty all non outcome and copy columns are used
-         :param outcome_name: name of column containing dependent variable
-         :param cols_to_copy: list or tuple of column names
-         :param params: vtreat.vtreat_parameters()
-         :param imputation_map: map of column names to custom missing imputation values or functions
+        :param var_list: list or tuple of column names, if empty all non outcome and copy columns are used
+        :param outcome_name: name of column containing dependent variable
+        :param cols_to_copy: list or tuple of column names
+        :param params: vtreat.vtreat_parameters()
+        :param imputation_map: map of column names to custom missing imputation values or functions
         """
         params = self.merge_params(params)
         vtreat_impl.VariableTreatment.__init__(
@@ -304,12 +304,12 @@ def __init__(
     ):
         """
 
-         :param var_list: list or tuple of column names, if empty all non outcome and copy columns are used
-         :param outcome_name: name of column containing dependent variable
-         :param outcome_target: value of outcome to consider "positive"
-         :param cols_to_copy: list or tuple of column names
-         :param params: vtreat.vtreat_parameters()
-         :param imputation_map: map of column names to custom missing imputation values or functions
+        :param var_list: list or tuple of column names, if empty all non outcome and copy columns are used
+        :param outcome_name: name of column containing dependent variable
+        :param outcome_target: value of outcome to consider "positive"
+        :param cols_to_copy: list or tuple of column names
+        :param params: vtreat.vtreat_parameters()
+        :param imputation_map: map of column names to custom missing imputation values or functions
         """
         params = self.merge_params(params)
         vtreat_impl.VariableTreatment.__init__(
@@ -502,11 +502,11 @@ def __init__(
     ):
         """
 
-         :param var_list: list or tuple of column names, if empty all non outcome and copy columns are used
-         :param outcome_name: name of column containing dependent variable
-         :param cols_to_copy: list or tuple of column names
-         :param params: vtreat.vtreat_parameters()
-         :param imputation_map: map of column names to custom missing imputation values or functions
+        :param var_list: list or tuple of column names, if empty all non outcome and copy columns are used
+        :param outcome_name: name of column containing dependent variable
+        :param cols_to_copy: list or tuple of column names
+        :param params: vtreat.vtreat_parameters()
+        :param imputation_map: map of column names to custom missing imputation values or functions
         """
 
         params = self.merge_params(params)
diff --git a/pkg/build/lib/vtreat/vtreat_db_adapter.py b/pkg/build/lib/vtreat/vtreat_db_adapter.py
index d222ebc..c11effd 100644
--- a/pkg/build/lib/vtreat/vtreat_db_adapter.py
+++ b/pkg/build/lib/vtreat/vtreat_db_adapter.py
@@ -1,178 +1 @@
-"""
-Convert the description of a vtreat variable treatment into a data algebra pipeline.
-"""
-
-from typing import Dict, Iterable, List, Optional, Tuple
-import numpy
-import pandas
-
-from vtreat.vtreat_impl import bad_sentinel, replace_bad_with_sentinel
-
-from data_algebra.data_ops import data, descr, describe_table, TableDescription, ViewRepresentation
-from data_algebra.solutions import def_multi_column_map
-
-
-def _check_treatment_table(vtreat_descr: pandas.DataFrame):
-    """
-    Assert if expected invariants don't hold for vtreat_descr.
-
-    :param vtreat_descr: .description_matrix() description of a transform to check.
-    :return: no return, assert on failure
-    """
-
-    # belt and suspenders replace missing with sentinel
-    vtreat_descr = vtreat_descr.copy()
-    vtreat_descr["value"] = replace_bad_with_sentinel(vtreat_descr["value"])
-    # check our expected invariants
-    assert isinstance(vtreat_descr, pandas.DataFrame)
-    # numeric is a function of original variable only
-    check_fn_relnn = (
-        data(vtreat_descr=vtreat_descr)
-            .project({}, group_by=["orig_var", "orig_was_numeric"])
-            .extend({"one": 1})
-            .project({"count": "one.sum()"}, group_by=["orig_var"])
-    ).ex()
-    assert numpy.all(check_fn_relnn["count"] == 1)
-    # variable consumed is function of variable produced and treatment only
-    check_fn_reln2 = (
-        data(vtreat_descr=vtreat_descr)
-            .project({}, group_by=["treatment", "orig_var", "variable"])
-            .extend({"one": 1})
-            .project({"count": "one.sum()"}, group_by=["treatment", "variable"])
-    ).ex()
-    assert numpy.all(check_fn_reln2["count"] == 1)
-    # clean copies don't change variable names
-    cn_rows = vtreat_descr.loc[
-        vtreat_descr["treatment_class"] == "CleanNumericTransform", :
-    ].reset_index(inplace=False, drop=True)
-    assert numpy.all(cn_rows["variable"] == cn_rows["orig_var"])
-    # operations other than clean copy produce new variable names
-    ot_rows = vtreat_descr.loc[
-        vtreat_descr["treatment_class"] != "CleanNumericTransform", :
-    ].reset_index(inplace=False, drop=True)
-    assert len(set(ot_rows["variable"]).intersection(vtreat_descr["orig_var"])) == 0
-    # clean copy and re-mapping take disjoint inputs (one alters input as a prep-step, so they would interfere)
-    mp_rows = (
-        data(vtreat_descr=vtreat_descr)
-        .select_rows("treatment_class == 'MappedCodeTransform'")
-        .project({}, group_by=["orig_var", "variable"])
-        .order_rows(["orig_var", "variable"])
-    ).ex()
-    assert len(set(mp_rows["orig_var"]).intersection(cn_rows["orig_var"])) == 0
-
-
-def as_data_algebra_pipeline(
-    *,
-    source: TableDescription,
-    vtreat_descr: pandas.DataFrame,
-    treatment_table_name: str,
-    row_keys: Iterable[str],
-) -> ViewRepresentation:
-    """
-    Convert the description of a vtreat transform (gotten via .description_matrix())
-    into a data algebra pipeline.
-    See: https://github.com/WinVector/data_algebra and https://github.com/WinVector/pyvtreat .
-    Missing and nan are treated as synonyms for '_NA_'.
-    Assembling the entire pipeline can be expensive. If one is willing to instantiate tables
-    it can be better to sequence operations instead of composing them.
-    Another way to use this methodology would be to port this code as a stored procedure
-    in a target database of choice, meaning only the vtreat_descr table would be needed on such systems.
-
-    :param source: input data.
-    :param vtreat_descr: .description_matrix() description of transform.
-                         Expected invariant: CleanNumericTransform doesn't change variable names,
-                         all other operations produce new names.
-    :param treatment_table_name: name to use for the vtreat_descr table.
-    :param row_keys: list of columns uniquely keying rows
-    :return: data algebra pipeline implementing specified vtreat treatment
-    """
-
-    assert isinstance(source, TableDescription)
-    assert isinstance(vtreat_descr, pandas.DataFrame)
-    assert isinstance(treatment_table_name, str)
-    assert row_keys is not None
-    assert not isinstance(row_keys, str)
-    row_keys = list(row_keys)
-    assert len(row_keys) > 0
-    assert numpy.all([isinstance(v, str) for v in row_keys])
-
-    _check_treatment_table(vtreat_descr)
-    # belt and suspenders replace missing with sentinel
-    vtreat_descr = vtreat_descr.copy()
-    vtreat_descr["value"] = replace_bad_with_sentinel(vtreat_descr["value"])
-    # start building up operator pipeline
-    ops = source
-    step_1_ops = dict()
-    # add in is_bad indicators
-    im_rows = vtreat_descr.loc[
-        vtreat_descr["treatment_class"] == "IndicateMissingTransform", :
-    ].reset_index(inplace=False, drop=True)
-    for i in range(im_rows.shape[0]):
-        if im_rows['orig_was_numeric'][i]:
-            step_1_ops[
-                im_rows["variable"][i]
-            ] = f"{im_rows['orig_var'][i]}.is_bad().where(1.0, 0.0)"
-        else:
-            step_1_ops[
-                im_rows["variable"][i]
-            ] = f"({im_rows['orig_var'][i]}.coalesce('{bad_sentinel}') == '{bad_sentinel}').where(1.0, 0.0)"
-    # add in general value indicators or dummies, all indicators are non-numeric (string)
-    ic_rows = vtreat_descr.loc[
-        vtreat_descr["treatment_class"] == "IndicatorCodeTransform", :
-    ].reset_index(inplace=False, drop=True)
-    for i in range(ic_rows.shape[0]):
-        ov = ic_rows["orig_var"].values[i]
-        vi = ic_rows["value"].values[i]
-        step_1_ops[
-            ic_rows["variable"][i]
-        ] = f"({ov}.coalesce('{bad_sentinel}') == '{vi}').where(1.0, 0.0)"
-    if len(step_1_ops) > 0:
-        ops = ops.extend(step_1_ops)
-    # mapped columns
-    mapping_table = (
-        describe_table(vtreat_descr, table_name=treatment_table_name)
-            .select_rows('treatment_class == "MappedCodeTransform"')
-            .select_columns(['orig_var', 'value', 'replacement', 'treatment']))
-    mapping_rows = mapping_table.transform(vtreat_descr)
-    if mapping_rows.shape[0] > 0:
-        groups = list(set(mapping_rows['treatment']))
-        mapping_rows = mapping_rows.groupby('treatment')
-        for group_name in groups:
-            mg = mapping_rows.get_group(group_name)
-            if mg.shape[0] > 0:
-                cols_to_map = list(set(mg['orig_var']))
-                cols_to_map_back = [f'{c}_{group_name}' for c in cols_to_map]
-                ops_g = def_multi_column_map(
-                    source.extend({v: f"{v}.coalesce('{bad_sentinel}')" for v in cols_to_map}),
-                    mapping_table=mapping_table.select_rows(f'treatment == "{group_name}"'),
-                    row_keys=row_keys,
-                    cols_to_map=cols_to_map,
-                    cols_to_map_back=cols_to_map_back,
-                    coalesce_value=0.0,
-                    col_name_key='orig_var',
-                    col_value_key='value',
-                    mapped_value_key='replacement',
-                )
-                ops = ops.natural_join(
-                    b=ops_g,
-                    by=row_keys,
-                    jointype='left',
-                )
-    # add in any clean numeric copies, inputs are numeric- so disjoint of categorical processing
-    cn_rows = vtreat_descr.loc[
-        vtreat_descr["treatment_class"] == "CleanNumericTransform", :
-    ].reset_index(inplace=False, drop=True)
-    if cn_rows.shape[0] > 0:
-        step_3_exprs = dict()
-        for i in range(cn_rows.shape[0]):
-            step_3_exprs[
-                cn_rows["variable"][i]
-            ] = f"{cn_rows['orig_var'][i]}.coalesce({cn_rows['replacement'][i]})"
-        ops = ops.extend(step_3_exprs)
-    # remove any input variables that are not the same name as variables we produced
-    # this prevents non-numerics from leaking forward
-    to_del = list(set(vtreat_descr["orig_var"]) - set(vtreat_descr["variable"]))
-    if len(to_del) > 0:
-        to_del.sort()
-        ops = ops.drop_columns(to_del)
-    return ops
+from vtreat.da_adapter import as_data_algebra_pipeline
diff --git a/pkg/build/lib/vtreat/vtreat_impl.py b/pkg/build/lib/vtreat/vtreat_impl.py
index b9ee41e..64da862 100644
--- a/pkg/build/lib/vtreat/vtreat_impl.py
+++ b/pkg/build/lib/vtreat/vtreat_impl.py
@@ -146,13 +146,14 @@ class TreatmentPlan:
     xforms: Tuple[VarTransform, ...]
 
     def __init__(
-            self,
-            *,
-            outcome_name: Optional[str] = None,
-            cols_to_copy: Optional[Iterable[str]] = None,
-            num_list: Optional[Iterable[str]] = None,
-            cat_list: Optional[Iterable[str]] = None,
-            xforms: Iterable[Optional[VarTransform]]):
+        self,
+        *,
+        outcome_name: Optional[str] = None,
+        cols_to_copy: Optional[Iterable[str]] = None,
+        num_list: Optional[Iterable[str]] = None,
+        cat_list: Optional[Iterable[str]] = None,
+        xforms: Iterable[Optional[VarTransform]],
+    ):
         self.outcome_name = outcome_name
         if cols_to_copy is None:
             self.cols_to_copy = tuple()
@@ -296,10 +297,7 @@ def __init__(
 class CleanNumericTransform(VarTransform):
     """Class for numeric column cleaner."""
 
-    def __init__(self,
-                 *,
-                 incoming_column_name: str,
-                 replacement_value: float):
+    def __init__(self, *, incoming_column_name: str, replacement_value: float):
         """
 
         :param incoming_column_name:
@@ -354,11 +352,13 @@ def description_matrix(self) -> pandas.DataFrame:
 class IndicateMissingTransform(VarTransform):
     """Class for missing value indicator."""
 
-    def __init__(self,
-                 *,
-                 incoming_column_name: str,
-                 incoming_column_is_numeric: bool,
-                 derived_column_name: str):
+    def __init__(
+        self,
+        *,
+        incoming_column_name: str,
+        incoming_column_is_numeric: bool,
+        derived_column_name: str,
+    ):
         """
 
         :param incoming_column_name:
@@ -568,15 +568,15 @@ def fit_binomial_impact_code(
     eps = 1.0e-3
     if params["use_hierarchical_estimate"]:
         cf = vtreat.util.pooled_impact_estimate(x, y)
-        cf["_logit_code"] = (
-            numpy.log((numpy.maximum(cf["estimate"], 0.0) + eps)
-                      / (numpy.maximum(cf["grand_mean"], 0.0) + eps))
+        cf["_logit_code"] = numpy.log(
+            (numpy.maximum(cf["estimate"], 0.0) + eps)
+            / (numpy.maximum(cf["grand_mean"], 0.0) + eps)
         )
     else:
         cf = vtreat.util.grouped_by_x_statistics(x, y)
-        cf["_logit_code"] = (
-            numpy.log((numpy.maximum(cf["_group_mean"], 0.0) + eps)
-                      / (numpy.maximum(cf["_gm"], 0.0) + eps))
+        cf["_logit_code"] = numpy.log(
+            (numpy.maximum(cf["_group_mean"], 0.0) + eps)
+            / (numpy.maximum(cf["_gm"], 0.0) + eps)
         )
     if cf.shape[0] <= 1:
         return None
@@ -715,7 +715,9 @@ def fit_indicator_code(
         return None
     return IndicatorCodeTransform(
         incoming_column_name=incoming_column_name,
-        derived_column_names=vtreat.util.build_level_codes(incoming_column_name, levels),
+        derived_column_names=vtreat.util.build_level_codes(
+            incoming_column_name, levels
+        ),
         levels=levels,
         sparse_indicators=sparse_indicators,
     )
@@ -748,7 +750,7 @@ def fit_prevalence_code(incoming_column_name: str, x) -> Optional[VarTransform]:
         incoming_column_name=incoming_column_name,
         derived_column_name=newcol,
         treatment="prevalence_code",
-        code_book=sf
+        code_book=sf,
     )
 
 
@@ -841,7 +843,7 @@ def fit_numeric_outcome_treatment(
                 IndicateMissingTransform(
                     incoming_column_name=vi,
                     incoming_column_is_numeric=vi in num_set,
-                    derived_column_name=vi + "_is_bad"
+                    derived_column_name=vi + "_is_bad",
                 )
             )
     if "clean_copy" in params["coders"]:
@@ -934,7 +936,7 @@ def fit_binomial_outcome_treatment(
                 IndicateMissingTransform(
                     incoming_column_name=vi,
                     incoming_column_is_numeric=vi in num_set,
-                    derived_column_name=vi + "_is_bad"
+                    derived_column_name=vi + "_is_bad",
                 )
             )
     if "clean_copy" in params["coders"]:
@@ -1020,7 +1022,7 @@ def fit_multinomial_outcome_treatment(
                 IndicateMissingTransform(
                     incoming_column_name=vi,
                     incoming_column_is_numeric=vi in num_set,
-                    derived_column_name=vi + "_is_bad"
+                    derived_column_name=vi + "_is_bad",
                 )
             )
     if "clean_copy" in params["coders"]:
@@ -1106,7 +1108,7 @@ def fit_unsupervised_treatment(
                 IndicateMissingTransform(
                     incoming_column_name=vi,
                     incoming_column_is_numeric=vi in num_set,
-                    derived_column_name=vi + "_is_bad"
+                    derived_column_name=vi + "_is_bad",
                 )
             )
     if "clean_copy" in params["coders"]:
@@ -1502,7 +1504,9 @@ def describe_ut(ut):
     return score_frame
 
 
-class VariableTreatment(abc.ABC, sklearn.base.BaseEstimator, sklearn.base.TransformerMixin):
+class VariableTreatment(
+    abc.ABC, sklearn.base.BaseEstimator, sklearn.base.TransformerMixin
+):
     """
     Class for variable treatments, implements much of the sklearn pipeline/transformer
     API. https://sklearn-template.readthedocs.io/en/latest/user_guide.html#transformer
@@ -1687,7 +1691,7 @@ def set_params(self, **params):
         :return: self (for method chaining)
         """
 
-        for (k, v) in params.items():
+        for k, v in params.items():
             if k in self.params_["tunable_params"]:
                 self.params_[k] = v
         return self
diff --git a/pkg/dist/vtreat-1.3.1-py3-none-any.whl b/pkg/dist/vtreat-1.3.1-py3-none-any.whl
index 029cb97..70ae09c 100644
Binary files a/pkg/dist/vtreat-1.3.1-py3-none-any.whl and b/pkg/dist/vtreat-1.3.1-py3-none-any.whl differ
diff --git a/pkg/dist/vtreat-1.3.1.tar.gz b/pkg/dist/vtreat-1.3.1.tar.gz
index d990b74..76cb33a 100644
Binary files a/pkg/dist/vtreat-1.3.1.tar.gz and b/pkg/dist/vtreat-1.3.1.tar.gz differ
diff --git a/pkg/vtreat/partial_pooling_estimator.py b/pkg/vtreat/partial_pooling_estimator.py
index 61fb474..84dc51d 100644
--- a/pkg/vtreat/partial_pooling_estimator.py
+++ b/pkg/vtreat/partial_pooling_estimator.py
@@ -66,11 +66,6 @@ def pooled_effect_estimate(observations: pd.DataFrame) -> pd.DataFrame:
     grand_mean = estimated_centers['grand_mean']
     # build the pooled estimate
     pooled_estimate = v * estimated_centers["estimate"] + (1 - v) * grand_mean
-    return pd.DataFrame(
-        {
-            "location_id": estimated_centers["location_id"],
-            "estimate": pooled_estimate,
-            "grand_mean": grand_mean,
-            "impact": pooled_estimate - grand_mean,
-        }
-    )
+    estimated_centers["estimate"] = pooled_estimate
+    estimated_centers['impact'] = pooled_estimate - grand_mean
+    return estimated_centers
diff --git a/vtreat_dev_env_package_list.txt b/vtreat_dev_env_package_list.txt
index 3284aed..f1c15e3 100644
--- a/vtreat_dev_env_package_list.txt
+++ b/vtreat_dev_env_package_list.txt
@@ -1,261 +1,270 @@
 # This file may be used to create an environment using:
 # $ conda create --name <env> --file <this file>
 # platform: osx-64
-abseil-cpp=20211102.0=he9d5cce_0
-aiofiles=22.1.0=py311hecd8cb5_0
-aiosqlite=0.18.0=py311hecd8cb5_0
-anyio=3.5.0=py311hecd8cb5_0
+_py-xgboost-mutex=2.0=cpu_0
+abseil-cpp=20230802.0=h61975a4_2
+anyio=4.2.0=py311hecd8cb5_0
 appnope=0.1.2=py311hecd8cb5_1001
 argon2-cffi=21.3.0=pyhd3eb1b0_0
 argon2-cffi-bindings=21.2.0=py311h6c40b1e_0
-arrow-cpp=11.0.0=h89a8245_2
-astroid=2.14.2=py311hecd8cb5_0
+arrow-cpp=14.0.2=h3ade35f_1
+astroid=3.2.2=py311hecd8cb5_0
 asttokens=2.0.5=pyhd3eb1b0_0
+async-lru=2.0.4=py311hecd8cb5_0
 atomicwrites=1.4.0=py_0
 attrs=23.1.0=py311hecd8cb5_0
-aws-c-common=0.6.8=h6c40b1e_1
-aws-c-event-stream=0.1.6=hcec6c5f_6
-aws-checksums=0.1.11=h6c40b1e_2
-aws-sdk-cpp=1.8.185=h1a8d504_1
+aws-c-auth=0.6.19=h6c40b1e_0
+aws-c-cal=0.5.20=h3333b6a_0
+aws-c-common=0.8.5=h6c40b1e_0
+aws-c-compression=0.2.16=h6c40b1e_0
+aws-c-event-stream=0.2.15=hcec6c5f_0
+aws-c-http=0.6.25=h6c40b1e_0
+aws-c-io=0.13.10=h6c40b1e_0
+aws-c-mqtt=0.7.13=h6c40b1e_0
+aws-c-s3=0.1.51=h6c40b1e_0
+aws-c-sdkutils=0.1.6=h6c40b1e_0
+aws-checksums=0.1.13=h6c40b1e_0
+aws-crt-cpp=0.18.16=hcec6c5f_0
+aws-sdk-cpp=1.10.55=h61975a4_0
 babel=2.11.0=py311hecd8cb5_0
-backcall=0.2.0=pyhd3eb1b0_0
-beautifulsoup4=4.12.2=py311hecd8cb5_0
-black=23.3.0=py311hecd8cb5_0
-blas=1.0=mkl
+beautifulsoup4=4.12.3=py311hecd8cb5_0
+black=24.4.2=py311hecd8cb5_0
+blas=2.116=openblas
+blas-devel=3.9.0=16_osx64_openblas
 bleach=4.1.0=pyhd3eb1b0_0
-boost-cpp=1.82.0=ha357a0b_1
-bottleneck=1.3.5=py311hb9e55a9_0
-brotli=1.0.9=hca72f7f_7
-brotli-bin=1.0.9=hca72f7f_7
-brotlipy=0.7.0=py311h6c40b1e_1002
-bzip2=1.0.8=h1de35cc_0
+boost-cpp=1.82.0=ha357a0b_2
+bottleneck=1.3.7=py311hb3a5e46_0
+brotli=1.0.9=h6c40b1e_8
+brotli-bin=1.0.9=h6c40b1e_8
+brotli-python=1.0.9=py311hcec6c5f_8
+bzip2=1.0.8=h6c40b1e_6
 c-ares=1.19.1=h6c40b1e_0
-ca-certificates=2023.08.22=hecd8cb5_0
-cachetools=5.3.1=pypi_0
-certifi=2023.7.22=py311hecd8cb5_0
-cffi=1.15.1=py311h6c40b1e_3
+ca-certificates=2024.3.11=hecd8cb5_0
+cachetools=5.3.3=pypi_0
+certifi=2024.6.2=py311hecd8cb5_0
+cffi=1.16.0=py311h6c40b1e_1
 charset-normalizer=2.0.4=pyhd3eb1b0_0
-click=8.0.4=py311hecd8cb5_0
+click=8.1.7=py311hecd8cb5_0
 cmarkgfm=2022.10.27=py311h6c40b1e_0
-colorama=0.4.6=py311hecd8cb5_0
-comm=0.1.2=py311hecd8cb5_0
-contourpy=1.0.5=py311ha357a0b_0
+comm=0.2.1=py311hecd8cb5_0
+contourpy=1.2.0=py311ha357a0b_0
 coverage=7.2.2=py311h6c40b1e_0
-cryptography=41.0.3=py311h30e54ef_0
+cryptography=42.0.5=py311h30e54ef_1
 cycler=0.11.0=pyhd3eb1b0_0
-data-algebra=1.7.0=pypi_0
+data-algebra=1.7.1=pypi_0
+db-dtypes=1.2.0=pyhd8ed1ab_0
 debugpy=1.6.7=py311hcec6c5f_0
 decorator=5.1.1=pyhd3eb1b0_0
 defusedxml=0.7.1=pyhd3eb1b0_0
-dill=0.3.7=py311hecd8cb5_0
+dill=0.3.8=py311hecd8cb5_0
 docutils=0.18.1=py311hecd8cb5_3
-entrypoints=0.4=py311hecd8cb5_0
 executing=0.8.3=pyhd3eb1b0_0
-fonttools=4.25.0=pyhd3eb1b0_0
+fonttools=4.51.0=py311h6c40b1e_0
 freetype=2.12.1=hd8bbffd_0
-gflags=2.2.2=h0a44026_0
-giflib=5.2.1=h6c40b1e_3
-glog=0.5.0=h23ab428_0
-google-api-core=2.12.0=pypi_0
-google-auth=2.23.2=pypi_0
+gflags=2.2.2=hcec6c5f_1
+glog=0.5.0=hcec6c5f_1
+google-api-core=2.19.0=pypi_0
+google-auth=2.30.0=pypi_0
 google-cloud=0.34.0=pypi_0
-google-cloud-bigquery=3.11.4=pypi_0
-google-cloud-core=2.3.3=pypi_0
+google-cloud-bigquery=3.24.0=pypi_0
+google-cloud-core=2.4.1=pypi_0
 google-crc32c=1.5.0=pypi_0
-google-resumable-media=2.6.0=pypi_0
-googleapis-common-protos=1.60.0=pypi_0
-greenlet=2.0.1=py311hcec6c5f_0
-grpc-cpp=1.48.2=h4ed1731_1
-grpcio=1.58.0=pypi_0
-grpcio-status=1.58.0=pypi_0
+google-resumable-media=2.7.1=pypi_0
+googleapis-common-protos=1.63.1=pypi_0
+greenlet=3.0.1=py311hcec6c5f_0
+grpc-cpp=1.48.2=hbe2b35a_4
+grpcio=1.64.1=pypi_0
+grpcio-status=1.62.2=pypi_0
+gtest=1.14.0=ha357a0b_1
 icu=73.1=hcec6c5f_0
-idna=3.4=py311hecd8cb5_0
-importlib-metadata=6.0.0=py311hecd8cb5_0
-importlib_metadata=6.0.0=hd3eb1b0_0
+idna=3.7=py311hecd8cb5_0
+importlib-metadata=7.0.1=py311hecd8cb5_0
+importlib_metadata=7.0.1=hd3eb1b0_0
 iniconfig=1.1.1=pyhd3eb1b0_0
-ipykernel=6.25.0=py311h85bffb1_0
-ipython=8.15.0=py311hecd8cb5_0
-ipython_genutils=0.2.0=pyhd3eb1b0_1
+ipykernel=6.28.0=py311hecd8cb5_0
+ipython=8.20.0=py311hecd8cb5_0
 isort=5.9.3=pyhd3eb1b0_0
 jaraco.classes=3.2.1=pyhd3eb1b0_0
 jedi=0.18.1=py311hecd8cb5_1
-jinja2=3.1.2=py311hecd8cb5_0
-joblib=1.2.0=py311hecd8cb5_0
+jinja2=3.1.4=py311hecd8cb5_0
+joblib=1.4.2=py311hecd8cb5_0
 jpeg=9e=h6c40b1e_1
 js2py=0.74=py311hecd8cb5_0
 json5=0.9.6=pyhd3eb1b0_0
-jsonschema=4.17.3=py311hecd8cb5_0
-jupyter_client=7.4.9=py311hecd8cb5_0
-jupyter_core=5.3.0=py311hecd8cb5_0
-jupyter_events=0.6.3=py311hecd8cb5_0
-jupyter_server=1.23.4=py311hecd8cb5_0
-jupyter_server_fileid=0.9.0=py311hecd8cb5_0
-jupyter_server_ydoc=0.8.0=py311hecd8cb5_1
-jupyter_ydoc=0.2.4=py311hecd8cb5_0
-jupyterlab=3.6.3=py311hecd8cb5_0
+jsonschema=4.19.2=py311hecd8cb5_0
+jsonschema-specifications=2023.7.1=py311hecd8cb5_0
+jupyter-lsp=2.2.0=py311hecd8cb5_0
+jupyter_client=8.6.0=py311hecd8cb5_0
+jupyter_core=5.5.0=py311hecd8cb5_0
+jupyter_events=0.8.0=py311hecd8cb5_0
+jupyter_server=2.10.0=py311hecd8cb5_0
+jupyter_server_terminals=0.4.4=py311hecd8cb5_1
+jupyterlab=4.0.11=py311hecd8cb5_0
 jupyterlab_pygments=0.1.2=py_0
-jupyterlab_server=2.22.0=py311hecd8cb5_0
-keyring=23.13.1=py311hecd8cb5_0
+jupyterlab_server=2.25.1=py311hecd8cb5_0
+keyring=24.3.1=py311hecd8cb5_0
 kiwisolver=1.4.4=py311hcec6c5f_0
 krb5=1.20.1=h428f121_1
 lark=1.1.2=py311hecd8cb5_0
-lazy-object-proxy=1.6.0=py311h6c40b1e_0
 lcms2=2.12=hf1fd2bf_0
 lerc=3.0=he9d5cce_0
-libboost=1.82.0=h74d5ea2_1
-libbrotlicommon=1.0.9=hca72f7f_7
-libbrotlidec=1.0.9=hca72f7f_7
-libbrotlienc=1.0.9=hca72f7f_7
-libcurl=8.2.1=hf20ceda_0
+libblas=3.9.0=16_osx64_openblas
+libboost=1.82.0=hf53b9f2_2
+libbrotlicommon=1.0.9=h6c40b1e_8
+libbrotlidec=1.0.9=h6c40b1e_8
+libbrotlienc=1.0.9=h6c40b1e_8
+libcblas=3.9.0=16_osx64_openblas
+libcurl=8.7.1=hf20ceda_0
 libcxx=14.0.6=h9765a3e_0
-libdeflate=1.17=hb664fd8_0
-libedit=3.1.20221030=h6c40b1e_0
+libdeflate=1.17=hb664fd8_1
+libedit=3.1.20230828=h6c40b1e_0
 libev=4.33=h9ed2024_1
 libevent=2.1.12=h04015c4_1
-libffi=3.4.4=hecd8cb5_0
+libffi=3.4.4=hecd8cb5_1
 libgfortran=5.0.0=11_3_0_hecd8cb5_28
 libgfortran5=11.3.0=h9dfd629_28
-libiconv=1.16=hca72f7f_2
-libnghttp2=1.52.0=h9beae6a_1
+libiconv=1.16=h6c40b1e_3
+liblapack=3.9.0=16_osx64_openblas
+liblapacke=3.9.0=16_osx64_openblas
+libnghttp2=1.57.0=h9beae6a_0
+libopenblas=0.3.21=openmp_h429af6e_3
 libpng=1.6.39=h6c40b1e_0
-libpq=12.15=h04015c4_1
+libpq=12.17=h04015c4_0
 libprotobuf=3.20.3=hfff2838_0
 libsodium=1.0.18=h1de35cc_0
-libssh2=1.10.0=h04015c4_2
+libssh2=1.11.0=hf20ceda_0
 libthrift=0.15.0=h70b4b81_2
 libtiff=4.5.1=hcec6c5f_0
-libwebp=1.3.2=hf6ce154_0
 libwebp-base=1.3.2=h6c40b1e_0
-libxml2=2.10.4=h1bd7e62_1
-libxslt=1.1.37=h6c40b1e_1
+libxgboost=2.0.3=hab2016f_0
 llvm-openmp=14.0.6=h0dcd299_0
-lxml=4.9.3=py311h946e0e5_0
-lz4-c=1.9.4=hcec6c5f_0
+lz4-c=1.9.4=hcec6c5f_1
 markdown-it-py=2.2.0=py311hecd8cb5_1
-markupsafe=2.1.1=py311h6c40b1e_0
-matplotlib=3.7.2=py311hecd8cb5_0
-matplotlib-base=3.7.2=py311h8251f7d_0
+markupsafe=2.1.3=py311h6c40b1e_0
+matplotlib=3.8.4=py311hecd8cb5_0
+matplotlib-base=3.8.4=py311h41a4f6b_0
 matplotlib-inline=0.1.6=py311hecd8cb5_0
 mccabe=0.7.0=pyhd3eb1b0_0
 mdurl=0.1.0=py311hecd8cb5_0
-mistune=0.8.4=py311h6c40b1e_1000
-mkl=2023.1.0=h44ed08c_48681
-mkl-service=2.4.0=py311h6c40b1e_1
-mkl_fft=1.3.8=py311h6c40b1e_0
-mkl_random=1.2.4=py311ha357a0b_0
-more-itertools=8.12.0=pyhd3eb1b0_0
-munkres=1.1.4=py_0
+mistune=2.0.4=py311hecd8cb5_0
+mizani=0.11.4=pypi_0
+more-itertools=10.1.0=py311hecd8cb5_0
 mypy_extensions=1.0.0=py311hecd8cb5_0
-nbclassic=0.5.5=py311hecd8cb5_0
-nbclient=0.5.13=py311hecd8cb5_0
-nbconvert=6.5.4=py311hecd8cb5_0
+nbclient=0.8.0=py311hecd8cb5_0
+nbconvert=7.10.0=py311hecd8cb5_0
 nbformat=5.9.2=py311hecd8cb5_0
 ncurses=6.4=hcec6c5f_0
-nest-asyncio=1.5.6=py311hecd8cb5_0
-notebook=6.5.4=py311hecd8cb5_1
-notebook-shim=0.2.2=py311hecd8cb5_0
-numexpr=2.8.4=py311h728a8a3_1
-numpy=1.26.0=py311h728a8a3_0
-numpy-base=1.26.0=py311h53bf9ac_0
-openssl=3.0.11=hca72f7f_2
+nest-asyncio=1.6.0=py311hecd8cb5_0
+notebook-shim=0.2.3=py311hecd8cb5_0
+numexpr=2.8.7=py311h91b6869_0
+numpy=1.26.4=py311h91b6869_0
+numpy-base=1.26.4=py311hb3ec012_0
+openblas=0.3.21=openmp_hbefa662_3
+openjpeg=2.4.0=h66ea3da_0
+openssl=3.0.13=hca72f7f_2
 orc=1.7.4=h995b336_1
-packaging=23.1=py311hecd8cb5_0
-pandas=2.0.3=py311hdb55bb0_0
+overrides=7.4.0=py311hecd8cb5_0
+packaging=23.2=py311hecd8cb5_0
+pandas=2.2.1=py311hdb55bb0_0
 pandocfilters=1.5.0=pyhd3eb1b0_0
 parso=0.8.3=pyhd3eb1b0_0
 pathspec=0.10.3=py311hecd8cb5_0
-pdoc=14.1.0=pypi_0
+patsy=0.5.6=pypi_0
+pdoc=14.5.0=pypi_0
 pexpect=4.8.0=pyhd3eb1b0_3
-pickleshare=0.7.5=pyhd3eb1b0_1003
-pillow=9.4.0=py311hcec6c5f_1
-pip=23.2.1=py311hecd8cb5_0
-pkginfo=1.9.6=py311hecd8cb5_0
+pillow=10.3.0=py311h6c40b1e_0
+pip=24.0=py311hecd8cb5_0
+pkginfo=1.10.0=py311hecd8cb5_0
 platformdirs=3.10.0=py311hecd8cb5_0
+plotnine=0.13.6=pypi_0
 pluggy=1.0.0=py311hecd8cb5_1
-polars=0.19.5=pypi_0
+polars=0.20.31=pypi_0
 prometheus_client=0.14.1=py311hecd8cb5_0
-prompt-toolkit=3.0.36=py311hecd8cb5_0
-proto-plus=1.22.3=pypi_0
-protobuf=4.24.3=pypi_0
+prompt-toolkit=3.0.43=py311hecd8cb5_0
+prompt_toolkit=3.0.43=hd3eb1b0_0
+proto-plus=1.23.0=pypi_0
+protobuf=4.25.3=pypi_0
 psutil=5.9.0=py311h6c40b1e_0
-psycopg2=2.9.3=py311h6c40b1e_1
+psycopg2=2.9.9=py311h6c40b1e_0
 ptyprocess=0.7.0=pyhd3eb1b0_2
 pure_eval=0.2.2=pyhd3eb1b0_0
-py=1.11.0=pyhd3eb1b0_0
+py-xgboost=2.0.3=py311hecd8cb5_0
 py4j=0.10.9.7=py311hecd8cb5_0
-pyarrow=11.0.0=py311hf41f4e6_1
-pyasn1=0.5.0=pypi_0
-pyasn1-modules=0.3.0=pypi_0
+pyarrow=14.0.2=py311h2a249a5_0
+pyasn1=0.6.0=pypi_0
+pyasn1-modules=0.4.0=pypi_0
+pybind11-abi=4=hd3eb1b0_1
 pycparser=2.21=pyhd3eb1b0_0
 pygments=2.15.1=py311hecd8cb5_1
 pyjsparser=2.7.1=py311hecd8cb5_0
-pylint=2.16.2=py311hecd8cb5_0
+pylint=3.2.2=py311hecd8cb5_0
 pymysql=1.0.2=py311hecd8cb5_1
-pyopenssl=23.2.0=py311hecd8cb5_0
 pyparsing=3.0.9=py311hecd8cb5_0
-pyrsistent=0.18.0=py311h6c40b1e_0
 pysocks=1.7.1=py311hecd8cb5_0
 pyspark=3.4.1=py311hecd8cb5_0
-pytest=7.4.0=py311hecd8cb5_0
-pytest-cov=4.1.0=py311hecd8cb5_0
-python=3.11.5=hf27a42d_0
-python-dateutil=2.8.2=pyhd3eb1b0_0
+pytest=7.4.4=py311hecd8cb5_0
+pytest-cov=4.1.0=py311hecd8cb5_1
+python=3.11.9=hf27a42d_0
+python-dateutil=2.9.0post0=py311hecd8cb5_2
 python-fastjsonschema=2.16.2=py311hecd8cb5_0
 python-json-logger=2.0.7=py311hecd8cb5_0
 python-tzdata=2023.3=pyhd3eb1b0_0
-pytz=2023.3.post1=py311hecd8cb5_0
-pyyaml=6.0=py311h6c40b1e_1
-pyzmq=23.2.0=py311hcec6c5f_0
+pytz=2024.1=py311hecd8cb5_0
+pyyaml=6.0.1=py311h6c40b1e_0
+pyzmq=25.1.2=py311hcec6c5f_0
 re2=2022.04.01=he9d5cce_0
 readline=8.2=hca72f7f_0
 readme_renderer=40.0=py311hecd8cb5_0
-regex=2022.7.9=py311h6c40b1e_0
-requests=2.31.0=py311hecd8cb5_0
+referencing=0.30.2=py311hecd8cb5_0
+regex=2023.10.3=py311h6c40b1e_0
+requests=2.32.2=py311hecd8cb5_0
 requests-toolbelt=1.0.0=py311hecd8cb5_0
 rfc3339-validator=0.1.4=py311hecd8cb5_0
 rfc3986=1.4.0=pyhd3eb1b0_0
 rfc3986-validator=0.1.1=py311hecd8cb5_0
 rich=13.3.5=py311hecd8cb5_0
+rpds-py=0.10.6=py311hf2ad997_0
 rsa=4.9=pypi_0
-scikit-learn=1.2.2=py311hcec6c5f_1
-scipy=1.11.1=py311h224febf_0
+scikit-learn=1.4.2=py311hdb55bb0_1
+scipy=1.13.1=py311hedc7b93_0
 seaborn=0.12.2=py311hecd8cb5_0
-send2trash=1.8.0=pyhd3eb1b0_1
-setuptools=68.0.0=py311hecd8cb5_0
+send2trash=1.8.2=py311hecd8cb5_0
+setuptools=69.5.1=py311hecd8cb5_0
 six=1.16.0=pyhd3eb1b0_1
-snappy=1.1.9=he9d5cce_0
-sniffio=1.2.0=py311hecd8cb5_1
-soupsieve=2.4=py311hecd8cb5_0
-sqlalchemy=2.0.21=py311h6c40b1e_0
-sqlite=3.41.2=h6c40b1e_0
+snappy=1.1.10=hcec6c5f_1
+sniffio=1.3.0=py311hecd8cb5_0
+soupsieve=2.5=py311hecd8cb5_0
+sqlalchemy=2.0.25=py311h6c40b1e_0
+sqlite=3.45.3=h6c40b1e_0
 stack_data=0.2.0=pyhd3eb1b0_0
-tbb=2021.8.0=ha357a0b_0
+statsmodels=0.14.2=pypi_0
 terminado=0.17.1=py311hecd8cb5_0
 threadpoolctl=2.2.0=pyh0d69192_0
 tinycss2=1.2.1=py311hecd8cb5_0
-tk=8.6.12=h5d9f67b_0
+tk=8.6.14=h4d00af3_0
 toml=0.10.2=pyhd3eb1b0_0
 tomlkit=0.11.1=py311hecd8cb5_0
-tornado=6.3.2=py311h6c40b1e_0
-traitlets=5.7.1=py311hecd8cb5_0
+tornado=6.3.3=py311h6c40b1e_0
+traitlets=5.14.3=py311hecd8cb5_0
 twine=4.0.2=py311hecd8cb5_0
-typing-extensions=4.7.1=py311hecd8cb5_0
-typing_extensions=4.7.1=py311hecd8cb5_0
-tzdata=2023c=h04d1e81_0
-tzlocal=2.1=py311hecd8cb5_1
-urllib3=1.26.16=py311hecd8cb5_0
-utf8proc=2.6.1=h9ed2024_0
+typing-extensions=4.11.0=py311hecd8cb5_0
+typing_extensions=4.11.0=py311hecd8cb5_0
+tzdata=2024a=h04d1e81_0
+tzlocal=5.2=py311hecd8cb5_0
+unicodedata2=15.1.0=py311h6c40b1e_0
+urllib3=2.2.1=py311hecd8cb5_0
+utf8proc=2.6.1=h6c40b1e_1
 vtreat=1.3.1=dev_0
 wcwidth=0.2.5=pyhd3eb1b0_0
 webencodings=0.5.1=py311hecd8cb5_1
-websocket-client=0.58.0=py311hecd8cb5_4
-wheel=0.41.2=py311hecd8cb5_0
-wrapt=1.14.1=py311h6c40b1e_0
-xz=5.4.2=h6c40b1e_0
-y-py=0.5.9=py311h7242b5c_0
+websocket-client=1.8.0=py311hecd8cb5_0
+wheel=0.43.0=py311hecd8cb5_0
+wvpy=1.1.2=pypi_0
+wvu=0.3.9=pypi_0
+xgboost=2.0.3=py311hecd8cb5_0
+xz=5.4.6=h6c40b1e_1
 yaml=0.2.5=haf1e3a3_0
-ypy-websocket=0.8.2=py311hecd8cb5_0
-zeromq=4.3.4=h23ab428_0
-zipp=3.11.0=py311hecd8cb5_0
-zlib=1.2.13=h4dc903c_0
-zstd=1.5.5=hc035e20_0
+zeromq=4.3.5=hcec6c5f_0
+zipp=3.17.0=py311hecd8cb5_0
+zlib=1.2.13=h4b97444_1
+zstd=1.5.5=hc035e20_2