ommx-python-mip-adapter 1.7.0__tar.gz → 1.8.0__tar.gz

{ommx_python_mip_adapter-1.7.0 → ommx_python_mip_adapter-1.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: ommx_python_mip_adapter
-Version: 1.7.0
+Version: 1.8.0
 Summary: An adapter for the Python-MIP from/to OMMX.
 Author-email: "Jij Inc." <info@j-ij.com>
 Project-URL: Repository, https://github.com/Jij-Inc/ommx
@@ -74,7 +74,7 @@ pip install ommx-python-mip-adapter
 Python-MIP can be used through `ommx-python-mip-adapter` by using the following:
 
 ```python markdown-code-runner
-import ommx_python_mip_adapter as adapter
+from ommx_python_mip_adapter import OMMXPythonMIPAdapter
 from ommx.v1 import Instance, DecisionVariable
 
 x1 = DecisionVariable.integer(1, lower=0, upper=5)
@@ -85,13 +85,10 @@ ommx_instance = Instance.from_components(
     sense=Instance.MINIMIZE,
 )
 
-# Convert from `ommx.v1.Instance` to `mip.Model`
-model = adapter.instance_to_model(ommx_instance)
-model.optimize()
-# Create `ommx.v1.State` from Optimized `mip.Model`
-ommx_state = adapter.model_to_state(model, ommx_instance)
+# Create `ommx.v1.Solution` from the `mip.Model`
+ommx_solution = OMMXPythonMIPAdapter.solve(ommx_instance)
 
-print(ommx_state)
+print(ommx_solution)
 ```
 
 You can get `ommx.v1.Instance` from a Python-MIP model as the following:

{ommx_python_mip_adapter-1.7.0 → ommx_python_mip_adapter-1.8.0}/README.md

@@ -45,7 +45,7 @@ pip install ommx-python-mip-adapter
 Python-MIP can be used through `ommx-python-mip-adapter` by using the following:
 
 ```python markdown-code-runner
-import ommx_python_mip_adapter as adapter
+from ommx_python_mip_adapter import OMMXPythonMIPAdapter
 from ommx.v1 import Instance, DecisionVariable
 
 x1 = DecisionVariable.integer(1, lower=0, upper=5)
@@ -56,13 +56,10 @@ ommx_instance = Instance.from_components(
     sense=Instance.MINIMIZE,
 )
 
-# Convert from `ommx.v1.Instance` to `mip.Model`
-model = adapter.instance_to_model(ommx_instance)
-model.optimize()
-# Create `ommx.v1.State` from Optimized `mip.Model`
-ommx_state = adapter.model_to_state(model, ommx_instance)
+# Create `ommx.v1.Solution` from the `mip.Model`
+ommx_solution = OMMXPythonMIPAdapter.solve(ommx_instance)
 
-print(ommx_state)
+print(ommx_solution)
 ```
 
 You can get `ommx.v1.Instance` from a Python-MIP model as the following:

ommx_python_mip_adapter-1.8.0/ommx_python_mip_adapter/__init__.py

@@ -0,0 +1,9 @@
+from .python_mip_to_ommx import (
+    model_to_instance,
+)
+from .adapter import OMMXPythonMIPAdapter
+
+__all__ = [
+    "model_to_instance",
+    "OMMXPythonMIPAdapter",
+]

ommx_python_mip_adapter-1.8.0/ommx_python_mip_adapter/adapter.py

@@ -0,0 +1,373 @@
+from __future__ import annotations
+
+from typing import Optional
+
+import mip
+
+from ommx.adapter import SolverAdapter, InfeasibleDetected, UnboundedDetected
+from ommx.v1 import Instance, Constraint, DecisionVariable, Solution, State, Optimality
+from ommx.v1.function_pb2 import Function
+from ommx.v1.solution_pb2 import Relaxation
+
+from .exception import OMMXPythonMIPAdapterError
+
+
+class OMMXPythonMIPAdapter(SolverAdapter):
+    def __init__(
+        self,
+        ommx_instance: Instance,
+        *,
+        relax: bool = False,
+        solver_name: str = mip.CBC,
+        solver: Optional[mip.Solver] = None,
+        verbose: bool = False,
+    ):
+        """
+        :param ommx_instance: The ommx.v1.Instance to solve.
+        :param relax: Applies integer relaxation globally to this model using Python-MIP's `Model.relax() <https://docs.python-mip.com/en/latest/classes.html#mip.Model.relax>`.
+        :param solver_name: Passes a specific solver name to the Python-MIP model. Defaults to `CBC`.
+        :param solver: Passes a specific solver to the Python-MIP model.
+        :param verbose: If True, enable Python-MIP's verbose mode
+        """
+        if ommx_instance.raw.sense == Instance.MAXIMIZE:
+            sense = mip.MAXIMIZE
+        elif ommx_instance.raw.sense == Instance.MINIMIZE:
+            sense = mip.MINIMIZE
+        else:
+            raise OMMXPythonMIPAdapterError(
+                f"Unsupported sense: {ommx_instance.raw.sense}"
+            )
+        self.instance = ommx_instance
+        self.model = mip.Model(
+            sense=sense,
+            solver_name=solver_name,
+            solver=solver,
+        )
+        if verbose:
+            self.model.verbose = 1
+        else:
+            self.model.verbose = 0
+
+        self._set_decision_variables()
+        self._set_objective()
+        self._set_constraints()
+
+        if relax:
+            self.model.relax()
+            self._relax = True
+        else:
+            self._relax = False
+
+    @staticmethod
+    def solve(
+        ommx_instance: Instance,
+        relax: bool = False,
+        verbose: bool = False,
+    ) -> Solution:
+        """
+        Solve the given ommx.v1.Instance using Python-MIP, returning an ommx.v1.Solution.
+
+        :param ommx_instance: The ommx.v1.Instance to solve.
+        :param relax: If True, relax all integer variables to continuous variables by using the `relax` parameter in Python-MIP's `Model.optimize() <https://docs.python-mip.com/en/latest/classes.html#mip.Model.optimize>`.
+        :param verbose: If True, enable Python-MIP's verbose mode
+
+        Examples
+        =========
+
+        KnapSack Problem
+
+        .. doctest::
+
+            >>> from ommx.v1 import Instance, DecisionVariable
+            >>> from ommx.v1.solution_pb2 import Optimality
+            >>> from ommx_python_mip_adapter import OMMXPythonMIPAdapter
+
+            >>> p = [10, 13, 18, 32, 7, 15]
+            >>> w = [11, 15, 20, 35, 10, 33]
+            >>> x = [DecisionVariable.binary(i) for i in range(6)]
+            >>> instance = Instance.from_components(
+            ...     decision_variables=x,
+            ...     objective=sum(p[i] * x[i] for i in range(6)),
+            ...     constraints=[sum(w[i] * x[i] for i in range(6)) <= 47],
+            ...     sense=Instance.MAXIMIZE,
+            ... )
+
+            Solve it
+
+            >>> solution = OMMXPythonMIPAdapter.solve(instance)
+
+            Check output
+
+            >>> sorted([(id, value) for id, value in solution.state.entries.items()])
+            [(0, 1.0), (1, 0.0), (2, 0.0), (3, 1.0), (4, 0.0), (5, 0.0)]
+            >>> solution.feasible
+            True
+            >>> assert solution.optimality == Optimality.OPTIMALITY_OPTIMAL
+
+            p[0] + p[3] = 42
+            w[0] + w[3] = 46 <= 47
+
+            >>> solution.objective
+            42.0
+            >>> solution.raw.evaluated_constraints[0].evaluated_value
+            -1.0
+
+        Infeasible Problem
+
+        .. doctest::
+
+                >>> from ommx.v1 import Instance, DecisionVariable
+                >>> from ommx_python_mip_adapter import OMMXPythonMIPAdapter
+
+                >>> x = DecisionVariable.integer(0, upper=3, lower=0)
+                >>> instance = Instance.from_components(
+                ...     decision_variables=[x],
+                ...     objective=x,
+                ...     constraints=[x >= 4],
+                ...     sense=Instance.MAXIMIZE,
+                ... )
+
+                >>> OMMXPythonMIPAdapter.solve(instance)
+                Traceback (most recent call last):
+                    ...
+                ommx.adapter.InfeasibleDetected: Model was infeasible
+
+        Unbounded Problem
+
+        .. doctest::
+
+                >>> from ommx.v1 import Instance, DecisionVariable
+                >>> from ommx_python_mip_adapter import OMMXPythonMIPAdapter
+
+                >>> x = DecisionVariable.integer(0, lower=0)
+                >>> instance = Instance.from_components(
+                ...     decision_variables=[x],
+                ...     objective=x,
+                ...     constraints=[],
+                ...     sense=Instance.MAXIMIZE,
+                ... )
+
+                >>> OMMXPythonMIPAdapter.solve(instance)
+                Traceback (most recent call last):
+                    ...
+                ommx.adapter.UnboundedDetected: Model was unbounded
+
+        Dual variable
+
+        .. doctest::
+
+                >>> from ommx.v1 import Instance, DecisionVariable
+                >>> from ommx_python_mip_adapter import OMMXPythonMIPAdapter
+
+                >>> x = DecisionVariable.continuous(0, lower=0, upper=1)
+                >>> y = DecisionVariable.continuous(1, lower=0, upper=1)
+                >>> instance = Instance.from_components(
+                ...     decision_variables=[x, y],
+                ...     objective=x + y,
+                ...     constraints=[x + y <= 1],
+                ...     sense=Instance.MAXIMIZE,
+                ... )
+
+                >>> solution = OMMXPythonMIPAdapter.solve(instance)
+                >>> solution.raw.evaluated_constraints[0].dual_variable
+                1.0
+
+        """
+        adapter = OMMXPythonMIPAdapter(ommx_instance, relax=relax, verbose=verbose)
+        model = adapter.solver_input
+        model.optimize(relax=relax)
+        return adapter.decode(model)
+
+    @property
+    def solver_input(self) -> mip.Model:
+        """The Python-MIP model generated from this OMMX instance"""
+        return self.model
+
+    def decode(self, data: mip.Model) -> Solution:
+        """Convert optimized Python-MIP model and ommx.v1.Instance to ommx.v1.Solution.
+
+        This method is intended to be used if the model has been acquired with
+        `solver_input` for futher adjustment of the solver parameters, and
+        separately optimizing the model.
+
+        Note that alterations to the model may make the decoding process
+        incompatible -- decoding will only work if the model still describes
+        effectively the same problem as the OMMX instance used to create the
+        adapter.
+
+        When creating the solution, this method reflects the `relax` flag used
+        in this adapter's constructor. The solution's `relaxation` metadata will
+        be set _only_ if `relax=True` was passed to the constructor. There is no
+        way for this adapter to get relaxation information from Python-MIP
+        directly. If relaxing the model separately after obtaining it with
+        `solver_input`, you must set `solution.raw.relaxation` yourself if you
+        care about this value.
+
+        Examples
+        =========
+
+        .. doctest::
+
+            >>> from ommx.v1 import Instance, DecisionVariable
+            >>> from ommx_python_mip_adapter import OMMXPythonMIPAdapter
+
+            >>> p = [10, 13, 18, 32, 7, 15]
+            >>> w = [11, 15, 20, 35, 10, 33]
+            >>> x = [DecisionVariable.binary(i) for i in range(6)]
+            >>> instance = Instance.from_components(
+            ...     decision_variables=x,
+            ...     objective=sum(p[i] * x[i] for i in range(6)),
+            ...     constraints=[sum(w[i] * x[i] for i in range(6)) <= 47],
+            ...     sense=Instance.MAXIMIZE,
+            ... )
+
+            >>> adapter = OMMXPythonMIPAdapter(instance)
+            >>> model = adapter.solver_input
+            >>> # ... some modification of model's parameters
+            >>> model.optimize()
+            <OptimizationStatus.OPTIMAL: 0>
+
+            >>> solution = adapter.decode(model)
+            >>> solution.raw.objective
+            42.0
+
+        """
+        # TODO check if `optimize()` has been called
+
+        if data.status == mip.OptimizationStatus.INFEASIBLE:
+            raise InfeasibleDetected("Model was infeasible")
+
+        if data.status == mip.OptimizationStatus.UNBOUNDED:
+            raise UnboundedDetected("Model was unbounded")
+
+        state = self.decode_to_state(data)
+        solution = self.instance.evaluate(state)
+
+        dual_variables = {}
+        for constraint in data.constrs:
+            pi = constraint.pi
+            if pi is not None:
+                id = int(constraint.name)
+                dual_variables[id] = pi
+        for constraint in solution.raw.evaluated_constraints:
+            id = constraint.id
+            if id in dual_variables:
+                constraint.dual_variable = dual_variables[id]
+
+        if data.status == mip.OptimizationStatus.OPTIMAL:
+            solution.raw.optimality = Optimality.OPTIMALITY_OPTIMAL
+
+        if self._relax:
+            solution.raw.relaxation = Relaxation.RELAXATION_LP_RELAXED
+        return solution
+
+    def decode_to_state(self, data: mip.Model) -> State:
+        """
+        Create an ommx.v1.State from an optimized Python-MIP Model.
+
+        Examples
+        =========
+
+        .. doctest::
+
+            The following example of solving an unconstrained linear optimization problem with x1 as the objective function.
+
+            >>> from ommx_python_mip_adapter import OMMXPythonMIPAdapter
+            >>> from ommx.v1 import Instance, DecisionVariable
+
+            >>> x1 = DecisionVariable.integer(1, lower=0, upper=5)
+            >>> ommx_instance = Instance.from_components(
+            ...     decision_variables=[x1],
+            ...     objective=x1,
+            ...     constraints=[],
+            ...     sense=Instance.MINIMIZE,
+            ... )
+            >>> adapter = OMMXPythonMIPAdapter(ommx_instance)
+            >>> model = adapter.solver_input
+            >>> model.optimize()
+            <OptimizationStatus.OPTIMAL: 0>
+
+            >>> ommx_state = adapter.decode_to_state(model)
+            >>> ommx_state.entries
+            {1: 0.0}
+        """
+        if not (
+            data.status == mip.OptimizationStatus.OPTIMAL
+            or data.status == mip.OptimizationStatus.FEASIBLE
+        ):
+            raise OMMXPythonMIPAdapterError(
+                " The model's `status` must be `OPTIMAL` or `FEASIBLE`."
+            )
+
+        return State(
+            entries={
+                var.id: data.var_by_name(str(var.id)).x  # type: ignore
+                for var in self.instance.raw.decision_variables
+            }
+        )
+
+    def _set_decision_variables(self):
+        for var in self.instance.raw.decision_variables:
+            if var.kind == DecisionVariable.BINARY:
+                self.model.add_var(
+                    name=str(var.id),
+                    var_type=mip.BINARY,
+                )
+            elif var.kind == DecisionVariable.INTEGER:
+                self.model.add_var(
+                    name=str(var.id),
+                    var_type=mip.INTEGER,
+                    lb=var.bound.lower,  # type: ignore
+                    ub=var.bound.upper,  # type: ignore
+                )
+            elif var.kind == DecisionVariable.CONTINUOUS:
+                self.model.add_var(
+                    name=str(var.id),
+                    var_type=mip.CONTINUOUS,
+                    lb=var.bound.lower,  # type: ignore
+                    ub=var.bound.upper,  # type: ignore
+                )
+            else:
+                raise OMMXPythonMIPAdapterError(
+                    f"Not supported decision variable kind: "
+                    f"id: {var.id}, kind: {var.kind}"
+                )
+
+    def _as_lin_expr(
+        self,
+        f: Function,
+    ) -> mip.LinExpr:
+        """
+        Translate ommx.v1.Function to `mip.LinExpr` or `float`.
+        """
+        if f.HasField("constant"):
+            return mip.LinExpr(const=f.constant)  # type: ignore
+        elif f.HasField("linear"):
+            ommx_linear = f.linear
+            return (
+                mip.xsum(
+                    term.coefficient * self.model.vars[str(term.id)]  # type: ignore
+                    for term in ommx_linear.terms
+                )
+                + ommx_linear.constant
+            )  # type: ignore
+        raise OMMXPythonMIPAdapterError(
+            "The function must be either `constant` or `linear`."
+        )
+
+    def _set_objective(self):
+        self.model.objective = self._as_lin_expr(self.instance.raw.objective)  # type: ignore
+
+    def _set_constraints(self):
+        for constraint in self.instance.raw.constraints:
+            lin_expr = self._as_lin_expr(constraint.function)
+            if constraint.equality == Constraint.EQUAL_TO_ZERO:
+                constr_expr = lin_expr == 0
+            elif constraint.equality == Constraint.LESS_THAN_OR_EQUAL_TO_ZERO:
+                constr_expr = lin_expr <= 0  # type: ignore
+            else:
+                raise OMMXPythonMIPAdapterError(
+                    f"Not supported constraint equality: "
+                    f"id: {constraint.id}, equality: {constraint.equality}"
+                )
+            self.model.add_constr(constr_expr, name=str(constraint.id))

{ommx_python_mip_adapter-1.7.0 → ommx_python_mip_adapter-1.8.0}/ommx_python_mip_adapter/python_mip_to_ommx.py

@@ -7,8 +7,7 @@ from mip.exceptions import ParameterNotAvailable
 from ommx.v1.constraint_pb2 import Constraint, Equality
 from ommx.v1.function_pb2 import Function
 from ommx.v1.linear_pb2 import Linear
-from ommx.v1.solution_pb2 import State, Optimality
-from ommx.v1 import Instance, DecisionVariable, Solution
+from ommx.v1 import Instance, DecisionVariable
 
 from .exception import OMMXPythonMIPAdapterError
 
@@ -150,105 +149,3 @@ def model_to_instance(model: mip.Model) -> Instance:
     """
     builder = OMMXInstanceBuilder(model)
     return builder.build()
-
-
-def model_to_state(
-    model: mip.Model,
-    instance: Instance,
-) -> State:
-    """
-    The function to create ommx.v1.State from optimized Python-MIP Model.
-
-    Examples
-    =========
-
-    .. doctest::
-
-        The following example of solving an unconstrained linear optimization problem with x1 as the objective function.
-
-        >>> import ommx_python_mip_adapter as adapter
-        >>> from ommx.v1 import Instance, DecisionVariable
-
-        >>> x1 = DecisionVariable.integer(1, lower=0, upper=5)
-        >>> ommx_instance = Instance.from_components(
-        ...     decision_variables=[x1],
-        ...     objective=x1,
-        ...     constraints=[],
-        ...     sense=Instance.MINIMIZE,
-        ... )
-        >>> model = adapter.instance_to_model(ommx_instance)
-        >>> model.optimize()
-        <OptimizationStatus.OPTIMAL: 0>
-
-        >>> ommx_state = adapter.model_to_state(model, ommx_instance)
-        >>> ommx_state.entries
-        {1: 0.0}
-    """
-    if not (
-        model.status == mip.OptimizationStatus.OPTIMAL
-        or model.status == mip.OptimizationStatus.FEASIBLE
-    ):
-        raise OMMXPythonMIPAdapterError(
-            "`model.status` must be `OPTIMAL` or `FEASIBLE`."
-        )
-
-    return State(
-        entries={
-            var.id: model.var_by_name(str(var.id)).x  # type: ignore
-            for var in instance.raw.decision_variables
-        }
-    )
-
-
-def model_to_solution(
-    model: mip.Model,
-    instance: Instance,
-) -> Solution:
-    """
-    Convert optimized Python-MIP model and ommx.v1.Instance to ommx.v1.Solution.
-
-    Examples
-    =========
-
-    .. doctest::
-
-        >>> from ommx.v1 import Instance, DecisionVariable
-        >>> from ommx_python_mip_adapter import instance_to_model, model_to_solution
-
-        >>> p = [10, 13, 18, 31, 7, 15]
-        >>> w = [11, 15, 20, 35, 10, 33]
-        >>> x = [DecisionVariable.binary(i) for i in range(6)]
-        >>> instance = Instance.from_components(
-        ...     decision_variables=x,
-        ...     objective=sum(p[i] * x[i] for i in range(6)),
-        ...     constraints=[sum(w[i] * x[i] for i in range(6)) <= 47],
-        ...     sense=Instance.MAXIMIZE,
-        ... )
-
-        >>> model = instance_to_model(instance)
-        >>> model.optimize()
-        <OptimizationStatus.OPTIMAL: 0>
-
-        >>> solution = model_to_solution(model, instance)
-        >>> solution.raw.objective
-        41.0
-
-    """
-    state = model_to_state(model, instance)
-    solution = instance.evaluate(state)
-
-    dual_variables = {}
-    for constraint in model.constrs:
-        pi = constraint.pi
-        if pi is not None:
-            id = int(constraint.name)
-            dual_variables[id] = pi
-    for constraint in solution.raw.evaluated_constraints:
-        id = constraint.id
-        if id in dual_variables:
-            constraint.dual_variable = dual_variables[id]
-
-    if model.status == mip.OptimizationStatus.OPTIMAL:
-        solution.raw.optimality = Optimality.OPTIMALITY_OPTIMAL
-
-    return solution

{ommx_python_mip_adapter-1.7.0 → ommx_python_mip_adapter-1.8.0}/ommx_python_mip_adapter.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: ommx_python_mip_adapter
-Version: 1.7.0
+Version: 1.8.0
 Summary: An adapter for the Python-MIP from/to OMMX.
 Author-email: "Jij Inc." <info@j-ij.com>
 Project-URL: Repository, https://github.com/Jij-Inc/ommx
@@ -74,7 +74,7 @@ pip install ommx-python-mip-adapter
 Python-MIP can be used through `ommx-python-mip-adapter` by using the following:
 
 ```python markdown-code-runner
-import ommx_python_mip_adapter as adapter
+from ommx_python_mip_adapter import OMMXPythonMIPAdapter
 from ommx.v1 import Instance, DecisionVariable
 
 x1 = DecisionVariable.integer(1, lower=0, upper=5)
@@ -85,13 +85,10 @@ ommx_instance = Instance.from_components(
     sense=Instance.MINIMIZE,
 )
 
-# Convert from `ommx.v1.Instance` to `mip.Model`
-model = adapter.instance_to_model(ommx_instance)
-model.optimize()
-# Create `ommx.v1.State` from Optimized `mip.Model`
-ommx_state = adapter.model_to_state(model, ommx_instance)
+# Create `ommx.v1.Solution` from the `mip.Model`
+ommx_solution = OMMXPythonMIPAdapter.solve(ommx_instance)
 
-print(ommx_state)
+print(ommx_solution)
 ```
 
 You can get `ommx.v1.Instance` from a Python-MIP model as the following:

{ommx_python_mip_adapter-1.7.0 → ommx_python_mip_adapter-1.8.0}/ommx_python_mip_adapter.egg-info/SOURCES.txt

@@ -1,15 +1,15 @@
 README.md
 pyproject.toml
 ommx_python_mip_adapter/__init__.py
+ommx_python_mip_adapter/adapter.py
 ommx_python_mip_adapter/exception.py
-ommx_python_mip_adapter/ommx_to_python_mip.py
 ommx_python_mip_adapter/python_mip_to_ommx.py
 ommx_python_mip_adapter.egg-info/PKG-INFO
 ommx_python_mip_adapter.egg-info/SOURCES.txt
 ommx_python_mip_adapter.egg-info/dependency_links.txt
 ommx_python_mip_adapter.egg-info/requires.txt
 ommx_python_mip_adapter.egg-info/top_level.txt
+tests/test_adapter.py
 tests/test_constant_constraint.py
-tests/test_instance_to_model.py
 tests/test_integration.py
 tests/test_model_to_instance.py

{ommx_python_mip_adapter-1.7.0 → ommx_python_mip_adapter-1.8.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ommx_python_mip_adapter"
-version = "1.7.0"
+version = "1.8.0"
 
 description = "An adapter for the Python-MIP from/to OMMX."
 authors = [{ name = "Jij Inc.", email = "info@j-ij.com" }]

ommx_python_mip_adapter-1.7.0/tests/test_instance_to_model.py → ommx_python_mip_adapter-1.8.0/tests/test_adapter.py

@@ -7,7 +7,7 @@ from ommx.v1.linear_pb2 import Linear
 from ommx.v1.quadratic_pb2 import Quadratic
 from ommx.v1 import Instance, DecisionVariable
 
-import ommx_python_mip_adapter as adapter
+from ommx_python_mip_adapter import OMMXPythonMIPAdapter
 
 from ommx_python_mip_adapter.exception import OMMXPythonMIPAdapterError
 
@@ -24,7 +24,7 @@ def test_error_not_suppoerted_decision_variable():
         sense=Instance.MINIMIZE,
     )
     with pytest.raises(OMMXPythonMIPAdapterError) as e:
-        adapter.instance_to_model(ommx_instance)
+        OMMXPythonMIPAdapter(ommx_instance)
     assert "Not supported decision variable" in str(e.value)
 
 
@@ -40,7 +40,7 @@ def test_error_nonlinear_objective():
     )
 
     with pytest.raises(OMMXPythonMIPAdapterError) as e:
-        adapter.instance_to_model(ommx_instance)
+        OMMXPythonMIPAdapter(ommx_instance)
     assert "The function must be either `constant` or `linear`." in str(e.value)
 
 
@@ -64,7 +64,7 @@ def test_error_nonlinear_constraint():
     )
 
     with pytest.raises(OMMXPythonMIPAdapterError) as e:
-        adapter.instance_to_model(ommx_instance)
+        OMMXPythonMIPAdapter(ommx_instance)
     assert "The function must be either `constant` or `linear`." in str(e.value)
 
 
@@ -86,5 +86,5 @@ def test_error_not_supported_constraint_equality():
     )
 
     with pytest.raises(OMMXPythonMIPAdapterError) as e:
-        adapter.instance_to_model(ommx_instance)
+        OMMXPythonMIPAdapter(ommx_instance)
     assert "Not supported constraint equality" in str(e.value)

{ommx_python_mip_adapter-1.7.0 → ommx_python_mip_adapter-1.8.0}/tests/test_constant_constraint.py

@@ -1,5 +1,6 @@
-import ommx_python_mip_adapter as adapter
+from ommx_python_mip_adapter import OMMXPythonMIPAdapter
 from ommx.v1 import Instance, DecisionVariable, Linear
+from ommx.adapter import InfeasibleDetected
 import pytest
 
 
@@ -18,14 +19,12 @@ def test_constant_constraint_feasible():
         ],
         sense=Instance.MAXIMIZE,
     )
-    result = adapter.solve(instance)
-    assert result.HasField("solution")
+    solution = OMMXPythonMIPAdapter.solve(instance)
 
-    solution = result.solution
     assert solution.state.entries == {0: 1.0}
     assert solution.objective == 1.0
 
-    assert len(solution.evaluated_constraints) == 2
+    assert len(solution.raw.evaluated_constraints) == 2
 
 
 @pytest.mark.skip(
@@ -43,5 +42,5 @@ def test_constant_constraint_infeasible():
         ],
         sense=Instance.MAXIMIZE,
     )
-    result = adapter.solve(instance)
-    assert result.HasField("infeasible")
+    with pytest.raises(InfeasibleDetected):
+        OMMXPythonMIPAdapter.solve(instance)

{ommx_python_mip_adapter-1.7.0 → ommx_python_mip_adapter-1.8.0}/tests/test_integration.py

@@ -1,9 +1,10 @@
 import pytest
 
 from ommx.v1 import Instance, DecisionVariable
+from ommx.v1.solution_pb2 import Optimality
 from ommx.testing import SingleFeasibleLPGenerator, DataType
 
-import ommx_python_mip_adapter as adapter
+from ommx_python_mip_adapter import OMMXPythonMIPAdapter
 
 
 @pytest.mark.parametrize(
@@ -19,9 +20,10 @@ def test_integration_lp(generater):
     #     A @ x = b    (A: regular matrix, b: constant vector)
     ommx_instance_bytes = generater.get_v1_instance()
 
-    model = adapter.instance_to_model(ommx_instance_bytes)
+    adapter = OMMXPythonMIPAdapter(ommx_instance_bytes)
+    model = adapter.solver_input
     model.optimize()
-    ommx_state = adapter.model_to_state(model, ommx_instance_bytes)
+    ommx_state = adapter.decode_to_state(model)
     expected_solution = generater.get_v1_state()
     assert ommx_state.entries.keys() == expected_solution.entries.keys()
     for key in ommx_state.entries.keys():
@@ -50,9 +52,24 @@ def test_integration_milp():
         sense=Instance.MINIMIZE,
     )
 
-    model = adapter.instance_to_model(ommx_instance)
+    adapter = OMMXPythonMIPAdapter(ommx_instance)
+    model = adapter.solver_input
     model.optimize()
-    ommx_state = adapter.model_to_state(model, ommx_instance)
+    ommx_state = adapter.decode_to_state(model)
 
     assert ommx_state.entries[1] == pytest.approx(3)
     assert ommx_state.entries[2] == pytest.approx(3)
+
+
+def test_solution_optimality():
+    x = DecisionVariable.integer(1, lower=0, upper=5)
+    y = DecisionVariable.integer(1, lower=0, upper=5)
+    ommx_instance = Instance.from_components(
+        decision_variables=[x, y],
+        objective=x + y,
+        constraints=[],
+        sense=Instance.MAXIMIZE,
+    )
+
+    solution = OMMXPythonMIPAdapter.solve(ommx_instance)
+    assert solution.optimality == Optimality.OPTIMALITY_OPTIMAL

{ommx_python_mip_adapter-1.7.0 → ommx_python_mip_adapter-1.8.0}/tests/test_model_to_instance.py

@@ -1,9 +1,8 @@
 import mip
 
 from ommx.v1 import Instance, DecisionVariable, Constraint
-from ommx.v1.solution_pb2 import Optimality
 
-import ommx_python_mip_adapter as adapter
+from ommx_python_mip_adapter import model_to_instance
 
 
 def test_milp():
@@ -44,7 +43,7 @@ def test_milp():
     model.add_constr(-7 * x1 + 8 * x3 - 9 <= 0)  # type: ignore
     model.add_constr(10 * x2 - 11 * x3 + 12 >= 0)  # type: ignore
 
-    ommx_instance = adapter.model_to_instance(model).raw
+    ommx_instance = model_to_instance(model).raw
 
     assert ommx_instance.sense == Instance.MINIMIZE
 
@@ -152,7 +151,7 @@ def test_no_objective_model():
     model.add_constr(1 * x1 + 2 * x2 - 5 == 0)  # type: ignore
     model.add_constr(4 * x1 + 3 * x2 - 10 == 0)  # type: ignore
 
-    ommx_instance = adapter.model_to_instance(model).raw
+    ommx_instance = model_to_instance(model).raw
 
     assert ommx_instance.sense == Instance.MAXIMIZE
 
@@ -201,19 +200,3 @@ def test_no_objective_model():
     constraint2_term_x3 = constraint2.function.linear.terms[1]
     assert constraint2_term_x3.id == 1
     assert constraint2_term_x3.coefficient == 3
-
-
-def test_solution_optimality():
-    x = DecisionVariable.integer(1, lower=0, upper=5)
-    y = DecisionVariable.integer(1, lower=0, upper=5)
-    ommx_instance = Instance.from_components(
-        decision_variables=[x, y],
-        objective=x + y,
-        constraints=[],
-        sense=Instance.MAXIMIZE,
-    )
-
-    model = adapter.instance_to_model(ommx_instance)
-    model.optimize()
-    solution = adapter.model_to_solution(model, ommx_instance)
-    assert solution.optimality == Optimality.OPTIMALITY_OPTIMAL

ommx_python_mip_adapter-1.7.0/ommx_python_mip_adapter/__init__.py

@@ -1,17 +0,0 @@
-from .ommx_to_python_mip import PythonMIPBuilder, instance_to_model, solve
-from .python_mip_to_ommx import (
-    OMMXInstanceBuilder,
-    model_to_instance,
-    model_to_state,
-    model_to_solution,
-)
-
-__all__ = [
-    "instance_to_model",
-    "model_to_instance",
-    "model_to_state",
-    "model_to_solution",
-    "PythonMIPBuilder",
-    "OMMXInstanceBuilder",
-    "solve",
-]

ommx_python_mip_adapter-1.7.0/ommx_python_mip_adapter/ommx_to_python_mip.py

@@ -1,311 +0,0 @@
-from __future__ import annotations
-
-from typing import Optional, final
-from dataclasses import dataclass
-
-import mip
-
-from ommx.v1.function_pb2 import Function
-from ommx.v1.solution_pb2 import Result, Infeasible, Unbounded, Relaxation
-from ommx.v1 import Instance, DecisionVariable, Constraint
-
-from .exception import OMMXPythonMIPAdapterError
-from .python_mip_to_ommx import model_to_solution
-
-
-@dataclass
-class PythonMIPBuilder:
-    """
-    Build Python-MIP Model from ommx.v1.Instance.
-    """
-
-    instance: Instance
-    model: mip.Model
-
-    def __init__(
-        self,
-        instance: Instance,
-        *,
-        solver_name: str = mip.CBC,
-        solver: Optional[mip.Solver] = None,
-        verbose: bool = False,
-    ):
-        if instance.raw.sense == Instance.MAXIMIZE:
-            sense = mip.MAXIMIZE
-        elif instance.raw.sense == Instance.MINIMIZE:
-            sense = mip.MINIMIZE
-        else:
-            raise OMMXPythonMIPAdapterError(
-                f"Not supported sense: {instance.raw.sense}"
-            )
-        self.instance = instance
-        self.model = mip.Model(
-            sense=sense,
-            solver_name=solver_name,
-            solver=solver,
-        )
-        if verbose:
-            self.model.verbose = 1
-        else:
-            self.model.verbose = 0
-
-    def set_decision_variables(self):
-        for var in self.instance.raw.decision_variables:
-            if var.kind == DecisionVariable.BINARY:
-                self.model.add_var(
-                    name=str(var.id),
-                    var_type=mip.BINARY,
-                )
-            elif var.kind == DecisionVariable.INTEGER:
-                self.model.add_var(
-                    name=str(var.id),
-                    var_type=mip.INTEGER,
-                    lb=var.bound.lower,  # type: ignore
-                    ub=var.bound.upper,  # type: ignore
-                )
-            elif var.kind == DecisionVariable.CONTINUOUS:
-                self.model.add_var(
-                    name=str(var.id),
-                    var_type=mip.CONTINUOUS,
-                    lb=var.bound.lower,  # type: ignore
-                    ub=var.bound.upper,  # type: ignore
-                )
-            else:
-                raise OMMXPythonMIPAdapterError(
-                    f"Not supported decision variable kind: "
-                    f"id: {var.id}, kind: {var.kind}"
-                )
-
-    def as_lin_expr(
-        self,
-        f: Function,
-    ) -> mip.LinExpr:
-        """
-        Translate ommx.v1.Function to `mip.LinExpr` or `float`.
-        """
-        if f.HasField("constant"):
-            return mip.LinExpr(const=f.constant)  # type: ignore
-        elif f.HasField("linear"):
-            ommx_linear = f.linear
-            return (
-                mip.xsum(
-                    term.coefficient * self.model.vars[str(term.id)]  # type: ignore
-                    for term in ommx_linear.terms
-                )
-                + ommx_linear.constant
-            )  # type: ignore
-        raise OMMXPythonMIPAdapterError(
-            "The function must be either `constant` or `linear`."
-        )
-
-    def set_objective(self):
-        self.model.objective = self.as_lin_expr(self.instance.raw.objective)  # type: ignore
-
-    def set_constraints(self):
-        for constraint in self.instance.raw.constraints:
-            lin_expr = self.as_lin_expr(constraint.function)
-            if constraint.equality == Constraint.EQUAL_TO_ZERO:
-                constr_expr = lin_expr == 0
-            elif constraint.equality == Constraint.LESS_THAN_OR_EQUAL_TO_ZERO:
-                constr_expr = lin_expr <= 0  # type: ignore
-            else:
-                raise OMMXPythonMIPAdapterError(
-                    f"Not supported constraint equality: "
-                    f"id: {constraint.id}, equality: {constraint.equality}"
-                )
-            self.model.add_constr(constr_expr, name=str(constraint.id))
-
-    @final
-    def build(self) -> mip.Model:
-        self.set_decision_variables()
-        self.set_objective()
-        self.set_constraints()
-        return self.model
-
-
-def instance_to_model(
-    instance: Instance,
-    *,
-    solver_name: str = mip.CBC,
-    solver: Optional[mip.Solver] = None,
-    verbose: bool = False,
-) -> mip.Model:
-    """
-    The function to convert ommx.v1.Instance to Python-MIP Model.
-
-    Examples
-    =========
-
-    .. doctest::
-
-        The following example of solving an unconstrained linear optimization problem with x1 as the objective function.
-
-        >>> import ommx_python_mip_adapter as adapter
-        >>> from ommx.v1 import Instance, DecisionVariable
-
-        >>> x1 = DecisionVariable.integer(1, lower=0, upper=5)
-        >>> ommx_instance = Instance.from_components(
-        ...     decision_variables=[x1],
-        ...     objective=x1,
-        ...     constraints=[],
-        ...     sense=Instance.MINIMIZE,
-        ... )
-        >>> model = adapter.instance_to_model(ommx_instance)
-        >>> model.optimize()
-        <OptimizationStatus.OPTIMAL: 0>
-
-        >>> ommx_state = adapter.model_to_state(model, ommx_instance)
-        >>> ommx_state.entries
-        {1: 0.0}
-    """
-    builder = PythonMIPBuilder(
-        instance,
-        solver_name=solver_name,
-        solver=solver,
-        verbose=verbose,
-    )
-    return builder.build()
-
-
-def solve(
-    instance: Instance,
-    *,
-    relax: bool = False,
-    solver_name: str = mip.CBC,
-    solver: Optional[mip.Solver] = None,
-    verbose: bool = False,
-) -> Result:
-    """
-    Solve the given ommx.v1.Instance by Python-MIP, and return ommx.v1.Solution.
-
-    :param instance: The ommx.v1.Instance to solve.
-    :param relax: If True, relax all integer variables to continuous one by calling `Model.relax() <https://docs.python-mip.com/en/latest/classes.html#mip.Model.relax>`_ of Python-MIP.
-
-    Examples
-    =========
-
-    KnapSack Problem
-
-    .. doctest::
-
-        >>> from ommx.v1 import Instance, DecisionVariable
-        >>> from ommx.v1.solution_pb2 import Optimality
-        >>> from ommx_python_mip_adapter import solve
-
-        >>> p = [10, 13, 18, 31, 7, 15]
-        >>> w = [11, 15, 20, 35, 10, 33]
-        >>> x = [DecisionVariable.binary(i) for i in range(6)]
-        >>> instance = Instance.from_components(
-        ...     decision_variables=x,
-        ...     objective=sum(p[i] * x[i] for i in range(6)),
-        ...     constraints=[sum(w[i] * x[i] for i in range(6)) <= 47],
-        ...     sense=Instance.MAXIMIZE,
-        ... )
-
-        Solve it
-
-        >>> result = solve(instance)
-        >>> solution = result.solution
-
-        Check output
-
-        >>> sorted([(id, value) for id, value in solution.state.entries.items()])
-        [(0, 1.0), (1, 0.0), (2, 0.0), (3, 1.0), (4, 0.0), (5, 0.0)]
-        >>> solution.feasible
-        True
-        >>> assert solution.optimality == Optimality.OPTIMALITY_OPTIMAL
-
-        p[0] + p[3] = 41
-        w[0] + w[3] = 46 <= 47
-
-        >>> solution.objective
-        41.0
-        >>> solution.evaluated_constraints[0].evaluated_value
-        -1.0
-
-    Infeasible Problem
-
-    .. doctest::
-
-            >>> from ommx.v1 import Instance, DecisionVariable
-            >>> from ommx_python_mip_adapter import solve
-
-            >>> x = DecisionVariable.integer(0, upper=3, lower=0)
-            >>> instance = Instance.from_components(
-            ...     decision_variables=[x],
-            ...     objective=x,
-            ...     constraints=[x >= 4],
-            ...     sense=Instance.MAXIMIZE,
-            ... )
-
-            >>> result = solve(instance)
-            >>> assert result.HasField("infeasible") is True
-            >>> assert result.HasField("unbounded") is False
-            >>> assert result.HasField("solution") is False
-
-    Unbounded Problem
-
-    .. doctest::
-
-            >>> from ommx.v1 import Instance, DecisionVariable
-            >>> from ommx_python_mip_adapter import solve
-
-            >>> x = DecisionVariable.integer(0, lower=0)
-            >>> instance = Instance.from_components(
-            ...     decision_variables=[x],
-            ...     objective=x,
-            ...     constraints=[],
-            ...     sense=Instance.MAXIMIZE,
-            ... )
-
-            >>> result = solve(instance)
-            >>> assert result.HasField("unbounded") is True
-            >>> assert result.HasField("infeasible") is False
-            >>> assert result.HasField("solution") is False
-
-    Dual variable
-
-    .. doctest::
-
-            >>> from ommx.v1 import Instance, DecisionVariable
-            >>> from ommx_python_mip_adapter import solve
-
-            >>> x = DecisionVariable.continuous(0, lower=0, upper=1)
-            >>> y = DecisionVariable.continuous(1, lower=0, upper=1)
-            >>> instance = Instance.from_components(
-            ...     decision_variables=[x, y],
-            ...     objective=x + y,
-            ...     constraints=[x + y <= 1],
-            ...     sense=Instance.MAXIMIZE,
-            ... )
-
-            >>> solution = solve(instance).solution
-            >>> solution.evaluated_constraints[0].dual_variable
-            1.0
-
-    """
-    model = instance_to_model(
-        instance, solver_name=solver_name, solver=solver, verbose=verbose
-    )
-    if relax:
-        model.relax()
-    model.optimize()
-
-    if model.status == mip.OptimizationStatus.INFEASIBLE:
-        return Result(infeasible=Infeasible())
-
-    if model.status == mip.OptimizationStatus.UNBOUNDED:
-        return Result(unbounded=Unbounded())
-
-    if model.status not in [
-        mip.OptimizationStatus.OPTIMAL,
-        mip.OptimizationStatus.FEASIBLE,
-    ]:
-        return Result(error=f"Unknown status: {model.status}")
-
-    solution = model_to_solution(model, instance)
-
-    if relax:
-        solution.raw.relaxation = Relaxation.RELAXATION_LP_RELAXED
-
-    return Result(solution=solution.raw)