rbartpackages 0.1.0__py3-none-any.whl

rbartpackages/BART.py

@@ -0,0 +1,335 @@
+# rbartpackages/src/rbartpackages/BART.py
+#
+# Copyright (c) 2024-2026, The rbartpackages Contributors
+#
+# This file is part of rbartpackages.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+"""Wrapper for the R package BART."""
+
+# ruff: noqa: ANN002, ANN003
+
+from functools import partial
+from typing import NamedTuple, TypedDict, cast
+
+import numpy as np
+from jaxtyping import AbstractDtype, Bool, Float64, Int32
+from numpy import ndarray
+from rpy2 import robjects
+from rpy2.rlike.container import NamedList
+
+from rbartpackages._base import RObjectBase, fork_safe_native_threads, rmethod
+
+
+class TreeDraws(TypedDict):
+    """Type of the `treedraws` attribute of `mc_gbart`."""
+
+    cutpoints: dict[int | str, Float64[ndarray, ' numcut[i]']]
+    """Per-variable grid of candidate split points, keyed by column index or name."""
+
+    trees: str
+    """Posterior tree ensemble serialized in BART's text format (read by `predict`)."""
+
+
+class PredictBinary(TypedDict):
+    """Type of `predict`'s return value for binary (`pbart`/`lbart`) fits."""
+
+    yhat_test: Float64[ndarray, 'ndpost m']
+    """Posterior latent-function draws at the test points."""
+
+    prob_test: Float64[ndarray, 'ndpost m']
+    """Success-probability draws (inverse probit/logit transform of `yhat_test`)."""
+
+    prob_test_mean: Float64[ndarray, ' m']
+    """Posterior mean of `prob_test`."""
+
+    binaryOffset: float
+    """Data centering value on the latent scale."""
+
+
+class String(AbstractDtype):
+    """Represent a `numpy.str_` data dtype."""
+
+    dtypes = r'<U\d+'
+
+
+class ProcTime(NamedTuple):
+    """Python representation of the output of R's `proc.time`."""
+
+    user_self: float
+    """CPU seconds charged to the R process in user mode."""
+
+    sys_self: float
+    """CPU seconds charged to the R process in system (kernel) mode."""
+
+    elapsed: float
+    """Wall-clock seconds elapsed."""
+
+    user_child: float
+    """User-mode CPU seconds of forked child processes (`mc.gbart` workers)."""
+
+    sys_child: float
+    """System-mode CPU seconds of forked child processes."""
+
+
+class mc_gbart(RObjectBase):  # noqa: D101 because the R doc is added automatically
+    _rfuncname = 'BART::mc.gbart'
+
+    LPML: float
+    """Log pseudo-marginal likelihood; unstable for BART.
+
+    Always computed, even without burn-in. Miscomputed by R for binary
+    `mc.gbart` fits with ``mc_cores > 1`` (the chains' probabilities are not
+    combined before the computation).
+    """
+
+    hostname: Bool[ndarray, ' mc_cores'] | String[ndarray, ' mc_cores']
+    """Per-chain hostname if fitted with ``hostname=True``, else per-chain ``False``."""
+
+    ndpost: int
+    """Number of posterior draws kept, after burn-in and thinning."""
+
+    offset: float
+    """Data centering value for the response (link scale for binary)."""
+
+    prob_test: None | Float64[ndarray, 'ndpost/mc_cores m'] = None
+    """Test-point success-probability draws (binary outcomes only).
+
+    `mc.gbart` with ``mc_cores > 1`` forgets to combine the chains, leaving
+    only the first chain's draws.
+    """
+
+    prob_test_mean: None | Float64[ndarray, ' m'] = None
+    """Posterior mean of `prob_test`."""
+
+    prob_train: None | Float64[ndarray, 'ndpost/mc_cores n'] = None
+    """Training-point success-probability draws (binary outcomes only).
+
+    `mc.gbart` with ``mc_cores > 1`` forgets to combine the chains, leaving
+    only the first chain's draws.
+    """
+
+    prob_train_mean: None | Float64[ndarray, ' n'] = None
+    """Posterior mean of `prob_train`."""
+
+    proc_time: ProcTime
+    """Timing of the fit, from R's `proc.time`."""
+
+    rm_const: Int32[ndarray, '<=p']
+    """0-based indices of the `x_train` columns kept (constant columns dropped).
+
+    `mc.gbart` with ``mc_cores=1`` relabels the kept columns to ``0 .. kept-1``,
+    losing which original columns were dropped.
+    """
+
+    sigma: (
+        Float64[ndarray, ' nskip+ndpost*keepevery']
+        | Float64[ndarray, 'nskip+ndpost*keepevery/mc_cores mc_cores']
+        | None
+    ) = None
+    """Error-SD draws, continuous outcomes only (per chain for `mc.gbart`).
+
+    One draw per MCMC iteration: burn-in and the thinned-away iterations are
+    included.
+    """
+
+    sigma_mean: float | None = None
+    """Mean of the first `ndpost` post-burn-in `sigma` draws (continuous only)."""
+
+    treedraws: TreeDraws
+    """Sampled trees: per-variable cutpoint grid and the serialized ensemble."""
+
+    varcount: Int32[ndarray, 'ndpost p']
+    """Per-draw count of splits on each variable, summed over trees."""
+
+    varcount_mean: Float64[ndarray, ' p']
+    """Posterior mean of `varcount` per variable."""
+
+    varprob: Float64[ndarray, 'ndpost p']
+    """Per-draw probability assigned to each variable for splitting."""
+
+    varprob_mean: Float64[ndarray, ' p']
+    """Posterior mean of `varprob` per variable."""
+
+    yhat_test: Float64[ndarray, 'ndpost m']
+    """Test-point posterior function draws (latent scale for binary).
+
+    Always present: R's `cgbart` allocates it unconditionally, so without test
+    data it is an empty array rather than ``None`` (with the rows of the first
+    chain only for `mc.gbart`, which combines the chains just when there is
+    test data).
+    """
+
+    yhat_test_mean: Float64[ndarray, ' m'] | None = None
+    """Posterior mean of `yhat_test` (continuous with test data only)."""
+
+    yhat_train: Float64[ndarray, 'ndpost n']
+    """Training-point posterior function draws (latent scale for binary)."""
+
+    yhat_train_mean: Float64[ndarray, ' n'] | None = None
+    """Posterior mean of `yhat_train` (continuous only)."""
+
+    def __init__(self, *args, **kw) -> None:
+        # mc.gbart forks via parallel::mcparallel; cap native thread pools at one
+        # thread across the fork to avoid a libgomp deadlock in the children.
+        with fork_safe_native_threads():
+            super().__init__(*args, **kw)
+
+        # fix up attributes
+        self.LPML = self.LPML.item()
+        self.ndpost = self.ndpost.astype(int).item()
+        self.offset = self.offset.item()
+        self.proc_time = ProcTime(*map(float, self.proc_time))
+
+        if np.all(self.rm_const < 0):
+            # R reports the dropped constant columns as negative indices into
+            # the original design matrix, while varcount has the kept ones
+            _, kept = self.varcount.shape
+            p = kept + self.rm_const.size
+            rm_const = np.ones(p, bool)
+            rm_const[-self.rm_const - 1] = False
+            self.rm_const = np.arange(p, dtype=np.int32)[rm_const]
+        elif np.all(self.rm_const > 0):
+            self.rm_const -= 1
+        else:  # pragma: no cover - R gives all-positive or all-negative indices
+            msg = 'failed to parse rm.const because indices change sign'
+            raise ValueError(msg)
+
+        if self.sigma_mean is not None:
+            self.sigma_mean = self.sigma_mean.item()
+
+        r_treedraws = cast(NamedList, self.treedraws)
+        cutpoints: NamedList = r_treedraws.getbyname('cutpoints')
+        self.treedraws = {
+            'cutpoints': {
+                i if it.name is None else it.name.item(): it.value
+                for i, it in enumerate(cutpoints.items())
+            },
+            'trees': r_treedraws.getbyname('trees').item(),
+        }
+
+    @partial(rmethod, rname='predict')
+    def _predict(self, newdata: Float64[ndarray, 'm p'], *args, **kwargs) -> object:
+        """Call R's `predict`; returns a matrix (continuous) or a list (binary)."""
+        ...
+
+    def predict(
+        self, newdata: Float64[ndarray, 'm p'], *args, **kwargs
+    ) -> Float64[ndarray, 'ndpost m'] | PredictBinary:
+        """Compute predictions.
+
+        For continuous (`wbart`) fits this is the matrix of posterior
+        latent-function draws. For binary (`pbart`/`lbart`) fits R returns a
+        list, exposed here as a `PredictBinary` dict.
+
+        For `mc.gbart` fits with ``mc_cores > 1`` that dropped constant
+        columns, R miscounts the kept columns and fails to update the header
+        of the serialized ensemble, so only the first chain's draws are
+        returned.
+        """
+        out = self._predict(newdata, *args, **kwargs)
+        if not hasattr(out, 'items'):
+            return out  # continuous: already a matrix
+
+        # binary: convert R's list (a NamedList) to a dict of arrays
+        out = cast(NamedList, out)
+        result = {str(it.name).replace('.', '_'): it.value for it in out.items()}
+        result['binaryOffset'] = result['binaryOffset'].item()
+        return result
+
+
+class bartModelMatrix(RObjectBase):  # noqa: D101 because the R doc is added automatically
+    _rfuncname = 'BART::bartModelMatrix'
+
+    X: Float64[ndarray, 'N p']
+    """Design matrix: vectors and data frames coerced to numeric, factors expanded to indicators."""
+
+    numcut: Int32[ndarray, ' p']
+    """Number of cutpoints chosen per column."""
+
+    rm_const: Int32[ndarray, '<=p']
+    """0-based indices of the non-constant columns of the expanded design.
+
+    The indices refer to the columns of `X` before removal: ``rm.const=True``
+    removes the constant columns from `X`, `numcut` and `xinfo`, while the
+    default only detects them.
+    """
+
+    xinfo: Float64[ndarray, 'p numcut']
+    """Per-column cutpoint grid, NaN-padded to the maximum cut count."""
+
+    grp: Int32[ndarray, ' p'] | Float64[ndarray, ' 1'] | None
+    """1-based input-column index each output column comes from (factors expand
+    to one indicator column per level); ``None`` for matrix input."""
+
+    def __new__(cls, *args, **kw) -> Float64[ndarray, 'N p'] | RObjectBase:
+        """Match R: return the bare matrix for ``numcut=0``, else a populated instance."""
+        # __init__ cannot change the return type, so the matrix-or-list choice
+        # is made here; returning a non-instance (the matrix) skips __init__.
+        self = super().__new__(cls)
+        self._robject = self._invoke_rfunc(args, kw)
+        if self._has_named_components(self._robject):
+            return self
+        return self._r2py(self._robject)
+
+    def __init__(self, *args, **kw) -> None:
+        # Only reached for the named-list case (numcut > 0); __new__ already
+        # invoked R and stored `_robject`, so just expose its components rather
+        # than calling super().__init__ (which would invoke R a second time).
+        self._set_attrs_from_robject()
+
+        # grp is R NULL for matrix input; expose it as None.
+        if self.grp is robjects.NULL:
+            self.grp = None
+
+        if np.all(self.rm_const < 0):
+            # R flags detected-constant columns as negative indices into the
+            # pre-removal design matrix; whether they were also removed from X
+            # depends on the rm.const argument, so recover it from the call
+            # (rm.const is the 5th parameter of R's bartModelMatrix)
+            removed = kw.get(
+                'rm.const', kw.get('rm_const', args[4] if len(args) > 4 else False)
+            )
+            _, n_cols = self.X.shape
+            p = n_cols + self.rm_const.size if removed else n_cols
+            rm_const = np.ones(p, bool)
+            rm_const[-self.rm_const - 1] = False
+            self.rm_const = np.arange(p, dtype=np.int32)[rm_const]
+        elif np.all(self.rm_const > 0):
+            self.rm_const -= 1
+        else:  # pragma: no cover - R gives all-positive or all-negative indices
+            msg = 'failed to parse rm.const because indices change sign'
+            raise ValueError(msg)
+
+
+class gbart(mc_gbart):  # noqa: D101 because the R doc is added automatically
+    _rfuncname = 'BART::gbart'
+
+    hostname: Bool[ndarray, ' 1'] | String[ndarray, ' 1']
+    """Hostname the fit ran on if fitted with ``hostname=True``, else ``False``."""
+
+    prob_test: None | Float64[ndarray, 'ndpost m'] = None
+    """Test-point success-probability draws (binary outcomes only)."""
+
+    prob_train: None | Float64[ndarray, 'ndpost n'] = None
+    """Training-point success-probability draws (binary outcomes only)."""
+
+    sigma: Float64[ndarray, ' nskip+ndpost*keepevery'] | None = None
+    """Error-SD draws for every MCMC iteration, burn-in included (continuous only)."""

