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

pyoframe/util.py

@@ -2,15 +2,28 @@
 File containing utility functions and classes.
 """
 
-from typing import Any, Iterable, Optional, Union, List, Dict
-
 from dataclasses import dataclass, field
+from functools import wraps
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Dict,
+    Iterable,
+    List,
+    Optional,
+    Sequence,
+    Type,
+    Union,
+)
 
-import polars as pl
 import pandas as pd
-from functools import wraps
+import polars as pl
 
-from pyoframe.constants import COEF_KEY, CONST_TERM, RESERVED_COL_KEYS, VAR_KEY
+from pyoframe.constants import COEF_KEY, CONST_TERM, RESERVED_COL_KEYS, VAR_KEY, Config
+
+if TYPE_CHECKING:  # pragma: no cover
+    from pyoframe.model import Variable
+    from pyoframe.model_element import ModelElementWithId
 
 
 def get_obj_repr(obj: object, _props: Iterable[str] = (), **kwargs):
@@ -47,10 +60,20 @@ def parse_inputs_as_iterable(
 
 
 def _is_iterable(input: Union[Any, Iterable[Any]]) -> bool:
-    # Inspired from the polars library
+    # Inspired from the polars library, TODO: Consider using opposite check, i.e. equals list or tuple
     return isinstance(input, Iterable) and not isinstance(
         input,
-        (str, bytes, pl.DataFrame, pl.Series, pd.DataFrame, pd.Series, pd.Index, dict),
+        (
+            str,
+            bytes,
+            pl.DataFrame,
+            pl.Series,
+            pd.DataFrame,
+            pd.Series,
+            pd.Index,
+            dict,
+            range,
+        ),
     )
 
 
@@ -58,7 +81,7 @@ def concat_dimensions(
     df: pl.DataFrame,
     prefix: Optional[str] = None,
     keep_dims: bool = True,
-    ignore_columns=RESERVED_COL_KEYS,
+    ignore_columns: Sequence[str] = RESERVED_COL_KEYS,
     replace_spaces: bool = True,
     to_col: str = "concated_dim",
 ) -> pl.DataFrame:
@@ -66,12 +89,14 @@ def concat_dimensions(
     Returns a new DataFrame with the column 'concated_dim'. Reserved columns are ignored.
 
     Parameters:
-        df : pl.DataFrame
+        df:
             The input DataFrame.
-        prefix : str, optional
+        prefix:
             The prefix to be added to the concated dimension.
-        keep_dims : bool, optional
+        keep_dims:
             If True, the original dimensions are kept in the new DataFrame.
+        replace_spaces : bool, optional
+            If True, replaces spaces with underscores.
 
     Examples:
         >>> import polars as pl
@@ -160,18 +185,19 @@ def concat_dimensions(
 
 
 def cast_coef_to_string(
-    df: pl.DataFrame, column_name: str = COEF_KEY, drop_ones=True, float_precision=None
+    df: pl.DataFrame, column_name: str = COEF_KEY, drop_ones: bool = True
 ) -> pl.DataFrame:
     """
+    Converts column `column_name` of the dataframe `df` to a string. Rounds to `Config.print_float_precision` decimal places if not None.
+
     Parameters:
-        df : pl.DataFrame
+        df:
             The input DataFrame.
-        column_name : str, optional
+        column_name:
             The name of the column to be casted.
-        drop_ones : bool, optional
+        drop_ones:
             If True, 1s are replaced with an empty string for non-constant terms.
