More filter standardization and cleanup

Author: Affie

src/Deprecated.jl

@@ -55,69 +55,31 @@ function mergeGraphVariableData!(args...)
     )
 end
 
-#NOTE List types funcction do not fit verb noun and will be deprecated.
-# should return types
-
 # """
-#     $SIGNATURES
+#     $(SIGNATURES)
+# Gives back all factor labels that fit the bill:
+#     lsWho(dfg, :Pose3)
 
-# Return `Vector{Symbol}` of all unique variable types in factor graph.
-# """
-function lsTypes(dfg::AbstractDFG)
-    vars = getVariables(dfg)
-    alltypes = Set{Symbol}()
-    for v in vars
-        varType = Symbol(typeof(getVariableType(v)))
-        push!(alltypes, varType)
-    end
-    return collect(alltypes)
-end
+# Notes
+# - Returns `Vector{Symbol}`
 
-# """
-#     $SIGNATURES
+# Dev Notes
+# - Cloud versions will benefit from less data transfer
+#  - `ls(dfg::C, ::T) where {C <: CloudDFG, T <: ..}`
+
+# Related
 
-# Return `::Dict{Symbol, Vector{Symbol}}` of all unique variable types with labels in a factor graph.
+# ls, lsf, lsfPriors
 # """
-function lsTypesDict(dfg::AbstractDFG)
+function lsWho(dfg::AbstractDFG, type::Symbol)
+    Base.depwarn("lsWho(dfg, type) is deprecated, use ls(dfg, type) instead.", :lsWho)
     vars = getVariables(dfg)
-    alltypes = Dict{Symbol, Vector{Symbol}}()
+    labels = Symbol[]
     for v in vars
-        varType = Symbol(typeof(getVariableType(v)))
-        d = get!(alltypes, varType, Symbol[])
-        push!(d, v.label)
-    end
-    return alltypes
-end
-
-# """
-#     $SIGNATURES
-
-# Return `Vector{Symbol}` of all unique factor types in factor graph.
-# """
-function lsfTypes(dfg::AbstractDFG)
-    facs = getFactors(dfg)
-    alltypes = Set{Symbol}()
-    for f in facs
-        facType = typeof(getFactorType(f)) |> nameof
-        push!(alltypes, facType)
-    end
-    return collect(alltypes)
-end
-
-# """
-#     $SIGNATURES
-
-# Return `::Dict{Symbol, Vector{Symbol}}` of all unique factors types with labels in a factor graph.
-# """
-function lsfTypesDict(dfg::AbstractDFG)
-    facs = getFactors(dfg)
-    alltypes = Dict{Symbol, Vector{Symbol}}()
-    for f in facs
-        facType = typeof(getFactorType(f)) |> nameof
-        d = get!(alltypes, facType, Symbol[])
-        push!(d, f.label)
+        varType = typeof(getVariableType(v)) |> nameof
+        varType == type && push!(labels, v.label)
     end
-    return alltypes
+    return labels
 end
 
 # solvekey is deprecated and sync!/copyto! is the better verb.
@@ -175,6 +137,67 @@ end
 export DFGVariable
 const DFGVariable = VariableCompute
 
+export listSolveKeys, listSupersolves
+# """
+#     $TYPEDSIGNATURES
+# List all the solvekeys used amongst all variables in the distributed factor graph object.
+
+# Related
+
+# [`listSolveKeys`](@ref), [`getSolverDataDict`](@ref), [`listVariables`](@ref)
+# """
+function listSolveKeys(
+    variable::VariableCompute,
+    filterSolveKeys::Union{Regex, Nothing} = nothing,
+    skeys = Set{Symbol}(),
+)
+    Base.depwarn(
+        "listSolveKeys is deprecated, use listVariableStates instead.",
+        :listSolveKeys,
+    )
+    #
+    for ky in keys(getSolverDataDict(variable))
+        push!(skeys, ky)
+    end
+
+    #filter the solveKey set with filterSolveKeys regex
+    !isnothing(filterSolveKeys) &&
+        return filter!(k -> occursin(filterSolveKeys, string(k)), skeys)
+    return skeys
+end
+
+function listSolveKeys(
+    dfg::AbstractDFG,
+    lbl::Symbol,
+    filterSolveKeys::Union{Regex, Nothing} = nothing,
+    skeys = Set{Symbol}(),
+)
+    return listSolveKeys(getVariable(dfg, lbl), filterSolveKeys, skeys)
+end
+#
+
+function listSolveKeys(
+    dfg::AbstractDFG,
+    filterVariables::Union{Type{<:VariableStateType}, Regex, Nothing} = nothing;
+    filterSolveKeys::Union{Regex, Nothing} = nothing,
+    tags::Vector{Symbol} = Symbol[],
+    solvable::Int = 0,
+)
+    #
+    skeys = Set{Symbol}()
+    varList = listVariables(dfg, filterVariables; tags = tags, solvable = solvable)
+    for vs in varList  #, ky in keys(getSolverDataDict(getVariable(dfg, vs)))
+        listSolveKeys(dfg, vs, filterSolveKeys, skeys)
+    end
+
+    # done inside the loop
+    # #filter the solveKey set with filterSolveKeys regex
+    # !isnothing(filterSolveKeys) && return filter!(k -> occursin(filterSolveKeys, string(k)), skeys)
+
+    return skeys
+end
+const listSupersolves = listSolveKeys
+
 ## ================================================================================
 ## Deprecated in v0.27
 ##=================================================================================

