🤖 Format .jl files

Author: juliohm

docs/make.jl

@@ -3,8 +3,11 @@ using DocumenterTools: Themes
 
 using TransformsBase
 
-Themes.compile(joinpath(@__DIR__,"src/assets/light.scss"), joinpath(@__DIR__,"src/assets/themes/documenter-light.css"))
-Themes.compile(joinpath(@__DIR__,"src/assets/dark.scss"), joinpath(@__DIR__,"src/assets/themes/documenter-dark.css"))
+Themes.compile(
+  joinpath(@__DIR__, "src/assets/light.scss"),
+  joinpath(@__DIR__, "src/assets/themes/documenter-light.css")
+)
+Themes.compile(joinpath(@__DIR__, "src/assets/dark.scss"), joinpath(@__DIR__, "src/assets/themes/documenter-dark.css"))
 
 DocMeta.setdocmeta!(TableTransforms, :DocTestSetup, :(using TableTransforms); recursive=true)
 
@@ -19,17 +22,12 @@ makedocs(;
   format=Documenter.HTML(;
     prettyurls=get(ENV, "CI", "false") == "true",
     canonical="https://JuliaML.github.io/TableTransforms.jl",
-    assets=["assets/favicon.ico", asset("https://fonts.googleapis.com/css?family=Montserrat|Source+Code+Pro&display=swap", class=:css)]
+    assets=[
+      "assets/favicon.ico",
+      asset("https://fonts.googleapis.com/css?family=Montserrat|Source+Code+Pro&display=swap", class=:css)
+    ]
   ),
-  pages=[
-    "Home" => "index.md",
-    "Transforms" => "transforms.md",
-    "Related" => "related.md"
-  ]
+  pages=["Home" => "index.md", "Transforms" => "transforms.md", "Related" => "related.md"]
 )
 
-deploydocs(;
-  repo="github.com/JuliaML/TableTransforms.jl",
-  devbranch="master",
-  push_preview=true
-)
+deploydocs(; repo="github.com/JuliaML/TableTransforms.jl", devbranch="master", push_preview=true)

src/TableTransforms.jl

@@ -67,9 +67,12 @@ export
   Quantile,
   Functional,
   EigenAnalysis,
-  PCA, DRS, SDS,
+  PCA,
+  DRS,
+  SDS,
   ProjectionPursuit,
   RowTable,
   ColTable,
-  →, ⊔
+  →,
+  ⊔
 end

src/assertions.jl

@@ -11,8 +11,7 @@ struct SciTypeAssertion{T,S<:ColSpec}
   colspec::S
 end
 
-SciTypeAssertion{T}(colspec::S) where {T,S<:ColSpec} = 
-  SciTypeAssertion{T,S}(colspec)
+SciTypeAssertion{T}(colspec::S) where {T,S<:ColSpec} = SciTypeAssertion{T,S}(colspec)
 
 SciTypeAssertion{T}() where {T} = SciTypeAssertion{T}(AllSpec())
 

src/distributions.jl

@@ -48,4 +48,4 @@ function cdf(d::EmpiricalDistribution{T}, x::T) where {T<:Real}
       return (pu - pl) * (x - l) / (u - l) + pl
     end
   end
-end
+end

src/tableselection.jl

@@ -20,17 +20,14 @@ struct TableSelection{T,C}
 end
 
 function Base.:(==)(a::TableSelection, b::TableSelection)
-  a.names  != b.names  && return false
+  a.names != b.names && return false
   a.onames != b.onames && return false
   all(nm -> Tables.getcolumn(a, nm) == Tables.getcolumn(b, nm), a.names)
 end
 
 function Base.show(io::IO, t::TableSelection)
   println(io, "TableSelection")
-  pretty_table(io, t,
-    vcrop_mode=:middle,
-    newline_at_end=false
-  )
+  pretty_table(io, t, vcrop_mode=:middle, newline_at_end=false)
 end
 
 # Tables.jl interface