-        float_precision : int, optional
-            The number of decimal places to round the coefficients to. If None, no rounding is done (so Polars' default precision is used).
+
     Examples:
         >>> import polars as pl
         >>> df = pl.DataFrame({"x": [1.0, -2.0, 1.0, 4.0], VAR_KEY: [1, 2, 0, 4]})
@@ -193,8 +219,8 @@ def cast_coef_to_string(
         _sign=pl.when(pl.col(column_name) < 0).then(pl.lit("-")).otherwise(pl.lit("+")),
     )
 
-    if float_precision is not None:
-        df = df.with_columns(pl.col(column_name).round(float_precision))
+    if Config.float_to_str_precision is not None:
+        df = df.with_columns(pl.col(column_name).round(Config.float_to_str_precision))
 
     df = df.with_columns(
         pl.when(pl.col(column_name) == pl.col(column_name).floor())
@@ -270,3 +296,115 @@ def dataframe_to_tupled_list(
 class FuncArgs:
     args: List
     kwargs: Dict = field(default_factory=dict)
+
+
+class Container:
+    """
+    A placeholder object that makes it easy to set and get attributes. Used in Model.attr and Model.params, for example.
+
+    Examples:
+        >>> x = {}
+        >>> params = Container(setter=lambda n, v: x.__setitem__(n, v), getter=lambda n: x[n])
+        >>> params.a = 1
+        >>> params.b = 2
+        >>> params.a
+        1
+        >>> params.b
+        2
+    """
+
+    def __init__(self, setter, getter):
+        self._setter = setter
+        self._getter = getter
+
+    def __setattr__(self, name: str, value: Any) -> None:
+        if name.startswith("_"):  # pragma: no cover
+            return super().__setattr__(name, value)
+        self._setter(name, value)
+
+    def __getattr__(self, name: str) -> Any:
+        if name.startswith("_"):  # pragma: no cover
+            return super().__getattribute__(name)
+        return self._getter(name)
+
+
+class NamedVariableMapper:
+    """
+    Maps variables to a string representation using the object's name and dimensions.
+
+    Examples:
+        >>> import polars as pl
+        >>> m = pf.Model()
+        >>> 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]
+    """
+
+    CONST_TERM_NAME = "_ONE"
+    NAME_COL = "__name"
+
+    def __init__(self, cls: Type["ModelElementWithId"]) -> None:
+        self._ID_COL = VAR_KEY
+        self.mapping_registry = pl.DataFrame(
+            {self._ID_COL: [], self.NAME_COL: []},
+            schema={self._ID_COL: pl.UInt32, self.NAME_COL: pl.String},
+        )
+        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},
+            )
+        )
+
+    def add(self, element: "Variable") -> 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])
+
+    def apply(
+        self,
+        df: pl.DataFrame,
+        to_col: str,
+        id_col: str,
+    ) -> pl.DataFrame:
+        return df.join(
+            self.mapping_registry,
+            how="left",
+            validate="m:1",
+            left_on=id_col,
+            right_on=self._ID_COL,
+        ).rename({self.NAME_COL: to_col})
+
+    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."
+        element._assert_has_ids()
+        return concat_dimensions(
+            element.data.select(element.dimensions_unsafe + [VAR_KEY]),
+            keep_dims=False,
+            prefix=element_name,
+            to_col=self.NAME_COL,
+        )
+
+
+def for_solvers(*solvers: str):
+    """
+    Decorator that limits the function to only be called when the solver is in the `only` list.
+    """
+
+    def decorator(func):
+        @wraps(func)
+        def wrapper(self, *args, **kwargs):
+            if self.solver_name not in solvers:
+                raise NotImplementedError(
+                    f"Method '{func.__name__}' is not implemented for solver '{self.solver_name}'."
+                )
+            return func(self, *args, **kwargs)
+
+        return wrapper
+
+    return decorator

{pyoframe-0.0.11.dist-info → pyoframe-0.1.1.dist-info}/LICENSE

@@ -1,8 +1,6 @@
 MIT License
 
 Copyright 2024 Bravos Power
-Copyright 2021-2023 Fabian Hofmann
-Copyright 2015-2021 PyPSA Developers
 
 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.0.11.dist-info → pyoframe-0.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: pyoframe
-Version: 0.0.11
+Version: 0.1.1
 Summary: Blazing fast linear program interface
 Author-email: Bravos Power <dev@bravospower.com>
 Project-URL: Homepage, https://bravos-power.github.io/pyoframe/
@@ -12,31 +12,37 @@ Classifier: Operating System :: OS Independent
 Classifier: Development Status :: 3 - Alpha
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Natural Language :: English
-Requires-Python: >=3.8
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: polars <2,>=0.20
+Requires-Dist: polars<2,>=0.20
 Requires-Dist: numpy
 Requires-Dist: pyarrow
 Requires-Dist: pandas
 Requires-Dist: packaging
+Requires-Dist: pyoptinterface~=0.4
 Provides-Extra: dev
-Requires-Dist: black ; 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: black[jupyter]; 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"
 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-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"
+Provides-Extra: highs
+Requires-Dist: highsbox; extra == "highs"
 
 # Pyoframe: Fast and low-memory linear programming models 
 
