pyoframe 0.1.4__py3-none-any.whl → 0.2.0__py3-none-any.whl

pyoframe/__init__.py

@@ -8,6 +8,11 @@ from pyoframe.core import Constraint, Expression, Set, Variable, sum, sum_by
 from pyoframe.model import Model
 from pyoframe.monkey_patch import patch_dataframe_libraries
 
+try:
+    from pyoframe._version import __version__, __version_tuple__  # noqa: F401
+except ModuleNotFoundError:  # pragma: no cover
+    pass
+
 patch_dataframe_libraries()
 
 __all__ = [

pyoframe/_arithmetic.py

@@ -10,7 +10,6 @@ from pyoframe.constants import (
     COEF_KEY,
     CONST_TERM,
     KEY_TYPE,
-    POLARS_VERSION,
     QUAD_VAR_KEY,
     RESERVED_COL_KEYS,
     VAR_KEY,
@@ -81,14 +80,14 @@ def _multiply_expressions_core(self: "Expression", other: "Expression") -> "Expr
         self, other = other, self
         self_degree, other_degree = other_degree, self_degree
     if other_degree == 1:
-        assert (
-            self_degree == 1
-        ), "This should always be true since the sum of degrees must be <=2."
+        assert self_degree == 1, (
+            "This should always be true since the sum of degrees must be <=2."
+        )
         return _quadratic_multiplication(self, other)
 
-    assert (
-        other_degree == 0
-    ), "This should always be true since other cases have already been handled."
+    assert other_degree == 0, (
+        "This should always be true since other cases have already been handled."
+    )
     multiplier = other.data.drop(
         VAR_KEY
     )  # QUAD_VAR_KEY doesn't need to be dropped since we know it doesn't exist
@@ -248,12 +247,12 @@ def _add_expressions_core(*expressions: "Expression") -> "Expression":
             left_data = left.data.join(get_indices(right), how="inner", on=dims)
             right_data = right.data.join(get_indices(left), how="inner", on=dims)
         elif strat == (UnmatchedStrategy.UNSET, UnmatchedStrategy.UNSET):
-            assert (
-                not Config.disable_unmatched_checks
-            ), "This code should not be reached when unmatched checks are disabled."
+            assert not Config.disable_unmatched_checks, (
+                "This code should not be reached when unmatched checks are disabled."
+            )
             outer_join = get_indices(left).join(
                 get_indices(right),
-                how="full" if POLARS_VERSION.major >= 1 else "outer",
+                how="full",
                 on=dims,
             )
             if outer_join.get_column(dims[0]).null_count() > 0:
@@ -280,9 +279,9 @@ def _add_expressions_core(*expressions: "Expression") -> "Expression":
                     + str(left_data.filter(left_data.get_column(COEF_KEY).is_null()))
                 )
         elif strat == (UnmatchedStrategy.KEEP, UnmatchedStrategy.UNSET):
-            assert (
-                not Config.disable_unmatched_checks
-            ), "This code should not be reached when unmatched checks are disabled."
+            assert not Config.disable_unmatched_checks, (
+                "This code should not be reached when unmatched checks are disabled."
+            )
             unmatched = right.data.join(get_indices(left), how="anti", on=dims)
             if len(unmatched) > 0:
                 raise PyoframeError(

pyoframe/_version.py

@@ -0,0 +1,21 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.2.0'
+__version_tuple__ = version_tuple = (0, 2, 0)

pyoframe/constants.py

@@ -8,11 +8,6 @@ from typing import Literal, Optional
 
 import polars as pl
 import pyoptinterface as poi
-from packaging import version
-
-# Constant to help split our logic depending on the polars version in use.
-# This approach is compatible with polars-lts-cpu.
-POLARS_VERSION = version.parse(pl.__version__)
 
 COEF_KEY = "__coeff"
 VAR_KEY = "__variable_id"
@@ -20,6 +15,7 @@ QUAD_VAR_KEY = "__quadratic_variable_id"
 CONSTRAINT_KEY = "__constraint_id"
 SOLUTION_KEY = "solution"
 DUAL_KEY = "dual"
+SUPPORTED_SOLVERS = ["gurobi", "highs"]
 SUPPORTED_SOLVER_TYPES = Literal["gurobi", "highs"]
 KEY_TYPE = pl.UInt32
 
@@ -44,7 +40,7 @@ class _ConfigMeta(type):
         cls._defaults = {
             k: v
             for k, v in dct.items()
-            if not k.startswith("_") and type(v) != classmethod
+            if not k.startswith("_") and type(v) != classmethod  # noqa: E721 (didn't want to mess with it since it works)
         }
 
 
@@ -59,10 +55,19 @@ class Config(metaclass=_ConfigMeta):
     print_uses_variable_names: bool = True
     print_max_line_length: int = 80
     print_max_lines: int = 15
-    # Number of elements to show when printing a set to the console (additional elements are replaced with ...)
     print_max_set_elements: int = 50
+    "Number of elements to show when printing a set to the console (additional elements are replaced with ...)"
+
     enable_is_duplicated_expression_safety_check: bool = False
 
+    integer_tolerance: float = 1e-8
+    """
+    For convenience, Pyoframe returns the solution of integer and binary variables as integers not floating point values.
+    To do so, Pyoframe must convert the solver-provided floating point values to integers. To avoid unexpected rounding errors,
+    Pyoframe uses this tolerance to check that the floating point result is an integer as expected. Overly tight tolerances can trigger
+    unexpected errors. Setting the tolerance to zero disables the check.
+    """
+
     @classmethod
     def reset_defaults(cls):
         """

pyoframe/core.py

@@ -33,7 +33,6 @@ from pyoframe.constants import (
     CONSTRAINT_KEY,
     DUAL_KEY,
     KEY_TYPE,
-    POLARS_VERSION,
     QUAD_VAR_KEY,
     RESERVED_COL_KEYS,
     SOLUTION_KEY,
@@ -294,9 +293,9 @@ class Set(ModelElement, SupportsMath, SupportPolarsMethodMixin):
         over_merged = over_frames[0]
 
         for df in over_frames[1:]:
-            assert (
-                set(over_merged.columns) & set(df.columns) == set()
-            ), "All coordinates must have unique column names."
+            assert set(over_merged.columns) & set(df.columns) == set(), (
+                "All coordinates must have unique column names."
+            )
             over_merged = over_merged.join(df, how="cross")
         return over_merged
 
@@ -309,9 +308,9 @@ class Set(ModelElement, SupportsMath, SupportPolarsMethodMixin):
 
     def __mul__(self, other):
         if isinstance(other, Set):
-            assert (
-                set(self.data.columns) & set(other.data.columns) == set()
-            ), "Cannot multiply two sets with columns in common."
+            assert set(self.data.columns) & set(other.data.columns) == set(), (
+                "Cannot multiply two sets with columns in common."
+            )
             return Set(self.data, other.data)
         return super().__mul__(other)
 
@@ -346,18 +345,11 @@ class Set(ModelElement, SupportsMath, SupportPolarsMethodMixin):
         elif isinstance(set, Constraint):
             df = set.data.select(set.dimensions_unsafe)
         elif isinstance(set, SupportsMath):
-            if POLARS_VERSION.major < 1:
-                df = (
-                    set.to_expr()
-                    .data.drop(RESERVED_COL_KEYS)
-                    .unique(maintain_order=True)
-                )
-            else:
-                df = (
-                    set.to_expr()
-                    .data.drop(RESERVED_COL_KEYS, strict=False)
-                    .unique(maintain_order=True)
-                )
+            df = (
+                set.to_expr()
+                .data.drop(RESERVED_COL_KEYS, strict=False)
+                .unique(maintain_order=True)
+            )
         elif isinstance(set, pd.Index):
             df = pl.from_pandas(pd.DataFrame(index=set).reset_index())
         elif isinstance(set, pd.DataFrame):
@@ -620,13 +612,13 @@ class Expression(ModelElement, SupportsMath, SupportPolarsMethodMixin):
         """
         df: pl.DataFrame = Set(set).data
         set_dims = _get_dimensions(df)
-        assert (
-            set_dims is not None
-        ), "Cannot use .within() with a set with no dimensions."
+        assert set_dims is not None, (
+            "Cannot use .within() with a set with no dimensions."
+        )
         dims = self.dimensions
-        assert (
-            dims is not None
-        ), "Cannot use .within() with an expression with no dimensions."
+        assert dims is not None, (
+            "Cannot use .within() with an expression with no dimensions."
+        )
         dims_in_common = [dim for dim in dims if dim in set_dims]
         by_dims = df.select(dims_in_common).unique(maintain_order=True)
         return self._new(self.data.join(by_dims, on=dims_in_common))
@@ -800,15 +792,9 @@ class Expression(ModelElement, SupportsMath, SupportPolarsMethodMixin):
                 keys = keys.with_columns(
                     pl.lit(CONST_TERM).alias(QUAD_VAR_KEY).cast(KEY_TYPE)
                 )
-            if POLARS_VERSION.major >= 1:
-                data = data.join(
-                    keys, on=dim + self._variable_columns, how="full", coalesce=True
-                )
-            else:
-                data = data.join(
-                    keys, on=dim + self._variable_columns, how="outer_coalesce"
-                )
-            data = data.with_columns(pl.col(COEF_KEY).fill_null(0.0))
+            data = data.join(
+                keys, on=dim + self._variable_columns, how="full", coalesce=True
+            ).with_columns(pl.col(COEF_KEY).fill_null(0.0))
 
         data = data.with_columns(
             pl.when(pl.col(VAR_KEY) == CONST_TERM)
@@ -826,10 +812,7 @@ class Expression(ModelElement, SupportsMath, SupportPolarsMethodMixin):
             constant_terms = constant_terms.drop(QUAD_VAR_KEY)
         if dims is not None:
             dims_df = self.data.select(dims).unique(maintain_order=True)
-            if POLARS_VERSION.major >= 1:
-                df = constant_terms.join(dims_df, on=dims, how="full", coalesce=True)
-            else:
-                df = constant_terms.join(dims_df, on=dims, how="outer_coalesce")
+            df = constant_terms.join(dims_df, on=dims, how="full", coalesce=True)
             return df.with_columns(pl.col(COEF_KEY).fill_null(0.0))
         else:
             if len(constant_terms) == 0:
@@ -870,9 +853,9 @@ class Expression(ModelElement, SupportsMath, SupportPolarsMethodMixin):
             >>> m.expr_2.evaluate()
             63.0
         """
-        assert (
-            self._model is not None
-        ), "Expression must be added to the model to use .value"
+        assert self._model is not None, (
+            "Expression must be added to the model to use .value"
+        )
 
         df = self.data
         sm = self._model.poi
@@ -899,16 +882,23 @@ class Expression(ModelElement, SupportsMath, SupportPolarsMethodMixin):
             df = df.group_by(dims, maintain_order=True)
         return df.sum()
 
-    def to_poi(self) -> poi.ScalarAffineFunction:
+    def to_poi(self) -> poi.ScalarAffineFunction | poi.ScalarQuadraticFunction:
         if self.dimensions is not None:
             raise ValueError(
                 "Only non-dimensioned expressions can be converted to PyOptInterface."
             )  # pragma: no cover
 
-        return poi.ScalarAffineFunction(
-            coefficients=self.data.get_column(COEF_KEY).to_numpy(),
-            variables=self.data.get_column(VAR_KEY).to_numpy(),
-        )
+        if self.is_quadratic:
+            return poi.ScalarQuadraticFunction(
+                coefficients=self.data.get_column(COEF_KEY).to_numpy(),
+                var1s=self.data.get_column(VAR_KEY).to_numpy(),
+                var2s=self.data.get_column(QUAD_VAR_KEY).to_numpy(),
+            )
+        else:
+            return poi.ScalarAffineFunction(
+                coefficients=self.data.get_column(COEF_KEY).to_numpy(),
+                variables=self.data.get_column(VAR_KEY).to_numpy(),
+            )
 
     def to_str_table(self, include_const_term=True):
         data = self.data if include_const_term else self.variable_terms
@@ -951,10 +941,10 @@ class Expression(ModelElement, SupportsMath, SupportPolarsMethodMixin):
 
         if dimensions is not None:
             data = data.group_by(dimensions, maintain_order=True).agg(
-                pl.col("expr").str.concat(delimiter=" ")
+                pl.col("expr").str.join(delimiter=" ")
             )
         else:
-            data = data.select(pl.col("expr").str.concat(delimiter=" "))
+            data = data.select(pl.col("expr").str.join(delimiter=" "))
 
         # Remove leading +
         data = data.with_columns(pl.col("expr").str.strip_chars(characters=" +"))
@@ -1010,7 +1000,7 @@ class Expression(ModelElement, SupportsMath, SupportPolarsMethodMixin):
                 include_const_term=include_const_term,
             )
             str_table = self.to_str_create_prefix(str_table)
-            result += str_table.select(pl.col("expr").str.concat(delimiter="\n")).item()
+            result += str_table.select(pl.col("expr").str.join(delimiter="\n")).item()
 
         return result
 
@@ -1054,6 +1044,31 @@ def sum(
     over: Union[str, Sequence[str], SupportsToExpr],
     expr: Optional[SupportsToExpr] = None,
 ) -> "Expression":
+    """
+    Sum an expression over specified dimensions.
+    If no dimensions are specified, the sum is taken over all of the expression's dimensions.
+
+    Examples:
+        >>> expr = pl.DataFrame({
+        ...     "time": ["mon", "tue", "wed", "mon", "tue"],
+        ...     "place": ["Toronto", "Toronto", "Toronto", "Vancouver", "Vancouver"],
+        ...     "tiktok_posts": [1e6, 3e6, 2e6, 1e6, 2e6]
+        ... }).to_expr()
+        >>> expr
+        <Expression size=5 dimensions={'time': 3, 'place': 2} terms=5>
+        [mon,Toronto]: 1000000
+        [tue,Toronto]: 3000000
+        [wed,Toronto]: 2000000
+        [mon,Vancouver]: 1000000
+        [tue,Vancouver]: 2000000
+        >>> pf.sum("time", expr)
+        <Expression size=2 dimensions={'place': 2} terms=2>
+        [Toronto]: 6000000
+        [Vancouver]: 3000000
+        >>> pf.sum(expr)
+        <Expression size=1 dimensions={} terms=1>
+        9000000
+    """
     if expr is None:
         assert isinstance(over, SupportsMath)
         over = over.to_expr()
@@ -1069,13 +1084,34 @@ def sum(
 
 
 def sum_by(by: Union[str, Sequence[str]], expr: SupportsToExpr) -> "Expression":
+    """
+    Like `pf.sum()`, but the sum is taken over all dimensions except those specified in `by` (just like a groupby operation).
+
+    Examples:
+        >>> expr = pl.DataFrame({
+        ...     "time": ["mon", "tue", "wed", "mon", "tue"],
+        ...     "place": ["Toronto", "Toronto", "Toronto", "Vancouver", "Vancouver"],
+        ...     "tiktok_posts": [1e6, 3e6, 2e6, 1e6, 2e6]
+        ... }).to_expr()
+        >>> expr
+        <Expression size=5 dimensions={'time': 3, 'place': 2} terms=5>
+        [mon,Toronto]: 1000000
+        [tue,Toronto]: 3000000
+        [wed,Toronto]: 2000000
+        [mon,Vancouver]: 1000000
+        [tue,Vancouver]: 2000000
+        >>> pf.sum_by("place", expr)
+        <Expression size=2 dimensions={'place': 2} terms=2>
+        [Toronto]: 6000000
+        [Vancouver]: 3000000
+    """
     if isinstance(by, str):
         by = [by]
     expr = expr.to_expr()
     dimensions = expr.dimensions
-    assert (
-        dimensions is not None
-    ), "Cannot sum by dimensions with an expression with no dimensions."
+    assert dimensions is not None, (
+        "Cannot sum by dimensions with an expression with no dimensions."
+    )
     remaining_dims = [dim for dim in dimensions if dim not in by]
     return sum(over=remaining_dims, expr=expr)
 
@@ -1329,9 +1365,9 @@ class Constraint(ModelElementWithId):
             return self
 
         var_name = f"{self.name}_relaxation"
-        assert not hasattr(
-            m, var_name
-        ), "Conflicting names, relaxation variable already exists on the model."
+        assert not hasattr(m, var_name), (
+            "Conflicting names, relaxation variable already exists on the model."
+        )
         var = Variable(self, lb=0, ub=max)
         setattr(m, var_name, var)
 
@@ -1374,7 +1410,7 @@ class Constraint(ModelElementWithId):
             [str_table, rhs], how=("align" if dims else "horizontal")
         )
         constr_str = constr_str.select(
-            pl.concat_str("expr", pl.lit(f" {self.sense.value} "), "rhs").str.concat(
+            pl.concat_str("expr", pl.lit(f" {self.sense.value} "), "rhs").str.join(
                 delimiter="\n"
             )
         ).item()
@@ -1459,9 +1495,9 @@ class Variable(ModelElementWithId, SupportsMath, SupportPolarsMethodMixin):
         equals: Optional[SupportsMath] = None,
     ):
         if equals is not None:
-            assert (
-                len(indexing_sets) == 0
-            ), "Cannot specify both 'equals' and 'indexing_sets'"
+            assert len(indexing_sets) == 0, (
+                "Cannot specify both 'equals' and 'indexing_sets'"
+            )
             indexing_sets = (equals,)
 
         data = Set(*indexing_sets).data if len(indexing_sets) > 0 else pl.DataFrame()
@@ -1578,9 +1614,78 @@ class Variable(ModelElementWithId, SupportsMath, SupportPolarsMethodMixin):
     @property
     @unwrap_single_values
     def solution(self):
-        solution = self.attr.Value
+        """
+        Retrieve a variable's optimal value after the model has been solved.
+        Returned as a DataFrame if the variable has dimensions, otherwise as a single value.
+        Binary and integer variables are returned as integers.
+
+        Examples:
+            >>> m = pf.Model()
+            >>> m.var_continuous = pf.Variable({"dim1": [1, 2, 3]}, lb=5, ub=5)
+            >>> m.var_integer = pf.Variable({"dim1": [1, 2, 3]}, lb=4.5, ub=5.5, vtype=VType.INTEGER)
+            >>> m.var_dimensionless = pf.Variable(lb=4.5, ub=5.5, vtype=VType.INTEGER)
+            >>> m.var_continuous.solution
+            Traceback (most recent call last):
+            ...
+            RuntimeError: Failed to retrieve solution for variable. Are you sure the model has been solved?
+            >>> m.optimize()
+            >>> m.var_continuous.solution
+            shape: (3, 2)
+            ┌──────┬──────────┐
+            │ dim1 ┆ solution │
+            │ ---  ┆ ---      │
+            │ i64  ┆ f64      │
+            ╞══════╪══════════╡
+            │ 1    ┆ 5.0      │
+            │ 2    ┆ 5.0      │
+            │ 3    ┆ 5.0      │
+            └──────┴──────────┘
+            >>> m.var_integer.solution
+            shape: (3, 2)
+            ┌──────┬──────────┐
+            │ dim1 ┆ solution │
+            │ ---  ┆ ---      │
+            │ i64  ┆ i64      │
+            ╞══════╪══════════╡
+            │ 1    ┆ 5        │
+            │ 2    ┆ 5        │
+            │ 3    ┆ 5        │
+            └──────┴──────────┘
+            >>> m.var_dimensionless.solution
+            5
+        """
+        try:
+            solution = self.attr.Value
+        except RuntimeError as e:
+            raise RuntimeError(
+                "Failed to retrieve solution for variable. Are you sure the model has been solved?"
+            ) from e
         if isinstance(solution, pl.DataFrame):
             solution = solution.rename({"Value": SOLUTION_KEY})
+
+        if self.vtype in [VType.BINARY, VType.INTEGER]:
+            if isinstance(solution, pl.DataFrame):
+                solution = solution.with_columns(
+                    pl.col("solution").alias("solution_float"),
+                    pl.col("solution").round().cast(pl.Int64),
+                )
+                if Config.integer_tolerance != 0:
+                    df = solution.filter(
+                        (pl.col("solution_float") - pl.col("solution")).abs()
+                        > Config.integer_tolerance
+                    )
+                    assert df.is_empty(), (
+                        f"Variable {self.name} has a non-integer value: {df}\nThis should not happen."
+                    )
+                solution = solution.drop("solution_float")
+            else:
+                solution_float = solution
+                solution = int(round(solution))
+                if Config.integer_tolerance != 0:
+                    assert abs(solution - solution_float) < Config.integer_tolerance, (
+                        f"Value of variable {self.name} is not an integer: {solution}. This should not happen."
+                    )
+
         return solution
 
     def __repr__(self):
@@ -1606,10 +1711,7 @@ class Variable(ModelElementWithId, SupportsMath, SupportPolarsMethodMixin):
 
     def to_expr(self) -> Expression:
         self._assert_has_ids()
-        if POLARS_VERSION.major < 1:
-            return self._new(self.data.drop(SOLUTION_KEY))
-        else:
-            return self._new(self.data.drop(SOLUTION_KEY, strict=False))
+        return self._new(self.data.drop(SOLUTION_KEY, strict=False))
 
     def _new(self, data: pl.DataFrame):
         self._assert_has_ids()
@@ -1686,12 +1788,7 @@ class Variable(ModelElementWithId, SupportsMath, SupportPolarsMethodMixin):
         expr = self.to_expr()
         data = expr.data.rename({dim: "__prev"})
 
-        if POLARS_VERSION.major < 1:
-            data = data.join(
-                wrapped, left_on="__prev", right_on="__next", how="inner"
-            ).drop(["__prev", "__next"])
-        else:
-            data = data.join(
-                wrapped, left_on="__prev", right_on="__next", how="inner"
-            ).drop(["__prev", "__next"], strict=False)
+        data = data.join(
+            wrapped, left_on="__prev", right_on="__next", how="inner"
+        ).drop(["__prev", "__next"], strict=False)
         return expr._new(data)

pyoframe/model.py

@@ -8,6 +8,7 @@ import pyoptinterface as poi
 from pyoframe.constants import (
     CONST_TERM,
     SUPPORTED_SOLVER_TYPES,
+    SUPPORTED_SOLVERS,
     Config,
     ObjSense,
     ObjSenseValue,
@@ -34,6 +35,7 @@ class Model:
             Gurobi only: a dictionary of parameters to set when creating the Gurobi environment.
         use_var_names:
             Whether to pass variable names to the solver. Set to `True` if you'd like outputs from e.g. `Model.write()` to be legible.
+            Does not work with HiGHS (see [here](https://github.com/Bravos-Power/pyoframe/issues/102#issuecomment-2727521430)).
         sense:
             Either "min" or "max". Indicates whether it's a minmization or maximization problem.
             Typically, this parameter can be omitted (`None`) as it will automatically be
@@ -76,10 +78,10 @@ class Model:
 
     def __init__(
         self,
-        name=None,
+        name: Optional[str] = None,
         solver: Optional[SUPPORTED_SOLVER_TYPES] = None,
         solver_env: Optional[Dict[str, str]] = None,
-        use_var_names=False,
+        use_var_names: bool = False,
         sense: Union[ObjSense, ObjSenseValue, None] = None,
     ):
         self.poi, self.solver_name = Model.create_poi_model(solver, solver_env)
@@ -106,7 +108,7 @@ class Model:
     ):
         if solver is None:
             if Config.default_solver is None:
-                for solver_option in ["highs", "gurobi"]:
+                for solver_option in SUPPORTED_SOLVERS:
                     try:
                         return cls.create_poi_model(solver_option, solver_env)
                     except RuntimeError:
@@ -122,13 +124,13 @@ class Model:
             from pyoptinterface import gurobi
 
             if solver_env is None:
-                model = gurobi.Model()
+                env = gurobi.Env()
             else:
                 env = gurobi.Env(empty=True)
                 for key, value in solver_env.items():
                     env.set_raw_parameter(key, value)
                 env.start()
-                model = gurobi.Model(env)
+            model = gurobi.Model(env)
         elif solver == "highs":
             from pyoptinterface import highs
 
@@ -233,9 +235,9 @@ class Model:
             and __name not in Model._reserved_attributes
         ):
             if isinstance(__value, ModelElementWithId):
-                assert not hasattr(
-                    self, __name
-                ), f"Cannot create {__name} since it was already created."
+                assert not hasattr(self, __name), (
+                    f"Cannot create {__name} since it was already created."
+                )
 
             __value.on_add_to_model(self, __name)
 
@@ -256,12 +258,32 @@ class Model:
             objective=bool(self.objective),
         )
 
-    def write(self, file_path: Union[Path, str]):
+    def write(self, file_path: Union[Path, str], pretty: bool = False):
+        """
+        Output the model to a file.
+
+        Typical usage includes writing the solution to a `.sol` file as well as writing the problem to a `.lp` or `.mps` file.
+        Set `use_var_names` in your model constructor to `True` if you'd like the output to contain human-readable names (useful for debugging).
+
+        Parameters:
+            file_path:
+                The path to the file to write to.
+            pretty:
+                Only used when writing .sol files in HiGHS. If `True`, will use HiGH's pretty print columnar style which contains more information.
+        """
         file_path = Path(file_path)
         file_path.parent.mkdir(parents=True, exist_ok=True)
-        self.poi.write(str(file_path))
+        kwargs = {}
+        if self.solver_name == "highs":
+            if self.use_var_names:
+                self.params.write_solution_style = 1
+            kwargs["pretty"] = pretty
+        self.poi.write(str(file_path), **kwargs)
 
     def optimize(self):
+        """
+        Optimize the model using your selected solver (e.g. Gurobi, HiGHS).
+        """
         self.poi.optimize()
 
     @for_solvers("gurobi")
@@ -282,11 +304,11 @@ class Model:
             >>> m.maximize = 3 * m.X + 2 * m.Y + m.Z
             >>> m.optimize()
             >>> m.X.solution, m.Y.solution, m.Z.solution
-            (1.0, 9.0, 0.0)
+            (1, 9, 0.0)
             >>> m.my_constraint.dual
             Traceback (most recent call last):
             ...
-            polars.exceptions.ComputeError: RuntimeError: Unable to retrieve attribute 'Pi'
+            RuntimeError: Unable to retrieve attribute 'Pi'
             >>> m.convert_to_fixed()
             >>> m.optimize()
             >>> m.my_constraint.dual
@@ -322,44 +344,44 @@ class Model:
             >>> m.bad_constraint.attr.IIS
             Traceback (most recent call last):
             ...
-            polars.exceptions.ComputeError: RuntimeError: Unable to retrieve attribute 'IISConstr'
+            RuntimeError: Unable to retrieve attribute 'IISConstr'
             >>> m.compute_IIS()
             >>> m.bad_constraint.attr.IIS
             True
         """
         self.poi.computeIIS()
 
-    @for_solvers("gurobi")
     def dispose(self):
         """
-        Tries to close the solver connection by deleting the model and forcing the garbage collector to run.
+        Disposes of the model and cleans up the solver environment.
 
-        Gurobi only. Once this method is called, this model is no longer usable.
+        When using Gurobi compute server, this cleanup will
+        ensure your run is not marked as 'ABORTED'.
 
-        This method will not work if you have a variable that references self.poi.
-        Unfortunately, this is a limitation from the underlying solver interface library.
-        See https://github.com/metab0t/PyOptInterface/issues/36 for context.
+        Note that once the model is disposed, it cannot be used anymore.
 
         Examples:
-            >>> m = pf.Model(solver="gurobi")
+            >>> m = pf.Model()
             >>> m.X = pf.Variable(ub=1)
             >>> m.maximize = m.X
             >>> m.optimize()
             >>> m.X.solution
             1.0
             >>> m.dispose()
-            >>> m.X.solution
-            Traceback (most recent call last):
-            ...
-            AttributeError: 'Model' object has no attribute 'poi'
         """
-        import gc
-
-        env = self.poi._env
-        del self.poi
-        gc.collect()
-        del env
-        gc.collect()
+        env = None
+        if hasattr(self.poi, "_env"):
+            env = self.poi._env
+        self.poi.close()
+        if env is not None:
+            env.close()
+
+    def __del__(self):
+        # This ensures that the model is closed *before* the environment is. This avoids the Gurobi warning:
+        #   Warning: environment still referenced so free is deferred (Continue to use WLS)
+        # I include the hasattr check to avoid errors in case __init__ failed and poi was never set.
+        if hasattr(self, "poi"):
+            self.poi.close()
 
     def _set_param(self, name, value):
         self.poi.set_raw_parameter(name, value)
@@ -370,11 +392,17 @@ class Model:
     def _set_attr(self, name, value):
         try:
             self.poi.set_model_attribute(poi.ModelAttribute[name], value)
-        except KeyError:
-            self.poi.set_model_raw_attribute(name, value)
+        except KeyError as e:
+            if self.solver_name == "gurobi":
+                self.poi.set_model_raw_attribute(name, value)
+            else:
+                raise e
 
     def _get_attr(self, name):
         try:
             return self.poi.get_model_attribute(poi.ModelAttribute[name])
-        except KeyError:
-            return self.poi.get_model_raw_attribute(name)
+        except KeyError as e:
+            if self.solver_name == "gurobi":
+                return self.poi.get_model_raw_attribute(name)
+            else:
+                raise e

pyoframe/model_element.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
-from collections import defaultdict
 from typing import TYPE_CHECKING, Any, Dict, List, Optional
 
 import polars as pl
@@ -22,9 +21,9 @@ if TYPE_CHECKING:  # pragma: no cover
 class ModelElement(ABC):
     def __init__(self, data: pl.DataFrame, **kwargs) -> None:
         # Sanity checks, no duplicate column names
-        assert len(data.columns) == len(
-            set(data.columns)
-        ), "Duplicate column names found."
+        assert len(data.columns) == len(set(data.columns)), (
+            "Duplicate column names found."
+        )
 
         cols = _get_dimensions(data)
         if cols is None:

pyoframe/util.py

@@ -379,9 +379,9 @@ class NamedVariableMapper:
 
     def _element_to_map(self, element) -> pl.DataFrame:
         element_name = element.name  # type: ignore
-        assert (
-            element_name is not None
-        ), "Element must have a name to be used in a named mapping."
+        assert element_name is not None, (
+            "Element must have a name to be used in a named mapping."
+        )
         element._assert_has_ids()
         return concat_dimensions(
             element.data.select(element.dimensions_unsafe + [VAR_KEY]),

{pyoframe-0.1.4.dist-info → pyoframe-0.2.0.dist-info}/METADATA

@@ -1,8 +1,9 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: pyoframe
-Version: 0.1.4
+Version: 0.2.0
 Summary: Blazing fast linear program interface
 Author-email: Bravos Power <dev@bravospower.com>
+License-Expression: MIT
 Project-URL: Homepage, https://bravos-power.github.io/pyoframe/
 Project-URL: documentation, https://bravos-power.github.io/pyoframe/
 Project-URL: repository, https://github.com/Bravos-Power/pyoframe/
@@ -10,40 +11,40 @@ Project-URL: Issues, https://github.com/Bravos-Power/pyoframe/issues
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent
 Classifier: Development Status :: 3 - Alpha
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Natural Language :: English
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: polars<2,>=0.20
+Requires-Dist: polars~=1.0
 Requires-Dist: numpy
 Requires-Dist: pyarrow
 Requires-Dist: pandas
-Requires-Dist: packaging
-Requires-Dist: pyoptinterface~=0.4
+Requires-Dist: pyoptinterface<1,>=0.4.1
 Provides-Extra: dev
-Requires-Dist: black[jupyter]; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: polars>=1.30.0; extra == "dev"
 Requires-Dist: bumpver; extra == "dev"
-Requires-Dist: isort; extra == "dev"
 Requires-Dist: pip-tools; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
 Requires-Dist: pre-commit; extra == "dev"
 Requires-Dist: gurobipy; extra == "dev"
 Requires-Dist: highsbox; extra == "dev"
-Requires-Dist: pre-commit; extra == "dev"
 Requires-Dist: coverage; extra == "dev"
-Provides-Extra: docs
-Requires-Dist: mkdocs-material==9.*; extra == "docs"
-Requires-Dist: mkdocstrings[python]; extra == "docs"
-Requires-Dist: mkdocs-git-revision-date-localized-plugin; extra == "docs"
-Requires-Dist: mkdocs-git-committers-plugin-2; extra == "docs"
-Requires-Dist: mkdocs-gen-files; extra == "docs"
-Requires-Dist: mkdocs-section-index; extra == "docs"
-Requires-Dist: mkdocs-literate-nav; extra == "docs"
-Requires-Dist: mkdocs-table-reader-plugin; extra == "docs"
+Requires-Dist: ipykernel; extra == "dev"
+Requires-Dist: pytest-markdown-docs; extra == "dev"
+Requires-Dist: mkdocs-material==9.*; extra == "dev"
+Requires-Dist: mkdocstrings[python]; extra == "dev"
+Requires-Dist: mkdocs-git-revision-date-localized-plugin; extra == "dev"
+Requires-Dist: mkdocs-git-committers-plugin-2; extra == "dev"
+Requires-Dist: mkdocs-gen-files; extra == "dev"
+Requires-Dist: mkdocs-section-index; extra == "dev"
+Requires-Dist: mkdocs-literate-nav; extra == "dev"
+Requires-Dist: mkdocs-table-reader-plugin; extra == "dev"
+Requires-Dist: markdown-hide-code>=0.1.1; extra == "dev"
 Provides-Extra: highs
 Requires-Dist: highsbox; extra == "highs"
+Dynamic: license-file
 
 # Pyoframe: Fast and low-memory linear programming models 
 

pyoframe-0.2.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+pyoframe/__init__.py,sha256=YswFUwm6GX98dXeT99hqxWqYWLELS71JZf1OpT1kvCg,619
+pyoframe/_arithmetic.py,sha256=agJm2Sl4EjEG7q4n2YHka4mGfCQI3LjOXLaW6oCfGiQ,17222
+pyoframe/_version.py,sha256=iB5DfB5V6YB5Wo4JmvS-txT42QtmGaWcWp3udRT7zCI,511
+pyoframe/constants.py,sha256=WBCmhunavNVwJcmg9ojnA6TVJCLSrgWVE4YKZnhZNz4,4192
+pyoframe/core.py,sha256=kK-eMI7teakAAG4JjOiwRBsCgNJIlOxR0b4JOUlQHs4,67239
+pyoframe/model.py,sha256=a7pEwagVxHC1ZUMr8ifO4n0ca5Ways3wip-Wps0rlcg,14257
+pyoframe/model_element.py,sha256=YmAdx4yM5irGTiZ5uQmDa-u05QdFKngIFy8qNnogvzo,5911
+pyoframe/monkey_patch.py,sha256=9IfS14G6IPabmM9z80jzi_D4Rq0Mdx5aUCA39Yi2tgE,2044
+pyoframe/objective.py,sha256=PBWxj30QkFlsvY6ijZ6KjyKdrJARD4to0ieF6GUqaQU,3238
+pyoframe/util.py,sha256=dHIwAyyD9wn36yM8IOlrboTGUGA7STq3IBTxfYSOPjU,13480
+pyoframe-0.2.0.dist-info/licenses/LICENSE,sha256=u_Spw4ynlwTMRZeCX-uacv_hBU547pBygiA6d2ONNV4,1074
+pyoframe-0.2.0.dist-info/METADATA,sha256=GTwsHP14u5Zwb1E4pnjyeCS9-0DVmLXjNlo3ebZiSbw,3607
+pyoframe-0.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pyoframe-0.2.0.dist-info/top_level.txt,sha256=10z3OOJSVLriQ0IrFLMH8CH9zByugPWolqhlHlkNjV4,9
+pyoframe-0.2.0.dist-info/RECORD,,

{pyoframe-0.1.4.dist-info → pyoframe-0.2.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

{pyoframe-0.1.4.dist-info → pyoframe-0.2.0.dist-info/licenses}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright 2024 Bravos Power
+Copyright (c) 2024-2025 Bravos Power
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

pyoframe-0.1.4.dist-info/RECORD

@@ -1,14 +0,0 @@
-pyoframe/__init__.py,sha256=nEN0OgqhevtsvxEiPbJLzwPojf3ngYAoT90M_1mc4kM,477
-pyoframe/_arithmetic.py,sha256=vqzMZip1kTkUUMyHohUyKJxx2nEeQIH7N57fwevLWaQ,17284
-pyoframe/constants.py,sha256=Dy1sCzykZlmkbvgsc5ckujqXPuYmsKkD3stANU0qr5Y,3784
-pyoframe/core.py,sha256=4heBn7RGOWV-Yg0OoiLr8sGBaygpTx-D-pLuC4nC0Dw,62865
-pyoframe/model.py,sha256=7nVH2oZeTuk53l76PLNElsiHEgmbTvrf7lGIa9_CYm4,13011
-pyoframe/model_element.py,sha256=RBmsE2FOct3UL2N2LZLfWYv2wL_QKqNmKmmR_pD_ERs,5945
-pyoframe/monkey_patch.py,sha256=9IfS14G6IPabmM9z80jzi_D4Rq0Mdx5aUCA39Yi2tgE,2044
-pyoframe/objective.py,sha256=PBWxj30QkFlsvY6ijZ6KjyKdrJARD4to0ieF6GUqaQU,3238
-pyoframe/util.py,sha256=Oyk8xh6FJHlb04X_cM4lN0UzdnKLXAMrKfyOf7IexiA,13480
-pyoframe-0.1.4.dist-info/LICENSE,sha256=dkwA40ZzT-3x6eu2a6mf_o7PNSqHbdsyaFNhLxGHNQs,1065
-pyoframe-0.1.4.dist-info/METADATA,sha256=v3ZH_JvXSg4cN515Qo0FvZviXIC0l-Ja5tgq5IdgwLI,3558
-pyoframe-0.1.4.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-pyoframe-0.1.4.dist-info/top_level.txt,sha256=10z3OOJSVLriQ0IrFLMH8CH9zByugPWolqhlHlkNjV4,9
-pyoframe-0.1.4.dist-info/RECORD,,