pyoframe 0.0.4__py3-none-any.whl → 0.0.6__py3-none-any.whl

pyoframe/io.py

@@ -6,16 +6,17 @@ from io import TextIOWrapper
 from tempfile import NamedTemporaryFile
 from pathlib import Path
 from typing import TYPE_CHECKING, Iterable, Optional, TypeVar, Union
+from tqdm import tqdm
 
-from pyoframe.constants import VAR_KEY, Config
-from pyoframe.constraints import Constraint
-from pyoframe.variables import Variable
+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,
+    NamedVariableMapper,
 )
 
 if TYPE_CHECKING:  # pragma: no cover
@@ -28,63 +29,88 @@ def objective_to_file(m: "Model", f: TextIOWrapper, var_map):
     """
     Write out the objective of a model to a lp file.
     """
-    assert m.objective is not None, "No objective set."
-
-    f.write(f"{m.objective.sense.value}\n\nobj:\n\n")
-    result = m.objective.to_str(var_map=var_map, include_prefix=False)
-    f.writelines(result)
+    if m.objective is None:
+        return
+    objective_sense = "minimize" if m.sense == ObjSense.MIN else "maximize"
+    f.write(f"{objective_sense}\n\nobj:\n\n")
+    result = m.objective.to_str(
+        var_map=var_map, include_prefix=False, include_const_variable=True
+    )
+    f.write(result)
 
 
 def constraints_to_file(m: "Model", f: TextIOWrapper, var_map, const_map):
-    for constraint in create_section(m.constraints, f, "s.t."):
-        f.writelines(constraint.to_str(var_map=var_map, const_map=const_map) + "\n")
+    for constraint in create_section(
+        tqdm(m.constraints, desc="Writing constraints to file"), f, "s.t."
+    ):
+        f.write(constraint.to_str(var_map=var_map, const_map=const_map) + "\n")
 
 
 def bounds_to_file(m: "Model", f, var_map):
     """
     Write out variables of a model to a lp file.
     """
-    for variable in create_section(m.variables, f, "bounds"):
-        lb = f"{variable.lb:.12g}"
-        ub = f"{variable.ub:.12g}"
+    if (m.objective is not None and m.objective.has_constant) or len(m.variables) != 0:
+        f.write("\n\nbounds\n\n")
+    if m.objective is not None and m.objective.has_constant:
+        const_term_df = pl.DataFrame(
+            {VAR_KEY: [CONST_TERM]}, schema={VAR_KEY: pl.UInt32}
+        )
+        f.write(f"{var_map.apply(const_term_df).item()} = 1\n")
+
+    for variable in tqdm(m.variables, desc="Writing bounds to file"):
+        terms = []
+
+        if variable.lb != 0:
+            terms.append(pl.lit(f"{variable.lb:.12g} <= "))
+
+        terms.append(VAR_KEY)
+
+        if variable.ub != float("inf"):
+            terms.append(pl.lit(f" <= {variable.ub:.12g}"))
+
+        terms.append(pl.lit("\n"))
+
+        if len(terms) < 3:
+            continue
 
         df = (
             var_map.apply(variable.data, to_col=None)
-            .select(
-                pl.concat_str(
-                    pl.lit(f"{lb} <= "), VAR_KEY, pl.lit(f" <= {ub}\n")
-                ).str.concat("")
-            )
+            .select(pl.concat_str(terms).str.concat(""))
             .item()
         )
 
-        f.writelines(df)
+        f.write(df)
 
 
 def binaries_to_file(m: "Model", f, var_map: Mapper):
     """
     Write out binaries of a model to a lp file.
     """
-    for variable in create_section(m.binary_variables, f, "binary"):
+    for variable in create_section(
+        tqdm(m.binary_variables, "Writing binary variables to file"), f, "binary"
+    ):
         lines = (
             var_map.apply(variable.data, to_col=None)
             .select(pl.col(VAR_KEY).str.concat("\n"))
             .item()
         )
-        f.writelines(lines + "\n")
+        f.write(lines + "\n")
 
 
 def integers_to_file(m: "Model", f, var_map: Mapper):
     """
     Write out integers of a model to a lp file.
     """
-    for variable in create_section(m.integer_variables, f, "general"):
+    for variable in create_section(
+        tqdm(m.integer_variables, "Writing integer variables to file"), f, "general"
+    ):
         lines = (
             var_map.apply(variable.data, to_col=None)
             .select(pl.col(VAR_KEY).str.concat("\n"))
             .item()
         )
-        f.writelines(lines + "\n")
+        f.write(lines + "\n")
 
 
 T = TypeVar("T")
@@ -103,9 +129,9 @@ def get_var_map(m: "Model", use_var_names):
     if use_var_names:
         if m.var_map is not None:
             return m.var_map
-        var_map = NamedMapper(Variable)
+        var_map = NamedVariableMapper(Variable)
     else:
-        var_map = Base62VarMapper(Variable)
+        var_map = Base36VarMapper(Variable)
 
     for v in m.variables:
         var_map.add(v)
