pyoframe 0.0.11__py3-none-any.whl → 0.1.1__py3-none-any.whl

pyoframe/io_mappers.py

@@ -1,238 +0,0 @@
-"""
-Defines various methods for mapping a variable or constraint to its string representation.
-"""
-
-from dataclasses import dataclass
-import math
-import string
-from abc import ABC, abstractmethod
-
-from typing import TYPE_CHECKING, Optional, Type, Union
-import polars as pl
-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.core import Constraint
-    from pyoframe.model_element import ModelElementWithId
-
-
-@dataclass
-class IOMappers:
-    var_map: "Mapper"
-    const_map: "Mapper"
-
-
-class Mapper(ABC):
-
-    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: [], Mapper.NAME_COL: []},
-            schema={self._ID_COL: pl.UInt32, Mapper.NAME_COL: pl.String},
-        )
-
-    def add(self, element: Union["Variable", "Constraint"]) -> None:
-        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: "ModelElementWithId") -> pl.DataFrame: ...
-
-    def apply(
-        self,
-        df: pl.DataFrame,
-        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({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=Mapper.NAME_COL, how="left", validate="m:1"
-        ).drop(Mapper.NAME_COL)
-
-
-class NamedMapper(Mapper):
-    """
-    Maps constraints or variables to a string representation using the object's name and dimensions.
-
-    Examples:
-
-        >>> import polars as pl
-        >>> import pyoframe as pf
-        >>> m = pf.Model("min")
-        >>> m.foo = pf.Variable(pl.DataFrame({"t": range(4)}))
-        >>> pf.sum(m.foo)
-        <Expression size=1 dimensions={} terms=4>
-        foo[0] + foo[1] + foo[2] + foo[3]
-    """
-
-    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."
-        return concat_dimensions(
-            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 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_lowercase)},
-    ).with_columns(pl.int_range(pl.len()).cast(pl.UInt32).alias("code"))
-
-    _BASE = _CHAR_TABLE.height  # _BASE = 36
-    _ZERO = _CHAR_TABLE.filter(pl.col("code") == 0).select("char").item()  # _ZERO = "0"
-
-    @property
-    @abstractmethod
-    def _prefix(self) -> "str": ...
-
-    def apply(
-        self,
-        df: pl.DataFrame,
-        to_col: Optional[str] = None,
-    ) -> pl.DataFrame:
-        if df.height == 0:
-            return df
-
-        query = pl.concat_str(
-            pl.lit(self._prefix),
-            pl.col(self._ID_COL).map_batches(
-                Base36Mapper._to_base36,
-                return_dtype=pl.String,
-                is_elementwise=True,
-            ),
-        )
-
-        if to_col is None:
-            to_col = self._ID_COL
-
-        return df.with_columns(query.alias(to_col))
-
-    @classmethod
-    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)
-            >>> Base36Mapper._to_base36(s).to_list()
-            ['0', 'a', 'k', '1o', '1h', '1u']
-
-            >>> s = pl.Series([0], dtype=pl.UInt32)
-            >>> Base36Mapper._to_base36(s).to_list()
-            ['0']
-        """
-        assert isinstance(
-            int_col.dtype, pl.UInt32
-        ), "_to_base36() only works for UInt32 id columns"
-
-        largest_id = int_col.max()
-        if largest_id == 0:
-            max_digits = 1
-        else:
-            max_digits = math.floor(math.log(largest_id, cls._BASE)) + 1  # type: ignore
-
-        digits = []
-
-        for i in range(max_digits):
-            remainder = int_col % cls._BASE
-
-            digits.append(
-                remainder.to_frame(name="code")
-                .join(cls._CHAR_TABLE, on="code", how="left")
-                .select("char")
-                .rename({"char": f"digit{i}"})
-            )
-            int_col //= cls._BASE
-
-        return (
-            pl.concat(reversed(digits), how="horizontal")
-            .select(pl.concat_str(pl.all()))
-            .to_series()
-            .str.strip_chars_start(cls._ZERO)
-            .replace("", cls._ZERO)
-        )
-
-    def _element_to_map(self, element) -> pl.DataFrame:
-        return self.apply(element.ids.select(self._ID_COL), to_col=Mapper.NAME_COL)
-
-
-class Base36VarMapper(Base36Mapper):
-    """
-    Examples:
-        >>> import polars as pl
-        >>> from pyoframe import Model, Variable
-        >>> from pyoframe.constants import VAR_KEY
-        >>> 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=Base36VarMapper(Variable))
-        '[11]: 1  + xb'
-
-        >>> Base36VarMapper(Variable).apply(pl.DataFrame({VAR_KEY: []}))
-        shape: (0, 1)
-        ┌───────────────┐
-        │ __variable_id │
-        │ ---           │
-        │ null          │
-        ╞═══════════════╡
-        └───────────────┘
-    """
-
-    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 Base36ConstMapper(Base36Mapper):
-
-    @property
-    def _prefix(self) -> "str":
-        return "c"

pyoframe/solvers.py

@@ -1,377 +0,0 @@
-"""
-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, Optional, Type, Union, TYPE_CHECKING
-
-import polars as pl
-
-from pyoframe.constants import (
-    DUAL_KEY,
-    SOLUTION_KEY,
-    SLACK_COL,
-    RC_COL,
-    VAR_KEY,
-    CONSTRAINT_KEY,
-    Result,
-    Solution,
-    Status,
-)
-import contextlib
-import pyoframe as pf
-
-from pathlib import Path
-
-if TYPE_CHECKING:  # pragma: no cover
-    from pyoframe.model import Model
-
-available_solvers = []
-solver_registry: Dict[str, Type["Solver"]] = {}
-
-with contextlib.suppress(ImportError):
-    import gurobipy
-
-    available_solvers.append("gurobi")
-
-
-def _register_solver(solver_name):
-    def decorator(cls):
-        solver_registry[solver_name] = cls
-        return cls
-
-    return decorator
-
-
-def solve(
-    m: "Model",
-    solver=None,
-    directory: Optional[Union[Path, str]] = None,
-    use_var_names=False,
-    log_fn=None,
-    warmstart_fn=None,
-    basis_fn=None,
-    solution_file=None,
-    log_to_console=True,
-):
-    if solver is None:
-        if len(available_solvers) == 0:
-            raise ValueError(
-                "No solvers available. Please install a solving library like gurobipy."
-            )
-        solver = available_solvers[0]
-
-    if solver not in solver_registry:
-        raise ValueError(f"Solver {solver} not recognized or supported.")
-
-    solver_cls = solver_registry[solver]
-    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]]:
-        for container in attr_container:
-            for param_name, param_value in container.attr:
-                m.solver.set_attr(container, param_name, param_value)
-
-    result = m.solver.solve(log_fn, warmstart_fn, basis_fn, solution_file)
-    result = m.solver.process_result(result)
-    m.result = result
-
-    if result.solution is not None:
-        if m.objective is not None:
-            m.objective.value = result.solution.objective
-
-        for variable in m.variables:
-            variable.solution = result.solution.primal
-
-        if result.solution.dual is not None:
-            for constraint in m.constraints:
-                constraint.dual = result.solution.dual
-
-    return result
-
-
-class Solver(ABC):
-    def __init__(self, model: "Model", log_to_console, params, directory):
-        self._model = model
-        self.solver_model: Optional[Any] = None
-        self.log_to_console: bool = log_to_console
-        self.params = params
-        self.directory = directory
-
-    @abstractmethod
-    def create_solver_model(self, use_var_names) -> Any: ...
-
-    @abstractmethod
-    def set_attr(self, element, param_name, param_value): ...
-
-    @abstractmethod
-    def solve(self, log_fn, warmstart_fn, basis_fn, solution_file) -> Result: ...
-
-    @abstractmethod
-    def process_result(self, results: Result) -> Result: ...
-
-    def load_rc(self):
-        rc = self._get_all_rc()
-        for variable in self._model.variables:
-            variable.RC = rc
-
-    def load_slack(self):
-        slack = self._get_all_slack()
-        for constraint in self._model.constraints:
-            constraint.slack = slack
-
-    @abstractmethod
-    def _get_all_rc(self): ...
-
-    @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 __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)
-            if not directory.exists():
-                directory.mkdir(parents=True)
-            filename = (
-                self._model.name if self._model.name is not None else "pyoframe-problem"
-            )
-            problem_file = directory / f"{filename}.lp"
-        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()
-
-    @abstractmethod
-    def create_solver_model_from_lp(self) -> Any: ...
-
-    def set_attr(self, element, param_name, param_value):
-        if isinstance(param_value, pl.DataFrame):
-            if isinstance(element, pf.Variable):
-                param_value = self._model.io_mappers.var_map.apply(param_value)
-            elif isinstance(element, pf.Constraint):
-                param_value = self._model.io_mappers.const_map.apply(param_value)
-        return self.set_attr_unmapped(element, param_name, param_value)
-
-    @abstractmethod
-    def set_attr_unmapped(self, element, param_name, param_value): ...
-
-    def process_result(self, results: Result) -> Result:
-        if results.solution is not None:
-            results.solution.primal = self._model.io_mappers.var_map.undo(
-                results.solution.primal
-            )
-            if results.solution.dual is not None:
-                results.solution.dual = self._model.io_mappers.const_map.undo(
-                    results.solution.dual
-                )
-
-        return results
-
-    def _get_all_rc(self):
-        return self._model.io_mappers.var_map.undo(self._get_all_rc_unmapped())
-
-    def _get_all_slack(self):
-        return self._model.io_mappers.const_map.undo(self._get_all_slack_unmapped())
-
-    @abstractmethod
-    def _get_all_rc_unmapped(self): ...
-
-    @abstractmethod
-    def _get_all_slack_unmapped(self): ...
-
-
-@_register_solver("gurobi")
-class GurobiSolver(FileBasedSolver):
-    # see https://www.gurobi.com/documentation/10.0/refman/optimization_status_codes.html
-    CONDITION_MAP = {
-        1: "unknown",
-        2: "optimal",
-        3: "infeasible",
-        4: "infeasible_or_unbounded",
-        5: "unbounded",
-        6: "other",
-        7: "iteration_limit",
-        8: "terminated_by_limit",
-        9: "time_limit",
-        10: "optimal",
-        11: "user_interrupt",
-        12: "other",
-        13: "suboptimal",
-        14: "unknown",
-        15: "terminated_by_limit",
-        16: "internal_solver_error",
-        17: "internal_solver_error",
-    }
-
-    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)
-
-        m = gurobipy.read(_path_to_str(self.problem_file), env=self.env)
-        if not self.keep_files:
-            self.problem_file.unlink()
-
-        return m
-
-    @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)}
-        ).with_columns(i=pl.int_range(pl.len()))
-
-    @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):
-            v, v_map = self._get_var_mapping()
-            param_value = param_value.join(v_map, on=VAR_KEY, how="left").drop(VAR_KEY)
-            self.solver_model.setAttr(
-                param_name,
-                [v[i] for i in param_value["i"]],
-                param_value[param_name],
-            )
-        elif isinstance(element, pf.Constraint):
-            c, c_map = self._get_constraint_mapping()
-            param_value = param_value.join(c_map, on=CONSTRAINT_KEY, how="left").drop(
-                CONSTRAINT_KEY
-            )
-            self.solver_model.setAttr(
-                param_name,
-                [c[i] for i in param_value["i"]],
-                param_value[param_name],
-            )
-        else:
-            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))
-        if warmstart_fn:
-            m.read(_path_to_str(warmstart_fn))
-
-        m.optimize()
-
-        if basis_fn:
-            try:
-                m.write(_path_to_str(basis_fn))
-            except gurobipy.GurobiError as err:
-                print("No model basis stored. Raised error: %s", err)
-
-        condition = m.status
-        termination_condition = GurobiSolver.CONDITION_MAP.get(condition, condition)
-        status = Status.from_termination_condition(termination_condition)
-
-        if status.is_ok and (termination_condition == "optimal"):
-            if solution_file:
-                m.write(_path_to_str(solution_file))
-
-            objective = m.ObjVal
-            vars = m.getVars()
-            sol = pl.DataFrame(
-                {
-                    VAR_KEY: m.getAttr("VarName", vars),
-                    SOLUTION_KEY: m.getAttr("X", vars),
-                }
-            )
-
-            constraints = m.getConstrs()
-            try:
-                dual = pl.DataFrame(
-                    {
-                        DUAL_KEY: m.getAttr("Pi", constraints),
-                        CONSTRAINT_KEY: m.getAttr("ConstrName", constraints),
-                    }
-                )
-            except gurobipy.GurobiError:
-                dual = None
-
-            solution = Solution(sol, dual, objective)
-        else:
-            solution = None
-
-        return Result(status, solution)
-
-    def _get_all_rc_unmapped(self):
-        m = self._model.solver_model
-        vars = m.getVars()
-        return pl.DataFrame(
-            {
-                RC_COL: m.getAttr("RC", vars),
-                VAR_KEY: m.getAttr("VarName", vars),
-            }
-        )
-
-    def _get_all_slack_unmapped(self):
-        m = self._model.solver_model
-        constraints = m.getConstrs()
-        return pl.DataFrame(
-            {
-                SLACK_COL: m.getAttr("Slack", constraints),
-                CONSTRAINT_KEY: m.getAttr("ConstrName", constraints),
-            }
-        )
-
-    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:
-    """
-    Convert a pathlib.Path to a string.
-    """
-    return str(path.resolve()) if isinstance(path, Path) else path

