pyoframe 0.2.1__py3-none-any.whl → 1.0.0a0__py3-none-any.whl

pyoframe/model.py

@@ -1,408 +0,0 @@
-from pathlib import Path
-from typing import Any, Dict, Iterable, List, Optional, Union
-
-import pandas as pd
-import polars as pl
-import pyoptinterface as poi
-
-from pyoframe.constants import (
-    CONST_TERM,
-    SUPPORTED_SOLVER_TYPES,
-    SUPPORTED_SOLVERS,
-    Config,
-    ObjSense,
-    ObjSenseValue,
-    PyoframeError,
-    VType,
-)
-from pyoframe.core import Constraint, Variable
-from pyoframe.model_element import ModelElement, ModelElementWithId
-from pyoframe.objective import Objective
-from pyoframe.util import Container, NamedVariableMapper, for_solvers, get_obj_repr
-
-
-class Model:
-    """
-    The object that holds all the variables, constraints, and the objective.
-
-    Parameters:
-        name:
-            The name of the model. Currently it is not used for much.
-        solver:
-            The solver to use. If `None`, `Config.default_solver` will be used.
-            If `Config.default_solver` has not been set (`None`), Pyoframe will try to detect whichever solver is already installed.
-        solver_env:
-            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
-            set when the objective is set using `.minimize` or `.maximize`.
-
-    Examples:
-        >>> m = pf.Model()
-        >>> m.X = pf.Variable()
-        >>> m.my_constraint = m.X <= 10
-        >>> m
-        <Model vars=1 constrs=1 objective=False>
-
-        Try setting the Gurobi license:
-        >>> m = pf.Model(solver="gurobi", solver_env=dict(ComputeServer="myserver", ServerPassword="mypassword"))
-        Traceback (most recent call last):
-        ...
-        RuntimeError: Could not resolve host: myserver (code 6, command POST http://myserver/api/v1/cluster/jobs)
-    """
-
-    _reserved_attributes = [
-        "_variables",
-        "_constraints",
-        "_objective",
-        "var_map",
-        "io_mappers",
-        "name",
-        "solver",
-        "poi",
-        "params",
-        "result",
-        "attr",
-        "sense",
-        "objective",
-        "_use_var_names",
-        "ONE",
-        "solver_name",
-        "minimize",
-        "maximize",
-    ]
-
-    def __init__(
-        self,
-        name: Optional[str] = None,
-        solver: Optional[SUPPORTED_SOLVER_TYPES] = None,
-        solver_env: Optional[Dict[str, str]] = None,
-        use_var_names: bool = False,
-        sense: Union[ObjSense, ObjSenseValue, None] = None,
-    ):
-        self.poi, self.solver_name = Model.create_poi_model(solver, solver_env)
-        self._variables: List[Variable] = []
-        self._constraints: List[Constraint] = []
-        self.sense = ObjSense(sense) if sense is not None else None
-        self._objective: Optional[Objective] = None
-        self.var_map = (
-            NamedVariableMapper(Variable) if Config.print_uses_variable_names else None
-        )
-        self.name = name
-
-        self.params = Container(self._set_param, self._get_param)
-        self.attr = Container(self._set_attr, self._get_attr)
-        self._use_var_names = use_var_names
-
-    @property
-    def use_var_names(self):
-        return self._use_var_names
-
-    @classmethod
-    def create_poi_model(
-        cls, solver: Optional[str], solver_env: Optional[Dict[str, str]]
-    ):
-        if solver is None:
-            if Config.default_solver is None:
-                for solver_option in SUPPORTED_SOLVERS:
-                    try:
-                        return cls.create_poi_model(solver_option, solver_env)
-                    except RuntimeError:
-                        pass
-                raise ValueError(
-                    'Could not automatically find a solver. Is one installed? If so, specify which one: e.g. Model(solver="gurobi")'
-                )
-            else:
-                solver = Config.default_solver
-
-        solver = solver.lower()
-        if solver == "gurobi":
-            from pyoptinterface import gurobi
-
-            if solver_env is None:
-                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)
-        elif solver == "highs":
-            from pyoptinterface import highs
-
-            model = highs.Model()
-        else:
-            raise ValueError(
-                f"Solver {solver} not recognized or supported."
-            )  # pragma: no cover
-
-        constant_var = model.add_variable(lb=1, ub=1, name="ONE")
-        if constant_var.index != CONST_TERM:
-            raise ValueError(
-                "The first variable should have index 0."
-            )  # pragma: no cover
-        return model, solver
-
-    @property
-    def variables(self) -> List[Variable]:
-        return self._variables
-
-    @property
-    def binary_variables(self) -> Iterable[Variable]:
-        """
-        Examples:
-            >>> m = pf.Model()
-            >>> m.X = pf.Variable(vtype=pf.VType.BINARY)
-            >>> m.Y = pf.Variable()
-            >>> len(list(m.binary_variables))
-            1
-        """
-        return (v for v in self.variables if v.vtype == VType.BINARY)
-
-    @property
-    def integer_variables(self) -> Iterable[Variable]:
-        """
-        Examples:
-            >>> m = pf.Model()
-            >>> m.X = pf.Variable(vtype=pf.VType.INTEGER)
-            >>> m.Y = pf.Variable()
-            >>> len(list(m.integer_variables))
-            1
-        """
-        return (v for v in self.variables if v.vtype == VType.INTEGER)
-
-    @property
-    def constraints(self):
-        return self._constraints
-
-    @property
-    def objective(self):
-        return self._objective
-
-    @objective.setter
-    def objective(self, value):
-        if self._objective is not None and (
-            not isinstance(value, Objective) or not value._constructive
-        ):
-            raise ValueError("An objective already exists. Use += or -= to modify it.")
-        if not isinstance(value, Objective):
-            value = Objective(value)
-        self._objective = value
-        value.on_add_to_model(self, "objective")
-
-    @property
-    def minimize(self):
-        if self.sense != ObjSense.MIN:
-            raise ValueError("Can't get .minimize in a maximization problem.")
-        return self._objective
-
-    @minimize.setter
-    def minimize(self, value):
-        if self.sense is None:
-            self.sense = ObjSense.MIN
-        if self.sense != ObjSense.MIN:
-            raise ValueError("Can't set .minimize in a maximization problem.")
-        self.objective = value
-
-    @property
-    def maximize(self):
-        if self.sense != ObjSense.MAX:
-            raise ValueError("Can't get .maximize in a minimization problem.")
-        return self._objective
-
-    @maximize.setter
-    def maximize(self, value):
-        if self.sense is None:
-            self.sense = ObjSense.MAX
-        if self.sense != ObjSense.MAX:
-            raise ValueError("Can't set .maximize in a minimization problem.")
-        self.objective = value
-
-    def __setattr__(self, __name: str, __value: Any) -> None:
-        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:
-        return get_obj_repr(
-            self,
-            name=self.name,
-            vars=len(self.variables),
-            constrs=len(self.constraints),
-            objective=bool(self.objective),
-        )
-
-    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)
-        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")
-    def convert_to_fixed(self) -> None:
-        """
-        Turns a mixed integer program into a continuous one by fixing
-        all the integer and binary variables to their solution values.
-
-        !!! warning "Gurobi only"
-            This method only works with the Gurobi solver. Open an issue if you'd like to see support for other solvers.
-
-        Examples:
-            >>> m = pf.Model(solver="gurobi")
-            >>> m.X = pf.Variable(vtype=pf.VType.BINARY, lb=0)
-            >>> m.Y = pf.Variable(vtype=pf.VType.INTEGER, lb=0)
-            >>> m.Z = pf.Variable(lb=0)
-            >>> m.my_constraint = m.X + m.Y + m.Z <= 10
-            >>> m.maximize = 3 * m.X + 2 * m.Y + m.Z
-            >>> m.optimize()
-            >>> m.X.solution, m.Y.solution, m.Z.solution
-            (1, 9, 0.0)
-            >>> m.my_constraint.dual
-            Traceback (most recent call last):
-            ...
-            RuntimeError: Unable to retrieve attribute 'Pi'
-            >>> m.convert_to_fixed()
-            >>> m.optimize()
-            >>> m.my_constraint.dual
-            1.0
-
-            Only works for Gurobi:
-
-            >>> m = pf.Model("max", solver="highs")
-            >>> m.convert_to_fixed()
-            Traceback (most recent call last):
-            ...
-            NotImplementedError: Method 'convert_to_fixed' is not implemented for solver 'highs'.
-        """
-        self.poi._converttofixed()
-
-    @for_solvers("gurobi", "copt")
-    def compute_IIS(self):
-        """
-        Computes the Irreducible Infeasible Set (IIS) of the model.
-
-        !!! warning "Gurobi only"
-            This method only works with the Gurobi solver. Open an issue if you'd like to see support for other solvers.
-
-        Examples:
-            >>> m = pf.Model(solver="gurobi")
-            >>> m.X = pf.Variable(lb=0, ub=2)
-            >>> m.Y = pf.Variable(lb=0, ub=2)
-            >>> m.bad_constraint = m.X >= 3
-            >>> m.minimize = m.X + m.Y
-            >>> m.optimize()
-            >>> m.attr.TerminationStatus
-            <TerminationStatusCode.INFEASIBLE: 3>
-            >>> m.bad_constraint.attr.IIS
-            Traceback (most recent call last):
-            ...
-            RuntimeError: Unable to retrieve attribute 'IISConstr'
-            >>> m.compute_IIS()
-            >>> m.bad_constraint.attr.IIS
-            True
-        """
-        self.poi.computeIIS()
-
-    def dispose(self):
-        """
-        Disposes of the model and cleans up the solver environment.
-
-        When using Gurobi compute server, this cleanup will
-        ensure your run is not marked as 'ABORTED'.
-
-        Note that once the model is disposed, it cannot be used anymore.
-
-        Examples:
-            >>> m = pf.Model()
-            >>> m.X = pf.Variable(ub=1)
-            >>> m.maximize = m.X
-            >>> m.optimize()
-            >>> m.X.solution
-            1.0
-            >>> m.dispose()
-        """
-        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)
-
-    def _get_param(self, name):
-        return self.poi.get_raw_parameter(name)
-
-    def _set_attr(self, name, value):
-        try:
-            self.poi.set_model_attribute(poi.ModelAttribute[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 as e:
-            if self.solver_name == "gurobi":
-                return self.poi.get_model_raw_attribute(name)
-            else:
-                raise e

pyoframe/model_element.py

@@ -1,184 +0,0 @@
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
-
-import polars as pl
-
-from pyoframe._arithmetic import _get_dimensions
-from pyoframe.constants import (
-    COEF_KEY,
-    KEY_TYPE,
-    QUAD_VAR_KEY,
-    RESERVED_COL_KEYS,
-    VAR_KEY,
-)
-
-if TYPE_CHECKING:  # pragma: no cover
-    from pyoframe.model import Model
-
-
-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."
-        )
-
-        cols = _get_dimensions(data)
-        if cols is None:
-            cols = []
-        cols += [col for col in RESERVED_COL_KEYS if col in data.columns]
-
-        # Reorder columns to keep things consistent
-        data = data.select(cols)
-
-        # Cast to proper dtype
-        if COEF_KEY in data.columns:
-            data = data.cast({COEF_KEY: pl.Float64})
-        if VAR_KEY in data.columns:
-            data = data.cast({VAR_KEY: KEY_TYPE})
-        if QUAD_VAR_KEY in data.columns:
-            data = data.cast({QUAD_VAR_KEY: KEY_TYPE})
-
-        self._data = data
-        self._model: Optional[Model] = None
-        self.name = None
-        super().__init__(**kwargs)
-
-    def on_add_to_model(self, model: "Model", name: str):
-        self.name = name
-        self._model = model
-
-    @property
-    def data(self) -> pl.DataFrame:
-        return self._data
-
-    @property
-    def friendly_name(self) -> str:
-        return self.name if self.name is not None else "unnamed"
-
-    @property
-    def dimensions(self) -> Optional[List[str]]:
-        """
-        The names of the data's dimensions.
-
-        Examples:
-            >>> # A variable with no dimensions
-            >>> pf.Variable().dimensions
-
-            >>> # A variable with dimensions of "hour" and "city"
-            >>> pf.Variable([{"hour": ["00:00", "06:00", "12:00", "18:00"]}, {"city": ["Toronto", "Berlin", "Paris"]}]).dimensions
-            ['hour', 'city']
-        """
-        return _get_dimensions(self.data)
-
-    @property
-    def dimensions_unsafe(self) -> List[str]:
-        """
-        Same as `dimensions` but returns an empty list if there are no dimensions instead of None.
-        When unsure, use `dimensions` instead since the type checker forces users to handle the None case (no dimensions).
-        """
-        dims = self.dimensions
-        if dims is None:
-            return []
-        return dims
-
-    @property
-    def shape(self) -> Dict[str, int]:
-        """
-        The number of indices in each dimension.
-
-        Examples:
-            >>> # A variable with no dimensions
-            >>> pf.Variable().shape
-            {}
-            >>> # A variable with dimensions of "hour" and "city"
-            >>> pf.Variable([{"hour": ["00:00", "06:00", "12:00", "18:00"]}, {"city": ["Toronto", "Berlin", "Paris"]}]).shape
-            {'hour': 4, 'city': 3}
-        """
-        dims = self.dimensions
-        if dims is None:
-            return {}
-        return {dim: self.data[dim].n_unique() for dim in dims}
-
-    def __len__(self) -> int:
-        dims = self.dimensions
-        if dims is None:
-            return 1
-        return self.data.select(dims).n_unique()
-
-
-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) -> Any:
-        result_from_polars = getattr(self.data, method_name)(*args, **kwargs)
-        if isinstance(result_from_polars, pl.DataFrame):
-            return self._new(result_from_polars)
-        else:
-            return result_from_polars
-
-    return method
-
-
-class SupportPolarsMethodMixin(ABC):
-    rename = _support_polars_method("rename")
-    with_columns = _support_polars_method("with_columns")
-    filter = _support_polars_method("filter")
-    estimated_size = _support_polars_method("estimated_size")
-
-    @abstractmethod
-    def _new(self, data: pl.DataFrame):
-        """
-        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): ...
-
-    def pick(self, **kwargs):
-        """
-        Filters elements by the given criteria and then drops the filtered dimensions.
-
-        Examples:
-            >>> m = pf.Model()
-            >>> m.v = pf.Variable([{"hour": ["00:00", "06:00", "12:00", "18:00"]}, {"city": ["Toronto", "Berlin", "Paris"]}])
-            >>> m.v.pick(hour="06:00")
-            <Expression size=3 dimensions={'city': 3} terms=3>
-            [Toronto]: v[06:00,Toronto]
-            [Berlin]: v[06:00,Berlin]
-            [Paris]: v[06:00,Paris]
-            >>> m.v.pick(hour="06:00", city="Toronto")
-            <Expression size=1 dimensions={} terms=1>
-            v[06:00,Toronto]
-        """
-        return self._new(self.data.filter(**kwargs).drop(kwargs.keys()))
-
-
-class ModelElementWithId(ModelElement):
-    """
-    Provides a method that assigns a unique ID to each row in a DataFrame.
-    IDs start at 1 and go up consecutively. No zero ID is assigned since it is reserved for the constant variable term.
-    IDs are only unique for the subclass since different subclasses have different counters.
-    """
-
-    @property
-    def _has_ids(self) -> bool:
-        return self.get_id_column_name() in self.data.columns
-
-    def _assert_has_ids(self):
-        if not self._has_ids:
-            raise ValueError(
-                f"Cannot use '{self.__class__.__name__}' before it has beed added to a model."
-            )
-
-    @classmethod
-    @abstractmethod
-    def get_id_column_name(cls) -> str:
-        """
-        Returns the name of the column containing the IDs.
-        """

pyoframe/monkey_patch.py

@@ -1,54 +0,0 @@
-from functools import wraps
-
-import pandas as pd
-import polars as pl
-
-from pyoframe.constants import COEF_KEY, CONST_TERM, VAR_KEY
-from pyoframe.core import Expression, SupportsMath
-
-# pyright: reportAttributeAccessIssue=false
-
-
-def _patch_class(cls):
-    def _patch_method(func):
-        @wraps(func)
-        def wrapper(self, other):
-            if isinstance(other, SupportsMath):
-                return NotImplemented
-            return func(self, other)
-
-        return wrapper
-
-    cls.__add__ = _patch_method(cls.__add__)
-    cls.__mul__ = _patch_method(cls.__mul__)
-    cls.__sub__ = _patch_method(cls.__sub__)
-    cls.__le__ = _patch_method(cls.__le__)
-    cls.__ge__ = _patch_method(cls.__ge__)
-    cls.__contains__ = _patch_method(cls.__contains__)
-
-
-def _dataframe_to_expr(self: pl.DataFrame) -> Expression:
-    return Expression(
-        self.rename({self.columns[-1]: COEF_KEY})
-        .drop_nulls(COEF_KEY)
-        .with_columns(pl.lit(CONST_TERM).alias(VAR_KEY))
-    )
-
-
-def patch_dataframe_libraries():
-    """
-    Applies two patches to the DataFrame and Series classes of both pandas and polars.
-    1) Patches arithmetic operators (e.g. `__add__`) such that operations between DataFrames/Series and `Expressionable`s
-        are not supported (i.e. `return NotImplemented`). This leads Python to try the reverse operation (e.g. `__radd__`)
-        which is supported by the `Expressionable` class.
-    2) Adds a `to_expr` method to DataFrame/Series that allows them to be converted to an `Expression` object.
-        Series become dataframes and dataframes become expressions where everything but the last column are treated as dimensions.
-    """
-    _patch_class(pd.DataFrame)
-    _patch_class(pd.Series)
-    _patch_class(pl.DataFrame)
-    _patch_class(pl.Series)
-    pl.DataFrame.to_expr = _dataframe_to_expr
-    pl.Series.to_expr = lambda self: self.to_frame().to_expr()
-    pd.DataFrame.to_expr = lambda self: pl.from_pandas(self).to_expr()
-    pd.Series.to_expr = lambda self: self.to_frame().reset_index().to_expr()

pyoframe-0.2.1.dist-info/RECORD

@@ -1,15 +0,0 @@
-pyoframe/__init__.py,sha256=YswFUwm6GX98dXeT99hqxWqYWLELS71JZf1OpT1kvCg,619
-pyoframe/_arithmetic.py,sha256=agJm2Sl4EjEG7q4n2YHka4mGfCQI3LjOXLaW6oCfGiQ,17222
-pyoframe/_version.py,sha256=vYqoJTG51NOUmYyL0xt8asRK8vUT4lGAdal_EZ59mvw,704
-pyoframe/constants.py,sha256=WBCmhunavNVwJcmg9ojnA6TVJCLSrgWVE4YKZnhZNz4,4192
-pyoframe/core.py,sha256=fjCu4eY7QJSFvVfCNtMq-o_spoo76FWO4AviCssHGoo,66925
-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.1.dist-info/licenses/LICENSE,sha256=u_Spw4ynlwTMRZeCX-uacv_hBU547pBygiA6d2ONNV4,1074
-pyoframe-0.2.1.dist-info/METADATA,sha256=_rmMdRjfEkv-1xn9UkjVubVxNUqSKgluVmXz7nSaRnA,3607
-pyoframe-0.2.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pyoframe-0.2.1.dist-info/top_level.txt,sha256=10z3OOJSVLriQ0IrFLMH8CH9zByugPWolqhlHlkNjV4,9
-pyoframe-0.2.1.dist-info/RECORD,,