arviz 0.20.0__tar.gz → 0.22.0__tar.gz

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

@@ -1,5 +1,40 @@
 # Change Log
 
+## v0.22.0 (2025 Jul 9)
+
+### New features
+- `plot_pair` now has more flexible support for `reference_values` ([2438](https://github.com/arviz-devs/arviz/pull/2438))
+- Make `arviz.from_numpyro(..., dims=None)` automatically infer dims from the numpyro model based on its numpyro.plate structure
+
+### Maintenance and fixes
+- `reference_values` and `labeller` now work together in `plot_pair` ([2437](https://github.com/arviz-devs/arviz/issues/2437))
+- Fix `plot_lm` for multidimensional data ([2408](https://github.com/arviz-devs/arviz/issues/2408))
+- Add [`scipy-stubs`](https://github.com/scipy/scipy-stubs) as a development dependency ([2445](https://github.com/arviz-devs/arviz/pull/2445))
+- Test compare dataframe stays consistent independently of input order ([2407](https://github.com/arviz-devs/arviz/pull/2407))
+- Fix hdi_probs behaviour in 2d `plot_kde` ([2460](https://github.com/arviz-devs/arviz/pull/2460))
+
+### Documentation
+- Added documentation for `reference_values` ([2438](https://github.com/arviz-devs/arviz/pull/2438))
+- Add migration guide page to help switch over to the new `arviz-xyz` libraries ([2459](https://github.com/arviz-devs/arviz/pull/2459))
+
+## v0.21.0 (2025 Mar 06)
+
+### New features
+
+### Maintenance and fixes
+- Make `arviz.data.generate_dims_coords` handle `dims` and `default_dims` consistently ([2395](https://github.com/arviz-devs/arviz/pull/2395))
+- Only emit a warning for custom groups in `InferenceData` when explicitly requested ([2401](https://github.com/arviz-devs/arviz/pull/2401))
+- Splits Bayes Factor computation out from `az.plot_bf` into `az.bayes_factor` ([2402](https://github.com/arviz-devs/arviz/issues/2402))
+- Update `method="sd"` of `mcse` to not use normality assumption ([2167](https://github.com/arviz-devs/arviz/pull/2167))
+- Add exception in `az.plot_hdi` for `x` of type `str` ([2413](https://github.com/arviz-devs/arviz/pull/2413))
+
+### Documentation
+- Add example of ECDF comparison plot to gallery ([2178](https://github.com/arviz-devs/arviz/pull/2178))
+- Change Twitter to X, including the icon ([2418](https://github.com/arviz-devs/arviz/pull/2418))
+- Update Bokeh link in Installation.rst ([2425](https://github.com/arviz-devs/arviz/pull/2425))
+- Add missing periods to the ArviZ community page ([2426](https://github.com/arviz-devs/arviz/pull/2426))
+- Fix missing docstring ([2430](https://github.com/arviz-devs/arviz/pull/2430))
+
 ## v0.20.0 (2024 Sep 28)
 
 ### New features

{arviz-0.20.0 → arviz-0.22.0}/CONTRIBUTING.md

@@ -1,8 +1,9 @@
 # Contributing to ArviZ
 This document outlines only the most common contributions.
 Please see the [Contributing guide](https://python.arviz.org/en/latest/contributing/index.html)
-on our documentation for a better view of how can you contribute to ArviZ.
+on our documentation for a better view of how you can contribute to ArviZ.
 We welcome a wide range of contributions, not only code!
+Even improving documentation or fixing typos is a valuable contribution to ArviZ.
 
 ## Reporting issues
 If you encounter any bug or incorrect behaviour while using ArviZ,

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

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

{arviz-0.20.0 → arviz-0.22.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.20.0"
+__version__ = "0.22.0"
 
 import logging
 import os
@@ -8,6 +8,7 @@ import os
 from matplotlib.colors import LinearSegmentedColormap
 from matplotlib.pyplot import style
 import matplotlib as mpl
+from packaging import version
 
 
 class Logger(logging.Logger):
@@ -41,8 +42,12 @@ from . import preview
 
 # add ArviZ's styles to matplotlib's styles
 _arviz_style_path = os.path.join(os.path.dirname(__file__), "plots", "styles")
-style.core.USER_LIBRARY_PATHS.append(_arviz_style_path)
-style.core.reload_library()
+if version.parse(mpl.__version__) >= version.parse("3.11.0.dev0"):
+    style.USER_LIBRARY_PATHS.append(_arviz_style_path)
+    style.reload_library()
+else:
+    style.core.USER_LIBRARY_PATHS.append(_arviz_style_path)
+    style.core.reload_library()
 
 
 if not logging.root.handlers:

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

@@ -201,10 +201,10 @@ def generate_dims_coords(
     for i, dim_len in enumerate(shape):
         idx = i + len([dim for dim in default_dims if dim in dims])
         if len(dims) < idx + 1:
-            dim_name = f"{var_name}_dim_{idx}"
+            dim_name = f"{var_name}_dim_{i}"
             dims.append(dim_name)
         elif dims[idx] is None:
-            dim_name = f"{var_name}_dim_{idx}"
+            dim_name = f"{var_name}_dim_{i}"
             dims[idx] = dim_name
         dim_name = dims[idx]
         if dim_name not in coords:

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

@@ -102,6 +102,7 @@ class InferenceData(Mapping[str, xr.Dataset]):
     def __init__(
         self,
         attrs: Union[None, Mapping[Any, Any]] = None,
+        warn_on_custom_groups: bool = False,
         **kwargs: Union[xr.Dataset, List[xr.Dataset], Tuple[xr.Dataset, xr.Dataset]],
     ) -> None:
         """Initialize InferenceData object from keyword xarray datasets.
@@ -110,6 +111,9 @@ class InferenceData(Mapping[str, xr.Dataset]):
         ----------
         attrs : dict
             sets global attribute for InferenceData object.
+        warn_on_custom_groups : bool, default False
+            Emit a warning when custom groups are present in the InferenceData.
+            "custom group" means any group whose name isn't defined in :ref:`schema`
         kwargs :
             Keyword arguments of xarray datasets
 
@@ -154,9 +158,10 @@ class InferenceData(Mapping[str, xr.Dataset]):
         for key in kwargs:
             if key not in SUPPORTED_GROUPS_ALL:
                 key_list.append(key)
-                warnings.warn(
-                    f"{key} group is not defined in the InferenceData scheme", UserWarning
-                )
+                if warn_on_custom_groups:
+                    warnings.warn(
+                        f"{key} group is not defined in the InferenceData scheme", UserWarning
+                    )
         for key in key_list:
             dataset = kwargs[key]
             dataset_warmup = None
@@ -527,24 +532,27 @@ class InferenceData(Mapping[str, xr.Dataset]):
         return filename
 
     def to_datatree(self):
-        """Convert InferenceData object to a :class:`~datatree.DataTree`."""
+        """Convert InferenceData object to a :class:`~xarray.DataTree`."""
         try:
-            from datatree import DataTree
-        except ModuleNotFoundError as err:
-            raise ModuleNotFoundError(
-                "datatree must be installed in order to use InferenceData.to_datatree"
+            from xarray import DataTree
+        except ImportError as err:
+            raise ImportError(
+                "xarray must be have DataTree in order to use InferenceData.to_datatree. "
+                "Update to xarray>=2024.11.0"
             ) from err
         return DataTree.from_dict({group: ds for group, ds in self.items()})
 
     @staticmethod
     def from_datatree(datatree):
-        """Create an InferenceData object from a :class:`~datatree.DataTree`.
+        """Create an InferenceData object from a :class:`~xarray.DataTree`.
 
         Parameters
         ----------
         datatree : DataTree
         """
-        return InferenceData(**{group: sub_dt.to_dataset() for group, sub_dt in datatree.items()})
+        return InferenceData(
+            **{group: child.to_dataset() for group, child in datatree.children.items()}
+        )
 
     def to_dict(self, groups=None, filter_groups=None):
         """Convert InferenceData to a dictionary following xarray naming conventions.
@@ -792,12 +800,20 @@ class InferenceData(Mapping[str, xr.Dataset]):
         ----------
         https://zarr.readthedocs.io/
         """
-        try:  # Check zarr
+        try:
             import zarr
-
-            assert version.parse(zarr.__version__) >= version.parse("2.5.0")
-        except (ImportError, AssertionError) as err:
-            raise ImportError("'to_zarr' method needs Zarr (2.5.0+) installed.") from err
+        except ImportError as err:
+            raise ImportError("'to_zarr' method needs Zarr (>=2.5.0,<3) installed.") from err
+        if version.parse(zarr.__version__) < version.parse("2.5.0"):
+            raise ImportError(
+                "Found zarr<2.5.0, please upgrade to a zarr (>=2.5.0,<3) to use 'to_zarr'"
+            )
+        if version.parse(zarr.__version__) >= version.parse("3.0.0.dev0"):
+            raise ImportError(
+                "Found zarr>=3, which is not supported by ArviZ. Instead, you can use "
+                "'dt = InfereceData.to_datatree' followed by 'dt.to_zarr()' "
+                "(needs xarray>=2024.11.0)"
+            )
 
         # Check store type and create store if necessary
         if store is None:
@@ -846,10 +862,18 @@ class InferenceData(Mapping[str, xr.Dataset]):
         """
         try:
             import zarr
-
-            assert version.parse(zarr.__version__) >= version.parse("2.5.0")
-        except (ImportError, AssertionError) as err:
-            raise ImportError("'to_zarr' method needs Zarr (2.5.0+) installed.") from err
+        except ImportError as err:
+            raise ImportError("'from_zarr' method needs Zarr (>=2.5.0,<3) installed.") from err
+        if version.parse(zarr.__version__) < version.parse("2.5.0"):
+            raise ImportError(
+                "Found zarr<2.5.0, please upgrade to a zarr (>=2.5.0,<3) to use 'from_zarr'"
+            )
+        if version.parse(zarr.__version__) >= version.parse("3.0.0.dev0"):
+            raise ImportError(
+                "Found zarr>=3, which is not supported by ArviZ. Instead, you can use "
+                "'xarray.open_datatree' followed by 'arviz.InferenceData.from_datatree' "
+                "(needs xarray>=2024.11.0)"
+            )
 
         # Check store type and create store if necessary
         if isinstance(store, str):
@@ -1467,7 +1491,9 @@ class InferenceData(Mapping[str, xr.Dataset]):
         else:
             return out
 
-    def add_groups(self, group_dict=None, coords=None, dims=None, **kwargs):
+    def add_groups(
+        self, group_dict=None, coords=None, dims=None, warn_on_custom_groups=False, **kwargs
+    ):
         """Add new groups to InferenceData object.
 
         Parameters
@@ -1479,6 +1505,9 @@ class InferenceData(Mapping[str, xr.Dataset]):
         dims : dict of {str : list of str}, optional
             Dimensions of each variable. The keys are variable names, values are lists of
             coordinates.
+        warn_on_custom_groups : bool, default False
+            Emit a warning when custom groups are present in the InferenceData.
+            "custom group" means any group whose name isn't defined in :ref:`schema`
         kwargs : dict, optional
             The keyword arguments form of group_dict. One of group_dict or kwargs must be provided.
 
@@ -1521,9 +1550,8 @@ class InferenceData(Mapping[str, xr.Dataset]):
             import xarray as xr
             from xarray_einstats.stats import XrDiscreteRV
             from scipy.stats import poisson
-            dist = XrDiscreteRV(poisson)
-            log_lik = xr.Dataset()
-            log_lik["home_points"] = dist.logpmf(obs["home_points"], np.exp(post["atts"]))
+            dist = XrDiscreteRV(poisson, np.exp(post["atts"]))
+            log_lik = dist.logpmf(obs["home_points"]).to_dataset(name="home_points")
             idata2.add_groups({"log_likelihood": log_lik})
             idata2
 
@@ -1542,7 +1570,7 @@ class InferenceData(Mapping[str, xr.Dataset]):
         if repeated_groups:
             raise ValueError(f"{repeated_groups} group(s) already exists.")
         for group, dataset in group_dict.items():
-            if group not in SUPPORTED_GROUPS_ALL:
+            if warn_on_custom_groups and group not in SUPPORTED_GROUPS_ALL:
                 warnings.warn(
                     f"The group {group} is not defined in the InferenceData scheme",
                     UserWarning,
@@ -1597,7 +1625,7 @@ class InferenceData(Mapping[str, xr.Dataset]):
                     else:
                         self._groups.append(group)
 
-    def extend(self, other, join="left"):
+    def extend(self, other, join="left", warn_on_custom_groups=False):
         """Extend InferenceData with groups from another InferenceData.
 
         Parameters
@@ -1608,6 +1636,9 @@ class InferenceData(Mapping[str, xr.Dataset]):
             Defines how the two decide which group to keep when the same group is
             present in both objects. 'left' will discard the group in ``other`` whereas 'right'
             will keep the group in ``other`` and discard the one in ``self``.
+        warn_on_custom_groups : bool, default False
+            Emit a warning when custom groups are present in the InferenceData.
+            "custom group" means any group whose name isn't defined in :ref:`schema`
 
         Examples
         --------
@@ -1651,7 +1682,7 @@ class InferenceData(Mapping[str, xr.Dataset]):
         for group in other._groups_all:  # pylint: disable=protected-access
             if hasattr(self, group) and join == "left":
                 continue
-            if group not in SUPPORTED_GROUPS_ALL:
+            if warn_on_custom_groups and group not in SUPPORTED_GROUPS_ALL:
                 warnings.warn(
                     f"{group} group is not defined in the InferenceData scheme", UserWarning
                 )

{arviz-0.20.0 → arviz-0.22.0}/arviz/data/io_datatree.py

@@ -4,7 +4,7 @@ from .inference_data import InferenceData
 
 
 def to_datatree(data):
-    """Convert InferenceData object to a :class:`~datatree.DataTree`.
+    """Convert InferenceData object to a :class:`~xarray.DataTree`.
 
     Parameters
     ----------
@@ -14,7 +14,7 @@ def to_datatree(data):
 
 
 def from_datatree(datatree):
-    """Create an InferenceData object from a :class:`~datatree.DataTree`.
+    """Create an InferenceData object from a :class:`~xarray.DataTree`.
 
     Parameters
     ----------

{arviz-0.20.0 → arviz-0.22.0}/arviz/data/io_numpyro.py

@@ -1,7 +1,8 @@
 """NumPyro-specific conversion code."""
 
+from collections import defaultdict
 import logging
-from typing import Callable, Optional
+from typing import Any, Callable, Optional, Dict, List, Tuple
 
 import numpy as np
 
@@ -13,6 +14,70 @@ from .inference_data import InferenceData
 _log = logging.getLogger(__name__)
 
 
+def _add_dims(dims_a: Dict[str, List[str]], dims_b: Dict[str, List[str]]) -> Dict[str, List[str]]:
+    merged = defaultdict(list)
+
+    for k, v in dims_a.items():
+        merged[k].extend(v)
+
+    for k, v in dims_b.items():
+        merged[k].extend(v)
+
+    # Convert back to a regular dict
+    return dict(merged)
+
+
+def infer_dims(
+    model: Callable,
+    model_args: Optional[Tuple[Any, ...]] = None,
+    model_kwargs: Optional[Dict[str, Any]] = None,
+) -> Dict[str, List[str]]:
+
+    from numpyro import handlers, distributions as dist
+    from numpyro.ops.pytree import PytreeTrace
+    from numpyro.infer.initialization import init_to_sample
+    import jax
+
+    model_args = tuple() if model_args is None else model_args
+    model_kwargs = dict() if model_args is None else model_kwargs
+
+    def _get_dist_name(fn):
+        if isinstance(fn, (dist.Independent, dist.ExpandedDistribution, dist.MaskedDistribution)):
+            return _get_dist_name(fn.base_dist)
+        return type(fn).__name__
+
+    def get_trace():
+        # We use `init_to_sample` to get around ImproperUniform distribution,
+        # which does not have `sample` method.
+        subs_model = handlers.substitute(
+            handlers.seed(model, 0),
+            substitute_fn=init_to_sample,
+        )
+        trace = handlers.trace(subs_model).get_trace(*model_args, **model_kwargs)
+        # Work around an issue where jax.eval_shape does not work
+        # for distribution output (e.g. the function `lambda: dist.Normal(0, 1)`)
+        # Here we will remove `fn` and store its name in the trace.
+        for _, site in trace.items():
+            if site["type"] == "sample":
+                site["fn_name"] = _get_dist_name(site.pop("fn"))
+            elif site["type"] == "deterministic":
+                site["fn_name"] = "Deterministic"
+        return PytreeTrace(trace)
+
+    # We use eval_shape to avoid any array computation.
+    trace = jax.eval_shape(get_trace).trace
+
+    named_dims = {}
+
+    for name, site in trace.items():
+        batch_dims = [frame.name for frame in sorted(site["cond_indep_stack"], key=lambda x: x.dim)]
+        event_dims = list(site.get("infer", {}).get("event_dims", []))
+        if site["type"] in ["sample", "deterministic"] and (batch_dims or event_dims):
+            named_dims[name] = batch_dims + event_dims
+
+    return named_dims
+
+
 class NumPyroConverter:
     """Encapsulate NumPyro specific logic."""
 
@@ -36,6 +101,7 @@ class NumPyroConverter:
         coords=None,
         dims=None,
         pred_dims=None,
+        extra_event_dims=None,
         num_chains=1,
     ):
         """Convert NumPyro data into an InferenceData object.
@@ -58,9 +124,12 @@ class NumPyroConverter:
         coords : dict[str] -> list[str]
             Map of dimensions to coordinates
         dims : dict[str] -> list[str]
-            Map variable names to their coordinates
+            Map variable names to their coordinates. Will be inferred if they are not provided.
         pred_dims: dict
             Dims for predictions data. Map variable names to their coordinates.
+        extra_event_dims: dict
+            Extra event dims for deterministic sites. Maps event dims that couldnt be inferred to
+            their coordinates.
         num_chains: int
             Number of chains used for sampling. Ignored if posterior is present.
         """
@@ -80,6 +149,7 @@ class NumPyroConverter:
         self.coords = coords
         self.dims = dims
         self.pred_dims = pred_dims
+        self.extra_event_dims = extra_event_dims
         self.numpyro = numpyro
 
         def arbitrary_element(dct):
@@ -107,6 +177,10 @@ class NumPyroConverter:
             # model arguments and keyword arguments
             self._args = self.posterior._args  # pylint: disable=protected-access
             self._kwargs = self.posterior._kwargs  # pylint: disable=protected-access
+            self.dims = self.dims if self.dims is not None else self.infer_dims()
+            self.pred_dims = (
+                self.pred_dims if self.pred_dims is not None else self.infer_pred_dims()
+            )
         else:
             self.nchains = num_chains
             get_from = None
@@ -325,6 +399,23 @@ class NumPyroConverter:
             }
         )
 
+    @requires("posterior")
+    @requires("model")
+    def infer_dims(self) -> Dict[str, List[str]]:
+        dims = infer_dims(self.model, self._args, self._kwargs)
+        if self.extra_event_dims:
+            dims = _add_dims(dims, self.extra_event_dims)
+        return dims
+
+    @requires("posterior")
+    @requires("model")
+    @requires("predictions")
+    def infer_pred_dims(self) -> Dict[str, List[str]]:
+        dims = infer_dims(self.model, self._args, self._kwargs)
+        if self.extra_event_dims:
+            dims = _add_dims(dims, self.extra_event_dims)
+        return dims
+
 
 def from_numpyro(
     posterior=None,
@@ -339,10 +430,25 @@ def from_numpyro(
     coords=None,
     dims=None,
     pred_dims=None,
+    extra_event_dims=None,
     num_chains=1,
 ):
     """Convert NumPyro data into an InferenceData object.
 
+    If no dims are provided, this will infer batch dim names from NumPyro model plates.
+    For event dim names, such as with the ZeroSumNormal, `infer={"event_dims":dim_names}`
+    can be provided in numpyro.sample, i.e.::
+
+        # equivalent to dims entry, {"gamma": ["groups"]}
+        gamma = numpyro.sample(
+            "gamma",
+            dist.ZeroSumNormal(1, event_shape=(n_groups,)),
+            infer={"event_dims":["groups"]}
+        )
+
+    There is also an additional `extra_event_dims` input to cover any edge cases, for instance
+    deterministic sites with event dims (which dont have an `infer` argument to provide metadata).
+
     For a usage example read the
     :ref:`Creating InferenceData section on from_numpyro <creating_InferenceData>`
 
@@ -364,9 +470,10 @@ def from_numpyro(
     coords : dict[str] -> list[str]
         Map of dimensions to coordinates
     dims : dict[str] -> list[str]
-        Map variable names to their coordinates
+        Map variable names to their coordinates. Will be inferred if they are not provided.
     pred_dims: dict
-        Dims for predictions data. Map variable names to their coordinates.
+        Dims for predictions data. Map variable names to their coordinates. Default behavior is to
+        infer dims if this is not provided
     num_chains: int
         Number of chains used for sampling. Ignored if posterior is present.
     """
@@ -382,5 +489,6 @@ def from_numpyro(
         coords=coords,
         dims=dims,
         pred_dims=pred_dims,
+        extra_event_dims=extra_event_dims,
         num_chains=num_chains,
     ).to_inference_data()

{arviz-0.20.0 → arviz-0.22.0}/arviz/plots/autocorrplot.py

@@ -4,7 +4,7 @@ from ..data import convert_to_dataset
 from ..labels import BaseLabeller
 from ..sel_utils import xarray_var_iter
 from ..rcparams import rcParams
-from ..utils import _var_names
+from ..utils import _var_names, get_coords
 from .plot_utils import default_grid, filter_plotters_list, get_plotting_function
 
 
@@ -14,6 +14,7 @@ def plot_autocorr(
     filter_vars=None,
     max_lag=None,
     combined=False,
+    coords=None,
     grid=None,
     figsize=None,
     textsize=None,
@@ -42,6 +43,8 @@ def plot_autocorr(
         interpret `var_names` as substrings of the real variables names. If "regex",
         interpret `var_names` as regular expressions on the real variables names. See
         :ref:`this section <common_filter_vars>` for usage examples.
+    coords: mapping, optional
+        Coordinates of var_names to be plotted. Passed to :meth:`xarray.Dataset.sel`
     max_lag : int, optional
         Maximum lag to calculate autocorrelation. By Default, the plot displays the
         first 100 lag or the total number of draws, whichever is smaller.
@@ -124,11 +127,18 @@ def plot_autocorr(
     if max_lag is None:
         max_lag = min(100, data["draw"].shape[0])
 
+    if coords is None:
+        coords = {}
+
     if labeller is None:
         labeller = BaseLabeller()
 
     plotters = filter_plotters_list(
-        list(xarray_var_iter(data, var_names, combined, dim_order=["chain", "draw"])),
+        list(
+            xarray_var_iter(
+                get_coords(data, coords), var_names, combined, dim_order=["chain", "draw"]
+            )
+        ),
         "plot_autocorr",
     )
     rows, cols = default_grid(len(plotters), grid=grid)

{arviz-0.20.0 → arviz-0.22.0}/arviz/plots/backends/__init__.py

@@ -213,10 +213,11 @@ def _copy_docstring(lib, function):
 
 
 # TODO: try copying substitutions too, or autoreplace them ourselves
-output_notebook.__doc__ += "\n\n" + _copy_docstring("bokeh.plotting", "output_notebook").replace(
-    "|save|", "save"
-).replace("|show|", "show")
-output_file.__doc__ += "\n\n" + _copy_docstring("bokeh.plotting", "output_file").replace(
-    "|save|", "save"
-).replace("|show|", "show")
-ColumnDataSource.__doc__ += "\n\n" + _copy_docstring("bokeh.models", "ColumnDataSource")
+if output_notebook.__doc__ is not None:  # if run with python -OO, __doc__ is stripped
+    output_notebook.__doc__ += "\n\n" + _copy_docstring(
+        "bokeh.plotting", "output_notebook"
+    ).replace("|save|", "save").replace("|show|", "show")
+    output_file.__doc__ += "\n\n" + _copy_docstring("bokeh.plotting", "output_file").replace(
+        "|save|", "save"
+    ).replace("|show|", "show")
+    ColumnDataSource.__doc__ += "\n\n" + _copy_docstring("bokeh.models", "ColumnDataSource")

{arviz-0.20.0 → arviz-0.22.0}/arviz/plots/backends/bokeh/bpvplot.py

@@ -41,6 +41,7 @@ def plot_bpv(
     plot_ref_kwargs,
     backend_kwargs,
     show,
+    smoothing,
 ):
     """Bokeh bpv plot."""
     if backend_kwargs is None:
@@ -90,6 +91,9 @@ def plot_bpv(
         obs_vals = obs_vals.flatten()
         pp_vals = pp_vals.reshape(total_pp_samples, -1)
 
+        if (obs_vals.dtype.kind == "i" or pp_vals.dtype.kind == "i") and smoothing is True:
+            obs_vals, pp_vals = smooth_data(obs_vals, pp_vals)
+
         if kind == "p_value":
             tstat_pit = np.mean(pp_vals <= obs_vals, axis=-1)
             x_s, tstat_pit_dens = kde(tstat_pit)
@@ -115,9 +119,6 @@ def plot_bpv(
                     )
 
         elif kind == "u_value":
-            if obs_vals.dtype.kind == "i" or pp_vals.dtype.kind == "i":
-                obs_vals, pp_vals = smooth_data(obs_vals, pp_vals)
-
             tstat_pit = np.mean(pp_vals <= obs_vals, axis=0)
             x_s, tstat_pit_dens = kde(tstat_pit)
             ax_i.line(x_s, tstat_pit_dens, color=color)

{arviz-0.20.0 → arviz-0.22.0}/arviz/plots/backends/bokeh/densityplot.py

@@ -225,7 +225,11 @@ def _d_helper(
 
     if point_estimate is not None:
         est = calculate_point_estimate(point_estimate, vec, bw, circular)
-        plotted.append(ax.circle(est, 0, fill_color=color, line_color="black", size=markersize))
+        plotted.append(
+            ax.scatter(
+                est, 0, marker="circle", fill_color=color, line_color="black", size=markersize
+            )
+        )
 
     _title = Title()
     _title.text = vname

{arviz-0.20.0 → arviz-0.22.0}/arviz/plots/backends/bokeh/dotplot.py

@@ -47,7 +47,10 @@ def plot_dot(
 
     if plot_kwargs is None:
         plot_kwargs = {}
-        plot_kwargs.setdefault("color", dotcolor)
+    else:
+        plot_kwargs = plot_kwargs.copy()
+    plot_kwargs.setdefault("color", dotcolor)
+    plot_kwargs.setdefault("marker", "circle")
 
     if linewidth is None:
         linewidth = auto_linewidth
@@ -95,7 +98,7 @@ def plot_dot(
     stack_locs, stack_count = wilkinson_algorithm(values, binwidth)
     x, y = layout_stacks(stack_locs, stack_count, binwidth, stackratio, rotated)
 
-    ax.circle(x, y, radius=dotsize * (binwidth / 2), **plot_kwargs, radius_dimension="y")
+    ax.scatter(x, y, radius=dotsize * (binwidth / 2), **plot_kwargs, radius_dimension="y")
     if rotated:
         ax.xaxis.major_tick_line_color = None
         ax.xaxis.minor_tick_line_color = None

{arviz-0.20.0 → arviz-0.22.0}/arviz/plots/backends/bokeh/essplot.py

@@ -73,12 +73,14 @@ def plot_ess(
     for (var_name, selection, isel, x), ax_ in zip(
         plotters, (item for item in ax.flatten() if item is not None)
     ):
-        bulk_points = ax_.circle(np.asarray(xdata), np.asarray(x), size=6)
+        bulk_points = ax_.scatter(np.asarray(xdata), np.asarray(x), marker="circle", size=6)
         if kind == "evolution":
             bulk_line = ax_.line(np.asarray(xdata), np.asarray(x))
             ess_tail = ess_tail_dataset[var_name].sel(**selection)
             tail_points = ax_.line(np.asarray(xdata), np.asarray(ess_tail), color="orange")
-            tail_line = ax_.circle(np.asarray(xdata), np.asarray(ess_tail), size=6, color="orange")
+            tail_line = ax_.scatter(
+                np.asarray(xdata), np.asarray(ess_tail), marker="circle", size=6, color="orange"
+            )
         elif rug:
             if rug_kwargs is None:
                 rug_kwargs = {}