format things related to verbosity

jClugstor · jClugstor · commit 1053de893442 · 2025-07-27T21:09:28.000-04:00
diff --git a/docs/src/basics/common_solver_opts.md b/docs/src/basics/common_solver_opts.md
@@ -32,65 +32,72 @@ The verbosity system in LinearSolve.jl provides fine-grained control over the di
 
 The verbosity system is organized hierarchically into three main categories:
 
-1. Error Control - Messages related to fallbacks and error handling
-2. Performance - Messages related to performance considerations
-3. Numerical - Messages related to numerical solvers and iterations
+ 1. Error Control - Messages related to fallbacks and error handling
+ 2. Performance - Messages related to performance considerations
+ 3. Numerical - Messages related to numerical solvers and iterations
 
 Each category can be configured independently, and individual settings can be adjusted to suit your needs.
 
 ### Verbosity Levels
+
 The following verbosity levels are available:
 
 #### Individual Settings
+
 These settings are meant for individual settings within a category. These can also be used to set all of the individual settings in a group to the same value.
-- Verbosity.None() - Suppress all messages
-- Verbosity.Info() - Show message as log message at info level
-- Verbosity.Warn() - Show warnings (default for most settings)
-- Verbosity.Error() - Throw errors instead of warnings
-- Verbosity.Level(n) - Show messages with a log level setting of n
+
+  - Verbosity.None() - Suppress all messages
+  - Verbosity.Info() - Show message as log message at info level
+  - Verbosity.Warn() - Show warnings (default for most settings)
+  - Verbosity.Error() - Throw errors instead of warnings
+  - Verbosity.Level(n) - Show messages with a log level setting of n
 
 #### Group Settings
-These settings are meant for controlling a group of settings. 
-- Verbosity.Default() - Use the default settings
-- Verbosity.All() - Show all possible messages
 
-### Basic Usage 
+These settings are meant for controlling a group of settings.
+
+  - Verbosity.Default() - Use the default settings
+  - Verbosity.All() - Show all possible messages
+
+### Basic Usage
 
 #### Global Verbosity Control
 
-```julia 
+```julia
 using LinearSolve
 
 # Suppress all messages
 verbose = LinearVerbosity(Verbosity.None())
 prob = LinearProblem(A, b)
-sol = solve(prob; verbose=verbose)
+sol = solve(prob; verbose = verbose)
 
 # Show all messages
 verbose = LinearVerbosity(Verbosity.All())
-sol = solve(prob; verbose=verbose)
+sol = solve(prob; verbose = verbose)
 
 # Use default settings
 verbose = LinearVerbosity(Verbosity.Default())
-sol = solve(prob; verbose=verbose)
+sol = solve(prob; verbose = verbose)
 ```
 
-#### Group Level Control 
+#### Group Level Control
 
-```julia 
+```julia
 # Customize by category
 verbose = LinearVerbosity(
     error_control = Verbosity.Warn(),   # Show warnings for error control related issues
     performance = Verbosity.None(),     # Suppress performance messages
     numerical = Verbosity.Info()        # Show all numerical related log messages at info level
 )
 
-sol = solve(prob; verbose=verbose)
+sol = solve(prob; verbose = verbose)
 ```
 
 #### Fine-grained Control
-The constructor for `LinearVerbosity` allows you to set verbosity for each specific message toggle, giving you fine-grained control. 
-The verbosity settings for the toggles are automatically passed to the group objects. 
+
+The constructor for `LinearVerbosity` allows you to set verbosity for each specific message toggle, giving you fine-grained control.
+The verbosity settings for the toggles are automatically passed to the group objects.
+
 ```julia
 # Set specific message types
 verbose = LinearVerbosity(
@@ -100,17 +107,23 @@ verbose = LinearVerbosity(
     KrylovKit_verbosity = Verbosity.Level(KrylovKit.WARN_LEVEL) # Set KrylovKit verbosity level using KrylovKit's own verbosity levels
 )
 
-sol = solve(prob; verbose=verbose)
+sol = solve(prob; verbose = verbose)
 
 ```
 
 #### Verbosity Levels
+
 ##### Error Control Settings
-- default_lu_fallback: Controls messages when falling back to LU factorization (default: Warn)
+
+  - default_lu_fallback: Controls messages when falling back to LU factorization (default: Warn)
+
 ##### Performance Settings
-- no_right_preconditioning: Controls messages when right preconditioning is not used (default: Warn)
+
+  - no_right_preconditioning: Controls messages when right preconditioning is not used (default: Warn)
+
 ##### Numerical Settings