src/DistributedFactorGraphs.jl

@@ -49,8 +49,6 @@ using RecursiveArrayTools: ArrayPartition
 export ArrayPartition
 using StaticArrays
 
-import Base: getindex
-
 using InteractiveUtils: subtypes
 
 ##==============================================================================
@@ -198,8 +196,6 @@ export exists,
     deleteFactor!,
     listVariables,
     listFactors,
-    listSolveKeys,
-    listSupersolves,
     getVariables,
     getFactors,
     isVariable,
@@ -341,7 +337,6 @@ export natural_lt, sortDFG
 
 ## List
 export ls, lsf, ls2
-export lsWho
 export isPrior, lsfPriors
 export hasTags, hasTagsNeighbors
 
@@ -355,7 +350,8 @@ export @defVariable
 
 # File import and export
 export saveDFG, loadDFG!, loadDFG
-export toDot, toDotFile
+
+# export toDot, toDotFile
 
 # shortest path
 export findShortestPathDijkstra

src/GraphsDFG/FactorGraphs/BiMaps.jl

@@ -1,4 +1,3 @@
-# import Base: getindex, setindex!, firstindex, lastindex, iterate, keys, isempty
 struct BiDictMap{T <: Integer}
     int_sym::Dict{T, Symbol}
     sym_int::Dict{Symbol, T}

src/GraphsDFG/FactorGraphs/FactorGraphs.jl

@@ -3,9 +3,7 @@ using Graphs
 
 using OrderedCollections
 
-import Base: eltype, show, ==, Pair, Tuple, copy, length, size, issubset, zero, getindex
-# import Random:
-#     randstring, seed!
+import Base
 
 import Graphs:
     AbstractGraph,
@@ -39,15 +37,7 @@ import Graphs.SimpleGraphs:
     AbstractSimpleGraph, SimpleGraph, SimpleDiGraph, SimpleEdge, fadj, badj
 
 export FactorGraph
-# addVariable!,
-# addFactor!,
-# GraphsBayesGraph,
-# filter_edges,
-# filter_vertices,
-# reverse
-
-# import DistributedFactorGraphs: AbstractGraphNode
-# const AbstractNodeType = AbstractGraphNode
+
 using DistributedFactorGraphs: AbstractGraphNode
 import DistributedFactorGraphs: AbstractGraphVariable, AbstractGraphFactor
 const AbstractVariableType = AbstractGraphVariable
@@ -83,15 +73,15 @@ end
 FactorGraph() = FactorGraph{Int, AbstractVariableType, AbstractFactorType}()
 # FactorGraph{V,F}() where {V <: AbstractVariableType, F <: AbstractFactorType} = FactorGraph{Int, V, F}()
 
-function show(io::IO, ::MIME"text/plain", g::FactorGraph)
+function Base.show(io::IO, ::MIME"text/plain", g::FactorGraph)
     dir = is_directed(g) ? "directed" : "undirected"
     return print(io, "{$(nv(g)), $(ne(g))} $dir $(eltype(g)) $(typeof(g))")
 end
 
 @inline fadj(g::FactorGraph, x...) = fadj(g.graph, x...)
 @inline badj(g::FactorGraph, x...) = badj(g.graph, x...)
 
-eltype(g::FactorGraph) = eltype(g.graph)
+Base.eltype(g::FactorGraph) = eltype(g.graph)
 edgetype(g::FactorGraph) = edgetype(g.graph)
 nv(g::FactorGraph) = nv(g.graph)
 vertices(g::FactorGraph) = vertices(g.graph)
@@ -109,7 +99,7 @@ is_directed(::Type{FactorGraph}) = false
 is_directed(::Type{FactorGraph{T, V, F}}) where {T, V, F} = false
 is_directed(g::FactorGraph) = false
 
-zero(g::FactorGraph{T, V, F}) where {T, V, F} = FactorGraph{T, V, F}(0, 0)
+Base.zero(g::FactorGraph{T, V, F}) where {T, V, F} = FactorGraph{T, V, F}(0, 0)
 
 # TODO issubset(g::T, h::T) where T <: FactorGraph = issubset(g.graph, h.graph)
 