@@ -113,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(
@@ -131,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)
@@ -144,6 +180,6 @@ def to_file(
         bounds_to_file(m, f, var_map)
         binaries_to_file(m, f, var_map)
         integers_to_file(m, f, var_map)
-        f.write("end\n")
+        f.write("\nend\n")
 
     return file_path

pyoframe/io_mappers.py

@@ -9,14 +9,14 @@ from abc import ABC, abstractmethod
 
 from typing import TYPE_CHECKING, Optional, Type, Union
 import polars as pl
-from pyoframe.constants import NAME_COL
 from pyoframe.util import concat_dimensions
+from pyoframe.constants import CONST_TERM
 
 
 if TYPE_CHECKING:  # pragma: no cover
     from pyoframe.model import Variable
-    from pyoframe.constraints import Constraint
-    from pyoframe.util import IdCounterMixin
+    from pyoframe.core import Constraint
+    from pyoframe.model_element import ModelElementWithId
 
 
 @dataclass
@@ -26,38 +26,47 @@ class IOMappers:
 
 
 class Mapper(ABC):
-    def __init__(self, cls: Type["IdCounterMixin"]) -> None:
+
+    NAME_COL = "__name"
+
+    def __init__(self, cls: Type["ModelElementWithId"]) -> None:
         self._ID_COL = cls.get_id_column_name()
         self.mapping_registry = pl.DataFrame(
-            {self._ID_COL: [], NAME_COL: []},
-            schema={self._ID_COL: pl.UInt32, NAME_COL: pl.String},
+            {self._ID_COL: [], Mapper.NAME_COL: []},
+            schema={self._ID_COL: pl.UInt32, Mapper.NAME_COL: pl.String},
         )
 
     def add(self, element: Union["Variable", "Constraint"]) -> None:
-        self.mapping_registry = pl.concat(
-            [self.mapping_registry, self._element_to_map(element)]
-        )
+        self._extend_registry(self._element_to_map(element))
+
+    def _extend_registry(self, df: pl.DataFrame) -> None:
+        self.mapping_registry = pl.concat([self.mapping_registry, df])
 
     @abstractmethod
-    def _element_to_map(self, element: "IdCounterMixin") -> pl.DataFrame: ...
+    def _element_to_map(self, element: "ModelElementWithId") -> pl.DataFrame: ...
 
     def apply(
         self,
         df: pl.DataFrame,
-        to_col: Optional[str],
+        to_col: Optional[str] = None,
     ) -> pl.DataFrame:
+        if df.height == 0:
+            return df
         result = df.join(
             self.mapping_registry, on=self._ID_COL, how="left", validate="m:1"
         )
         if to_col is None:
             result = result.drop(self._ID_COL)
             to_col = self._ID_COL
-        return result.rename({NAME_COL: to_col})
+        return result.rename({Mapper.NAME_COL: to_col})
 
     def undo(self, df: pl.DataFrame) -> pl.DataFrame:
+        if df.height == 0:
+            return df
+        df = df.rename({self._ID_COL: Mapper.NAME_COL})
         return df.join(
-            self.mapping_registry, on=NAME_COL, how="left", validate="m:1"
-        ).drop(NAME_COL)
+            self.mapping_registry, on=Mapper.NAME_COL, how="left", validate="m:1"
+        ).drop(Mapper.NAME_COL)
 
 
 class NamedMapper(Mapper):
@@ -68,7 +77,7 @@ class NamedMapper(Mapper):
 
         >>> import polars as pl
         >>> import pyoframe as pf
-        >>> m = pf.Model()
+        >>> m = pf.Model("min")
         >>> m.foo = pf.Variable(pl.DataFrame({"t": range(4)}))
         >>> pf.sum(m.foo)
         <Expression size=1 dimensions={} terms=4>
@@ -81,17 +90,31 @@ class NamedMapper(Mapper):
             element_name is not None
         ), "Element must have a name to be used in a named mapping."
         return concat_dimensions(
-            element.ids, keep_dims=False, prefix=element_name, to_col=NAME_COL
+            element.ids, keep_dims=False, prefix=element_name, to_col=Mapper.NAME_COL
+        )
+
+
+class NamedVariableMapper(NamedMapper):
+    CONST_TERM_NAME = "_ONE"
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self._extend_registry(
+            pl.DataFrame(
+                {self._ID_COL: [CONST_TERM], self.NAME_COL: [self.CONST_TERM_NAME]},
+                schema={self._ID_COL: pl.UInt32, self.NAME_COL: pl.String},
+            )
         )
 
 
-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
@@ -109,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,
             ),
@@ -121,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:
@@ -168,23 +191,23 @@ class Base62Mapper(Mapper, ABC):
         )
 
     def _element_to_map(self, element) -> pl.DataFrame:
-        return self.apply(element.ids.select(self._ID_COL), to_col=NAME_COL)
+        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
         >>> from pyoframe import Model, Variable
         >>> from pyoframe.constants import VAR_KEY
