ommx-python-mip-adapter 0.4.0__tar.gz → 0.5.0__tar.gz

{ommx_python_mip_adapter-0.4.0 → ommx_python_mip_adapter-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ommx_python_mip_adapter
-Version: 0.4.0
+Version: 0.5.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-python-mip-adapter
@@ -15,7 +15,7 @@ Classifier: License :: OSI Approved :: Apache Software License
 Classifier: License :: OSI Approved :: MIT License
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
-Requires-Dist: ommx<0.5.0,>=0.4.0
+Requires-Dist: ommx<0.6.0,>=0.5.0
 Requires-Dist: mip
 Provides-Extra: dev
 Requires-Dist: markdown-code-runner; extra == "dev"

ommx_python_mip_adapter-0.5.0/ommx_python_mip_adapter/__init__.py

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

ommx_python_mip_adapter-0.5.0/ommx_python_mip_adapter/ommx_to_python_mip.py

@@ -0,0 +1,328 @@
+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 Optimality, 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_solutions = adapter.model_to_solution(model, ommx_instance)
+        >>> ommx_solutions.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}")
+
+    state = model_to_solution(model, instance)
+    solution = instance.evaluate(state)
+
+    assert solution.raw.feasible
+
+    if model.status == mip.OptimizationStatus.OPTIMAL:
+        solution.raw.optimality = Optimality.OPTIMALITY_OPTIMAL
+
+    if relax:
+        solution.raw.relaxation = Relaxation.RELAXATION_LP_RELAXED
+
+    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]
+
+    return Result(solution=solution.raw)

ommx_python_mip_adapter-0.5.0/ommx_python_mip_adapter/python_mip_to_ommx.py

@@ -0,0 +1,200 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import final
+import mip
+
+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
+from ommx.v1 import Instance, DecisionVariable
+
+from .exception import OMMXPythonMIPAdapterError
+
+
+@dataclass
+class OMMXInstanceBuilder:
+    """
+    Build ommx.v1.Instance from Python-MIP Model.
+    """
+
+    model: mip.Model
+
+    def decision_variables(self) -> list[DecisionVariable]:
+        """
+        Gather decision variables from Python-MIP Model as ommx.v1.DecisionVariable.
+        """
+        decision_variables = []
+        for var in self.model.vars:
+            if var.var_type == mip.BINARY:
+                kind = DecisionVariable.BINARY
+            elif var.var_type == mip.INTEGER:
+                kind = DecisionVariable.INTEGER
+            elif var.var_type == mip.CONTINUOUS:
+                kind = DecisionVariable.CONTINUOUS
+            else:
+                raise OMMXPythonMIPAdapterError(
+                    f"Not supported variable type. "
+                    f"idx: {var.idx} name: {var.name}, type: {var.var_type}"
+                )
+            decision_variables.append(
+                DecisionVariable.of_type(
+                    kind, var.idx, lower=var.lb, upper=var.ub, name=var.name
+                )
+            )
+        return decision_variables
+
+    def as_ommx_function(self, lin_expr: mip.LinExpr) -> Function:
+        terms = [
+            Linear.Term(id=var.idx, coefficient=coefficient)  # type: ignore
+            for var, coefficient in lin_expr.expr.items()
+        ]
+        constant: float = lin_expr.const  # type: ignore
+
+        # If the terms are empty, the function is a constant.
+        if len(terms) == 0:
+            return Function(constant=constant)
+        else:
+            return Function(linear=Linear(terms=terms, constant=constant))
+
+    def objective(self) -> Function:
+        # In Python-MIP, it is allowed not to set the objective function.
+        # If it isn't set, the model behaves as if the objective function is set to 0.
+        # However, an error occurs when accessing `.objective`.
+        # So if an error occurs, treat the objective function as 0.
+        try:
+            objective = self.model.objective
+        except ParameterNotAvailable:
+            return Function(constant=0)
+
+        return self.as_ommx_function(objective)
+
+    def constraints(self) -> list[Constraint]:
+        constraints = []
+
+        for constr in self.model.constrs:
+            id = constr.idx
+            lin_expr = constr.expr
+            name = constr.name
+
+            if lin_expr.sense == "=":
+                constraint = Constraint(
+                    id=id,
+                    equality=Equality.EQUALITY_EQUAL_TO_ZERO,
+                    function=self.as_ommx_function(lin_expr),
+                    name=name,
+                )
+            elif lin_expr.sense == "<":
+                constraint = Constraint(
+                    id=id,
+                    equality=Equality.EQUALITY_LESS_THAN_OR_EQUAL_TO_ZERO,
+                    function=self.as_ommx_function(lin_expr),
+                    name=name,
+                )
+            elif lin_expr.sense == ">":
+                # `ommx.v1.Constraint` does not support `GREATER_THAN_OR_EQUAL_TO_ZERO`.
+                # So multiply the linear expression by -1.
+                constraint = Constraint(
+                    id=id,
+                    equality=Equality.EQUALITY_LESS_THAN_OR_EQUAL_TO_ZERO,
+                    function=self.as_ommx_function(-lin_expr),
+                    name=name,
+                )
+            else:
+                raise OMMXPythonMIPAdapterError(
+                    f"Not supported constraint sense: "
+                    f"name: {constr.name}, sense: {lin_expr.sense}"
+                )
+
+            constraints.append(constraint)
+
+        return constraints
+
+    def sense(self):
+        if self.model.sense == mip.MAXIMIZE:
+            return Instance.MAXIMIZE
+        elif self.model.sense == mip.MINIMIZE:
+            return Instance.MINIMIZE
+        raise OMMXPythonMIPAdapterError(f"Not supported sense: {self.model.sense}")
+
+    @final
+    def build(self) -> Instance:
+        return Instance.from_components(
+            decision_variables=self.decision_variables(),
+            objective=self.objective(),
+            constraints=self.constraints(),
+            sense=self.sense(),
+        )
+
+
+def model_to_instance(model: mip.Model) -> Instance:
+    """
+    The function to convert Python-MIP Model to ommx.v1.Instance.
+
+    Examples
+    =========
+
+    .. doctest::
+        >>> import mip
+        >>> import ommx_python_mip_adapter as adapter
+
+        >>> model = mip.Model()
+        >>> x1=model.add_var(name="1", var_type=mip.INTEGER, lb=0, ub=5)
+        >>> x2=model.add_var(name="2", var_type=mip.CONTINUOUS, lb=0, ub=5)
+
+        >>> model.objective = - x1 - 2 * x2
+        >>> constr = model.add_constr(x1 + x2 - 6 <= 0)
+
+        >>> ommx_instance = adapter.model_to_instance(model)
+    """
+    builder = OMMXInstanceBuilder(model)
+    return builder.build()
+
+
+def model_to_solution(
+    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_solutions = adapter.model_to_solution(model, ommx_instance)
+        >>> ommx_solutions.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
+        }
+    )

