Better printing of the table and mtg

Author: VEZY

Project.toml

@@ -11,6 +11,7 @@ Graphs = "86223c79-3864-5bf0-83f7-82e725a168b6"
 MetaGraphsNext = "fa8bd995-216d-47f1-8a91-f3b68fbeb377"
 MutableNamedTuples = "af6c499f-54b4-48cc-bbd2-094bba7533c7"
 OrderedCollections = "bac558e1-5e72-5ebc-8fee-abe8a469f55d"
+PrettyTables = "08abe8d2-0d0c-5749-adfa-8a2ac140af0d"
 Printf = "de0858da-6303-5e67-8744-51eddeeeb8d7"
 SHA = "ea8e919c-243c-51af-8825-aaa63cd721ce"
 Tables = "bd369af6-aec1-5ad0-b16a-f7cc5008161c"
@@ -23,6 +24,7 @@ Graphs = "1"
 MetaGraphsNext = "0.5, 0.6, 0.7, 0.8"
 MutableNamedTuples = "0.1"
 OrderedCollections = "1.4"
+PrettyTables = "3"
 SHA = "0.7, 1"
 Tables = "1"
 XLSX = "0.7, 0.8, 0.9, 0.10"

docs/src/tutorials/4.convert_mtg.md

@@ -27,6 +27,8 @@ The unified table reports MTG topology columns plus all attributes:
 - parent_id: the node's parent id
 - link: the link between the node and its parent
 