-- using_IterativeSolvers: Controls messages when using the IterativeSolvers.jl package (default: Warn)
-- IterativeSolvers_iterations: Controls messages about iteration counts from IterativeSolvers.jl (default: Warn)
-- KrylovKit_verbosity: Controls messages from the KrylovKit.jl package (default: Warn)
-- KrylovJL_verbosity: Controls verbosity of the KrylovJL.jl package (default: None)
+
+  - using_IterativeSolvers: Controls messages when using the IterativeSolvers.jl package (default: Warn)
+  - IterativeSolvers_iterations: Controls messages about iteration counts from IterativeSolvers.jl (default: Warn)
+  - KrylovKit_verbosity: Controls messages from the KrylovKit.jl package (default: Warn)
+  - KrylovJL_verbosity: Controls verbosity of the KrylovJL.jl package (default: None)
diff --git a/ext/LinearSolveCUDAExt.jl b/ext/LinearSolveCUDAExt.jl
@@ -55,19 +55,22 @@ end
 
 function LinearSolve.init_cacheval(
         ::SparspakFactorization, A::CUDA.CUSPARSE.CuSparseMatrixCSR, b, u,
-        Pl, Pr, maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions)
+        Pl, Pr, maxiters::Int, abstol, reltol,
+        verbose::LinearVerbosity, assumptions::OperatorAssumptions)
     nothing
 end
 
 function LinearSolve.init_cacheval(
         ::KLUFactorization, A::CUDA.CUSPARSE.CuSparseMatrixCSR, b, u,
-        Pl, Pr, maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions)
+        Pl, Pr, maxiters::Int, abstol, reltol,
+        verbose::LinearVerbosity, assumptions::OperatorAssumptions)
     nothing
 end
 
 function LinearSolve.init_cacheval(
         ::UMFPACKFactorization, A::CUDA.CUSPARSE.CuSparseMatrixCSR, b, u,
-        Pl, Pr, maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions)
+        Pl, Pr, maxiters::Int, abstol, reltol,
+        verbose::LinearVerbosity, assumptions::OperatorAssumptions)
     nothing
 end
 
diff --git a/ext/LinearSolveHYPREExt.jl b/ext/LinearSolveHYPREExt.jl
@@ -161,7 +161,6 @@ function create_solver(alg::HYPREAlgorithm, cache::LinearCache)
 
     # Construct solver options
 
