Update printing -> only visit each node once + shorten huge graphs

Author: VEZY

src/component_models/ModelList.jl

@@ -187,8 +187,6 @@ function ModelList(
     ts_kwargs = homogeneous_ts_kwargs(status)
     ts_kwargs = add_model_vars(ts_kwargs, mods, type_promotion)
 
-
-
     model_list = ModelList(
         mods,
         ts_kwargs,

src/dependencies/dependency_graph.jl

@@ -64,6 +64,8 @@ AbstractTrees.printnode(io::IO, node::HardDependencyNode{T}) where {T} = print(i
 AbstractTrees.printnode(io::IO, node::SoftDependencyNode{T}) where {T} = print(io, T)
 Base.show(io::IO, t::AbstractDependencyNode) = AbstractTrees.print_tree(io, t)
 Base.length(t::AbstractDependencyNode) = length(collect(AbstractTrees.PreOrderDFS(t)))
+Base.length(t::DependencyGraph) = length(traverse_dependency_graph(t))
+AbstractTrees.children(t::DependencyGraph) = collect(t.roots)
 
 # Long form printing
 function Base.show(io::IO, ::MIME"text/plain", t::DependencyGraph)

src/dependencies/printing.jl

@@ -1,21 +1,29 @@
 function draw_dependency_graph(
     io,
     graphs::DependencyGraph;
-    title="Dependency graph",
+    title=string("Dependency graph (", length(graphs), " models)"),
+    max_depth::Int=1,
     title_style::String="#FFA726 italic",
     guides_style::String="#42A5F5",
     dep_graph_guides=(space=" ", vline="│", branch="├", leaf="└", hline="─")
 )
 
     dep_graph_guides = map((g) -> Term.apply_style("{$guides_style}$g{/$guides_style}"), dep_graph_guides)
 
+    max_depth_reached = Ref(max_depth)
+
     graph_panel = []
     for (p, graph) in graphs.roots
+        if max_depth_reached[] <= 0
+            push!(graph_panel, "...")
+            break
+        end
         node = []
         # p = :process2; graph = graphs.roots[p]
         # typeof(deps[:process4].children[1].hard_dependency.children[1])
-        draw_panel(node, graph, "", dep_graph_guides, graph; title="Main model")
+        draw_panel(node, graph, "", dep_graph_guides, graph, max_depth_reached; title="Main model")
         push!(graph_panel, Term.Panel(node...; fit=true, title=string(p), style="green dim"))
+        max_depth_reached[] -= 1
     end
 
     print(
@@ -34,7 +42,12 @@ end
 
 Draw the panels for all dependencies
 """
-function draw_panel(node, graph, prefix, dep_graph_guides, parent; title="Soft-coupled model")
+function draw_panel(node, graph, prefix, dep_graph_guides, parent, max_depth_reached=Ref(5); title="Soft-coupled model")
+
+    if max_depth_reached[] <= 0
+        push!(node, "...")
+        return nothing
+    end
 
     # If the node has a sibling, draw a branching guide + a horizontal line:
     if length(parent.children) <= 1
@@ -65,7 +78,8 @@ function draw_panel(node, graph, prefix, dep_graph_guides, parent; title="Soft-c
     if graph isa SoftDependencyNode
         # draw a branching guide if there's more soft dependencies after this one:
         for child in graph.hard_dependency
-            draw_panel(node, child, panel_hright, dep_graph_guides, graph; title="Hard-coupled model")
+            draw_panel(node, child, panel_hright, dep_graph_guides, graph, max_depth_reached; title="Hard-coupled model")
+            max_depth_reached[] -= 1
         end
     elseif isa(parent, SoftDependencyNode) && length(parent.children) > 0
         # The current node is a hard dependency of a soft dependency.
@@ -75,7 +89,8 @@ function draw_panel(node, graph, prefix, dep_graph_guides, parent; title="Soft-c
 
     # Recursive call:
     for child in AbstractTrees.children(graph)
-        draw_panel(node, child, panel_hright, dep_graph_guides, graph; title=title_panel(child))
+        draw_panel(node, child, panel_hright, dep_graph_guides, graph, max_depth_reached; title=title_panel(child))
+        max_depth_reached[] -= 1
     end
 end
 

src/dependencies/soft_dependencies.jl

@@ -40,7 +40,8 @@ function soft_dependencies(d::DependencyGraph{Dict{Symbol,HardDependencyNode}},
     d_vars = Dict{Symbol,Vector{Pair{Symbol,NamedTuple}}}()
     for (procname, node) in d.roots
         var = Pair{Symbol,NamedTuple}[]
-        traverse_dependency_graph!(node, variables, var)
+        nodes_visited = Set{AbstractDependencyNode}()
+        traverse_dependency_graph!(node, variables, var; node_visited=nodes_visited)
         push!(d_vars, procname => var)
     end
 
@@ -138,7 +139,7 @@ function soft_dependencies(d::DependencyGraph{Dict{Symbol,HardDependencyNode}},
 end
 
 # For multiscale mapping:
-function soft_dependencies_multiscale(soft_dep_graphs_roots::DependencyGraph{Dict{String,Any}}, mapping::Dict{String,A}, hard_dep_dict::Dict{Pair{Symbol, String}, HardDependencyNode}) where {A<:Any}
+function soft_dependencies_multiscale(soft_dep_graphs_roots::DependencyGraph{Dict{String,Any}}, mapping::Dict{String,A}, hard_dep_dict::Dict{Pair{Symbol,String},HardDependencyNode}) where {A<:Any}
     mapped_vars = mapped_variables(mapping, soft_dep_graphs_roots, verbose=false)
     rev_mapping = reverse_mapping(mapped_vars, all=false)
 
@@ -151,11 +152,11 @@ function soft_dependencies_multiscale(soft_dep_graphs_roots::DependencyGraph{Dic
 
             # Remove the hard dependencies from the soft dependencies:
             soft_deps_not_hard = drop_process(soft_deps, [hd.process for hd in i.hard_dependency])
-           
+
             hard_dependencies_from_other_scale = [hd for hd in i.hard_dependency if hd.scale != i.scale]
 
             # NB: if a node is already a hard dependency of the node, it cannot be a soft dependency
-            
+
             # Check if the process has soft dependencies at other scales:
             soft_deps_multiscale = search_inputs_in_multiscale_output(proc, organ, ins, soft_dep_graphs_roots.roots, rev_mapping, hard_dependencies_from_other_scale)
             # Example output: "Soil" => Dict(:soil_water=>[:soil_water_content]), which means that the variable :soil_water_content
@@ -171,37 +172,37 @@ function soft_dependencies_multiscale(soft_dep_graphs_roots::DependencyGraph{Dic
                     # If the process has soft dependencies, then it is not independant
                     # and we need to add its parent(s) to the node, and the node as a child
                     for (parent_soft_dep, soft_dep_vars) in pairs(soft_deps_not_hard)
-    
+
                         # if the parent isn't registered as a soft dependency, it likely means the soft dependecy should be to an internal hard dependency to the parent
-                        if(!haskey(soft_dep_graph, parent_soft_dep))
+                        if (!haskey(soft_dep_graph, parent_soft_dep))
 
                             roots_at_given_scale = soft_dep_graphs_roots.roots[i.scale][:soft_dep_graph]
-                            if !(parent_soft_dep in keys(roots_at_given_scale))                                                               
+                            if !(parent_soft_dep in keys(roots_at_given_scale))
                                 master_node = ()
-                                for ((hd_key, hd_scale), hd) in hard_dep_dict 
-                                    if parent_soft_dep == hd_key     
-                                        master_node = hd                                                                                                                                                                                       
+                                for ((hd_key, hd_scale), hd) in hard_dep_dict
+                                    if parent_soft_dep == hd_key
+                                        master_node = hd
                                         depth = 0
                                         # A cleaner way of preventing cycles or infinite loops would be more desirable
                                         while !isa(master_node, SoftDependencyNode) && depth < 50
                                             master_node.parent === nothing && error("Finalised hard dependency has no parent")
                                             master_node = master_node.parent
                                             depth += 1
-                                        end                                      
-                                        
+                                        end
+
                                         break
                                     end
-                               end
-                            master_node == () && error("Parent is not located in hard deps, nor in roots, which should be the case when initalizing soft dependencies")
-                        end
+                                end
+                                master_node == () && error("Parent is not located in hard deps, nor in roots, which should be the case when initalizing soft dependencies")
+                            end
                             # NOTE : this may need to be propagated within internal hard dependencies' ancestors of this model... ?
                             parent_node = soft_dep_graphs_roots.roots[master_node.scale][:soft_dep_graph][master_node.process]
                         else
                             parent_node = soft_dep_graph[parent_soft_dep]
                         end
-                        
-                        
-                        
+
+
+
                         # preventing a cyclic dependency
                         if parent_soft_dep == proc
                             error("Cyclic model dependency detected for process $proc from organ $organ.")
@@ -247,33 +248,33 @@ function soft_dependencies_multiscale(soft_dep_graphs_roots::DependencyGraph{Dic
                 # If the node has soft dependencies at other scales, add it as child of the other scale (and add its parent too):
                 if length(soft_deps_multiscale) > 0
                     for org in keys(soft_deps_multiscale)
-                        for (parent_soft_dep, soft_dep_vars) in soft_deps_multiscale[org]                            
-                                                      
+                        for (parent_soft_dep, soft_dep_vars) in soft_deps_multiscale[org]
+
                             # if the node has a soft dependency on a node that is a nested hard dependency, 
                             # have it point to the master node of that hard dependency instead of the internal node
                             # This check is meant in case the organ at the inspected scale is part of a hard dependency, 
                             # and therefore already absent from the roots
 
-                            roots_at_given_scale = soft_dep_graphs_roots.roots[org][:soft_dep_graph]   
-                            if !(parent_soft_dep in keys(roots_at_given_scale))                                                               
+                            roots_at_given_scale = soft_dep_graphs_roots.roots[org][:soft_dep_graph]
+                            if !(parent_soft_dep in keys(roots_at_given_scale))
                                 master_node = ()
-                                for ((hd_key, hd_scale), hd) in hard_dep_dict 
-                                    if parent_soft_dep == hd_key     
-                                        master_node = hd                                                                                                                                                                                       
+                                for ((hd_key, hd_scale), hd) in hard_dep_dict
+                                    if parent_soft_dep == hd_key
+                                        master_node = hd
                                         depth = 0
                                         # A cleaner way of preventing cycles or infinite loops would be more desirable
                                         while !isa(master_node, SoftDependencyNode) && depth < 50
                                             master_node.parent === nothing && error("Finalised hard dependency has no parent")
                                             master_node = master_node.parent
                                             depth += 1
-                                        end                                      
-                                        
+                                        end
+
                                         break
                                     end
-                               end
+                                end
 
                                 master_node == () && error("Parent is not located in hard deps, nor in roots, which should be the case when initalizing soft dependencies")
-                            
+
                                 # NOTE : this may need to be propagated within internal hard dependencies' ancestors of this model... ?
                                 parent_node = soft_dep_graphs_roots.roots[master_node.scale][:soft_dep_graph][master_node.process]
                             else
@@ -298,13 +299,13 @@ function soft_dependencies_multiscale(soft_dep_graphs_roots::DependencyGraph{Dic
                                 )
                             end
 
-                            
+
                             if !(i in parent_node.children) # && error("Cyclic dependency detected for process $proc from organ $organ.")
 
                                 # Add the current node as a child of the node on which it depends:
                                 push!(parent_node.children, i)
                             end
-                                # Add the node on which the current node depends as a parent
+                            # Add the node on which the current node depends as a parent
                             if i.parent === nothing
                                 # If the node had no parent already, it is nothing, so we change into a vector
                                 i.parent = [parent_node]
@@ -315,7 +316,7 @@ function soft_dependencies_multiscale(soft_dep_graphs_roots::DependencyGraph{Dic
                             end
 
                             # Add the multiscale soft dependencies variables of the parent to the current node
-                            i.parent_vars = NamedTuple(Symbol(k) => NamedTuple(v) for (k, v) in soft_deps_multiscale)                             
+                            i.parent_vars = NamedTuple(Symbol(k) => NamedTuple(v) for (k, v) in soft_deps_multiscale)
                         end
                     end
                 end
@@ -488,9 +489,9 @@ function search_inputs_in_multiscale_output(process, organ, inputs, soft_dep_gra
                 # Avoid collecting variables at other scales if they come from a hard dependency
                 # They are handled internally by the hard dep, so if a hard dependency contains that variable, don't add it
                 # (This only needs to be done one level beneath the soft dependency nodes, any hard dependencies internal to another one don't expose their variables here)
-               
+
                 in_hard_dep::Bool = false
-                hd_os_current_scale = filter(x -> x.scale == org, hard_dependencies_from_other_scale)               
+                hd_os_current_scale = filter(x -> x.scale == org, hard_dependencies_from_other_scale)
                 for hd_os in hd_os_current_scale
                     hd_os_output_vars = [first(p) for p in pairs(hd_os.outputs)]
                     in_hard_dep |= length(filter(x -> x == var, hd_os_output_vars)) > 0

src/dependencies/traversal.jl

@@ -1,9 +1,11 @@
 """
     traverse_dependency_graph(graph::DependencyGraph, f::Function; visit_hard_dep=true)
+    traverse_dependency_graph(graph; visit_hard_dep=true)
 
-Traverse the dependency `graph` and apply the function `f` to each node.
-The first-level soft-dependencies are traversed first, then their
-hard-dependencies (if `visit_hard_dep=true`), and then the children of the soft-dependencies.
+Traverse the dependency `graph` and apply the function `f` to each node, or just return the nodes if `f` is not provided.
+
+The first-level soft-dependencies are traversed first, then their hard-dependencies (if `visit_hard_dep=true`), and then 
+the children of the soft-dependencies.
 
 Return a vector of pairs of the node and the result of the function `f`.
 
@@ -38,23 +40,38 @@ function traverse_dependency_graph(
     f::Function;
     visit_hard_dep=true
 )
-    var = []
-    node_visited = Set()
+
+    var = Pair{Symbol,Any}[]
+    nodes_types = visit_hard_dep ? AbstractDependencyNode : SoftDependencyNode
+    node_visited = Set{nodes_types}()
     for (p, root) in graph.roots
         traverse_dependency_graph!(root, f, var; visit_hard_dep=visit_hard_dep, node_visited=node_visited)
     end
 
     return var
 end
 
+function traverse_dependency_graph(
+    graph::DependencyGraph,
+    visit_hard_dep=true
+)
+    nodes_types = visit_hard_dep ? AbstractDependencyNode : SoftDependencyNode
+    var = Pair{Symbol,nodes_types}[]
+    node_visited = Set{nodes_types}()
+    for (p, root) in graph.roots
+        traverse_dependency_graph!(root, x -> x, var; visit_hard_dep=visit_hard_dep, node_visited=node_visited)
+    end
 
-function traverse_dependency_graph!(f::Function, graph::DependencyGraph; visit_hard_dep=true, node_visited::Set{AbstractDependencyNode}=Set())
+    return last.(var)
+end
+
+function traverse_dependency_graph!(f::Function, graph::DependencyGraph; visit_hard_dep=true, node_visited::Set=Set{AbstractDependencyNode}())
     for (p, root) in graph.roots
         traverse_dependency_graph!(f, root, visit_hard_dep=visit_hard_dep, node_visited=node_visited)
     end
 end
 
-function traverse_dependency_graph!(f::Function, node::SoftDependencyNode; visit_hard_dep=true, node_visited::Set{AbstractDependencyNode}=Set())
+function traverse_dependency_graph!(f::Function, node::SoftDependencyNode; visit_hard_dep=true, node_visited::Set=Set{AbstractDependencyNode}())
     if node in node_visited
         return nothing
     end
@@ -76,7 +93,7 @@ function traverse_dependency_graph!(f::Function, node::SoftDependencyNode; visit
     end
 end
 
-function traverse_dependency_graph!(f::Function, node::HardDependencyNode; visit_hard_dep=true, node_visited::Set{AbstractDependencyNode}=Set())
+function traverse_dependency_graph!(f::Function, node::HardDependencyNode; visit_hard_dep=true, node_visited::Set=Set{AbstractDependencyNode}())
     if node in node_visited
         return nothing
     end
@@ -105,7 +122,7 @@ function traverse_dependency_graph!(
     f::Function,
     var::Vector;
     visit_hard_dep=true,
-    node_visited::Set{AbstractDependencyNode}=Set()
+    node_visited::Set=Set{AbstractDependencyNode}()
 )
     if node in node_visited
         return nothing
@@ -140,8 +157,9 @@ function traverse_dependency_graph!(
     f::Function,
     var::Vector;
     visit_hard_dep=true,  # Just to be compatible with a call shared with SoftDependencyNode method
-    node_visited::Set{AbstractDependencyNode}=Set()
+    node_visited::Set=Set{HardDependencyNode}()
 )
+
     if node in node_visited
         return nothing
     end