+`symbols` and `scales` are shown as table metadata in the display header (not as columns).
+
 If you only need a few attributes, you can select them directly:
 
 ```@example usepkg

src/MultiScaleTreeGraph.jl

@@ -5,6 +5,7 @@ using Printf
 import MutableNamedTuples: MutableNamedTuple
 using DelimitedFiles
 using OrderedCollections
+import PrettyTables
 import XLSX: readxlsx, sheetnames
 import SHA: sha1 # for naming the cache variable
 import Base

src/conversion/Tables.jl

@@ -3,6 +3,8 @@ struct MTGAttrColumnView{N,T} <: AbstractVector{T}
     key::Symbol
 end
 
+const _TABLE_META_COLUMNS = (:description, :symbols, :scales)
+
 Base.IndexStyle(::Type{<:MTGAttrColumnView}) = IndexLinear()
 Base.size(col::MTGAttrColumnView) = (length(col.nodes),)
 Base.length(col::MTGAttrColumnView) = length(col.nodes)
@@ -61,6 +63,7 @@ function _collect_attr_names_from_store(store::MTGAttributeStore)
     for bucket in store.buckets
         for col in bucket.columns
             name = col.name
+            name in _TABLE_META_COLUMNS && continue
             if !(name in seen)
                 push!(seen, name)
                 push!(out, name)
@@ -75,6 +78,7 @@ function _collect_attr_names_from_nodes(nodes)
     seen = Set{Symbol}()
     for n in nodes
         for key in attribute_names(n)
+            key in _TABLE_META_COLUMNS && continue
             if !(key in seen)
                 push!(seen, key)
                 push!(out, key)
@@ -102,6 +106,24 @@ function _build_attr_columns(nodes, attr_names)
     cols
 end
 
+@inline function _filter_meta_columns(vars)
+    out = Symbol[]
+    for v in vars
+        v in _TABLE_META_COLUMNS || push!(out, v)
+    end
+    out
+end
+
+function _table_metadata_from_mtg(mtg::Node)
+    root = get_root(mtg)
+    md = Dict{Symbol,Any}()
+    syms = attribute(root, :symbols, default=nothing)
+    scs = attribute(root, :scales, default=nothing)
+    syms === nothing || (md[:symbols] = syms)
+    scs === nothing || (md[:scales] = scs)
+    return md
+end
+
 @inline function _value_type_or_missing(values::Vector{Any})
     T = Union{}
     has_missing = false
@@ -128,6 +150,8 @@ If `vars` is provided (`Symbol`/`String`/vector/tuple), only these attributes ar
 function symbol_table(mtg::Node, symbol, vars=nothing)
     symbol_ = _to_table_key(symbol)
     vars_ = _to_table_vars(vars)
+    vars_ === nothing || (vars_ = _filter_meta_columns(vars_))
+    metadata = _table_metadata_from_mtg(mtg)
     attrs = node_attributes(get_root(mtg))
     if attrs isa ColumnarAttrs
         store = _store_for_node_attrs(attrs)
@@ -142,7 +166,7 @@ function symbol_table(mtg::Node, symbol, vars=nothing)
                         push!(cols_, Missing[])
                     end
                 end
-                return ColumnTable(names_, cols_)
+                return ColumnTable(names_, cols_; metadata=metadata)
             end
             bucket = store.buckets[bid]
             names_ = Symbol[:node_id]
@@ -163,7 +187,7 @@ function symbol_table(mtg::Node, symbol, vars=nothing)
                     end
                 end
             end
-            return ColumnTable(names_, cols_)
+            return ColumnTable(names_, cols_; metadata=metadata)
         end
     end
 
@@ -178,7 +202,7 @@ function symbol_table(mtg::Node, symbol, vars=nothing)
         push!(names_, attr_names[i])
         push!(cols_, attr_cols[i])
     end
-    ColumnTable(names_, cols_)
+    ColumnTable(names_, cols_; metadata=metadata)
 end
 
 """
@@ -191,6 +215,8 @@ If `vars` is provided (`Symbol`/`String`/vector/tuple), only these attributes ar
 function mtg_table(mtg::Node, vars=nothing)
     nodes = traverse(mtg, node -> node, type=typeof(mtg))
     vars_ = _to_table_vars(vars)
+    vars_ === nothing || (vars_ = _filter_meta_columns(vars_))
+    metadata = _table_metadata_from_mtg(mtg)
 
     names_ = Symbol[:node_id, :symbol, :scale, :index, :link, :parent_id]
     cols_ = AbstractVector[
@@ -212,7 +238,7 @@ function mtg_table(mtg::Node, vars=nothing)
                 T = _table_attr_type_from_store(store, key)
                 push!(cols_, MTGAttrColumnView{typeof(nodes[1]),T}(nodes, key))
             end
-            return ColumnTable(names_, cols_)
+            return ColumnTable(names_, cols_; metadata=metadata)
         end
     end
 
@@ -224,7 +250,7 @@ function mtg_table(mtg::Node, vars=nothing)
         push!(cols_, attr_cols[i])
     end
 
-    ColumnTable(names_, cols_)
+    ColumnTable(names_, cols_; metadata=metadata)
 end
 
 @inline function _materialize_table(source, sink)

src/print_MTG/print.jl

@@ -22,6 +22,13 @@ mtg
 ```
 """
 function Base.print(node::Node; leading::AbstractString="", io::IO=stdout, limit=true)
+    if isroot(node)
+        syms = attribute(node, :symbols, default=nothing)
+        scs = attribute(node, :scales, default=nothing)
+        syms === nothing || print(io, "Symbols: ", syms, "\n")
+        scs === nothing || print(io, "Scales: ", scs, "\n")
+    end
+
     node_vec = get_printing(node; leading=leading)
 
     for (i, j) in enumerate(node_vec)

src/types/ColumnTable.jl

@@ -2,9 +2,10 @@ mutable struct ColumnTable
     col_names::Vector{Symbol}
     name_to_idx::Dict{Symbol,Int}
     cols::Vector{AbstractVector}
+    metadata::Dict{Symbol,Any}
 end
 
-function ColumnTable(col_names::Vector{Symbol}, cols::Vector{AbstractVector})
+function ColumnTable(col_names::Vector{Symbol}, cols::Vector{AbstractVector}; metadata=Dict{Symbol,Any}())
     length(col_names) == length(cols) || error("Column names and columns must have the same length.")
     nrows = isempty(cols) ? 0 : length(cols[1])
     @inbounds for i in 2:length(cols)
@@ -14,17 +15,17 @@ function ColumnTable(col_names::Vector{Symbol}, cols::Vector{AbstractVector})
     @inbounds for i in eachindex(col_names)
         name_to_idx[col_names[i]] = i
     end
-    ColumnTable(col_names, name_to_idx, cols)
+    ColumnTable(col_names, name_to_idx, cols, Dict{Symbol,Any}(pairs(metadata)))
 end
 
-function ColumnTable(; kwargs...)
+function ColumnTable(; metadata=Dict{Symbol,Any}(), kwargs...)
     names_ = Symbol[]
     cols_ = AbstractVector[]
     for (k, v) in pairs(kwargs)
         push!(names_, k)
         push!(cols_, v)
     end
-    ColumnTable(names_, cols_)
+    ColumnTable(names_, cols_; metadata=metadata)
 end
 
 @inline function _column_idx(table::ColumnTable, name::Symbol)
@@ -39,14 +40,14 @@ Base.size(table::ColumnTable) = (isempty(table.cols) ? 0 : length(table.cols[1])
 Base.length(table::ColumnTable) = first(size(table))
 
 function Base.getproperty(table::ColumnTable, name::Symbol)
-    if name === :col_names || name === :name_to_idx || name === :cols
+    if name === :col_names || name === :name_to_idx || name === :cols || name === :metadata
         return getfield(table, name)
     end
     return table.cols[_column_idx(table, name)]
 end
 
 function Base.setproperty!(table::ColumnTable, name::Symbol, values)
-    if name === :col_names || name === :name_to_idx || name === :cols
+    if name === :col_names || name === :name_to_idx || name === :cols || name === :metadata
         setfield!(table, name, values)
         return values
     end
@@ -75,7 +76,7 @@ Base.getindex(table::ColumnTable, ::Colon, col::Int) = table.cols[col]
 
 function Base.copy(table::ColumnTable)
     new_cols = AbstractVector[copy(col) for col in table.cols]
-    ColumnTable(copy(table.col_names), new_cols)
+    ColumnTable(copy(table.col_names), new_cols; metadata=copy(table.metadata))
 end
 
 function Base.:(==)(a::ColumnTable, b::ColumnTable)
@@ -84,7 +85,8 @@ function Base.:(==)(a::ColumnTable, b::ColumnTable)
     @inbounds for i in eachindex(a.cols)
         a.cols[i] == b.cols[i] || return false
     end
-    return true
+    a.metadata == b.metadata || return false
+    true
 end
 
 function Base.isequal(a::ColumnTable, b::ColumnTable)
@@ -93,7 +95,8 @@ function Base.isequal(a::ColumnTable, b::ColumnTable)
     @inbounds for i in eachindex(a.cols)
         isequal(a.cols[i], b.cols[i]) || return false
     end
-    return true
+    isequal(a.metadata, b.metadata) || return false
+    true
 end
 
 function Base.sort!(table::ColumnTable, by::Symbol; kwargs...)
@@ -112,3 +115,33 @@ Tables.columnnames(table::ColumnTable) = Tuple(table.col_names)
 Tables.getcolumn(table::ColumnTable, i::Int) = table.cols[i]
 Tables.getcolumn(table::ColumnTable, name::Symbol) = table.cols[_column_idx(table, name)]
 Tables.schema(table::ColumnTable) = Tables.Schema(Tuple(table.col_names), Tuple(eltype.(table.cols)))
+
+function Base.show(io::IO, ::MIME"text/plain", table::ColumnTable)
+    nrows, ncols = size(table)
+    title = "ColumnTable($(nrows) x $(ncols))"
+
+    syms = get(table.metadata, :symbols, nothing)
+    scales = get(table.metadata, :scales, nothing)
+    syms === nothing || print(io, "Symbols: ", syms, "\n")
+    scales === nothing || print(io, "Scales: ", scales, "\n")
+
+    if ncols == 0
+        print(io, title)
+        return
+    end
+
+    t_format = PrettyTables.TextTableFormat(
+        borders=PrettyTables.text_table_borders__unicode_rounded
+    )
+
+    PrettyTables.pretty_table(
+        io,
+        table;
+        backend=:text,
+        title=title,
+        table_format=t_format,
+        row_number_column_label="Row",
+        row_labels=1:nrows,
+        vertical_crop_mode=:middle,
+    )
+end

test/test-columnar.jl

@@ -43,6 +43,9 @@ all_table = to_table(mtg)
 all_df = DataFrame(all_table)
 @test :node_id in Symbol.(names(all_df))
 @test :symbol in Symbol.(names(all_df))
+@test !(:symbols in Symbol.(names(all_df)))
+@test !(:scales in Symbol.(names(all_df)))
+@test !(:description in Symbol.(names(all_df)))
 @test all_df.node_id == list_nodes(mtg)
 @test any(ismissing, all_df.Width)
 
@@ -55,6 +58,13 @@ all_selected_kw = to_table(mtg, vars=[:Width, :Length])
 all_df_sink = to_table(mtg, vars=[:Width, :Length], sink=DataFrame)
 @test :Width in Symbol.(names(all_df_sink))
 
+all_table_str = sprint(show, MIME("text/plain"), all_selected_kw)
+@test occursin("ColumnTable", all_table_str)
+@test occursin("node_id", all_table_str)
+@test occursin("Width", all_table_str)
+@test occursin("Symbols:", all_table_str)
+@test occursin("Scales:", all_table_str)
+
 # Hybrid descendants traversal strategy.
 @test descendants_strategy(mtg) == :auto
 descendants_strategy!(mtg, :indexed)

test/test-conversion.jl

@@ -2,7 +2,9 @@ mtg = read_mtg("files/simple_plant.mtg")
 
 @testset "Tables/DataFrame interoperability" begin
     df_mtg = DataFrame(mtg)
-    @test df_mtg[1, :scales] == [0, 1, 2, 3, 3]
+    @test !(:scales in Symbol.(names(df_mtg)))
+    @test !(:symbols in Symbol.(names(df_mtg)))
+    @test !(:description in Symbol.(names(df_mtg)))
     @test df_mtg[7, :Length] == 0.2
 end
 

test/test-nodes.jl

@@ -92,7 +92,11 @@ mtg = read_mtg(file)
 @testset "names" begin
     @test sort!(get_attributes(mtg)) == [:Length, :Width, :XEuler, :dateDeath, :description, :isAlive, :scales, :symbols]
     @test names(mtg) == get_attributes(mtg)
-    @test sort(names(DataFrame(mtg))[7:end]) == sort(string.(names(mtg)))
+    attrs_no_meta = setdiff(names(mtg), [:description, :symbols, :scales])
+    @test sort(names(DataFrame(mtg))[7:end]) == sort(string.(attrs_no_meta))
+    mtg_print = sprint(show, mtg)
+    @test occursin("Symbols:", mtg_print)
+    @test occursin("Scales:", mtg_print)
 end