-
     verbose = verbosity_to_int(cache.verbose.numerical.HYPRE_verbosity)
 
     solver_options = (;
diff --git a/ext/LinearSolveIterativeSolversExt.jl b/ext/LinearSolveIterativeSolversExt.jl
@@ -66,7 +66,7 @@ function LinearSolve.init_cacheval(alg::IterativeSolversJL, A, b, u, Pl, Pr, max
             kwargs...)
     elseif alg.generate_iterator === IterativeSolvers.idrs_iterable!
         !!LinearSolve._isidentity_struct(Pr) &&
-            @SciMLMessage("$(alg.generate_iterator) doesn't support right preconditioning", 
+            @SciMLMessage("$(alg.generate_iterator) doesn't support right preconditioning",
                 verbose, :no_right_preconditioning, :performance)
         history = IterativeSolvers.ConvergenceHistory(partial = true)
         history[:abstol] = abstol
@@ -107,11 +107,13 @@ function SciMLBase.solve!(cache::LinearCache, alg::IterativeSolversJL; kwargs...
     end
     purge_history!(cache.cacheval, cache.u, cache.b)
 
-    @SciMLMessage("Using IterativeSolvers.$(alg.generate_iterator)", cache.verbose, :using_IterativeSolvers, :numerical)
+    @SciMLMessage("Using IterativeSolvers.$(alg.generate_iterator)",
+        cache.verbose, :using_IterativeSolvers, :numerical)
     i = 0
     for iter in enumerate(cache.cacheval)
         i += 1
-        @SciMLMessage("Iter: $(iter[1]), residual: $(iter[2])", cache.verbose, :IterativeSolvers_iterations, :numerical)
+        @SciMLMessage("Iter: $(iter[1]), residual: $(iter[2])",
+            cache.verbose, :IterativeSolvers_iterations, :numerical)
         # TODO inject callbacks KSP into solve! cb!(cache.cacheval)
     end
 
diff --git a/ext/LinearSolveSparseArraysExt.jl b/ext/LinearSolveSparseArraysExt.jl
@@ -5,7 +5,8 @@ using LinearSolve: LinearSolve, BLASELTYPES, pattern_changed, ArrayInterface,
                    GenericLUFactorization,
                    KLUFactorization, LUFactorization, NormalCholeskyFactorization,
                    OperatorAssumptions,
-                   QRFactorization, RFLUFactorization, UMFPACKFactorization, solve, LinearVerbosity
+                   QRFactorization, RFLUFactorization, UMFPACKFactorization, solve,
+                   LinearVerbosity
 using ArrayInterface: ArrayInterface
 using LinearAlgebra: LinearAlgebra, I, Hermitian, Symmetric, cholesky, ldiv!, lu, lu!, QR
 using SparseArrays: SparseArrays, AbstractSparseArray, AbstractSparseMatrixCSC,
@@ -289,7 +290,7 @@ function LinearSolve.init_cacheval(alg::CHOLMODFactorization,
         Pl, Pr,
         maxiters::Int, abstol, reltol,
         verbose::LinearVerbosity, assumptions::OperatorAssumptions) where {T <:
-                                                                Float64}
+                                                                           Float64}
     PREALLOCATED_CHOLMOD
 end
 
@@ -298,7 +299,7 @@ function LinearSolve.init_cacheval(alg::CHOLMODFactorization,
         Pl, Pr,
         maxiters::Int, abstol, reltol,
         verbose::LinearVerbosity, assumptions::OperatorAssumptions) where {T <:
-                                                                BLASELTYPES}
+                                                                           BLASELTYPES}
     cholesky(sparse(reshape([one(T)], 1, 1)))
 end
 
diff --git a/src/LinearSolve.jl b/src/LinearSolve.jl
@@ -21,7 +21,8 @@ using SciMLBase: SciMLBase, LinearAliasSpecifier, AbstractSciMLOperator,
 using SciMLOperators: SciMLOperators, AbstractSciMLOperator, IdentityOperator,
                       MatrixOperator,
                       has_ldiv!, issquare
-using SciMLVerbosity: Verbosity, @SciMLMessage, @match, AbstractVerbositySpecifier, verbosity_to_int
+using SciMLVerbosity: Verbosity, @SciMLMessage, @match, AbstractVerbositySpecifier,
+                      verbosity_to_int
 using Setfield: @set, @set!
 using UnPack: @unpack
 using DocStringExtensions: DocStringExtensions
@@ -231,7 +232,8 @@ error_no_cudss_lu(A) = nothing
 cudss_loaded(A) = false
 is_cusparse(A) = false
 
-export LinearVerbosity, LinearErrorControlVerbosity, LinearPerformanceVerbosity, LinearNumericalVerbosity
+export LinearVerbosity, LinearErrorControlVerbosity, LinearPerformanceVerbosity,
+       LinearNumericalVerbosity
 
 export LUFactorization, SVDFactorization, QRFactorization, GenericFactorization,
        GenericLUFactorization, SimpleLUFactorization, RFLUFactorization,
diff --git a/src/default.jl b/src/default.jl
@@ -365,8 +365,8 @@ end
             newex = quote
                 sol = SciMLBase.solve!(cache, $(algchoice_to_alg(alg)), args...; kwargs...)
                 if sol.retcode === ReturnCode.Failure && alg.safetyfallback
-                    @SciMLMessage("LU factorization failed, falling back to QR factorization. `A` is potentially rank-deficient.", 
-                    cache.verbose, :default_lu_fallback, :error_control)
+                    @SciMLMessage("LU factorization failed, falling back to QR factorization. `A` is potentially rank-deficient.",
+                        cache.verbose, :default_lu_fallback, :error_control)
 
                     sol = SciMLBase.solve!(
                         cache, QRFactorization(ColumnNorm()), args...; kwargs...)
diff --git a/src/factorization.jl b/src/factorization.jl
@@ -385,7 +385,8 @@ function init_cacheval(alg::CholeskyFactorization, A::SMatrix{S1, S2}, b, u, Pl,
 end
 
 function init_cacheval(alg::CholeskyFactorization, A::GPUArraysCore.AnyGPUArray, b, u, Pl,
-        Pr, maxiters::Int, abstol, reltol, verbose::LinearVerbosity, assumptions::OperatorAssumptions)
+        Pr, maxiters::Int, abstol, reltol, verbose::LinearVerbosity,
+        assumptions::OperatorAssumptions)
     cholesky(A; check = false)
 end
 
diff --git a/src/iterative_wrappers.jl b/src/iterative_wrappers.jl
@@ -335,5 +335,3 @@ function SciMLBase.solve!(cache::LinearCache, alg::KrylovJL; kwargs...)
     return SciMLBase.build_linear_solution(alg, cache.u, Ref(resid), cache;
         iters = stats.niter, retcode, stats)
 end
-
-
diff --git a/src/verbosity.jl b/src/verbosity.jl
@@ -181,4 +181,4 @@ function LinearVerbosity(;
 
     LinearVerbosity{true}(error_control_verbosity,
         performance_verbosity, numerical_verbosity)
-end
+end
diff --git a/test/hypretests.jl b/test/hypretests.jl
@@ -79,7 +79,8 @@ function test_interface(alg; kw...)
 
     atol = 1e-6
     rtol = 1e-6
-    cache_kwargs = (; verbose = LinearVerbosity(), abstol = atol, reltol = rtol, maxiters = 50)
+    cache_kwargs = (;
+        verbose = LinearVerbosity(), abstol = atol, reltol = rtol, maxiters = 50)
     cache_kwargs = merge(cache_kwargs, kw)
 
     # prob1, prob3 with initial guess, prob2, prob4 without
@@ -88,7 +89,7 @@ function test_interface(alg; kw...)
 
         # Solve prob directly (without cache)
         y = solve(prob, alg; cache_kwargs..., Pl = HYPRE.BoomerAMG)
-        @test A * to_array(y.u)≈b atol=atol rtol=rtol
+        @test A*to_array(y.u)≈b atol=atol rtol=rtol
         @test y.iters > 0
         @test y.resid < rtol
 
@@ -100,7 +101,7 @@ function test_interface(alg; kw...)
         cache = y.cache
         @test cache.isfresh == cache.cacheval.isfresh_A ==
               cache.cacheval.isfresh_b == cache.cacheval.isfresh_u == false
-        @test A * to_array(y.u)≈b atol=atol rtol=rtol
+        @test A*to_array(y.u)≈b atol=atol rtol=rtol
 
         # Update A
         cache.A = A
@@ -110,7 +111,7 @@ function test_interface(alg; kw...)
         cache = y.cache
         @test cache.isfresh == cache.cacheval.isfresh_A ==
               cache.cacheval.isfresh_b == cache.cacheval.isfresh_u == false
-        @test A * to_array(y.u)≈b atol=atol rtol=rtol
+        @test A*to_array(y.u)≈b atol=atol rtol=rtol
 
         # Update b
         b2 = 2 * to_array(b)
@@ -124,7 +125,7 @@ function test_interface(alg; kw...)
         cache = y.cache
         @test cache.isfresh == cache.cacheval.isfresh_A ==
               cache.cacheval.isfresh_b == cache.cacheval.isfresh_u == false
-        @test A * to_array(y.u)≈to_array(b2) atol=atol rtol=rtol
+        @test A*to_array(y.u)≈to_array(b2) atol=atol rtol=rtol
     end
     return
 end
diff --git a/test/verbosity.jl b/test/verbosity.jl
@@ -10,13 +10,18 @@ A = [1.0 0 0 0
 b = rand(4)
 prob = LinearProblem(A, b)
 
-@test_logs (:warn, "LU factorization failed, falling back to QR factorization. `A` is potentially rank-deficient.") solve(prob, 
-verbose=LinearVerbosity(default_lu_fallback=Verbosity.Warn()))
+@test_logs (:warn,
+    "LU factorization failed, falling back to QR factorization. `A` is potentially rank-deficient.") solve(
+    prob,
+    verbose = LinearVerbosity(default_lu_fallback = Verbosity.Warn()))
 
-@test_logs (:warn, "LU factorization failed, falling back to QR factorization. `A` is potentially rank-deficient.") solve(
+@test_logs (:warn,
+    "LU factorization failed, falling back to QR factorization. `A` is potentially rank-deficient.") solve(
     prob, verbose = true)
 
 @test_logs min_level = SciMLVerbosity.Logging.Warn solve(prob, verbose = false)
 
-@test_logs (:info, "LU factorization failed, falling back to QR factorization. `A` is potentially rank-deficient.") solve(prob, 
-verbose=LinearVerbosity(default_lu_fallback=Verbosity.Info()))
+@test_logs (:info,
+    "LU factorization failed, falling back to QR factorization. `A` is potentially rank-deficient.") solve(
+    prob,
+    verbose = LinearVerbosity(default_lu_fallback = Verbosity.Info()))
