Switch to Tables.jl API

.appveyor.yml

@@ -1,6 +1,5 @@
 environment:
   matrix:
-  - julia_version: 0.7
   - julia_version: 1.0
   - julia_version: nightly
 

.travis.yml

@@ -4,7 +4,6 @@ os:
   - linux
   - osx
 julia:
-  - 0.7
   - 1.0
   - nightly
 notifications:

Project.toml

@@ -4,16 +4,22 @@ authors = ["Invenia Technical Computing"]
 version = "0.2.0"
 
 [deps]
-DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0"
+IterTools = "c8e1da08-722c-5040-9ed9-7db0dc04731e"
+Missings = "e1d29d7a-bbdc-5cf2-9ac0-f12de2c33e28"
 Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"
+StatsBase = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91"
+Tables = "bd369af6-aec1-5ad0-b16a-f7cc5008161c"
 
 [compat]
 DataFrames = "0.17, 0.18"
+IterTools = "1.2"
+Tables = "0.2"
 julia = "1"
 
 [extras]
+DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0"
 RDatasets = "ce6b1742-4840-55fa-b093-852dadbb1d8b"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [targets]
-test = ["RDatasets", "Test"]
+test = ["DataFrames", "RDatasets", "Test"]

src/Impute.jl

@@ -1,14 +1,38 @@
 module Impute
 
-using DataFrames
+using IterTools
 using Statistics
+using StatsBase
+using Tables: Tables, materializer, istable
 
-import DataFrames: DataFrameRow
-import Base.Iterators
+import Base.Iterators: drop
 
 export impute, impute!, chain, chain!, drop, drop!, interp, interp!, ImputeError
 
