Commit ⋅ arviz-devs/ArviZ.jl

convert_result(::typeof(waic), result) = todataframes(result)
convert_result(::typeof(r2_score), result) = todataframes(result)
function convert_result(::typeof(compare), result)
    return todataframes(result; index_name = :name)
    return todataframes(result; index_name=:name)
end

@doc doc"""

@@ -126,15 +126,15 @@

summarystats(idata; var_names = ["mu", "tau"], stat_funcs = func_dict, extend = false)
```
"""
function StatsBase.summarystats(data::InferenceData; group = :posterior, kwargs...)
function StatsBase.summarystats(data::InferenceData; group=:posterior, kwargs...)
    dataset = getproperty(data, Symbol(group))
    return summarystats(dataset; kwargs...)
end
function StatsBase.summarystats(data::Dataset; index_origin = 1, fmt = :wide, kwargs...)
    s = arviz.summary(data; index_origin = index_origin, fmt = fmt, kwargs...)
function StatsBase.summarystats(data::Dataset; index_origin=1, fmt=:wide, kwargs...)
    s = arviz.summary(data; index_origin=index_origin, fmt=fmt, kwargs...)
    s isa Dataset && return s
    index_name = Symbol(fmt) == :long ? :statistic : :variable
    return todataframes(s; index_name = index_name)
    return todataframes(s; index_name=index_name)
end

"""

@@ -150,12 +150,12 @@


# Keywords

- `coords::Dict{String,Vector}=nothing`: Map from named dimension to named indices.
- `dims::Dict{String,Vector{String}}=nothing`: Map from variable name to names of its
  - `coords::Dict{String,Vector}=nothing`: Map from named dimension to named indices.
  - `dims::Dict{String,Vector{String}}=nothing`: Map from variable name to names of its
    dimensions.
- `kwargs`: Keyword arguments passed to [`summarystats`](@ref).
  - `kwargs`: Keyword arguments passed to [`summarystats`](@ref).
"""
function summary(data; group = :posterior, coords = nothing, dims = nothing, kwargs...)
    dataset = convert_to_dataset(data; group = group, coords = coords, dims = dims)
function summary(data; group=:posterior, coords=nothing, dims=nothing, kwargs...)
    dataset = convert_to_dataset(data; group=group, coords=coords, dims=dims)
    return summarystats(dataset; kwargs...)
end

@@ -18,9 +18,10 @@

Convert `MonteCarloMeasurements.AbstractParticles` to an [`InferenceData`](@ref).

`obj` may have the following types:
- `::AbstractParticles`: Univariate draws from a single chain.
- `::AbstractVector{<:AbstractParticles}`: Univariate draws from a vector of chains.
- `::AbstractVector{<:AbstractArray{<:AbstractParticles}}`: Multivariate draws from a vector

  - `::AbstractParticles`: Univariate draws from a single chain.
  - `::AbstractVector{<:AbstractParticles}`: Univariate draws from a vector of chains.
  - `::AbstractVector{<:AbstractArray{<:AbstractParticles}}`: Multivariate draws from a vector
    of chains.
"""
function convert_to_inference_data(obj::AbstractParticles; kwargs...)

@@ -30,8 +31,7 @@

    return convert_to_inference_data(stack(stack.(obj)); kwargs...)
end
function convert_to_inference_data(
    obj::AbstractVector{<:AbstractArray{<:AbstractParticles}};
    kwargs...,
    obj::AbstractVector{<:AbstractArray{<:AbstractParticles}}; kwargs...
)
    return convert_to_inference_data(stack(stack.(obj)); kwargs...)
end

@@ -96,7 +96,7 @@


# Load ArviZ once at precompilation time for docstringS
copy!(arviz, import_arviz())
check_needs_update(update = false)
check_needs_update(; update=false)
const _precompile_arviz_version = arviz_version()

function __init__()

@@ -1,9 +1,9 @@

const has_bokeh_png_deps = false

function initialize_bokeh()
    ispynull(bokeh) || return
    ispynull(bokeh) || return nothing
    try
        copy!(bokeh, _import_dependency("bokeh", "bokeh"; channel = "conda-forge"))
        copy!(bokeh, _import_dependency("bokeh", "bokeh"; channel="conda-forge"))
    catch err
        copy!(bokeh, PyNULL())
        throw(err)

@@ -13,9 +13,9 @@


# install dependencies for saving PNGs if using conda
function initialize_bokeh_png_deps()
    has_bokeh_png_deps && return
    has_bokeh_png_deps && return nothing
    try
        _import_dependency("selenium", "selenium"; channel = "conda-forge")
        _import_dependency("selenium", "selenium"; channel="conda-forge")
        has_bokeh_png_deps = true
    catch err
        has_bokeh_png_deps = false

@@ -59,7 +59,7 @@

    return getproperty(o, name)
end

function render_html(plot::BokehPlot, name = nothing)
function render_html(plot::BokehPlot, name=nothing)
    obj = PyObject(plot)
    return bokeh.embed.file_html(obj, bokeh.resources.CDN, name)
end

@@ -5,7 +5,7 @@

@forwardfun rhat

function convert_arguments(::typeof(bfmi), data, args...; kwargs...)
    dataset = convert_to_dataset(data; group = :sample_stats)
    dataset = convert_to_dataset(data; group=:sample_stats)
    return tuple(dataset, args...), kwargs
end
function convert_arguments(::typeof(bfmi), data::AbstractArray, args...; kwargs...)

@@ -15,7 +15,7 @@

for f in (:ess, :mcse, :rhat)
    @eval begin
        function convert_arguments(::typeof($(f)), data, args...; kwargs...)
            dataset = convert_to_dataset(data; group = :posterior)
            dataset = convert_to_dataset(data; group=:posterior)
            return tuple(dataset, args...), kwargs
        end
        function convert_arguments(::typeof($(f)), data::AbstractArray, args...; kwargs...)

@@ -11,7 +11,7 @@

```@example
using ArviZ
nchains, ndraws = 4, 100
data = [(x = rand(), y = randn(2), z = randn(2, 3)) for _ in 1:nchains, _ in 1:ndraws];
data = [(x=rand(), y=randn(2), z=randn(2, 3)) for _ in 1:nchains, _ in 1:ndraws];
stacked_data = ArviZ.stack(data);
```
"""

@@ -27,7 +27,7 @@

    return ret
end
function stack(x::AbstractArray{<:NamedTuple{K}}) where {K}
    length(x) == 0 && return
    length(x) == 0 && return nothing
    @inbounds x1 = x[1]
    ret = NamedTuple()
    for k in K

@@ -127,7 +127,7 @@

    sample_stats,
    predictions,
    log_likelihood;
    library = nothing,
    library=nothing,
    kwargs...,
)
    all_idata = InferenceData()

@@ -161,23 +161,23 @@

    if library !== nothing
        setattribute!(group_dataset, "inference_library", string(library))
    end
    concat!(all_idata, InferenceData(posterior = group_dataset))
    concat!(all_idata, InferenceData(; posterior=group_dataset))

    return all_idata