rbartpackages/BART3.py

@@ -0,0 +1,368 @@
+# rbartpackages/src/rbartpackages/BART3.py
+#
+# Copyright (c) 2025-2026, The rbartpackages Contributors
+#
+# This file is part of rbartpackages.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+"""Wrapper for the R package BART3."""
+
+# ruff: noqa: ANN002, ANN003
+
+from functools import partial
+from typing import NamedTuple, TypedDict, cast
+
+import numpy as np
+from jaxtyping import AbstractDtype, Float64, Int32
+from numpy import ndarray
+from rpy2 import robjects
+from rpy2.rlike.container import NamedList
+
+from rbartpackages._base import RObjectBase, fork_safe_native_threads, rmethod
+
+
+class TreeDraws(TypedDict):
+    """Type of the `treedraws` attribute of `mc_gbart`."""
+
+    cutpoints: dict[int | str, Float64[ndarray, ' numcut[i]']]
+    """Per-variable grid of candidate split points, keyed by column index or name."""
+
+    trees: str
+    """Posterior tree ensemble serialized in BART's text format (read by `predict`)."""
+
+
+class PredictBinary(TypedDict):
+    """Type of `predict`'s return value for binary (`pbart`/`lbart`) fits."""
+
+    yhat_test: Float64[ndarray, 'ndpost m']
+    """Posterior latent-function draws at the test points."""
+
+    prob_test: Float64[ndarray, 'ndpost m']
+    """Success-probability draws (inverse probit/logit transform of `yhat_test`)."""
+
+    prob_test_mean: Float64[ndarray, ' m']
+    """Posterior mean of `prob_test`."""
+
+    prob_test_lower: Float64[ndarray, ' m']
+    """Lower `probs` quantile of `prob_test` (default 2.5%)."""
+
+    prob_test_upper: Float64[ndarray, ' m']
+    """Upper `probs` quantile of `prob_test` (default 97.5%)."""
+
+    binaryOffset: float
+    """Data centering value on the latent scale."""
+
+
+class String(AbstractDtype):
+    """Represent a `numpy.str_` data dtype."""
+
+    dtypes = r'<U\d+'
+
+
+class ProcTime(NamedTuple):
+    """Python representation of the output of R's `proc.time`."""
+
+    user_self: float
+    """CPU seconds charged to the R process in user mode."""
+
+    sys_self: float
+    """CPU seconds charged to the R process in system (kernel) mode."""
+
+    elapsed: float
+    """Wall-clock seconds elapsed."""
+
+    user_child: float
+    """User-mode CPU seconds of forked child processes (`mc.gbart` workers)."""
+
+    sys_child: float
+    """System-mode CPU seconds of forked child processes."""
+
+
+class mc_gbart(RObjectBase):  # noqa: D101 because the R doc is added automatically
+    _rfuncname = 'BART3::mc.gbart'
+
+    LPML: float | None = None
+    """Log pseudo-marginal likelihood; ``None`` without burn-in. Unstable for BART."""
+
+    accept: (
+        Float64[ndarray, ' nskip+ndpost*keepevery']
+        | Float64[ndarray, 'nskip+ndpost*keepevery/mc_cores mc_cores']
+    )
+    """Per-iteration Metropolis-Hastings acceptance rate (per chain for `mc.gbart`).
+
+    Recorded for every MCMC iteration, including the thinned-away ones (unlike
+    `sigma`, which keeps only burn-in plus retained draws).
+    """
+
+    chains: int
+    """Number of MCMC chains, i.e. the `mc_cores` actually used."""
+
+    grp: Float64[ndarray, ' p']
+    """Group index of each column for the sparse (DART) variable-selection prior."""
+
+    ndpost: int
+    """Number of posterior draws kept, after burn-in and thinning."""
+
+    offset: float
+    """Data centering value for the response (link scale for binary)."""
+
+    prob_test: None | Float64[ndarray, 'ndpost m'] = None
+    """Test-point success-probability draws (binary outcomes only)."""
+
+    prob_test_lower: Float64[ndarray, ' m'] | None = None
+    """Lower `probs` quantile of `prob_test` (default 2.5%)."""
+
+    prob_test_mean: None | Float64[ndarray, ' m'] = None
+    """Posterior mean of `prob_test`."""
+
+    prob_test_upper: Float64[ndarray, ' m'] | None = None
+    """Upper `probs` quantile of `prob_test` (default 97.5%)."""
+
+    prob_train: None | Float64[ndarray, 'ndpost n'] = None
+    """Training-point success-probability draws (binary outcomes only)."""
+
+    prob_train_mean: None | Float64[ndarray, ' n'] = None
+    """Posterior mean of `prob_train`."""
+
+    proc_time: ProcTime
+    """Timing of the fit, from R's `proc.time`."""
+
+    rho: float
+    """Concentration of the sparse (DART) prior; defaults to ``sum(1/grp)``."""
+
+    rm_const: Int32[ndarray, '<=p']
+    """0-based indices of the `x_train` columns kept (constant columns dropped)."""
+
+    sigest: float | None = None
+    """Rough residual SD used to set the sigma prior (continuous only).
+
+    ``None`` for binary outcomes; ``nan`` when the `mc.gbart` ``mc_cores > 1``
+    bug overwrites it with a logical missing value.
+    """
+
+    sigma: (
+        Float64[ndarray, ' nskip+ndpost']
+        | Float64[ndarray, 'nskip+ndpost/mc_cores mc_cores']
+        | None
+    ) = None
+    """Error-SD draws including burn-in, continuous only (per chain for `mc.gbart`)."""
+
+    sigma_: Float64[ndarray, ' ndpost'] | None = None
+    """Kept `sigma` draws with burn-in dropped; ``None`` without burn-in."""
+
+    sigma_mean: float | None = None
+    """Mean of `sigma_`; falls back to `sigest` when no draws are kept."""
+
+    treedraws: TreeDraws
+    """Sampled trees: per-variable cutpoint grid and the serialized ensemble."""
+
+    varcount: Int32[ndarray, 'ndpost p']
+    """Per-draw count of splits on each variable, summed over trees."""
+
+    varcount_mean: Float64[ndarray, ' p']
+    """Posterior mean of `varcount` per variable."""
+
+    varprob: Float64[ndarray, 'ndpost p']
+    """Per-draw probability assigned to each variable for splitting."""
+
+    varprob_mean: Float64[ndarray, ' p']
+    """Posterior mean of `varprob` per variable."""
+
+    x_test: Float64[ndarray, ' m <=p'] | None = None
+    """Test design matrix as used (imputed, factors expanded, constant columns dropped)."""
+
+    x_train: Float64[ndarray, ' n <=p']
+    """Training design matrix as used (original scale, not binned; constant columns dropped)."""
+
+    yhat_test: Float64[ndarray, 'ndpost m']
+    """Test-point posterior function draws (latent scale for binary).
+
+    Always present: R's `cgbart` allocates it unconditionally, so without test
+    data it is an empty ``(ndpost, 0)`` array rather than ``None`` (unlike the
+    derived `yhat_test_mean`/`lower`/`upper`, which R only fills when test data
+    is given).
+    """
+
+    yhat_test_lower: Float64[ndarray, ' m'] | None = None
+    """Lower `probs` quantile of `yhat_test` (default 2.5%, continuous only)."""
+
+    yhat_test_mean: Float64[ndarray, ' m'] | None = None
+    """Posterior mean of `yhat_test`."""
+
+    yhat_test_upper: Float64[ndarray, ' m'] | None = None
+    """Upper `probs` quantile of `yhat_test` (default 97.5%, continuous only)."""
+
+    yhat_train: Float64[ndarray, 'ndpost n']
+    """Training-point posterior function draws (latent scale for binary)."""
+
+    yhat_train_lower: Float64[ndarray, ' n'] | None = None
+    """Lower `probs` quantile of `yhat_train` (default 2.5%, continuous only)."""
+
+    yhat_train_mean: Float64[ndarray, ' n'] | None = None
+    """Posterior mean of `yhat_train`."""
+
+    yhat_train_upper: Float64[ndarray, ' n'] | None = None
+    """Upper `probs` quantile of `yhat_train` (default 97.5%, continuous only)."""
+
+    def __init__(self, *args, **kw) -> None:
+        # mc.gbart forks via parallel::mcparallel; cap native thread pools at one
+        # thread across the fork to avoid a libgomp deadlock in the children.
+        with fork_safe_native_threads():
+            super().__init__(*args, **kw)
+
+        # fix up attributes
+        self.chains = self.chains.item()
+        self.ndpost = self.ndpost.astype(int).item()
+        self.offset = self.offset.item()
+        self.proc_time = ProcTime(*map(float, self.proc_time))
+        self.rho = self.rho.item()
+
+        if np.all(self.rm_const < 0):
+            # R reports the dropped constant columns as negative indices into
+            # the original design matrix, while varcount has the kept ones
+            _, kept = self.varcount.shape
+            p = kept + self.rm_const.size
+            rm_const = np.ones(p, bool)
+            rm_const[-self.rm_const - 1] = False
+            self.rm_const = np.arange(p, dtype=np.int32)[rm_const]
+        elif np.all(self.rm_const > 0):
+            self.rm_const -= 1
+        else:  # pragma: no cover - R gives all-positive or all-negative indices
+            msg = 'failed to parse rm.const because indices change sign'
+            raise ValueError(msg)
+
+        if self.LPML is not None:
+            self.LPML = self.LPML.item()
+        if self.sigest is not None:
+            if self.sigest.dtype == bool:
+                # BART3 bug: mc.gbart with mc_cores > 1 overwrites sigest with
+                # its logical-NA default instead of the estimate.
+                self.sigest = float('nan')
+            else:
+                self.sigest = self.sigest.item()
+        if self.sigma_mean is not None:
+            self.sigma_mean = self.sigma_mean.item()
+
+        r_treedraws = cast(NamedList, self.treedraws)
+        cutpoints: NamedList = r_treedraws.getbyname('cutpoints')
+        self.treedraws = {
+            'cutpoints': {
+                i if it.name is None else it.name.item(): it.value
+                for i, it in enumerate(cutpoints.items())
+            },
+            'trees': r_treedraws.getbyname('trees').item(),
+        }
+
+    @partial(rmethod, rname='predict')
+    def _predict(self, newdata: Float64[ndarray, 'm p'], *args, **kwargs) -> object:
+        """Call R's `predict`; returns a matrix (continuous) or a list (binary)."""
+        ...
+
+    def predict(
+        self, newdata: Float64[ndarray, 'm p'], *args, **kwargs
+    ) -> Float64[ndarray, 'ndpost m'] | PredictBinary:
+        """Compute predictions.
+
+        For continuous (`wbart`) fits this is the matrix of posterior
+        latent-function draws. For binary (`pbart`/`lbart`) fits R returns a
+        list, exposed here as a `PredictBinary` dict.
+        """
+        out = self._predict(newdata, *args, **kwargs)
+        if not hasattr(out, 'items'):
+            return out  # continuous: already a matrix
+
+        # binary: convert R's list (a NamedList) to a dict of arrays
+        out = cast(NamedList, out)
+        result = {str(it.name).replace('.', '_'): it.value for it in out.items()}
+        result['binaryOffset'] = result['binaryOffset'].item()
+        return result
+
+
+class bartModelMatrix(RObjectBase):  # noqa: D101 because the R doc is added automatically
+    _rfuncname = 'BART3::bartModelMatrix'
+
+    X: Float64[ndarray, 'N p']
+    """Design matrix: vectors and data frames coerced to numeric, factors expanded to indicators."""
+
+    numcut: Int32[ndarray, ' p']
+    """Number of cutpoints chosen per column."""
+
+    rm_const: Int32[ndarray, '<=p']
+    """0-based indices of the non-constant columns of the expanded design.
+
+    The indices refer to the columns of `X` before removal: ``rm.const=True``
+    removes the constant columns from `X`, `numcut` and `xinfo`, while the
+    default only detects them.
+    """
+
+    xinfo: Float64[ndarray, 'p numcut']
+    """Per-column cutpoint grid, NaN-padded to the maximum cut count."""
+
+    grp: Float64[ndarray, ' p'] | None
+    """Group size of each expanded factor's indicator columns, or None if no factors."""
+
+    def __new__(cls, *args, **kw) -> Float64[ndarray, 'N p'] | RObjectBase:
+        """Match R: return the bare matrix for ``numcut=0``, else a populated instance."""
+        # __init__ cannot change the return type, so the matrix-or-list choice
+        # is made here; returning a non-instance (the matrix) skips __init__.
+        self = super().__new__(cls)
+        self._robject = self._invoke_rfunc(args, kw)
+        if self._has_named_components(self._robject):
+            return self
+        return self._r2py(self._robject)
+
+    def __init__(self, *args, **kw) -> None:
+        # Only reached for the named-list case (numcut > 0); __new__ already
+        # invoked R and stored `_robject`, so just expose its components rather
+        # than calling super().__init__ (which would invoke R a second time).
+        self._set_attrs_from_robject()
+
+        # grp is R NULL unless the input had factor columns; expose it as None.
+        if self.grp is robjects.NULL:
+            self.grp = None
+
+        if np.all(self.rm_const < 0):
+            # R flags detected-constant columns as negative indices into the
+            # pre-removal design matrix; whether they were also removed from X
+            # depends on the rm.const argument, so recover it from the call
+            # (rm.const is the 5th parameter of R's bartModelMatrix)
+            removed = kw.get(
+                'rm.const', kw.get('rm_const', args[4] if len(args) > 4 else False)
+            )
+            _, n_cols = self.X.shape
+            p = n_cols + self.rm_const.size if removed else n_cols
+            rm_const = np.ones(p, bool)
+            rm_const[-self.rm_const - 1] = False
+            self.rm_const = np.arange(p, dtype=np.int32)[rm_const]
+        elif np.all(self.rm_const > 0):
+            self.rm_const -= 1
+        else:  # pragma: no cover - R gives all-positive or all-negative indices
+            msg = 'failed to parse rm.const because indices change sign'
+            raise ValueError(msg)
+
+
+class gbart(mc_gbart):  # noqa: D101 because the R doc is added automatically
+    _rfuncname = 'BART3::gbart'
+
+    accept: Float64[ndarray, ' nskip+ndpost*keepevery']
+    """Per-iteration Metropolis-Hastings acceptance rate (every MCMC iteration)."""
+
+    sigma: Float64[ndarray, ' nskip+ndpost'] | None = None
+    """Error-SD draws including burn-in (continuous only)."""

