added functionality + test to add a custom callback and interrupt the… (#843)

* added functionality + test to add a custom callback and interrupt the solving

* fix types

Author: pchtsp

pulp/apis/highs_api.py

@@ -3,7 +3,7 @@
 import os
 import subprocess
 from math import inf
-from typing import List
+from typing import List, Optional
 
 from .. import constants
 from .core import LpSolver, LpSolver_CMD, PulpSolverError
@@ -271,13 +271,17 @@ def readsol(self, filename):
         return values
 
 
+highspy = None
+
+
 class HiGHS(LpSolver):
     name = "HiGHS"
 
     try:
         global highspy
         import highspy  # type: ignore[import-not-found, import-untyped, unused-ignore]
     except:
+        hscb = None
 
         def available(self):
             """True if the solver is available"""
@@ -288,13 +292,7 @@ def actualSolve(self, lp, callback=None):
             raise PulpSolverError("HiGHS: Not Available")
 
     else:
-        # Note(maciej): It was surprising to me that higshpy wasn't logging out of the box,
-        #  even with the different logging options set. This callback seems to work, but there
-        #  are probably better ways of doing this ¯\_(ツ)_/¯
-        DEFAULT_CALLBACK = lambda logType, logMsg, callbackValue: print(
-            f"[{logType.name}] {logMsg}"
-        )
-        DEFAULT_CALLBACK_VALUE = ""
+        hscb = highspy.cb  # type: ignore[attr-defined, unused-ignore]
 
         def __init__(
             self,
@@ -305,21 +303,23 @@ def __init__(
             gapRel=None,
             threads=None,
             timeLimit=None,
+            callbacksToActivate: Optional[List[highspy.cb.HighsCallbackType]] = None,
             **solverParams,
         ):
             """
             :param bool mip: if False, assume LP even if integer variables
             :param bool msg: if False, no log is shown
-            :param tuple callbackTuple: Tuple of log callback function (see DEFAULT_CALLBACK above for definition)
-                and callbackValue (tag embedded in every callback)
+            :param tuple callbackTuple: Tuple of callback function and callbackValue (see tests for an example)
             :param float gapRel: relative gap tolerance for the solver to stop (in fraction)
             :param float gapAbs: absolute gap tolerance for the solver to stop
             :param int threads: sets the maximum number of threads
             :param float timeLimit: maximum time for solver (in seconds)
             :param dict solverParams: list of named options to pass directly to the HiGHS solver
+            :param callbacksToActivate: list of callback types to start
             """
             super().__init__(mip=mip, msg=msg, timeLimit=timeLimit, **solverParams)
             self.callbackTuple = callbackTuple
+            self.callbacksToActivate = callbacksToActivate
             self.gapAbs = gapAbs
             self.gapRel = gapRel
             self.threads = threads
@@ -333,12 +333,12 @@ def callSolver(self, lp):
         def createAndConfigureSolver(self, lp):
             lp.solverModel = highspy.Highs()
 
-            if self.msg and self.callbackTuple:
-                callbackTuple = self.callbackTuple or (
-                    HiGHS.DEFAULT_CALLBACK,
-                    HiGHS.DEFAULT_CALLBACK_VALUE,
-                )
-                lp.solverModel.setLogCallback(*callbackTuple)
+            if self.callbackTuple:
+                lp.solverModel.setCallback(*self.callbackTuple)
+
+            if self.callbacksToActivate:
+                for cb_type in self.callbacksToActivate:
+                    lp.solverModel.startCallback(cb_type)
 
             if not self.msg:
                 lp.solverModel.setOptionValue("output_flag", False)
@@ -465,6 +465,10 @@ def findSolutionValues(self, lp):
                     constants.LpStatusOptimal,
                     constants.LpSolutionIntegerFeasible,
                 ),
+                HighsModelStatus.kInterrupt: (
+                    constants.LpStatusOptimal,
+                    constants.LpSolutionIntegerFeasible,
+                ),
                 HighsModelStatus.kTimeLimit: (
                     constants.LpStatusOptimal,
                     constants.LpSolutionIntegerFeasible,

pulp/tests/test_pulp.py

@@ -2194,6 +2194,36 @@ class SCIP_PYTest(BaseSolverTest.PuLPTest):
 class HiGHS_PYTest(BaseSolverTest.PuLPTest):
     solveInst = HiGHS
 
+    def test_callback(self):
+        prob = create_bin_packing_problem(bins=40, seed=99)
+
+        # we pass a list as data to the tuple, so we can edit it.
+        # then we count the number of calls and stop the solving
+        # for more information on the callback, see: github.com/ERGO-Code/HiGHS @ examples/call_highs_from_python
+        def user_callback(
+            callback_type, message, data_out, data_in, user_callback_data
+        ):
+            #
+            if callback_type == HiGHS.hscb.HighsCallbackType.kCallbackMipInterrupt:
+                print(
+                    f"userInterruptCallback(type {callback_type}); "
+                    f"data {user_callback_data};"
+                    f"message: {message};"
+                    f"objective {data_out.objective_function_value:.4g};"
+                )
+                print(f"Dual bound = {data_out.mip_dual_bound:.4g}")
+                print(f"Primal bound = {data_out.mip_primal_bound:.4g}")
+                print(f"Gap = {data_out.mip_gap:.4g}")
+                if isinstance(user_callback_data, list):
+                    user_callback_data.append(1)
+                    data_in.user_interrupt = len(user_callback_data) > 5
+
+        solver = HiGHS(
+            callbackTuple=(user_callback, []),
+            callbacksToActivate=[HiGHS.hscb.HighsCallbackType.kCallbackMipInterrupt],
+        )
+        status = prob.solve(solver)
+
 
 class HiGHS_CMDTest(BaseSolverTest.PuLPTest):
     solveInst = HiGHS_CMD