arviz 0.19.0__tar.gz → 0.20.0__tar.gz

{arviz-0.19.0 → arviz-0.20.0}/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Change Log
 
+## v0.20.0 (2024 Sep 28)
+
+### New features
+- Add optimized simultaneous ECDF confidence bands ([2368](https://github.com/arviz-devs/arviz/pull/2368))
+- Add support for setting groups with `idata[group]` ([2374](https://github.com/arviz-devs/arviz/pull/2374))
+
+### Maintenance and fixes
+- Make `dm-tree` and optional dependency ([2379](https://github.com/arviz-devs/arviz/pull/2379))
+- Fix bug in `psislw` modifying input inplace  ([2377](https://github.com/arviz-devs/arviz/pull/2377))
+- Fix behaviour of two dimensional KDE plot with recent matplotlib releases ([2383](https://github.com/arviz-devs/arviz/pull/2383))
+- Make defaults in `plot_compare` more intuitive ([2388](https://github.com/arviz-devs/arviz/pull/2388))
+
+### Documentation
+- Added extensions of virtual environments in [.gitignore](https://github.com/arviz-devs/arviz/blob/main/.gitignore) ([2371](https://github.com/arviz-devs/arviz/issues/2371))
+- Fixed the issue in the [Contribution References Documentation](https://python.arviz.org/en/latest/contributing/index.html) ([2369](https://github.com/arviz-devs/arviz/issues/2369))
+- Improve docstrings for `loo` and `waic`  ([2366](https://github.com/arviz-devs/arviz/pull/2366))
+
 ## v0.19.0 (2024 Jul 19)
 
 ### New features

{arviz-0.19.0 → arviz-0.20.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: arviz
-Version: 0.19.0
+Version: 0.20.0
 Summary: Exploratory analysis of Bayesian models
 Home-page: http://github.com/arviz-devs/arviz
 Author: ArviZ Developers

{arviz-0.19.0 → arviz-0.20.0}/arviz/__init__.py

@@ -1,6 +1,6 @@
 # pylint: disable=wildcard-import,invalid-name,wrong-import-position
 """ArviZ is a library for exploratory analysis of Bayesian models."""
-__version__ = "0.19.0"
+__version__ = "0.20.0"
 
 import logging
 import os

{arviz-0.19.0 → arviz-0.20.0}/arviz/data/base.py

@@ -9,9 +9,13 @@ from copy import deepcopy
 from typing import Any, Callable, Dict, List, Optional, Tuple, TypeVar, Union
 
 import numpy as np
-import tree
 import xarray as xr
 
+try:
+    import tree
+except ImportError:
+    tree = None
+
 try:
     import ujson as json
 except ImportError:
@@ -89,6 +93,9 @@ def _yield_flat_up_to(shallow_tree, input_tree, path=()):
         input_tree.
     """
     # pylint: disable=protected-access
+    if tree is None:
+        raise ImportError("Missing optional dependency 'dm-tree'. Use pip or conda to install it")
+
     if isinstance(shallow_tree, tree._TEXT_OR_BYTES) or not (
         isinstance(shallow_tree, tree.collections_abc.Mapping)
         or tree._is_namedtuple(shallow_tree)
@@ -299,7 +306,7 @@ def numpy_to_data_array(
     return xr.DataArray(ary, coords=coords, dims=dims)
 
 
-def pytree_to_dataset(
+def dict_to_dataset(
     data,
     *,
     attrs=None,
@@ -312,6 +319,8 @@ def pytree_to_dataset(
 ):
     """Convert a dictionary or pytree of numpy arrays to an xarray.Dataset.
 
+    ArviZ itself supports conversion of flat dictionaries.
+    Suport for pytrees requires ``dm-tree`` which is an optional dependency.
     See https://jax.readthedocs.io/en/latest/pytrees.html for what a pytree is, but
     this inclues at least dictionaries and tuple types.
 
@@ -386,10 +395,12 @@ def pytree_to_dataset(
     """
     if dims is None:
         dims = {}
-    try:
-        data = {k[0] if len(k) == 1 else k: v for k, v in _flatten_with_path(data)}
-    except TypeError:  # probably unsortable keys -- the function will still work if
-        pass  # it is an honest dictionary.
+
+    if tree is not None:
+        try:
+            data = {k[0] if len(k) == 1 else k: v for k, v in _flatten_with_path(data)}
+        except TypeError:  # probably unsortable keys -- the function will still work if
+            pass  # it is an honest dictionary.
 
     data_vars = {
         key: numpy_to_data_array(
@@ -406,7 +417,7 @@ def pytree_to_dataset(
     return xr.Dataset(data_vars=data_vars, attrs=make_attrs(attrs=attrs, library=library))
 
 
-dict_to_dataset = pytree_to_dataset
+pytree_to_dataset = dict_to_dataset
 
 
 def make_attrs(attrs=None, library=None):

{arviz-0.19.0 → arviz-0.20.0}/arviz/data/converters.py

@@ -1,9 +1,13 @@
 """High level conversion functions."""
 
 import numpy as np
-import tree
 import xarray as xr
 
+try:
+    from tree import is_nested
+except ImportError:
+    is_nested = lambda obj: False
+
 from .base import dict_to_dataset
 from .inference_data import InferenceData
 from .io_beanmachine import from_beanmachine
@@ -107,7 +111,7 @@ def convert_to_inference_data(obj, *, group="posterior", coords=None, dims=None,
         dataset = obj.to_dataset()
     elif isinstance(obj, dict):
         dataset = dict_to_dataset(obj, coords=coords, dims=dims)
-    elif tree.is_nested(obj) and not isinstance(obj, (list, tuple)):
+    elif is_nested(obj) and not isinstance(obj, (list, tuple)):
         dataset = dict_to_dataset(obj, coords=coords, dims=dims)
     elif isinstance(obj, np.ndarray):
         dataset = dict_to_dataset({"x": obj}, coords=coords, dims=dims)
@@ -122,7 +126,7 @@ def convert_to_inference_data(obj, *, group="posterior", coords=None, dims=None,
             "xarray dataarray",
             "xarray dataset",
             "dict",
-            "pytree",
+            "pytree (if 'dm-tree' is installed)",
             "netcdf filename",
             "numpy array",
             "pystan fit",

{arviz-0.19.0 → arviz-0.20.0}/arviz/data/inference_data.py

@@ -266,6 +266,14 @@ class InferenceData(Mapping[str, xr.Dataset]):
             raise KeyError(key)
         return getattr(self, key)
 
+    def __setitem__(self, key: str, value: xr.Dataset):
+        """Set item by key and update group list accordingly."""
+        if key.startswith(WARMUP_TAG):
+            self._groups_warmup.append(key)
+        else:
+            self._groups.append(key)
+        setattr(self, key, value)
+
     def groups(self) -> List[str]:
         """Return all groups present in InferenceData object."""
         return self._groups_all

{arviz-0.19.0 → arviz-0.20.0}/arviz/plots/compareplot.py

@@ -11,9 +11,9 @@ def plot_compare(
     comp_df,
     insample_dev=False,
     plot_standard_error=True,
-    plot_ic_diff=True,
+    plot_ic_diff=False,
     order_by_rank=True,
-    legend=True,
+    legend=False,
     title=True,
     figsize=None,
     textsize=None,
@@ -45,12 +45,12 @@ def plot_compare(
         penalization given by the effective number of parameters (p_loo or p_waic).
     plot_standard_error : bool, default True
         Plot the standard error of the ELPD.
-    plot_ic_diff : bool, default True
+    plot_ic_diff : bool, default False
         Plot standard error of the difference in ELPD between each model
         and the top-ranked model.
     order_by_rank : bool, default True
         If True ensure the best model is used as reference.
-    legend : bool, default True
+    legend : bool, default False
         Add legend to figure.
     figsize : (float, float), optional
         If `None`, size is (6, num of models) inches.

{arviz-0.19.0 → arviz-0.20.0}/arviz/plots/ecdfplot.py

@@ -73,6 +73,7 @@ def plot_ecdf(
         - False: No confidence bands are plotted (default).
         - True: Plot bands computed with the default algorithm (subject to change)
         - "pointwise": Compute the pointwise (i.e. marginal) confidence band.
+        - "optimized": Use optimization to estimate a simultaneous confidence band.
         - "simulated": Use Monte Carlo simulation to estimate a simultaneous confidence
           band.
 
@@ -216,8 +217,7 @@ def plot_ecdf(
         >>> pit_vals = distribution.cdf(sample)
         >>> uniform_dist = uniform(0, 1)
         >>> az.plot_ecdf(
-        >>>     pit_vals, cdf=uniform_dist.cdf,
-        >>>     rvs=uniform_dist.rvs, confidence_bands=True
+        >>>     pit_vals, cdf=uniform_dist.cdf, confidence_bands=True,
         >>> )
 
     Plot an ECDF-difference plot of PIT values.
@@ -226,8 +226,8 @@ def plot_ecdf(
         :context: close-figs
 
         >>> az.plot_ecdf(
-        >>>     pit_vals, cdf = uniform_dist.cdf, rvs = uniform_dist.rvs,
-        >>>     confidence_bands = True, difference = True
+        >>>     pit_vals, cdf = uniform_dist.cdf, confidence_bands = True,
+        >>>     difference = True
         >>> )
     """
     if confidence_bands is True:
@@ -238,9 +238,12 @@ def plot_ecdf(
             )
             confidence_bands = "pointwise"
         else:
-            confidence_bands = "simulated"
-    elif confidence_bands == "simulated" and pointwise:
-        raise ValueError("Cannot specify both `confidence_bands='simulated'` and `pointwise=True`")
+            confidence_bands = "auto"
+        # if pointwise specified, confidence_bands must be a bool or 'pointwise'
+    elif confidence_bands not in [False, "pointwise"] and pointwise:
+        raise ValueError(
+            f"Cannot specify both `confidence_bands='{confidence_bands}'` and `pointwise=True`"
+        )
 
     if fpr is not None:
         warnings.warn(
@@ -298,7 +301,7 @@ def plot_ecdf(
             "`eval_points` explicitly.",
             BehaviourChangeWarning,
         )
-        if confidence_bands == "simulated":
+        if confidence_bands in ["optimized", "simulated"]:
             warnings.warn(
                 "For simultaneous bands to be correctly calibrated, specify `eval_points` "
                 "independent of the `values`"
@@ -319,6 +322,11 @@ def plot_ecdf(
 
     if confidence_bands:
         ndraws = len(values)
+        if confidence_bands == "auto":
+            if ndraws < 200 or num_trials >= 250 * np.sqrt(ndraws):
+                confidence_bands = "optimized"
+            else:
+                confidence_bands = "simulated"
         x_bands = eval_points
         lower, higher = ecdf_confidence_band(
             ndraws,

{arviz-0.19.0 → arviz-0.20.0}/arviz/plots/forestplot.py

@@ -55,8 +55,8 @@ def plot_forest(
         Specify the kind of plot:
 
         * The ``kind="forestplot"`` generates credible intervals, where the central points are the
-          estimated posterior means, the thick lines are the central quartiles, and the thin lines
-          represent the :math:`100\times`(`hdi_prob`)% highest density intervals.
+          estimated posterior median, the thick lines are the central quartiles, and the thin lines
+          represent the :math:`100\times(hdi\_prob)\%` highest density intervals.
         * The ``kind="ridgeplot"`` option generates density plots (kernel density estimate or
           histograms) in the same graph. Ridge plots can be configured to have different overlap,
           truncation bounds and quantile markers.

{arviz-0.19.0 → arviz-0.20.0}/arviz/plots/kdeplot.py

@@ -72,7 +72,7 @@ def plot_kde(
         If True plot the 2D KDE using contours, otherwise plot a smooth 2D KDE.
     hdi_probs : list, optional
         Plots highest density credibility regions for the provided probabilities for a 2D KDE.
-        Defaults to matplotlib chosen levels with no fixed probability associated.
+        Defaults to [0.5, 0.8, 0.94].
     fill_last : bool, default False
         If True fill the last contour of the 2D KDE plot.
     figsize : (float, float), optional
@@ -270,6 +270,9 @@ def plot_kde(
         gridsize = (128, 128) if contour else (256, 256)
         density, xmin, xmax, ymin, ymax = _fast_kde_2d(values, values2, gridsize=gridsize)
 
+        if hdi_probs is None:
+            hdi_probs = [0.5, 0.8, 0.94]
+
         if hdi_probs is not None:
             # Check hdi probs are within bounds (0, 1)
             if min(hdi_probs) <= 0 or max(hdi_probs) >= 1:
@@ -289,7 +292,11 @@ def plot_kde(
                     "Using 'hdi_probs' in favor of 'levels'.",
                     UserWarning,
                 )
-            contour_kwargs["levels"] = contour_level_list
+
+            if backend == "bokeh":
+                contour_kwargs["levels"] = contour_level_list
+            elif backend == "matplotlib":
+                contour_kwargs["levels"] = contour_level_list[1:]
 
             contourf_kwargs = _init_kwargs_dict(contourf_kwargs)
             if "levels" in contourf_kwargs:

{arviz-0.19.0 → arviz-0.20.0}/arviz/stats/ecdf_utils.py

@@ -1,10 +1,25 @@
 """Functions for evaluating ECDFs and their confidence bands."""
 
+import math
 from typing import Any, Callable, Optional, Tuple
 import warnings
 
 import numpy as np
 from scipy.stats import uniform, binom
+from scipy.optimize import minimize_scalar
+
+try:
+    from numba import jit, vectorize
+except ImportError:
+
+    def jit(*args, **kwargs):  # pylint: disable=unused-argument
+        return lambda f: f
+
+    def vectorize(*args, **kwargs):  # pylint: disable=unused-argument
+        return lambda f: f
+
+
+from ..utils import Numba
 
 
 def compute_ecdf(sample: np.ndarray, eval_points: np.ndarray) -> np.ndarray:
@@ -73,7 +88,7 @@ def ecdf_confidence_band(
     eval_points: np.ndarray,
     cdf_at_eval_points: np.ndarray,
     prob: float = 0.95,
-    method="simulated",
+    method="optimized",
     **kwargs,
 ) -> Tuple[np.ndarray, np.ndarray]:
     """Compute the `prob`-level confidence band for the ECDF.
@@ -92,6 +107,7 @@ def ecdf_confidence_band(
     method : string, default "simulated"
         The method used to compute the confidence band. Valid options are:
         - "pointwise": Compute the pointwise (i.e. marginal) confidence band.
+        - "optimized": Use optimization to estimate a simultaneous confidence band.
         - "simulated": Use Monte Carlo simulation to estimate a simultaneous confidence band.
           `rvs` must be provided.
     rvs: callable, optional
@@ -115,12 +131,18 @@ def ecdf_confidence_band(
 
     if method == "pointwise":
         prob_pointwise = prob
+    elif method == "optimized":
+        prob_pointwise = _optimize_simultaneous_ecdf_band_probability(
+            ndraws, eval_points, cdf_at_eval_points, prob=prob, **kwargs
+        )
     elif method == "simulated":
         prob_pointwise = _simulate_simultaneous_ecdf_band_probability(
             ndraws, eval_points, cdf_at_eval_points, prob=prob, **kwargs
         )
     else:
-        raise ValueError(f"Unknown method {method}. Valid options are 'pointwise' or 'simulated'.")
+        raise ValueError(
+            f"Unknown method {method}. Valid options are 'pointwise', 'optimized', or 'simulated'."
+        )
 
     prob_lower, prob_upper = _get_pointwise_confidence_band(
         prob_pointwise, ndraws, cdf_at_eval_points
@@ -129,6 +151,139 @@ def ecdf_confidence_band(
     return prob_lower, prob_upper
 
 
+def _update_ecdf_band_interior_probabilities(
+    prob_left: np.ndarray,
+    interval_left: np.ndarray,
+    interval_right: np.ndarray,
+    p: float,
+    ndraws: int,
+) -> np.ndarray:
+    """Update the probability that an ECDF has been within the envelope including at the current
+    point.
+
+    Arguments
+    ---------
+    prob_left : np.ndarray
+        For each point in the interior at the previous point, the joint probability that it and all
+        points before are in the interior.
+    interval_left : np.ndarray
+        The set of points in the interior at the previous point.
+    interval_right : np.ndarray
+        The set of points in the interior at the current point.
+    p : float
+        The probability of any given point found between the previous point and the current one.
+    ndraws : int
+        Number of draws in the original dataset.
+
+    Returns
+    -------
+    prob_right : np.ndarray
+        For each point in the interior at the current point, the joint probability that it and all
+        previous points are in the interior.
+    """
+    interval_left = interval_left[:, np.newaxis]
+    prob_conditional = binom.pmf(interval_right, ndraws - interval_left, p, loc=interval_left)
+    prob_right = prob_left.dot(prob_conditional)
+    return prob_right
+
+
+@vectorize(["float64(int64, int64, float64, int64)"])
+def _binom_pmf(k, n, p, loc):
+    k -= loc
+    if k < 0 or k > n:
+        return 0.0
+    if p == 0:
+        return 1.0 if k == 0 else 0.0
+    if p == 1:
+        return 1.0 if k == n else 0.0
+    if k == 0:
+        return (1 - p) ** n
+    if k == n:
+        return p**n
+    lbinom = math.lgamma(n + 1) - math.lgamma(k + 1) - math.lgamma(n - k + 1)
+    return np.exp(lbinom + k * np.log(p) + (n - k) * np.log1p(-p))
+
+
+@jit(nopython=True)
+def _update_ecdf_band_interior_probabilities_numba(
+    prob_left: np.ndarray,
+    interval_left: np.ndarray,
+    interval_right: np.ndarray,
+    p: float,
+    ndraws: int,
+) -> np.ndarray:
+    interval_left = interval_left[:, np.newaxis]
+    prob_conditional = _binom_pmf(interval_right, ndraws - interval_left, p, interval_left)
+    prob_right = prob_left.dot(prob_conditional)
+    return prob_right
+
+
+def _ecdf_band_interior_probability(prob_between_points, ndraws, lower_count, upper_count):
+    interval_left = np.arange(1)
+    prob_interior = np.ones(1)
+    for i in range(prob_between_points.shape[0]):
+        interval_right = np.arange(lower_count[i], upper_count[i])
+        prob_interior = _update_ecdf_band_interior_probabilities(
+            prob_interior, interval_left, interval_right, prob_between_points[i], ndraws
+        )
+        interval_left = interval_right
+    return prob_interior.sum()
+
+
+@jit(nopython=True)
+def _ecdf_band_interior_probability_numba(prob_between_points, ndraws, lower_count, upper_count):
+    interval_left = np.arange(1)
+    prob_interior = np.ones(1)
+    for i in range(prob_between_points.shape[0]):
+        interval_right = np.arange(lower_count[i], upper_count[i])
+        prob_interior = _update_ecdf_band_interior_probabilities_numba(
+            prob_interior, interval_left, interval_right, prob_between_points[i], ndraws
+        )
+        interval_left = interval_right
+    return prob_interior.sum()
+
+
+def _ecdf_band_optimization_objective(
+    prob_pointwise: float,
+    cdf_at_eval_points: np.ndarray,
+    ndraws: int,
+    prob_target: float,
+) -> float:
+    """Objective function for optimizing the simultaneous confidence band probability."""
+    lower, upper = _get_pointwise_confidence_band(prob_pointwise, ndraws, cdf_at_eval_points)
+    lower_count = (lower * ndraws).astype(int)
+    upper_count = (upper * ndraws).astype(int) + 1
+    cdf_with_zero = np.insert(cdf_at_eval_points[:-1], 0, 0)
+    prob_between_points = (cdf_at_eval_points - cdf_with_zero) / (1 - cdf_with_zero)
+    if Numba.numba_flag:
+        prob_interior = _ecdf_band_interior_probability_numba(
+            prob_between_points, ndraws, lower_count, upper_count
+        )
+    else:
+        prob_interior = _ecdf_band_interior_probability(
+            prob_between_points, ndraws, lower_count, upper_count
+        )
+    return abs(prob_interior - prob_target)
+
+
+def _optimize_simultaneous_ecdf_band_probability(
+    ndraws: int,
+    eval_points: np.ndarray,  # pylint: disable=unused-argument
+    cdf_at_eval_points: np.ndarray,
+    prob: float = 0.95,
+    **kwargs,  # pylint: disable=unused-argument
+):
+    """Estimate probability for simultaneous confidence band using optimization.
+
+    This function simulates the pointwise probability needed to construct pointwise confidence bands
+    that form a `prob`-level confidence envelope for the ECDF of a sample.
+    """
+    cdf_at_eval_points = np.unique(cdf_at_eval_points)
+    objective = lambda p: _ecdf_band_optimization_objective(p, cdf_at_eval_points, ndraws, prob)
+    prob_pointwise = minimize_scalar(objective, bounds=(prob, 1), method="bounded").x
+    return prob_pointwise
+
+
 def _simulate_simultaneous_ecdf_band_probability(
     ndraws: int,
     eval_points: np.ndarray,

{arviz-0.19.0 → arviz-0.20.0}/arviz/stats/stats.py

@@ -711,16 +711,19 @@ def loo(data, pointwise=None, var_name=None, reff=None, scale=None):
     Returns
     -------
     ELPDData object (inherits from :class:`pandas.Series`) with the following row/attributes:
-    elpd: approximated expected log pointwise predictive density (elpd)
+    elpd_loo: approximated expected log pointwise predictive density (elpd)
     se: standard error of the elpd
     p_loo: effective number of parameters
-    shape_warn: bool
-        True if the estimated shape parameter of Pareto distribution is greater than a thresold
-        value  for one or more samples. For a sample size S, the thresold is compute as
-        min(1 - 1/log10(S), 0.7)
-    loo_i: array of pointwise predictive accuracy, only if pointwise True
+    n_samples: number of samples
+    n_data_points: number of data points
+    warning: bool
+        True if the estimated shape parameter of Pareto distribution is greater than
+        ``good_k``.
+    loo_i: :class:`~xarray.DataArray` with the pointwise predictive accuracy,
+            only if pointwise=True
     pareto_k: array of Pareto shape values, only if pointwise True
     scale: scale of the elpd
+    good_k: For a sample size S, the thresold is compute as min(1 - 1/log10(S), 0.7)
 
         The returned object has a custom print method that overrides pd.Series method.
 
@@ -914,6 +917,7 @@ def psislw(log_weights, reff=1.0):
            ...: az.psislw(-log_likelihood, reff=0.8)
 
     """
+    log_weights = deepcopy(log_weights)
     if hasattr(log_weights, "__sample__"):
         n_samples = len(log_weights.__sample__)
         shape = [
@@ -1580,7 +1584,9 @@ def waic(data, pointwise=None, var_name=None, scale=None, dask_kwargs=None):
     elpd_waic: approximated expected log pointwise predictive density (elpd)
     se: standard error of the elpd
     p_waic: effective number parameters
-    var_warn: bool
+    n_samples: number of samples
+    n_data_points: number of data points
+    warning: bool
         True if posterior variance of the log predictive densities exceeds 0.4
     waic_i: :class:`~xarray.DataArray` with the pointwise predictive accuracy,
             only if pointwise=True

{arviz-0.19.0 → arviz-0.20.0}/arviz/tests/base_tests/test_data.py

@@ -44,6 +44,10 @@ from ..helpers import (  # pylint: disable=unused-import
     models,
 )
 
+# Check if dm-tree is installed
+dm_tree_installed = importlib.util.find_spec("tree") is not None  # pylint: disable=invalid-name
+skip_tests = (not dm_tree_installed) and ("ARVIZ_REQUIRE_ALL_DEPS" not in os.environ)
+
 
 @pytest.fixture(autouse=True)
 def no_remote_data(monkeypatch, tmpdir):
@@ -895,6 +899,11 @@ class TestInferenceData:  # pylint: disable=too-many-public-methods
         assert escape(repr(idata)) in html
         xr.set_options(display_style=display_style)
 
+    def test_setitem(self, data_random):
+        data_random["new_group"] = data_random.posterior
+        assert "new_group" in data_random.groups()
+        assert hasattr(data_random, "new_group")
+
     def test_add_groups(self, data_random):
         data = np.random.normal(size=(4, 500, 8))
         idata = data_random
@@ -1076,6 +1085,7 @@ def test_dict_to_dataset():
     assert set(dataset.b.coords) == {"chain", "draw", "c"}
 
 
+@pytest.mark.skipif(skip_tests, reason="test requires dm-tree which is not installed")
 def test_nested_dict_to_dataset():
     datadict = {
         "top": {"a": np.random.randn(100), "b": np.random.randn(1, 100, 10)},

{arviz-0.19.0 → arviz-0.20.0}/arviz/tests/base_tests/test_plots_matplotlib.py

@@ -1285,10 +1285,11 @@ def test_plot_ecdf_eval_points():
     assert axes is not None
 
 
-@pytest.mark.parametrize("confidence_bands", [True, "pointwise", "simulated"])
-def test_plot_ecdf_confidence_bands(confidence_bands):
+@pytest.mark.parametrize("confidence_bands", [True, "pointwise", "optimized", "simulated"])
+@pytest.mark.parametrize("ndraws", [100, 10_000])
+def test_plot_ecdf_confidence_bands(confidence_bands, ndraws):
     """Check that all confidence_bands values correctly accepted"""
-    data = np.random.randn(4, 1000)
+    data = np.random.randn(4, ndraws // 4)
     axes = plot_ecdf(data, confidence_bands=confidence_bands, cdf=norm(0, 1).cdf)
     assert axes is not None
 
@@ -1326,6 +1327,8 @@ def test_plot_ecdf_error():
     # contradictory confidence band types
     with pytest.raises(ValueError):
         plot_ecdf(data, cdf=dist.cdf, confidence_bands="simulated", pointwise=True)
+    with pytest.raises(ValueError):
+        plot_ecdf(data, cdf=dist.cdf, confidence_bands="optimized", pointwise=True)
     plot_ecdf(data, cdf=dist.cdf, confidence_bands=True, pointwise=True)
     plot_ecdf(data, cdf=dist.cdf, confidence_bands="pointwise")
 

{arviz-0.19.0 → arviz-0.20.0}/arviz/tests/base_tests/test_stats_ecdf_utils.py

@@ -10,6 +10,13 @@ from ...stats.ecdf_utils import (
     _get_pointwise_confidence_band,
 )
 
+try:
+    import numba  # pylint: disable=unused-import
+
+    numba_options = [True, False]
+except ImportError:
+    numba_options = [False]
+
 
 def test_compute_ecdf():
     """Test compute_ecdf function."""
@@ -109,9 +116,15 @@ def test_get_pointwise_confidence_band(dist, prob, ndraws, num_trials=1_000, see
     ids=["continuous", "continuous default rvs", "discrete"],
 )
 @pytest.mark.parametrize("ndraws", [10_000])
-@pytest.mark.parametrize("method", ["pointwise", "simulated"])
-def test_ecdf_confidence_band(dist, rvs, prob, ndraws, method, num_trials=1_000, seed=57):
+@pytest.mark.parametrize("method", ["pointwise", "optimized", "simulated"])
+@pytest.mark.parametrize("use_numba", numba_options)
+def test_ecdf_confidence_band(
+    dist, rvs, prob, ndraws, method, use_numba, num_trials=1_000, seed=57
+):
     """Test test_ecdf_confidence_band."""
+    if use_numba and method != "optimized":
+        pytest.skip("Numba only used in optimized method")
+
     eval_points = np.linspace(*dist.interval(0.99), 10)
     cdf_at_eval_points = dist.cdf(eval_points)
     random_state = np.random.default_rng(seed)

{arviz-0.19.0 → arviz-0.20.0}/arviz.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: arviz
-Version: 0.19.0
+Version: 0.20.0
 Summary: Exploratory analysis of Bayesian models
 Home-page: http://github.com/arviz-devs/arviz
 Author: ArviZ Developers

{arviz-0.19.0 → arviz-0.20.0}/requirements-docs.txt

@@ -15,3 +15,4 @@ sphinx_design
 sphinx-codeautolink>=0.9.0
 jupyter-sphinx
 sphinxcontrib-youtube
+dm-tree>=0.1.8

{arviz-0.19.0 → arviz-0.20.0}/requirements-optional.txt

@@ -6,3 +6,4 @@ ujson
 dask[distributed]
 zarr>=2.5.0,<3
 xarray-datatree
+dm-tree>=0.1.8

{arviz-0.19.0 → arviz-0.20.0}/requirements.txt

@@ -4,7 +4,6 @@ numpy>=1.23.0
 scipy>=1.9.0
 packaging
 pandas>=1.5.0
-dm-tree>=0.1.8
 xarray>=2022.6.0
 h5netcdf>=1.0.2
 typing_extensions>=4.1.0