arviz 0.23.3__py3-none-any.whl → 1.0.0rc0__py3-none-any.whl

arviz/plots/tsplot.py

@@ -1,440 +0,0 @@
-"""Plot timeseries data."""
-
-import warnings
-import numpy as np
-
-from ..sel_utils import xarray_var_iter
-from ..rcparams import rcParams
-from .plot_utils import default_grid, get_plotting_function
-
-
-def plot_ts(
-    idata,
-    y,
-    x=None,
-    y_hat=None,
-    y_holdout=None,
-    y_forecasts=None,
-    x_holdout=None,
-    plot_dim=None,
-    holdout_dim=None,
-    num_samples=100,
-    backend=None,
-    backend_kwargs=None,
-    y_kwargs=None,
-    y_hat_plot_kwargs=None,
-    y_mean_plot_kwargs=None,
-    vline_kwargs=None,
-    textsize=None,
-    figsize=None,
-    legend=True,
-    axes=None,
-    show=None,
-):
-    """Plot timeseries data.
-
-    Parameters
-    ----------
-    idata : InferenceData
-        :class:`arviz.InferenceData` object.
-    y : str
-        Variable name from ``observed_data``.
-        Values to be plotted on y-axis before holdout.
-    x : str, Optional
-        Values to be plotted on x-axis before holdout.
-        If None, coords of ``y`` dims is chosen.
-    y_hat : str, optional
-        Variable name from ``posterior_predictive``.
-        Assumed to be of shape ``(chain, draw, *y_dims)``.
-    y_holdout : str, optional
-        Variable name from ``observed_data``.
-        It represents the observed data after the holdout period.
-        Useful while testing the model, when you want to compare
-        observed test data with predictions/forecasts.
-    y_forecasts : str, optional
-        Variable name from ``posterior_predictive``.
-        It represents forecasts (posterior predictive) values after holdout period.
-        Useful to compare observed vs predictions/forecasts.
-        Assumed shape ``(chain, draw, *shape)``.
-    x_holdout : str, Defaults to coords of y.
-        Variable name from ``constant_data``.
-        If None, coords of ``y_holdout`` or
-        coords of ``y_forecast`` (either of the two available) is chosen.
-    plot_dim: str, Optional
-        Should be present in ``y.dims``.
-        Necessary for selection of ``x`` if ``x`` is None and ``y`` is multidimensional.
-    holdout_dim: str, Optional
-        Should be present in ``y_holdout.dims`` or ``y_forecats.dims``.
-        Necessary to choose ``x_holdout`` if ``x`` is None and
-        if ``y_holdout`` or ``y_forecasts`` is multidimensional.
-    num_samples : int, default 100
-        Number of posterior predictive samples drawn from ``y_hat`` and ``y_forecasts``.
-    backend : {"matplotlib", "bokeh"}, default "matplotlib"
-        Select plotting backend.
-    y_kwargs : dict, optional
-        Passed to :meth:`matplotlib.axes.Axes.plot` in matplotlib.
-    y_hat_plot_kwargs : dict, optional
-        Passed to :meth:`matplotlib.axes.Axes.plot` in matplotlib.
-    y_mean_plot_kwargs : dict, optional
-        Passed to :meth:`matplotlib.axes.Axes.plot` in matplotlib.
-    vline_kwargs : dict, optional
-        Passed to :meth:`matplotlib.axes.Axes.axvline` in matplotlib.
-    backend_kwargs : dict, optional
-        These are kwargs specific to the backend being used. Passed to
-        :func:`matplotlib.pyplot.subplots`.
-    figsize : tuple, optional
-        Figure size. If None, it will be defined automatically.
-    textsize : float, optional
-        Text size scaling factor for labels, titles and lines. If None, it will be
-        autoscaled based on ``figsize``.
-
-
-    Returns
-    -------
-    axes: matplotlib axes or bokeh figures.
-
-    See Also
-    --------
-    plot_lm : Posterior predictive and mean plots for regression-like data.
-    plot_ppc : Plot for posterior/prior predictive checks.
-
-    Examples
-    --------
-    Plot timeseries default plot
-
-    .. plot::
-        :context: close-figs
-
-        >>> import arviz as az
-        >>> nchains, ndraws = (4, 500)
-        >>> obs_data = {
-        ...     "y": 2 * np.arange(1, 9) + 3,
-        ...     "z": 2 * np.arange(8, 12) + 3,
-        ... }
-        >>> posterior_predictive = {
-        ...     "y": np.random.normal(
-        ...         (obs_data["y"] * 1.2) - 3, size=(nchains, ndraws, len(obs_data["y"]))
-        ...     ),
-        ...     "z": np.random.normal(
-        ...         (obs_data["z"] * 1.2) - 3, size=(nchains, ndraws, len(obs_data["z"]))
-        ...     ),
-        ...  }
-        >>> idata = az.from_dict(
-        ...     observed_data=obs_data,
-        ...     posterior_predictive=posterior_predictive,
-        ...     coords={"obs_dim": np.arange(1, 9), "pred_dim": np.arange(8, 12)},
-        ...     dims={"y": ["obs_dim"], "z": ["pred_dim"]},
-        ... )
-        >>> ax = az.plot_ts(idata=idata, y="y", y_holdout="z")
-
-    Plot timeseries multidim plot
-
-    .. plot::
-        :context: close-figs
-
-        >>> ndim1, ndim2 = (5, 7)
-        >>> data = {
-        ...     "y": np.random.normal(size=(ndim1, ndim2)),
-        ...     "z": np.random.normal(size=(ndim1, ndim2)),
-        ... }
-        >>> posterior_predictive = {
-        ...     "y": np.random.randn(nchains, ndraws, ndim1, ndim2),
-        ...     "z": np.random.randn(nchains, ndraws, ndim1, ndim2),
-        ... }
-        >>> const_data = {"x": np.arange(1, 6), "x_pred": np.arange(5, 10)}
-        >>> idata = az.from_dict(
-        ...     observed_data=data,
-        ...     posterior_predictive=posterior_predictive,
-        ...     constant_data=const_data,
-        ...     dims={
-        ...         "y": ["dim1", "dim2"],
-        ...         "z": ["holdout_dim1", "holdout_dim2"],
-        ...     },
-        ...     coords={
-        ...         "dim1": range(ndim1),
-        ...         "dim2": range(ndim2),
-        ...         "holdout_dim1": range(ndim1 - 1, ndim1 + 4),
-        ...         "holdout_dim2": range(ndim2 - 1, ndim2 + 6),
-        ...     },
-        ... )
-        >>> az.plot_ts(
-        ...     idata=idata,
-        ...     y="y",
-        ...     plot_dim="dim1",
-        ...     y_holdout="z",
-        ...     holdout_dim="holdout_dim1",
-        ... )
-
-    """
-    # Assign default values if none is provided
-    y_hat = y if y_hat is None and isinstance(y, str) else y_hat
-    y_forecasts = y_holdout if y_forecasts is None and isinstance(y_holdout, str) else y_forecasts
-    # holdout_dim = plot_dim if holdout_dim is None and plot_dim is not None else holdout_dim
-
-    if isinstance(y, str):
-        y = idata.observed_data[y]
-
-    if isinstance(y_holdout, str):
-        y_holdout = idata.observed_data[y_holdout]
-
-    if len(y.dims) > 1 and plot_dim is None:
-        raise ValueError("Argument plot_dim is needed in case of multidimensional data")
-
-    if y_holdout is not None and len(y_holdout.dims) > 1 and holdout_dim is None:
-        raise ValueError("Argument holdout_dim is needed in case of multidimensional data")
-
-    # Assigning values to x
-    x_var_names = None
-    if isinstance(x, str):
-        x = idata.constant_data[x]
-    elif isinstance(x, tuple):
-        x_var_names = x
-        x = idata.constant_data
-    elif x is None:
-        if plot_dim is None:
-            x = y.coords[y.dims[0]]
-        else:
-            x = y.coords[plot_dim]
-
-    # If posterior_predictive is present in idata and y_hat is there, get its values
-    if isinstance(y_hat, str):
-        if "posterior_predictive" not in idata.groups():
-            warnings.warn("posterior_predictive not found in idata", UserWarning)
-            y_hat = None
-        elif hasattr(idata.posterior_predictive, y_hat):
-            y_hat = idata.posterior_predictive[y_hat]
-        else:
-            warnings.warn("y_hat not found in posterior_predictive", UserWarning)
-            y_hat = None
-
-    # If posterior_predictive is present in idata and y_forecasts is there, get its values
-    x_holdout_var_names = None
-    if isinstance(y_forecasts, str):
-        if "posterior_predictive" not in idata.groups():
-            warnings.warn("posterior_predictive not found in idata", UserWarning)
-            y_forecasts = None
-        elif hasattr(idata.posterior_predictive, y_forecasts):
-            y_forecasts = idata.posterior_predictive[y_forecasts]
-        else:
-            warnings.warn("y_hat not found in posterior_predictive", UserWarning)
-            y_forecasts = None
-
-    # Assign values to y_holdout
-    if isinstance(y_holdout, str):
-        y_holdout = idata.observed_data[y_holdout]
-
-    # Assign values to x_holdout.
-    if y_holdout is not None or y_forecasts is not None:
-        if x_holdout is None:
-            if holdout_dim is None:
-                if y_holdout is None:
-                    x_holdout = y_forecasts.coords[y_forecasts.dims[-1]]
-                else:
-                    x_holdout = y_holdout.coords[y_holdout.dims[-1]]
-            elif y_holdout is None:
-                x_holdout = y_forecasts.coords[holdout_dim]
-            else:
-                x_holdout = y_holdout.coords[holdout_dim]
-        elif isinstance(x_holdout, str):
-            x_holdout = idata.constant_data[x_holdout]
-        elif isinstance(x_holdout, tuple):
-            x_holdout_var_names = x_holdout
-            x_holdout = idata.constant_data
-
-    # Choose dims to generate y plotters
-    if plot_dim is None:
-        skip_dims = list(y.dims)
-    elif isinstance(plot_dim, str):
-        skip_dims = [plot_dim]
-    elif isinstance(plot_dim, tuple):
-        skip_dims = list(plot_dim)
-
-    # Choose dims to generate y_holdout plotters
-    if holdout_dim is None:
-        if y_holdout is not None:
-            skip_holdout_dims = list(y_holdout.dims)
-        elif y_forecasts is not None:
-            skip_holdout_dims = list(y_forecasts.dims)
-    elif isinstance(holdout_dim, str):
-        skip_holdout_dims = [holdout_dim]
-    elif isinstance(holdout_dim, tuple):
-        skip_holdout_dims = list(holdout_dim)
-
-    # Compulsory plotters
-    y_plotters = list(
-        xarray_var_iter(
-            y,
-            skip_dims=set(skip_dims),
-            combined=True,
-        )
-    )
-
-    # Compulsory plotters
-    x_plotters = list(
-        xarray_var_iter(
-            x,
-            var_names=x_var_names,
-            skip_dims=set(x.dims),
-            combined=True,
-        )
-    )
-    # Necessary when multidim y
-    # If there are multiple x and multidimensional y, we need total of len(x)*len(y) graphs
-    len_y = len(y_plotters)
-    len_x = len(x_plotters)
-    length_plotters = len_x * len_y
-    # TODO: Incompatible types in assignment (expression has type "ndarray[Any, dtype[Any]]",
-    # TODO: variable has type "List[Any]")  [assignment]
-    y_plotters = np.tile(np.array(y_plotters, dtype=object), (len_x, 1))  # type: ignore[assignment]
-    x_plotters = np.tile(np.array(x_plotters, dtype=object), (len_y, 1))  # type: ignore[assignment]
-
-    # Generate plotters for all the available data
-    y_mean_plotters = None
-    y_hat_plotters = None
-    if y_hat is not None:
-        total_samples = y_hat.sizes["chain"] * y_hat.sizes["draw"]
-        pp_sample_ix = np.random.choice(total_samples, size=num_samples, replace=False)
-
-        y_hat_satcked = y_hat.stack(__sample__=("chain", "draw"))[..., pp_sample_ix]
-
-        y_hat_plotters = list(
-            xarray_var_iter(
-                y_hat_satcked,
-                skip_dims=set(skip_dims + ["__sample__"]),
-                combined=True,
-            )
-        )
-
-        y_mean = y_hat.mean(("chain", "draw"))
-        y_mean_plotters = list(
-            xarray_var_iter(
-                y_mean,
-                skip_dims=set(skip_dims),
-                combined=True,
-            )
-        )
-
-        # Necessary when multidim y
-        # If there are multiple x and multidimensional y, we need total of len(x)*len(y) graphs
-        # TODO: Incompatible types in assignment (expression has type "ndarray[Any, dtype[Any]]",
-        # TODO: variable has type "List[Any]")  [assignment]
-        y_hat_plotters = np.tile(
-            np.array(y_hat_plotters, dtype=object), (len_x, 1)
-        )  # type: ignore[assignment]
-        y_mean_plotters = np.tile(
-            np.array(y_mean_plotters, dtype=object), (len_x, 1)
-        )  # type: ignore[assignment]
-
-    y_holdout_plotters = None
-    x_holdout_plotters = None
-    if y_holdout is not None:
-        y_holdout_plotters = list(
-            xarray_var_iter(
-                y_holdout,
-                skip_dims=set(skip_holdout_dims),
-                combined=True,
-            )
-        )
-
-        x_holdout_plotters = list(
-            xarray_var_iter(
-                x_holdout,
-                var_names=x_holdout_var_names,
-                skip_dims=set(x_holdout.dims),
-                combined=True,
-            )
-        )
-
-        # Necessary when multidim y
-        # If there are multiple x and multidimensional y, we need total of len(x)*len(y) graphs
-        # TODO: Incompatible types in assignment (expression has type "ndarray[Any, dtype[Any]]",
-        # TODO: variable has type "List[Any]")  [assignment]
-        y_holdout_plotters = np.tile(
-            np.array(y_holdout_plotters, dtype=object), (len_x, 1)
-        )  # type: ignore[assignment]
-        x_holdout_plotters = np.tile(
-            np.array(x_holdout_plotters, dtype=object), (len_y, 1)
-        )  # type: ignore[assignment]
-
-    y_forecasts_plotters = None
-    y_forecasts_mean_plotters = None
-    if y_forecasts is not None:
-        total_samples = y_forecasts.sizes["chain"] * y_forecasts.sizes["draw"]
-        pp_sample_ix = np.random.choice(total_samples, size=num_samples, replace=False)
-
-        y_forecasts_satcked = y_forecasts.stack(__sample__=("chain", "draw"))[..., pp_sample_ix]
-
-        y_forecasts_plotters = list(
-            xarray_var_iter(
-                y_forecasts_satcked,
-                skip_dims=set(skip_holdout_dims + ["__sample__"]),
-                combined=True,
-            )
-        )
-
-        y_forecasts_mean = y_forecasts.mean(("chain", "draw"))
-        y_forecasts_mean_plotters = list(
-            xarray_var_iter(
-                y_forecasts_mean,
-                skip_dims=set(skip_holdout_dims),
-                combined=True,
-            )
-        )
-
-        x_holdout_plotters = list(
-            xarray_var_iter(
-                x_holdout,
-                var_names=x_holdout_var_names,
-                skip_dims=set(x_holdout.dims),
-                combined=True,
-            )
-        )
-
-        # Necessary when multidim y
-        # If there are multiple x and multidimensional y, we need total of len(x)*len(y) graphs
-        # TODO: Incompatible types in assignment (expression has type "ndarray[Any, dtype[Any]]",
-        # TODO: variable has type "List[Any]")  [assignment]
-        y_forecasts_mean_plotters = np.tile(
-            np.array(y_forecasts_mean_plotters, dtype=object), (len_x, 1)
-        )  # type: ignore[assignment]
-        y_forecasts_plotters = np.tile(
-            np.array(y_forecasts_plotters, dtype=object), (len_x, 1)
-        )  # type: ignore[assignment]
-        x_holdout_plotters = np.tile(
-            np.array(x_holdout_plotters, dtype=object), (len_y, 1)
-        )  # type: ignore[assignment]
-
-    rows, cols = default_grid(length_plotters)
-
-    tsplot_kwargs = dict(
-        x_plotters=x_plotters,
-        y_plotters=y_plotters,
-        y_mean_plotters=y_mean_plotters,
-        y_hat_plotters=y_hat_plotters,
-        y_holdout_plotters=y_holdout_plotters,
-        x_holdout_plotters=x_holdout_plotters,
-        y_forecasts_plotters=y_forecasts_plotters,
-        y_forecasts_mean_plotters=y_forecasts_mean_plotters,
-        num_samples=num_samples,
-        length_plotters=length_plotters,
-        rows=rows,
-        cols=cols,
-        backend_kwargs=backend_kwargs,
-        y_kwargs=y_kwargs,
-        y_hat_plot_kwargs=y_hat_plot_kwargs,
-        y_mean_plot_kwargs=y_mean_plot_kwargs,
-        vline_kwargs=vline_kwargs,
-        textsize=textsize,
-        figsize=figsize,
-        legend=legend,
-        axes=axes,
-        show=show,
-    )
-
-    if backend is None:
-        backend = rcParams["plot.backend"]
-    backend = backend.lower()
-
-    plot = get_plotting_function("plot_ts", "tsplot", backend)
-    ax = plot(**tsplot_kwargs)
-    return ax