rbartpackages/__init__.py

@@ -0,0 +1,35 @@
+# rbartpackages/src/rbartpackages/__init__.py
+#
+# Copyright (c) 2025-2026, The rbartpackages Contributors
+#
+# This file is part of rbartpackages.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+"""
+Python wrappers of R BART packages.
+
+Each wrapped R package has its own submodule (``BART``, ``BART3``,
+``bartMachine``, ``dbarts``); import the one you need, e.g.
+``from rbartpackages import BART3``. Importing a wrapper requires the
+corresponding R package to be installed, because the class docstrings are pulled
+from the R documentation at import time.
+"""
+
+from rbartpackages._version import __version__, __version_info__  # noqa: F401

rbartpackages/_base.py

@@ -0,0 +1,293 @@
+# rbartpackages/src/rbartpackages/_base.py
+#
+# Copyright (c) 2024-2026, The rbartpackages Contributors
+#
+# This file is part of rbartpackages.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+import ctypes
+from collections.abc import Callable, Iterable, Iterator, Mapping
+from contextlib import contextmanager
+from functools import wraps
+from re import fullmatch, match
+from textwrap import indent
+from typing import Any
+
+import numpy as np
+from rpy2 import robjects
+from rpy2.robjects import BoolVector, conversion, numpy2ri
+from rpy2.robjects.help import Package
+from rpy2.robjects.methods import RS4
+
+# converter for pandas
+PANDAS_CONVERTER = conversion.Converter('pandas')
+try:
+    from rpy2.robjects import pandas2ri
+except ImportError:  # pragma: no cover - optional dep always present in CI
+    pass
+else:
+    PANDAS_CONVERTER = pandas2ri.converter
+
+# converter for polars
+POLARS_CONVERTER = conversion.Converter('polars')
+try:
+    import polars as pl
+    from rpy2.robjects import pandas2ri
+except ImportError:  # pragma: no cover - optional dep always present in CI
+    pass
+else:
+
+    def polars_to_r(df: pl.DataFrame) -> object:
+        df = df.to_pandas()
+        return pandas2ri.py2rpy(df)
+
+    POLARS_CONVERTER.py2rpy.register(pl.DataFrame, polars_to_r)
+    POLARS_CONVERTER.py2rpy.register(pl.Series, polars_to_r)
+
+# converter for jax
+JAX_CONVERTER = conversion.Converter('jax')
+try:
+    import jax
+except ImportError:  # pragma: no cover - optional dep always present in CI
+    pass
+else:
+
+    def jax_to_r(x: jax.Array) -> object:
+        x = np.asarray(x)
+        if x.ndim == 0:
+            x = x[()]
+        return numpy2ri.py2rpy(x)
+
+    JAX_CONVERTER.py2rpy.register(jax.Array, jax_to_r)
+
+# converter for numpy
+NUMPY_CONVERTER = numpy2ri.converter
+
+
+# converter for BoolVector (why isn't it in the numpy converter?)
+def bool_vector_to_python(x: BoolVector) -> np.ndarray[Any, np.dtype[np.bool_]]:
+    return np.array(x, bool)
+
+
+BOOL_VECTOR_CONVERTER = conversion.Converter('bool_vector')
+BOOL_VECTOR_CONVERTER.rpy2py.register(BoolVector, bool_vector_to_python)
+
+
+# converter for python dictionaries
+DICT_CONVERTER = conversion.Converter('dict')
+
+
+def dict_to_r(x: dict[str, Any]) -> robjects.ListVector:
+    return robjects.ListVector(x)
+
+
+DICT_CONVERTER.py2rpy.register(dict, dict_to_r)
+
+R_IDENTIFIER = r'(?:[a-zA-Z]|\.(?![0-9]))[a-zA-Z0-9._]*'
+
+# In-process native thread pools to cap before R forks. R's
+# `parallel::mcparallel` (used by the `mc.*` BART functions) forks, but GNU
+# libgomp is not fork-safe: a forked child that enters an OpenMP parallel region
+# hangs forever on a barrier because the worker threads do not survive the fork.
+# The threaded OpenBLAS that R's LAPACK calls (e.g. `summary(lm(...))` for the
+# `sigest` default) dispatches through libgomp, so a child deadlocks there.
+# Running these pools single-threaded across the fork stops the thread team from
+# being started at all, sidestepping the deadlock. Each entry is a (getter,
+# setter) pair of C symbols; missing ones (e.g. a single-threaded reference BLAS)
+# are skipped.
+NATIVE_THREAD_POOLS = (
+    ('omp_get_max_threads', 'omp_set_num_threads'),
+    ('openblas_get_num_threads', 'openblas_set_num_threads'),
+)
+
+
+@contextmanager
+def fork_safe_native_threads() -> Iterator[None]:
+    """Cap OpenMP/OpenBLAS thread pools at one thread for the duration.
+
+    Workaround for the deadlock that hangs the children forked by R's
+    ``parallel::mcparallel`` when GNU libgomp has a live thread pool (see
+    `NATIVE_THREAD_POOLS`). The previous thread counts are restored on exit.
+    """
+    handle = ctypes.CDLL(None)
+    saved = []
+    for getter_name, setter_name in NATIVE_THREAD_POOLS:
+        try:
+            getter = getattr(handle, getter_name)
+            setter = getattr(handle, setter_name)
+        except AttributeError:
+            continue
+        getter.restype = ctypes.c_int
+        setter.argtypes = (ctypes.c_int,)
+        saved.append((setter, getter()))
+        setter(1)
+    try:
+        yield
+    finally:
+        for setter, nthreads in saved:
+            setter(nthreads)
+
+
+class RObjectBase:
+    """
+    Base class for Python wrappers of R objects creators.
+
+    Subclasses should define the class attribute `_rfuncname`, and declare
+    stub methods decorated with `rmethod`.
+
+    _rfuncname : str
+        An R function in the format ``'<package>::<function>``. The function is
+        called with the initialization arguments, converted to R objects, and is
+        expected to return an R object. The attributes of the R object are
+        converted to equivalent Python values and set as attributes of the
+        Python object. The R object itself is assigned to the member `_robject`.
+    """
+
+    _converter = (
+        robjects.default_converter
+        + PANDAS_CONVERTER
+        + POLARS_CONVERTER
+        + NUMPY_CONVERTER
+        + BOOL_VECTOR_CONVERTER
+        + JAX_CONVERTER
+        + DICT_CONVERTER
+    )
+    _convctx = conversion.localconverter(_converter)
+
+    def _py2r(self, x: object) -> object:
+        if isinstance(x, __class__):
+            return x._robject  # noqa: SLF001, same-class access
+        with self._convctx:
+            return self._converter.py2rpy(x)
+
+    def _r2py(self, x: object) -> object:
+        with self._convctx:
+            return self._converter.rpy2py(x)
+
+    def _args2r(self, args: Iterable[Any]) -> tuple[Any, ...]:
+        return tuple(map(self._py2r, args))
+
+    def _kw2r(self, kw: Mapping[str, Any]) -> dict[str, Any]:
+        return {key: self._py2r(value) for key, value in kw.items()}
+
+    _rfuncname: str = NotImplemented
+
+    @property
+    def _library(self) -> str:
+        """Parse `_rfuncname` to get the library. Also checks `_rfuncname` is valid."""
+        pattern = rf'^({R_IDENTIFIER})::({R_IDENTIFIER})$'
+        m = match(pattern, self._rfuncname)
+        if m is None:
+            msg = f'Invalid _rfuncname: {self._rfuncname}.'
+            raise ValueError(msg)
+        return m.group(1)
+
+    @staticmethod
+    def _has_named_components(obj: object) -> bool:
+        """Whether `obj` exposes named components to set as attributes.
+
+        Only an R named list qualifies. A bare matrix (as `bartModelMatrix`
+        gives with ``numcut=0``) is excluded by the `ListVector` check: rpy2
+        reports a matrix's dimnames as ``names``, so the names check alone
+        would not cut it out.
+        """
+        names = getattr(obj, 'names', None)
+        return (
+            isinstance(obj, robjects.vectors.ListVector)
+            and names is not None
+            and names is not robjects.NULL
+        )
+
+    def _invoke_rfunc(self, args: Iterable[Any], kw: Mapping[str, Any]) -> object:
+        """Load the namespace and call `_rfuncname` on the converted arguments."""
+        robjects.r(f'loadNamespace("{self._library}")')
+        func = robjects.r(self._rfuncname)
+        return func(*self._args2r(args), **self._kw2r(kw))
+
+    def _set_attrs_from_robject(self) -> None:
+        """Set the named components of `self._robject` as Python attributes."""
+        if self._has_named_components(self._robject):
+            for s, v in self._robject.items():
+                setattr(self, s.replace('.', '_'), self._r2py(v))
+
+    def __init__(self, *args: Any, **kw: Any) -> None:
+        self._robject = self._invoke_rfunc(args, kw)
+        self._set_attrs_from_robject()
+
+    def __init_subclass__(cls, **kw: Any) -> None:
+        """Automatically add R documentation to subclasses."""
+        library, name = cls._rfuncname.split('::')
+        page = Package(library).fetch(name)
+        if cls.__doc__ is None:
+            cls.__doc__ = ''
+        # the R help text is plain text, not valid RST: append it as a literal
+        # block so docutils renders it verbatim instead of misparsing it
+        cls.__doc__ += '\nR documentation::\n\n' + indent(page.to_docstring(), '    ')
+
+
+def rmethod(meth: Callable, *, rname: str | None = None) -> Callable:
+    """Automatically implement a method using the correspoding R method.
+
+    Parameters
+    ----------
+    meth
+        A method in a subclass of `RObjectBase`.
+    rname
+        The name of the method in R. If not specified, use the name of `meth`.
+
+    Returns
+    -------
+    methimpl
+        An implementation of the method that calls the R method. The original
+        implementation of meth is completely discarded.
+
+    Examples
+    --------
+    >>> class MyRObject(RObjectBase):
+    ...     _rfuncname = 'mypackage::myfunction'
+    ...     @partial(rmethod, rname='my.method')
+    ...     def my_method(self, arg1: int, arg2: str):
+    ...         ...
+    """
+    if rname is None:
+        rname = meth.__name__
+
+    # I can't automatically add a docstring to the method because the R class
+    # can be determined at runtime
+
+    @wraps(meth)
+    def impl(self: RObjectBase, *args: Any, **kw: Any) -> object:
+        if isinstance(self._robject, RS4):
+            func = robjects.r['$'](self._robject, rname)
+            out = func(*self._args2r(args), **self._kw2r(kw))
+
+        else:
+            if not fullmatch(R_IDENTIFIER, rname):
+                msg = f'Invalid R method name: {rname}'
+                raise ValueError(msg)
+            rclass = self._robject.rclass[0]
+            func = robjects.r(
+                f'getS3method("{rname}", "{rclass}", envir = asNamespace("{self._library}"))'
+            )
+            out = func(self._robject, *self._args2r(args), **self._kw2r(kw))
+
+        return self._r2py(out)
+
+    return impl

rbartpackages/_version.py

@@ -0,0 +1,2 @@
+__version__ = '0.1.0'
+__version_info__ = (0, 1, 0)

rbartpackages/bartMachine.py

@@ -0,0 +1,58 @@
+# rbartpackages/src/rbartpackages/bartMachine.py
+#
+# Copyright (c) 2025-2026, The rbartpackages Contributors
+#
+# This file is part of rbartpackages.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+"""Python wrapper of the R package bartMachine."""
+
+# ruff: noqa: D102, ANN201, ANN002, ANN003
+
+from rpy2 import robjects
+
+from rbartpackages._base import RObjectBase, rmethod
+
+
+class bartMachine(RObjectBase):  # noqa: D101, because the doc is pulled from R
+    _rfuncname = 'bartMachine::bartMachine'
+
+    def __init__(
+        self, *args, num_cores: int | None = None, megabytes: int = 5000, **kw
+    ) -> None:
+        # bartMachine uses the (incubating) Vector API on JDK 16+, so the JVM
+        # must be started with that module or fitting raises NoClassDefFoundError.
+        robjects.r(
+            'options(java.parameters = c('
+            f'"-Xmx{megabytes:d}m", "--add-modules=jdk.incubator.vector"))'
+        )
+        robjects.r('loadNamespace("bartMachine")')
+        if num_cores is not None:
+            robjects.r(f'bartMachine::set_bart_machine_num_cores({int(num_cores)})')
+        super().__init__(*args, **kw)
+
+    @rmethod
+    def predict(self, *args, **kw): ...
+
+    @rmethod
+    def get_posterior(self, *args, **kw): ...
+
+    @rmethod
+    def get_sigsqs(self, *args, **kw): ...

rbartpackages/dbarts.py

@@ -0,0 +1,152 @@
+# rbartpackages/src/rbartpackages/dbarts.py
+#
+# Copyright (c) 2025-2026, The rbartpackages Contributors
+#
+# This file is part of rbartpackages.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+"""Python wrapper of the R package `dbarts`."""
+
+# ruff: noqa: D101, D102, ANN201, ANN002, ANN003
+
+from rpy2 import robjects
+
+from rbartpackages._base import RObjectBase, rmethod
+
+
+class bart(RObjectBase):
+    """
+    Python interface to dbarts::bart.
+
+    The named numeric vector form of the `splitprobs` parameter must be
+    specified as a dictionary in Python.
+    """
+
+    _rfuncname = 'dbarts::bart'
+    _split_probs = 'splitprobs'
+
+    def __init__(self, *args, **kw) -> None:
+        split_probs = kw.get(self._split_probs)
+        if isinstance(split_probs, dict):
+            values = list(split_probs.values())
+            names = list(split_probs.keys())
+            split_probs = robjects.FloatVector(values)
+            split_probs = robjects.r('setNames')(split_probs, names)
+            kw[self._split_probs] = split_probs
+
+        super().__init__(*args, **kw)
+
+    @rmethod
+    def predict(self, *args, **kw): ...
+
+    @rmethod
+    def extract(self, *args, **kw): ...
+
+    @rmethod
+    def fitted(self, *args, **kw): ...
+
+
+class bart2(bart):
+    """
+    Python interface to dbarts::bart2.
+
+    The named numeric vector form of the `split_probs` parameter must be
+    specified as a dictionary in Python.
+    """
+
+    _rfuncname = 'dbarts::bart2'
+    _split_probs = 'split_probs'
+
+    def __init__(self, formula: str, *args, **kw) -> None:
+        rformula = robjects.Formula(formula)
+        super().__init__(rformula, *args, **kw)
+
+
+class rbart_vi(bart2):
+    """
+    Python interface to dbarts::rbart_vi.
+
+    The named numeric vector form of the `split_probs` parameter must be
+    specified as a dictionary in Python.
+    """
+
+    _rfuncname = 'dbarts::rbart_vi'
+
+
+class dbarts(RObjectBase):
+    _rfuncname = 'dbarts::dbarts'
+
+    @rmethod
+    def run(self, *args, **kw): ...
+
+    @rmethod
+    def sampleTreesFromPrior(self, *args, **kw): ...
+
+    @rmethod
+    def sampleNodeParametersFromPrior(self, *args, **kw): ...
+
+    @rmethod
+    def copy(self, *args, **kw): ...
+
+    @rmethod
+    def show(self, *args, **kw): ...
+
+    @rmethod
+    def predict(self, *args, **kw): ...
+
+    @rmethod
+    def setControl(self, *args, **kw): ...
+
+    @rmethod
+    def setModel(self, *args, **kw): ...
+
+    @rmethod
+    def setData(self, *args, **kw): ...
+
+    @rmethod
+    def setResponse(self, *args, **kw): ...
+
+    @rmethod
+    def setOffset(self, *args, **kw): ...
+
+    @rmethod
+    def setSigma(self, *args, **kw): ...
+
+    @rmethod
+    def setPredictor(self, *args, **kw): ...
+
+    @rmethod
+    def setTestPredictor(self, *args, **kw): ...
+
+    @rmethod
+    def setTestPredictorAndOffset(self, *args, **kw): ...
+
+    @rmethod
+    def setTestOffset(self, *args, **kw): ...
+
+    @rmethod
+    def printTrees(self, *args, **kw): ...
+
+    @rmethod
+    def plotTree(self, *args, **kw): ...
+
+
+class dbartsControl(RObjectBase):
+    _rfuncname = 'dbarts::dbartsControl'

rbartpackages-0.1.0.dist-info/METADATA

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: rbartpackages
+Version: 0.1.0
+Summary: Python wrappers of R BART packages via rpy2
+Author: Giacomo Petrillo
+Author-email: Giacomo Petrillo <info@giacomopetrillo.com>
+License-Expression: MIT
+License-File: LICENSE
+Requires-Dist: rpy2>=3.6.0
+Requires-Dist: numpy>=2.2.6
+Requires-Dist: jaxtyping>=0.3.2
+Requires-Dist: jax>=0.6.1 ; extra == 'jax'
+Requires-Dist: pandas>=2.2.3 ; extra == 'pandas'
+Requires-Dist: polars>=1.30.0 ; extra == 'polars'
+Requires-Dist: pandas>=2.2.3 ; extra == 'polars'
+Requires-Python: >=3.10
+Project-URL: Homepage, https://github.com/bartz-org/rbartpackages
+Project-URL: Documentation, https://bartz-org.github.io/rbartpackages/docs-dev
+Project-URL: Issues, https://github.com/bartz-org/rbartpackages/issues
+Provides-Extra: jax
+Provides-Extra: pandas
+Provides-Extra: polars
+Description-Content-Type: text/markdown
+
+# rbartpackages
+
+Python wrappers of R BART (Bayesian Additive Regression Trees) packages, built on [rpy2](https://rpy2.github.io).
+
+`rbartpackages` lets you call several R BART implementations from Python with a uniform, lightly-typed interface: arguments are converted to R, the fitted R object's components become Python attributes, and the original R documentation is attached to each wrapper class. It currently wraps:
+
+- [`BART`](https://cran.r-project.org/package=BART)
+- [`BART3`](https://github.com/rsparapa/bnptools) (the development superset of `BART`)
+- [`bartMachine`](https://cran.r-project.org/package=bartMachine)
+- [`dbarts`](https://cran.r-project.org/package=dbarts)
+
+## Installation
+
+```sh
+pip install rbartpackages
+```
+
+You also need R with the package(s) you want to use installed (`BART`, `dbarts`, `bartMachine` from CRAN; `BART3` from `rsparapa/bnptools` on GitHub). `bartMachine` additionally requires Java. Optional extras `pandas`, `polars`, and `jax` enable passing those array/frame types directly. See the documentation for details.
+
+## Usage
+
+```python
+import numpy as np
+from rbartpackages import BART3
+
+x_train = np.random.randn(100, 5)
+y_train = x_train[:, 0] + 0.1 * np.random.randn(100)
+
+bart = BART3.gbart(x_train=x_train, y_train=y_train, ndpost=200)
+y_pred = bart.predict(x_train)  # shape (ndpost, n)
+```
+
+R argument names with dots are passed with underscores (`x.train` → `x_train`).
+
+## Links
+
+- [Documentation](https://bartz-org.github.io/rbartpackages/docs-dev)
+- [Repository](https://github.com/bartz-org/rbartpackages)
+- [List of BART packages](https://bartz-org.github.io/bartz/docs-dev/pkglist.html) (maintained in the bartz docs)
+
+These wrappers originated in the [bartz](https://github.com/bartz-org/bartz) project, where they are used to validate against reference R implementations.

rbartpackages-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+rbartpackages/BART.py,sha256=Hs227Xk4NomTkUj0zxtrUlky1TQdtVcrfD5maZFdD9A,13154
+rbartpackages/BART3.py,sha256=_OlOYiXXWQA0HGk6MqDmv-epa81bmP4LC5G2TKimSyc,14499
+rbartpackages/__init__.py,sha256=gRLv9gu9gJ_ry7dts9TKfJh8gH77mlqQYl2JTE1_q1s,1648
+rbartpackages/_base.py,sha256=23KeW39IoFxkZ-t1U9rDwoqJCdgOdDM4gf5L79OLw7o,10521
+rbartpackages/_version.py,sha256=Y4LHeOXBqKMcOffQfycAar5j-JEc-ObkXZE04PES0Tw,51
+rbartpackages/bartMachine.py,sha256=bZPHksSM6w7ebNrfT2XovOLjNmzliuf64OcsBAwZ7Fg,2311
+rbartpackages/dbarts.py,sha256=WuhrFmqfzZCAeo6G6cp5BdYGX9MyIP2giTYgiUJK11c,4078
+rbartpackages-0.1.0.dist-info/licenses/LICENSE,sha256=pouECvzJhnd4fBwt1rCQYLgRpjnCdMAEpqOE8Pwn-sI,1092
+rbartpackages-0.1.0.dist-info/WHEEL,sha256=f5fWSvWsg5Knq5GWa6t1nJIug0Tqo69GqAWD_9LbBKw,81
+rbartpackages-0.1.0.dist-info/METADATA,sha256=zIkothg8jK6V4dyC3zEqgfg-pH9hweqZuq3-g245CbA,2702
+rbartpackages-0.1.0.dist-info/RECORD,,

rbartpackages-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.11.16
+Root-Is-Purelib: true
+Tag: py3-none-any

rbartpackages-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-2026 The rbartpackages Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.