Add Assert transform (#249)

* Add Assert transform

* Fix typo

* Rename variable

Author: eliascarv

docs/src/transforms.md

@@ -2,6 +2,12 @@
 
 Below is the list of transforms that are are available in this package.
 
+# Assert
+
+```@docs
+Assert
+```
+
 ## Select
 
 ```@docs

src/TableTransforms.jl

@@ -30,7 +30,6 @@ import Distributions: quantile, cdf
 import TransformsBase: assertions, isrevertible, isinvertible
 import TransformsBase: apply, revert, reapply, preprocess, inverse
 
-include("assertions.jl")
 include("tabletraits.jl")
 include("distributions.jl")
 include("tableselection.jl")
@@ -49,6 +48,7 @@ export
   reapply,
 
   # built-in
+  Assert,
   Select,
   Reject,
   Satisfies,

src/assertions.jl

@@ -265,6 +265,7 @@ end
 # ----------------
 
 include("transforms/utils.jl")
+include("transforms/assert.jl")
 include("transforms/select.jl")
 include("transforms/satisfies.jl")
 include("transforms/rename.jl")

src/transforms.jl

@@ -0,0 +1,64 @@
+# ------------------------------------------------------------------
+# Licensed under the MIT License. See LICENSE in the project root.
+# ------------------------------------------------------------------
+
+"""
+    Assert(; cond, msg="")
+
+Asserts all columns of the table by throwing a `AssertionError(msg)`
+if `cond(column)` returns `false`, otherwise returns the input table.
+
+The `msg` argument can be a string, or a function that receives
+the column name and returns a string, e.g.: `nm -> "error in column \$nm"`.
+
+    Assert(col₁, col₂, ..., colₙ; cond, msg="")
+    Assert([col₁, col₂, ..., colₙ]; cond, msg="")
+    Assert((col₁, col₂, ..., colₙ); cond, msg="")
+
+Asserts the selected columns `col₁`, `col₂`, ..., `colₙ`.
+
+    Assert(regex; cond, msg="")
+
+Asserts the columns that match with `regex`.
+
+# Examples
+
+```julia
+Assert(cond=allunique, msg="assertion error")
+Assert([2, 3, 5], cond=x -> sum(x) > 100)
+Assert([:b, :c, :e], cond=x -> eltype(x) <: Integer)
+Assert(("b", "c", "e"), cond=allunique, msg=nm -> "error in column \$nm")
+Assert(r"[bce]", cond=x -> sum(x) > 100)
+```
+"""
+struct Assert{S<:ColumnSelector,C,M} <: StatelessFeatureTransform
+  selector::S
+  cond::C
+  msg::M
+end
+
+Assert(selector::ColumnSelector; cond, msg="") = Assert(selector, cond, msg)
+
+Assert(; kwargs...) = Assert(AllSelector(); kwargs...)
+Assert(cols; kwargs...) = Assert(selector(cols); kwargs...)
+Assert(cols::C...; kwargs...) where {C<:Column} = Assert(selector(cols); kwargs...)
+
+isrevertible(::Type{<:Assert}) = true
+
+function applyfeat(transform::Assert, feat, prep)
+  cols = Tables.columns(feat)
+  names = Tables.columnnames(cols)
+  snames = transform.selector(names)
+  cond = transform.cond
+  msg = transform.msg
+
+  msgfun = msg isa AbstractString ? _ -> msg : msg
+  for name in snames
+    x = Tables.getcolumn(cols, name)
+    _assert(cond(x), msgfun(name))
+  end
+
+  feat, nothing
+end
+
+revertfeat(::Assert, newfeat, fcache) = newfeat

src/transforms/assert.jl

@@ -35,7 +35,7 @@ Center() = Center(AllSelector())
 Center(cols) = Center(selector(cols))
 Center(cols::C...) where {C<:Column} = Center(selector(cols))
 
-assertions(transform::Center) = [SciTypeAssertion{Continuous}(transform.selector)]
+assertions(transform::Center) = [scitypeassert(Continuous, transform.selector)]
 
 isrevertible(::Type{<:Center}) = true
 

src/transforms/center.jl

@@ -15,7 +15,7 @@ struct Closure <: StatelessFeatureTransform end
 
 isrevertible(::Type{Closure}) = true
 
-assertions(::Closure) = [SciTypeAssertion{Continuous}()]
+assertions(::Closure) = [scitypeassert(Continuous)]
 
 function applyfeat(::Closure, feat, prep)
   cols = Tables.columns(feat)

src/transforms/closure.jl

@@ -52,7 +52,7 @@ end
 
 EigenAnalysis(proj; maxdim=nothing, pratio=1.0) = EigenAnalysis(proj, maxdim, pratio)
 
-assertions(::EigenAnalysis) = [SciTypeAssertion{Continuous}()]
+assertions(::EigenAnalysis) = [scitypeassert(Continuous)]
 
 isrevertible(::Type{EigenAnalysis}) = true
 

src/transforms/eigenanalysis.jl

@@ -46,7 +46,7 @@ end
 
 Indicator(col::Column; k=10, scale=:quantile, categ=false) = Indicator(selector(col), k, scale, categ)
 
-assertions(transform::Indicator) = [SciTypeAssertion{Continuous}(transform.selector)]
+assertions(transform::Indicator) = [scitypeassert(Continuous, transform.selector)]
 
 isrevertible(::Type{<:Indicator}) = true
 

src/transforms/indicator.jl

@@ -27,7 +27,7 @@ Levels(pairs::Pair{C}...; ordered=nothing) where {C<:Column} =
 
 Levels(; kwargs...) = throw(ArgumentError("cannot create Levels transform without arguments"))
 
-assertions(transform::Levels) = [SciTypeAssertion{Categorical}(transform.selector)]
+assertions(transform::Levels) = [scitypeassert(Categorical, transform.selector)]
 
 isrevertible(::Type{<:Levels}) = true