arviz/plots/violinplot.py

@@ -1,192 +0,0 @@
-"""Plot posterior traces as violin plot."""
-
-from ..data import convert_to_dataset
-from ..labels import BaseLabeller
-from ..sel_utils import xarray_var_iter
-from ..utils import _var_names
-from ..rcparams import rcParams
-from .plot_utils import default_grid, filter_plotters_list, get_plotting_function
-
-
-def plot_violin(
-    data,
-    var_names=None,
-    combine_dims=None,
-    filter_vars=None,
-    transform=None,
-    quartiles=True,
-    rug=False,
-    side="both",
-    hdi_prob=None,
-    shade=0.35,
-    bw="default",
-    circular=False,
-    sharex=True,
-    sharey=True,
-    grid=None,
-    figsize=None,
-    textsize=None,
-    labeller=None,
-    ax=None,
-    shade_kwargs=None,
-    rug_kwargs=None,
-    backend=None,
-    backend_kwargs=None,
-    show=None,
-):
-    """Plot posterior of traces as violin plot.
-
-    Notes
-    -----
-    If multiple chains are provided for a variable they will be combined
-
-    Parameters
-    ----------
-    data: obj
-        Any object that can be converted to an :class:`arviz.InferenceData` object
-        Refer to documentation of :func:`arviz.convert_to_dataset` for details
-    var_names: list of variable names, optional
-        Variables to be plotted, if None all variable are plotted. Prefix the
-        variables by ``~`` when you want to exclude them from the plot.
-    combine_dims : set_like of str, optional
-        List of dimensions to reduce. Defaults to reducing only the "chain" and "draw" dimensions.
-        See the :ref:`this section <common_combine_dims>` for usage examples.
-    filter_vars: {None, "like", "regex"}, optional, default=None
-        If `None` (default), interpret var_names as the real variables names. If "like",
-        interpret var_names as substrings of the real variables names. If "regex",
-        interpret var_names as regular expressions on the real variables names. A la
-        ``pandas.filter``.
-    transform: callable
-        Function to transform data (defaults to None i.e. the identity function).
-    quartiles: bool, optional
-        Flag for plotting the interquartile range, in addition to the ``hdi_prob`` * 100%
-        intervals. Defaults to ``True``.
-    rug: bool
-        If ``True`` adds a jittered rugplot. Defaults to ``False``.
-    side : {"both", "left", "right"}, default "both"
-        If ``both``, both sides of the violin plot are rendered. If ``left`` or ``right``, only
-        the respective side is rendered. By separately plotting left and right halfs with
-        different data, split violin plots can be achieved.
-    hdi_prob: float, optional
-        Plots highest posterior density interval for chosen percentage of density.
-        Defaults to 0.94.
-    shade: float
-        Alpha blending value for the shaded area under the curve, between 0
-        (no shade) and 1 (opaque). Defaults to 0.
-    bw: float or str, optional
-        If numeric, indicates the bandwidth and must be positive.
-        If str, indicates the method to estimate the bandwidth and must be
-        one of "scott", "silverman", "isj" or "experimental" when ``circular`` is ``False``
-        and "taylor" (for now) when ``circular`` is ``True``.
-        Defaults to "default" which means "experimental" when variable is not circular
-        and "taylor" when it is.
-    circular: bool, optional.
-        If ``True``, it interprets `values` is a circular variable measured in radians
-        and a circular KDE is used. Defaults to ``False``.
-    grid : tuple
-        Number of rows and columns. Defaults to None, the rows and columns are
-        automatically inferred.
-    figsize: tuple
-        Figure size. If None it will be defined automatically.
-    textsize: int
-        Text size of the point_estimates, axis ticks, and highest density interval. If None it will
-        be autoscaled based on ``figsize``.
-    labeller : labeller instance, optional
-        Class providing the method ``make_label_vert`` to generate the labels in the plot titles.
-        Read the :ref:`label_guide` for more details and usage examples.
-    sharex: bool
-        Defaults to ``True``, violinplots share a common x-axis scale.
-    sharey: bool
-        Defaults to ``True``, violinplots share a common y-axis scale.
-    ax: numpy array-like of matplotlib axes or bokeh figures, optional
-        A 2D array of locations into which to plot the densities. If not supplied, Arviz will create
-        its own array of plot areas (and return it).
-    shade_kwargs: dicts, optional
-        Additional keywords passed to :meth:`matplotlib.axes.Axes.fill_between`, or
-        :meth:`matplotlib.axes.Axes.barh` to control the shade.
-    rug_kwargs: dict
-        Keywords passed to the rug plot. If true only the right half side of the violin will be
-        plotted.
-    backend: str, optional
-        Select plotting backend {"matplotlib","bokeh"}. Default to "matplotlib".
-    backend_kwargs: bool, optional
-        These are kwargs specific to the backend being used, passed to
-        :func:`matplotlib.pyplot.subplots` or :func:`bokeh.plotting.figure`.
-        For additional documentation check the plotting method of the backend.
-    show: bool, optional
-        Call backend show function.
-
-    Returns
-    -------
-    axes: matplotlib axes or bokeh figures
-
-    See Also
-    --------
-    plot_forest: Forest plot to compare HDI intervals from a number of distributions.
-
-    Examples
-    --------
-    Show a default violin plot
-
-    .. plot::
-        :context: close-figs
-
-        >>> import arviz as az
-        >>> data = az.load_arviz_data('centered_eight')
-        >>> az.plot_violin(data)
-
-    """
-    if labeller is None:
-        labeller = BaseLabeller()
-
-    data = convert_to_dataset(data, group="posterior")
-    if transform is not None:
-        data = transform(data)
-    var_names = _var_names(var_names, data, filter_vars)
-
-    plotters = filter_plotters_list(
-        list(xarray_var_iter(data, var_names=var_names, combined=True, skip_dims=combine_dims)),
-        "plot_violin",
-    )
-
-    rows, cols = default_grid(len(plotters), grid=grid)
-
-    if hdi_prob is None:
-        hdi_prob = rcParams["stats.ci_prob"]
-    elif not 1 >= hdi_prob > 0:
-        raise ValueError("The value of hdi_prob should be in the interval (0, 1]")
-
-    violinplot_kwargs = dict(
-        ax=ax,
-        plotters=plotters,
-        figsize=figsize,
-        rows=rows,
-        cols=cols,
-        sharex=sharex,
-        sharey=sharey,
-        shade_kwargs=shade_kwargs,
-        shade=shade,
-        rug=rug,
-        rug_kwargs=rug_kwargs,
-        side=side,
-        bw=bw,
-        textsize=textsize,
-        labeller=labeller,
-        circular=circular,
-        hdi_prob=hdi_prob,
-        quartiles=quartiles,
-        backend_kwargs=backend_kwargs,
-        show=show,
-    )
-
-    if backend is None:
-        backend = rcParams["plot.backend"]
-    backend = backend.lower()
-
-    if side not in ("both", "left", "right"):
-        raise ValueError(f"'side' can only be 'both', 'left', or 'right', got: '{side}'")
-
-    # TODO: Add backend kwargs
-    plot = get_plotting_function("plot_violin", "violinplot", backend)
-    ax = plot(**violinplot_kwargs)
-    return ax