end
function from_namedtuple(
    posterior::Union{NamedTuple,Nothing} = nothing;
    posterior_predictive = nothing,
    sample_stats = nothing,
    predictions = nothing,
    prior = nothing,
    prior_predictive = nothing,
    sample_stats_prior = nothing,
    observed_data = nothing,
    constant_data = nothing,
    predictions_constant_data = nothing,
    log_likelihood = nothing,
    library = nothing,
    posterior::Union{NamedTuple,Nothing}=nothing;
    posterior_predictive=nothing,
    sample_stats=nothing,
    predictions=nothing,
    prior=nothing,
    prior_predictive=nothing,
    sample_stats_prior=nothing,
    observed_data=nothing,
    constant_data=nothing,
    predictions_constant_data=nothing,
    log_likelihood=nothing,
    library=nothing,
    kwargs...,
)
    all_idata = from_namedtuple(

@@ -186,16 +186,16 @@

        sample_stats,
        predictions,
        log_likelihood;
        library = library,
        library=library,
        kwargs...,
    )

    if any(x -> x !== nothing, [prior, prior_predictive, sample_stats_prior])
        pre_prior_idata = convert_to_inference_data(
            prior;
            posterior_predictive = prior_predictive,
            sample_stats = sample_stats_prior,
            library = library,
            posterior_predictive=prior_predictive,
            sample_stats=sample_stats_prior,
            library=library,
            kwargs...,
        )
        prior_idata = rekey(

@@ -216,8 +216,7 @@

    ]
        group_data === nothing && continue
        group_dict = convert(Dict, group_data)
        group_dataset =
            convert_to_constant_dataset(group_dict; library = library, kwargs...)
        group_dataset = convert_to_constant_dataset(group_dict; library=library, kwargs...)
        concat!(all_idata, InferenceData(; group => group_dataset))
    end


@@ -250,8 +249,7 @@

    return from_namedtuple(data; kwargs...)
end
function convert_to_inference_data(
    data::AbstractVector{<:AbstractVector{<:NamedTuple}};
    kwargs...,
    data::AbstractVector{<:AbstractVector{<:NamedTuple}}; kwargs...
)
    return from_namedtuple(data; kwargs...)
end

@@ -17,7 +17,7 @@

"""
with_interactive_backend

function with_interactive_backend(f; backend = nothing)
function with_interactive_backend(f; backend=nothing)
    oldisint = PyPlot.isinteractive()
    oldgui = pygui()
    backend === nothing || pygui(Symbol(backend))

@@ -90,17 +90,19 @@

"""
macro forwardfun(f)
    fdoc = forwarddoc(f)
    return esc(quote
        @doc $fdoc $f

        function $(f)(args...; kwargs...)
            args, kwargs = convert_arguments($(f), args...; kwargs...)
            result = arviz.$(f)(args...; kwargs...)
            return convert_result($(f), result)
        end
    return esc(
        quote
            @doc $fdoc $f

            function $(f)(args...; kwargs...)
                args, kwargs = convert_arguments($(f), args...; kwargs...)
                result = arviz.$(f)(args...; kwargs...)
                return convert_result($(f), result)
            end

        Docs.getdoc(::typeof($(f))) = forwardgetdoc(Symbol($(f)))
    end)
            Docs.getdoc(::typeof($(f))) = forwardgetdoc(Symbol($(f)))
        end,
    )
end

"""

@@ -115,23 +117,25 @@

"""
macro forwardplotfun(f)
    fdoc = forwarddoc(f)
    return esc(quote
        @doc $fdoc $f

        function $(f)(args...; backend = nothing, kwargs...)
            if backend === nothing
                backend = get(rcParams, "plot.backend", nothing)
    return esc(
        quote
            @doc $fdoc $f

            function $(f)(args...; backend=nothing, kwargs...)
                if backend === nothing
                    backend = get(rcParams, "plot.backend", nothing)
                end
                backend = Symbol(backend)
                backend_val = Val(backend)
                load_backend(backend_val)
                args, kwargs = convert_arguments($(f), args...; kwargs...)
                result = arviz.$(f)(args...; kwargs..., backend=backend)
                return convert_result($(f), result, backend_val)
            end
            backend = Symbol(backend)
            backend_val = Val(backend)
            load_backend(backend_val)
            args, kwargs = convert_arguments($(f), args...; kwargs...)
            result = arviz.$(f)(args...; kwargs..., backend = backend)
            return convert_result($(f), result, backend_val)
        end

        Docs.getdoc(::typeof($(f))) = forwardgetdoc(Symbol($(f)))
    end)

            Docs.getdoc(::typeof($(f))) = forwardgetdoc(Symbol($(f)))
        end,
    )
end

# Replace `missing` values with `NaN` and do type inference on the result

@@ -192,7 +196,7 @@

If `index_name` is not `nothing`, the index is converted into a column with `index_name`.
Otherwise, it is discarded.
"""
function todataframes(::Val{:DataFrame}, df::PyObject; index_name = nothing)
function todataframes(::Val{:DataFrame}, df::PyObject; index_name=nothing)
    initialize_pandas()
    col_vals = map(df.columns) do name
        series = py"$(df)[$(name)]"

@@ -229,13 +233,13 @@

If `index_name` is not `nothing`, the corresponding column is made the index of the
returned dataframe.
"""
function topandas(::Val{:DataFrame}, df; index_name = nothing)
function topandas(::Val{:DataFrame}, df; index_name=nothing)
    initialize_pandas()
    df = DataFrames.DataFrame(df)
    colnames = names(df)
    rowvals = map(Array, eachrow(df))
    pdf = pandas.DataFrame(rowvals; columns = colnames)
    index_name !== nothing && pdf.set_index(index_name; inplace = true)
    pdf = pandas.DataFrame(rowvals; columns=colnames)
    index_name !== nothing && pdf.set_index(index_name; inplace=true)
    return pdf
end
function topandas(::Val{:Series}, df)

@@ -44,7 +44,11 @@

            if pyisinstance(err, py"ValueError")
                throw(ErrorException(err.args[1]))
            elseif pyisinstance(err, py"KeyError")
                throw(KeyError("$(k) is not a valid rc parameter (see keys(rcParams) for a list of valid parameters)"))
                throw(
                    KeyError(
                        "$(k) is not a valid rc parameter (see keys(rcParams) for a list of valid parameters)",
                    ),
                )
            end
        end
        throw(e)

