chore: bump compat for DimensionalData to 0.30, (keep existing compat) (#109)

* CompatHelper: bump compat for DimensionalData to 0.30, (keep existing compat)

* chore: Increment patch version number

* fix: Use syntax compatible with both old and new DD versions

* feat: Update Dataset types for DD v0.30

This would be breaking if types are considered as part of the API, but we clearly document our API and do not include the types, so we treat it as non-breaking

* fix: Remove now-unneeded workaround

* fix: Fix docs assignment to Dataset

* format: Run formatter on changed lines

* docs: Update doctests

* reformat: Run formatter

---------

Co-authored-by: CompatHelper Julia <compathelper_noreply@julialang.org>
Co-authored-by: Seth Axen <seth@sethaxen.com>

Author: 3 people

Project.toml

@@ -1,7 +1,7 @@
 name = "InferenceObjects"
 uuid = "b5cf5a8d-e756-4ee3-b014-01d49d192c00"
 authors = ["Seth Axen <seth.axen@gmail.com> and contributors"]
-version = "0.4.15"
+version = "0.4.16"
 
 [deps]
 ANSIColoredPrinters = "a4c015fc-c6ff-483c-b24f-f7ea428134e9"
@@ -25,7 +25,7 @@ InferenceObjectsPosteriorStatsExt = ["PosteriorStats", "StatsBase"]
 ANSIColoredPrinters = "0.0.1"
 ArviZExampleData = "0.3"
 Dates = "1"
-DimensionalData = "0.27, 0.28, 0.29"
+DimensionalData = "0.27, 0.28, 0.29, 0.30"
 EvoTrees = "0.16"
 MCMCDiagnosticTools = "0.3.4"
 MLJBase = "1"

ext/InferenceObjectsMCMCDiagnosticToolsExt/InferenceObjectsMCMCDiagnosticToolsExt.jl

@@ -1,7 +1,7 @@
 module InferenceObjectsMCMCDiagnosticToolsExt
 
 using Base: @doc
-using DimensionalData: DimensionalData, Dimensions, LookupArrays
+using DimensionalData: DimensionalData, Dimensions
 using InferenceObjects: InferenceObjects, Random
 using MCMCDiagnosticTools: MCMCDiagnosticTools
 

ext/InferenceObjectsNCDatasetsExt/InferenceObjectsNCDatasetsExt.jl

@@ -1,6 +1,6 @@
 module InferenceObjectsNCDatasetsExt
 
-using DimensionalData: DimensionalData, Dimensions, LookupArrays
+using DimensionalData: DimensionalData, Dimensions, Lookups
 using NCDatasets: NCDatasets
 using InferenceObjects
 
@@ -20,7 +20,7 @@ function _from_netcdf(ds, load_mode)
                 index = collect(group[dim_name])
                 if index == eachindex(index)
                     # discard the index if it is just the default
-                    index = LookupArrays.NoLookup()
+                    index = Lookups.NoLookup()
                 end
                 return Symbol(dim_name) => Dimensions.Dim{Symbol(dim_name)}(index)
             end...
@@ -36,7 +36,7 @@ function _from_netcdf(ds, load_mode)
                 else
                     var.attrib
                 end
-                metadata = isempty(attrib) ? LookupArrays.NoMetadata() : attrib
+                metadata = isempty(attrib) ? Lookups.NoMetadata() : attrib
                 da = DimensionalData.DimArray(vals, dims; name, metadata)
                 return name => da
             end...
@@ -89,7 +89,7 @@ function InferenceObjects.to_netcdf(
         for dim in Dimensions.dims(group_data)
             dim_name = String(Dimensions.name(dim))
             NCDatasets.defDim(group_ds, dim_name, length(dim))
-            index = LookupArrays.index(group_data, dim)
+            index = parent(Dimensions.lookup(group_data, dim))
             var = NCDatasets.defVar(group_ds, dim_name, eltype(index), (dim_name,))
             copyto!(var, index)
         end

ext/InferenceObjectsPosteriorStatsExt/InferenceObjectsPosteriorStatsExt.jl

@@ -1,7 +1,7 @@
 module InferenceObjectsPosteriorStatsExt
 
 using Base: @doc
-using DimensionalData: DimensionalData, Dimensions, LookupArrays
+using DimensionalData: DimensionalData, Dimensions
 using InferenceObjects: InferenceObjects
 using PosteriorStats: PosteriorStats
 using StatsBase: StatsBase

src/InferenceObjects.jl

@@ -2,7 +2,7 @@ module InferenceObjects
 
 using ANSIColoredPrinters: ANSIColoredPrinters
 using Dates: Dates
-using DimensionalData: DimensionalData, Dimensions, LookupArrays
+using DimensionalData: DimensionalData, Dimensions, Lookups
 using Random: Random
 using Tables: Tables
 

src/dataset.jl

@@ -20,18 +20,26 @@ that implements the same interface as `DimensionalData.DimStack` and has identic
 In most cases, use [`convert_to_dataset`](@ref) to create a `Dataset` instead of directly
 using a constructor.
 """
-struct Dataset{K,T,N,L,D<:DimensionalData.AbstractDimStack{K,T,N,L}} <:
-       DimensionalData.AbstractDimStack{K,T,N,L}
-    data::D
-end
+Dataset
+@static if pkgversion(DimensionalData) ≥ v"0.30.0"
+    struct Dataset{K,T,N,L,D,Data<:DimensionalData.AbstractDimStack{K,T,N,L,D}} <:
+           DimensionalData.AbstractDimStack{K,T,N,L,D}
+        data::Data
+    end
+else # DimensionalData < 0.30
+    struct Dataset{K,T,N,L,Data<:DimensionalData.AbstractDimStack{K,T,N,L}} <:
+           DimensionalData.AbstractDimStack{K,T,N,L}
+        data::Data
+    end
 
-function Dataset{K,T,N}(
-    data::L, dims, refdims, layerdims, metadata, layermetadata
-) where {K,T,N,L}
-    data = DimensionalData.DimStack{K,T,N}(
-        data, dims, refdims, layerdims, metadata, layermetadata
-    )
-    return Dataset{K,T,N,L,typeof(data)}(data)
+    function Dataset{K,T,N}(
+        data::L, dims, refdims, layerdims, metadata, layermetadata
+    ) where {K,T,N,L}
+        data = DimensionalData.DimStack{K,T,N}(
+            data, dims, refdims, layerdims, metadata, layermetadata
+        )
+        return Dataset{K,T,N,L,typeof(data)}(data)
+    end
 end
 Dataset(args...; kwargs...) = Dataset(DimensionalData.DimStack(args...; kwargs...))
 Dataset(data::Dataset) = data
@@ -123,9 +131,6 @@ end
 
 DimensionalData.modify(f, s::Dataset) = Dataset(DimensionalData.modify(f, parent(s)))
 
-# Warning: this is not an API function and probably should be implemented abstractly upstream
-DimensionalData.show_after(io, mime, ::Dataset) = nothing
-
 attributes(data::DimensionalData.AbstractDimStack) = DimensionalData.metadata(data)
 
 Base.convert(T::Type{<:DimensionalData.DimStack}, data::Dataset) = convert(T, parent(data))

src/dimensions.jl

@@ -2,13 +2,13 @@ has_all_sample_dims(dims) = all(Dimensions.hasdim(dims, DEFAULT_SAMPLE_DIMS))
 
 # Like Dimensions.name2dim but doesn't allow users to inject their own dimensions using
 # Dimensions.@dim. See https://github.com/arviz-devs/InferenceObjects.jl/issues/37
-_name2dim(d::Symbol) = Dimensions.Dim{d}(LookupArrays.NoLookup())
+_name2dim(d::Symbol) = Dimensions.Dim{d}(Lookups.NoLookup())
 _name2dim(d::Tuple) = map(_name2dim, d)
 _name2dim(d) = d
 
 # make sure dim has a lookup value accessible with `val`
 _valdim(d) = d
-_valdim(d::Type{<:Dimensions.Dimension}) = d(LookupArrays.NoLookup())
+_valdim(d::Type{<:Dimensions.Dimension}) = d(Lookups.NoLookup())
 
 """
     as_dimension(dim, coords, axis) -> DimensionsionalData.Dimension
@@ -31,8 +31,8 @@ Convert `dim`, `coords`, and `axis` to a `Dimension` object.
 """
 function as_dimension(dim, coords, axis)
     cdim = _valdim(_name2dim(dim))
-    val = LookupArrays.val(cdim)
-    inds = val isa Union{Colon,LookupArrays.NoLookup} ? axis : val
+    val = Lookups.val(cdim)
+    inds = val isa Union{Colon,Lookups.NoLookup} ? axis : val
     coords_inds = get(coords, Dimensions.name(cdim), inds)
     return Dimensions.rebuild(cdim, coords_inds)
 end
@@ -79,7 +79,7 @@ function generate_dims(array, name; dims=(), coords=(;), default_dims=())
     end
     dims_all = (default_dims..., dims_named...)
     # default to the axes if no coords are provided
-    axes_all = map(_ -> LookupArrays.NoLookup(), dims_all)
+    axes_all = map(_ -> Lookups.NoLookup(), dims_all)
     T = NTuple{ndims(array),Dimensions.Dimension}
     dims_with_coords = as_dimension.(dims_all, Ref(coords), axes_all)::T
     return Dimensions.format(dims_with_coords, array)::T
@@ -107,20 +107,20 @@ function array_to_dimarray(array::DimensionalData.AbstractDimArray, name; kwargs
 end
 
 """
-    AsSlice{T<:LookupArrays.Selector} <: LookupArrays.Selector{T}
+    AsSlice{T<:Lookups.Selector} <: Lookups.Selector{T}
 
     AsSlice(selector)
 
 Selector that ensures selected indices are arrays so that slicing occurs.
 
 This is useful to ensure that selecting a single index still returns an array.
 """
-struct AsSlice{T<:LookupArrays.Selector} <: LookupArrays.Selector{T}
+struct AsSlice{T<:Lookups.Selector} <: Lookups.Selector{T}
     val::T
 end
 
-function LookupArrays.selectindices(l::LookupArrays.LookupArray, sel::AsSlice; kw...)
-    i = LookupArrays.selectindices(l, LookupArrays.val(sel); kw...)
+function Lookups.selectindices(l::Lookups.LookupArray, sel::AsSlice; kw...)
+    i = Lookups.selectindices(l, Lookups.val(sel); kw...)
     inds = i isa AbstractVector ? i : [i]
     return inds
 end
@@ -132,4 +132,4 @@ Convert `index` to a collection of indices or a selector representing such a col
 """
 index_to_indices(i) = i
 index_to_indices(i::Int) = [i]
-index_to_indices(sel::LookupArrays.Selector) = AsSlice(sel)
+index_to_indices(sel::Lookups.Selector) = AsSlice(sel)

src/inference_data.jl

@@ -320,6 +320,7 @@ julia> idata_cat1.posterior
 ├────────────────────────────────────────────────── metadata ┤
   Dict{String, Any} with 1 entry:
   "created_at" => "2025-07-25T10:11:18.92"
+└────────────────────────────────────────────────────────────┘
 ```
 
 Alternatively, we can concatenate along a new `run` dimension, which will be created.
@@ -342,6 +343,7 @@ julia> idata_cat2.posterior
 ├───────────────────────────────────────────────────────── metadata ┤
   Dict{String, Any} with 1 entry:
   "created_at" => "2025-07-25T10:11:18.92"
+└───────────────────────────────────────────────────────────────────┘
 ```
 
 We can also concatenate only a subset of groups and merge the rest, which is useful when
@@ -374,6 +376,7 @@ julia> idata_cat3.posterior
 ├───────────────────────────────────────────────────────── metadata ┤
   Dict{String, Any} with 1 entry:
   "created_at" => "2025-07-25T10:11:18.92"
+└───────────────────────────────────────────────────────────────────┘
 
 julia> idata_cat3.observed_data
 ┌ 10-element Dataset ┐
@@ -384,6 +387,7 @@ julia> idata_cat3.observed_data
 ├────────────────────────────────────────────┴ metadata ┐
   Dict{String, Any} with 1 entry:
   "created_at" => "2025-07-25T10:11:18.951"
+└───────────────────────────────────────────────────────┘
 ```
 """
 function Base.cat(data::InferenceData, others::InferenceData...; groups=keys(data), dims)

test/dataset.jl

@@ -1,4 +1,5 @@
 using InferenceObjects, DimensionalData, Test
+using DimensionalData: Lookups
 
 @testset "dataset" begin
     @testset "Dataset" begin
@@ -118,9 +119,9 @@ using InferenceObjects, DimensionalData, Test
         end
 
         @testset "DimensionalData.set" begin
-            ds2 = DimensionalData.set(ds; ydim1=LookupArrays.Sampled([-2, 2]))
+            ds2 = DimensionalData.set(ds, :ydim1 => Lookups.Sampled([-2, 2]))
             @test ds2 isa Dataset
-            @test DimensionalData.lookup(ds2, :ydim1) == [-2, 2]
+            @test parent(DimensionalData.lookup(ds2, :ydim1)) == [-2, 2]
             @test DimensionalData.data(ds2) == DimensionalData.data(ds)
         end
     end

test/dimensions.jl

@@ -1,5 +1,5 @@
 using InferenceObjects, DimensionalData, OffsetArrays, Test
-using DimensionalData.LookupArrays
+using DimensionalData.Lookups
 
 Dimensions.@dim foo "foo"
 
@@ -69,24 +69,27 @@ Dimensions.@dim foo "foo"
         )
         @test gdims isa NTuple{4,Dim}
         @test Dimensions.name(gdims) === (:x_dim_1, :x_dim_2, :x_dim_3, :x_dim_4)
-        @test Dimensions.index(gdims) == (11:20, 0:3, -1:0, 2:4)
-        @test Dimensions.val.(Dimensions.dims(gdims)) isa NTuple{4,LookupArrays.NoLookup}
+        glooks = Dimensions.lookup(gdims)
+        @test glooks isa NTuple{4,NoLookup}
+        @test parent.(glooks) == (11:20, 0:3, -1:0, 2:4)
 
         gdims = @inferred NTuple{4,Dimensions.Dimension} InferenceObjects.generate_dims(
             x, :y; dims=(:a, :b)
         )
         @test gdims isa NTuple{4,Dim}
         @test Dimensions.name(gdims) === (:a, :b, :y_dim_3, :y_dim_4)
-        @test Dimensions.index(gdims) == (11:20, 0:3, -1:0, 2:4)
-        @test Dimensions.val.(Dimensions.dims(gdims)) isa NTuple{4,LookupArrays.NoLookup}
+        glooks = Dimensions.lookup(gdims)
+        @test glooks isa NTuple{4,NoLookup}
+        @test parent.(glooks) == (11:20, 0:3, -1:0, 2:4)
 
         gdims = @inferred NTuple{4,Dimensions.Dimension} InferenceObjects.generate_dims(
             x, :z; dims=(:c, :d), default_dims=(:draw, :chain)
         )
         @test gdims isa NTuple{4,Dim}
         @test Dimensions.name(gdims) === (:draw, :chain, :c, :d)
-        @test Dimensions.index(gdims) == (11:20, 0:3, -1:0, 2:4)
-        @test Dimensions.val.(Dimensions.dims(gdims)) isa NTuple{4,LookupArrays.NoLookup}
+        glooks = Dimensions.lookup(gdims)
+        @test glooks isa NTuple{4,NoLookup}
+        @test parent.(glooks) == (11:20, 0:3, -1:0, 2:4)
 
         x = randn(2, 3)
         InferenceObjects.generate_dims(x, :x; dims=(:a, :b))
@@ -109,15 +112,15 @@ Dimensions.@dim foo "foo"
         gdims = Dimensions.dims(da)
         @test gdims isa NTuple{4,Dim}
         @test Dimensions.name(gdims) === (:x_dim_1, :x_dim_2, :x_dim_3, :x_dim_4)
-        @test Dimensions.index(gdims) == (11:20, 0:3, -1:0, 2:4)
+        @test parent.(Dimensions.lookup(gdims)) == (11:20, 0:3, -1:0, 2:4)
 
         da = @inferred DimArray InferenceObjects.array_to_dimarray(x, :y; dims=(:a, :b))
         @test da == x
         @test DimensionalData.name(da) === :y
         gdims = Dimensions.dims(da)
         @test gdims isa NTuple{4,Dim}
         @test Dimensions.name(gdims) === (:a, :b, :y_dim_3, :y_dim_4)
-        @test Dimensions.index(gdims) == (11:20, 0:3, -1:0, 2:4)
+        @test parent.(Dimensions.lookup(gdims)) == (11:20, 0:3, -1:0, 2:4)
 
         da = @inferred DimArray InferenceObjects.array_to_dimarray(
             x, :z; dims=(:c, :d), default_dims=(:draw, :chain)
@@ -127,7 +130,7 @@ Dimensions.@dim foo "foo"
         gdims = Dimensions.dims(da)
         @test gdims isa NTuple{4,Dim}
         @test Dimensions.name(gdims) === (:draw, :chain, :c, :d)
-        @test Dimensions.index(gdims) == (11:20, 0:3, -1:0, 2:4)
+        @test parent.(Dimensions.lookup(gdims)) == (11:20, 0:3, -1:0, 2:4)
 
         v = randn(1_000)
         da = @inferred DimArray InferenceObjects.array_to_dimarray(
@@ -138,7 +141,7 @@ Dimensions.@dim foo "foo"
         gdims = Dimensions.dims(da)
         @test gdims isa NTuple{2,Dim}
         @test Dimensions.name(gdims) === (:draw, :chain)
-        @test Dimensions.index(gdims) == (1:1000, 1:1)
+        @test parent.(Dimensions.lookup(gdims)) == (1:1000, 1:1)
 
         s = fill(1) # 0-dimensional array
         da = @inferred DimArray InferenceObjects.array_to_dimarray(
@@ -149,18 +152,18 @@ Dimensions.@dim foo "foo"
         gdims = Dimensions.dims(da)
         @test gdims isa NTuple{2,Dim}
         @test Dimensions.name(gdims) === (:draw, :chain)
-        @test Dimensions.index(gdims) == (1:1, 1:1)
+        @test parent.(Dimensions.lookup(gdims)) == (1:1, 1:1)
     end
 
     @testset "AsSlice" begin
         da = DimArray(randn(2), Dim{:a}(["foo", "bar"]))
-        @test da[a=At("foo")] == da[1]
-        da_sel = @inferred da[a=InferenceObjects.AsSlice(At("foo"))]
+        @test da[a = At("foo")] == da[1]
+        da_sel = @inferred da[a = InferenceObjects.AsSlice(At("foo"))]
         @test da_sel isa DimArray
         @test Dimensions.dims(da_sel) == (Dim{:a}(["foo"]),)
-        @test da_sel == da[a=At(["foo"])]
+        @test da_sel == da[a = At(["foo"])]
 
-        da_sel = @inferred da[a=At(["foo", "bar"])]
+        da_sel = @inferred da[a = At(["foo", "bar"])]
         @test da_sel isa DimArray
         @test Dimensions.dims(da_sel) == Dimensions.dims(da)
         @test da_sel == da