@@ -50,16 +56,12 @@ Requires-Dist: mkdocs-literate-nav ; extra == 'docs'
 
 A library to rapidly and memory-efficiently formulate large and sparse optimization models using Pandas or Polars dataframes.
 
-## Contribute
+## **[Documentation](https://bravos-power.github.io/pyoframe/)**
 
-Contributions are welcome! See [`CONTRIBUTE.md`](./CONTRIBUTE.md).
+[Read the documentation](https://bravos-power.github.io/pyoframe/) to get started or to learn how to [contribute](https://bravos-power.github.io/pyoframe/contribute/).
 
-## Acknowledgments
-
-Martin Staadecker first created this library while working for [Bravos Power](https://www.bravospower.com/) The library takes inspiration from Linopy and Pyomo, two prior libraries for optimization for which we are thankful.
 
-## Troubleshooting Common Errors
+## Acknowledgments
 
-### `datatypes of join keys don't match`
+Martin Staadecker first created this library while working for [Bravos Power](https://www.bravospower.com/). The library takes inspiration from Linopy and Pyomo, two prior libraries for optimization for which we are thankful.
 
-Often, this error indicates that two dataframes in your inputs representing the same dimension have different datatypes (e.g. 16bit integer and 64bit integer). This is not allowed and you should ensure for the same dimensions, datatypes are identical.

pyoframe-0.1.1.dist-info/RECORD

@@ -0,0 +1,14 @@
+pyoframe/__init__.py,sha256=nEN0OgqhevtsvxEiPbJLzwPojf3ngYAoT90M_1mc4kM,477
+pyoframe/_arithmetic.py,sha256=LvuxI4pFYuqrqus4FxcIekUwXfdEMEVWBR-1h5hF7Ac,14764
+pyoframe/constants.py,sha256=STQZufgBCS7QTmyQTK_8lINYNSDjXCxVFgF1mXoXen4,3769
+pyoframe/core.py,sha256=C9T0wFDAgcsFVxwnLOYqQ2j9fwnCCS_usjlGSME_qmo,62743
+pyoframe/model.py,sha256=d_WyLzdfroDYAtyXs3Ie_jo5c_CGxTX5qPT4vCVaiB8,11967
+pyoframe/model_element.py,sha256=nCfe56CRWr6bwP8irUd2bmLAEGQ-7GwOQtWeqz2WxtU,5944
+pyoframe/monkey_patch.py,sha256=9IfS14G6IPabmM9z80jzi_D4Rq0Mdx5aUCA39Yi2tgE,2044
+pyoframe/objective.py,sha256=PBWxj30QkFlsvY6ijZ6KjyKdrJARD4to0ieF6GUqaQU,3238
+pyoframe/util.py,sha256=Oyk8xh6FJHlb04X_cM4lN0UzdnKLXAMrKfyOf7IexiA,13480
+pyoframe-0.1.1.dist-info/LICENSE,sha256=dkwA40ZzT-3x6eu2a6mf_o7PNSqHbdsyaFNhLxGHNQs,1065
+pyoframe-0.1.1.dist-info/METADATA,sha256=fJyV3KirCM8UBwOGNYODi_6mRxKKU7chhvuYpWob4bE,3518
+pyoframe-0.1.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+pyoframe-0.1.1.dist-info/top_level.txt,sha256=10z3OOJSVLriQ0IrFLMH8CH9zByugPWolqhlHlkNjV4,9
+pyoframe-0.1.1.dist-info/RECORD,,

{pyoframe-0.0.11.dist-info → pyoframe-0.1.1.dist-info}/WHEEL

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

pyoframe/io.py

@@ -1,252 +0,0 @@
-"""
-Module containing all import/export functionalities.
-"""
-
-import sys
-import time
-from io import TextIOWrapper
-from pathlib import Path
-from tempfile import NamedTemporaryFile
-from typing import TYPE_CHECKING, Iterable, Optional, TypeVar, Union
-
-from pyoframe.constants import CONST_TERM, VAR_KEY, ObjSense
-from pyoframe.core import Constraint, Variable
-from pyoframe.io_mappers import (
-    Base36ConstMapper,
-    Base36VarMapper,
-    IOMappers,
-    Mapper,
-    NamedMapper,
-    NamedVariableMapper,
-)
-
-if TYPE_CHECKING:  # pragma: no cover
-    from pyoframe.model import Model
-
-import polars as pl
-
-T = TypeVar("T")
-
-
-def io_progress_bar(
-    iterable: Iterable[T],
-    prefix: str = "",
-    suffix: str = "",
-    length: int = 50,
-    fill: str = "█",
-    update_every: int = 1,
-):
-    """
-    Display progress bar for I/O operations.
-    """
-    try:
-        total = len(iterable)
-    except TypeError:
-        total = None
-
-    start_time = time.time()
-
-    def print_progress(iteration: int):
-        if total is not None:
-            percent = f"{100 * (iteration / float(total)):.1f}"
-            filled_length = int(length * iteration // total)
-            bar = fill * filled_length + "-" * (length - filled_length)
-        else:
-            percent = "N/A"
-            bar = fill * (iteration % length) + "-" * (length - (iteration % length))
-        elapsed_time = time.time() - start_time
-        if iteration > 0:
-            estimated_total_time = (
-                elapsed_time * (total / iteration) if total else elapsed_time
-            )
-            estimated_remaining_time = estimated_total_time - elapsed_time
-            eta = time.strftime("%H:%M:%S", time.gmtime(estimated_remaining_time))
-        else:
-            eta = "Estimating..."  # pragma: no cover
-        sys.stdout.write(
-            f'\r{prefix} |{bar}| {percent}% Complete ({iteration}/{total if total else "?"}) ETA: {eta} {suffix}'
-        )
-        sys.stdout.flush()
-
-    for i, item in enumerate(iterable):
-        yield item
-        if (i + 1) % update_every == 0 or total is None or i == total - 1:
-            print_progress(i + 1)
-
-    sys.stdout.write("\n")
-    sys.stdout.flush()
-
-
-def objective_to_file(m: "Model", f: TextIOWrapper, var_map):
-    """
-    Write out the objective of a model to a lp file.
-    """
-    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(
-        io_progress_bar(
-            m.constraints, prefix="Writing constraints to file", update_every=5
-        ),
-        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.
-    """
-    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 io_progress_bar(
-        m.variables, prefix="Writing bounds to file", update_every=1
-    ):
-        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(terms).str.concat(""))
-            .item()
-        )
-
-        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(
-        io_progress_bar(
-            m.binary_variables,
-            prefix="Writing binary variables to file",
-            update_every=1,
-        ),
-        f,
-        "binary",
-    ):
-        lines = (
-            var_map.apply(variable.data, to_col=None)
-            .select(pl.col(VAR_KEY).str.concat("\n"))
-            .item()
-        )
-        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(
-        io_progress_bar(
-            m.integer_variables,
-            prefix="Writing integer variables to file",
-            update_every=5,
-        ),
-        f,
-        "general",
-    ):
-        lines = (
-            var_map.apply(variable.data, to_col=None)
-            .select(pl.col(VAR_KEY).str.concat("\n"))
-            .item()
-        )
-        f.write(lines + "\n")
-
-
-def create_section(iterable: Iterable[T], f, section_header) -> Iterable[T]:
-    wrote = False
-    for item in iterable:
-        if not wrote:
-            f.write(f"\n\n{section_header}\n\n")
-            wrote = True
-        yield item
-
-
-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 = NamedVariableMapper(Variable)
-    else:
-        var_map = Base36VarMapper(Variable)
-
-    for v in m.variables:
-        var_map.add(v)
-    return var_map
-
-
-def to_file(
-    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(
-            prefix="pyoframe-problem-", suffix=".lp", mode="w", delete=False
-        ) as f:
-            file_path = f.name
-
-    file_path = Path(file_path)
-    assert file_path.suffix == ".lp", f"File format `{file_path.suffix}` not supported."
-
-    if file_path.exists():
-        file_path.unlink()
-
-    const_map = (
-        NamedMapper(Constraint) if use_var_names else Base36ConstMapper(Constraint)
-    )
-    for c in m.constraints:
-        const_map.add(c)
-    var_map = get_var_map(m, use_var_names)
-    m.io_mappers = IOMappers(var_map, const_map)
-
-    with open(file_path, mode="w") as f:
-        objective_to_file(m, f, var_map)
-        constraints_to_file(m, f, var_map, const_map)
-        bounds_to_file(m, f, var_map)
-        binaries_to_file(m, f, var_map)
-        integers_to_file(m, f, var_map)
-        f.write("\nend\n")
-
-    return file_path