Merge branch 'master' into J19

Author: mcabbott

Project.toml

@@ -1,7 +1,7 @@
 name = "AxisKeys"
 uuid = "94b1ba4f-4ee9-5380-92f1-94cde586c3c5"
 license = "MIT"
-version = "0.2.9"
+version = "0.2.11"
 
 [deps]
 AbstractFFTs = "621f4979-c628-5d54-868e-fcf4e3e8185c"

src/AxisKeys.jl

@@ -6,7 +6,7 @@ export KeyedArray, axiskeys
 include("lookup.jl")
 
 include("names.jl")
-export named_axiskeys
+export named_axiskeys, rekey
 export NamedDimsArray, dimnames, rename  # Reexport key NamedDimsArrays things
 
 include("wrap.jl")

src/functions.jl

@@ -459,4 +459,9 @@ function Base.filter!(f, a::KeyedVector)
     deleteat!(a, j:lastindex(a))
     return a
 end
-                                                                
+
+function Base.empty!(v::KeyedVector)
+    empty!(axiskeys(v, 1))
+    empty!(v.data)
+    return v
+end

src/names.jl

@@ -173,3 +173,27 @@ function named_axiskeys(A::AbstractArray)
     NT = NamedTuple{dimnames(A)}
     NT(axiskeys(A))
 end
+
+
+"""
+    rekey(A, (1:10, [:a, :b]))
+    rekey(A, 2 => [:a, :b])
+    rekey(A, :y => [:a, :b])
+
+Rekey a KeyedArray via `Tuple`s or `Pair`s, `dim => newkey`. If `A` also has named
+dimensions then you can also pass `dimname => newkey`.
+"""
+rekey(A::Union{KeyedArray, NdaKa}, k2::Tuple) = KeyedArray(keyless(A), k2)
+function rekey(A::Union{KeyedArray, NdaKa}, k2::Pair{<:Integer, <:AbstractVector}...)
+    dims, vals = first.(k2), last.(k2)
+    new_key = ntuple(ndims(A)) do d
+        idx = findfirst(==(d), dims)
+        idx === nothing ? axiskeys(A, d) : vals[idx]
+    end
+    return rekey(A, new_key)
+end
+
+function rekey(A::Union{KaNda, NdaKa}, k2::Pair{Symbol, <:AbstractVector}...)
+    pairs = map(p -> NamedDims.dim(A, p[1]) => p[2], k2)
+    return rekey(A, pairs...)
+end

src/stack.jl

@@ -14,11 +14,11 @@ function LazyStack.rewrap_like(A, a::NamedTuple)
 end
 
 # tuple of arrays
-function LazyStack.lazystack(x::Tuple{Vararg{<:KeyedArray}})
+function LazyStack.lazystack(x::Tuple{Vararg{KeyedArray}})
     KeyedArray(lazystack(map(parent, x)), stack_keys(x))
 end
 
-stack_keys(xs::Tuple{Vararg{<:KeyedArray}}) =
+stack_keys(xs::Tuple{Vararg{KeyedArray}}) =
     (keys_or_axes(first(xs))..., Base.OneTo(length(xs)))
 
 # array of arrays: first strip off outer containers...

src/statsbase.jl

@@ -48,7 +48,7 @@ end
 
 for fun in (:std, :var, :cov)
     full_name = Symbol("mean_and_$fun")
-    @eval StatsBase.$full_name(A::KeyedMatrix, wv::Vararg{<:AbstractWeights}; dims=:, corrected::Bool=true, kwargs...) =
+    @eval StatsBase.$full_name(A::KeyedMatrix, wv::Vararg{AbstractWeights}; dims=:, corrected::Bool=true, kwargs...) =
         (
             mean(A, wv...; dims=dims, kwargs...),
             $fun(A, wv...; dims=dims, corrected=corrected, kwargs...)

src/tables.jl

@@ -130,7 +130,7 @@ end
 
 Populate `A` with the contents of the `value` column in a provided `table`, matching the
 [Tables.jl](https://github.com/JuliaData/Tables.jl) API. The `table` must contain columns
-corresponding to the keys in `A` and implements `Tables.rows`. If the keys in `A` do not
+corresponding to the keys in `A` and implement `Tables.columns`. If the keys in `A` do not
 uniquely identify rows in the `table` then an `ArgumentError` is throw. If `force` is true
 then the duplicate (non-unique) entries will be overwritten.
 """

test/_basic.jl

@@ -170,6 +170,16 @@ end
 
         @test_throws Exception N(obs=55)  # ideally ArgumentError
         @test_throws Exception N(obs='z') # ideally BoundsError
+
+        new_obs = [:x, :y, :z]
+        new_iter = 1:4
+
+        # Rekey with Tuple
+        @test axiskeys(rekey(N, ([:x, :y, :z], 1:4))) == ([:x, :y, :z], 1:4)
+        # Rekey with dim => axiskey pair
+        @test axiskeys(rekey(N, 2 => 1:4)) == (['a', 'b', 'c'], 1:4)
+        # Rekey with dimname => axiskey pair
+        @test axiskeys(rekey(N, :iter => 1:4)) == (['a', 'b', 'c'], 1:4)
     end
 
     @testset "named_axiskeys" begin

test/_functions.jl

@@ -159,7 +159,7 @@ end
 
     @test axiskeys(filter(isodd, V2),1) isa Vector{Int}
     @test dimnames(filter(isodd, V2)) == (:v,)
-    
+
     V4 = wrapdims(rand(1:99, 10), collect(2:11))
     V4c = copy(V4)
     @test filter!(isodd, V4c) === V4c == filter(isodd, V4)
@@ -299,6 +299,17 @@ end
     @test ka == KeyedArray([4, 5, 6.0], a=1:3)
 end
 
+@testset "empty!" begin
+    kv = wrapdims([1, 2, 3, 4, 5, 6.0], a=[:a, :b, :c, :d, :e, :f])
+    @test kv == empty!(kv)
+    @test isempty(kv)
+
+    # make sure array is not in an invalid state if the emtpy for indices fails
+    ka = wrapdims([4, 5, 6.0], a=1:3)
+    @test_throws MethodError empty!(ka)
+    @test ka == KeyedArray([4, 5, 6.0], a=1:3)
+end
+
 @testset "equality" begin
 
     data = parent(parent(M))