Removed Python specific error messages and cleaned up HiPO logging in HighsOptions to remove redundancy.

mathgeekcoder · mathgeekcoder · commit 21c386b218e8 · 2026-04-30T17:16:27.000-07:00
The new error message is also more generic, in case future algorithms need these external dependencies.
diff --git a/check/TestHighsExternalDeps.cpp b/check/TestHighsExternalDeps.cpp
@@ -22,10 +22,14 @@ TEST_CASE("HighsExternalDeps-compile-time", "[highs_external_deps]") {
   // isAvailableAtCompile should be consistent with build config
   bool compile = HighsExternalDeps::isAvailableAtCompile();
 
-  // If compile-time available, runtime must also be available
+// If compile-time aware and statically linked, it must be available
+// If compile-time aware and dynamically linked, it may or may not be available
+// at runtime
+#if !defined(HIGHS_SHARED_EXTRAS_LIBRARY)
   if (compile) {
     REQUIRE(HighsExternalDeps::isAvailable());
   }
+#endif
 }
 
 TEST_CASE("HighsExternalDeps-getCopyrightInfo", "[highs_external_deps]") {
diff --git a/highs/HighsExternalDeps.cpp b/highs/HighsExternalDeps.cpp
@@ -29,6 +29,32 @@ bool HighsExternalDeps::tryLoad() {
   return tryLoad(empty_path);
 }
 
+void HighsExternalDeps::logUnavailable(const HighsLogOptions& log_options,
+                                       const HighsLogType type,
+                                       const char* format, ...) {
+  if (!isAvailable()) {
+    va_list argptr;
+    va_start(argptr, format);
+    std::array<char, kIoBufferSize> msgbuffer = {};
+    int len = vsnprintf(msgbuffer.data(), msgbuffer.size(), format, argptr);
+    va_end(argptr);
+
+    if (!isAvailableAtCompile()) {
+      highsLogUser(log_options, type, "%s%s%s", msgbuffer.data(),
+                   (len > 0) ? " " : "",
+                   "This build was compiled without external dependencies. "
+                   "Reconfigure with -DHIPO=ON to enable.\n");
+    } else {
+      highsLogUser(
+          log_options, type, "%s%s%s", msgbuffer.data(), (len > 0) ? " " : "",
+          "The external dependencies are missing. Please install "
+          "highs_extras library. For example, in Python use `pip install "
+          "highspy[extras]`. Note, this changes the HiGHS license from MIT "
+          "to Apache, due to the dependencies' licensing.\n");
+    }
+  }
+}
+
 #ifdef HIGHS_SHARED_EXTRAS_LIBRARY
 // Platform-specific includes for dynamic loading
 #if defined(_WIN32) || defined(_WIN64)
@@ -171,9 +197,7 @@ bool HighsExternalDeps::tryLoad(const std::string& path) {
         std::string extras_version = get_version();
         if (extras_version != highs_version) {
           inst.status_ = "Extras: ABI version mismatch: expected " +
-                         highs_version + ", got " + extras_version +
-                         ". Please reinstall: pip install --force-reinstall "
-                         "highspy[extras]";
+                         highs_version + ", got " + extras_version + ".";
           inst.unload();
           ok = false;
         } else {
diff --git a/highs/HighsExternalDeps.h b/highs/HighsExternalDeps.h
@@ -13,6 +13,7 @@
 #include <string>
 
 #include "HighsExtrasApi.h"
+#include "io/HighsIO.h"
 #include "rcm/rcm.h"
 #include "util/HighsInt.h"
 
@@ -199,6 +200,9 @@ struct HighsExternalDeps {
   HighsExternalDeps& operator=(const HighsExternalDeps&) = delete;
 
   static bool tryLoad();
+  static void logUnavailable(const HighsLogOptions& log_options,
+                             const HighsLogType type, const char* format = "",
+                             ...);
 
 // Exclude dependencies
 #ifndef HIPO
@@ -215,7 +219,7 @@ struct HighsExternalDeps {
 // Shared library support
 #elif defined(HIGHS_SHARED_EXTRAS_LIBRARY)
   static inline bool isAvailable() { return tryLoad(); }
-  static constexpr bool isAvailableAtCompile() { return false; }
+  static constexpr bool isAvailableAtCompile() { return true; }
 
   static bool tryLoad(const std::string& path);
   static void unload();
@@ -234,7 +238,6 @@ struct HighsExternalDeps {
   static inline const std::string getLoadStatus() {
     return "Extras: Available at compile time";
   }
-
 #endif
 
  private:
diff --git a/highs/lp_data/HighsOptions.cpp b/highs/lp_data/HighsOptions.cpp
@@ -81,120 +81,83 @@ bool optionOffOnOk(const HighsLogOptions& report_log_options,
 
 bool optionSolverOk(const HighsLogOptions& report_log_options,
                     const string& value) {
-  if (value == kHipoString && !HighsExternalDeps::isAvailable()) {
-    if (HighsExternalDeps::isAvailableAtCompile()) {
-      highsLogUser(
-          report_log_options, HighsLogType::kError,
-          "The HiPO solver was requested via the \"%s\" option, but this build "
-          "was compiled without HiPO support. Reconfigure with FAST_BUILD=ON "
-          "and -DHIPO=ON to enable HiPO.\n",
-          kSolverString.c_str());
-    } else {
-      highsLogUser(
-          report_log_options, HighsLogType::kError,
-          "The HiPO solver was requested via the \"%s\" option, but the "
-          "HiPO dependencies are missing. Install with highspy[hipo] or "
-          "install "
-          "highspy-extras. Note, that using HiPO changes the HiGHS license "
-          "from "
-          " MIT to Apache, due to the dependencies' licensing.\n",
-          kSolverString.c_str());
-    }
-    return false;
-  }
   if (value == kHighsChooseString || value == kSimplexString ||
       value == kIpmString ||
       (value == kHipoString && HighsExternalDeps::isAvailable()) ||
       value == kIpxString || value == kPdlpString || value == kQpAsmString ||
       value == kHiPdlpString)
     return true;
-  highsLogUser(
-      report_log_options, HighsLogType::kWarning,
-      "Value \"%s\" for LP solver option (\"%s\") is not one of "
-      "%s\"%s\", \"%s\", \"%s\", \"%s\" or \"%s\"\n",
-      value.c_str(), kSolverString.c_str(),
-      HighsExternalDeps::isAvailable() ? (kHipoString + "\", \"").c_str() : "",
-      kHighsChooseString.c_str(), kSimplexString.c_str(), kIpmString.c_str(),
-      kIpxString.c_str(), kPdlpString.c_str(), kQpAsmString.c_str(),
-      kHiPdlpString.c_str());
-  return false;
+  else if (value == kHipoString && !HighsExternalDeps::isAvailable()) {
+    HighsExternalDeps::logUnavailable(
+        report_log_options, HighsLogType::kError,
+        "The HiPO solver was requested via the \"%s\" option.",
+        kSolverString.c_str());
+    return false;
+  } else {
+    highsLogUser(report_log_options, HighsLogType::kWarning,
+                 "Value \"%s\" for LP solver option (\"%s\") is not one of "
+                 "%s\"%s\", \"%s\", \"%s\", \"%s\" or \"%s\"\n",
+                 value.c_str(), kSolverString.c_str(),
+                 HighsExternalDeps::isAvailable()
+                     ? (kHipoString + "\", \"").c_str()
+                     : "",
+                 kHighsChooseString.c_str(), kSimplexString.c_str(),
+                 kIpmString.c_str(), kIpxString.c_str(), kPdlpString.c_str(),
+                 kQpAsmString.c_str(), kHiPdlpString.c_str());
+    return false;
+  }
 }
 
 bool optionMipLpSolverOk(const HighsLogOptions& report_log_options,
                          const string& value) {
-  if (value == kHipoString && !HighsExternalDeps::isAvailable()) {
-    if (HighsExternalDeps::isAvailableAtCompile()) {
-      highsLogUser(
-          report_log_options, HighsLogType::kError,
-          "The HiPO solver was requested via the \"%s\" option, but this build "
-          "was compiled without HiPO support. Reconfigure with FAST_BUILD=ON "
-          "and -DHIPO=ON to enable HiPO.\n",
-          kMipLpSolverString.c_str());
-    } else {
-      highsLogUser(
-          report_log_options, HighsLogType::kError,
-          "The HiPO solver was requested via the \"%s\" option, but the "
-          "HiPO dependencies are missing. Install with highspy[hipo] or "
-          "install "
-          "highspy-extras. Note, that using HiPO changes the HiGHS license "
-          "from "
-          "MIT to Apache, due to the dependencies' licensing.\n",
-          kMipLpSolverString.c_str());
-    }
-    return false;
-  }
-
   if (value == kHighsChooseString || value == kSimplexString ||
       value == kIpmString ||
       (value == kHipoString && HighsExternalDeps::isAvailable()) ||
       value == kIpxString)
     return true;
-  highsLogUser(
-      report_log_options, HighsLogType::kError,
-      "Value \"%s\" for MIP LP solver option (\"%s\") is not one of "
-      "%s\"%s\", \"%s\", \"%s\" or \"%s\"\n",
-      value.c_str(), kMipLpSolverString.c_str(),
-      HighsExternalDeps::isAvailable() ? (kHipoString + "\", \"").c_str() : "",
-      kHighsChooseString.c_str(), kSimplexString.c_str(), kIpmString.c_str(),
-      kIpxString.c_str());
-  return false;
+  else if (value == kHipoString && !HighsExternalDeps::isAvailable()) {
+    HighsExternalDeps::logUnavailable(
+        report_log_options, HighsLogType::kError,
+        "The HiPO solver was requested via the \"%s\" option.",
+        kMipLpSolverString.c_str());
+    return false;
+  } else {
+    highsLogUser(report_log_options, HighsLogType::kError,
+                 "Value \"%s\" for MIP LP solver option (\"%s\") is not one of "
+                 "%s\"%s\", \"%s\", \"%s\" or \"%s\"\n",
+                 value.c_str(), kMipLpSolverString.c_str(),
+                 HighsExternalDeps::isAvailable()
+                     ? (kHipoString + "\", \"").c_str()
+                     : "",
+                 kHighsChooseString.c_str(), kSimplexString.c_str(),
+                 kIpmString.c_str(), kIpxString.c_str());
+    return false;
+  }
 }
 
 bool optionMipIpmSolverOk(const HighsLogOptions& report_log_options,
                           const string& value) {
-  if (value == kHipoString && !HighsExternalDeps::isAvailable()) {
-    if (HighsExternalDeps::isAvailableAtCompile()) {
-      highsLogUser(
-          report_log_options, HighsLogType::kError,
-          "The HiPO solver was requested via the \"%s\" option, but this build "
-          "was compiled without HiPO support. Reconfigure with FAST_BUILD=ON "
-          "and -DHIPO=ON to enable HiPO.\n",
-          kMipIpmSolverString.c_str());
-    } else {
-      highsLogUser(
-          report_log_options, HighsLogType::kError,
-          "The HiPO solver was requested via the \"%s\" option, but the "
-          "HiPO dependencies are missing. Install with highspy[hipo] or "
-          "install "
-          "highspy-extras. Note, that using HiPO changes the HiGHS license "
-          "from "
-          "MIT to Apache, due to the dependencies' licensing.\n",
-          kMipIpmSolverString.c_str());
-    }
-    return false;
-  }
   if (value == kHighsChooseString || value == kIpmString ||
       (value == kHipoString && HighsExternalDeps::isAvailable()) ||
       value == kIpxString)
     return true;
-  highsLogUser(
-      report_log_options, HighsLogType::kError,
-      "Value \"%s\" for MIP IPM solver (\"%s\") option is not one of "
-      "%s\"%s\", \"%s\" or \"%s\"\n",
-      value.c_str(), kMipIpmSolverString.c_str(),
-      HighsExternalDeps::isAvailable() ? (kHipoString + "\", \"").c_str() : "",
-      kHighsChooseString.c_str(), kIpmString.c_str(), kIpxString.c_str());
-  return false;
+  else if (value == kHipoString && !HighsExternalDeps::isAvailable()) {
+    HighsExternalDeps::logUnavailable(
+        report_log_options, HighsLogType::kError,
+        "The HiPO solver was requested via the \"%s\" option.",
+        kMipIpmSolverString.c_str());
+    return false;
+  } else {
+    highsLogUser(
+        report_log_options, HighsLogType::kError,
+        "Value \"%s\" for MIP IPM solver (\"%s\") option is not one of "
+        "%s\"%s\", \"%s\" or \"%s\"\n",
+        value.c_str(), kMipIpmSolverString.c_str(),
+        HighsExternalDeps::isAvailable() ? (kHipoString + "\", \"").c_str()
+                                         : "",
+        kHighsChooseString.c_str(), kIpmString.c_str(), kIpxString.c_str());
+    return false;
+  }
 }
 
 bool optionHipoParallelTypeOk(const HighsLogOptions& report_log_options,
@@ -389,11 +352,10 @@ OptionStatus checkOptions(const HighsLogOptions& report_log_options,
 OptionStatus checkOption(const HighsLogOptions& report_log_options,
                          const OptionRecordInt& option) {
   if (option.lower_bound > option.upper_bound) {
-    highsLogUser(
-        report_log_options, HighsLogType::kError,
-        "checkOption: Option \"%s\" has inconsistent bounds [%" HIGHSINT_FORMAT
-        ", %" HIGHSINT_FORMAT "]\n",
-        option.name.c_str(), option.lower_bound, option.upper_bound);
+    highsLogUser(report_log_options, HighsLogType::kError,
+                 "checkOption: Option \"%s\" has inconsistent bounds "
+                 "[%" HIGHSINT_FORMAT ", %" HIGHSINT_FORMAT "]\n",
+                 option.name.c_str(), option.lower_bound, option.upper_bound);
     return OptionStatus::kIllegalValue;
   }
   if (option.default_value < option.lower_bound ||
@@ -614,10 +576,10 @@ OptionStatus setLocalOptionValue(const HighsLogOptions& report_log_options,
     bool value_bool;
     bool return_status = boolFromString(value_trim, value_bool);
     if (!return_status) {
-      highsLogUser(
-          report_log_options, HighsLogType::kError,
-          "setLocalOptionValue: Value \"%s\" cannot be interpreted as a bool\n",
-          value_trim.c_str());
+      highsLogUser(report_log_options, HighsLogType::kError,
+                   "setLocalOptionValue: Value \"%s\" cannot be interpreted "
+                   "as a bool\n",
+                   value_trim.c_str());
       return OptionStatus::kIllegalValue;
     }
     return setLocalOptionValue(((OptionRecordBool*)option_records[index])[0],
@@ -1135,13 +1097,13 @@ void reportOption(FILE* file, const HighsLogOptions& log_options,
 
   if (!report_only_deviations || option.default_value != *option.value) {
     if (file_type == HighsFileType::kMd) {
-      fprintf(
-          file,
-          "## [%s](@id option-%s)\n- %s\n- Type: string\n- Default: \"%s\"\n\n",
-          highsInsertMdEscapes(option.name).c_str(),
-          highsInsertMdId(option.name).c_str(),
-          highsInsertMdEscapes(option.description).c_str(),
-          option.default_value.c_str());
+      fprintf(file,
+              "## [%s](@id option-%s)\n- %s\n- Type: string\n- Default: "
+              "\"%s\"\n\n",
+              highsInsertMdEscapes(option.name).c_str(),
+              highsInsertMdId(option.name).c_str(),
+              highsInsertMdEscapes(option.description).c_str(),
+              option.default_value.c_str());
     } else if (file_type == HighsFileType::kFull) {
       fprintf(file, "\n# %s\n", option.description.c_str());
       fprintf(file, "# [type: string, advanced: %s, default: \"%s\"]\n",

Original file line number	Diff line number	Diff line change
`@@ -22,10 +22,14 @@ TEST_CASE("HighsExternalDeps-compile-time", "[highs_external_deps]") {`
`22`	`22`	`// isAvailableAtCompile should be consistent with build config`
`23`	`23`	`bool compile = HighsExternalDeps::isAvailableAtCompile();`
`24`	`24`
`25`		`- // If compile-time available, runtime must also be available`
	`25`	`+// If compile-time aware and statically linked, it must be available`
	`26`	`+// If compile-time aware and dynamically linked, it may or may not be available`
	`27`	`+// at runtime`
	`28`	`+#if !defined(HIGHS_SHARED_EXTRAS_LIBRARY)`
`26`	`29`	`if (compile) {`
`27`	`30`	`REQUIRE(HighsExternalDeps::isAvailable());`
`28`	`31`	`}`
	`32`	`+#endif`
`29`	`33`	`}`
`30`	`34`
`31`	`35`	`TEST_CASE("HighsExternalDeps-getCopyrightInfo", "[highs_external_deps]") {`