@@ -49,13 +46,12 @@ function Tables.getcolumn(t::TableSelection, nm::Symbol)
   Tables.getcolumn(t.cols, t.mapnames[nm])
 end
 
-Tables.materializer(t::TableSelection) =
-  Tables.materializer(t.table)
+Tables.materializer(t::TableSelection) = Tables.materializer(t.table)
 
 function Tables.schema(t::TableSelection)
   schema = Tables.schema(t.cols)
-  names  = schema.names
-  types  = schema.types
-  inds   = indexin(t.onames, collect(names))
+  names = schema.names
+  types = schema.types
+  inds = indexin(t.onames, collect(names))
   Tables.Schema(t.names, types[inds])
 end

src/tabletraits.jl

@@ -16,4 +16,4 @@ divide(table) = table, nothing
 Combine a table with `features` and a `metadata`
 object into a special type of `table`.
 """
-attach(features, ::Nothing) = features
+attach(features, ::Nothing) = features

src/transforms.jl

@@ -150,7 +150,7 @@ function revert(transform::FeatureTransform, newtable, cache)
   @assert isrevertible(transform) "Transform is not revertible"
 
   newfeat, newmeta = divide(newtable)
-  fcache,   mcache = cache
+  fcache, mcache = cache
 
   feat = revertfeat(transform, newfeat, fcache)
   meta = revertmeta(transform, newmeta, mcache)
@@ -159,7 +159,7 @@ function revert(transform::FeatureTransform, newtable, cache)
 end
 
 function reapply(transform::FeatureTransform, table, cache)
-  feat,     meta = divide(table)
+  feat, meta = divide(table)
   fcache, mcache = cache
 
   for assertion in assertions(transform)
@@ -180,22 +180,20 @@ reapplymeta(::FeatureTransform, meta, mcache) = meta
 # STATELESS FALLBACKS
 # --------------------
 
-reapply(transform::StatelessTableTransform, table, cache) =
-  apply(transform, table) |> first
+reapply(transform::StatelessTableTransform, table, cache) = apply(transform, table) |> first
 
-reapply(transform::StatelessFeatureTransform, table, cache) =
-  apply(transform, table) |> first
+reapply(transform::StatelessFeatureTransform, table, cache) = apply(transform, table) |> first
 
 # ------------------
 # COLWISE FALLBACKS
 # ------------------
 
 function applyfeat(transform::ColwiseFeatureTransform, feat, prep)
   # retrieve column names and values
-  cols   = Tables.columns(feat)
-  names  = Tables.columnnames(cols)
+  cols = Tables.columns(feat)
+  names = Tables.columnnames(cols)
   snames = choose(transform.colspec, names)
-  
+
   # function to transform a single column
   function colfunc(n)
     x = Tables.getcolumn(cols, n)
@@ -225,11 +223,11 @@ end
 
 function revertfeat(transform::ColwiseFeatureTransform, newfeat, fcache)
   # transformed columns
-  cols  = Tables.columns(newfeat)
+  cols = Tables.columns(newfeat)
   names = Tables.columnnames(cols)
-  
+
   caches, snames = fcache
-  
+
   # function to transform a single column
   function colfunc(i)
     n = names[i]
@@ -248,11 +246,11 @@ end
 
 function reapplyfeat(transform::ColwiseFeatureTransform, feat, fcache)
   # retrieve column names and values
-  cols  = Tables.columns(feat)
+  cols = Tables.columns(feat)
   names = Tables.columnnames(cols)
 
   caches, snames = fcache
-  
+
   # check that cache is valid
   @assert length(names) == length(caches) "invalid caches for feat"
 
@@ -296,4 +294,4 @@ include("transforms/eigenanalysis.jl")
 include("transforms/projectionpursuit.jl")
 include("transforms/rowtable.jl")
 include("transforms/coltable.jl")
-include("transforms/parallel.jl")
+include("transforms/parallel.jl")

src/transforms/center.jl

@@ -33,15 +33,14 @@ end
 
 Center() = Center(AllSpec())
 Center(spec) = Center(colspec(spec))
-Center(cols::C...) where {C<:Col} = 
-  Center(colspec(cols))
+Center(cols::C...) where {C<:Col} = Center(colspec(cols))
 
 assertions(transform::Center) = [SciTypeAssertion{Continuous}(transform.colspec)]
 
 isrevertible(::Type{<:Center}) = true
 
 colcache(::Center, x) = mean(x)
 
-colapply(::Center, x, μ)  = @. x - μ
+colapply(::Center, x, μ) = @. x - μ
 
 colrevert(::Center, y, μ) = @. y + μ

src/transforms/coalesce.jl

@@ -40,8 +40,7 @@ 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(cols::C...; value) where {C<:Col} = Coalesce(colspec(cols), value)
 
 isrevertible(::Type{<:Coalesce}) = true
 

src/transforms/coerce.jl

@@ -22,30 +22,27 @@ struct Coerce{P} <: FeatureTransform
   verbosity::Int
 end
 
-Coerce(pair::Pair{Symbol,<:Type}...; tight=false, verbosity=1) = 
-  Coerce(pair, tight, verbosity)
+Coerce(pair::Pair{Symbol,<:Type}...; tight=false, verbosity=1) = Coerce(pair, tight, verbosity)
 
 isrevertible(::Type{<:Coerce}) = true
 
 function applyfeat(transform::Coerce, feat, prep)
-  newtable = coerce(feat, transform.pairs...;
-                    tight=transform.tight,
-                    verbosity=transform.verbosity)
+  newtable = coerce(feat, transform.pairs...; tight=transform.tight, verbosity=transform.verbosity)
 
   types = Tables.schema(feat).types
-  
+
   newtable, types
 end
 
 function revertfeat(::Coerce, newfeat, fcache)
   cols = Tables.columns(newfeat)
   names = Tables.columnnames(cols)
-  
+
   oldcols = map(zip(fcache, names)) do (T, n)
     x = Tables.getcolumn(cols, n)
     collect(T, x)
   end
-    
+
   𝒯 = (; zip(names, oldcols)...)
   𝒯 |> Tables.materializer(newfeat)
 end

src/transforms/eigenanalysis.jl

@@ -51,8 +51,7 @@ struct EigenAnalysis <: FeatureTransform
   end
 end
 
-EigenAnalysis(proj; maxdim=nothing, pratio=1.0) = 
-  EigenAnalysis(proj, maxdim, pratio)
+EigenAnalysis(proj; maxdim=nothing, pratio=1.0) = EigenAnalysis(proj, maxdim, pratio)
 
 assertions(::Type{EigenAnalysis}) = [SciTypeAssertion{Continuous}()]
 
@@ -130,10 +129,10 @@ _maxdim(::Nothing, Y) = size(Y, 2)
 
 function outdim(transform, Y, λ)
   pratio = transform.pratio
-  csums  = cumsum(λ) 
+  csums = cumsum(λ)
   ratios = csums ./ last(csums)
-  mdim   = _maxdim(transform.maxdim, Y)
-  pdim   = findfirst(≥(pratio), ratios)
+  mdim = _maxdim(transform.maxdim, Y)
+  pdim = findfirst(≥(pratio), ratios)
   min(mdim, pdim)
 end
 
@@ -144,15 +143,15 @@ function eigenmatrices(transform, Y)
   λ, V = eigen(Σ, sortby=λ -> -real(λ))
 
   if proj == :V
-    S   = V
+    S = V
     S⁻¹ = transpose(V)
   elseif proj == :VD
-    Λ   = Diagonal(sqrt.(λ))
-    S   = V * inv(Λ)
+    Λ = Diagonal(sqrt.(λ))
+    S = V * inv(Λ)
     S⁻¹ = Λ * transpose(V)
   elseif proj == :VDV
-    Λ   = Diagonal(sqrt.(λ))
-    S   = V * inv(Λ) * transpose(V)
+    Λ = Diagonal(sqrt.(λ))
+    S = V * inv(Λ) * transpose(V)
     S⁻¹ = V * Λ * transpose(V)
   end
 
@@ -177,8 +176,7 @@ PCA(pratio=0.86)
 PCA(maxdim=2, pratio=0.86)
 ```
 """
