modist 0.1.0__tar.gz

modist-0.1.0/PKG-INFO

@@ -0,0 +1,121 @@
+Metadata-Version: 2.4
+Name: modist
+Version: 0.1.0
+Summary: Interactive distribution widgets for marimo, in the style of wigglystuff
+Keywords: marimo,anywidget,statistics,distribution,visualization
+Author: Will Dean
+Author-email: Will Dean <wd60622@gmail.com>
+License-Expression: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Requires-Dist: anywidget>=0.11.0
+Requires-Dist: pytest>=8 ; extra == 'dev'
+Requires-Dist: marimo>=0.9 ; extra == 'dev'
+Requires-Dist: conjugate-models ; extra == 'dev'
+Requires-Dist: pymc>=5.10 ; extra == 'pymc'
+Requires-Dist: scipy>=1.12 ; extra == 'scipy'
+Requires-Python: >=3.12, <3.15
+Project-URL: Documentation, https://github.com/williambdean/modist#readme
+Project-URL: Homepage, https://github.com/williambdean/modist
+Project-URL: Repository, https://github.com/williambdean/modist
+Provides-Extra: dev
+Provides-Extra: pymc
+Provides-Extra: scipy
+Description-Content-Type: text/markdown
+
+# `modist`
+
+Interactive distribution widgets for [marimo](https://marimo.io), in the style
+of [`koaning/wigglystuff`](https://github.com/koaning/wigglystuff). Drag the
+density curve to shape a distribution, then feed the params straight into a
+distribution constructor with a single splat.
+
+## Install
+
+```sh
+uv add modist            # or: uv pip install modist  (pip install modist)
+```
+
+## Quickstart
+
+```python
+import marimo as mo
+import modist as md
+
+w = mo.ui.anywidget(md.Normal())
+w
+```
+
+```python
+params = w.value            # {'mu': ..., 'sigma': ...}
+```
+
+```python
+import pymc as pm
+dist = pm.Normal.dist(**params)   # or pm.Beta / pm.Gamma
+```
+
+## Families
+
+| Widget                       | Params        | Domain            | Drag affordances          |
+| ---------------------------- | ------------- | ----------------- | ------------------------- |
+| [`Normal`](src/modist/normal.py)  | `mu`, `sigma`      | free             | mean line → `mu`, ±1σ squares → `sigma` |
+| [`Beta`](src/modist/beta.py)      | `alpha`, `beta`    | fixed `[0, 1]`    | mean line → translate, q25/q75 squares → concentrate |
+| [`Gamma`](src/modist/gamma.py)    | `alpha`, `beta`    | edge pinned at 0  | mean line → translate, q25/q75 squares → reshape |
+
+`alpha`/`beta` follow the [PyMC](https://www.pymc.io) / statistics convention
+(`Gamma`'s `beta` is the **rate**, not scipy's `scale`). The lazy `.scipy` and
+`.pymc` adapters map to the right parametrization automatically:
+
+```python
+n = md.Normal(mu=2.0, sigma=3.0)
+n.scipy   # <scipy.stats.norm> via loc=/scale=
+n.pymc    # pm.Normal.dist(mu=2.0, sigma=3.0)
+
+g = md.Gamma(alpha=2.0, beta=3.0)
+g.scipy   # scipy.stats.gamma(a=2.0, scale=1/3)  -- rate handled for you
+```
+
+`w.value` is a plain dict of the synced traits, so `pm.X.dist(**w.value)` works
+with no conversion.
+
+## How it works
+
+Each family is its own anywidget class with a small set of synced parameter
+traits (no `x_min`/`x_max`/`n_points`). The view — SVG scaffold, pan/zoom,
+draggable hit lines, and per-family math — lives in a self-contained ESM module.
+
+Source JS lives in [`js/`](js/) (`js/base.js` shared scaffold + one family file,
+all importing a vendored copy of [jStat](https://jstat.github.io/) for
+`pdf`/`cdf`/quantile math). Anywidget delivers `_esm` as a Blob URL, which
+cannot resolve relative imports, so [esbuild](https://esbuild.github.io)
+bundles each family (jStat inlined) into the committed `src/modist/static/*.js`
+files — the same pattern wigglystuff uses for its JS-heavy widgets.
+
+### Rebuilding the JS
+
+```sh
+make js          # esbuild js/*.js -> src/modist/static/*.js
+make js-watch    # rebuild on every edit (for anywidget hot-reload dev)
+```
+
+Requires a local esbuild (`npm install --no-save esbuild`).
+
+## Development
+
+```sh
+make venv        # creates .venv with dev deps + esbuild
+make test        # pytest
+npm run test:js  # Playwright JS integration probes (headless Chromium)
+```
+
+## Acknowledgements
+
+- [jStat](https://jstat.github.io/) — JavaScript statistics library (MIT), vendored and bundled for the pdf/cdf/quantile math.
+- [wigglystuff](https://github.com/koaning/wigglystuff) — the interaction and architecture model (one class per family, prebuilt ESM per class).

modist-0.1.0/README.md

@@ -0,0 +1,90 @@
+# `modist`
+
+Interactive distribution widgets for [marimo](https://marimo.io), in the style
+of [`koaning/wigglystuff`](https://github.com/koaning/wigglystuff). Drag the
+density curve to shape a distribution, then feed the params straight into a
+distribution constructor with a single splat.
+
+## Install
+
+```sh
+uv add modist            # or: uv pip install modist  (pip install modist)
+```
+
+## Quickstart
+
+```python
+import marimo as mo
+import modist as md
+
+w = mo.ui.anywidget(md.Normal())
+w
+```
+
+```python
+params = w.value            # {'mu': ..., 'sigma': ...}
+```
+
+```python
+import pymc as pm
+dist = pm.Normal.dist(**params)   # or pm.Beta / pm.Gamma
+```
+
+## Families
+
+| Widget                       | Params        | Domain            | Drag affordances          |
+| ---------------------------- | ------------- | ----------------- | ------------------------- |
+| [`Normal`](src/modist/normal.py)  | `mu`, `sigma`      | free             | mean line → `mu`, ±1σ squares → `sigma` |
+| [`Beta`](src/modist/beta.py)      | `alpha`, `beta`    | fixed `[0, 1]`    | mean line → translate, q25/q75 squares → concentrate |
+| [`Gamma`](src/modist/gamma.py)    | `alpha`, `beta`    | edge pinned at 0  | mean line → translate, q25/q75 squares → reshape |
+
+`alpha`/`beta` follow the [PyMC](https://www.pymc.io) / statistics convention
+(`Gamma`'s `beta` is the **rate**, not scipy's `scale`). The lazy `.scipy` and
+`.pymc` adapters map to the right parametrization automatically:
+
+```python
+n = md.Normal(mu=2.0, sigma=3.0)
+n.scipy   # <scipy.stats.norm> via loc=/scale=
+n.pymc    # pm.Normal.dist(mu=2.0, sigma=3.0)
+
+g = md.Gamma(alpha=2.0, beta=3.0)
+g.scipy   # scipy.stats.gamma(a=2.0, scale=1/3)  -- rate handled for you
+```
+
+`w.value` is a plain dict of the synced traits, so `pm.X.dist(**w.value)` works
+with no conversion.
+
+## How it works
+
+Each family is its own anywidget class with a small set of synced parameter
+traits (no `x_min`/`x_max`/`n_points`). The view — SVG scaffold, pan/zoom,
+draggable hit lines, and per-family math — lives in a self-contained ESM module.
+
+Source JS lives in [`js/`](js/) (`js/base.js` shared scaffold + one family file,
+all importing a vendored copy of [jStat](https://jstat.github.io/) for
+`pdf`/`cdf`/quantile math). Anywidget delivers `_esm` as a Blob URL, which
+cannot resolve relative imports, so [esbuild](https://esbuild.github.io)
+bundles each family (jStat inlined) into the committed `src/modist/static/*.js`
+files — the same pattern wigglystuff uses for its JS-heavy widgets.
+
+### Rebuilding the JS
+
+```sh
+make js          # esbuild js/*.js -> src/modist/static/*.js
+make js-watch    # rebuild on every edit (for anywidget hot-reload dev)
+```
+
+Requires a local esbuild (`npm install --no-save esbuild`).
+
+## Development
+
+```sh
+make venv        # creates .venv with dev deps + esbuild
+make test        # pytest
+npm run test:js  # Playwright JS integration probes (headless Chromium)
+```
+
+## Acknowledgements
+
+- [jStat](https://jstat.github.io/) — JavaScript statistics library (MIT), vendored and bundled for the pdf/cdf/quantile math.
+- [wigglystuff](https://github.com/koaning/wigglystuff) — the interaction and architecture model (one class per family, prebuilt ESM per class).

modist-0.1.0/pyproject.toml

@@ -0,0 +1,42 @@
+[project]
+name = "modist"
+version = "0.1.0"
+description = "Interactive distribution widgets for marimo, in the style of wigglystuff"
+readme = "README.md"
+authors = [
+    { name = "Will Dean", email = "wd60622@gmail.com" }
+]
+license = "MIT"
+keywords = [
+    "marimo",
+    "anywidget",
+    "statistics",
+    "distribution",
+    "visualization",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Scientific/Engineering :: Visualization",
+]
+requires-python = ">=3.12,<3.15"
+dependencies = ["anywidget>=0.11.0"]
+
+[project.urls]
+Homepage = "https://github.com/williambdean/modist"
+Repository = "https://github.com/williambdean/modist"
+Documentation = "https://github.com/williambdean/modist#readme"
+
+[project.optional-dependencies]
+scipy = ["scipy>=1.12"]
+pymc = ["pymc>=5.10"]
+dev = ["pytest>=8", "marimo>=0.9", "conjugate-models"]
+
+[build-system]
+requires = ["uv_build>=0.8.22,<0.9.0"]
+build-backend = "uv_build"

modist-0.1.0/src/modist/__init__.py

@@ -0,0 +1,21 @@
+"""modist - interactive distribution widgets for marimo.
+
+Each widget renders a draggable density curve. The synced parameter traits
+make ``mo.ui.anywidget(w).value`` a dict that splats directly into a
+distribution constructor, e.g. ``pm.Normal.dist(**w.value)``.
+
+Families
+--------
+- :class:`Normal`  -- ``mu`` / ``sigma``
+- :class:`Beta`    -- ``alpha`` / ``beta`` (fixed [0, 1])
+- :class:`Gamma`   -- ``alpha`` / ``beta`` (shape / rate, edge at 0)
+"""
+
+from ._base import DistMixin
+from .beta import Beta
+from .gamma import Gamma
+from .normal import Normal
+
+__all__ = ["Normal", "Beta", "Gamma", "DistMixin"]
+
+__version__ = "0.1.0"

modist-0.1.0/src/modist/_base.py

@@ -0,0 +1,60 @@
+"""Shared lazy adapters for modist widgets.
+
+Each widget exposes a ``params`` dict of its canonical synced traits plus lazy
+``.scipy`` and ``.pymc`` attributes that construct a frozen scipy distribution
+or a pymc distribution from those params. Imports happen only on first access.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict
+
+
+class DistMixin:
+    """Provides ``params`` plus lazy ``.scipy`` / ``.pymc`` distribution adapters."""
+
+    # Family subclasses set these:
+    _param_names: tuple[str, ...] = ()
+    _dist_name: str = ""
+
+    @property
+    def params(self) -> Dict[str, float]:
+        """The canonical parameters of this distribution (the synced traits)."""
+        return {name: getattr(self, name) for name in self._param_names}
+
+    @property
+    def scipy(self) -> Any:
+        """A frozen ``scipy.stats`` distribution for the current params (lazy import)."""
+        from scipy import stats  # type: ignore[import-not-found]
+
+        return self._make_scipy(stats)
+
+    @property
+    def pymc(self) -> Any:
+        """A ``pymc`` distribution object from the current params (lazy import)."""
+        import pymc as pm  # type: ignore[import-not-found]
+
+        dist = getattr(pm, self._dist_name)
+        return dist.dist(**self.params)
+
+    def create_variable(self, name: str) -> Any:
+        """A symbolic pymc distribution whose parameters are named pytensor
+        scalars (``{name}_{param}``), ready for ``pm.compile`` with
+        ``pytensor.graph.traversal.explicit_graph_inputs``.
+
+        This is the compiled-input counterpart to :attr:`pymc`/:attr:`params`:
+        instead of baking the current values in, each parameter becomes a
+        ``pt.scalar(f"{name}_{param}")`` so the graph can be compiled once and
+        re-called with new values without rebuilding. E.g.
+
+        ``w_int.create_variable("intercept")`` gives ``pm.Normal.dist(
+        mu=pt.scalar("intercept_mu"), sigma=pt.scalar("intercept_sigma"))``.
+        """
+        import pymc as pm  # type: ignore[import-not-found]
+        import pytensor.tensor as pt  # type: ignore[import-not-found]
+
+        kwargs = {p: pt.scalar(f"{name}_{p}") for p in self._param_names}
+        return getattr(pm, self._dist_name).dist(**kwargs)
+
+    def _make_scipy(self, stats: Any) -> Any:
+        raise NotImplementedError

modist-0.1.0/src/modist/beta.py

@@ -0,0 +1,41 @@
+"""Interactive Beta distribution widget on the fixed [0, 1] domain.
+
+Drag the mean line to translate (at a fixed concentration) or either ``q25`` /
+``q75`` square to concentrate / spread out. Synced ``alpha`` / ``beta`` traits
+make ``mo.ui.anywidget(...).value`` splat into ``pm.Beta.dist(**w.value)``.
+
+Examples
+--------
+>>> import marimo as mo
+>>> import modist as md
+>>> w = mo.ui.anywidget(md.Beta(alpha=2, beta=2))
+>>> w
+>>> params = w.value  # {'alpha': ..., 'beta': ...}
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import anywidget
+import traitlets
+
+from ._base import DistMixin
+
+_ESM = Path(__file__).parent / "static" / "beta.js"
+_CSS = Path(__file__).parent / "styles.css"
+
+
+class Beta(DistMixin, anywidget.AnyWidget):
+    """An interactive Beta distribution with draggable mean and concentration."""
+
+    _esm = _ESM
+    _css = _CSS
+    _param_names = ("alpha", "beta")
+    _dist_name = "Beta"
+
+    alpha = traitlets.Float(2.0).tag(sync=True)
+    beta = traitlets.Float(2.0).tag(sync=True)
+
+    def _make_scipy(self, stats):
+        return stats.beta(a=self.alpha, b=self.beta)

modist-0.1.0/src/modist/gamma.py

@@ -0,0 +1,43 @@
+"""Interactive Gamma distribution widget, left edge pinned at 0.
+
+Drag the mean line to translate (at a fixed shape) or either ``q25`` / ``q75``
+square to reshape. ``alpha`` is the shape and ``beta`` the rate (pymc / stats
+convention, not the scipy ``scale``). Synced traits make
+``mo.ui.anywidget(...).value`` splat into ``pm.Gamma.dist(**w.value)``.
+
+Examples
+--------
+>>> import marimo as mo
+>>> import modist as md
+>>> w = mo.ui.anywidget(md.Gamma(alpha=2, beta=2))
+>>> w
+>>> params = w.value  # {'alpha': ..., 'beta': ...}
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import anywidget
+import traitlets
+
+from ._base import DistMixin
+
+_ESM = Path(__file__).parent / "static" / "gamma.js"
+_CSS = Path(__file__).parent / "styles.css"
+
+
+class Gamma(DistMixin, anywidget.AnyWidget):
+    """An interactive Gamma distribution with draggable mean and shape."""
+
+    _esm = _ESM
+    _css = _CSS
+    _param_names = ("alpha", "beta")
+    _dist_name = "Gamma"
+
+    alpha = traitlets.Float(2.0).tag(sync=True)
+    beta = traitlets.Float(2.0).tag(sync=True)
+
+    def _make_scipy(self, stats):
+        # scipy gamma parametrizes by (shape, scale); here beta is the rate.
+        return stats.gamma(a=self.alpha, scale=1.0 / self.beta)

modist-0.1.0/src/modist/normal.py

@@ -0,0 +1,42 @@
+"""Interactive Normal distribution widget.
+
+A draggable Normal curve: drag the mean line to reposition, or either of the
+``\u00b11\u03c3`` squares to reshape the spread. The synced ``mu`` / ``sigma``
+traits make ``mo.ui.anywidget(...).value`` splat directly into a distribution
+constructor, e.g. ``pm.Normal.dist(**w.value)``.
+
+Examples
+--------
+>>> import marimo as mo
+>>> import modist as md
+>>> w = mo.ui.anywidget(md.Normal(mu=0, sigma=1))
+>>> w
+>>> params = w.value  # {'mu': ..., 'sigma': ...}
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import anywidget
+import traitlets
+
+from ._base import DistMixin
+
+_ESM = Path(__file__).parent / "static" / "normal.js"
+_CSS = Path(__file__).parent / "styles.css"
+
+
+class Normal(DistMixin, anywidget.AnyWidget):
+    """An interactive Normal distribution with draggable mean and spread."""
+
+    _esm = _ESM
+    _css = _CSS
+    _param_names = ("mu", "sigma")
+    _dist_name = "Normal"
+
+    mu = traitlets.Float(0.0).tag(sync=True)
+    sigma = traitlets.Float(1.0).tag(sync=True)
+
+    def _make_scipy(self, stats):
+        return stats.norm(loc=self.mu, scale=self.sigma)