fix train show and tests (#214)

* fix train show and tests

* m lines

Author: lazarusA

src/utils/show_train.jl

@@ -6,6 +6,15 @@ function _print_nested_keys(io::IO, nt::NamedTuple; indent = 4)
         pad = " "^(maxkey - length(kstr) + 2)
         if isa(v, NamedTuple)
             println(io, prefix, kstr, pad, "(", join(propertynames(v), ", "), ")")
+        elseif isa(v, Tuple)
+            # Tuples need special handling - use length or show as scalar
+            if length(v) == 0
+                println(io, prefix, kstr, pad, "()")
+            else
+                printstyled(io, prefix * kstr * pad; color = 10)
+                printstyled(io, "($(length(v)),)"; color = :light_black)
+                println(io)
+            end
         else
             sz = size(v)
             if sz == ()
@@ -49,6 +58,9 @@ function Base.show(io::IO, ::MIME"text/plain", tr::TrainResults)
             println(io)
             _print_nested_keys(io, val; indent = 4)
         else
+            # Print scalar values or other types
+            print(io)
+            printstyled(io, "$(val)"; color = :light_red)
             println(io)
         end
     end

test/runtests.jl

@@ -16,6 +16,8 @@ include("test_loss_types.jl")
 include("test_show_loss_types.jl")
 include("test_compute_loss.jl")
 include("test_loss_fn.jl")
+include("test_show_train.jl")
+include("test_show_generic_hybrid.jl")
 
 @testset "LinearHM" begin
     # test model instantiation

test/test_show_generic_hybrid.jl

@@ -0,0 +1,125 @@
+using EasyHybrid: HybridParams, ParameterContainer, SingleNNHybridModel, MultiNNHybridModel
+using EasyHybrid: _print_field, _print_header, IndentedIO
+
+@testset "show_generic.jl" begin
+
+    @testset "_print_field and _print_header" begin
+        result = sprint(
+            io -> begin
+                _print_header(io, "Test Header", color = :blue)
+                _print_field(io, "scalar", 42)
+                _print_field(io, "bool_true", true)
+                _print_field(io, "bool_false", false)
+                _print_field(io, "namedtuple", (a = 1, b = 2.0))
+                _print_field(io, "function", sum)
+            end, context = :color => false
+        )
+
+        @test occursin("Test Header", result)
+        @test occursin("scalar", result) && occursin("42", result)
+        @test occursin("bool_true", result) && occursin("bool_false", result)
+        @test occursin("namedtuple", result) && occursin("a =", result) && occursin("b =", result)
+        @test occursin("function", result) && occursin("sum", result)
+    end
+
+    @testset "HybridParams show" begin
+        params = (a = (1.0, 0.0, 2.0), b = (2.0, 1.0, 3.0))
+        pc = ParameterContainer(params)
+        hp = HybridParams{typeof(sum)}(pc)
+
+        # Compact show
+        result_compact = sprint(show, hp, context = :color => false)
+        @test occursin("HybridParams", result_compact) && occursin("ParameterContainer", result_compact)
+
+        # Text/plain show
+        result_full = sprint(show, MIME"text/plain"(), hp, context = :color => false)
+        @test occursin("Hybrid Parameters", result_full) # only check for the header
+    end
+
+    @testset "ParameterContainer compact show" begin
+        params = (a = (1.0, 0.0, 2.0), b = (2.0, 1.0, 3.0))
+        pc = ParameterContainer(params)
+
+        result = sprint(show, pc, context = :color => false)
+        @test occursin("ParameterContainer(a, b)", result)
+    end
+
+    @testset "SingleNNHybridModel show" begin
+        function test_model(; x1, a, b)
+            return (; y_pred = a .* x1 .+ b)
+        end
+
+        model = constructHybridModel(
+            [:x1, :x2], [:x3], [:y], test_model,
+            (a = (1.0, 0.0, 2.0), b = (2.0, 1.0, 3.0)),
+            [:a], [:b];
+            hidden_layers = [4, 4], activation = tanh
+        )
+
+        result = sprint(show, MIME"text/plain"(), model, context = :color => false)
+
+        @test occursin("Hybrid Model (Single NN)", result)
+        @test occursin("Neural Network:", result) && occursin("Configuration:", result)
+        @test all(
+            occursin.(
+                [
+                    "predictors", "forcing", "targets", "mechanistic_model",
+                    "neural_param_names", "global_param_names", "scale_nn_outputs",
+                    "start_from_default", "config", "Parameters:",
+                ], Ref(result)
+            )
+        )
+    end
+
+    @testset "MultiNNHybridModel show" begin
+        function test_model(; x1, x2, x3, a, b, c, d)
+            return (; obs = a .* x2 .+ d .* x1 .+ b)
+        end
+
+        model = constructHybridModel(
+            (a = [:x2, :x3], d = [:x1]), [:x1], [:obs], test_model,
+            (a = (1.0, 0.0, 5.0), b = (2.0, 0.0, 10.0), c = (0.5, 0.0, 2.0), d = (0.5, 0.0, 2.0)),
+            [:b];  # Only global_param_names, neural_param_names derived from predictors keys
+            hidden_layers = [4, 4], activation = tanh
+        )
+
+        result = sprint(show, MIME"text/plain"(), model, context = :color => false)
+
+        @test occursin("Hybrid Model (Multi NN)", result)
+        @test occursin("Neural Networks:", result) && occursin("Configuration:", result)
+        @test all(occursin.(["predictors", "a", "d", "forcing", "targets", "config", "Parameters:"], Ref(result)))
+    end
+
+    @testset "IndentedIO" begin
+        result = sprint(
+            io -> begin
+                ido = IndentedIO(io; indent = "  ")
+                println(ido, "line1")
+                println(ido, "line2")
+            end, context = :color => false
+        )
+
+        @test occursin("  line1", result) && occursin("  line2", result)
+
+        # Test flush, isopen, close, readavailable methods
+        io1 = IOBuffer()
+        ido1 = IndentedIO(io1; indent = "  ")
+        @test isopen(ido1) == isopen(io1)
+        print(ido1, "test")
+        flush(ido1)
+        @test String(take!(io1)) == "  test"
+
+        # Test readavailable (for IOBuffer)
+        io2 = IOBuffer("data")
+        ido2 = IndentedIO(io2)
+        @test readavailable(ido2) == UInt8[0x64, 0x61, 0x74, 0x61]
+
+        # Test close
+        io3 = IOBuffer()
+        ido3 = IndentedIO(io3)
+        @test isopen(ido3)
+        close(ido3)
+        @test !isopen(ido3)
+    end
+
+end

test/test_show_train.jl

@@ -0,0 +1,75 @@
+using Test
+using EasyHybrid
+using EasyHybrid: TrainResults
+using DataFrames
+
+@testset "show_train.jl" begin
+
+    @testset "_print_nested_keys" begin
+        # Test scalars, arrays, nested NamedTuples, empty and non-empty tuples
+        nt = (
+            scalar = 1.0,
+            array = [1, 2, 3],
+            nested = (x = 1.0, y = 2.0),
+            empty_tuple = (),
+            non_empty_tuple = (1.0, 2.0, 3.0),  # Non-empty tuple to cover tuple length printing
+        )
+        result = sprint(io -> EasyHybrid._print_nested_keys(io, nt; indent = 4), context = :color => false)
+
+        @test occursin("scalar", result) && occursin("array", result) && occursin("nested", result)
+        @test occursin("(x, y)", result)  # Nested property names
+        @test occursin("(3,)", result)  # Array size
+        @test occursin("non_empty_tuple", result) && occursin("(3,)", result)  # Non-empty tuple length
+        @test occursin("empty_tuple", result) && occursin("()", result)  # Empty tuple
+    end
+
+    @testset "Base.show for TrainResults" begin
+        # Comprehensive test covering all field types
+        train_history = [(mse = (reco = 1.0, sum = 0.5), r2 = (reco = 0.9, sum = 0.45))]
+        val_history = [(mse = (reco = 1.1, sum = 0.55), r2 = (reco = 0.88, sum = 0.44))]
+        ps_history = [(ϕ = (), monitor = (train = (), val = ()))]
+        train_obs_pred = DataFrame(reco = [1.0, 2.0], index = [1, 2], reco_pred = [1.1, 2.1])
+        val_obs_pred = DataFrame(reco = [3.0], index = [3], reco_pred = [3.1])
+        train_diffs = (Q10 = [2.0], rb = [1.0, 2.0], parameters = (rb = [1.0], Q10 = [2.0]))
+        val_diffs = (Q10 = [2.0], rb = [3.0], parameters = (rb = [3.0], Q10 = [2.0]))
+        ps = ([1.0, 2.0],)  # Tuple, (not really the full expected type, but it's a tuple)
+        st = (st_nn = (layer_1 = (), layer_2 = ()), fixed = ())
+        best_epoch = 42
+        best_loss = 0.123
+
+        tr = TrainResults(
+            train_history, val_history, ps_history, train_obs_pred, val_obs_pred,
+            train_diffs, val_diffs, ps, st, best_epoch, best_loss
+        )
+
+        result = sprint(show, MIME"text/plain"(), tr; context = :color => false)
+
+        # All fields present
+        @test all(
+            occursin.(
+                [
+                    "train_history:", "val_history:", "ps_history:", "train_obs_pred:",
+                    "val_obs_pred:", "train_diffs:", "val_diffs:", "ps:", "st:",
+                    "best_epoch:", "best_loss:",
+                ], Ref(result)
+            )
+        )
+
+        # Array sizes and nested structures
+        @test occursin("(1,)", result)
+        @test occursin("(reco, sum)", result) && occursin("(train, val)", result)
+        @test occursin("(rb, Q10)", result)
+
+        # DataFrame format
+        @test occursin("DataFrame", result) && occursin("reco", result) && occursin("index", result)
+
+        # Scalar values printed
+        @test occursin("42", result) && occursin("0.123", result)
+
+        # Empty arrays and tuples handled
+        tr_empty = TrainResults([], [], [], DataFrame(), DataFrame(), nothing, nothing, (), (), 0, 0.0)
+        result_empty = sprint(show, MIME"text/plain"(), tr_empty; context = :color => false)
+        @test occursin("(0,)", result_empty) && occursin("best_epoch:", result_empty)
+    end
+
+end