math_opt: fixup

* remove stubby sample

Author: Mizux

ortools/math_opt/elemental/python/elemental.cc

@@ -496,6 +496,14 @@ PYBIND11_MODULE(cpp_elemental, py_module) {
       },
       py::kw_only(), arg("remove_names") = false);
 
+  elemental.def_static(
+      "from_model_proto",
+      [](const ModelProto& proto) {
+        return std::make_unique<Elemental>(
+            ThrowIfError(Elemental::FromModelProto(proto)));
+      },
+      arg("proto"));
+
   elemental.def("add_diff", [](Elemental& e) { return e.AddDiff().id(); });
 
   elemental.def("delete_diff", [](Elemental& e, const int64_t diff_handle) {

ortools/math_opt/elemental/python/elemental_test.py

@@ -461,6 +461,36 @@ def test_export_model(self):
         expected.variables.names[:] = []
         self.assert_protos_equal(e.export_model(remove_names=True), expected)
 
+    def test_from_model_proto(self):
+        proto = model_pb2.ModelProto(
+            name="model",
+            variables=model_pb2.VariablesProto(
+                ids=[2],
+                lower_bounds=[4.0],
+                upper_bounds=[math.inf],
+                integers=[False],
+                names=["x"],
+            ),
+        )
+        e = cpp_elemental.CppElemental.from_model_proto(proto)
+        self.assertEqual(e.model_name, "model")
+        x = 2
+        np.testing.assert_array_equal(
+            e.get_elements(_VARIABLE), np.array([x], dtype=np.int64), strict=True
+        )
+        self.assertEqual(e.get_element_name(_VARIABLE, x), "x")
+        self.assertEqual(e.get_attr(_VARIABLE_LOWER_BOUND, (x,)), 4.0)
+        self.assertEqual(e.get_next_element_id(_VARIABLE), 3)
+        self.assert_protos_equal(e.export_model(), proto)
+
+    def test_from_model_proto_empty(self):
+        proto = model_pb2.ModelProto()
+        e = cpp_elemental.CppElemental.from_model_proto(proto)
+        self.assertEqual(e.model_name, "")
+        self.assertEqual(e.primary_objective_name, "")
+        for element_type in enums.ElementType:
+            self.assertEqual(e.get_num_elements(element_type), 0)
+
     def test_repr(self):
         e = cpp_elemental.CppElemental()
         e.add_element(_VARIABLE, "xyz")

ortools/math_opt/io/BUILD.bazel

@@ -85,7 +85,6 @@ cc_library(
     hdrs = ["lp_parser.h"],
     deps = [
         ":mps_converter",
-        "//ortools/base",
         "//ortools/base:file",
         "//ortools/base:path",
         "//ortools/base:status_macros",

ortools/math_opt/python/BUILD.bazel

@@ -62,6 +62,7 @@ py_library(
         ":objectives",
         ":quadratic_constraints",
         ":variables",
+        requirement("typing-extensions"),
         "//ortools/math_opt:model_py_pb2",
         "//ortools/math_opt:model_update_py_pb2",
         "//ortools/math_opt/elemental/python:cpp_elemental",

ortools/math_opt/python/model.py

@@ -44,6 +44,9 @@
 import math
 from typing import Iterator, Optional, Tuple, Union
 
+# typing.Self is only in python 3.11+, for OR-tools supports down to 3.8.
+from typing_extensions import Self
+
 from ortools.math_opt import model_pb2
 from ortools.math_opt import model_update_pb2
 from ortools.math_opt.elemental.python import cpp_elemental
@@ -910,6 +913,13 @@ def get_indicator_constraints(
     # Proto import/export
     ##############################################################################
 
+    @classmethod
+    def from_model_proto(cls, proto: model_pb2.ModelProto) -> Self:
+        """Returns a Model equivalent to the input model proto."""
+        model = cls()
+        model._elemental = cpp_elemental.CppElemental.from_model_proto(proto)
+        return model
+
     def export_model(self, *, remove_names: bool = False) -> model_pb2.ModelProto:
         """Returns a protocol buffer equivalent to this model.
 

ortools/math_opt/python/model_test.py

@@ -518,6 +518,58 @@ def test_export(self, remove_names: Optional[bool]) -> None:
             ),
         )
 
+    def test_from_model_proto(self) -> None:
+        model_proto = model_pb2.ModelProto(
+            name="test_model",
+            variables=model_pb2.VariablesProto(
+                ids=[0, 1],
+                lower_bounds=[0.0, 1.0],
+                upper_bounds=[2.0, 3.0],
+                integers=[True, False],
+                names=["x", "y"],
+            ),
+            linear_constraints=model_pb2.LinearConstraintsProto(
+                ids=[0],
+                lower_bounds=[-1.0],
+                upper_bounds=[2.0],
+                names=["c"],
+            ),
+            objective=model_pb2.ObjectiveProto(
+                maximize=True,
+                offset=2.0,
+                linear_coefficients=sparse_containers_pb2.SparseDoubleVectorProto(
+                    ids=[1], values=[3.0]
+                ),
+            ),
+            linear_constraint_matrix=sparse_containers_pb2.SparseDoubleMatrixProto(
+                row_ids=[0, 0], column_ids=[0, 1], coefficients=[1.0, 2.0]
+            ),
+        )
+        mod = model.Model.from_model_proto(model_proto)
+        self.assertEqual(mod.name, "test_model")
+        self.assertEqual(mod.get_num_variables(), 2)
+        x = mod.get_variable(0)
+        y = mod.get_variable(1)
+        self.assertEqual(x.name, "x")
+        self.assertEqual(x.lower_bound, 0.0)
+        self.assertEqual(x.upper_bound, 2.0)
+        self.assertTrue(x.integer)
+        self.assertEqual(y.name, "y")
+        self.assertEqual(y.lower_bound, 1.0)
+        self.assertEqual(y.upper_bound, 3.0)
+        self.assertFalse(y.integer)
+        self.assertEqual(mod.get_num_linear_constraints(), 1)
+        c = mod.get_linear_constraint(0)
+        self.assertEqual(c.name, "c")
+        self.assertEqual(c.lower_bound, -1.0)
+        self.assertEqual(c.upper_bound, 2.0)
+        self.assertEqual(c.get_coefficient(x), 1.0)
+        self.assertEqual(c.get_coefficient(y), 2.0)
+        self.assertTrue(mod.objective.is_maximize)
+        self.assertEqual(mod.objective.offset, 2.0)
+        self.assertEqual(mod.objective.get_linear_coefficient(x), 0.0)
+        self.assertEqual(mod.objective.get_linear_coefficient(y), 3.0)
+
     def test_update_tracker_simple(self) -> None:
         mod = model.Model(name="test_model")
         x = mod.add_binary_variable(name="x")

ortools/math_opt/samples/cpp/BUILD.bazel

@@ -192,6 +192,7 @@ cc_binary(
     srcs = ["tsp.cc"],
     deps = [
         "//ortools/base",
+        "//ortools/base:file",
         "//ortools/base:status_macros",
         "//ortools/math_opt/cpp:math_opt",
         "//ortools/math_opt/solvers:gscip_solver",

ortools/math_opt/samples/python/BUILD.bazel

@@ -99,19 +99,6 @@ py_binary(
     ],
 )
 
-#py_binary(
-#    name = "stubby_remote_streaming_solve_example",
-#    srcs = ["stubby_remote_streaming_solve_example.py"],
-#    test_lib = True,
-#    deps = [
-#        requirement("absl-py"),
-#        "//ortools/math_opt:rpc_stubby_pyclif",
-#        "//ortools/math_opt/python:mathopt",
-#        "//ortools/math_opt/python/ipc:solve_service_stubby_client",
-#        "//ortools/math_opt/python/ipc:stubby_remote_streaming_solve",
-#    ],
-#)
-
 py_binary(
     name = "time_indexed_scheduling",
     srcs = ["time_indexed_scheduling.py"],

ortools/math_opt/samples/python/stubby_remote_streaming_solve_example.py

@@ -221,7 +221,7 @@ TEST(GScipEventHandlerDeathTest, ErrorReturnedByInit) {
         const absl::Status status = gscip->Solve().status();
         LOG(ERROR) << "status: " << status;
         if (!status.ok() &&
-            absl::StrContains(status.message(), "SCIP error code 0")) {
+            absl::StrContains(status.message(), "SCIP error code -8")) {
           // Write the expected marker only if we see the expected error.
           LOG(FATAL) << kMarker;
         }