feat: relax metadata type for JSON 1.0 (#13)

Author: Beforerr

.github/workflows/CI.yml

@@ -23,8 +23,7 @@ jobs:
       fail-fast: false
       matrix:
         version:
-          - '1.10'
-          - '1.11'
+          - '1'
           - 'pre'
         os:
           - ubuntu-latest

.github/workflows/TagBot.yml

@@ -6,20 +6,8 @@ on:
   workflow_dispatch:
     inputs:
       lookback:
+        description: "Number of days to look back for new releases"
         default: "3"
-permissions:
-  actions: read
-  checks: read
-  contents: write
-  deployments: read
-  issues: read
-  discussions: read
-  packages: read
-  pages: read
-  pull-requests: read
-  repository-projects: read
-  security-events: read
-  statuses: read
 jobs:
   TagBot:
     if: github.event_name == 'workflow_dispatch' || github.actor == 'JuliaTagBot'

Project.toml

@@ -23,8 +23,8 @@ CSV = "0.10"
 Dates = "1"
 DimensionalData = "0.29"
 HTTP = "1"
-JSON = "0.21"
+JSON = "0.21, 1"
 SpaceDataModel = "0.1.7, 0.2"
 Tables = "1"
-Unitful = "1.22.0"
+Unitful = "1"
 julia = "1.10"

src/HAPIClient.jl

@@ -1,9 +1,10 @@
 module HAPIClient
 
 using HTTP
-using JSON
+using HTTP: request_uri, URI
+import JSON
 using Dates
-using CSV
+import CSV
 using Tables
 using Unitful
 using SpaceDataModel: AbstractDataVariable, parse_datetime
@@ -14,6 +15,8 @@ import SpaceDataModel: times
 export hapi, get_data, meta, times
 export HAPIVariable, HAPIVariables
 
+json_parse(x) = JSON.parse(String(x))
+
 include("server.jl")
 include("metadata.jl")
 include("data.jl")

src/data.jl

@@ -22,31 +22,23 @@ function get_data(server, dataset, parameters, tmin, tmax; format = format(serve
         "time.max" => tmax,
         "format" => format
     )
-    uri = HTTP.request_uri(url, query)
+    uri = request_uri(url, query)
     verbose > 0 && @info "Getting data from $uri"
     response = HTTP.get(uri; verbose, kw...)
 
     data = if format == "csv"
         CSV.File(response.body; header = false, dateformat = DEFAULT_DATE_FORMAT)
     elseif format == "json"
-        JSON.parse(String(response.body))
+        json_parse(response.body)
     elseif format == "binary"
         error("Binary format not yet implemented")
     else
         throw("Unsupported format: $format")
     end
     meta = get_parameters(server, dataset, parameters)
-    meta["uri"] = uri
     params = meta["parameters"]
-    n = length(params) - 1
-    verbose > 0 && @info "Got $n parameters"
-    return HAPIVariables(data, params, meta, server, dataset)
-end
-
-_merge_meta!(x, meta) = begin
-    merge!(x.meta, meta)
-    delete!(x.meta, "parameters")
-    return x
+    verbose > 0 && @info "Got $(length(params) - 1) parameters"
+    return HAPIVariables(data, params, meta, server, dataset, uri)
 end
 
 """

src/metadata.jl

@@ -22,7 +22,7 @@ function check_status_code(i)
     end
 end
 
-check_status_code(response::Dict) = check_status_code(response["status"]["code"])
+check_status_code(response::AbstractDict) = check_status_code(response["status"]["code"])
 
 """
     get_catalog(server)
@@ -33,34 +33,33 @@ HAPI info response JSON structure: https://github.com/hapi-server/data-specifica
 """
 function get_catalog(server)
     response = HTTP.get(url(server, "catalog"))
-    response_dict = JSON.parse(String(response.body))
+    response_dict = json_parse(response.body)
     if check_status_code(response_dict)
         return response_dict["catalog"]
     end
 end
 
 """
-    get_parameters(server, dataset)
+    get_parameters(server, id)
 
-Get a dictionary containing the HAPI info metadata for all parameters in the `dataset`.
+Get a dictionary containing the HAPI info metadata for all parameters in the `id` dataset.
 Returns a tuple of (info, parameters) where info is the full response and parameters is
 a Vector of Parameter objects.
 
 HAPI info response JSON structure: https://github.com/hapi-server/data-specification/blob/master/hapi-dev/HAPI-data-access-spec-dev.md#36-info
 """
-function get_parameters(server, dataset)
-    query = Dict("id" => dataset)
-    response = HTTP.get(url(server, "info"); query)
-    return JSON.parse(String(response.body))
+function get_parameters(server, id)
+    response = HTTP.get(url(server, "info"); query = (; id))
+    return json_parse(response.body)
 end
 
 """
-    get_parameters(server, dataset, parameters)
+    get_parameters(server, id, parameters)
 
 Get a dictionary containing the HAPI info metadata for each parameter in the comma-separated string `parameters`.
 """
-function get_parameters(server, dataset, parameters)
-    query = Dict("id" => dataset, "parameters" => parameters)
+function get_parameters(server, id, parameters)
+    query = (; id, parameters)
     response = HTTP.get(url(server, "info"); query)
-    return JSON.parse(String(response.body))
+    return json_parse(response.body)
 end

src/server.jl

@@ -39,7 +39,7 @@ Get server capabilities.
 """
 function get_capabilities(server)
     response = HTTP.get(url(server, "capabilities"))
-    return JSON.parse(String(response.body))
+    return json_parse(response.body)
 end
 
 """
@@ -51,7 +51,7 @@ function load_servers_from_json(; url=DEFAULT_SERVERS_JSON_URL, register=false)
     # Fetch the JSON data: try to load from URL first, fall back to file if HTTP fails
     servers_data = try
         response = HTTP.get(url)
-        JSON.parse(String(response.body))
+        json_parse(response.body)
     catch
         @warn "HTTP request failed, falling back to local file"
         JSON.parsefile(joinpath(@__DIR__, "abouts.json"))

src/specs/parameter.jl

@@ -39,7 +39,7 @@ struct Parameter
     vectorComponents::Union{String,Vector{String},Nothing}
     bins::Union{Vector{Dict{String,Any}},Nothing}
 
-    function Parameter(dict::Dict{String,Any})
+    function Parameter(dict::AbstractDict)
         # Validate required fields
         name = get(dict, "name") do
             throw(ArgumentError("Parameter missing required field 'name'"))
@@ -101,7 +101,7 @@ struct Parameter
 end
 
 # Constructor from JSON-like dictionary
-Base.convert(::Type{Parameter}, dict::Dict{String,Any}) = Parameter(dict)
+Base.convert(::Type{Parameter}, dict::AbstractDict{String,Any}) = Parameter(dict)
 
 """
     is_time_parameter(param::Parameter)

src/types.jl

@@ -1,4 +1,3 @@
-
 """
 An array-like object that represents a HAPI variable.
 
@@ -8,27 +7,35 @@ An array-like object that represents a HAPI variable.
 - `time`: The time axis (use `times(x)` to access).
 - `meta`: The metadata (use `meta(x)` to access).
 """
-struct HAPIVariable{T, N, A <: AbstractArray{T, N}, Tt <: AbstractVector} <: AbstractDataVariable{T, N}
+struct HAPIVariable{T, N, A <: AbstractArray{T, N}, Tt <: AbstractVector, M <: AbstractDict} <: AbstractDataVariable{T, N}
     data::A
     time::Tt
-    meta::Dict
+    meta::M
 end
 
 """
 A thin wrapper over NamedTuple for HAPI variables that shares the same time axis.
 """
-struct HAPIVariables{NT <: NamedTuple, D <: Dict, S, DS}
+struct HAPIVariables{NT <: NamedTuple, D <: AbstractDict, S, DS}
     nt::NT
     meta::D
     server::S
     dataset::DS
+    uri::URI
 end
 
 @inline Base.parent(x::HAPIVariables) = getfield(x, :nt)
 times(x::HAPIVariables) = times(first(parent(x)))
 server(x::HAPIVariables) = getfield(x, :server)
 dataset(x::HAPIVariables) = getfield(x, :dataset)
-id(x::HAPIVariables) = id(server(x)) * "/" * dataset(x)
+function id(x::HAPIVariables)
+    s = server(x)
+    if s isa Server
+        return id(s) * "/" * dataset(x)
+    else
+        return s * "/info?id=" * dataset(x)
+    end
+end
 Base.propertynames(x::HAPIVariables) = propertynames(parent(x))
 Base.getproperty(x::HAPIVariables, s::Symbol) = getproperty(parent(x), s)
 Base.length(x::HAPIVariables) = length(parent(x))
@@ -38,12 +45,13 @@ Base.getindex(x::HAPIVariables, i) = getindex(parent(x), i)
 Base.show(io::IO, x::HAPIVariables) = show(io, parent(x))
 function Base.show(io::IO, m::MIME"text/plain", var::HAPIVariables)
     print(io, "HAPIVariables: ")
-    printstyled(io, id(var), color=209)
+    printstyled(io, id(var), color = 209)
+    print(io, " (", getfield(var, :uri), ")")
     foreach(var) do v
         print(io, "\n  ")
         show(io, v)
     end
-    if (mt = meta(var)) !== nothing
+    return if (mt = meta(var)) !== nothing
         print(io, "\nMetadata - ")
         show(io, m, mt)
     end
@@ -96,15 +104,15 @@ end
 
 Construct a `HAPIVariable` object from a JSON-parsed Dict `d` (containing parameters) at index `i`.
 """
-function HAPIVariable(d::Dict, i::Integer)
+function HAPIVariable(d::AbstractDict, i::Integer)
     data = d["data"]
     param = d["parameters"][i + 1]
     time = @. DateTime(getindex(data, 1), DEFAULT_DATE_FORMAT)
     values = getindex.(data, i + 1)
     return HAPIVariable(values, time, param)
 end
 
-HAPIVariable(d::Dict, meta, i::Integer) = HAPIVariable(d, i)
+HAPIVariable(d::AbstractDict, meta, i::Integer) = HAPIVariable(d, i)
 
 columns(var::HAPIVariable) = meta(var)["columns"]
 colsize(var::HAPIVariable) = colsize(meta(var))

test/data.jl

@@ -22,7 +22,8 @@ end
     tmin = "1970-01-01T00:00:00"
     tmax = "1970-01-01T00:00:10"
 
-    @test_nowarn hapi(server, dataset, parameters, tmin, tmax)
+    vars = hapi(server, dataset, parameters, tmin, tmax)
+    display(vars)
 end
 
 @testitem "TestData2.1" begin