pyoframe 0.0.5__tar.gz → 0.0.6__tar.gz

{pyoframe-0.0.5/src/pyoframe.egg-info → pyoframe-0.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyoframe
-Version: 0.0.5
+Version: 0.0.6
 Summary: Blazing fast linear program interface
 Author-email: Bravos Power <dev@bravospower.com>
 Project-URL: Homepage, https://bravos-power.github.io/pyoframe/

{pyoframe-0.0.5 → pyoframe-0.0.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pyoframe"
-version = "0.0.5"
+version = "0.0.6"
 authors = [{ name = "Bravos Power", email = "dev@bravospower.com" }]
 description = "Blazing fast linear program interface"
 readme = "README.md"

{pyoframe-0.0.5 → pyoframe-0.0.6}/src/pyoframe/_arithmetic.py

@@ -106,7 +106,7 @@ def _add_expressions_core(*expressions: "Expression") -> "Expression":
 
         strat = (left.unmatched_strategy, right.unmatched_strategy)
 
-        propogate_strat = propogatation_strategies[strat]
+        propogate_strat = propogatation_strategies[strat]  # type: ignore
 
         if strat == (UnmatchedStrategy.DROP, UnmatchedStrategy.DROP):
             left_data = left.data.join(get_indices(right), how="inner", on=dims)

{pyoframe-0.0.5 → pyoframe-0.0.6}/src/pyoframe/constants.py

@@ -132,8 +132,11 @@ class SolverStatus(Enum):
     def from_termination_condition(
         cls, termination_condition: "TerminationCondition"
     ) -> "SolverStatus":
-        for status in STATUS_TO_TERMINATION_CONDITION_MAP:
-            if termination_condition in STATUS_TO_TERMINATION_CONDITION_MAP[status]:
+        for (
+            status,
+            termination_conditions,
+        ) in STATUS_TO_TERMINATION_CONDITION_MAP.items():
+            if termination_condition in termination_conditions:
                 return status
         return cls("unknown")
 

{pyoframe-0.0.5 → pyoframe-0.0.6}/src/pyoframe/core.py

@@ -689,9 +689,9 @@ class Expression(ModelElement, SupportsMath, SupportPolarsMethodMixin):
             >>> import pyoframe as pf
             >>> m = pf.Model("max")
             >>> m.X = pf.Variable({"dim1": [1, 2, 3]}, ub=10)
-            >>> m.expr_1 = 2 * m.X
+            >>> m.expr_1 = 2 * m.X + 1
             >>> m.expr_2 = pf.sum(m.expr_1)
-            >>> m.objective = m.expr_2 + 3
+            >>> m.objective = m.expr_2 - 3
             >>> result = m.solve(log_to_console=False)
             >>> m.expr_1.value
             shape: (3, 2)
@@ -700,15 +700,16 @@ class Expression(ModelElement, SupportsMath, SupportPolarsMethodMixin):
             │ ---  ┆ ---      │
             │ i64  ┆ f64      │
             ╞══════╪══════════╡
-            │ 1    ┆ 20.0     │
-            │ 2    ┆ 20.0     │
-            │ 3    ┆ 20.0     │
+            │ 1    ┆ 21.0     │
+            │ 2    ┆ 21.0     │
+            │ 3    ┆ 21.0     │
             └──────┴──────────┘
             >>> m.expr_2.value
-            60.0
-            >>> m.objective.value
             63.0
         """
+        assert (
+            self._model is not None
+        ), "Expression must be added to the model to use .value"
         if self._model.result is None or self._model.result.solution is None:
             raise ValueError(
                 "Can't obtain value of expression since the model has not been solved."
@@ -716,8 +717,15 @@ class Expression(ModelElement, SupportsMath, SupportPolarsMethodMixin):
 
         df = (
             self.data.join(self._model.result.solution.primal, on=VAR_KEY, how="left")
+            .with_columns(
+                (
+                    pl.when(pl.col(VAR_KEY) == CONST_TERM)
+                    .then(1)
+                    .otherwise(pl.col(SOLUTION_KEY))
+                    * pl.col(COEF_KEY)
+                ).alias(SOLUTION_KEY)
+            )
             .drop(VAR_KEY)
-            .with_columns((pl.col(SOLUTION_KEY) * pl.col(COEF_KEY)))
             .drop(COEF_KEY)
         )
 
@@ -924,6 +932,9 @@ class Constraint(ModelElementWithId):
         The first call to this property will load the slack values from the solver (lazy loading).
         """
         if SLACK_COL not in self.data.columns:
+            assert (
+                self._model is not None
+            ), "Constraint must be added to a model to get the slack."
             if self._model.solver is None:
                 raise ValueError("The model has not been solved yet.")
             self._model.solver.load_slack()
@@ -1160,7 +1171,7 @@ class Variable(ModelElementWithId, SupportsMath, SupportPolarsMethodMixin):
         lb: float | int | SupportsToExpr | None = None,
         ub: float | int | SupportsToExpr | None = None,
         vtype: VType | VTypeValue = VType.CONTINUOUS,
-        equals: SupportsToExpr = None,
+        equals: Optional[SupportsMath] = None,
     ):
         if lb is None:
             lb = float("-inf")
@@ -1222,6 +1233,9 @@ class Variable(ModelElementWithId, SupportsMath, SupportPolarsMethodMixin):
         The first call to this property will load the reduced costs from the solver (lazy loading).
         """
         if RC_COL not in self.data.columns:
+            assert (
+                self._model is not None
+            ), "Variable must be added to a model to get the reduced cost."
             if self._model.solver is None:
                 raise ValueError("The model has not been solved yet.")
             self._model.solver.load_rc()

{pyoframe-0.0.5 → pyoframe-0.0.6}/src/pyoframe/io.py

@@ -11,8 +11,8 @@ from tqdm import tqdm
 from pyoframe.constants import CONST_TERM, VAR_KEY, ObjSense
 from pyoframe.core import Constraint, Variable
 from pyoframe.io_mappers import (
-    Base62ConstMapper,
-    Base62VarMapper,
+    Base36ConstMapper,
+    Base36VarMapper,
     IOMappers,
     Mapper,
     NamedMapper,
@@ -131,7 +131,7 @@ def get_var_map(m: "Model", use_var_names):
             return m.var_map
         var_map = NamedVariableMapper(Variable)
     else:
-        var_map = Base62VarMapper(Variable)
+        var_map = Base36VarMapper(Variable)
 
     for v in m.variables:
         var_map.add(v)
@@ -139,10 +139,20 @@ def get_var_map(m: "Model", use_var_names):
 
 
 def to_file(
-    m: "Model", file_path: Optional[Union[str, Path]], use_var_names=False
+    m: "Model", file_path: Optional[Union[str, Path]] = None, use_var_names=False
 ) -> Path:
     """
     Write out a model to a lp file.
+
+    Args:
+        m: The model to write out.
+        file_path: The path to write the model to. If None, a temporary file is created. The caller is responsible for
+            deleting the file after use.
+        use_var_names: If True, variable names are used in the lp file. Otherwise, variable
+            indices are used.
+
+    Returns:
+        The path to the lp file.
     """
     if file_path is None:
         with NamedTemporaryFile(
@@ -157,7 +167,7 @@ def to_file(
         file_path.unlink()
 
     const_map = (
-        NamedMapper(Constraint) if use_var_names else Base62ConstMapper(Constraint)
+        NamedMapper(Constraint) if use_var_names else Base36ConstMapper(Constraint)
     )
     for c in m.constraints:
         const_map.add(c)

{pyoframe-0.0.5 → pyoframe-0.0.6}/src/pyoframe/io_mappers.py

@@ -16,7 +16,7 @@ from pyoframe.constants import CONST_TERM
 if TYPE_CHECKING:  # pragma: no cover
     from pyoframe.model import Variable
     from pyoframe.core import Constraint
-    from pyoframe.util import CountableModelElement
+    from pyoframe.model_element import ModelElementWithId
 
 
 @dataclass
@@ -29,7 +29,7 @@ class Mapper(ABC):
 
     NAME_COL = "__name"
 
-    def __init__(self, cls: Type["CountableModelElement"]) -> None:
+    def __init__(self, cls: Type["ModelElementWithId"]) -> None:
         self._ID_COL = cls.get_id_column_name()
         self.mapping_registry = pl.DataFrame(
             {self._ID_COL: [], Mapper.NAME_COL: []},
@@ -43,7 +43,7 @@ class Mapper(ABC):
         self.mapping_registry = pl.concat([self.mapping_registry, df])
 
     @abstractmethod
-    def _element_to_map(self, element: "CountableModelElement") -> pl.DataFrame: ...
+    def _element_to_map(self, element: "ModelElementWithId") -> pl.DataFrame: ...
 
     def apply(
         self,
@@ -107,13 +107,14 @@ class NamedVariableMapper(NamedMapper):
         )
 
 
-class Base62Mapper(Mapper, ABC):
-    # Mapping between a base 62 character and its integer value
+class Base36Mapper(Mapper, ABC):
+    # Mapping between a base 36 character and its integer value
+    # Note: we must use only lowercase since Gurobi auto-converts variables that aren't in constraints to lowercase (kind of annoying)
     _CHAR_TABLE = pl.DataFrame(
-        {"char": list(string.digits + string.ascii_letters)},
+        {"char": list(string.digits + string.ascii_lowercase)},
     ).with_columns(pl.int_range(pl.len()).cast(pl.UInt32).alias("code"))
 
-    _BASE = _CHAR_TABLE.height  # _BASE = 62
+    _BASE = _CHAR_TABLE.height  # _BASE = 36
     _ZERO = _CHAR_TABLE.filter(pl.col("code") == 0).select("char").item()  # _ZERO = "0"
 
     @property
@@ -131,7 +132,7 @@ class Base62Mapper(Mapper, ABC):
         query = pl.concat_str(
             pl.lit(self._prefix),
             pl.col(self._ID_COL).map_batches(
-                Base62Mapper._to_base62,
+                Base36Mapper._to_base36,
                 return_dtype=pl.String,
                 is_elementwise=True,
             ),
@@ -143,24 +144,24 @@ class Base62Mapper(Mapper, ABC):
         return df.with_columns(query.alias(to_col))
 
     @classmethod
-    def _to_base62(cls, int_col: pl.Series) -> pl.Series:
-        """Returns a series of dtype str with a base 62 representation of the integers in int_col.
-        The letters 0-9a-zA-Z are used as symbols for the representation.
+    def _to_base36(cls, int_col: pl.Series) -> pl.Series:
+        """Returns a series of dtype str with a base 36 representation of the integers in int_col.
+        The letters 0-9A-Z are used as symbols for the representation.
 
         Examples:
 
             >>> import polars as pl
             >>> s = pl.Series([0,10,20,60,53,66], dtype=pl.UInt32)
-            >>> Base62Mapper._to_base62(s).to_list()
-            ['0', 'a', 'k', 'Y', 'R', '14']
+            >>> Base36Mapper._to_base36(s).to_list()
+            ['0', 'a', 'k', '1o', '1h', '1u']
 
             >>> s = pl.Series([0], dtype=pl.UInt32)
-            >>> Base62Mapper._to_base62(s).to_list()
+            >>> Base36Mapper._to_base36(s).to_list()
             ['0']
         """
         assert isinstance(
             int_col.dtype, pl.UInt32
-        ), "_to_base62() only works for UInt32 id columns"
+        ), "_to_base36() only works for UInt32 id columns"
 
         largest_id = int_col.max()
         if largest_id == 0:
