Update deprecated functions

Author: Affie

src/DataBlobs/services/BlobEntry.jl

@@ -306,7 +306,7 @@ function gatherBlobentries(
         labelFilter = variableLabelFilter,
     )
     return map(vls) do vl
-        return vl => getBlobentries(dfg, vl; labelFilter, blobIdFilter)
+        return vl => getVariableBlobentries(dfg, vl; labelFilter, blobIdFilter)
     end
 end
 const collectBlobentries = gatherBlobentries

src/DataBlobs/services/BlobWrappers.jl

@@ -70,7 +70,7 @@ function loadBlob_Variable(
     # hashfunction = sha256,
     # checkhash::Bool = true,
 )
-    entry = getBlobentry(dfg, variable_label, entry_label)
+    entry = getVariableBlobentry(dfg, variable_label, entry_label)
     blob = getBlob(dfg, entry)
     # checkhash && assertHash(de, db; hashfunction)
     return entry, blob
@@ -82,7 +82,7 @@ function saveBlob_Variable!(
     blob::Vector{UInt8},
     entry::Blobentry,
 )
-    addBlobentry!(dfg, variable_label, entry)
+    addVariableBlobentry!(dfg, variable_label, entry)
     addBlob!(dfg, entry, blob)
     return entry
 end
@@ -100,8 +100,8 @@ function saveBlob_Variable!(
 end
 
 function deleteBlob_Variable!(dfg::AbstractDFG, variable_label::Symbol, entry_label::Symbol)
-    entry = getBlobentry(dfg, variable_label, entry_label)
-    deleteBlobentry!(dfg, variable_label, entry_label)
+    entry = getVariableBlobentry(dfg, variable_label, entry_label)
+    deleteVariableBlobentry!(dfg, variable_label, entry_label)
     deleteBlob!(dfg, entry)
     return 2
 end

src/DistributedFactorGraphs.jl

@@ -451,13 +451,13 @@ const unstable_functions::Vector{Symbol} = [
     :getVariableTypeName,
     :getStateKind,
     :setTimestamp,
-    :setMetadata!, # no set, use add merge
     :setAgentMetadata!,
     :setGraphMetadata!,
     # :getSolverDataDict,# obsolete
     :getAddHistory,
 
     #Deprecated in v0.28
+    :setMetadata!, # no set, use add merge
     :AbstractRelativeMinimize,
     :AbstractManifoldMinimize,
     :AbstractPrior,

src/FileDFG/services/FileDFG.jl

@@ -39,18 +39,18 @@ function saveDFG(folder::AbstractString, dfg::AbstractDFG)
     map(f -> rm("$varFolder/$f"), readdir(varFolder))
     map(f -> rm("$factorFolder/$f"), readdir(factorFolder))
     # Variables
-    @showprogress "saving variables" for v in variables
+    @showprogress desc = "saving variables" for v in variables
         # vPacked = packVariable(v)
         JSON.json("$varFolder/$(v.label).json", v; style = DFGJSONStyle())
     end
     # Factors
-    @showprogress "saving factors" for f in factors
+    @showprogress desc = "saving factors" for f in factors
         JSON.json("$factorFolder/$(f.label).json", f; style = DFGJSONStyle())
     end
 
     #GraphsDFG nodes
     @assert isa(dfg, GraphsDFG) "only metadata for GraphsDFG are supported"
-    p = Progress(4, "Saving DFG Nodes")
+    p = Progress(4; desc = "Saving DFG Nodes")
     JSON.json("$savepath/graphroot.json", dfg.graph; style = DFGJSONStyle())
     next!(p)
     JSON.json("$savepath/agent.json", dfg.agent; style = DFGJSONStyle())
@@ -119,7 +119,7 @@ function loadDFG!(
     variablefiles = readdir(joinpath(loaddir, "variables"); sort = false, join = true)
 
     # type instability on `variables` as either `::Vector{Variable}` or `::Vector{VariableCompute{<:}}` (vector of abstract)
-    variables = @showprogress 1 "loading variables" asyncmap(variablefiles) do file
+    variables = @showprogress dt=1 desc = "loading variables" asyncmap(variablefiles) do file
         v = JSON.parsefile(file, V; style = DFGJSONStyle())
         return addVariable!(dfgLoadInto, v)
     end
@@ -128,7 +128,7 @@ function loadDFG!(
 
     factorfiles = readdir(joinpath(loaddir, "factors"); sort = false, join = true)
 
-    factors = @showprogress 1 "loading factors" asyncmap(factorfiles) do file
+    factors = @showprogress dt=1 desc = "loading factors" asyncmap(factorfiles) do file
         f = JSON.parsefile(file, F; style = DFGJSONStyle())
         return addFactor!(dfgLoadInto, f)
     end
@@ -137,7 +137,7 @@ function loadDFG!(
 
     if isa(dfgLoadInto, GraphsDFG) && getTypeDFGFactors(dfgLoadInto) <: FactorDFG
         # Finally, rebuild the CCW's for the factors to completely reinflate them
-        @showprogress 1 "Rebuilding factor solver cache" for factor in factors
+        @showprogress dt=1 desc = "Rebuilding factor solver cache" for factor in factors
             rebuildFactorCache!(dfgLoadInto, factor)
         end
     end
@@ -170,7 +170,7 @@ function loadDFG(file::AbstractString)
     loaddir = Tar.extract(hdr -> contains(hdr.path, dfgnodenames), tar)
     close(tar)
 
-    progess = Progress(4, "Loading DFG Nodes")
+    progess = Progress(4; desc="Loading DFG Nodes")
     agent = JSON.parsefile(joinpath(loaddir, "agent.json"), Agent; style = DFGJSONStyle())
     next!(progess)
     graph = JSON.parsefile(

src/GraphsDFG/services/GraphsDFG.jl

@@ -326,8 +326,9 @@ function listNeighbors(
     dfg::GraphsDFG,
     node::AbstractGraphNode;
     solvable::Union{Nothing, Int} = nothing,
+    kwargs...,
 )
-    return listNeighbors(dfg, node.label; solvable)
+    return listNeighbors(dfg, node.label; solvable, kwargs...)
 end
 
 function listNeighbors(
@@ -402,8 +403,9 @@ end
 function getBiadjacencyMatrix(
     dfg::GraphsDFG;
     solvable::Union{Nothing, Int} = nothing,
-    varLabels = listVariables(dfg; solvable),
-    factLabels = listFactors(dfg; solvable),
+    solvableFilter = isnothing(solvable) ? nothing : >=(solvable),
+    varLabels = listVariables(dfg; solvableFilter),
+    factLabels = listFactors(dfg; solvableFilter),
 )
     varIndex = [dfg.g.labels[s] for s in varLabels]
     factIndex = [dfg.g.labels[s] for s in factLabels]

src/services/AbstractDFG.jl

@@ -358,10 +358,10 @@ function getVariable(dfg::AbstractDFG, label::Symbol, solveKey::Symbol)
     # function getVariable(dfg::AbstractDFG, label::Symbol; stateLabelFilter::Union{Nothing, ...} = nothing) 
     var = getVariable(dfg, label)
 
-    if isa(var, VariableCompute) && !haskey(var.states, solveKey)
+    if isa(var, VariableDFG) && !haskey(var.states, solveKey)
         throw(LabelNotFoundError("VariableNode", solveKey))
-    elseif !isa(var, VariableCompute)
-        @warn "getVariable(dfg, label, solveKey) only supported for type VariableCompute."
+    elseif !isa(var, VariableDFG)
+        @warn "getVariable(dfg, label, solveKey) only supported for type VariableDFG."
     end
 
     return var
@@ -549,9 +549,8 @@ function deepcopyGraph(
     graphLabel::Symbol = Symbol(getGraphLabel(sourceDFG), "_cp_$(string(uuid4())[1:6])"),
     kwargs...,
 ) where {T <: AbstractDFG}
-    ginfo = getDFGInfo(sourceDFG)
 
-    destDFG = T(; ginfo..., graphLabel)
+    destDFG = T(; graph=sourceDFG.graph, agent=sourceDFG.agent, graphLabel)
     copyGraph!(
         destDFG,
         sourceDFG,

src/services/CommonAccessors.jl

@@ -48,7 +48,7 @@ Variables or factors may or may not be 'solvable', depending on a user definitio
 Related:
 - isSolveInProgress
 """
-getSolvable(node::Union{VariableDFG, FactorDFG}) = node.solvable[]
+getSolvable(node::Union{VariableDFG, VariableSummary, FactorDFG, FactorSummary}) = node.solvable[]
 
 """
     $SIGNATURES

src/services/CompareUtils.jl

@@ -321,40 +321,40 @@ function compareFactor(
         )
     @debug "compareFactor 3/5" TP
 
-    #FIXME is measurement stil in use and should it be checked, skipping for now
-    if false # !(:measurement in skip)
+    #FIXME is measurement stil in use
+    if !(:measurement in skip)
         TP =
             TP & (
                 skipsamples || compareAll(
-                    getSolverData(A).fnc.measurement,
-                    getSolverData(B).fnc.measurement;
+                    getCache(A).measurement,
+                    getCache(B).measurement;
                     show = show,
                     skip = skip,
                 )
             )
     end
     @debug "compareFactor 4/5" TP
     #FIXME is varValsAll stil in use and should it be checked, skipping for now
-    if false #!(:varValsAll in skip) && hasfield(typeof(getSolverData(A).fnc), :varValsAll)
+    if !(:varValsAll in skip) && hasfield(typeof(getCache(A)), :varValsAll)
         TP =
             TP & (
                 skipcompute || compareAll(
-                    getSolverData(A).fnc.varValsAll,
-                    getSolverData(B).fnc.varValsAll;
+                    getCache(A).varValsAll,
+                    getCache(B).varValsAll;
                     show = show,
                     skip = skip,
                 )
             )
     end
     @debug "compareFactor 5/5" TP
-    #FIXME is varidx stil in use and should it be checked, skipping for now
-    if false #!(:varidx in skip) && hasfield(typeof(getSolverData(A).fnc), :varidx) &&
-        getSolverData(A).fnc.varidx isa Base.RefValue
+    #FIXME is varidx stil in use and should it be checked
+    if !(:varidx in skip) && hasfield(typeof(getCache(A)), :varidx) &&
+        getCache(A).varidx isa Base.RefValue
         TP =
             TP & (
                 skipcompute || compareAll(
-                    getSolverData(A).fnc.varidx[],
-                    getSolverData(B).fnc.varidx[];
+                    getCache(A).varidx[],
+                    getCache(B).varidx[];
                     show = show,
                     skip = skip,
                 )

src/services/find.jl

@@ -61,7 +61,7 @@ function findVariableNearTimestamp(
     #
     # get the variable labels based on filters
     # syms = listVariables(dfg, regexFilter, tags=tags, solvable=solvable)
-    syms = listVariables(dfg, regexFilter; tags = tags, solvable = solvable)
+    syms = listVariables(dfg, regexFilter; tags = tags, solvableFilter = >=(solvable))
     # compile timestamps with label
     # vars = map( x->getVariable(dfg, x), syms )
     timeset = map(x -> (getTimestamp(getVariable(dfg, x)), x), syms)

test/iifCompareTests.jl

@@ -75,7 +75,7 @@ using Test
         skip = [:fullvariables],
     )
 
-    @test_broken !compareSimilarFactors(fg, fg2; skipsamples = true, skipcompute = false)
+    @test !compareSimilarFactors(fg, fg2; skipsamples = true, skipcompute = false)
 
     @test compareFactorGraphs(
         fg,