pyoframe/user_defined.py

@@ -1,60 +0,0 @@
-"""
-Contains the base classes to support .params and .attr containers for user-defined parameters and attributes.
-"""
-
-from typing import Any
-
-
-class Container:
-    """
-    A container for user-defined attributes or parameters.
-
-    Parameters:
-        preprocess : Callable[str, Any], optional
-            A function to preprocess user-defined values before adding them to the container.
-
-    Examples:
-        >>> params = Container()
-        >>> params.a = 1
-        >>> params.b = 2
-        >>> params.a
-        1
-        >>> params.b
-        2
-        >>> for k, v in params:
-        ...     print(k, v)
-        a 1
-        b 2
-    """
-
-    def __init__(self, preprocess=None):
-        self._preprocess = preprocess
-        self._attributes = {}
-
-    def __setattr__(self, name: str, value: Any) -> None:
-        if name.startswith("_"):
-            return super().__setattr__(name, value)
-        if self._preprocess is not None:
-            value = self._preprocess(name, value)
-        self._attributes[name] = value
-
-    def __getattr__(self, name: str) -> Any:
-        if name.startswith("_"):
-            return super().__getattribute__(name)
-        return self._attributes[name]
-
-    def __iter__(self):
-        return iter(self._attributes.items())
-
-
-class AttrContainerMixin:
-    def __init__(self, *args, **kwargs) -> None:
-        super().__init__(*args, **kwargs)
-        self.attr = Container(preprocess=self._preprocess_attr)
-
-    def _preprocess_attr(self, name: str, value: Any) -> Any:
-        """
-        Preprocesses user-defined values before adding them to the Params container.
-        By default this function does nothing but subclasses can override it.
-        """
-        return value