@@ -193,7 +194,7 @@ class Base62Mapper(Mapper, ABC):
         return self.apply(element.ids.select(self._ID_COL), to_col=Mapper.NAME_COL)
 
 
-class Base62VarMapper(Base62Mapper):
+class Base36VarMapper(Base36Mapper):
     """
     Examples:
         >>> import polars as pl
@@ -203,10 +204,10 @@ class Base62VarMapper(Base62Mapper):
         >>> m.x = Variable(pl.DataFrame({"t": range(1,63)}))
         >>> (m.x.filter(t=11)+1).to_str()
         '[11]: 1  + x[11]'
-        >>> (m.x.filter(t=11)+1).to_str(var_map=Base62VarMapper(Variable))
+        >>> (m.x.filter(t=11)+1).to_str(var_map=Base36VarMapper(Variable))
         '[11]: 1  + xb'
 
-        >>> Base62VarMapper(Variable).apply(pl.DataFrame({VAR_KEY: []}))
+        >>> Base36VarMapper(Variable).apply(pl.DataFrame({VAR_KEY: []}))
         shape: (0, 1)
         ┌───────────────┐
         │ __variable_id │
@@ -230,7 +231,7 @@ class Base62VarMapper(Base62Mapper):
         return "x"
 
 
-class Base62ConstMapper(Base62Mapper):
+class Base36ConstMapper(Base36Mapper):
 
     @property
     def _prefix(self) -> "str":

{pyoframe-0.0.5 → pyoframe-0.0.6}/src/pyoframe/model.py

@@ -37,6 +37,7 @@ class Model(AttrContainerMixin):
         "result",
         "attr",
         "sense",
+        "objective",
     ]
 
     def __init__(self, min_or_max: Union[ObjSense, ObjSenseValue], name=None, **kwargs):
@@ -75,6 +76,12 @@ class Model(AttrContainerMixin):
     def objective(self):
         return self._objective
 
+    @objective.setter
+    def objective(self, value):
+        value = Objective(value)
+        self._objective = value
+        value.on_add_to_model(self, "objective")
+
     def __setattr__(self, __name: str, __value: Any) -> None:
         if __name not in Model._reserved_attributes and not isinstance(
             __value, (ModelElement, pl.DataFrame, pd.DataFrame)
@@ -87,9 +94,6 @@ class Model(AttrContainerMixin):
             isinstance(__value, ModelElement)
             and __name not in Model._reserved_attributes
         ):
-            if __name == "objective":
-                __value = Objective(__value)
-
             if isinstance(__value, ModelElementWithId):
                 assert not hasattr(
                     self, __name
@@ -103,9 +107,6 @@ class Model(AttrContainerMixin):
                     self.var_map.add(__value)
             elif isinstance(__value, Constraint):
                 self._constraints.append(__value)
-            elif isinstance(__value, Objective):
-                self._objective = __value
-                return
         return super().__setattr__(__name, __value)
 
     def __repr__(self) -> str:

{pyoframe-0.0.5 → pyoframe-0.0.6}/src/pyoframe/model_element.py

@@ -109,7 +109,7 @@ def _support_polars_method(method_name: str):
     Wrapper to add a method to ModelElement that simply calls the underlying Polars method on the data attribute.
     """
 
