Add Satisfies transform and derived transforms: Only and Except (#236)

* Add 'Satisfies' transform and derived transforms: 'Only' and 'Except'

* Update docstrings

* Fix typo

Author: eliascarv

docs/src/transforms.md

@@ -14,12 +14,24 @@ Select
 Reject
 ```
 
+## Satisfies
+
+```@docs
+Satisfies
+```
+
 ## Only
 
 ```@docs
 Only
 ```
 
+## Except
+
+```@docs
+Except
+```
+
 ## Rename
 
 ```@docs

src/TableTransforms.jl

@@ -51,7 +51,9 @@ export
   # built-in
   Select,
   Reject,
+  Satisfies,
   Only,
+  Except,
   Rename,
   StdNames,
   Sort,

src/transforms.jl

@@ -265,7 +265,7 @@ end
 # ----------------
 
 include("transforms/select.jl")
-include("transforms/only.jl")
+include("transforms/satisfies.jl")
 include("transforms/rename.jl")
 include("transforms/stdnames.jl")
 include("transforms/sort.jl")

src/transforms/only.jl

@@ -0,0 +1,68 @@
+# ------------------------------------------------------------------
+# Licensed under the MIT License. See LICENSE in the project root.
+# ------------------------------------------------------------------
+
+"""
+    Satisfies(pred)
+
+Selects the columns where `pred(column)` returns `true`.
+
+# Examples
+
+```julia
+Satisfies(allunique)
+Satisfies(x -> sum(x) > 100)
+Satisfies(x -> eltype(x) <: Integer)
+```
+"""
+struct Satisfies{F} <: StatelessFeatureTransform
+  pred::F
+end
+
+isrevertible(::Type{<:Satisfies}) = true
+
+function applyfeat(transform::Satisfies, feat, prep)
+  pred = transform.pred
+  cols = Tables.columns(feat)
+  names = Tables.columnnames(cols)
+  snames = filter(names) do name
+    x = Tables.getcolumn(cols, name)
+    pred(x)
+  end
+  strans = Select(snames)
+  newfeat, sfcache = applyfeat(strans, feat, prep)
+  newfeat, (strans, sfcache)
+end
+
+function revertfeat(::Satisfies, newfeat, fcache)
+  strans, sfcache = fcache
+  revertfeat(strans, newfeat, sfcache)
+end
+
+"""
+    Only(S)
+
+Selects the columns that have scientific type `S`.
+
+# Examples
+
+```julia
+import DataScienceTraits as DST
+Only(DST.Continuous)
+```
+"""
+Only(S::Type{<:SciType}) = Satisfies(x -> elscitype(x) <: S)
+
+"""
+    Except(S)
+
+Selects the columns that don't have scientific type `S`.
+
+# Examples
+
+```julia
+import DataScienceTraits as DST
+Except(DST.Continuous)
+```
+"""
+Except(S::Type{<:SciType}) = Satisfies(x -> !(elscitype(x) <: S))

src/transforms/satisfies.jl

@@ -42,18 +42,18 @@
     └─ selector = [:a, :b, :c]"""
   end
 
-  @testset "Only" begin
-    T = Only(DST.Continuous)
+  @testset "Satisfies" begin
+    T = Satisfies(allunique)
 
     # compact mode
     iostr = sprint(show, T)
-    @test iostr == "Only(DataScienceTraits.Continuous)"
+    @test iostr == "Satisfies(allunique)"
 
     # full mode
     iostr = sprint(show, MIME("text/plain"), T)
     @test iostr == """
-    Only transform
-    └─ scitype = DataScienceTraits.Continuous"""
+    Satisfies transform
+    └─ pred = allunique"""
   end
 
   @testset "Rename" begin

test/shows.jl

@@ -1,7 +1,7 @@
 transformfiles = [
   "select.jl",
   "rename.jl",
-  "only.jl",
+  "satisfies.jl",
   "stdnames.jl",
   "sort.jl",
   "sample.jl",

test/transforms.jl

@@ -0,0 +1,73 @@
+@testset "Satisfies" begin
+  @test isrevertible(Satisfies(allunique))
+
+  a = [1, 2, 3, 4, 5, 6]
+  b = [6, 5, 4, 3, 2, 1]
+  c = [1, 2, 3, 4, 6, 6]
+  d = [6, 6, 4, 3, 2, 1]
+  t = Table(; a, b, c, d)
+
+  T = Satisfies(allunique)
+  n, c = apply(T, t)
+  @test Tables.schema(n).names == (:a, :b)
+  @test Tables.getcolumn(n, :a) == t.a
+  @test Tables.getcolumn(n, :b) == t.b
+  tₒ = revert(T, n, c)
+  @test t == tₒ
+
+  T = Satisfies(x -> sum(x) > 21)
+  n, c = apply(T, t)
+  @test Tables.schema(n).names == (:c, :d)
+  @test Tables.getcolumn(n, :c) == t.c
+  @test Tables.getcolumn(n, :d) == t.d
+  tₒ = revert(T, n, c)
+  @test t == tₒ
+end
+
+@testset "Only" begin
+  a = rand(10)
+  b = rand(Float32, 10)
+  c = rand(1:9, 10)
+  d = rand('a':'z', 10)
+  t = Table(; a, b, c, d)
+
+  T = Only(DST.Continuous)
+  n, c = apply(T, t)
+  @test Tables.schema(n).names == (:a, :b)
+  @test Tables.getcolumn(n, :a) == t.a
+  @test Tables.getcolumn(n, :b) == t.b
+  tₒ = revert(T, n, c)
+  @test t == tₒ
+
+  T = Only(DST.Categorical)
+  n, c = apply(T, t)
+  @test Tables.schema(n).names == (:c, :d)
+  @test Tables.getcolumn(n, :c) == t.c
+  @test Tables.getcolumn(n, :d) == t.d
+  tₒ = revert(T, n, c)
+  @test t == tₒ
+end
+
+@testset "Except" begin
+  a = rand(10)
+  b = rand(Float32, 10)
+  c = rand(1:9, 10)
+  d = rand('a':'z', 10)
+  t = Table(; a, b, c, d)
+
+  T = Except(DST.Categorical)
+  n, c = apply(T, t)
+  @test Tables.schema(n).names == (:a, :b)
+  @test Tables.getcolumn(n, :a) == t.a
+  @test Tables.getcolumn(n, :b) == t.b
+  tₒ = revert(T, n, c)
+  @test t == tₒ
+
+  T = Except(DST.Continuous)
+  n, c = apply(T, t)
+  @test Tables.schema(n).names == (:c, :d)
+  @test Tables.getcolumn(n, :c) == t.c
+  @test Tables.getcolumn(n, :d) == t.d
+  tₒ = revert(T, n, c)
+  @test t == tₒ
+end