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

arviz/data/io_cmdstan.py

@@ -1,1036 +0,0 @@
-# pylint: disable=too-many-lines
-"""CmdStan-specific conversion code."""
-try:
-    import ujson as json
-except ImportError:
-    # Can't find ujson using json
-    # mypy struggles with conditional imports expressed as catching ImportError:
-    # https://github.com/python/mypy/issues/1153
-    import json  # type: ignore
-import logging
-import os
-import re
-from collections import defaultdict
-from glob import glob
-from pathlib import Path
-from typing import Dict, List, Optional, Union
-
-import numpy as np
-
-from .. import utils
-from ..rcparams import rcParams
-from .base import CoordSpec, DimSpec, dict_to_dataset, infer_stan_dtypes, requires
-from .inference_data import InferenceData
-
-_log = logging.getLogger(__name__)
-
-
-def check_glob(path, group, disable_glob):
-    """Find files with glob."""
-    if isinstance(path, str) and (not disable_glob):
-        path_glob = glob(path)
-        if path_glob:
-            path = sorted(path_glob)
-            msg = "\n".join(f"{i}: {os.path.normpath(fpath)}" for i, fpath in enumerate(path, 1))
-            len_p = len(path)
-            _log.info("glob found %d files for '%s':\n%s", len_p, group, msg)
-    return path
-
-
-class CmdStanConverter:
-    """Encapsulate CmdStan specific logic."""
-
-    # pylint: disable=too-many-instance-attributes
-
-    def __init__(
-        self,
-        *,
-        posterior=None,
-        posterior_predictive=None,
-        predictions=None,
-        prior=None,
-        prior_predictive=None,
-        observed_data=None,
-        observed_data_var=None,
-        constant_data=None,
-        constant_data_var=None,
-        predictions_constant_data=None,
-        predictions_constant_data_var=None,
-        log_likelihood=None,
-        index_origin=None,
-        coords=None,
-        dims=None,
-        disable_glob=False,
-        save_warmup=None,
-        dtypes=None,
-    ):
-        self.posterior_ = check_glob(posterior, "posterior", disable_glob)
-        self.posterior_predictive = check_glob(
-            posterior_predictive, "posterior_predictive", disable_glob
-        )
-        self.predictions = check_glob(predictions, "predictions", disable_glob)
-        self.prior_ = check_glob(prior, "prior", disable_glob)
-        self.prior_predictive = check_glob(prior_predictive, "prior_predictive", disable_glob)
-        self.log_likelihood = check_glob(log_likelihood, "log_likelihood", disable_glob)
-        self.observed_data = observed_data
-        self.observed_data_var = observed_data_var
-        self.constant_data = constant_data
-        self.constant_data_var = constant_data_var
-        self.predictions_constant_data = predictions_constant_data
-        self.predictions_constant_data_var = predictions_constant_data_var
-        self.coords = coords if coords is not None else {}
-        self.dims = dims if dims is not None else {}
-
-        self.posterior = None
-        self.prior = None
-        self.attrs = None
-        self.attrs_prior = None
-
-        self.save_warmup = rcParams["data.save_warmup"] if save_warmup is None else save_warmup
-        self.index_origin = index_origin
-
-        if dtypes is None:
-            dtypes = {}
-        elif isinstance(dtypes, str):
-            dtypes_path = Path(dtypes)
-            if dtypes_path.exists():
-                with dtypes_path.open("r", encoding="UTF-8") as f_obj:
-                    model_code = f_obj.read()
-            else:
-                model_code = dtypes
-
-            dtypes = infer_stan_dtypes(model_code)
-
-        self.dtypes = dtypes
-
-        # populate posterior and sample_stats
-        self._parse_posterior()
-        self._parse_prior()
-
-        if (
-            self.log_likelihood is None
-            and self.posterior_ is not None
-            and any(name.split(".")[0] == "log_lik" for name in self.posterior_columns)
-        ):
-            self.log_likelihood = ["log_lik"]
-        elif isinstance(self.log_likelihood, bool):
-            self.log_likelihood = None
-
-    @requires("posterior_")
-    def _parse_posterior(self):
-        """Read csv paths to list of ndarrays."""
-        paths = self.posterior_
-        if isinstance(paths, str):
-            paths = [paths]
-
-        chain_data = []
-        columns = None
-        for path in paths:
-            output_data = _read_output(path)
-            chain_data.append(output_data)
-            if columns is None:
-                columns = output_data
-
-        self.posterior = (
-            [item["sample"] for item in chain_data],
-            [item["sample_warmup"] for item in chain_data],
-        )
-        self.posterior_columns = columns["sample_columns"]
-        self.sample_stats_columns = columns["sample_stats_columns"]
-
-        attrs = {}
-        for item in chain_data:
-            for key, value in item["configuration_info"].items():
-                if key not in attrs:
-                    attrs[key] = []
-                attrs[key].append(value)
-        self.attrs = attrs
-
-    @requires("prior_")
-    def _parse_prior(self):
-        """Read csv paths to list of ndarrays."""
-        paths = self.prior_
-        if isinstance(paths, str):
-            paths = [paths]
-
-        chain_data = []
-        columns = None
-        for path in paths:
-            output_data = _read_output(path)
-            chain_data.append(output_data)
-            if columns is None:
-                columns = output_data
-
-        self.prior = (
-            [item["sample"] for item in chain_data],
-            [item["sample_warmup"] for item in chain_data],
-        )
-        self.prior_columns = columns["sample_columns"]
-        self.sample_stats_prior_columns = columns["sample_stats_columns"]
-
-        attrs = {}
-        for item in chain_data:
-            for key, value in item["configuration_info"].items():
-                if key not in attrs:
-                    attrs[key] = []
-                attrs[key].append(value)
-        self.attrs_prior = attrs
-
-    @requires("posterior")
-    def posterior_to_xarray(self):
-        """Extract posterior samples from output csv."""
-        columns = self.posterior_columns
-
-        # filter posterior_predictive, predictions and log_likelihood
-        posterior_predictive = self.posterior_predictive
-        if posterior_predictive is None or (
-            isinstance(posterior_predictive, str) and posterior_predictive.lower().endswith(".csv")
-        ):
-            posterior_predictive = []
-        elif isinstance(posterior_predictive, str):
-            posterior_predictive = [
-                col for col in columns if posterior_predictive == col.split(".")[0]
-            ]
-        else:
-            posterior_predictive = [
-                col
-                for col in columns
-                if any(item == col.split(".")[0] for item in posterior_predictive)
-            ]
-
-        predictions = self.predictions
-        if predictions is None or (
-            isinstance(predictions, str) and predictions.lower().endswith(".csv")
-        ):
-            predictions = []
-        elif isinstance(predictions, str):
-            predictions = [col for col in columns if predictions == col.split(".")[0]]
-        else:
-            predictions = [
-                col for col in columns if any(item == col.split(".")[0] for item in predictions)
-            ]
-
-        log_likelihood = self.log_likelihood
-        if log_likelihood is None or (
-            isinstance(log_likelihood, str) and log_likelihood.lower().endswith(".csv")
-        ):
-            log_likelihood = []
-        elif isinstance(log_likelihood, str):
-            log_likelihood = [col for col in columns if log_likelihood == col.split(".")[0]]
-        elif isinstance(log_likelihood, dict):
-            log_likelihood = [
-                col
-                for col in columns
-                if any(item == col.split(".")[0] for item in log_likelihood.values())
-            ]
-        else:
-            log_likelihood = [
-                col for col in columns if any(item == col.split(".")[0] for item in log_likelihood)
-            ]
-
-        invalid_cols = posterior_predictive + predictions + log_likelihood
-        valid_cols = {col: idx for col, idx in columns.items() if col not in invalid_cols}
-        data = _unpack_ndarrays(self.posterior[0], valid_cols, self.dtypes)
-        data_warmup = _unpack_ndarrays(self.posterior[1], valid_cols, self.dtypes)
-        return (
-            dict_to_dataset(
-                data,
-                coords=self.coords,
-                dims=self.dims,
-                attrs=self.attrs,
-                index_origin=self.index_origin,
-            ),
-            dict_to_dataset(
-                data_warmup,
-                coords=self.coords,
-                dims=self.dims,
-                attrs=self.attrs,
-                index_origin=self.index_origin,
-            ),
-        )
-
-    @requires("posterior")
-    @requires("sample_stats_columns")
-    def sample_stats_to_xarray(self):
-        """Extract sample_stats from fit."""
-        dtypes = {"diverging": bool, "n_steps": np.int64, "tree_depth": np.int64, **self.dtypes}
-        rename_dict = {
-            "divergent": "diverging",
-            "n_leapfrog": "n_steps",
-            "treedepth": "tree_depth",
-            "stepsize": "step_size",
-            "accept_stat": "acceptance_rate",
-        }
-
-        columns_new = {}
-        for key, idx in self.sample_stats_columns.items():
-            name = re.sub("__$", "", key)
-            name = rename_dict.get(name, name)
-            columns_new[name] = idx
-
-        data = _unpack_ndarrays(self.posterior[0], columns_new, dtypes)
-        data_warmup = _unpack_ndarrays(self.posterior[1], columns_new, dtypes)
-        return (
-            dict_to_dataset(
-                data,
-                coords=self.coords,
-                dims=self.dims,
-                attrs={item: key for key, item in rename_dict.items()},
-                index_origin=self.index_origin,
-            ),
-            dict_to_dataset(
-                data_warmup,
-                coords=self.coords,
-                dims=self.dims,
-                attrs={item: key for key, item in rename_dict.items()},
-                index_origin=self.index_origin,
-            ),
-        )
-
-    @requires("posterior")
-    @requires("posterior_predictive")
-    def posterior_predictive_to_xarray(self):
-        """Convert posterior_predictive samples to xarray."""
-        posterior_predictive = self.posterior_predictive
-
-        if (
-            isinstance(posterior_predictive, (tuple, list))
-            and posterior_predictive[0].endswith(".csv")
-        ) or (isinstance(posterior_predictive, str) and posterior_predictive.endswith(".csv")):
-            if isinstance(posterior_predictive, str):
-                posterior_predictive = [posterior_predictive]
-            chain_data = []
-            chain_data_warmup = []
-            columns = None
-            attrs = {}
-            for path in posterior_predictive:
-                parsed_output = _read_output(path)
-                chain_data.append(parsed_output["sample"])
-                chain_data_warmup.append(parsed_output["sample_warmup"])
-                if columns is None:
-                    columns = parsed_output["sample_columns"]
-
-                for key, value in parsed_output["configuration_info"].items():
-                    if key not in attrs:
-                        attrs[key] = []
-                    attrs[key].append(value)
-
-            data = _unpack_ndarrays(chain_data, columns, self.dtypes)
-            data_warmup = _unpack_ndarrays(chain_data_warmup, columns, self.dtypes)
-
-        else:
-            if isinstance(posterior_predictive, str):
-                posterior_predictive = [posterior_predictive]
-            columns = {
-                col: idx
-                for col, idx in self.posterior_columns.items()
-                if any(item == col.split(".")[0] for item in posterior_predictive)
-            }
-            data = _unpack_ndarrays(self.posterior[0], columns, self.dtypes)
-            data_warmup = _unpack_ndarrays(self.posterior[1], columns, self.dtypes)
-
-            attrs = None
-        return (
-            dict_to_dataset(
-                data,
-                coords=self.coords,
-                dims=self.dims,
-                attrs=attrs,
-                index_origin=self.index_origin,
-            ),
-            dict_to_dataset(
-                data_warmup,
-                coords=self.coords,
-                dims=self.dims,
-                attrs=attrs,
-                index_origin=self.index_origin,
-            ),
-        )
-
-    @requires("posterior")
-    @requires("predictions")
-    def predictions_to_xarray(self):
-        """Convert out of sample predictions samples to xarray."""
-        predictions = self.predictions
-
-        if (isinstance(predictions, (tuple, list)) and predictions[0].endswith(".csv")) or (
-            isinstance(predictions, str) and predictions.endswith(".csv")
-        ):
-            if isinstance(predictions, str):
-                predictions = [predictions]
-            chain_data = []
-            chain_data_warmup = []
-            columns = None
-            attrs = {}
-            for path in predictions:
-                parsed_output = _read_output(path)
-                chain_data.append(parsed_output["sample"])
-                chain_data_warmup.append(parsed_output["sample_warmup"])
-                if columns is None:
-                    columns = parsed_output["sample_columns"]
-
-                for key, value in parsed_output["configuration_info"].items():
-                    if key not in attrs:
-                        attrs[key] = []
-                    attrs[key].append(value)
-
-            data = _unpack_ndarrays(chain_data, columns, self.dtypes)
-            data_warmup = _unpack_ndarrays(chain_data_warmup, columns, self.dtypes)
-        else:
-            if isinstance(predictions, str):
-                predictions = [predictions]
-            columns = {
-                col: idx
-                for col, idx in self.posterior_columns.items()
-                if any(item == col.split(".")[0] for item in predictions)
-            }
-            data = _unpack_ndarrays(self.posterior[0], columns, self.dtypes)
-            data_warmup = _unpack_ndarrays(self.posterior[1], columns, self.dtypes)
-
-            attrs = None
-        return (
-            dict_to_dataset(
-                data,
-                coords=self.coords,
-                dims=self.dims,
-                attrs=attrs,
-                index_origin=self.index_origin,
-            ),
-            dict_to_dataset(
-                data_warmup,
-                coords=self.coords,
-                dims=self.dims,
-                attrs=attrs,
-                index_origin=self.index_origin,
-            ),
-        )
-
-    @requires("posterior")
-    @requires("log_likelihood")
-    def log_likelihood_to_xarray(self):
-        """Convert elementwise log_likelihood samples to xarray."""
-        log_likelihood = self.log_likelihood
-
-        if (isinstance(log_likelihood, (tuple, list)) and log_likelihood[0].endswith(".csv")) or (
-            isinstance(log_likelihood, str) and log_likelihood.endswith(".csv")
-        ):
-            if isinstance(log_likelihood, str):
-                log_likelihood = [log_likelihood]
-
-            chain_data = []
-            chain_data_warmup = []
-            columns = None
-            attrs = {}
-            for path in log_likelihood:
-                parsed_output = _read_output(path)
-                chain_data.append(parsed_output["sample"])
-                chain_data_warmup.append(parsed_output["sample_warmup"])
-
-                if columns is None:
-                    columns = parsed_output["sample_columns"]
-
-                for key, value in parsed_output["configuration_info"].items():
-                    if key not in attrs:
-                        attrs[key] = []
-                    attrs[key].append(value)
-            data = _unpack_ndarrays(chain_data, columns, self.dtypes)
-            data_warmup = _unpack_ndarrays(chain_data_warmup, columns, self.dtypes)
-        else:
-            if isinstance(log_likelihood, dict):
-                log_lik_to_obs_name = {v: k for k, v in log_likelihood.items()}
-                columns = {
-                    col.replace(col_name, log_lik_to_obs_name[col_name]): idx
-                    for col, col_name, idx in (
-                        (col, col.split(".")[0], idx) for col, idx in self.posterior_columns.items()
-                    )
-                    if any(item == col_name for item in log_likelihood.values())
-                }
-            else:
-                if isinstance(log_likelihood, str):
-                    log_likelihood = [log_likelihood]
-                columns = {
-                    col: idx
-                    for col, idx in self.posterior_columns.items()
-                    if any(item == col.split(".")[0] for item in log_likelihood)
-                }
-            data = _unpack_ndarrays(self.posterior[0], columns, self.dtypes)
-            data_warmup = _unpack_ndarrays(self.posterior[1], columns, self.dtypes)
-            attrs = None
-        return (
-            dict_to_dataset(
-                data,
-                coords=self.coords,
-                dims=self.dims,
-                attrs=attrs,
-                index_origin=self.index_origin,
-                skip_event_dims=True,
-            ),
-            dict_to_dataset(
-                data_warmup,
-                coords=self.coords,
-                dims=self.dims,
-                attrs=attrs,
-                index_origin=self.index_origin,
-                skip_event_dims=True,
-            ),
-        )
-
-    @requires("prior")
-    def prior_to_xarray(self):
-        """Convert prior samples to xarray."""
-        # filter prior_predictive
-        prior_predictive = self.prior_predictive
-
-        columns = self.prior_columns
-
-        if prior_predictive is None or (
-            isinstance(prior_predictive, str) and prior_predictive.lower().endswith(".csv")
-        ):
-            prior_predictive = []
-        elif isinstance(prior_predictive, str):
-            prior_predictive = [col for col in columns if prior_predictive == col.split(".")[0]]
-        else:
-            prior_predictive = [
-                col
-                for col in columns
-                if any(item == col.split(".")[0] for item in prior_predictive)
-            ]
-
-        invalid_cols = prior_predictive
-        valid_cols = {col: idx for col, idx in columns.items() if col not in invalid_cols}
-        data = _unpack_ndarrays(self.prior[0], valid_cols, self.dtypes)
-        data_warmup = _unpack_ndarrays(self.prior[1], valid_cols, self.dtypes)
-        return (
-            dict_to_dataset(
-                data,
-                coords=self.coords,
-                dims=self.dims,
-                attrs=self.attrs_prior,
-                index_origin=self.index_origin,
-            ),
-            dict_to_dataset(
-                data_warmup,
-                coords=self.coords,
-                dims=self.dims,
-                attrs=self.attrs_prior,
-                index_origin=self.index_origin,
-            ),
-        )
-
-    @requires("prior")
-    @requires("sample_stats_prior_columns")
-    def sample_stats_prior_to_xarray(self):
-        """Extract sample_stats from fit."""
-        dtypes = {"diverging": bool, "n_steps": np.int64, "tree_depth": np.int64, **self.dtypes}
-        rename_dict = {
-            "divergent": "diverging",
-            "n_leapfrog": "n_steps",
-            "treedepth": "tree_depth",
-            "stepsize": "step_size",
-            "accept_stat": "acceptance_rate",
-        }
-
-        columns_new = {}
-        for key, idx in self.sample_stats_prior_columns.items():
-            name = re.sub("__$", "", key)
-            name = rename_dict.get(name, name)
-            columns_new[name] = idx
-
-        data = _unpack_ndarrays(self.posterior[0], columns_new, dtypes)
-        data_warmup = _unpack_ndarrays(self.posterior[1], columns_new, dtypes)
-        return (
-            dict_to_dataset(
-                data,
-                coords=self.coords,
-                dims=self.dims,
-                attrs={item: key for key, item in rename_dict.items()},
-                index_origin=self.index_origin,
-            ),
-            dict_to_dataset(
-                data_warmup,
-                coords=self.coords,
-                dims=self.dims,
-                attrs={item: key for key, item in rename_dict.items()},
-                index_origin=self.index_origin,
-            ),
-        )
-
-    @requires("prior")
-    @requires("prior_predictive")
-    def prior_predictive_to_xarray(self):
-        """Convert prior_predictive samples to xarray."""
-        prior_predictive = self.prior_predictive
-
-        if (
-            isinstance(prior_predictive, (tuple, list)) and prior_predictive[0].endswith(".csv")
-        ) or (isinstance(prior_predictive, str) and prior_predictive.endswith(".csv")):
-            if isinstance(prior_predictive, str):
-                prior_predictive = [prior_predictive]
-            chain_data = []
-            chain_data_warmup = []
-            columns = None
-            attrs = {}
-            for path in prior_predictive:
-                parsed_output = _read_output(path)
-                chain_data.append(parsed_output["sample"])
-                chain_data_warmup.append(parsed_output["sample_warmup"])
-                if columns is None:
-                    columns = parsed_output["sample_columns"]
-                for key, value in parsed_output["configuration_info"].items():
-                    if key not in attrs:
-                        attrs[key] = []
-                    attrs[key].append(value)
-            data = _unpack_ndarrays(chain_data, columns, self.dtypes)
-            data_warmup = _unpack_ndarrays(chain_data_warmup, columns, self.dtypes)
-        else:
-            if isinstance(prior_predictive, str):
-                prior_predictive = [prior_predictive]
-            columns = {
-                col: idx
-                for col, idx in self.prior_columns.items()
-                if any(item == col.split(".")[0] for item in prior_predictive)
-            }
-            data = _unpack_ndarrays(self.prior[0], columns, self.dtypes)
-            data_warmup = _unpack_ndarrays(self.prior[1], columns, self.dtypes)
-            attrs = None
-        return (
-            dict_to_dataset(
-                data,
-                coords=self.coords,
-                dims=self.dims,
-                attrs=attrs,
-                index_origin=self.index_origin,
-            ),
-            dict_to_dataset(
-                data_warmup,
-                coords=self.coords,
-                dims=self.dims,
-                attrs=attrs,
-                index_origin=self.index_origin,
-            ),
-        )
-
-    @requires("observed_data")
-    def observed_data_to_xarray(self):
-        """Convert observed data to xarray."""
-        observed_data_raw = _read_data(self.observed_data)
-        variables = self.observed_data_var
-        if isinstance(variables, str):
-            variables = [variables]
-        observed_data = {
-            key: utils.one_de(vals)
-            for key, vals in observed_data_raw.items()
-            if variables is None or key in variables
-        }
-        return dict_to_dataset(
-            observed_data,
-            coords=self.coords,
-            dims=self.dims,
-            default_dims=[],
-            index_origin=self.index_origin,
-        )
-
-    @requires("constant_data")
-    def constant_data_to_xarray(self):
-        """Convert constant data to xarray."""
-        constant_data_raw = _read_data(self.constant_data)
-        variables = self.constant_data_var
-        if isinstance(variables, str):
-            variables = [variables]
-        constant_data = {
-            key: utils.one_de(vals)
-            for key, vals in constant_data_raw.items()
-            if variables is None or key in variables
-        }
-        return dict_to_dataset(
-            constant_data,
-            coords=self.coords,
-            dims=self.dims,
-            default_dims=[],
-            index_origin=self.index_origin,
-        )
-
-    @requires("predictions_constant_data")
-    def predictions_constant_data_to_xarray(self):
-        """Convert predictions constant data to xarray."""
-        predictions_constant_data_raw = _read_data(self.predictions_constant_data)
-        variables = self.predictions_constant_data_var
-        if isinstance(variables, str):
-            variables = [variables]
-        predictions_constant_data = {}
-        for key, vals in predictions_constant_data_raw.items():
-            if variables is not None and key not in variables:
-                continue
-            vals = utils.one_de(vals)
-            predictions_constant_data[key] = utils.one_de(vals)
-        return dict_to_dataset(
-            predictions_constant_data,
-            coords=self.coords,
-            dims=self.dims,
-            default_dims=[],
-            index_origin=self.index_origin,
-        )
-
-    def to_inference_data(self):
-        """Convert all available data to an InferenceData object.
-
-        Note that if groups can not be created (i.e., there is no `output`, so
-        the `posterior` and `sample_stats` can not be extracted), then the InferenceData
-        will not have those groups.
-        """
-        return InferenceData(
-            save_warmup=self.save_warmup,
-            **{
-                "posterior": self.posterior_to_xarray(),
-                "sample_stats": self.sample_stats_to_xarray(),
-                "log_likelihood": self.log_likelihood_to_xarray(),
-                "posterior_predictive": self.posterior_predictive_to_xarray(),
-                "prior": self.prior_to_xarray(),
-                "sample_stats_prior": self.sample_stats_prior_to_xarray(),
-                "prior_predictive": self.prior_predictive_to_xarray(),
-                "observed_data": self.observed_data_to_xarray(),
-                "constant_data": self.constant_data_to_xarray(),
-                "predictions": self.predictions_to_xarray(),
-                "predictions_constant_data": self.predictions_constant_data_to_xarray(),
-            },
-        )
-
-
-def _process_configuration(comments):
-    """Extract sampling information."""
-    results = {
-        "comments": "\n".join(comments),
-        "stan_version": {},
-    }
-
-    comments_gen = iter(comments)
-
-    for comment in comments_gen:
-        comment = re.sub(r"^\s*#\s*|\s*\(Default\)\s*$", "", comment).strip()
-        if comment.startswith("stan_version_"):
-            key, val = re.sub(r"^\s*stan_version_", "", comment).split("=")
-            results["stan_version"][key.strip()] = val.strip()
-        elif comment.startswith("Step size"):
-            _, val = comment.split("=")
-            results["step_size"] = float(val.strip())
-        elif "inverse mass matrix" in comment:
-            comment = re.sub(r"^\s*#\s*", "", next(comments_gen)).strip()
-            results["inverse_mass_matrix"] = [float(item) for item in comment.split(",")]
-        elif ("seconds" in comment) and any(
-            item in comment for item in ("(Warm-up)", "(Sampling)", "(Total)")
-        ):
-            value = re.sub(
-                (
-                    r"^Elapsed\s*Time:\s*|"
-                    r"\s*seconds\s*\(Warm-up\)\s*|"
-                    r"\s*seconds\s*\(Sampling\)\s*|"
-                    r"\s*seconds\s*\(Total\)\s*"
-                ),
-                "",
-                comment,
-            )
-            key = (
-                "warmup_time_seconds"
-                if "(Warm-up)" in comment
-                else "sampling_time_seconds" if "(Sampling)" in comment else "total_time_seconds"
-            )
-            results[key] = float(value)
-        elif "=" in comment:
-            match_int = re.search(r"^(\S+)\s*=\s*([-+]?[0-9]+)$", comment)
-            match_float = re.search(r"^(\S+)\s*=\s*([-+]?[0-9]+\.[0-9]+)$", comment)
-            match_str_bool = re.search(r"^(\S+)\s*=\s*(true|false)$", comment)
-            match_str = re.search(r"^(\S+)\s*=\s*(\S+)$", comment)
-            match_empty = re.search(r"^(\S+)\s*=\s*$", comment)
-            if match_int:
-                key, value = match_int.group(1), match_int.group(2)
-                results[key] = int(value)
-            elif match_float:
-                key, value = match_float.group(1), match_float.group(2)
-                results[key] = float(value)
-            elif match_str_bool:
-                key, value = match_str_bool.group(1), match_str_bool.group(2)
-                results[key] = int(value == "true")
-            elif match_str:
-                key, value = match_str.group(1), match_str.group(2)
-                results[key] = value
-            elif match_empty:
-                key = match_empty.group(1)
-                results[key] = None
-
-    results = {key: str(results[key]) for key in sorted(results)}
-    return results
-
-
-def _read_output_file(path):
-    """Read Stan csv file to ndarray."""
-    comments = []
-    data = []
-    columns = None
-    with open(path, "rb") as f_obj:
-        # read header
-        for line in f_obj:
-            if line.startswith(b"#"):
-                comments.append(line.strip().decode("utf-8"))
-                continue
-            columns = {key: idx for idx, key in enumerate(line.strip().decode("utf-8").split(","))}
-            break
-        # read data
-        for line in f_obj:
-            line = line.strip()
-            if line.startswith(b"#"):
-                comments.append(line.decode("utf-8"))
-                continue
-            if line:
-                data.append(np.array(line.split(b","), dtype=np.float64))
-
-    return columns, np.array(data, dtype=np.float64), comments
-
-
-def _read_output(path):
-    """Read CmdStan output csv file.
-
-    Parameters
-    ----------
-    path : str
-
-    Returns
-    -------
-    Dict[str, Any]
-    """
-    # Read data
-    columns, data, comments = _read_output_file(path)
-
-    pconf = _process_configuration(comments)
-
-    # split dataframe to warmup and draws
-    saved_warmup = (
-        int(pconf.get("save_warmup", 0))
-        * int(pconf.get("num_warmup", 0))
-        // int(pconf.get("thin", 1))
-    )
-
-    data_warmup = data[:saved_warmup]
-    data = data[saved_warmup:]
-
-    # Split data to sample_stats and sample
-    sample_stats_columns = {col: idx for col, idx in columns.items() if col.endswith("__")}
-    sample_columns = {col: idx for col, idx in columns.items() if col not in sample_stats_columns}
-
-    return {
-        "sample": data,
-        "sample_warmup": data_warmup,
-        "sample_columns": sample_columns,
-        "sample_stats_columns": sample_stats_columns,
-        "configuration_info": pconf,
-    }
-
-
-def _process_data_var(string):
-    """Transform datastring to key, values pair.
-
-    All values are transformed to floating point values.
-
-    Parameters
-    ----------
-    string : str
-
-    Returns
-    -------
-    Tuple[Str, Str]
-        key, values pair
-    """
-    key, var = string.split("<-")
-    if "structure" in var:
-        var, dim = var.replace("structure(", "").replace(",", "").split(".Dim")
-        # dtype = int if '.' not in var and 'e' not in var.lower() else float
-        dtype = float
-        var = var.replace("c(", "").replace(")", "").strip().split()
-        dim = dim.replace("=", "").replace("c(", "").replace(")", "").strip().split()
-        dim = tuple(map(int, dim))
-        var = np.fromiter(map(dtype, var), dtype).reshape(dim, order="F")
-    elif "c(" in var:
-        # dtype = int if '.' not in var and 'e' not in var.lower() else float
-        dtype = float
-        var = var.replace("c(", "").replace(")", "").split(",")
-        var = np.fromiter(map(dtype, var), dtype)
-    else:
-        # dtype = int if '.' not in var and 'e' not in var.lower() else float
-        dtype = float
-        var = dtype(var)
-    return key.strip(), var
-
-
-def _read_data(path):
-    """Read Rdump or JSON output to dictionary.
-
-    Parameters
-    ----------
-    path : str
-
-    Returns
-    -------
-    Dict
-        key, values pairs from Rdump/JSON formatted data.
-    """
-    data = {}
-    with open(path, "r", encoding="utf8") as f_obj:
-        if path.lower().endswith(".json"):
-            return json.load(f_obj)
-        var = ""
-        for line in f_obj:
-            if "<-" in line:
-                if len(var):
-                    key, var = _process_data_var(var)
-                    data[key] = var
-                var = ""
-            var += f" {line.strip()}"
-        if len(var):
-            key, var = _process_data_var(var)
-            data[key] = var
-    return data
-
-
-def _unpack_ndarrays(arrays, columns, dtypes=None):
-    """Transform a list of ndarrays to dictionary containing ndarrays.
-
-    Parameters
-    ----------
-    arrays : List[np.ndarray]
-    columns: Dict[str, int]
-    dtypes: Dict[str, Any]
-
-    Returns
-    -------
-    Dict
-        key, values pairs. Values are formatted to shape = (nchain, ndraws, *shape)
-    """
-    col_groups = defaultdict(list)
-    for col, col_idx in columns.items():
-        key, *loc = col.split(".")
-        loc = tuple(int(i) - 1 for i in loc)
-        col_groups[key].append((col_idx, loc))
-
-    chains = len(arrays)
-    draws = len(arrays[0])
-    sample = {}
-    if draws:
-        for key, cols_locs in col_groups.items():
-            ndim = np.array([loc for _, loc in cols_locs]).max(0) + 1
-            dtype = dtypes.get(key, np.float64)
-            sample[key] = np.zeros((chains, draws, *ndim), dtype=dtype)
-            for col, loc in cols_locs:
-                for chain_id, arr in enumerate(arrays):
-                    draw = arr[:, col]
-                    if loc == ():
-                        sample[key][chain_id, :] = draw
-                    else:
-                        axis1_all = range(sample[key].shape[1])
-                        slicer = (chain_id, axis1_all, *loc)
-                        sample[key][slicer] = draw
-    return sample
-
-
-def from_cmdstan(
-    posterior: Optional[Union[str, List[str]]] = None,
-    *,
-    posterior_predictive: Optional[Union[str, List[str]]] = None,
-    predictions: Optional[Union[str, List[str]]] = None,
-    prior: Optional[Union[str, List[str]]] = None,
-    prior_predictive: Optional[Union[str, List[str]]] = None,
-    observed_data: Optional[str] = None,
-    observed_data_var: Optional[Union[str, List[str]]] = None,
-    constant_data: Optional[str] = None,
-    constant_data_var: Optional[Union[str, List[str]]] = None,
-    predictions_constant_data: Optional[str] = None,
-    predictions_constant_data_var: Optional[Union[str, List[str]]] = None,
-    log_likelihood: Optional[Union[str, List[str]]] = None,
-    index_origin: Optional[int] = None,
-    coords: Optional[CoordSpec] = None,
-    dims: Optional[DimSpec] = None,
-    disable_glob: Optional[bool] = False,
-    save_warmup: Optional[bool] = None,
-    dtypes: Optional[Dict] = None,
-) -> InferenceData:
-    """Convert CmdStan data into an InferenceData object.
-
-    For a usage example read the
-    :ref:`Creating InferenceData section on from_cmdstan <creating_InferenceData>`
-
-    Parameters
-    ----------
-    posterior : str or list of str, optional
-        List of paths to output.csv files.
-    posterior_predictive : str or list of str, optional
-        Posterior predictive samples for the fit. If endswith ".csv" assumes file.
-    predictions : str or list of str, optional
-        Out of sample predictions samples for the fit. If endswith ".csv" assumes file.
-    prior : str or list of str, optional
-        List of paths to output.csv files
-    prior_predictive : str or list of str, optional
-        Prior predictive samples for the fit. If endswith ".csv" assumes file.
-    observed_data : str, optional
-        Observed data used in the sampling. Path to data file in Rdump or JSON format.
-    observed_data_var : str or list of str, optional
-        Variable(s) used for slicing observed_data. If not defined, all
-        data variables are imported.
-    constant_data : str, optional
-        Constant data used in the sampling. Path to data file in Rdump or JSON format.
-    constant_data_var : str or list of str, optional
-        Variable(s) used for slicing constant_data. If not defined, all
-        data variables are imported.
-    predictions_constant_data : str, optional
-        Constant data for predictions used in the sampling.
-        Path to data file in Rdump or JSON format.
-    predictions_constant_data_var : str or list of str, optional
-        Variable(s) used for slicing predictions_constant_data.
-        If not defined, all data variables are imported.
-    log_likelihood : dict of {str: str}, list of str or str, optional
-        Pointwise log_likelihood for the data. log_likelihood is extracted from the
-        posterior. It is recommended to use this argument as a dictionary whose keys
-        are observed variable names and its values are the variables storing log
-        likelihood arrays in the Stan code. In other cases, a dictionary with keys
-        equal to its values is used. By default, if a variable ``log_lik`` is
-        present in the Stan model, it will be retrieved as pointwise log
-        likelihood values. Use ``False`` to avoid this behaviour.
-    index_origin : int, optional
-        Starting value of integer coordinate values. Defaults to the value in rcParam
-        ``data.index_origin``.
-    coords : dict of {str: array_like}, optional
-        A dictionary containing the values that are used as index. The key
-        is the name of the dimension, the values are the index values.
-    dims : dict of {str: list of str}, optional
-        A mapping from variables to a list of coordinate names for the variable.
-    disable_glob : bool
-        Don't use glob for string input. This means that all string input is
-        assumed to be variable names (samples) or a path (data).
-    save_warmup : bool
-        Save warmup iterations into InferenceData object, if found in the input files.
-        If not defined, use default defined by the rcParams.
-    dtypes : dict or str
-        A dictionary containing dtype information (int, float) for parameters.
-        If input is a string, it is assumed to be a model code or path to model code file.
-
-    Returns
-    -------
-    InferenceData object
-    """
-    return CmdStanConverter(
-        posterior=posterior,
-        posterior_predictive=posterior_predictive,
-        predictions=predictions,
-        prior=prior,
-        prior_predictive=prior_predictive,
-        observed_data=observed_data,
-        observed_data_var=observed_data_var,
-        constant_data=constant_data,
-        constant_data_var=constant_data_var,
-        predictions_constant_data=predictions_constant_data,
-        predictions_constant_data_var=predictions_constant_data_var,
-        log_likelihood=log_likelihood,
-        index_origin=index_origin,
-        coords=coords,
-        dims=dims,
-        disable_glob=disable_glob,
-        save_warmup=save_warmup,
-        dtypes=dtypes,
-    ).to_inference_data()