@@ -63,19 +63,20 @@

    ndraws, _, nchains = size(chns)
    loc_names_old = getfield(chns.name_map, section) # old may be Symbol or String
    loc_names = string.(loc_names_old)
    loc_str_to_old =
        Dict(name_str => name_old for (name_str, name_old) in zip(loc_names, loc_names_old))
    loc_str_to_old = Dict(
        name_str => name_old for (name_str, name_old) in zip(loc_names, loc_names_old)
    )
    vars_to_locs = varnames_locs_dict(loc_names, loc_str_to_old)
    vars_to_arrays = Dict{String,Array}()
    for (var_name, names_locs) in vars_to_locs
        loc_names, locs = names_locs
        max_loc = maximum(hcat([[loc...] for loc in locs]...); dims = 2)
        max_loc = maximum(hcat([[loc...] for loc in locs]...); dims=2)
        ndim = length(max_loc)
        sizes = tuple(max_loc...)

        oldarr = reshape_values(replacemissing(Array(chns.value[:, loc_names, :])))
        if ndim == 0
            arr = dropdims(oldarr; dims = 3)
            arr = dropdims(oldarr; dims=3)
        else
            arr = Array{Union{typeof(NaN),eltype(oldarr)}}(undef, nchains, ndraws, sizes...)
            fill!(arr, NaN)

@@ -89,10 +90,7 @@

end

function chains_to_dict(
    chns::Chains;
    ignore = String[],
    section = :parameters,
    rekey_fun = identity,
    chns::Chains; ignore=String[], section=:parameters, rekey_fun=identity
)
    section in sections(chns) || return Dict()
    chns_dict = section_dict(chns, section)

@@ -108,7 +106,7 @@


Remaining `kwargs` are forwarded to [`from_mcmcchains`](@ref).
"""
function convert_to_inference_data(chns::Chains; group = :posterior, kwargs...)
function convert_to_inference_data(chns::Chains; group=:posterior, kwargs...)
    group = Symbol(group)
    group == :posterior && return from_mcmcchains(chns; kwargs...)
    return from_mcmcchains(; group => chns)

@@ -169,16 +167,16 @@

    posterior_predictive,
    predictions,
    log_likelihood;
    library = MCMCChains,
    library=MCMCChains,
    kwargs...,
)
    kwargs = convert(Dict, merge((; dims = nothing), kwargs))
    kwargs = convert(Dict, merge((; dims=nothing), kwargs))
    library = string(library)
    rekey_fun = d -> rekey(d, stats_key_map)

    # Convert chains to dicts
    post_dict = chains_to_dict(posterior)
    stats_dict = chains_to_dict(posterior; section = :internals, rekey_fun = rekey_fun)
    stats_dict = chains_to_dict(posterior; section=:internals, rekey_fun=rekey_fun)
    stats_dict = enforce_stat_types(stats_dict)

    all_idata = InferenceData()

@@ -197,48 +195,45 @@

        if group_data isa Union{AbstractVector{String},NTuple{N,String} where {N}}
            group_data = popsubdict!(post_dict, group_data)
        end
        group_dataset = convert_to_dataset(group_data; library = library, kwargs...)
        group_dataset = convert_to_dataset(group_data; library=library, kwargs...)
        setattribute!(group_dataset, "inference_library", library)
        concat!(all_idata, InferenceData(; group => group_dataset))
    end

    attrs = attributes_dict(posterior)
    attrs = merge(attrs, Dict("inference_library" => library))
    kwargs = convert(Dict, merge((; attrs = attrs, dims = nothing), kwargs))
    post_idata = _from_dict(post_dict; sample_stats = stats_dict, kwargs...)
    kwargs = convert(Dict, merge((; attrs=attrs, dims=nothing), kwargs))
    post_idata = _from_dict(post_dict; sample_stats=stats_dict, kwargs...)
    concat!(all_idata, post_idata)
    return all_idata
end
function from_mcmcchains(
    posterior = nothing;
    posterior_predictive = nothing,
    predictions = nothing,
    prior = nothing,
    prior_predictive = nothing,
    observed_data = nothing,
    constant_data = nothing,
    predictions_constant_data = nothing,
    log_likelihood = nothing,
    library = MCMCChains,
    posterior=nothing;
    posterior_predictive=nothing,
    predictions=nothing,
    prior=nothing,
    prior_predictive=nothing,
    observed_data=nothing,
    constant_data=nothing,
    predictions_constant_data=nothing,
    log_likelihood=nothing,
    library=MCMCChains,
    kwargs...,
)
    kwargs = convert(Dict, merge((; dims = nothing, coords = nothing), kwargs))
    kwargs = convert(Dict, merge((; dims=nothing, coords=nothing), kwargs))

    all_idata = from_mcmcchains(
        posterior,
        posterior_predictive,
        predictions,
        log_likelihood;
        library = library,
        library=library,
        kwargs...,
    )

    if prior !== nothing
        pre_prior_idata = convert_to_inference_data(
            prior;
            posterior_predictive = prior_predictive,
            library = library,
            kwargs...,
            prior; posterior_predictive=prior_predictive, library=library, kwargs...
        )
        prior_idata = rekey(
            pre_prior_idata,

@@ -257,8 +252,7 @@

        :predictions_constant_data => predictions_constant_data,
    ]
        group_data === nothing && continue
        group_dataset =
            convert_to_constant_dataset(group_data; library = library, kwargs...)
        group_dataset = convert_to_constant_dataset(group_data; library=library, kwargs...)
        concat!(all_idata, InferenceData(; group => group_dataset))
    end


@@ -271,5 +265,5 @@

Call [`from_mcmcchains`](@ref) on output of `CmdStan`.
"""
function from_cmdstan(posterior::Chains; kwargs...)
    return from_mcmcchains(posterior; library = "CmdStan", kwargs...)
    return from_mcmcchains(posterior; library="CmdStan", kwargs...)
end

@@ -6,13 +6,15 @@


# Keywords

- `data_vars::Dict{String,Any}`: Dict mapping variable names to
    + `Vector`: Data vector. Single dimension is named after variable.
    + `Tuple{String,Vector}`: Dimension name and data vector.
    + `Tuple{NTuple{N,String},Array{T,N}} where {N,T}`: Dimension names and data array.
- `coords::Dict{String,Any}`: Dict mapping dimension names to index names. Possible
  - `data_vars::Dict{String,Any}`: Dict mapping variable names to
    
      + `Vector`: Data vector. Single dimension is named after variable.
      + `Tuple{String,Vector}`: Dimension name and data vector.
      + `Tuple{NTuple{N,String},Array{T,N}} where {N,T}`: Dimension names and data array.

  - `coords::Dict{String,Any}`: Dict mapping dimension names to index names. Possible
    arguments has same form as `data_vars`.
- `attrs::Dict{String,Any}`: Global attributes to save on this dataset.
  - `attrs::Dict{String,Any}`: Global attributes to save on this dataset.

In most cases, use [`convert_to_dataset`](@ref) or [`convert_to_constant_dataset`](@ref) or
to create a `Dataset` instead of directly using a constructor.

@@ -82,9 +84,9 @@

