fix some tests

Author: Affie

src/DataBlobs/entities/BlobEntry.jl

@@ -50,7 +50,12 @@ StructUtils.@kwarg struct Blobentry
 end
 version(::Type{Blobentry}) = v"0.1.0"
 
-function Blobentry(label::Symbol, blobstore = :default; metadata, kwargs...)
+function Blobentry(
+    label::Symbol,
+    blobstore = :default;
+    metadata = JSONText("{}"),
+    kwargs...,
+)
     if !(metadata isa JSONText)
         metadata = JSONText(JSON.json(metadata))
     end

src/DistributedFactorGraphs.jl

@@ -331,6 +331,7 @@ export @defStateType #TODO Should this be exported?
 # list of unstable functions not exported any more
 # will move to public or deprecate over time
 const unstable_functions::Vector{Symbol} = [
+    :refStates, #internal maybe make public
     :InMemoryBlobstore,
     :MetadataTypes, #maybe make public after metadata stable
     :getFactorState, # FIXME getFactorState were questioned and being reviewed again for name, other than that they are checked.
@@ -396,7 +397,7 @@ const unstable_functions::Vector{Symbol} = [
     :plotDFG,
     :pack,
     :packDistribution,
-    :packVariable,
+    # :packVariable,
     # :packFactor,
     :packBlob,
     :packState,
@@ -468,7 +469,7 @@ const unstable_functions::Vector{Symbol} = [
     :DFGFactor,
     :PackedFactor,
     :Factor,
-    :AbstractPointParametricEst,
+    # :AbstractPointParametricEst,
     # :MeanMaxPPE,
     # :getPPEMax,
     # :getPPEMean,

src/entities/DFGFactor.jl

@@ -188,22 +188,16 @@ function FactorDFG(
         solvercache = Ref(cache)
     end
 
-    # deprecated in v0.29
+    # TODO v0.29 deprecate ZonedDateTime or convert internally
     if timestamp isa ZonedDateTime
-        Base.depwarn(
-            "`FactorDFG` timestamp as `ZonedDateTime` is deprecated, use `TimeDateZone(timestamp.utc_datetime)` instead",
-            :FactorDFG,
-        )
-        nd_timestamp = TimeDateZone(timestamp.utc_datetime)
-    else
-        nd_timestamp = timestamp
+        timestamp = TimeDateZone(timestamp)
     end
 
     return FactorDFG(
         label,
         tags,
         Tuple(variableorder),
-        nd_timestamp,
+        timestamp,
         Ref(solvable),
         bloblets,
         observation,

src/entities/DFGVariable.jl

@@ -54,15 +54,15 @@ $(TYPEDFIELDS)
     """
     observability::Vector{Float64} = Float64[]#zeros(getDimension(T)) #TODO renamed from infoPerCoord
     """
-    Should this variable solveKey be treated as marginalized in inference computations.
+    Should this state be treated as marginalized in inference computations.
     """
     marginalized::Bool = false #TODO renamed from ismargin 
     # """
     # Should this variable solveKey always be kept fluid and not be automatically marginalized.
     # """
     # dontmargin::Bool = false
     """
-    How many times has a solver updated this variable solveKey estimte.
+    How many times has a solver updated this state estimate.
     """
     solves::Int = 0 # TODO renamed from solvedCount
     # """
@@ -242,6 +242,9 @@ function VariableDFG(
         Base.depwarn("smalldata kwarg is deprecated, use bloblets instead", :VariableDFG)
         #TODO convert smalldata to bloblets
     end
+    if solvable isa Int
+        solvable = Ref(solvable)
+    end
     union!(tags, [:VARIABLE])
 
     N = getDimension(T)
@@ -250,7 +253,12 @@ function VariableDFG(
 end
 
 function VariableDFG(label::Symbol, state::State; kwargs...)
-    return VariableCompute(; label, states = OrderedDict(state.label => state), kwargs...)
+    return VariableDFG(
+        label,
+        getStateType(state);
+        states = OrderedDict(state.label => state),
+        kwargs...,
+    )
 end
 
 # Base.getproperty(x::VariableCompute, f::Symbol) = begin

src/services/AbstractDFG.jl

@@ -756,8 +756,8 @@ end
 Find and return the closest timestamp from two sets of Tuples.  Also return the minimum delta-time (`::Millisecond`) and how many elements match from the two sets are separated by the minimum delta-time.
 """
 function findClosestTimestamp(
-    setA::Vector{Tuple{ZonedDateTime, T}},
-    setB::Vector{Tuple{ZonedDateTime, S}},
+    setA::Vector{Tuple{TimeDateZone, T}},
+    setB::Vector{Tuple{TimeDateZone, S}},
 ) where {S, T}
     #
     # build matrix of delta times, ranges on rows x vars on columns
@@ -798,7 +798,7 @@ ls, listVariables, findClosestTimestamp
 """
 function findVariableNearTimestamp(
     dfg::AbstractDFG,
-    timest::ZonedDateTime,
+    timest::TimeDateZone,#ZonedDateTime,
     regexFilter::Union{Nothing, Regex} = nothing;
     tags::Vector{Symbol} = Symbol[],
     solvable::Int = 0,
@@ -848,7 +848,7 @@ function findVariableNearTimestamp(
 )
     return findVariableNearTimestamp(
         dfg,
-        ZonedDateTime(timest, timezone),
+        TimeDateZone(timest, timezone),
         regexFilter;
         kwargs...,
     )

src/services/CompareUtils.jl

@@ -241,7 +241,7 @@ function compareVariable(
     skiplist = union(
         [
             :attributes;
-            :solverDataDict;
+            :states;
             :createdTimestamp;
             :lastUpdatedTimestamp;
             :timezone;

src/services/CustomPrinting.jl

@@ -74,7 +74,7 @@ function printVariable(
         printstyled(ioc, summary(vert); bold = true, color = :blue)
         println(ioc, "")
 
-        :solver in skipfields && push!(skipfields, :solverDataDict)
+        :solver in skipfields && push!(skipfields, :states)
 
         t = typeof(vert)
         fields = setdiff(fieldnames(t), skipfields)

src/services/DFGVariable.jl

@@ -578,16 +578,10 @@ function copytoState!(
     stateLabel::Symbol,
     state::State,
 )
-    newstate = State(
-        getVariableType(state);
-        (k => deepcopy(getproperty(state, k)) for k in fieldnames(State))...,
-        solveKey = stateLabel,
-    )
+    newstate = State(state; label = stateLabel)
     return mergeState!(dfg, variableLabel, newstate)
 end
 
-#
-
 """
     $(SIGNATURES)
 Delete the variable `State` by label, returns the number of deleted elements.

src/services/Serialization.jl

@@ -178,61 +178,3 @@ function unpackState(d)
         solves = d.solves,
     )
 end
-
-##==============================================================================
-## Variable Packing and unpacking
-##==============================================================================
-
-function packVariable(
-    v::VariableCompute;
-    includeSolveData::Bool = true,
-    includeDataEntries::Bool = true,
-)
-    return (
-        id = v.id,
-        label = v.label,
-        timestamp = v.timestamp,
-        nstime = string(v.nstime.value),
-        tags = collect(v.tags), # Symbol.()
-        solverData = packState.(collect(values(v.states))),
-        metadata = base64encode(JSON.json(v.smallData)),
-        solvable = getSolvable(v),
-        variableType = stringVariableType(DFG.getVariableType(v)),
-        blobEntries = collect(values(v.blobentries)),
-        _version = _getDFGVersion(),
-    )
-end
-
-function unpackVariable(variable; skipVersionCheck::Bool = false)
-    !skipVersionCheck && _versionCheck(variable)
-
-    # Variable and point type
-    variableType = parseVariableType(variable.variableType)
-    isnothing(variableType) && error(
-        "Cannot deserialize variableType '$(variable.variableType)' in variable '$(variable.label)'",
-    )
-    pointType = DFG.getPointType(variableType)
-
-    N = getDimension(variableType)
-    solverDict = Dict{Symbol, State{variableType, pointType, N}}(
-        map(sd -> sd.label, variable.solverData) .=>
-            map(sd -> DFG.unpackState(sd), variable.solverData),
-    )
-    dataDict = Dict{Symbol, Blobentry}(
-        map(de -> de.label, variable.blobEntries) .=> variable.blobEntries,
-    )
-    metadata = JSON.parse(base64decode(variable.metadata), Dict{Symbol, DFG.MetadataTypes})
-
-    return VariableCompute(
-        variable.label,
-        variableType;
-        id = variable.id,
-        timestamp = variable.timestamp,
-        nstime = Nanosecond(variable.nstime),
-        tags = Set(variable.tags),
-        solverDataDict = solverDict,
-        smallData = metadata,
-        dataDict = dataDict,
-        solvable = variable.solvable,
-    )
-end

test/interfaceTests.jl

@@ -22,6 +22,9 @@ if false
     global_logger(logger)
 end
 
+# DFG.@usingDFG true
+# include("testBlocks.jl")
+
 # DFG Accessors
 @testset "DFG Structure and Accessors" begin
     # Constructors
@@ -64,13 +67,13 @@ end
     @test printVariable(iobuf, var1; skipfields = [:timestamp, :solver, :ppe, :nstime]) ===
           nothing
 
-    @test String(take!(iobuf)) ==
-          "VariableCompute{TestVariableType1, Vector{Float64}, 1}\nid:\nnothing\nlabel:\n:a\ntags:\nSet([:VARIABLE, :POSE])\nsmallData:\nDict{Symbol, Union{Bool, Float64, Int64, Vector{Bool}, Vector{Float64}, Vector{Int64}, Vector{String}, String}}()\ndataDict:\nDict{Symbol, Blobentry}()\nsolvable:\nRefValue{Int64}(0)\n"
-    # "VariableCompute{TestVariableType1, Vector{Float64}, 1}\nid:\nnothing\nlabel:\n:a\ntags:\nSet([:VARIABLE, :POSE])\nsmallData:\nDict{Symbol, Union{Bool, Float64, Int64, Vector{Bool}, Vector{Float64}, Vector{Int64}, Vector{String}, String}}(:small=>\"data\")\ndataDict:\nDict{Symbol, Blobentry}()\nsolvable:\n0\n"
+    varstr = String(take!(iobuf))
+    @test occursin(r"VariableDFG", varstr)
+    @test occursin(r"label", varstr)
 
     @test printVariable(iobuf, var1; short = true) === nothing
     varstr = String(take!(iobuf))
-    @test occursin(r"VariableCompute", varstr)
+    @test occursin(r"VariableDFG", varstr)
     @test occursin(r"timestamp", varstr)
     @test occursin(r"label", varstr)
     @test occursin(r"bandwidths", varstr)