{ommx_python_mip_adapter-0.4.0 → ommx_python_mip_adapter-0.5.0}/ommx_python_mip_adapter.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ommx_python_mip_adapter
-Version: 0.4.0
+Version: 0.5.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-python-mip-adapter
@@ -15,7 +15,7 @@ Classifier: License :: OSI Approved :: Apache Software License
 Classifier: License :: OSI Approved :: MIT License
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
-Requires-Dist: ommx<0.5.0,>=0.4.0
+Requires-Dist: ommx<0.6.0,>=0.5.0
 Requires-Dist: mip
 Provides-Extra: dev
 Requires-Dist: markdown-code-runner; extra == "dev"

{ommx_python_mip_adapter-0.4.0 → ommx_python_mip_adapter-0.5.0}/ommx_python_mip_adapter.egg-info/SOURCES.txt

@@ -1,8 +1,9 @@
 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-0.4.0 → ommx_python_mip_adapter-0.5.0}/ommx_python_mip_adapter.egg-info/requires.txt

@@ -1,4 +1,4 @@
-ommx<0.5.0,>=0.4.0
+ommx<0.6.0,>=0.5.0
 mip
 
 [dev]

{ommx_python_mip_adapter-0.4.0 → ommx_python_mip_adapter-0.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ommx_python_mip_adapter"
-version = "0.4.0"
+version = "0.5.0"
 
 description = "An adapter for the Python-MIP from/to OMMX."
 authors = [
@@ -24,7 +24,7 @@ classifiers = [
     "License :: OSI Approved :: MIT License",
 ]
 dependencies = [
-    "ommx >= 0.4.0, < 0.5.0",
+    "ommx >= 0.5.0, < 0.6.0",
     "mip",
 ]
 

{ommx_python_mip_adapter-0.4.0 → ommx_python_mip_adapter-0.5.0}/tests/test_instance_to_model.py

@@ -41,7 +41,7 @@ def test_error_nonlinear_objective():
 
     with pytest.raises(OMMXPythonMIPAdapterError) as e:
         adapter.instance_to_model(ommx_instance)
-    assert "The objective function must be" in str(e.value)
+    assert "The function must be either `constant` or `linear`." in str(e.value)
 
 
 def test_error_nonlinear_constraint():
@@ -65,7 +65,7 @@ def test_error_nonlinear_constraint():
 
     with pytest.raises(OMMXPythonMIPAdapterError) as e:
         adapter.instance_to_model(ommx_instance)
-    assert "Only linear constraints are supported" in str(e.value)
+    assert "The function must be either `constant` or `linear`." in str(e.value)
 
 
 def test_error_not_supported_constraint_equality():

ommx_python_mip_adapter-0.4.0/ommx_python_mip_adapter/__init__.py

@@ -1,11 +0,0 @@
-from ommx_python_mip_adapter.adapter import (
-    instance_to_model,
-    model_to_instance,
-    model_to_solution,
-)
-
-__all__ = [
-    "instance_to_model",
-    "model_to_instance",
-    "model_to_solution",
-]

ommx_python_mip_adapter-0.4.0/ommx_python_mip_adapter/adapter.py

@@ -1,362 +0,0 @@
-import typing as tp
-
-import mip
-
-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
-from ommx.v1 import Instance, DecisionVariable
-
-from ommx_python_mip_adapter.exception import OMMXPythonMIPAdapterError
-
-
-class PythonMIPBuilder:
-    def __init__(
-        self,
-        instance: Instance,
-        *,
-        sense: str = mip.MINIMIZE,
-        solver_name: str = mip.CBC,
-        solver: tp.Optional[mip.Solver] = None,
-    ):
-        self._ommx_instance = instance.raw
-        self._model = mip.Model(
-            sense=sense,
-            solver_name=solver_name,
-            solver=solver,
-        )
-
-    def _set_decision_variables(self):
-        for var in self._ommx_instance.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 _make_linear_expr(
-        self,
-        ommx_function: Function,
-    ) -> mip.LinExpr:
-        ommx_linear = ommx_function.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
-
-    def _set_objective_function(self):
-        ommx_objective = self._ommx_instance.objective
-
-        if ommx_objective.HasField("constant"):
-            self._model.objective = ommx_objective.constant  # type: ignore
-        elif ommx_objective.HasField("linear"):
-            self._model.objective = self._make_linear_expr(ommx_objective)
-        else:
-            raise OMMXPythonMIPAdapterError(
-                "The objective function must be either `constant` or `linear`."
-            )
-
-    def _set_constraints(self):
-        ommx_constraints = self._ommx_instance.constraints
-
-        for constraint in ommx_constraints:
-            if not constraint.function.HasField("linear"):
-                raise OMMXPythonMIPAdapterError(
-                    f"Only linear constraints are supported: "
-                    f"id: {constraint.id}, "
-                    f"type: {constraint.function.WhichOneof('function')}"
-                )
-
-            lin_expr = self._make_linear_expr(constraint.function)
-
-            if constraint.equality == Equality.EQUALITY_EQUAL_TO_ZERO:
-                constr_expr = lin_expr == 0
-            elif constraint.equality == Equality.EQUALITY_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))
-
-    def build(self) -> mip.Model:
-        self._set_decision_variables()
-        self._set_objective_function()
-        self._set_constraints()
-
-        return self._model
-
-
-class OMMXInstanceBuilder:
-    def __init__(
-        self,
-        model: mip.Model,
-    ):
-        self._model = model
-
-    def _decision_variables(self) -> tp.List[DecisionVariable]:
-        decision_variables = []
-
-        for var in self._model.vars:
-            if var.var_type == mip.BINARY:
-                kind = DecisionVariable.BINARY
-            elif var.var_type == mip.INTEGER:
-                kind = DecisionVariable.INTEGER
-            elif var.var_type == mip.CONTINUOUS:
-                kind = DecisionVariable.CONTINUOUS
-            else:
-                raise OMMXPythonMIPAdapterError(
-                    f"Not supported variable type. "
-                    f"idx: {var.idx} name: {var.name}, type: {var.var_type}"
-                )
-
-            decision_variables.append(
-                DecisionVariable.of_type(
-                    kind, var.idx, lower=var.lb, upper=var.ub, name=var.name
-                )
-            )
-
-        return decision_variables
-
-    def _make_function_from_lin_expr(
-        self,
-        lin_expr: mip.LinExpr,
-    ) -> Function:
-        terms = [
-            Linear.Term(id=var.idx, coefficient=coeff)  # type: ignore
-            for var, coeff in lin_expr.expr.items()
-        ]
-        constant: float = lin_expr.const  # type: ignore
-
-        # If the terms are empty, the function is a constant.
-        if len(terms) == 0:
-            return Function(constant=constant)
-        else:
-            return Function(linear=Linear(terms=terms, constant=constant))
-
-    def _objective(self) -> Function:
-        # In Python-MIP, it is allowed not to set the objective function.
-        # If it isn't set, the model behaves as if the objective function is set to 0.
-        # However, an error occurs when accessing `.objective`.
-        # So if an error occurs, treat the objective function as 0.
-        try:
-            objective = self._model.objective
-        except ParameterNotAvailable:
-            return Function(constant=0)
-
-        return self._make_function_from_lin_expr(objective)
-
-    def _constraints(self) -> tp.List[Constraint]:
-        constraints = []
-
-        for constr in self._model.constrs:
-            id = constr.idx
-            lin_expr = constr.expr
-            name = constr.name
-
-            if lin_expr.sense == "=":
-                constraint = Constraint(
-                    id=id,
-                    equality=Equality.EQUALITY_EQUAL_TO_ZERO,
-                    function=self._make_function_from_lin_expr(lin_expr),
-                    name=name,
-                )
-            elif lin_expr.sense == "<":
-                constraint = Constraint(
-                    id=id,
-                    equality=Equality.EQUALITY_LESS_THAN_OR_EQUAL_TO_ZERO,
-                    function=self._make_function_from_lin_expr(lin_expr),
-                    name=name,
-                )
-            elif lin_expr.sense == ">":
-                # `ommx.v1.Constraint` does not support `GREATER_THAN_OR_EQUAL_TO_ZERO`.
-                # So multiply the linear expression by -1.
-                constraint = Constraint(
-                    id=id,
-                    equality=Equality.EQUALITY_LESS_THAN_OR_EQUAL_TO_ZERO,
-                    function=self._make_function_from_lin_expr(-lin_expr),
-                    name=name,
-                )
-            else:
-                raise OMMXPythonMIPAdapterError(
-                    f"Not supported constraint sense: "
-                    f"name: {constr.name}, sense: {lin_expr.sense}"
-                )
-
-            constraints.append(constraint)
-
-        return constraints
-
-    def _sense(self):
-        if self._model.sense == mip.MAXIMIZE:
-            return Instance.MAXIMIZE
-        else:
-            return Instance.MINIMIZE
-
-    def build(self) -> Instance:
-        return Instance.from_components(
-            decision_variables=self._decision_variables(),
-            objective=self._objective(),
-            constraints=self._constraints(),
-            sense=self._sense(),
-        )
-
-
-def instance_to_model(
-    instance: Instance,
-    *,
-    sense: str = mip.MINIMIZE,
-    solver_name: str = mip.CBC,
-    solver: tp.Optional[mip.Solver] = None,
-) -> mip.Model:
-    """
-    The function to convert ommx.v1.Instance to Python-MIP Model.
-
-    Args:
-        ommx_instance_bytes (bytes): Serialized ommx.v1.Instance.
-        sense (str): mip.MINIMIZE or mip.MAXIMIZE.
-        solver_name (str): mip.CBC or mip.GUROBI. Searches for which solver is available if not informed.
-        solver (mip.Solver): if this argument is provided, solver_name will be ignored.
-
-    Returns:
-        mip.Model: Python-MIP Model converted from ommx.v1.Instance.
-
-    Raises:
-        OMMXPythonMIPAdapterError: If converting is not possible.
-
-    Examples:
-        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_solutions = adapter.model_to_solution(model, ommx_instance)
-        >>> ommx_solutions.entries
-        {1: 0.0}
-    """
-    builder = PythonMIPBuilder(
-        instance,
-        sense=sense,
-        solver_name=solver_name,
-        solver=solver,
-    )
-    return builder.build()
-
-
-def model_to_instance(model: mip.Model) -> Instance:
-    """
-    The function to convert Python-MIP Model to ommx.v1.Instance.
-
-    Args:
-        model (mip.Model): Python-MIP Model.
-
-    Returns:
-        bytes: Serialized ommx.v1.Instance.
-
-    Raises:
-        OMMXPythonMIPAdapterError: If converting is not possible.
-
-    Examples:
-        >>> import mip
-        >>> import ommx_python_mip_adapter as adapter
-        >>> model = mip.Model()
-        >>> x1=model.add_var(name="1", var_type=mip.INTEGER, lb=0, ub=5)
-        >>> x2=model.add_var(name="2", var_type=mip.CONTINUOUS, lb=0, ub=5)
-        >>> model.objective = - x1 - 2 * x2
-        >>> constr = model.add_constr(x1 + x2 - 6 <= 0)
-        >>> ommx_instance = adapter.model_to_instance(model)
-    """
-    builder = OMMXInstanceBuilder(model)
-    return builder.build()
-
-
-def model_to_solution(
-    model: mip.Model,
-    instance: Instance,
-) -> State:
-    """
-    The function to create ommx.v1.SolutionList from optimized Python-MIP Model.
-
-    Args:
-        model (mip.Model): Optimized Python-MIP Model.
-        ommx_instance_bytes (bytes): Serialized ommx.v1.Instance.
-
-    Returns:
-        bytes: Serialized ommx.v1.SolutionList
-
-    Raises:
-        OMMXPythonMIPAdapterError: When ommx.v1.SolutionList cannot be created.
-
-    Examples:
-        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_solutions = adapter.model_to_solution(model, ommx_instance)
-        >>> ommx_solutions.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
-        }
-    )