"""
convert_to_dataset

function convert_to_dataset(obj; group = :posterior, kwargs...)
function convert_to_dataset(obj; group=:posterior, kwargs...)
    group = Symbol(group)
    idata = convert_to_inference_data(obj; group = group, kwargs...)
    idata = convert_to_inference_data(obj; group=group, kwargs...)
    dataset = getproperty(idata, group)
    return dataset
end

@@ -110,11 +112,7 @@

convert_to_constant_dataset

function convert_to_constant_dataset(
    obj;
    coords = nothing,
    dims = nothing,
    library = nothing,
    attrs = nothing,
    obj; coords=nothing, dims=nothing, library=nothing, attrs=nothing
)
    base = arviz.data.base


@@ -127,9 +125,10 @@

    for (key, vals) in obj
        vals = _asarray(vals)
        val_dims = get(dims, key, nothing)
        (val_dims, val_coords) =
            base.generate_dims_coords(size(vals), key; dims = val_dims, coords = coords)
        data[key] = xarray.DataArray(vals; dims = val_dims, coords = val_coords)
        (val_dims, val_coords) = base.generate_dims_coords(
            size(vals), key; dims=val_dims, coords=coords
        )
        data[key] = xarray.DataArray(vals; dims=val_dims, coords=val_coords)
    end

    default_attrs = base.make_attrs()

@@ -137,7 +136,7 @@

        default_attrs = merge(default_attrs, Dict("inference_library" => string(library)))
    end
    attrs = merge(default_attrs, attrs)
    return Dataset(data_vars = data, coords = coords, attrs = attrs)
    return Dataset(; data_vars=data, coords=coords, attrs=attrs)
end

@doc doc"""

@@ -164,12 +163,12 @@

"""
dict_to_dataset

function dict_to_dataset(data; library = nothing, attrs = nothing, kwargs...)
function dict_to_dataset(data; library=nothing, attrs=nothing, kwargs...)
    if library !== nothing
        ldict = Dict("inference_library" => string(library))
        attrs = (attrs === nothing ? ldict : merge(attrs, ldict))
    end
    return arviz.dict_to_dataset(data; attrs = attrs, kwargs...)
    return arviz.dict_to_dataset(data; attrs=attrs, kwargs...)
end

@doc doc"""

@@ -200,5 +199,5 @@

        end
    end

    return data, (attrs = attrs, coords = coords, dims = dims)
    return data, (attrs=attrs, coords=coords, dims=dims)
end

@@ -87,7 +87,7 @@


convert_to_inference_data(::Nothing; kwargs...) = InferenceData()

function convert_to_dataset(data::InferenceData; group = :posterior, kwargs...)
function convert_to_dataset(data::InferenceData; group=:posterior, kwargs...)
    group = Symbol(group)
    dataset = getproperty(data, group)
    return dataset

@@ -109,19 +109,13 @@


# A more flexible form of `from_dict`
# Internally calls `dict_to_dataset`
function _from_dict(
    posterior = nothing;
    attrs = Dict(),
    coords = nothing,
    dims = nothing,
    dicts...,
)
    dicts = (posterior = posterior, dicts...)
function _from_dict(posterior=nothing; attrs=Dict(), coords=nothing, dims=nothing, dicts...)
    dicts = (posterior=posterior, dicts...)

    datasets = []
    for (name, dict) in pairs(dicts)
        (dict === nothing || isempty(dict)) && continue
        dataset = dict_to_dataset(dict; attrs = attrs, coords = coords, dims = dims)
        dataset = dict_to_dataset(dict; attrs=attrs, coords=coords, dims=dims)
        push!(datasets, name => dataset)
    end


@@ -132,7 +126,7 @@

@doc forwarddoc(:concat) concat

function concat(data::InferenceData...; kwargs...)
    return arviz.concat(data...; inplace = false, kwargs...)
    return arviz.concat(data...; inplace=false, kwargs...)
end

Docs.getdoc(::typeof(concat)) = forwardgetdoc(:concat)

@@ -146,7 +140,7 @@

concat!

function concat!(data::InferenceData, other_data::InferenceData...; kwargs...)
    arviz.concat(data, other_data...; inplace = true, kwargs...)
    arviz.concat(data, other_data...; inplace=true, kwargs...)
    return data
end
concat!(; kwargs...) = InferenceData()

@@ -162,7 +156,7 @@

    return concat(data_new...)
end

function reorder_groups!(data::InferenceData; group_order = SUPPORTED_GROUPS)
function reorder_groups!(data::InferenceData; group_order=SUPPORTED_GROUPS)
    group_order = map(Symbol, group_order)
    names = groupnames(data)
    sorted_names = filter(n -> n ∈ names, group_order)

@@ -26,7 +26,7 @@

@deprecate plot_joint(args...; kwargs...) plot_pair(args...; kwargs...)

function convert_arguments(::typeof(plot_compare), df, args...; kwargs...)
    pdf = topandas(Val(:DataFrame), df; index_name = :name)
    pdf = topandas(Val(:DataFrame), df; index_name=:name)
    return tuple(pdf, args...), kwargs
end


@@ -54,7 +54,7 @@

)
    @eval begin
        function convert_arguments(::typeof($(f)), data, args...; kwargs...)
            idata = convert_to_inference_data(data; group = :posterior)
            idata = convert_to_inference_data(data; group=:posterior)
            return tuple(idata, args...), kwargs
        end
    end

@@ -69,22 +69,17 @@

end

function convert_arguments(::typeof(plot_energy), data, args...; kwargs...)
    dataset = convert_to_dataset(data; group = :sample_stats)
    dataset = convert_to_dataset(data; group=:sample_stats)
    return tuple(dataset, args...), kwargs
end

for f in (:plot_density, :plot_forest, :plot_rank)
    @eval begin
        function convert_arguments(
            ::typeof($(f)),
            data,
            args...;
            transform = identity,
            group = :posterior,
            kwargs...,
            ::typeof($(f)), data, args...; transform=identity, group=:posterior, kwargs...
        )
            tdata = transform(data)
            dataset = convert_to_dataset(tdata; group = group)
            dataset = convert_to_dataset(tdata; group=group)
            return tuple(dataset, args...), kwargs
        end
    end

@@ -95,27 +90,27 @@

        function convert_arguments(
            ::typeof($(f)),
            data::Union{AbstractVector,Tuple},
            transform = identity,
            group = :posterior,
            transform=identity,
            group=:posterior,
            args...;
            kwargs...,
        )
            tdata = transform(data)
            datasets = map(tdata) do datum
                return convert_to_dataset(datum; group = group)
                return convert_to_dataset(datum; group=group)
            end
            return tuple(datasets, args...), kwargs
        end
        function convert_arguments(
            ::typeof($(f)),
            data::AbstractVector{<:Real},
            transform = identity,
            group = :posterior,
            transform=identity,
            group=:posterior,
            args...;
            kwargs...,
        )
            tdata = transform(data)
            dataset = convert_to_dataset(tdata; group = group)
            dataset = convert_to_dataset(tdata; group=group)
            return tuple(dataset, args...), kwargs
        end
    end

@@ -1,8 +1,8 @@

import_arviz() = _import_dependency("arviz", "arviz"; channel = "conda-forge")
import_arviz() = _import_dependency("arviz", "arviz"; channel="conda-forge")

