Refactor: Drop ColSpec in favor of ColumnSelector from ColumnSelectors.jl (#203)

* Refactor: Drop 'ColSpec' in favor of 'ColumnSelector' from ColumnSelectors.jl

* Update 'DropUnits' and 'AbsoluteUnits'

* Fix typo

Author: eliascarv

Project.toml

@@ -6,6 +6,7 @@ version = "1.15.3"
 [deps]
 AbstractTrees = "1520ce14-60c1-5f80-bbc7-55ef81b5835c"
 CategoricalArrays = "324d7699-5711-5eae-9e2f-1d82baa6b597"
+ColumnSelectors = "9cc86067-7e36-4c61-b350-1ac9833d277f"
 Distributions = "31c24e10-a181-5473-b8eb-7969acd0382f"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 NelderMead = "2f6b4ddb-b4ff-44c0-b59b-2ab99302f970"
@@ -22,6 +23,7 @@ Unitful = "1986cc42-f94f-5a68-af5c-568840ba703d"
 [compat]
 AbstractTrees = "0.4"
 CategoricalArrays = "0.10"
+ColumnSelectors = "0.1"
 Distributions = "0.25"
 NelderMead = "0.4"
 PrettyTables = "2"

src/TableTransforms.jl

@@ -19,6 +19,8 @@ using CategoricalArrays
 using Random
 using NelderMead: optimise
 
+using ColumnSelectors: ColumnSelector, SingleColumnSelector
+using ColumnSelectors: AllSelector, Column, selector, selectsingle
 using Unitful: AbstractQuantity, AffineQuantity, AffineUnits, Units
 
 import Distributions: ContinuousUnivariateDistribution
@@ -28,7 +30,6 @@ import TransformsBase: Transform, Identity, →
 import TransformsBase: assertions, isrevertible, preprocess
 import TransformsBase: apply, revert, reapply
 
-include("colspec.jl")
 include("assertions.jl")
 include("tabletraits.jl")
 include("distributions.jl")

src/assertions.jl

@@ -3,22 +3,22 @@
 # ------------------------------------------------------------------
 
 """
-    SciTypeAssertion{T}(colspec = AllSpec())
+    SciTypeAssertion{T}(selector = AllSelector())
 
-Asserts that the columns in the `colspec` have a scientific type `T`.
+Asserts that the columns in the `selector` have a scientific type `T`.
 """
-struct SciTypeAssertion{T,S<:ColSpec}
-  colspec::S
+struct SciTypeAssertion{T,S<:ColumnSelector}
+  selector::S
 end
 
-SciTypeAssertion{T}(colspec::S) where {T,S<:ColSpec} = SciTypeAssertion{T,S}(colspec)
+SciTypeAssertion{T}(selector::S) where {T,S<:ColumnSelector} = SciTypeAssertion{T,S}(selector)
 
-SciTypeAssertion{T}() where {T} = SciTypeAssertion{T}(AllSpec())
+SciTypeAssertion{T}() where {T} = SciTypeAssertion{T}(AllSelector())
 
 function (assertion::SciTypeAssertion{T})(table) where {T}
   cols = Tables.columns(table)
   names = Tables.columnnames(cols)
-  snames = choose(assertion.colspec, names)
+  snames = assertion.selector(names)
 
   for nm in snames
     x = Tables.getcolumn(cols, nm)

src/colspec.jl

@@ -91,7 +91,7 @@ these functions in parallel for all columns with multiple threads.
 
 ## Notes
 
-* `ColwiseFeatureTransform` subtypes must have a `colspec` field.
+* `ColwiseFeatureTransform` subtypes must have a `selector` field.
 """
 abstract type ColwiseFeatureTransform <: FeatureTransform end
 
@@ -182,7 +182,7 @@ function applyfeat(transform::ColwiseFeatureTransform, feat, prep)
   # retrieve column names and values
   cols = Tables.columns(feat)
   names = Tables.columnnames(cols)
-  snames = choose(transform.colspec, names)
+  snames = transform.selector(names)
 
   # function to transform a single column
   function colfunc(n)

src/transforms.jl

@@ -28,13 +28,13 @@ AbsoluteUnits(("b", "c", "e"))
 AbsoluteUnits(r"[bce]")
 ```
 """
-struct AbsoluteUnits{S<:ColSpec} <: StatelessFeatureTransform
-  colspec::S
+struct AbsoluteUnits{S<:ColumnSelector} <: StatelessFeatureTransform
+  selector::S
 end
 
-AbsoluteUnits() = AbsoluteUnits(AllSpec())
-AbsoluteUnits(spec) = AbsoluteUnits(colspec(spec))
-AbsoluteUnits(cols::T...) where {T<:Col} = AbsoluteUnits(colspec(cols))
+AbsoluteUnits() = AbsoluteUnits(AllSelector())
+AbsoluteUnits(cols) = AbsoluteUnits(selector(cols))
+AbsoluteUnits(cols::C...) where {C<:Column} = AbsoluteUnits(selector(cols))
 
 isrevertible(::Type{<:AbsoluteUnits}) = true
 
@@ -51,7 +51,7 @@ end
 function applyfeat(transform::AbsoluteUnits, feat, prep)
   cols = Tables.columns(feat)
   names = Tables.columnnames(cols)
-  snames = choose(transform.colspec, names)
+  snames = transform.selector(names)
 
   tuples = map(names) do name
     x = Tables.getcolumn(cols, name)

src/transforms/absoluteunits.jl

@@ -27,15 +27,15 @@ Center(("a", "c", "e"))
 Center(r"[ace]")
 ```
 """
-struct Center{S<:ColSpec} <: ColwiseFeatureTransform
-  colspec::S
+struct Center{S<:ColumnSelector} <: ColwiseFeatureTransform
+  selector::S
 end
 
-Center() = Center(AllSpec())
-Center(spec) = Center(colspec(spec))
-Center(cols::C...) where {C<:Col} = Center(colspec(cols))
+Center() = Center(AllSelector())
+Center(cols) = Center(selector(cols))
+Center(cols::C...) where {C<:Column} = Center(selector(cols))
 
-assertions(transform::Center) = [SciTypeAssertion{Continuous}(transform.colspec)]
+assertions(transform::Center) = [SciTypeAssertion{Continuous}(transform.selector)]
 
 isrevertible(::Type{<:Center}) = true
 

src/transforms/center.jl

@@ -33,14 +33,14 @@ Coalesce(r"[ace]", value=4)
 
 * The transform can alter the element type of columns from `Union{Missing,T}` to `T`.
 """
-struct Coalesce{S<:ColSpec,T} <: ColwiseFeatureTransform
-  colspec::S
+struct Coalesce{S<:ColumnSelector,T} <: ColwiseFeatureTransform
+  selector::S
   value::T
 end
 
-Coalesce(; value) = Coalesce(AllSpec(), value)
-Coalesce(spec; value) = Coalesce(colspec(spec), value)
-Coalesce(cols::C...; value) where {C<:Col} = Coalesce(colspec(cols), value)
+Coalesce(; value) = Coalesce(AllSelector(), value)
+Coalesce(cols; value) = Coalesce(selector(cols), value)
+Coalesce(cols::C...; value) where {C<:Column} = Coalesce(selector(cols), value)
 
 isrevertible(::Type{<:Coalesce}) = true