arviz 0.21.0__tar.gz → 0.23.0__tar.gz

{arviz-0.21.0 → arviz-0.23.0}/CHANGELOG.md

@@ -1,5 +1,30 @@
 # Change Log
 
+## v0.23.0 (2025 Des 9)
+
+### Maintenance and fixes
+- Fix numpyro jax incompatibility. ([2465](https://github.com/arviz-devs/arviz/pull/2465))
+- Avoid closing unloaded files in `from_netcdf()` ([2463](https://github.com/arviz-devs/arviz/issues/2463))
+- Fix sign error in lp parsed in from_numpyro ([2468](https://github.com/arviz-devs/arviz/issues/2468))
+- Fix attrs persistance in idata-datatree conversions ([2476](https://github.com/arviz-devs/arviz/issues/2476))
+
+## 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
@@ -8,7 +33,7 @@
 - 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)) 
+- 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

{arviz-0.21.0 → arviz-0.23.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.21.0 → arviz-0.23.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: arviz
-Version: 0.21.0
+Version: 0.23.0
 Summary: Exploratory analysis of Bayesian models
 Home-page: http://github.com/arviz-devs/arviz
 Author: ArviZ Developers
@@ -20,9 +20,42 @@ Classifier: Topic :: Scientific/Engineering :: Visualization
 Classifier: Topic :: Scientific/Engineering :: Mathematics
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: setuptools>=60.0.0
+Requires-Dist: matplotlib>=3.8
+Requires-Dist: numpy>=1.26.0
+Requires-Dist: scipy>=1.11.0
+Requires-Dist: packaging
+Requires-Dist: pandas>=2.1.0
+Requires-Dist: xarray>=2023.7.0
+Requires-Dist: h5netcdf>=1.0.2
+Requires-Dist: typing_extensions>=4.1.0
+Requires-Dist: xarray-einstats>=0.3
 Provides-Extra: all
+Requires-Dist: numba; extra == "all"
+Requires-Dist: netcdf4; extra == "all"
+Requires-Dist: bokeh>=3; extra == "all"
+Requires-Dist: contourpy; extra == "all"
+Requires-Dist: ujson; extra == "all"
+Requires-Dist: dask[distributed]; extra == "all"
+Requires-Dist: zarr<3,>=2.5.0; extra == "all"
+Requires-Dist: xarray>=2024.11.0; extra == "all"
+Requires-Dist: dm-tree>=0.1.8; extra == "all"
 Provides-Extra: preview
-License-File: LICENSE
+Requires-Dist: arviz-base[h5netcdf]; extra == "preview"
+Requires-Dist: arviz-stats[xarray]; extra == "preview"
+Requires-Dist: arviz-plots; extra == "preview"
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 <img src="https://raw.githubusercontent.com/arviz-devs/arviz-project/main/arviz_logos/ArviZ.png#gh-light-mode-only" width=200></img>
 <img src="https://raw.githubusercontent.com/arviz-devs/arviz-project/main/arviz_logos/ArviZ_white.png#gh-dark-mode-only" width=200></img>

{arviz-0.21.0 → arviz-0.23.0}/arviz/__init__.py

@@ -1,13 +1,54 @@
 # pylint: disable=wildcard-import,invalid-name,wrong-import-position
 """ArviZ is a library for exploratory analysis of Bayesian models."""
-__version__ = "0.21.0"
+__version__ = "0.23.0"
 
 import logging
 import os
+import re
 
 from matplotlib.colors import LinearSegmentedColormap
 from matplotlib.pyplot import style
 import matplotlib as mpl
+from packaging import version
+
+
+def _warn_once_per_day():
+    from .preview import info
+
+    # skip warning if all 3 arviz subpackages are already installed
+    pat = re.compile(r"arviz_(base|stats|plots) available")
+    if len(pat.findall(info)) == 3:
+        return
+
+    import datetime
+    from warnings import warn
+    from pathlib import Path
+
+    warning_dir = Path.home() / "arviz_data"
+    warning_dir.mkdir(exist_ok=True)
+
+    stamp_file = warning_dir / "daily_warning"
+    today = datetime.date.today()
+
+    if stamp_file.exists():
+        last_date = datetime.date.fromisoformat(stamp_file.read_text().strip())
+    else:
+        last_date = None
+
+    if last_date != today:
+        warn(
+            "\nArviZ is undergoing a major refactor to improve flexibility and extensibility "
+            "while maintaining a user-friendly interface."
+            "\nSome upcoming changes may be backward incompatible."
+            "\nFor details and migration guidance, visit: "
+            "https://python.arviz.org/en/latest/user_guide/migration_guide.html",
+            FutureWarning,
+        )
+
+        stamp_file.write_text(today.isoformat())
+
+
+_warn_once_per_day()
 
 
 class Logger(logging.Logger):
@@ -41,8 +82,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:
@@ -328,4 +373,4 @@ except ModuleNotFoundError:
 
 
 # clean namespace
-del os, logging, LinearSegmentedColormap, Logger, mpl
+del os, re, logging, version, LinearSegmentedColormap, Logger, mpl

{arviz-0.21.0 → arviz-0.23.0}/arviz/data/converters.py

@@ -2,6 +2,7 @@
 
 import numpy as np
 import xarray as xr
+import pandas as pd
 
 try:
     from tree import is_nested
@@ -44,6 +45,8 @@ def convert_to_inference_data(obj, *, group="posterior", coords=None, dims=None,
             | dict: creates an xarray dataset as the only group
             | numpy array: creates an xarray dataset as the only group, gives the
                          array an arbitrary name
+            | object with __array__: converts to numpy array, then creates an xarray dataset as
+                         the only group, gives the array an arbitrary name
     group : str
         If `obj` is a dict or numpy array, assigns the resulting xarray
         dataset to this group. Default: "posterior".
@@ -115,6 +118,13 @@ def convert_to_inference_data(obj, *, group="posterior", coords=None, dims=None,
         dataset = dict_to_dataset(obj, coords=coords, dims=dims)
     elif isinstance(obj, np.ndarray):
         dataset = dict_to_dataset({"x": obj}, coords=coords, dims=dims)
+    elif (
+        hasattr(obj, "__array__")
+        and callable(getattr(obj, "__array__"))
+        and (not isinstance(obj, pd.DataFrame))
+    ):
+        obj = obj.__array__()
+        dataset = dict_to_dataset({"x": obj}, coords=coords, dims=dims)
     elif isinstance(obj, (list, tuple)) and isinstance(obj[0], str) and obj[0].endswith(".csv"):
         if group == "sample_stats":
             kwargs["posterior"] = kwargs.pop(group)
@@ -129,6 +139,7 @@ def convert_to_inference_data(obj, *, group="posterior", coords=None, dims=None,
             "pytree (if 'dm-tree' is installed)",
             "netcdf filename",
             "numpy array",
+            "object with __array__",
             "pystan fit",
             "emcee fit",
             "pyro mcmc fit",

{arviz-0.21.0 → arviz-0.23.0}/arviz/data/inference_data.py

@@ -430,11 +430,12 @@ class InferenceData(Mapping[str, xr.Dataset]):
                         if re.search(key, group):
                             group_kws = kws
                 group_kws.setdefault("engine", engine)
-                with xr.open_dataset(filename, group=f"{base_group}/{group}", **group_kws) as data:
-                    if rcParams["data.load"] == "eager":
+                data = xr.open_dataset(filename, group=f"{base_group}/{group}", **group_kws)
+                if rcParams["data.load"] == "eager":
+                    with data:
                         groups[group] = data.load()
-                    else:
-                        groups[group] = data
+                else:
+                    groups[group] = data
 
             with xr.open_dataset(filename, engine=engine, group=base_group) as data:
                 attrs.update(data.load().attrs)
@@ -532,24 +533,30 @@ 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()})
+        dt = DataTree.from_dict({group: ds for group, ds in self.items()})
+        dt.attrs = self.attrs
+        return dt
 
     @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(
+            attrs=datatree.attrs,
+            **{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.
@@ -797,12 +804,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 = InferenceData.to_datatree' followed by 'dt.to_zarr()' "
+                "(needs xarray>=2024.11.0)"
+            )
 
         # Check store type and create store if necessary
         if store is None:
@@ -851,10 +866,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):
@@ -1531,9 +1554,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
 

{arviz-0.21.0 → arviz-0.23.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.21.0 → arviz-0.23.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
@@ -167,7 +241,10 @@ class NumPyroConverter:
                 continue
             name = rename_key.get(stat, stat)
             value = value.copy()
-            data[name] = value
+            if stat == "potential_energy":
+                data[name] = -value
+            else:
+                data[name] = value
             if stat == "num_steps":
                 data["tree_depth"] = np.log2(value).astype(int) + 1
         return dict_to_dataset(
@@ -325,6 +402,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 +433,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 +473,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 +492,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.21.0 → arviz-0.23.0}/arviz/data/io_pyjags.py

@@ -277,7 +277,7 @@ def _extract_arviz_dict_from_inference_data(
 
 
 def _convert_arviz_dict_to_pyjags_dict(
-    samples: tp.Mapping[str, np.ndarray]
+    samples: tp.Mapping[str, np.ndarray],
 ) -> tp.Mapping[str, np.ndarray]:
     """
     Convert and ArviZ dictionary to a PyJAGS dictionary.

{arviz-0.21.0 → arviz-0.23.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.21.0 → arviz-0.23.0}/arviz/plots/backends/bokeh/hdiplot.py

@@ -21,9 +21,13 @@ def plot_hdi(ax, x_data, y_data, color, figsize, plot_kwargs, fill_kwargs, backe
     plot_kwargs["color"] = vectorized_to_hex(plot_kwargs.get("color", color))
     plot_kwargs.setdefault("alpha", 0)
 
-    fill_kwargs = {} if fill_kwargs is None else fill_kwargs
-    fill_kwargs["color"] = vectorized_to_hex(fill_kwargs.get("color", color))
-    fill_kwargs.setdefault("alpha", 0.5)
+    fill_kwargs = {} if fill_kwargs is None else fill_kwargs.copy()
+    # Convert matplotlib color to bokeh fill_color if needed
+    if "color" in fill_kwargs and "fill_color" not in fill_kwargs:
+        fill_kwargs["fill_color"] = vectorized_to_hex(fill_kwargs.pop("color"))
+    else:
+        fill_kwargs["fill_color"] = vectorized_to_hex(fill_kwargs.get("fill_color", color))
+    fill_kwargs.setdefault("fill_alpha", fill_kwargs.pop("alpha", 0.5))
 
     figsize, *_ = _scale_fig_size(figsize, None)
 
@@ -38,9 +42,6 @@ def plot_hdi(ax, x_data, y_data, color, figsize, plot_kwargs, fill_kwargs, backe
     plot_kwargs.setdefault("line_color", plot_kwargs.pop("color"))
     plot_kwargs.setdefault("line_alpha", plot_kwargs.pop("alpha", 0))
 
-    fill_kwargs.setdefault("fill_color", fill_kwargs.pop("color"))
-    fill_kwargs.setdefault("fill_alpha", fill_kwargs.pop("alpha", 0))
-
     ax.patch(
         np.concatenate((x_data, x_data[::-1])),
         np.concatenate((y_data[:, 0], y_data[:, 1][::-1])),