implement __repr__ and more testing

Author: alphaville

open-codegen/opengen/templates/python/python_bindings.rs

@@ -3,6 +3,7 @@
 ///
 use optimization_engine::alm::*;
 
+use pyo3::class::basic::PyObjectProtocol;
 use pyo3::prelude::*;
 use pyo3::wrap_pyfunction;
 
@@ -114,6 +115,24 @@ impl From<SolverStatusData> for SolverStatus {
     }
 }
 
+#[pyproto]
+impl PyObjectProtocol for SolverStatus {
+    fn __repr__(&self) -> PyResult<String> {
+        Ok(format!(
+            "SolverStatus(exit_status={:?}, num_outer_iterations={}, num_inner_iterations={}, last_problem_norm_fpr={}, f1_infeasibility={}, f2_norm={}, solve_time_ms={}, penalty={}, cost={})",
+            self.exit_status,
+            self.num_outer_iterations,
+            self.num_inner_iterations,
+            self.last_problem_norm_fpr,
+            self.f1_infeasibility,
+            self.f2_norm,
+            self.solve_time_ms,
+            self.penalty,
+            self.cost
+        ))
+    }
+}
+
 #[pyclass]
 struct SolverError {
     #[pyo3(get)]
@@ -131,11 +150,41 @@ impl From<SolverErrorData> for SolverError {
     }
 }
 
+#[pyproto]
+impl PyObjectProtocol for SolverError {
+    fn __repr__(&self) -> PyResult<String> {
+        Ok(format!(
+            "SolverError(code={}, message={:?})",
+            self.code,
+            self.message
+        ))
+    }
+}
+
 #[pyclass]
 struct SolverResponse {
     payload: SolverResponsePayload,
 }
 
+#[pyproto]
+impl PyObjectProtocol for SolverResponse {
+    fn __repr__(&self) -> PyResult<String> {
+        match &self.payload {
+            SolverResponsePayload::Ok(status) => Ok(format!(
+                "SolverResponse(ok=True, exit_status={:?}, num_outer_iterations={}, num_inner_iterations={})",
+                status.exit_status,
+                status.num_outer_iterations,
+                status.num_inner_iterations
+            )),
+            SolverResponsePayload::Err(error) => Ok(format!(
+                "SolverResponse(ok=False, code={}, message={:?})",
+                error.code,
+                error.message
+            )),
+        }
+    }
+}
+
 #[pymethods]
 impl SolverResponse {
     fn is_ok(&self) -> bool {

open-codegen/test/test.py

@@ -409,6 +409,34 @@ def test_python_bindings_error_details(self):
             error.message
         )
 
+    def test_python_bindings_initial_guess_error_details(self):
+        python_bindings = RustBuildTestCase.import_generated_module(
+            "python_bindings", "python_bindings")
+
+        solver = python_bindings.solver()
+        result = solver.run([1., 2.], initial_guess=[0.0])
+        self.assertFalse(result.is_ok())
+        error = result.get()
+        self.assertEqual(1600, error.code)
+        self.assertEqual(
+            "initial guess has incompatible dimensions: provided 1, expected 5",
+            error.message
+        )
+
+    def test_python_bindings_initial_lagrange_multipliers_error_details(self):
+        python_bindings = RustBuildTestCase.import_generated_module(
+            "python_bindings", "python_bindings")
+
+        solver = python_bindings.solver()
+        result = solver.run([1., 2.], initial_lagrange_multipliers=[0.1])
+        self.assertFalse(result.is_ok())
+        error = result.get()
+        self.assertEqual(1700, error.code)
+        self.assertEqual(
+            "wrong dimension of Langrange multipliers: provided 1, expected 0",
+            error.message
+        )
+
     def test_python_bindings_solver_error_details(self):
         python_bindings = RustBuildTestCase.import_generated_module(
             "python_bindings", "python_bindings")
@@ -423,6 +451,24 @@ def test_python_bindings_solver_error_details(self):
             error.message
         )
 
+    def test_python_bindings_repr(self):
+        python_bindings = RustBuildTestCase.import_generated_module(
+            "python_bindings", "python_bindings")
+
+        solver = python_bindings.solver()
+
+        ok_response = solver.run([1., 2.])
+        self.assertIn("SolverResponse(ok=True", repr(ok_response))
+        ok_status = ok_response.get()
+        self.assertIn("SolverStatus(", repr(ok_status))
+        self.assertIn('exit_status="Converged"', repr(ok_status))
+
+        error_response = solver.run([1., 2., 3.])
+        self.assertIn("SolverResponse(ok=False", repr(error_response))
+        error = error_response.get()
+        self.assertIn("SolverError(", repr(error))
+        self.assertIn("code=3003", repr(error))
+
     def test_rectangle_empty(self):
         xmin = [-1, 2]
         xmax = [-2, 4]