arviz_version() = VersionNumber(arviz.__version__)

function check_needs_update(; update = true)
function check_needs_update(; update=true)
    if arviz_version() < _min_arviz_version
        @warn "ArviZ.jl only officially supports arviz version $(_min_arviz_version) or " *
              "greater but found version $(arviz_version())."

@@ -39,9 +39,9 @@

end

function initialize_arviz()
    ispynull(arviz) || return
    ispynull(arviz) || return nothing
    copy!(arviz, import_arviz())
    check_needs_update(update = true)
    check_needs_update(; update=true)
    check_needs_rebuild()

    append!(SUPPORTED_GROUPS, map(Symbol, arviz.data.inference_data.SUPPORTED_GROUPS))

@@ -63,9 +63,9 @@

end

function initialize_xarray()
    ispynull(xarray) || return
    copy!(xarray, _import_dependency("xarray", "xarray"; channel = "conda-forge"))
    _import_dependency("dask", "dask"; channel = "conda-forge")
    ispynull(xarray) || return nothing
    copy!(xarray, _import_dependency("xarray", "xarray"; channel="conda-forge"))
    _import_dependency("dask", "dask"; channel="conda-forge")
    pytype_mapping(xarray.Dataset, Dataset)
    return nothing
end

@@ -77,8 +77,8 @@

end

function initialize_pandas()
    ispynull(pandas) || return
    copy!(pandas, _import_dependency("pandas", "pandas"; channel = "conda-forge"))
    ispynull(pandas) || return nothing
    copy!(pandas, _import_dependency("pandas", "pandas"; channel="conda-forge"))
    return nothing
end


@@ -87,7 +87,7 @@

    if _using_conda() && _isyes(Base.prompt("Try updating arviz using conda? [Y/n]"))
        # this syntax isn't officially supported, but it works (for now)
        try
            Conda.add("arviz>=$_min_arviz_version"; channel = "conda-forge")
            Conda.add("arviz>=$_min_arviz_version"; channel="conda-forge")
            return true
        catch e
            println(e.msg)

@@ -105,7 +105,7 @@

    return false
end

function _import_dependency(modulename, pkgname = modulename; channel = nothing)
function _import_dependency(modulename, pkgname=modulename; channel=nothing)
    try
        return if channel === nothing
            pyimport_conda(modulename, pkgname)

Files		•	•	•	Coverage
src	539	477	0	62	88.50%
Project Totals (13 files)	539	477	0	62	88.50%

View CI Build Download

No yaml found.

Create your codecov.yml to customize your Codecov experience

Read the docs

Interact now

The inner-most circle is the entire project, moving away from the center are folders then, finally, a single file. The size and color of each slice is representing the number of statements and the coverage, respectively.

SVG

The top section represents the entire project. Proceeding with folders and finally individual files. The size and color of each slice is representing the number of statements and the coverage, respectively.

SVG

Each block represents a single file in the project. The size and color of each block is represented by the number of statements and the coverage, respectively.

SVG

Learn more about the coverage sunburst graph

216	216		]
217	217		group_data === nothing && continue
218	218		group_dict = convert(Dict, group_data)
219		-	group_dataset =
220		-	convert_to_constant_dataset(group_dict; library = library, kwargs...)
	219	+	group_dataset = convert_to_constant_dataset(group_dict; library=library, kwargs...)
221	220		concat!(all_idata, InferenceData(; group => group_dataset))
222	221		end
223	222

229	233		If `index_name` is not `nothing`, the corresponding column is made the index of the
230	234		returned dataframe.
231	235		"""
232		-	function topandas(::Val{:DataFrame}, df; index_name = nothing)
	236	+	function topandas(::Val{:DataFrame}, df; index_name=nothing)
233	237		initialize_pandas()
234	238		df = DataFrames.DataFrame(df)
235	239		colnames = names(df)
236	240		rowvals = map(Array, eachrow(df))
237		-	pdf = pandas.DataFrame(rowvals; columns = colnames)
238		-	index_name !== nothing && pdf.set_index(index_name; inplace = true)
	241	+	pdf = pandas.DataFrame(rowvals; columns=colnames)
	242	+	index_name !== nothing && pdf.set_index(index_name; inplace=true)
239	243		return pdf
240	244		end
241	245		function topandas(::Val{:Series}, df)

169	167		posterior_predictive,
170	168		predictions,
171	169		log_likelihood;
172		-	library = MCMCChains,
	170	+	library=MCMCChains,
173	171		kwargs...,
174	172		)
175		-	kwargs = convert(Dict, merge((; dims = nothing), kwargs))
	173	+	kwargs = convert(Dict, merge((; dims=nothing), kwargs))
176	174		library = string(library)
177	175		rekey_fun = d -> rekey(d, stats_key_map)
178	176
179	177		# Convert chains to dicts
180	178		post_dict = chains_to_dict(posterior)
181		-	stats_dict = chains_to_dict(posterior; section = :internals, rekey_fun = rekey_fun)
	179	+	stats_dict = chains_to_dict(posterior; section=:internals, rekey_fun=rekey_fun)
182	180		stats_dict = enforce_stat_types(stats_dict)
183	181
184	182		all_idata = InferenceData()

197	195		if group_data isa Union{AbstractVector{String},NTuple{N,String} where {N}}
198	196		group_data = popsubdict!(post_dict, group_data)
199	197		end
200		-	group_dataset = convert_to_dataset(group_data; library = library, kwargs...)
	198	+	group_dataset = convert_to_dataset(group_data; library=library, kwargs...)
201	199		setattribute!(group_dataset, "inference_library", library)
202	200		concat!(all_idata, InferenceData(; group => group_dataset))
203	201		end
204	202
205	203		attrs = attributes_dict(posterior)
206	204		attrs = merge(attrs, Dict("inference_library" => library))
207		-	kwargs = convert(Dict, merge((; attrs = attrs, dims = nothing), kwargs))
208		-	post_idata = _from_dict(post_dict; sample_stats = stats_dict, kwargs...)
	205	+	kwargs = convert(Dict, merge((; attrs=attrs, dims=nothing), kwargs))
	206	+	post_idata = _from_dict(post_dict; sample_stats=stats_dict, kwargs...)
209	207		concat!(all_idata, post_idata)
210	208		return all_idata
211	209		end
212	210		function from_mcmcchains(
213		-	posterior = nothing;
214		-	posterior_predictive = nothing,
215		-	predictions = nothing,
216		-	prior = nothing,
217		-	prior_predictive = nothing,
218		-	observed_data = nothing,
219		-	constant_data = nothing,
220		-	predictions_constant_data = nothing,
221		-	log_likelihood = nothing,
222		-	library = MCMCChains,
	211	+	posterior=nothing;
	212	+	posterior_predictive=nothing,
	213	+	predictions=nothing,
	214	+	prior=nothing,
	215	+	prior_predictive=nothing,
	216	+	observed_data=nothing,
	217	+	constant_data=nothing,
	218	+	predictions_constant_data=nothing,
	219	+	log_likelihood=nothing,
	220	+	library=MCMCChains,
223	221		kwargs...,
224	222		)
225		-	kwargs = convert(Dict, merge((; dims = nothing, coords = nothing), kwargs))
	223	+	kwargs = convert(Dict, merge((; dims=nothing, coords=nothing), kwargs))
226	224
227	225		all_idata = from_mcmcchains(
228	226		posterior,
229	227		posterior_predictive,
230	228		predictions,
231	229		log_likelihood;
232		-	library = library,
	230	+	library=library,
233	231		kwargs...,
234	232		)
235	233
236	234		if prior !== nothing
237	235		pre_prior_idata = convert_to_inference_data(
238		-	prior;
239		-	posterior_predictive = prior_predictive,
240		-	library = library,
241		-	kwargs...,
	236	+	prior; posterior_predictive=prior_predictive, library=library, kwargs...
242	237		)
243	238		prior_idata = rekey(
244	239		pre_prior_idata,

257	252		:predictions_constant_data => predictions_constant_data,
258	253		]
259	254		group_data === nothing && continue
260		-	group_dataset =
261		-	convert_to_constant_dataset(group_data; library = library, kwargs...)
	255	+	group_dataset = convert_to_constant_dataset(group_data; library=library, kwargs...)
262	256		concat!(all_idata, InferenceData(; group => group_dataset))
263	257		end
264	258

34	34		convert_result(::typeof(waic), result) = todataframes(result)
35	35		convert_result(::typeof(r2_score), result) = todataframes(result)
36	36		function convert_result(::typeof(compare), result)
37		-	return todataframes(result; index_name = :name)
	37	+	return todataframes(result; index_name=:name)
38	38		end
39	39
40	40		@doc doc"""