-PCA(; maxdim=nothing, pratio=1.0) = 
-  ZScore() → EigenAnalysis(:V, maxdim, pratio)
+PCA(; maxdim=nothing, pratio=1.0) = ZScore() → EigenAnalysis(:V, maxdim, pratio)
 
 """
     DRS(; maxdim=nothing, pratio=1.0)
@@ -196,8 +194,7 @@ DRS(pratio=0.87)
 DRS(maxdim=3, pratio=0.87)
 ```
 """
-DRS(; maxdim=nothing, pratio=1.0) = 
-  ZScore() → EigenAnalysis(:VD, maxdim, pratio)
+DRS(; maxdim=nothing, pratio=1.0) = ZScore() → EigenAnalysis(:VD, maxdim, pratio)
 
 """
     SDS(; maxdim=nothing, pratio=1.0)
@@ -216,5 +213,4 @@ SDS(pratio=0.88)
 SDS(maxdim=4, pratio=0.88)
 ```
 """
-SDS(; maxdim=nothing, pratio=1.0) = 
-  ZScore() → EigenAnalysis(:VDV, maxdim, pratio)
+SDS(; maxdim=nothing, pratio=1.0) = ZScore() → EigenAnalysis(:VDV, maxdim, pratio)

src/transforms/filter.jl

