Refactor variable value retrieval to use get_values

Replaces calls to the deprecated get_variable_values method with get_values throughout the codebase for consistency and future compatibility. Adds a deprecation warning to get_variable_values in SolverWrapper, and updates related documentation and comments. This change modernizes variable retrieval and prepares for the eventual removal of the old method.

Author: alexandrutomescu

examples/inexact_flow_solver.py

@@ -130,6 +130,7 @@ def get_solution(self):
             return self._solution
 
         solution_weights_dict = self.solver.get_variable_values("w", [int])
+        # solution_weights_dict = self.solver.get_values(self.path_weights_vars)
         self._solution = {
             "paths": self.get_solution_paths(),
             "weights": [solution_weights_dict[i] for i in range(self.k)],

flowpaths/abstractpathmodeldag.py

@@ -678,10 +678,7 @@ def get_solution_paths(self) -> list:
             return self.external_solution_paths
 
         if self.edge_vars_sol == {}:
-            self.edge_vars_sol = self.solver.get_variable_values(
-                "edge", [str, str, int], 
-                binary_values=True,
-            )
+            self.edge_vars_sol = self.solver.get_values(self.edge_vars, binary_values=True)
 
         paths = []
         for i in range(self.k):
@@ -732,7 +729,7 @@ def verify_edge_position(self):
 
         paths = self.get_solution_paths()
 
-        edge_position_sol = self.solver.get_variable_values("position", [str, str, int])
+        edge_position_sol = self.solver.get_values(self.edge_position_vars)
 
         for path_index, path in enumerate(paths):
             current_edge_position = 0
@@ -752,7 +749,7 @@ def verify_path_length(self):
 
         paths = self.get_solution_paths()
 
-        path_length_sol = self.solver.get_variable_values("path_length", [int])
+        path_length_sol = self.solver.get_values(self.path_length_vars)
 
         for path_index, path in enumerate(paths):
             if len(path) > 0:

flowpaths/abstractwalkmodeldigraph.py

@@ -679,12 +679,6 @@ def get_solution_walks(self) -> list:
             self.edge_vars_sol = self.solver.get_values(self.edge_vars)
         # utils.logger.debug(f"{__name__}: Getting solution walks with self.edge_vars_sol = {self.edge_vars_sol}")
 
-        # self.distance_vars_sol = self.solver.get_variable_values("distance", [str, int])
-        # utils.logger.debug(f"{__name__}: Getting solution walks with distances = {self.distance_vars_sol}")
-
-        # self.edge_selected_sol = self.solver.get_variable_values("selected_edge", [str, str, int])
-        # utils.logger.debug(f"{__name__}: Getting solution walks with edge selected = {self.edge_selected_sol}")
-
         walks = []
         for i in range(self.k):
             # Build residual graph for this layer with edge multiplicities

flowpaths/kflowdecomp.py

@@ -431,7 +431,7 @@ def get_solution(self, remove_empty_paths=False):
         if self._solution is None:            
 
             self.check_is_solved()
-            weights_sol_dict = self.solver.get_variable_values("w", [int])
+            weights_sol_dict = self.solver.get_values(self.path_weights_vars)
             self.path_weights_sol = [
                 (
                     round(weights_sol_dict[i])

flowpaths/kleastabserrors.py

@@ -425,7 +425,7 @@ def get_solution(self, remove_empty_paths=True):
 
         self.check_is_solved()
 
-        weights_sol_dict = self.solver.get_variable_values("weights", [int])
+        weights_sol_dict = self.solver.get_values(self.path_weights_vars)
         self.path_weights_sol = [
             (
                 round(weights_sol_dict[i])
@@ -434,7 +434,7 @@ def get_solution(self, remove_empty_paths=True):
             )
             for i in range(self.k)
         ]
-        self.edge_errors_sol = self.solver.get_variable_values("ee", [str, str])
+        self.edge_errors_sol = self.solver.get_values(self.edge_errors_vars)
         for (u,v) in self.edge_indexes_basic:
             self.edge_errors_sol[(u,v)] = round(self.edge_errors_sol[(u,v)]) if self.weight_type == int else float(self.edge_errors_sol[(u,v)])
 

flowpaths/kminpatherror.py

@@ -538,7 +538,7 @@ def get_solution(self, remove_empty_paths=True):
 
         self.check_is_solved()
 
-        weights_sol_dict = self.solver.get_variable_values("weights", [int])
+        weights_sol_dict = self.solver.get_values(self.path_weights_vars)
         self.path_weights_sol = [
             (
                 round(weights_sol_dict[i])
@@ -547,7 +547,7 @@ def get_solution(self, remove_empty_paths=True):
             )
             for i in range(self.k)
         ]
-        slacks_sol_dict = self.solver.get_variable_values("slack", [int])
+        slacks_sol_dict = self.solver.get_values(self.path_slacks_vars)
         self.path_slacks_sol = [
             (
                 round(slacks_sol_dict[i])
@@ -572,7 +572,7 @@ def get_solution(self, remove_empty_paths=True):
                 }
 
         if len(self.path_length_factors) > 0:
-            slacks_scaled_sol_dict = self.solver.get_variable_values("scaled_slack", index_types=[int])
+            slacks_scaled_sol_dict = self.solver.get_values(self.scaled_slack_vars)
             self.path_slacks_scaled_sol = [slacks_scaled_sol_dict[i] for i in range(self.k)]
 
             self._solution["scaled_slacks"] = self.path_slacks_scaled_sol
@@ -658,10 +658,10 @@ def is_valid_solution(self, tolerance=0.001):
 
         # Checking that the error scale factor is correctly encoded
         if len(self.path_length_factors) > 0:
-            path_length_sol = self.solver.get_variable_values("path_length", [int])
-            slack_sol = self.solver.get_variable_values("slack", [int])
-            path_slack_scaled_sol = self.solver.get_variable_values("path_slack_scaled", [int])
-            scaled_slack_sol = self.solver.get_variable_values("scaled_slack", [int])
+            path_length_sol = self.solver.get_values(self.path_length_vars)
+            slack_sol = self.solver.get_values(self.path_slacks_vars)
+            path_slack_scaled_sol = self.solver.get_values(self.slack_factors_vars)
+            scaled_slack_sol = self.solver.get_values(self.scaled_slack_vars) 
 
             for i in range(self.k):
                 # Checking which interval the path length is in,
@@ -682,16 +682,6 @@ def is_valid_solution(self, tolerance=0.001):
         if not self.verify_path_length():
             return False
 
-        # var_dict = {var: val for var, val in zip(self.solver.get_all_variable_names(),self.solver.get_all_variable_values())}
-        # print(var_dict)
-        # self.solver.write_model("kminpatherror.lp")
-
-        # gamma_sol = self.solver.get_variable_values("gamma", [str, str, int])
-        # pi_sol = self.solver.get_variable_values("pi", [str, str, int])
-
-        # print("pi_sol", pi_sol)
-        # print("gamma_sol", gamma_sol)
-
         return True
 
     def get_objective_value(self):

flowpaths/minerrorflow.py

@@ -461,15 +461,15 @@ def get_solution(self):
 
         self._check_is_solved()
 
-        edge_sol_dict = self.solver.get_variable_values("edge_vars", [str, str])
+        edge_sol_dict = self.solver.get_values(self.edge_vars)
         for edge in edge_sol_dict.keys():
             self.edge_sol[edge] = (
                 round(edge_sol_dict[edge])
                 if self.weight_type == int
                 else float(edge_sol_dict[edge])
             )
-        
-        edge_error_sol_dict = self.solver.get_variable_values("edge_error_vars", [str, str])
+
+        edge_error_sol_dict = self.solver.get_values(self.edge_error_vars)
         error = sum(edge_error_sol_dict.values())
 
         corrected_graph = deepcopy(self.original_graph_copy)

flowpaths/mingenset.py

@@ -323,7 +323,7 @@ def solve(self):
             self.solver.optimize()
 
             if self.solver.get_model_status() == "kOptimal":
-                genset_sol = self.solver.get_variable_values("gen_set", [int])
+                genset_sol = self.solver.get_values(self.genset_vars)
                 self._solution = sorted(self.weight_type(genset_sol[i]) for i in range(k))
                 self._is_solved = True
                 self.solve_statistics = {

flowpaths/minsetcover.py

@@ -99,7 +99,7 @@ def solve(self) -> bool:
 
         self.solver.optimize()
         if self.solver.get_model_status() == "kOptimal":
-            subset_cover_sol = self.solver.get_variable_values("subset", [int])
+            subset_cover_sol = self.solver.get_values(self.subset_vars)
             self._solution = [i for i in range(len(self.subsets)) if subset_cover_sol[i] == 1]
             self._is_solved = True
             self.solve_statistics = {

flowpaths/utils/solverwrapper.py

@@ -8,6 +8,7 @@
 import math
 import flowpaths.utils as utils
 import numpy as np
+import warnings
 
 class SolverWrapper:
     """Unified MILP/LP modelling convenience layer for HiGHS and Gurobi.
@@ -256,15 +257,6 @@ def add_variables(self, indexes, name_prefix: str, lb=0, ub=1, var_type="integer
             Mapping from provided index to underlying solver variable objects
             (HiGHS returns an internal structure; Gurobi returns a dict).
 
-                Notes
-                -----
-                - Avoid ambiguous prefixes across different variable groups. For example,
-                    prefer prefixes like "x("/"x[" or "x_" that unambiguously delimit the
-                    name from indices, rather than bare "x" if you also use "x_long".
-                - Retrieval via ``get_variable_values`` matches only exact structured
-                    forms ``prefix(...)`` or ``prefix[...]`` and a legacy single numeric
-                    suffix ``prefix<idx>`` (or ``prefix_<idx>``). Overlapping prefixes are
-                    safe under these rules, but ambiguous ad-hoc naming may still collide.
         """
 
     # No internal tracking of prefixes; caller must avoid collisions.
@@ -682,10 +674,15 @@ def parse_var_name(self, string, name_prefix):
 
         return components
 
+
     def get_variable_values(
         self, name_prefix, index_types: list, binary_values: bool = False 
     ) -> dict:
         """
+        !!! warning "Deprecated"
+
+            Use `get_values(...)` instead.
+
         Retrieve the values of variables belonging to a given prefix.
 
         This method matches variables using one of these forms for the given
@@ -709,14 +706,22 @@ def get_variable_values(
 
         Returns:
             values: A dictionary where the keys are the indices of the variables (as tuples or 
-                  single values) and the values are the corresponding variable values.
-                  If index_types is empty, then the unique key is 0 and the value is the variable value.
+                single values) and the values are the corresponding variable values.
+                If index_types is empty, then the unique key is 0 and the value is the variable value.
 
         Raises:
             Exception: If the length of `index_types` does not match the number of indices 
-                       in a variable name.
+                    in a variable name.
             Exception: If `binary_values` is True and a variable value (rounded) is not binary.
         """
+        # Emit a deprecation warning (hidden by default unless enabled by filters)
+        warnings.warn(
+            "SolverWrapper.get_variable_values is deprecated and will be removed in a future release. "
+            "Use SolverWrapper.get_values(...) instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+
         varNames = self.get_all_variable_names()
         varValues = self.get_all_variable_values()