arviz/preview.py

@@ -1,58 +0,0 @@
-# pylint: disable=unused-import,unused-wildcard-import,wildcard-import,invalid-name
-"""Expose features from arviz-xyz refactored packages inside ``arviz.preview`` namespace."""
-import logging
-
-_log = logging.getLogger(__name__)
-
-info = ""
-
-try:
-    from arviz_base import *
-    import arviz_base as base
-
-    _status = "arviz_base available, exposing its functions as part of arviz.preview"
-    _log.info(_status)
-except ModuleNotFoundError:
-    _status = "arviz_base not installed"
-    _log.info(_status)
-except ImportError:
-    _status = "Unable to import arviz_base"
-    _log.info(_status, exc_info=True)
-
-info += _status + "\n"
-
-try:
-    from arviz_stats import *
-
-    # the base computational module fron arviz_stats will override the alias to arviz-base
-    # arviz.stats.base will still be available
-    import arviz_base as base
-    import arviz_stats as stats
-
-    _status = "arviz_stats available, exposing its functions as part of arviz.preview"
-    _log.info(_status)
-except ModuleNotFoundError:
-    _status = "arviz_stats not installed"
-    _log.info(_status)
-except ImportError:
-    _status = "Unable to import arviz_stats"
-    _log.info(_status, exc_info=True)
-info += _status + "\n"
-
-try:
-    from arviz_plots import *
-    import arviz_plots as plots
-
-    _status = "arviz_plots available, exposing its functions as part of arviz.preview"
-    _log.info(_status)
-except ModuleNotFoundError:
-    _status = "arviz_plots not installed"
-    _log.info(_status)
-except ImportError:
-    _status = "Unable to import arviz_plots"
-    _log.info(_status, exc_info=True)
-
-info += _status + "\n"
-
-# clean namespace
-del logging, _status, _log