Skip to content

Commit

Permalink
BIND: Use module local scope for exports
Browse files Browse the repository at this point in the history
  • Loading branch information
@HaoZeke
HaoZeke committed Jul 20, 2024
1 parent 1ca6719 commit 8dc335e
Showing 1 changed file with 38 additions and 37 deletions.
75 changes: 38 additions & 37 deletions src/highs_bindings.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -580,28 +580,28 @@ std::tuple<HighsStatus, int> highs_getRowByName(Highs* h,
PYBIND11_MODULE(_core, m) {
// enumerations
// Older enums, need to have values exported
py::enum_<SolutionStatus>(m, "SolutionStatus")
py::enum_<SolutionStatus>(m, "SolutionStatus", py::module_local())
.value("kSolutionStatusNone", SolutionStatus::kSolutionStatusNone)
.value("kSolutionStatusInfeasible",
SolutionStatus::kSolutionStatusInfeasible)
.value("kSolutionStatusFeasible", SolutionStatus::kSolutionStatusFeasible)
.export_values();
py::enum_<BasisValidity>(m, "BasisValidity")
py::enum_<BasisValidity>(m, "BasisValidity", py::module_local())
.value("kBasisValidityInvalid", BasisValidity::kBasisValidityInvalid)
.value("kBasisValidityValid", BasisValidity::kBasisValidityValid)
.export_values();
// C++ enum classes do not need to have values exported
py::enum_<ObjSense>(m, "ObjSense")
py::enum_<ObjSense>(m, "ObjSense", py::module_local())
.value("kMinimize", ObjSense::kMinimize)
.value("kMaximize", ObjSense::kMaximize);
py::enum_<MatrixFormat>(m, "MatrixFormat")
py::enum_<MatrixFormat>(m, "MatrixFormat", py::module_local())
.value("kColwise", MatrixFormat::kColwise)
.value("kRowwise", MatrixFormat::kRowwise)
.value("kRowwisePartitioned", MatrixFormat::kRowwisePartitioned);
py::enum_<HessianFormat>(m, "HessianFormat")
py::enum_<HessianFormat>(m, "HessianFormat", py::module_local())
.value("kTriangular", HessianFormat::kTriangular)
.value("kSquare", HessianFormat::kSquare);
py::enum_<HighsModelStatus>(m, "HighsModelStatus")
py::enum_<HighsModelStatus>(m, "HighsModelStatus", py::module_local())
.value("kNotset", HighsModelStatus::kNotset)
.value("kLoadError", HighsModelStatus::kLoadError)
.value("kModelError", HighsModelStatus::kModelError)
Expand All @@ -621,7 +621,7 @@ PYBIND11_MODULE(_core, m) {
.value("kSolutionLimit", HighsModelStatus::kSolutionLimit)
.value("kInterrupt", HighsModelStatus::kInterrupt)
.value("kMemoryLimit", HighsModelStatus::kMemoryLimit);
py::enum_<HighsPresolveStatus>(m, "HighsPresolveStatus")
py::enum_<HighsPresolveStatus>(m, "HighsPresolveStatus", py::module_local())
.value("kNotPresolved", HighsPresolveStatus::kNotPresolved)
.value("kNotReduced", HighsPresolveStatus::kNotReduced)
.value("kInfeasible", HighsPresolveStatus::kInfeasible)
Expand All @@ -632,38 +632,38 @@ PYBIND11_MODULE(_core, m) {
.value("kTimeout", HighsPresolveStatus::kTimeout)
.value("kNullError", HighsPresolveStatus::kNullError)
.value("kOptionsError", HighsPresolveStatus::kOptionsError);
py::enum_<HighsBasisStatus>(m, "HighsBasisStatus")
py::enum_<HighsBasisStatus>(m, "HighsBasisStatus", py::module_local())
.value("kLower", HighsBasisStatus::kLower)
.value("kBasic", HighsBasisStatus::kBasic)
.value("kUpper", HighsBasisStatus::kUpper)
.value("kZero", HighsBasisStatus::kZero)
.value("kNonbasic", HighsBasisStatus::kNonbasic);
py::enum_<HighsVarType>(m, "HighsVarType")
py::enum_<HighsVarType>(m, "HighsVarType", py::module_local())
.value("kContinuous", HighsVarType::kContinuous)
.value("kInteger", HighsVarType::kInteger)
.value("kSemiContinuous", HighsVarType::kSemiContinuous)
.value("kSemiInteger", HighsVarType::kSemiInteger);
py::enum_<HighsOptionType>(m, "HighsOptionType")
py::enum_<HighsOptionType>(m, "HighsOptionType", py::module_local())
.value("kBool", HighsOptionType::kBool)
.value("kInt", HighsOptionType::kInt)
.value("kDouble", HighsOptionType::kDouble)
.value("kString", HighsOptionType::kString);
py::enum_<HighsInfoType>(m, "HighsInfoType")
py::enum_<HighsInfoType>(m, "HighsInfoType", py::module_local())
.value("kInt64", HighsInfoType::kInt64)
.value("kInt", HighsInfoType::kInt)
.value("kDouble", HighsInfoType::kDouble);
py::enum_<HighsStatus>(m, "HighsStatus")
py::enum_<HighsStatus>(m, "HighsStatus", py::module_local())
.value("kError", HighsStatus::kError)
.value("kOk", HighsStatus::kOk)
.value("kWarning", HighsStatus::kWarning);
py::enum_<HighsLogType>(m, "HighsLogType")
py::enum_<HighsLogType>(m, "HighsLogType", py::module_local())
.value("kInfo", HighsLogType::kInfo)
.value("kDetailed", HighsLogType::kDetailed)
.value("kVerbose", HighsLogType::kVerbose)
.value("kWarning", HighsLogType::kWarning)
.value("kError", HighsLogType::kError);
// Classes
py::class_<HighsSparseMatrix>(m, "HighsSparseMatrix")
py::class_<HighsSparseMatrix>(m, "HighsSparseMatrix", py::module_local())
.def(py::init<>())
.def_readwrite("format_", &HighsSparseMatrix::format_)
.def_readwrite("num_col_", &HighsSparseMatrix::num_col_)
Expand All @@ -672,7 +672,7 @@ PYBIND11_MODULE(_core, m) {
.def_readwrite("p_end_", &HighsSparseMatrix::p_end_)
.def_readwrite("index_", &HighsSparseMatrix::index_)
.def_readwrite("value_", &HighsSparseMatrix::value_);
py::class_<HighsLp>(m, "HighsLp")
py::class_<HighsLp>(m, "HighsLp", py::module_local())
.def(py::init<>())
.def_readwrite("num_col_", &HighsLp::num_col_)
.def_readwrite("num_row_", &HighsLp::num_row_)
Expand All @@ -692,18 +692,18 @@ PYBIND11_MODULE(_core, m) {
.def_readwrite("is_scaled_", &HighsLp::is_scaled_)
.def_readwrite("is_moved_", &HighsLp::is_moved_)
.def_readwrite("mods_", &HighsLp::mods_);
py::class_<HighsHessian>(m, "HighsHessian")
py::class_<HighsHessian>(m, "HighsHessian", py::module_local())
.def(py::init<>())
.def_readwrite("dim_", &HighsHessian::dim_)
.def_readwrite("format_", &HighsHessian::format_)
.def_readwrite("start_", &HighsHessian::start_)
.def_readwrite("index_", &HighsHessian::index_)
.def_readwrite("value_", &HighsHessian::value_);
py::class_<HighsModel>(m, "HighsModel")
py::class_<HighsModel>(m, "HighsModel", py::module_local())
.def(py::init<>())
.def_readwrite("lp_", &HighsModel::lp_)
.def_readwrite("hessian_", &HighsModel::hessian_);
py::class_<HighsInfo>(m, "HighsInfo")
py::class_<HighsInfo>(m, "HighsInfo", py::module_local())
.def(py::init<>())
.def_readwrite("valid", &HighsInfo::valid)
.def_readwrite("mip_node_count", &HighsInfo::mip_node_count)
Expand Down Expand Up @@ -740,7 +740,7 @@ PYBIND11_MODULE(_core, m) {
&HighsInfo::max_complementarity_violation)
.def_readwrite("sum_complementarity_violations",
&HighsInfo::sum_complementarity_violations);
py::class_<HighsOptions>(m, "HighsOptions")
py::class_<HighsOptions>(m, "HighsOptions", py::module_local())
.def(py::init<>())
.def_readwrite("presolve", &HighsOptions::presolve)
.def_readwrite("solver", &HighsOptions::solver)
Expand Down Expand Up @@ -828,7 +828,7 @@ PYBIND11_MODULE(_core, m) {
&HighsOptions::mip_heuristic_effort)
.def_readwrite("mip_min_logging_interval",
&HighsOptions::mip_min_logging_interval);
py::class_<Highs>(m, "_Highs")
py::class_<Highs>(m, "_Highs", py::module_local())
.def(py::init<>())
.def("version", &Highs::version)
.def("versionMajor", &Highs::versionMajor)
Expand Down Expand Up @@ -967,19 +967,19 @@ PYBIND11_MODULE(_core, m) {
.def("stopCallbackInt", static_cast<HighsStatus (Highs::*)(const int)>(
&Highs::stopCallback));
// structs
py::class_<HighsSolution>(m, "HighsSolution")
py::class_<HighsSolution>(m, "HighsSolution", py::module_local())
.def(py::init<>())
.def_readwrite("value_valid", &HighsSolution::value_valid)
.def_readwrite("dual_valid", &HighsSolution::dual_valid)
.def_readwrite("col_value", &HighsSolution::col_value)
.def_readwrite("col_dual", &HighsSolution::col_dual)
.def_readwrite("row_value", &HighsSolution::row_value)
.def_readwrite("row_dual", &HighsSolution::row_dual);
py::class_<HighsObjectiveSolution>(m, "HighsObjectiveSolution")
py::class_<HighsObjectiveSolution>(m, "HighsObjectiveSolution", py::module_local())
.def(py::init<>())
.def_readwrite("objective", &HighsObjectiveSolution::objective)
.def_readwrite("col_value", &HighsObjectiveSolution::col_value);
py::class_<HighsBasis>(m, "HighsBasis")
py::class_<HighsBasis>(m, "HighsBasis", py::module_local())
.def(py::init<>())
.def_readwrite("valid", &HighsBasis::valid)
.def_readwrite("alien", &HighsBasis::alien)
Expand All @@ -989,13 +989,13 @@ PYBIND11_MODULE(_core, m) {
.def_readwrite("debug_origin_name", &HighsBasis::debug_origin_name)
.def_readwrite("col_status", &HighsBasis::col_status)
.def_readwrite("row_status", &HighsBasis::row_status);
py::class_<HighsRangingRecord>(m, "HighsRangingRecord")
py::class_<HighsRangingRecord>(m, "HighsRangingRecord", py::module_local())
.def(py::init<>())
.def_readwrite("value_", &HighsRangingRecord::value_)
.def_readwrite("objective_", &HighsRangingRecord::objective_)
.def_readwrite("in_var_", &HighsRangingRecord::in_var_)
.def_readwrite("ou_var_", &HighsRangingRecord::ou_var_);
py::class_<HighsRanging>(m, "HighsRanging")
py::class_<HighsRanging>(m, "HighsRanging", py::module_local())
.def(py::init<>())
.def_readwrite("valid", &HighsRanging::valid)
.def_readwrite("col_cost_up", &HighsRanging::col_cost_up)
Expand All @@ -1016,7 +1016,7 @@ PYBIND11_MODULE(_core, m) {
py::module_ simplex_constants =
m.def_submodule("simplex_constants", "Submodule for simplex constants");

py::enum_<SimplexStrategy>(simplex_constants, "SimplexStrategy")
py::enum_<SimplexStrategy>(simplex_constants, "SimplexStrategy", py::module_local())
.value("kSimplexStrategyMin", SimplexStrategy::kSimplexStrategyMin)
.value("kSimplexStrategyChoose", SimplexStrategy::kSimplexStrategyChoose)
.value("kSimplexStrategyDual", SimplexStrategy::kSimplexStrategyDual)
Expand All @@ -1031,7 +1031,7 @@ PYBIND11_MODULE(_core, m) {
.value("kSimplexStrategyNum", SimplexStrategy::kSimplexStrategyNum)
.export_values(); // needed since it isn't an enum class
py::enum_<SimplexUnscaledSolutionStrategy>(simplex_constants,
"SimplexUnscaledSolutionStrategy")
"SimplexUnscaledSolutionStrategy", py::module_local())
.value(
"kSimplexUnscaledSolutionStrategyMin",
SimplexUnscaledSolutionStrategy::kSimplexUnscaledSolutionStrategyMin)
Expand All @@ -1051,7 +1051,7 @@ PYBIND11_MODULE(_core, m) {
"kSimplexUnscaledSolutionStrategyNum",
SimplexUnscaledSolutionStrategy::kSimplexUnscaledSolutionStrategyNum)
.export_values();
py::enum_<SimplexSolvePhase>(simplex_constants, "SimplexSolvePhase")
py::enum_<SimplexSolvePhase>(simplex_constants, "SimplexSolvePhase", py::module_local())
.value("kSolvePhaseMin", SimplexSolvePhase::kSolvePhaseMin)
.value("kSolvePhaseError", SimplexSolvePhase::kSolvePhaseError)
.value("kSolvePhaseExit", SimplexSolvePhase::kSolvePhaseExit)
Expand All @@ -1067,7 +1067,7 @@ PYBIND11_MODULE(_core, m) {
.value("kSolvePhaseMax", SimplexSolvePhase::kSolvePhaseMax)
.export_values();
py::enum_<SimplexEdgeWeightStrategy>(simplex_constants,
"SimplexEdgeWeightStrategy")
"SimplexEdgeWeightStrategy", py::module_local())
.value("kSimplexEdgeWeightStrategyMin",
SimplexEdgeWeightStrategy::kSimplexEdgeWeightStrategyMin)
.value("kSimplexEdgeWeightStrategyChoose",
Expand All @@ -1081,7 +1081,7 @@ PYBIND11_MODULE(_core, m) {
.value("kSimplexEdgeWeightStrategyMax",
SimplexEdgeWeightStrategy::kSimplexEdgeWeightStrategyMax)
.export_values();
py::enum_<SimplexPriceStrategy>(simplex_constants, "SimplexPriceStrategy")
py::enum_<SimplexPriceStrategy>(simplex_constants, "SimplexPriceStrategy", py::module_local())
.value("kSimplexPriceStrategyMin",
SimplexPriceStrategy::kSimplexPriceStrategyMin)
.value("kSimplexPriceStrategyCol",
Expand All @@ -1096,7 +1096,7 @@ PYBIND11_MODULE(_core, m) {
SimplexPriceStrategy::kSimplexPriceStrategyMax)
.export_values();
py::enum_<SimplexPivotalRowRefinementStrategy>(
simplex_constants, "SimplexPivotalRowRefinementStrategy")
simplex_constants, "SimplexPivotalRowRefinementStrategy", py::module_local())
.value("kSimplexInfeasibilityProofRefinementMin",
SimplexPivotalRowRefinementStrategy::
kSimplexInfeasibilityProofRefinementMin)
Expand All @@ -1114,7 +1114,7 @@ PYBIND11_MODULE(_core, m) {
kSimplexInfeasibilityProofRefinementMax)
.export_values();
py::enum_<SimplexPrimalCorrectionStrategy>(simplex_constants,
"SimplexPrimalCorrectionStrategy")
"SimplexPrimalCorrectionStrategy", py::module_local())
.value(
"kSimplexPrimalCorrectionStrategyNone",
SimplexPrimalCorrectionStrategy::kSimplexPrimalCorrectionStrategyNone)
Expand All @@ -1125,7 +1125,7 @@ PYBIND11_MODULE(_core, m) {
SimplexPrimalCorrectionStrategy::
kSimplexPrimalCorrectionStrategyAlways)
.export_values();
py::enum_<SimplexNlaOperation>(simplex_constants, "SimplexNlaOperation")
py::enum_<SimplexNlaOperation>(simplex_constants, "SimplexNlaOperation", py::module_local())
.value("kSimplexNlaNull", SimplexNlaOperation::kSimplexNlaNull)
.value("kSimplexNlaBtranFull", SimplexNlaOperation::kSimplexNlaBtranFull)
.value("kSimplexNlaPriceFull", SimplexNlaOperation::kSimplexNlaPriceFull)
Expand All @@ -1142,14 +1142,15 @@ PYBIND11_MODULE(_core, m) {
.value("kNumSimplexNlaOperation",
SimplexNlaOperation::kNumSimplexNlaOperation)
.export_values();
py::enum_<EdgeWeightMode>(simplex_constants, "EdgeWeightMode")
py::enum_<EdgeWeightMode>(simplex_constants, "EdgeWeightMode", py::module_local())
.value("kDantzig", EdgeWeightMode::kDantzig)
.value("kDevex", EdgeWeightMode::kDevex)
.value("kSteepestEdge", EdgeWeightMode::kSteepestEdge)
.value("kCount", EdgeWeightMode::kCount);

py::module_ callbacks = m.def_submodule("cb", "Callback interface submodule");
// Types for interface
py::enum_<HighsCallbackType>(callbacks, "HighsCallbackType")
py::enum_<HighsCallbackType>(callbacks, "HighsCallbackType", py::module_local())
.value("kCallbackMin", HighsCallbackType::kCallbackMin)
.value("kCallbackLogging", HighsCallbackType::kCallbackLogging)
.value("kCallbackSimplexInterrupt",
Expand All @@ -1167,7 +1168,7 @@ PYBIND11_MODULE(_core, m) {
.value("kNumCallbackType", HighsCallbackType::kNumCallbackType)
.export_values();
// Classes
py::class_<HighsCallbackDataOut>(callbacks, "HighsCallbackDataOut")
py::class_<HighsCallbackDataOut>(callbacks, "HighsCallbackDataOut", py::module_local())
.def(py::init<>())
.def_readwrite("log_type", &HighsCallbackDataOut::log_type)
.def_readwrite("running_time", &HighsCallbackDataOut::running_time)
Expand All @@ -1194,7 +1195,7 @@ PYBIND11_MODULE(_core, m) {
[](HighsCallbackDataOut& self, py::array_t<double> new_mip_solution) {
self.mip_solution = new_mip_solution.mutable_data();
});
py::class_<HighsCallbackDataIn>(callbacks, "HighsCallbackDataIn")
py::class_<HighsCallbackDataIn>(callbacks, "HighsCallbackDataIn", py::module_local())
.def(py::init<>())
.def_readwrite("user_interrupt", &HighsCallbackDataIn::user_interrupt);
}

0 comments on commit 8dc335e

Please sign in to comment.