some small repairs (#7)

- Updated readme to use the actual names I ended up going with in #1 
- Fix bug when passing `Pair` object with `on`
- Fix bug in method definition for `quantile_windows`
- Test various keyword arguments for `interval_join`

Author: haberdashPI

.JuliaFormatter.toml

@@ -0,0 +1 @@
+style = "yas"

Project.toml

@@ -1,7 +1,7 @@
 name = "DataFrameIntervals"
 uuid = "33b79e07-adbe-4034-b8be-6bacde625d75"
 authors = ["Beacon Biosignals, Inc."]
-version = "0.0.1"
+version = "0.0.2"
 
 [deps]
 DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0"

README.md

@@ -7,11 +7,15 @@
 [![Docs: Dev](https://img.shields.io/badge/docs-dev-blue.svg)](https://beacon-biosignals.github.io/DataFrameIntervals.jl/dev)
 
 DataFrameIntervals provides two functions that are handy for computing joins over intervals
-of time: split_into and split_into_combine, and a helper function called `quantile_windows`.
+of time: `interval_join` and `groupby_interval_join`, and a helper function called `quantile_windows`.
 
-Rows match in this join if their time spans overlap. The time spans can be represented as i[`TimeSpan`](https://juliapackages.com/p/timespans) objects or [`Interval`](https://juliapackages.com/p/intervals) objects.
+Rows match in this join if their time spans overlap. The time spans can be represented as
 
-Currently this requires an unreleased version of `Intervals.jl` (which should be version 1.8 when released). Make sure to add the following to your project before adding `DataFrameIntervals`.
+- [`TimeSpan`](https://juliapackages.com/p/timespans) objects 
+- [`Interval`](https://juliapackages.com/p/intervals) objects.
+- `NamedTuples` with a `start` and `stop` field.
+
+Currently this requires an unreleased version of `Intervals.jl` (which should be version 1.8 when released). If you don't use the manifest, make sure to add the following to your project before adding `DataFrameIntervals`.
 
 ```
 julia> ]add https://github.com/invenia/Intervals.jl#rf/intervalset-type
@@ -53,13 +57,13 @@ df = DataFrame(label = rand(('a':'d'), n), x = rand(n), span = spans)
 ```julia
 quarters = quantile_windows(4, df, label=:quarter)
 
-split_into(df, quarters)
+interval_join(df, quarters, on=:span)
 ```
 
 ```
 103×6 DataFrame
- Row │ quarter  label  x          left_span                          right_span                         span
-     │ Int64    Char   Float64    TimeSpan                           TimeSpan                           TimeSpan
+ Row │ quarter  label  x          span_left                          span_right                         span                              
+     │ Int64    Char   Float64    TimeSpan                           TimeSpan                           TimeSpan                          
 ─────┼────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
    1 │       1  b      0.0606309  TimeSpan(00:00:05.164631882, 00:…  TimeSpan(00:00:05.164631882, 00:…  TimeSpan(00:00:05.164631882, 00:…
    2 │       1  a      0.961599   TimeSpan(00:00:08.853504418, 00:…  TimeSpan(00:00:05.164631882, 00:…  TimeSpan(00:00:08.853504418, 00:…

src/DataFrameIntervals.jl

@@ -59,7 +59,8 @@ forright(x::Pair) = last(x)
 
 function setup_column_names!(left, right; on, renamecols=identity => identity,
                              renameon=:_left => :_right)
-    if !(on isa Symbol || on isa AbstractString)
+    if !(on isa Union{Symbol,AbstractString,Pair{Symbol,Symbol},
+                      Pair{<:AbstractString,<:AbstractString}})
         error("Interval joins support only one `on` column; iterables are not allowed.")
     end
 
@@ -335,7 +336,7 @@ function quantile_windows(n, span_; spancol=:span, label=:index, min_duration=no
     df = DataFrame(; (spancol => splits, label_helper(label) => value_helper(label, n))...)
     return df
 end
-function quantile_windows(n, span::DataFrame; spancol=:span, kwds...)
+function quantile_windows(n, span::AbstractDataFrame; spancol=:span, kwds...)
     return quantile_windows(n, dfspan(span, spancol); spancol, kwds...)
 end
 

test/runtests.jl

@@ -20,15 +20,14 @@ Base.isapprox(a::TimePeriod, b::TimePeriod; atol=period) = return abs(a - b) ≤
     df1 = DataFrame(; label=rand(('a':'d'), n), x=rand(n), span=spans)
     quarters = quantile_windows(4, df1; label=:quarter)
     @test nrow(quarters) == 4
-    @test isapprox(duration(quarters.span[1]), duration(quarters.span[2]),
+    @test isapprox(duration(quarters.span[1]), duration(quarters.span[2]);
                    atol=Nanosecond(1))
-    @test isapprox(duration(quarters.span[2]), duration(quarters.span[3]),
+    @test isapprox(duration(quarters.span[2]), duration(quarters.span[3]);
                    atol=Nanosecond(1))
     @test isapprox(duration(quarters.span[2]), duration(quarters.span[3]);
                    atol=Nanosecond(1)) ||
           duration(quarters.span[4]) ≤ duration(quarters.span[3])
-
-    # TODO: test various column renaming bevhariors
+    @test nrow(quantile_windows(4, subset(df1, :label => ByRow(in('a':'b'))))) == 4
 
     # NOTE: the bulk of the correctness testing for interval intersections
     # has already been handled by calling out to `Intervals.find_intervals`
@@ -41,6 +40,21 @@ Base.isapprox(a::TimePeriod, b::TimePeriod; atol=period) = return abs(a - b) ≤
                                        DataFrameIntervals.interval.(df1.span))
     @test df_result.span_left == mapreduce(ix -> df1.span[ix], vcat, ixs)
 
+    # test column renaming
+    rename!(quarters, :span => :time_span)
+    df_result2 = interval_join(df1, quarters; on=:span => :time_span,
+                               renameon=:_a => :_b,
+                               renamecols=:_left => :_right)
+    rename!(quarters, :time_span => :span)
+    @test issetequal(names(df_result2),
+                     ["time_span_b", "quarter_right", "label_left", "x_left", "span_a",
+                      "span"])
+    quarters_2 = insertcols!(copy(quarters), :label => rand('y':'z', 4))
+    df_result3 = interval_join(df1, quarters_2; on=:span, makeunique=true)
+    @test issetequal(names(df_result3),
+                     ["span_right", "quarter", "label", "label_1", "x",
+                      "span_left", "span"])
+
     # test interval joins with named tuples
     nt_spans = [(; start=start(x), stop=stop(x)) for x in spans]
     df1_nt = hcat(df1[!, Not(:span)], DataFrame(; span=nt_spans))