Make output Tables.jl-compatible

[pdeffebach]

This is almost a dupe of the PR here but I think it deserves it's own issue.

The type of output that alphavantage gives is currently kind of awkward: A Matrix of type Any and a one-row Matrix of names.

Kind of similarly, in the readme you write data = DataFrame(spy[1]);. Assuming spy[1] is a Matrix, is deprecated in DataFrames and will error in post-1.0 DataFrames.

It shouldn't be too hard to implement a very basic Tables.jl compatible output so people can easily call DataFrame or TimeArray or whatever else they prefer to work with.

[pdeffebach]

Here is a small implementation based on a DataFrame

julia> begin 
           struct MyTable
               data::Vector{AbstractVector}
               names::Vector{String}
               
               MyTable(data::Vector{AbstractVector}, names::Vector{String}) = begin 
                   l1 = length(data[1])
                   @assert all(t -> length(t) == l1, data)
                   @assert length(data) == length(names)
                   new(data, names)
               end
           end
           MyTable(data::Vector{Vector{T}} where T, names::Vector{String}) = begin 
               MyTable(AbstractVector[d for d in data], names)
           end
           MyTable(data::Matrix{T} where T, names::Matrix{String}) = begin 
               v = AbstractVector[c for c in eachcol(data)]
               @show typeof(v)
               n = vec(names)
               MyTable(v, n)
           end
       end;

julia> begin
           import Tables
           Tables.istable(::MyTable) = true
           Tables.rowaccess(::MyTable) = false
           Tables.columnaccess(::MyTable) = true
           Tables.columns(t::MyTable) = t
           Tables.getcolumn(t::MyTable, i::Int) = t.data[i]
           Tables.getcolumn(t::MyTable, nm::Symbol) = begin 
               ind = findfirst(==(nm), Symbol.(t.names))
               t.data[ind]
           end
           Tables.columnnames(t::MyTable) = Symbol.(t.names)
       end;

julia> using DataFrames;

julia> t = MyTable(rand(2,2), ["a" "b"])
typeof(v) = Vector{AbstractVector{T} where T}
MyTable(AbstractVector{T} where T[[0.12988099768593808, 0.7023047863467995], [0.617259710696815, 0.9205761607605008]], ["a", "b"])

julia> DataFrame(t)
2×2 DataFrame
 Row │ a         b        
     │ Float64   Float64  
─────┼────────────────────
   1 │ 0.129881  0.61726
   2 │ 0.702305  0.920576

[ellisvalentiner]

@pdeffebach Thanks for the detailed issue. I'll try to solve this with #6 and #9

[pdeffebach]

With regards to #9, you can be agnostic about the table type of output if you implement your own super minimal wrapper type.

I would just make a very minimal type and then not add any unecessary dependencies, like TimeArray. Leave the conversion to a "real" table up to the user.

[ellisvalentiner]

@pdeffebach would you try the v0.4.0 branch and let me know if it works for you?

[FuZhiyu]

@ellisvalentiner It seems in v0.4.0 the type is not recognized at all so all columns are Any[], which I guess won't be efficient?

Btw there is a typo in the readme in v0.4.0, it was misspelled as AlphaVanatage.

[pdeffebach]

Sorry I will get to this soon!

[pdeffebach]

Hey sorry for not getting to this faster, but this works great!

The only problem at the moment is that it gives vectors of eltype Any. Now that I've deved it I can try a PR to fix that.