src/GraphsDFG/services/GraphsDFG.jl

@@ -258,7 +258,7 @@ function getFactors(
     filterDFG!(factors, labelFilter, (String ∘ getLabel))
     filterDFG!(factors, solvableFilter, getSolvable)
     filterDFG!(factors, tagsFilter, getTags)
-    filterDFG!(factors, typeFilter, getFactorType)
+    filterDFG!(factors, typeFilter, typeof ∘ getFactorType)
     return factors
 end
 
@@ -304,17 +304,27 @@ function isConnected(dfg::GraphsDFG)
     # return length(Graphs.connected_components(dfg.g)) == 1
 end
 
+_isSolvable(dfg::GraphsDFG, label::Symbol, ready::Nothing) = true
+
 function _isSolvable(dfg::GraphsDFG, label::Symbol, ready::Int)
     haskey(dfg.g.variables, label) && (return dfg.g.variables[label].solvable >= ready)
     haskey(dfg.g.factors, label) && (return dfg.g.factors[label].solvable >= ready)
     throw(LabelNotFoundError(label))
 end
 
-function listNeighbors(dfg::GraphsDFG, node::AbstractGraphNode; solvable::Int = 0)
+function listNeighbors(
+    dfg::GraphsDFG,
+    node::AbstractGraphNode;
+    solvable::Union{Nothing, Int} = nothing,
+)
     return listNeighbors(dfg, node.label; solvable)
 end
 
-function listNeighbors(dfg::GraphsDFG, label::Symbol; solvable::Int = 0)
+function listNeighbors(
+    dfg::GraphsDFG,
+    label::Symbol;
+    solvable::Union{Nothing, Int} = nothing,
+)
     if !(hasVariable(dfg, label) || hasFactor(dfg, label))
         throw(LabelNotFoundError(label))
     end
@@ -337,7 +347,7 @@ function listNeighborhood(
     dfg::GraphsDFG,
     variableFactorLabels::Vector{Symbol},
     distance::Int;
-    solvable::Int = 0,
+    solvable::Union{Nothing, Int} = nothing,
 )
     # find neighbors at distance to add
     nbhood = Int[]
@@ -348,7 +358,8 @@ function listNeighborhood(
 
     allvarfacs = [dfg.g.labels[id] for id in nbhood]
 
-    solvable != 0 && filter!(nlbl -> (getSolvable(dfg, nlbl) >= solvable), allvarfacs)
+    !isnothing(solvable) &&
+        filter!(nlbl -> (getSolvable(dfg, nlbl) >= solvable), allvarfacs)
 
     return allvarfacs
 end
@@ -365,9 +376,9 @@ end
 #  Biadjacency Matrix https://en.wikipedia.org/wiki/Adjacency_matrix#Of_a_bipartite_graph
 function getBiadjacencyMatrix(
     dfg::GraphsDFG;
-    solvable::Int = 0,
-    varLabels = listVariables(dfg; solvable = solvable),
-    factLabels = listFactors(dfg; solvable = solvable),
+    solvable::Union{Nothing, Int} = nothing,
+    varLabels = listVariables(dfg; solvable),
+    factLabels = listFactors(dfg; solvable),
 )
     varIndex = [dfg.g.labels[s] for s in varLabels]
     factIndex = [dfg.g.labels[s] for s in factLabels]
@@ -443,7 +454,7 @@ function findShortestPathDijkstra(
     tagsFactors::Vector{Symbol} = Symbol[],
     typeVariables::Union{Nothing, <:AbstractVector} = nothing,
     typeFactors::Union{Nothing, <:AbstractVector} = nothing,
-    solvable::Int = 0,
+    solvable::Union{Nothing, Int} = nothing,
     initialized::Union{Nothing, Bool} = nothing,
 )
     #
@@ -458,14 +469,14 @@ function findShortestPathDijkstra(
 
     #
     duplicate =
-        regexVariables !== nothing ||
-        regexFactors !== nothing ||
-        0 < length(tagsVariables) ||
-        0 < length(tagsFactors) ||
-        typeVariables !== nothing ||
-        typeFactors !== nothing ||
-        initialized !== nothing ||
-        solvable != 0
+        !isnothing(regexVariables) ||
+        !isnothing(regexFactors) ||
+        !isempty(tagsVariables) ||
+        !isempty(tagsFactors) ||
+        !isnothing(typeVariables) ||
+        !isnothing(typeFactors) ||
+        !isnothing(initialized) ||
+        !isnothing(solvable)
     #
     dfg_ = if duplicate
         # use copy if filter is being applied