-        >>> m = Model()
+        >>> m = Model("min")
         >>> 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 │
@@ -194,12 +217,21 @@ class Base62VarMapper(Base62Mapper):
         └───────────────┘
     """
 
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        df = pl.DataFrame(
+            {self._ID_COL: [CONST_TERM]},
+            schema={self._ID_COL: pl.UInt32},
+        )
+        df = self.apply(df, to_col=Mapper.NAME_COL)
+        self._extend_registry(df)
+
     @property
     def _prefix(self) -> "str":
         return "x"
 
 
-class Base62ConstMapper(Base62Mapper):
+class Base36ConstMapper(Base36Mapper):
 
     @property
     def _prefix(self) -> "str":

pyoframe/model.py

@@ -1,29 +1,60 @@
-from typing import Any, Iterable, List, Optional
-from pyoframe.constants import ObjSense, VType, Config
-from pyoframe.constraints import SupportsMath
-from pyoframe.io_mappers import NamedMapper, IOMappers
-from pyoframe.model_element import ModelElement
-from pyoframe.constraints import Constraint
+from typing import Any, Iterable, List, Optional, Union
+from pyoframe.constants import (
+    ObjSense,
+    VType,
+    Config,
+    Result,
+    PyoframeError,
+    ObjSenseValue,
+)
+from pyoframe.io_mappers import NamedVariableMapper, IOMappers
+from pyoframe.model_element import ModelElement, ModelElementWithId
+from pyoframe.core import Constraint
 from pyoframe.objective import Objective
-from pyoframe.variables import Variable
+from pyoframe.user_defined import Container, AttrContainerMixin
+from pyoframe.core import Variable
 from pyoframe.io import to_file
-from pyoframe.solvers import solve
+from pyoframe.solvers import solve, Solver
+import polars as pl
+import pandas as pd
 
 
-class Model:
+class Model(AttrContainerMixin):
     """
     Represents a mathematical optimization model. Add variables, constraints, and an objective to the model by setting attributes.
     """
 
-    def __init__(self, name=None):
+    _reserved_attributes = [
+        "_variables",
+        "_constraints",
+        "_objective",
+        "var_map",
+        "io_mappers",
+        "name",
+        "solver",
+        "solver_model",
+        "params",
+        "result",
+        "attr",
+        "sense",
+        "objective",
+    ]
+
+    def __init__(self, min_or_max: Union[ObjSense, ObjSenseValue], name=None, **kwargs):
+        super().__init__(**kwargs)
         self._variables: List[Variable] = []
         self._constraints: List[Constraint] = []
+        self.sense = ObjSense(min_or_max)
         self._objective: Optional[Objective] = None
         self.var_map = (
-            NamedMapper(Variable) if Config.print_uses_variable_names else None
+            NamedVariableMapper(Variable) if Config.print_uses_variable_names else None
         )
         self.io_mappers: Optional[IOMappers] = None
         self.name = name
+        self.solver: Optional[Solver] = None
+        self.solver_model: Optional[Any] = None
+        self.params = Container()
+        self.result: Optional[Result] = None
 
     @property
     def variables(self) -> List[Variable]:
@@ -45,44 +76,37 @@ class Model:
     def objective(self):
         return self._objective
 
-    @property
-    def maximize(self):
-        assert self.objective is not None and self.objective.sense == ObjSense.MAX
-        return self.objective
-
-    @property
-    def minimize(self):
-        assert self.objective is not None and self.objective.sense == ObjSense.MIN
-        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 in ("maximize", "minimize"):
-            assert isinstance(
-                __value, SupportsMath
-            ), f"Setting {__name} on the model requires an objective expression."
-            self._objective = Objective(__value, sense=__name)
-            self._objective.name = __name
-            self._objective._model = self
-            return
-
-        if isinstance(__value, ModelElement) and not __name.startswith("_"):
-            assert not hasattr(
-                self, __name
-            ), f"Cannot create {__name} since it was already created."
-
-            __value.name = __name
-            __value._model = self
-
-            if isinstance(__value, Objective):
-                assert self.objective is None, "Cannot create more than one objective."
-                self._objective = __value
+        if __name not in Model._reserved_attributes and not isinstance(
+            __value, (ModelElement, pl.DataFrame, pd.DataFrame)
+        ):
+            raise PyoframeError(
+                f"Cannot set attribute '{__name}' on the model because it isn't of type ModelElement (e.g. Variable, Constraint, ...)"
+            )
+
+        if (
+            isinstance(__value, ModelElement)
+            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."
+
+            __value.on_add_to_model(self, __name)
+
             if isinstance(__value, Variable):
                 self._variables.append(__value)
                 if self.var_map is not None:
                     self.var_map.add(__value)
             elif isinstance(__value, Constraint):
                 self._constraints.append(__value)
-
         return super().__setattr__(__name, __value)
 
     def __repr__(self) -> str: