modist 0.1.0__py3-none-any.whl

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/_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/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/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/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)