-    def method(self: "SupportPolarsMethodMixin", *args, **kwargs):
+    def method(self: "SupportPolarsMethodMixin", *args, **kwargs) -> Any:
         result_from_polars = getattr(self.data, method_name)(*args, **kwargs)
         if isinstance(result_from_polars, pl.DataFrame):
             return self._new(result_from_polars)
@@ -119,7 +119,7 @@ def _support_polars_method(method_name: str):
     return method
 
 
-class SupportPolarsMethodMixin:
+class SupportPolarsMethodMixin(ABC):
     rename = _support_polars_method("rename")
     with_columns = _support_polars_method("with_columns")
     filter = _support_polars_method("filter")
@@ -131,6 +131,10 @@ class SupportPolarsMethodMixin:
         Used to create a new instance of the same class with the given data (for e.g. on .rename(), .with_columns(), etc.).
         """
 
+    @property
+    @abstractmethod
+    def data(self): ...
+
 
 class ModelElementWithId(ModelElement, AttrContainerMixin):
     """

{pyoframe-0.0.5 → pyoframe-0.0.6}/src/pyoframe/solvers.py

@@ -5,7 +5,7 @@ Code to interface with various solvers
 from abc import abstractmethod, ABC
 from functools import lru_cache
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Type, Union, TYPE_CHECKING
+from typing import Any, Dict, Optional, Type, Union, TYPE_CHECKING
 
 import polars as pl
 