-const Dataset = Union{AbstractArray, DataFrame}
+function __init__()
+    sym = join(["chain", "chain!", "drop", "drop!", "interp", "interp!"], ", ", " and ")
+
+    @warn(
+        """
+        The following symbols will not be exported in future releases: $sym.
+        Please qualify your calls with `Impute.<method>(...)` or explicitly import the symbol.
+        """
+    )
+
+    @warn(
+        """
+        The default limit for all impute functions will be 1.0 going forward.
+        If you depend on a specific threshold please pass in an appropriate `AbstractContext`.
+        """
+    )
+
+    @warn(
+        """
+        All matrix imputation methods will be switching to the JuliaStats column-major convention
+        (e.g., each column corresponds to an observation, and each row corresponds to a variable).
+        """
+    )
+end
 
 """
     ImputeError{T} <: Exception
@@ -28,118 +52,31 @@ include("context.jl")
 include("imputors.jl")
 
 const global imputation_methods = Dict{Symbol, Type}(
-    :drop => Drop,
+    :drop => DropObs,
+    :dropobs => DropObs,
+    :dropvars => DropVars,
     :interp => Interpolate,
     :fill => Fill,
     :locf => LOCF,
     :nocb => NOCB,
 )
 
-"""
-    impute!(data::Dataset, method::Symbol=:interp, args...; limit::Float64=0.1)
-
-Looks up the `Imputor` type for the `method`, creates it and calls
-`impute!(imputor::Imputor, data::Dataset, limit::Float64)` with it.
-
-# Arguments
-* `data::Dataset`: the datset containing missing elements we should impute.
-* `method::Symbol`: the imputation method to use
-    (options: [`:drop`, `:fill`, `:interp`, `:locf`, `:nocb`])
-* `args::Any...`: any arguments you should pass to the `Imputor` constructor.
-* `limit::Float64`: missing data ratio limit/threshold (default: 0.1)
-"""
-function impute!(data::Dataset, method::Symbol, args...; limit::Float64=0.1)
-    imputor_type = imputation_methods[method]
-    imputor = length(args) > 0 ? imputor_type(args...) : imputor_type()
-    return impute!(imputor, data, limit)
-end
-
-"""
-    impute!(data::Dataset, missing::Function, method::Symbol=:interp, args...; limit::Float64=0.1)
-
-Creates the appropriate `Imputor` type and `Context` (using `missing` function) in order to call
-`impute!(imputor::Imputor, ctx::Context, data::Dataset)` with them.
-
-# Arguments
-* `data::Dataset`: the datset containing missing elements we should impute.
-* `missing::Function`: the missing data function to use
-* `method::Symbol`: the imputation method to use
-    (options: [`:drop`, `:fill`, `:interp`, `:locf`, `:nocb`])
-* `args::Any...`: any arguments you should pass to the `Imputor` constructor.
-* `limit::Float64`: missing data ratio limit/threshold (default: 0.1)
-"""
-function impute!(data::Dataset, missing::Function, method::Symbol, args...; limit::Float64=0.1)
-    imputor_type = imputation_methods[method]
-    imputor = length(args) > 0 ? imputor_type(args...) : imputor_type()
-    ctx = Context(*(size(data)...), 0, limit, missing)
-    return impute!(imputor, ctx, data)
+include("deprecated.jl")
+
+let
+    for (k, v) in imputation_methods
+        local typename = nameof(v)
+        local f = k
+        local f! = Symbol(k, :!)
+
+        # NOTE: The
+        @eval begin
+            $f(data; kwargs...) = impute($typename(; _extract_context_kwargs(kwargs...)...), data)
+            $f!(data; kwargs...) = impute!($typename(; _extract_context_kwargs(kwargs...)...), data)
+            $f(; kwargs...) = data -> impute($typename(; _extract_context_kwargs(kwargs...)...), data)
+            $f!(; kwargs...) = data -> impute!($typename(; _extract_context_kwargs(kwargs...)...), data)
+        end
+    end
 end
 
-"""
-    impute(data::Dataset, args...; kwargs...)
-
-Copies the `data` before calling `impute!(new_data, args...; kwargs...)`
-"""
-function impute(data::Dataset, args...; kwargs...)
-    return impute!(deepcopy(data), args...; kwargs...)
-end
-
-"""
-    chain!(data::Dataset, missing::Function, imputors::Imputor...; kwargs...)
-
-Creates a `Chain` with `imputors` and calls `impute!(imputor, missing, data; kwargs...)`
-"""
-function chain!(data::Dataset, missing::Function, imputors::Imputor...; kwargs...)
-    imputor = Chain(imputors...)
-    return impute!(imputor, missing, data; kwargs...)
-end
-
-"""
-    chain!(data::Dataset, imputors::Imputor...; kwargs...)
-
-Creates a `Chain` with `imputors` and calls `impute!(imputor, data; kwargs...)`
-"""
-function chain!(data::Dataset, imputors::Imputor...; kwargs...)
-    imputor = Chain(imputors...)
-    return impute!(imputor, data; kwargs...)
-end
-
-"""
-    chain(data::Dataset, args...; kwargs...)
-
-Copies the `data` before calling `chain!(data, args...; kwargs...)`
-"""
-function chain(data::Dataset, args...; kwargs...)
-    result = deepcopy(data)
-    return chain!(data, args...; kwargs...)
-end
-
-"""
-    drop!(data::Dataset; limit=1.0)
-
-Utility method for `impute!(data, :drop; limit=limit)`
-"""
-drop!(data::Dataset; limit=1.0) = impute!(data, :drop; limit=limit)
-
-"""
-    drop(data::Dataset; limit=1.0)
-
-Utility method for `impute(data, :drop; limit=limit)`
-"""
-Iterators.drop(data::Dataset; limit=1.0) = impute(data, :drop; limit=limit)
-
-"""
-    interp!(data::Dataset; limit=1.0)
-
-Utility method for `impute!(data, :interp; limit=limit)`
-"""
-interp!(data::Dataset; limit=1.0) = impute!(data, :interp; limit=limit)
-
-"""
-    interp(data::Dataset; limit=1.0)
-
-Utility method for `impute(data, :interp; limit=limit)`
-"""
-interp(data::Dataset; limit=1.0) = impute(data, :interp; limit=limit)
-
 end  # module