126	126		summarystats(idata; var_names = ["mu", "tau"], stat_funcs = func_dict, extend = false)
127	127		```
128	128		"""
129		-	function StatsBase.summarystats(data::InferenceData; group = :posterior, kwargs...)
	129	+	function StatsBase.summarystats(data::InferenceData; group=:posterior, kwargs...)
130	130		dataset = getproperty(data, Symbol(group))
131	131		return summarystats(dataset; kwargs...)
132	132		end
133		-	function StatsBase.summarystats(data::Dataset; index_origin = 1, fmt = :wide, kwargs...)
134		-	s = arviz.summary(data; index_origin = index_origin, fmt = fmt, kwargs...)
	133	+	function StatsBase.summarystats(data::Dataset; index_origin=1, fmt=:wide, kwargs...)
	134	+	s = arviz.summary(data; index_origin=index_origin, fmt=fmt, kwargs...)
135	135		s isa Dataset && return s
136	136		index_name = Symbol(fmt) == :long ? :statistic : :variable
137		-	return todataframes(s; index_name = index_name)
	137	+	return todataframes(s; index_name=index_name)
138	138		end
139	139
140	140		"""

150	150
151	151		# Keywords
152	152
153		-	- `coords::Dict{String,Vector}=nothing`: Map from named dimension to named indices.
154		-	- `dims::Dict{String,Vector{String}}=nothing`: Map from variable name to names of its
	153	+	- `coords::Dict{String,Vector}=nothing`: Map from named dimension to named indices.
	154	+	- `dims::Dict{String,Vector{String}}=nothing`: Map from variable name to names of its
155	155		dimensions.
156		-	- `kwargs`: Keyword arguments passed to [`summarystats`](@ref).
	156	+	- `kwargs`: Keyword arguments passed to [`summarystats`](@ref).
157	157		"""
158		-	function summary(data; group = :posterior, coords = nothing, dims = nothing, kwargs...)
159		-	dataset = convert_to_dataset(data; group = group, coords = coords, dims = dims)
	158	+	function summary(data; group=:posterior, coords=nothing, dims=nothing, kwargs...)
	159	+	dataset = convert_to_dataset(data; group=group, coords=coords, dims=dims)
160	160		return summarystats(dataset; kwargs...)
161	161		end

18	18		Convert `MonteCarloMeasurements.AbstractParticles` to an [`InferenceData`](@ref).
19	19
20	20		`obj` may have the following types:
21		-	- `::AbstractParticles`: Univariate draws from a single chain.
22		-	- `::AbstractVector{<:AbstractParticles}`: Univariate draws from a vector of chains.
23		-	- `::AbstractVector{<:AbstractArray{<:AbstractParticles}}`: Multivariate draws from a vector
	21	+
	22	+	- `::AbstractParticles`: Univariate draws from a single chain.
	23	+	- `::AbstractVector{<:AbstractParticles}`: Univariate draws from a vector of chains.
	24	+	- `::AbstractVector{<:AbstractArray{<:AbstractParticles}}`: Multivariate draws from a vector
24	25		of chains.
25	26		"""
26	27		function convert_to_inference_data(obj::AbstractParticles; kwargs...)

30	31		return convert_to_inference_data(stack(stack.(obj)); kwargs...)
31	32		end
32	33		function convert_to_inference_data(
33		-	obj::AbstractVector{<:AbstractArray{<:AbstractParticles}};
34		-	kwargs...,
	34	+	obj::AbstractVector{<:AbstractArray{<:AbstractParticles}}; kwargs...
35	35		)
36	36		return convert_to_inference_data(stack(stack.(obj)); kwargs...)
37	37		end

96	96
97	97		# Load ArviZ once at precompilation time for docstringS
98	98		copy!(arviz, import_arviz())
99		-	check_needs_update(update = false)
	99	+	check_needs_update(; update=false)
100	100		const _precompile_arviz_version = arviz_version()
101	101
102	102		function __init__()

1	1		const has_bokeh_png_deps = false
2	2
3	3		function initialize_bokeh()
4		-	ispynull(bokeh) \|\| return
	4	+	ispynull(bokeh) \|\| return nothing
5	5		try
6		-	copy!(bokeh, _import_dependency("bokeh", "bokeh"; channel = "conda-forge"))
	6	+	copy!(bokeh, _import_dependency("bokeh", "bokeh"; channel="conda-forge"))
7	7		catch err
8	8		copy!(bokeh, PyNULL())
9	9		throw(err)

13	13
14	14		# install dependencies for saving PNGs if using conda
15	15		function initialize_bokeh_png_deps()
16		-	has_bokeh_png_deps && return
	16	+	has_bokeh_png_deps && return nothing
17	17		try
18		-	_import_dependency("selenium", "selenium"; channel = "conda-forge")
	18	+	_import_dependency("selenium", "selenium"; channel="conda-forge")
19	19		has_bokeh_png_deps = true
20	20		catch err
21	21		has_bokeh_png_deps = false

59	59		return getproperty(o, name)
60	60		end
61	61
62		-	function render_html(plot::BokehPlot, name = nothing)
	62	+	function render_html(plot::BokehPlot, name=nothing)
63	63		obj = PyObject(plot)
64	64		return bokeh.embed.file_html(obj, bokeh.resources.CDN, name)
65	65		end

5	5		@forwardfun rhat
6	6
7	7		function convert_arguments(::typeof(bfmi), data, args...; kwargs...)
8		-	dataset = convert_to_dataset(data; group = :sample_stats)
	8	+	dataset = convert_to_dataset(data; group=:sample_stats)
9	9		return tuple(dataset, args...), kwargs
10	10		end
11	11		function convert_arguments(::typeof(bfmi), data::AbstractArray, args...; kwargs...)

15	15		for f in (:ess, :mcse, :rhat)
16	16		@eval begin
17	17		function convert_arguments(::typeof($(f)), data, args...; kwargs...)
18		-	dataset = convert_to_dataset(data; group = :posterior)
	18	+	dataset = convert_to_dataset(data; group=:posterior)
19	19		return tuple(dataset, args...), kwargs
20	20		end
21	21		function convert_arguments(::typeof($(f)), data::AbstractArray, args...; kwargs...)

11	11		```@example
12	12		using ArviZ
13	13		nchains, ndraws = 4, 100
14		-	data = [(x = rand(), y = randn(2), z = randn(2, 3)) for _ in 1:nchains, _ in 1:ndraws];
	14	+	data = [(x=rand(), y=randn(2), z=randn(2, 3)) for _ in 1:nchains, _ in 1:ndraws];