@@ -50,7 +50,6 @@ def solve(
     solver=None,
     directory: Optional[Union[Path, str]] = None,
     use_var_names=False,
-    env=None,
     log_fn=None,
     warmstart_fn=None,
     basis_fn=None,
@@ -68,8 +67,13 @@ def solve(
         raise ValueError(f"Solver {solver} not recognized or supported.")
 
     solver_cls = solver_registry[solver]
-    m.solver = solver_cls(m, log_to_console)
-    m.solver_model = m.solver.create_solver_model(directory, use_var_names, env)
+    m.solver = solver_cls(
+        m,
+        log_to_console,
+        params={param: value for param, value in m.params},
+        directory=directory,
+    )
+    m.solver_model = m.solver.create_solver_model(use_var_names)
     m.solver.solver_model = m.solver_model
 
     for attr_container in [m.variables, m.constraints, [m]]:
@@ -77,9 +81,6 @@ def solve(
             for param_name, param_value in container.attr:
                 m.solver.set_attr(container, param_name, param_value)
 
-    for param, value in m.params:
-        m.solver.set_param(param, value)
-
     result = m.solver.solve(log_fn, warmstart_fn, basis_fn, solution_file)
     result = m.solver.process_result(result)
     m.result = result
@@ -99,20 +100,19 @@ def solve(
 
 
 class Solver(ABC):
-    def __init__(self, model, log_to_console):
+    def __init__(self, model: "Model", log_to_console, params, directory):
         self._model = model
         self.solver_model: Optional[Any] = None
-        self.log_to_console = log_to_console
+        self.log_to_console: bool = log_to_console
+        self.params = params
+        self.directory = directory
 
     @abstractmethod
-    def create_solver_model(self) -> Any: ...
+    def create_solver_model(self, use_var_names) -> Any: ...
 
     @abstractmethod
     def set_attr(self, element, param_name, param_value): ...
 
-    @abstractmethod
-    def set_param(self, param_name, param_value): ...
-
     @abstractmethod
     def solve(self, log_fn, warmstart_fn, basis_fn, solution_file) -> Result: ...
 
@@ -135,12 +135,25 @@ class Solver(ABC):
     @abstractmethod
     def _get_all_slack(self): ...
 
+    def dispose(self):
+        """
+        Clean up any resources that wouldn't be cleaned up by the garbage collector.
+
+        For now, this is only used by the Gurobi solver to call .dispose() on the solver model and Gurobi environment
+        which helps close a connection to the Gurobi Computer Server. Note that this effectively disables commands that
+        need access to the solver model (like .slack and .RC)
+        """
+
 
 class FileBasedSolver(Solver):
-    def create_solver_model(
-        self, directory: Optional[Union[Path, str]], use_var_names, env
-    ) -> Any:
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.problem_file: Optional[Path] = None
+        self.keep_files = self.directory is not None
+
+    def create_solver_model(self, use_var_names) -> Any:
         problem_file = None
+        directory = self.directory
         if directory is not None:
             if isinstance(directory, str):
                 directory = Path(directory)
@@ -150,12 +163,14 @@ class FileBasedSolver(Solver):
                 self._model.name if self._model.name is not None else "pyoframe-problem"
             )
             problem_file = directory / f"{filename}.lp"
-        problem_file = self._model.to_file(problem_file, use_var_names=use_var_names)
+        self.problem_file = self._model.to_file(
+            problem_file, use_var_names=use_var_names
+        )
         assert self._model.io_mappers is not None
-        return self.create_solver_model_from_lp(problem_file, env)
+        return self.create_solver_model_from_lp()
 
     @abstractmethod
-    def create_solver_model_from_lp(self, problem_file: Path, env) -> Any: ...
+    def create_solver_model_from_lp(self) -> Any: ...
 
     def set_attr(self, element, param_name, param_value):
         if isinstance(param_value, pl.DataFrame):
@@ -216,30 +231,30 @@ class GurobiSolver(FileBasedSolver):
         17: "internal_solver_error",
     }
 
-    def create_solver_model_from_lp(self, problem_fn, env) -> Result:
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        if not self.log_to_console:
+            self.params["LogToConsole"] = 0
+        self.env = None
+
+    def create_solver_model_from_lp(self) -> Any:
         """
         Solve a linear problem using the gurobi solver.
 
         This function communicates with gurobi using the gurubipy package.
         """
+        assert self.problem_file is not None
+        self.env = gurobipy.Env(params=self.params)
 
-        if env is None:
-            if self.log_to_console:
-                env = gurobipy.Env()
-            else:
-                # See https://support.gurobi.com/hc/en-us/articles/360044784552-How-do-I-suppress-all-console-output-from-Gurobi
-                env = gurobipy.Env(empty=True)
-                env.setParam("LogToConsole", 0)
-                env.start()
+        m = gurobipy.read(_path_to_str(self.problem_file), env=self.env)
+        if not self.keep_files:
+            self.problem_file.unlink()
 
-        m = gurobipy.read(_path_to_str(problem_fn), env=env)
         return m
 
-    def set_param(self, param_name, param_value):
-        self.solver_model.setParam(param_name, param_value)
-
     @lru_cache
     def _get_var_mapping(self):
+        assert self.solver_model is not None
         vars = self.solver_model.getVars()
         return vars, pl.DataFrame(
             {VAR_KEY: self.solver_model.getAttr("VarName", vars)}
@@ -247,12 +262,14 @@ class GurobiSolver(FileBasedSolver):
 
     @lru_cache
     def _get_constraint_mapping(self):
+        assert self.solver_model is not None
         constraints = self.solver_model.getConstrs()
         return constraints, pl.DataFrame(
             {CONSTRAINT_KEY: self.solver_model.getAttr("ConstrName", constraints)}
         ).with_columns(i=pl.int_range(pl.len()))
 
     def set_attr_unmapped(self, element, param_name, param_value):
+        assert self.solver_model is not None
         if isinstance(element, pf.Model):
             self.solver_model.setAttr(param_name, param_value)
         elif isinstance(element, pf.Variable):
@@ -277,6 +294,7 @@ class GurobiSolver(FileBasedSolver):
             raise ValueError(f"Element type {type(element)} not recognized.")
 
     def solve(self, log_fn, warmstart_fn, basis_fn, solution_file) -> Result:
+        assert self.solver_model is not None
         m = self.solver_model
         if log_fn is not None:
             m.setParam("logfile", _path_to_str(log_fn))
@@ -345,6 +363,12 @@ class GurobiSolver(FileBasedSolver):
             }
         )
 
+    def dispose(self):
+        if self.solver_model is not None:
+            self.solver_model.dispose()
+        if self.env is not None:
+            self.env.dispose()
+
 
 def _path_to_str(path: Union[Path, str]) -> str:
     """

{pyoframe-0.0.5 → pyoframe-0.0.6/src/pyoframe.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyoframe
-Version: 0.0.5
+Version: 0.0.6
 Summary: Blazing fast linear program interface
 Author-email: Bravos Power <dev@bravospower.com>
 Project-URL: Homepage, https://bravos-power.github.io/pyoframe/