ommx-python-mip-adapter 0.3.4__tar.gz → 0.4.1__tar.gz

{ommx_python_mip_adapter-0.3.4 → ommx_python_mip_adapter-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ommx_python_mip_adapter
-Version: 0.3.4
+Version: 0.4.1
 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.4.0,>=0.3.4
+Requires-Dist: ommx<0.5.0,>=0.4.1
 Requires-Dist: mip
 Provides-Extra: dev
 Requires-Dist: markdown-code-runner; extra == "dev"

ommx_python_mip_adapter-0.4.1/ommx_python_mip_adapter/__init__.py

@@ -0,0 +1,14 @@
+from .ommx_to_python_mip import PythonMIPBuilder, instance_to_model
+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",
+]

ommx_python_mip_adapter-0.4.1/ommx_python_mip_adapter/ommx_to_python_mip.py

@@ -0,0 +1,155 @@
+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 import Instance, DecisionVariable, Constraint
+
+from .exception import OMMXPythonMIPAdapterError
+
+
+@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,
+    ):
+        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,
+        )
+
+    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,
+) -> mip.Model:
+    """
+    The function to convert ommx.v1.Instance to Python-MIP Model.
+
+    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,
+        solver_name=solver_name,
+        solver=solver,
+    )
+    return builder.build()

ommx_python_mip_adapter-0.4.1/ommx_python_mip_adapter/python_mip_to_ommx.py

@@ -0,0 +1,193 @@
+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:
+        >>> 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:
+        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.3.4 → ommx_python_mip_adapter-0.4.1}/ommx_python_mip_adapter.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ommx_python_mip_adapter
-Version: 0.3.4
+Version: 0.4.1
 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.4.0,>=0.3.4
+Requires-Dist: ommx<0.5.0,>=0.4.1
 Requires-Dist: mip
 Provides-Extra: dev
 Requires-Dist: markdown-code-runner; extra == "dev"

{ommx_python_mip_adapter-0.3.4 → ommx_python_mip_adapter-0.4.1}/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.3.4 → ommx_python_mip_adapter-0.4.1}/ommx_python_mip_adapter.egg-info/requires.txt

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

{ommx_python_mip_adapter-0.3.4 → ommx_python_mip_adapter-0.4.1}/pyproject.toml

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

{ommx_python_mip_adapter-0.3.4 → ommx_python_mip_adapter-0.4.1}/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.3.4 → ommx_python_mip_adapter-0.4.1}/tests/test_model_to_instance.py

@@ -54,19 +54,19 @@ def test_milp():
     assert decision_variables_x1.kind == DecisionVariable.CONTINUOUS
     assert decision_variables_x1.bound.lower == CONTINUOUS_LOWER_BOUND
     assert decision_variables_x1.bound.upper == CONTINUOUS_UPPER_BOUND
-    assert decision_variables_x1.description.name == "1"
+    assert decision_variables_x1.name == "1"
     decision_variables_x2 = ommx_instance.decision_variables[1]
     assert decision_variables_x2.id == 1
     assert decision_variables_x2.kind == DecisionVariable.INTEGER
     assert decision_variables_x2.bound.lower == INTEGER_LOWER_BOUND
     assert decision_variables_x2.bound.upper == INTEGER_UPPER_BOUND
-    assert decision_variables_x2.description.name == "2"
+    assert decision_variables_x2.name == "2"
     decision_variables_x3 = ommx_instance.decision_variables[2]
     assert decision_variables_x3.id == 2
     assert decision_variables_x3.kind == DecisionVariable.BINARY
     assert decision_variables_x3.bound.lower == 0
     assert decision_variables_x3.bound.upper == 1
-    assert decision_variables_x3.description.name == "3"
+    assert decision_variables_x3.name == "3"
 
     # Check the objective function
     assert ommx_instance.objective.HasField("linear")
@@ -162,13 +162,13 @@ def test_no_objective_model():
     assert decision_variables_x1.kind == DecisionVariable.CONTINUOUS
     assert decision_variables_x1.bound.lower == LOWER_BOUND
     assert decision_variables_x1.bound.upper == UPPER_BOUND
-    assert decision_variables_x1.description.name == "1"
+    assert decision_variables_x1.name == "1"
     decision_variables_x2 = ommx_instance.decision_variables[1]
     assert decision_variables_x2.id == 1
     assert decision_variables_x2.kind == DecisionVariable.CONTINUOUS
     assert decision_variables_x2.bound.lower == LOWER_BOUND
     assert decision_variables_x2.bound.upper == UPPER_BOUND
-    assert decision_variables_x2.description.name == "2"
+    assert decision_variables_x2.name == "2"
 
     # check the objective function
     assert ommx_instance.objective.HasField("constant")

ommx_python_mip_adapter-0.3.4/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.3.4/ommx_python_mip_adapter/adapter.py

@@ -1,366 +0,0 @@
-import typing as tp
-
-import mip
-
-from mip.exceptions import ParameterNotAvailable
-from ommx.v1.constraint_pb2 import Constraint, Equality, ConstraintDescription
-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,
-                    description=DecisionVariable.Description(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),
-                    description=ConstraintDescription(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),
-                    description=ConstraintDescription(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),
-                    description=ConstraintDescription(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
-        }
-    )