15	15		stacked_data = ArviZ.stack(data);
16	16		```
17	17		"""

27	27		return ret
28	28		end
29	29		function stack(x::AbstractArray{<:NamedTuple{K}}) where {K}
30		-	length(x) == 0 && return
	30	+	length(x) == 0 && return nothing
31	31		@inbounds x1 = x[1]
32	32		ret = NamedTuple()
33	33		for k in K

127	127		sample_stats,
128	128		predictions,
129	129		log_likelihood;
130		-	library = nothing,
	130	+	library=nothing,
131	131		kwargs...,
132	132		)
133	133		all_idata = InferenceData()

161	161		if library !== nothing
162	162		setattribute!(group_dataset, "inference_library", string(library))
163	163		end
164		-	concat!(all_idata, InferenceData(posterior = group_dataset))
	164	+	concat!(all_idata, InferenceData(; posterior=group_dataset))
165	165
166	166		return all_idata
167	167		end
168	168		function from_namedtuple(
169		-	posterior::Union{NamedTuple,Nothing} = nothing;
170		-	posterior_predictive = nothing,
171		-	sample_stats = nothing,
172		-	predictions = nothing,
173		-	prior = nothing,
174		-	prior_predictive = nothing,
175		-	sample_stats_prior = nothing,
176		-	observed_data = nothing,
177		-	constant_data = nothing,
178		-	predictions_constant_data = nothing,
179		-	log_likelihood = nothing,
180		-	library = nothing,
	169	+	posterior::Union{NamedTuple,Nothing}=nothing;
	170	+	posterior_predictive=nothing,
	171	+	sample_stats=nothing,
	172	+	predictions=nothing,
	173	+	prior=nothing,
	174	+	prior_predictive=nothing,
	175	+	sample_stats_prior=nothing,
	176	+	observed_data=nothing,
	177	+	constant_data=nothing,
	178	+	predictions_constant_data=nothing,
	179	+	log_likelihood=nothing,
	180	+	library=nothing,
181	181		kwargs...,
182	182		)
183	183		all_idata = from_namedtuple(

250	249		return from_namedtuple(data; kwargs...)
251	250		end
252	251		function convert_to_inference_data(
253		-	data::AbstractVector{<:AbstractVector{<:NamedTuple}};
254		-	kwargs...,
	252	+	data::AbstractVector{<:AbstractVector{<:NamedTuple}}; kwargs...
255	253		)
256	254		return from_namedtuple(data; kwargs...)
257	255		end

17	17		"""
18	18		with_interactive_backend
19	19
20		-	function with_interactive_backend(f; backend = nothing)
	20	+	function with_interactive_backend(f; backend=nothing)
21	21		oldisint = PyPlot.isinteractive()
22	22		oldgui = pygui()
23	23		backend === nothing \|\| pygui(Symbol(backend))

90	90		"""
91	91		macro forwardfun(f)
92	92		fdoc = forwarddoc(f)
93		-	return esc(quote
94		-	@doc $fdoc $f
95		-
96		-	function $(f)(args...; kwargs...)
97		-	args, kwargs = convert_arguments($(f), args...; kwargs...)
98		-	result = arviz.$(f)(args...; kwargs...)
99		-	return convert_result($(f), result)
100		-	end
	93	+	return esc(
	94	+	quote
	95	+	@doc $fdoc $f
	96	+
	97	+	function $(f)(args...; kwargs...)
	98	+	args, kwargs = convert_arguments($(f), args...; kwargs...)
	99	+	result = arviz.$(f)(args...; kwargs...)
	100	+	return convert_result($(f), result)
	101	+	end
101	102
102		-	Docs.getdoc(::typeof($(f))) = forwardgetdoc(Symbol($(f)))
103		-	end)
	103	+	Docs.getdoc(::typeof($(f))) = forwardgetdoc(Symbol($(f)))
	104	+	end,
	105	+	)
104	106		end
105	107
106	108		"""

115	117		"""
116	118		macro forwardplotfun(f)
117	119		fdoc = forwarddoc(f)
118		-	return esc(quote
119		-	@doc $fdoc $f
120		-
121		-	function $(f)(args...; backend = nothing, kwargs...)
122		-	if backend === nothing
123		-	backend = get(rcParams, "plot.backend", nothing)
	120	+	return esc(
	121	+	quote
	122	+	@doc $fdoc $f
	123	+
	124	+	function $(f)(args...; backend=nothing, kwargs...)
	125	+	if backend === nothing
	126	+	backend = get(rcParams, "plot.backend", nothing)
	127	+	end
	128	+	backend = Symbol(backend)
	129	+	backend_val = Val(backend)
	130	+	load_backend(backend_val)
	131	+	args, kwargs = convert_arguments($(f), args...; kwargs...)
	132	+	result = arviz.$(f)(args...; kwargs..., backend=backend)
	133	+	return convert_result($(f), result, backend_val)
124	134		end
125		-	backend = Symbol(backend)
126		-	backend_val = Val(backend)
127		-	load_backend(backend_val)
128		-	args, kwargs = convert_arguments($(f), args...; kwargs...)
129		-	result = arviz.$(f)(args...; kwargs..., backend = backend)
130		-	return convert_result($(f), result, backend_val)
131		-	end
132		-
133		-	Docs.getdoc(::typeof($(f))) = forwardgetdoc(Symbol($(f)))
134		-	end)
	135	+
	136	+	Docs.getdoc(::typeof($(f))) = forwardgetdoc(Symbol($(f)))
	137	+	end,
	138	+	)
135	139		end
136	140
137	141		# Replace `missing` values with `NaN` and do type inference on the result

192	196		If `index_name` is not `nothing`, the index is converted into a column with `index_name`.
193	197		Otherwise, it is discarded.
194	198		"""
195		-	function todataframes(::Val{:DataFrame}, df::PyObject; index_name = nothing)
	199	+	function todataframes(::Val{:DataFrame}, df::PyObject; index_name=nothing)
196	200		initialize_pandas()
197	201		col_vals = map(df.columns) do name
198	202		series = py"$(df)[$(name)]"

44	44		if pyisinstance(err, py"ValueError")
45	45		throw(ErrorException(err.args[1]))
46	46		elseif pyisinstance(err, py"KeyError")
47		-	throw(KeyError("$(k) is not a valid rc parameter (see keys(rcParams) for a list of valid parameters)"))
	47	+	throw(
	48	+	KeyError(
	49	+	"$(k) is not a valid rc parameter (see keys(rcParams) for a list of valid parameters)",
	50	+	),
	51	+	)
48	52		end
49	53		end
50	54		throw(e)

63	63		ndraws, _, nchains = size(chns)
64	64		loc_names_old = getfield(chns.name_map, section) # old may be Symbol or String
65	65		loc_names = string.(loc_names_old)
66		-	loc_str_to_old =
67		-	Dict(name_str => name_old for (name_str, name_old) in zip(loc_names, loc_names_old))
	66	+	loc_str_to_old = Dict(
	67	+	name_str => name_old for (name_str, name_old) in zip(loc_names, loc_names_old)
	68	+	)
68	69		vars_to_locs = varnames_locs_dict(loc_names, loc_str_to_old)
69	70		vars_to_arrays = Dict{String,Array}()
70	71		for (var_name, names_locs) in vars_to_locs
71	72		loc_names, locs = names_locs
72		-	max_loc = maximum(hcat([[loc...] for loc in locs]...); dims = 2)
	73	+	max_loc = maximum(hcat([[loc...] for loc in locs]...); dims=2)
73	74		ndim = length(max_loc)
74	75		sizes = tuple(max_loc...)
75	76
76	77		oldarr = reshape_values(replacemissing(Array(chns.value[:, loc_names, :])))
77	78		if ndim == 0
78		-	arr = dropdims(oldarr; dims = 3)
	79	+	arr = dropdims(oldarr; dims=3)
79	80		else
80	81		arr = Array{Union{typeof(NaN),eltype(oldarr)}}(undef, nchains, ndraws, sizes...)
81	82		fill!(arr, NaN)

89	90		end
90	91
91	92		function chains_to_dict(
92		-	chns::Chains;
93		-	ignore = String[],
94		-	section = :parameters,
95		-	rekey_fun = identity,
	93	+	chns::Chains; ignore=String[], section=:parameters, rekey_fun=identity
96	94		)
97	95		section in sections(chns) \|\| return Dict()
98	96		chns_dict = section_dict(chns, section)

108	106
109	107		Remaining `kwargs` are forwarded to [`from_mcmcchains`](@ref).
110	108		"""
111		-	function convert_to_inference_data(chns::Chains; group = :posterior, kwargs...)
	109	+	function convert_to_inference_data(chns::Chains; group=:posterior, kwargs...)
112	110		group = Symbol(group)
113	111		group == :posterior && return from_mcmcchains(chns; kwargs...)
114	112		return from_mcmcchains(; group => chns)

271	265		Call [`from_mcmcchains`](@ref) on output of `CmdStan`.
272	266		"""
273	267		function from_cmdstan(posterior::Chains; kwargs...)
274		-	return from_mcmcchains(posterior; library = "CmdStan", kwargs...)
	268	+	return from_mcmcchains(posterior; library="CmdStan", kwargs...)
275	269		end

6	6
7	7		# Keywords
8	8
9		-	- `data_vars::Dict{String,Any}`: Dict mapping variable names to
10		-	+ `Vector`: Data vector. Single dimension is named after variable.
11		-	+ `Tuple{String,Vector}`: Dimension name and data vector.
12		-	+ `Tuple{NTuple{N,String},Array{T,N}} where {N,T}`: Dimension names and data array.
13		-	- `coords::Dict{String,Any}`: Dict mapping dimension names to index names. Possible
	9	+	- `data_vars::Dict{String,Any}`: Dict mapping variable names to
	10	+
	11	+	+ `Vector`: Data vector. Single dimension is named after variable.
	12	+	+ `Tuple{String,Vector}`: Dimension name and data vector.
	13	+	+ `Tuple{NTuple{N,String},Array{T,N}} where {N,T}`: Dimension names and data array.
	14	+
	15	+	- `coords::Dict{String,Any}`: Dict mapping dimension names to index names. Possible
14	16		arguments has same form as `data_vars`.
15		-	- `attrs::Dict{String,Any}`: Global attributes to save on this dataset.
	17	+	- `attrs::Dict{String,Any}`: Global attributes to save on this dataset.
16	18
17	19		In most cases, use [`convert_to_dataset`](@ref) or [`convert_to_constant_dataset`](@ref) or
18	20		to create a `Dataset` instead of directly using a constructor.

82	84		"""
83	85		convert_to_dataset
84	86
85		-	function convert_to_dataset(obj; group = :posterior, kwargs...)
	87	+	function convert_to_dataset(obj; group=:posterior, kwargs...)
86	88		group = Symbol(group)
87		-	idata = convert_to_inference_data(obj; group = group, kwargs...)
	89	+	idata = convert_to_inference_data(obj; group=group, kwargs...)
88	90		dataset = getproperty(idata, group)
89	91		return dataset
90	92		end

110	112		convert_to_constant_dataset
111	113
112	114		function convert_to_constant_dataset(
113		-	obj;
114		-	coords = nothing,
115		-	dims = nothing,
116		-	library = nothing,
117		-	attrs = nothing,
	115	+	obj; coords=nothing, dims=nothing, library=nothing, attrs=nothing
118	116		)
119	117		base = arviz.data.base
120	118

127	125		for (key, vals) in obj
128	126		vals = _asarray(vals)
129	127		val_dims = get(dims, key, nothing)
130		-	(val_dims, val_coords) =
131		-	base.generate_dims_coords(size(vals), key; dims = val_dims, coords = coords)
132		-	data[key] = xarray.DataArray(vals; dims = val_dims, coords = val_coords)
	128	+	(val_dims, val_coords) = base.generate_dims_coords(
	129	+	size(vals), key; dims=val_dims, coords=coords
	130	+	)
	131	+	data[key] = xarray.DataArray(vals; dims=val_dims, coords=val_coords)
133	132		end
134	133
135	134		default_attrs = base.make_attrs()

137	136		default_attrs = merge(default_attrs, Dict("inference_library" => string(library)))
138	137		end
139	138		attrs = merge(default_attrs, attrs)
140		-	return Dataset(data_vars = data, coords = coords, attrs = attrs)
	139	+	return Dataset(; data_vars=data, coords=coords, attrs=attrs)
141	140		end
142	141
143	142		@doc doc"""