@@ -19,14 +19,14 @@ Filter(row -> row.a == true && row.b < 30)
 * The schema of the table is preserved by the transform.
 """
 struct Filter{F} <: StatelessFeatureTransform
-  func::F 
+  func::F
 end
 
 isrevertible(::Type{<:Filter}) = true
 
 function preprocess(transform::Filter, table)
   # lazy row iterator
-  rows  = Tables.rows(table)
+  rows = Tables.rows(table)
 
   # selected indices
   sinds, nrows = Int[], 0
@@ -107,16 +107,13 @@ DropMissing() = DropMissing(AllSpec())
 
 DropMissing(spec) = DropMissing(colspec(spec))
 
-DropMissing(cols::T...) where {T<:Col} =
-  DropMissing(colspec(cols))
+DropMissing(cols::T...) where {T<:Col} = DropMissing(colspec(cols))
 
 isrevertible(::Type{<:DropMissing}) = true
 
-_ftrans(::DropMissing{AllSpec}, cols) =
-  Filter(row -> all(!ismissing, row))
+_ftrans(::DropMissing{AllSpec}, cols) = Filter(row -> all(!ismissing, row))
 
-_ftrans(::DropMissing, cols) =
-  Filter(row -> all(!ismissing, getindex.(Ref(row), cols)))
+_ftrans(::DropMissing, cols) = Filter(row -> all(!ismissing, getindex.(Ref(row), cols)))
 
 # nonmissing 
 _nonmissing(::Type{T}, x) where {T} = x
@@ -125,10 +122,10 @@ _nonmissing(x) = _nonmissing(eltype(x), x)
 
 function preprocess(transform::DropMissing, table)
   schema = Tables.schema(table)
-  names  = schema.names
+  names = schema.names
   snames = choose(transform.colspec, names)
   ftrans = _ftrans(transform, snames)
-  fprep  = preprocess(ftrans, table)
+  fprep = preprocess(ftrans, table)
   ftrans, fprep, snames
 end
 
@@ -138,7 +135,7 @@ function applyfeat(::DropMissing, feat, prep)
   newfeat, ffcache = applyfeat(ftrans, feat, fprep)
 
   # drop Missing type
-  cols  = Tables.columns(newfeat)
+  cols = Tables.columns(newfeat)
   names = Tables.columnnames(cols)
   ncols = map(names) do n
     x = Tables.getcolumn(cols, n)