Some more modifs due to Guillaume comments

src/Algorithm/conquer.jl

@@ -126,9 +126,10 @@ end
 
     Column-and-cut-generation based algorithm to find primal and dual bounds for a 
     problem decomposed using Dantzig-Wolfe paradigm. It applies `stages` of the column generation 
-    algorithm (for example, the exact stage and the heuristic stage), `cutgen` for the cut 
-    generation phase, and it can apply several primal
-    heuristics to more efficiently find feasible solutions.
+    algorithm. Stages are called in the reverse order of vector `stages`. So usually, first stage
+    is the one with exact pricing, and other stages use heuristic pricing (the higher is stage, 
+    the faster is the heuristic). It applies `cutgen` for the cut generation phase. It can apply 
+    several primal heuristics to more efficiently find feasible solutions.
 """
 @with_kw struct ColCutGenConquer <: AbstractConquerAlgorithm 
     stages::Vector{ColumnGeneration} = [ColumnGeneration()]

src/Algorithm/pricing.jl

@@ -1,13 +1,13 @@
 @with_kw struct DefaultPricing <: AbstractOptimizationAlgorithm
-    callbackalg::PricingCallback = PricingCallback()
-    MIPalg::SolveIpForm = SolveIpForm(deactivate_artificial_vars=false, enforce_integrality=false, log_level=2)
+    pricing_callback::PricingCallback = PricingCallback()
+    solve_ip_form::SolveIpForm = SolveIpForm(deactivate_artificial_vars=false, enforce_integrality=false, log_level=2)
     dispatch::Int = 0 # 0 - automatic, 1 - impose pricing callback, 2 - impose pricing by MIP 
 end
 
 function get_child_algorithms(algo::DefaultPricing, spform::Formulation{DwSp}) 
     child_algs = Tuple{AbstractAlgorithm,AbstractModel}[]
-    algo.dispatch != 2 && push!(child_algs, (algo.callbackalg, spform))
-    algo.dispatch != 1 && push!(child_algs, (algo.MIPalg, spform))
+    algo.dispatch != 2 && push!(child_algs, (algo.pricing_callback, spform))
+    algo.dispatch != 1 && push!(child_algs, (algo.solve_ip_form, spform))
     return child_algs
 end 
 
@@ -18,8 +18,8 @@ function run!(algo::DefaultPricing, env::Env, spform::Formulation{DwSp}, input::
     end 
 
     if algo.dispatch != 2 && isa(getuseroptimizer(spform), UserOptimizer)
-        return run!(algo.callbackalg, env, spform, input)
+        return run!(algo.pricing_callback, env, spform, input)
     end
 
-    return run!(algo.MIPalg, env, spform, input)
+    return run!(algo.solve_ip_form, env, spform, input)
 end

src/decomposition.jl

@@ -432,13 +432,6 @@ function getmoioptbuilder(prob::Problem, ann::BD.Annotation)
     return prob.default_optimizer_builder
 end
 
-function getuseroptbuilder(prob::Problem, ann::BD.Annotation)
-    if BD.getpricingoracle(ann) !== nothing
-        return () -> UserOptimizer(BD.getpricingoracle(ann))
-    end
-    return prob.default_optimizer_builder
-end
-
 function buildformulations!(
     prob::Problem, reform::Reformulation, env::Env, annotations::Annotations, parent,
     node::BD.Root

test/pricing_callback_tests.jl

@@ -11,11 +11,11 @@ function pricing_callback_tests()
                     conqueralg = ClA.ColCutGenConquer(
                         stages = [ClA.ColumnGeneration(
                                     pricing_prob_solve_alg = ClA.DefaultPricing(
-                                        dispatch=1, callbackalg = PricingCallback(stage=1) 
+                                        dispatch=1, pricing_callback = PricingCallback(stage=1) 
                                     )),
                                   ClA.ColumnGeneration(
                                     pricing_prob_solve_alg = ClA.DefaultPricing(
-                                        dispatch=1, callbackalg = PricingCallback(stage=2) 
+                                        dispatch=1, pricing_callback = PricingCallback(stage=2) 
                                     ))
                                  ]
                     )