pyoframe-0.0.11.dist-info/RECORD

@@ -1,18 +0,0 @@
-pyoframe/__init__.py,sha256=D7HHQPy2Me-LLyfPCcSE74dn83PeMK3aOby7i7oiLTs,507
-pyoframe/_arithmetic.py,sha256=riyN2JC-BnOgTIxGfXKIS-X_p7zm8JaKrLk_KDwKAAw,9046
-pyoframe/constants.py,sha256=WoWNVsTeAqOHdUPkaZqFR3X3swrsf7OQnZ9AOaUF3uE,7358
-pyoframe/core.py,sha256=co4Z-i2AZ4jpvqfTKG67AKcBSFputZ0QrTtrglfkOzQ,51915
-pyoframe/io.py,sha256=DJUQ-WlxYe-Ya49pn_T3z6HhJxSD2LSdxm43AGqLuXw,7106
-pyoframe/io_mappers.py,sha256=Op5451Yo4gNa-2BiPPCAjPYdFLo8jIeKHCYXUcGPRug,7385
-pyoframe/model.py,sha256=xod3hSf__WWDy0V9pao9wPlQTc7-7x56FJoKKidsMbw,3768
-pyoframe/model_element.py,sha256=H2gZxksb3UQ25vIdNlb07bCx3ZcWh7YD6-ViPVJV-JI,7691
-pyoframe/monkey_patch.py,sha256=S_DU7cieU5C3t3kAyKQrGyLTwno0WANpDBV3xn7AyG8,2068
-pyoframe/objective.py,sha256=JzuyMAQZ2OxEoAaK-splWwZei2hHPbCLdG-X2-yRkD0,1338
-pyoframe/solvers.py,sha256=yf-hzUHDvKgmIHk2FobmygzE9-LnOzTBL5ps-nqGo8I,11875
-pyoframe/user_defined.py,sha256=UWZSTpFj0a8n1_RHwC8Ubwqr4FO-gRPBqqfNUut1IZg,1717
-pyoframe/util.py,sha256=KJubFV66E7WPI5UhcuUNsVwCm7WOcQBiLN1af1MAAgA,9647
-pyoframe-0.0.11.dist-info/LICENSE,sha256=L1pXz6p_1OW5XGWb2UCR6PNu6k3JAT0XWhi8jV0cuRg,1137
-pyoframe-0.0.11.dist-info/METADATA,sha256=qtlWiEBTxnFXguG57ZfmJ0rG4AcjOad5HM3a2CFJym8,3461
-pyoframe-0.0.11.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
-pyoframe-0.0.11.dist-info/top_level.txt,sha256=10z3OOJSVLriQ0IrFLMH8CH9zByugPWolqhlHlkNjV4,9
-pyoframe-0.0.11.dist-info/RECORD,,