pyoframe 0.0.4__py3-none-any.whl

pyoframe/solvers.py

@@ -0,0 +1,186 @@
+"""
+Code to interface with various solvers
+"""
+
+from abc import abstractmethod, ABC
+from pathlib import Path
+from typing import Optional, Union, TYPE_CHECKING
+
+import polars as pl
+
+from pyoframe.constants import (
+    DUAL_KEY,
+    NAME_COL,
+    SOLUTION_KEY,
+    Result,
+    Solution,
+    Status,
+)
+import contextlib
+
+from pathlib import Path
+
+if TYPE_CHECKING:  # pragma: no cover
+    from pyoframe.model import Model
+
+
+def solve(m: "Model", solver, **kwargs):
+    if solver == "gurobi":
+        result = GurobiSolver().solve(m, **kwargs)
+    else:
+        raise ValueError(f"Solver {solver} not recognized or supported.")
+
+    if result.solution 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):
+    @abstractmethod
+    def solve(self, model, directory: Optional[Path] = None, **kwargs) -> Result: ...
+
+
+class FileBasedSolver(Solver):
+    def solve(
+        self,
+        model: "Model",
+        directory: Optional[Union[Path, str]] = None,
+        use_var_names=None,
+        **kwargs,
+    ) -> Result:
+        problem_file = None
+        if directory is not None:
+            if isinstance(directory, str):
+                directory = Path(directory)
+            if not directory.exists():
+                directory.mkdir(parents=True)
+            filename = model.name if model.name is not None else "pyoframe-problem"
+            problem_file = directory / f"{filename}.lp"
+        problem_file = model.to_file(problem_file, use_var_names=use_var_names)
+        assert model.io_mappers is not None
+
+        results = self.solve_from_lp(problem_file, **kwargs)
+
+        if results.solution is not None:
+            results.solution.primal = model.io_mappers.var_map.undo(
+                results.solution.primal
+            )
+            if results.solution.dual is not None:
+                results.solution.dual = model.io_mappers.const_map.undo(
+                    results.solution.dual
+                )
+
+        return results
+
+    @abstractmethod
+    def solve_from_lp(self, problem_file: Path, **kwargs) -> Result: ...
+
+
+class GurobiSolver(FileBasedSolver):
+    def solve_from_lp(
+        self,
+        problem_fn,
+        log_fn=None,
+        warmstart_fn=None,
+        basis_fn=None,
+        solution_file=None,
+        env=None,
+        **solver_options,
+    ) -> Result:
+        """
+        Solve a linear problem using the gurobi solver.
+
+        This function communicates with gurobi using the gurubipy package.
+        """
+        import gurobipy
+
+        # 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",
+        }
+
+        with contextlib.ExitStack() as stack:
+            if env is None:
+                env = stack.enter_context(gurobipy.Env())
+
+            m = gurobipy.read(path_to_str(problem_fn), env=env)
+            if solver_options is not None:
+                for key, value in solver_options.items():
+                    m.setParam(key, value)
+            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 = CONDITION_MAP.get(condition, condition)
+            status = Status.from_termination_condition(termination_condition)
+
+            if status.is_ok:
+                if solution_file:
+                    m.write(path_to_str(solution_file))
+
+                objective = m.ObjVal
+                vars = m.getVars()
+                sol = pl.DataFrame(
+                    {
+                        NAME_COL: m.getAttr("VarName", vars),
+                        SOLUTION_KEY: m.getAttr("X", vars),
+                    }
+                )
+
+                constraints = m.getConstrs()
+                try:
+                    dual = pl.DataFrame(
+                        {
+                            DUAL_KEY: m.getAttr("Pi", constraints),
+                            NAME_COL: m.getAttr("ConstrName", constraints),
+                        }
+                    )
+                except gurobipy.GurobiError:
+                    dual = None
+
+                solution = Solution(sol, dual, objective)
+            else:
+                solution = None
+
+        return Result(status, solution, m)
+
+
+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/util.py

@@ -0,0 +1,271 @@
+"""
+File containing utility functions and classes.
+"""
+
+from abc import abstractmethod, ABC
+from collections import defaultdict
+from typing import Any, Dict, Iterable, Optional, Union
+
+import polars as pl
+import pandas as pd
+
+from pyoframe.constants import COEF_KEY, CONST_TERM, RESERVED_COL_KEYS, VAR_KEY
+
+
+class IdCounterMixin(ABC):
+    """
+    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.
+    """
+
+    # Keys are the subclass names and values are the next unasigned ID.
+    _id_counters: Dict[str, int] = defaultdict(lambda: 1)
+
+    @classmethod
+    def _reset_counters(cls):
+        """
+        Resets all the ID counters.
+        This function is called before every unit test to reset the code state.
+        """
+        cls._id_counters = defaultdict(lambda: 1)
+
+    def _assign_ids(self, df: pl.DataFrame) -> pl.DataFrame:
+        """
+        Adds the column `to_column` to the DataFrame `df` with the next batch
+        of unique consecutive IDs.
+        """
+        cls_name = self.__class__.__name__
+        cur_count = self._id_counters[cls_name]
+        id_col_name = self.get_id_column_name()
+
+        if df.height == 0:
+            df = df.with_columns(pl.lit(cur_count).alias(id_col_name))
+        else:
+            df = df.with_columns(
+                pl.int_range(cur_count, cur_count + pl.len()).alias(id_col_name)
+            )
+        df = df.with_columns(pl.col(id_col_name).cast(pl.UInt32))
+        self._id_counters[cls_name] += df.height
+        return df
+
+    @classmethod
+    @abstractmethod
+    def get_id_column_name(cls) -> str:
+        """
+        Returns the name of the column containing the IDs.
+        """
+
+    @property
+    @abstractmethod
+    def ids(self) -> pl.DataFrame:
+        """
+        Returns a dataframe with the IDs and any other relevant columns (i.e. the dimension columns).
+        """
+
+
+def get_obj_repr(obj: object, _props: Iterable[str] = (), **kwargs):
+    """
+    Helper function to generate __repr__ strings for classes. See usage for examples.
+    """
+    props = {prop: getattr(obj, prop) for prop in _props}
+    props_str = " ".join(f"{k}={v}" for k, v in props.items() if v is not None)
+    if props_str:
+        props_str += " "
+    kwargs_str = " ".join(f"{k}={v}" for k, v in kwargs.items() if v is not None)
+    return f"<{obj.__class__.__name__} {props_str}{kwargs_str}>"
+
+
+def parse_inputs_as_iterable(
+    *inputs: Union[Any, Iterable[Any]],
+) -> Iterable[Any]:
+    """
+    Converts a parameter *x: Any | Iteraable[Any] to a single Iterable[Any] object.
+    This is helpful to support these two ways of passing arguments:
+        - foo([1, 2, 3])
+        - foo(1, 2, 3)
+
+    Inspired from the polars library.
+    """
+    if not inputs:
+        return []
+
+    # Treat elements of a single iterable as separate inputs
+    if len(inputs) == 1 and _is_iterable(inputs[0]):
+        return inputs[0]
+
+    return inputs
+
+
+def _is_iterable(input: Union[Any, Iterable[Any]]) -> bool:
+    # Inspired from the polars library
+    return isinstance(input, Iterable) and not isinstance(
+        input,
+        (str, bytes, pl.DataFrame, pl.Series, pd.DataFrame, pd.Series, pd.Index, dict),
+    )
+
+
+def concat_dimensions(
+    df: pl.DataFrame,
+    prefix: Optional[str] = None,
+    keep_dims: bool = True,
+    ignore_columns=RESERVED_COL_KEYS,
+    replace_spaces: bool = True,
+    to_col: str = "concated_dim",
+) -> pl.DataFrame:
+    """
+    Returns a new DataFrame with the column 'concated_dim'. Reserved columns are ignored.
+
+    Parameters:
+        df : pl.DataFrame
+            The input DataFrame.
+        prefix : str, optional
+            The prefix to be added to the concated dimension.
+        keep_dims : bool, optional
+            If True, the original dimensions are kept in the new DataFrame.
+
+    Examples:
+        >>> import polars as pl
+        >>> df = pl.DataFrame(
+        ...     {
+        ...         "dim1": [1, 2, 3, 1, 2, 3],
+        ...         "dim2": ["Y", "Y", "Y", "N", "N", "N"],
+        ...     }
+        ... )
+        >>> concat_dimensions(df)
+        shape: (6, 3)
+        ┌──────┬──────┬──────────────┐
+        │ dim1 ┆ dim2 ┆ concated_dim │
+        │ ---  ┆ ---  ┆ ---          │
+        │ i64  ┆ str  ┆ str          │
+        ╞══════╪══════╪══════════════╡
+        │ 1    ┆ Y    ┆ [1,Y]        │
+        │ 2    ┆ Y    ┆ [2,Y]        │
+        │ 3    ┆ Y    ┆ [3,Y]        │
+        │ 1    ┆ N    ┆ [1,N]        │
+        │ 2    ┆ N    ┆ [2,N]        │
+        │ 3    ┆ N    ┆ [3,N]        │
+        └──────┴──────┴──────────────┘
+        >>> concat_dimensions(df, prefix="x")
+        shape: (6, 3)
+        ┌──────┬──────┬──────────────┐
+        │ dim1 ┆ dim2 ┆ concated_dim │
+        │ ---  ┆ ---  ┆ ---          │
+        │ i64  ┆ str  ┆ str          │
+        ╞══════╪══════╪══════════════╡
+        │ 1    ┆ Y    ┆ x[1,Y]       │
+        │ 2    ┆ Y    ┆ x[2,Y]       │
+        │ 3    ┆ Y    ┆ x[3,Y]       │
+        │ 1    ┆ N    ┆ x[1,N]       │
+        │ 2    ┆ N    ┆ x[2,N]       │
+        │ 3    ┆ N    ┆ x[3,N]       │
+        └──────┴──────┴──────────────┘
+        >>> concat_dimensions(df, keep_dims=False)
+        shape: (6, 1)
+        ┌──────────────┐
+        │ concated_dim │
+        │ ---          │
+        │ str          │
+        ╞══════════════╡
+        │ [1,Y]        │
+        │ [2,Y]        │
+        │ [3,Y]        │
+        │ [1,N]        │
+        │ [2,N]        │
+        │ [3,N]        │
+        └──────────────┘
+        >>> # Properly handles cases with no dimensions and ignores reserved columns
+        >>> df = pl.DataFrame({VAR_KEY: [1, 2]})
+        >>> concat_dimensions(df, prefix="x")
+        shape: (2, 2)
+        ┌───────────────┬──────────────┐
+        │ __variable_id ┆ concated_dim │
+        │ ---           ┆ ---          │
+        │ i64           ┆ str          │
+        ╞═══════════════╪══════════════╡
+        │ 1             ┆ x            │
+        │ 2             ┆ x            │
+        └───────────────┴──────────────┘
+    """
+    if prefix is None:
+        prefix = ""
+    dimensions = [col for col in df.columns if col not in ignore_columns]
+    if dimensions:
+        query = pl.concat_str(
+            pl.lit(prefix + "["),
+            pl.concat_str(*dimensions, separator=","),
+            pl.lit("]"),
+        )
+    else:
+        query = pl.lit(prefix)
+
+    df = df.with_columns(query.alias(to_col))
+
+    if replace_spaces:
+        df = df.with_columns(pl.col(to_col).str.replace_all(" ", "_"))
+
+    if not keep_dims:
+        df = df.drop(*dimensions)
+
+    return df
+
+
+def cast_coef_to_string(
+    df: pl.DataFrame, column_name: str = COEF_KEY, drop_ones=True, float_precision=None
+) -> pl.DataFrame:
+    """
+    Parameters:
+        df : pl.DataFrame
+            The input DataFrame.
+        column_name : str, optional
+            The name of the column to be casted.
+        drop_ones : bool, optional
+            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]})
+        >>> cast_coef_to_string(df, "x")
+        shape: (4, 2)
+        ┌─────┬───────────────┐
+        │ x   ┆ __variable_id │
+        │ --- ┆ ---           │
+        │ str ┆ i64           │
+        ╞═════╪═══════════════╡
+        │ +   ┆ 1             │
+        │ -2  ┆ 2             │
+        │ +1  ┆ 0             │
+        │ +4  ┆ 4             │
+        └─────┴───────────────┘
+    """
+    df = df.with_columns(
+        pl.col(column_name).abs(),
+        _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))
+
+    df = df.with_columns(
+        pl.when(pl.col(column_name) == pl.col(column_name).floor())
+        .then(pl.col(column_name).cast(pl.Int64).cast(pl.String))
+        .otherwise(pl.col(column_name).cast(pl.String))
+        .alias(column_name)
+    )
+
+    if drop_ones:
+        condition = pl.col(column_name) == str(1)
+        if VAR_KEY in df.columns:
+            condition = condition & (pl.col(VAR_KEY) != CONST_TERM)
+        df = df.with_columns(
+            pl.when(condition)
+            .then(pl.lit(""))
+            .otherwise(pl.col(column_name))
+            .alias(column_name)
+        )
+    else:
+        df = df.with_columns(pl.col(column_name).cast(pl.Utf8))
+    return df.with_columns(pl.concat_str("_sign", column_name).alias(column_name)).drop(
+        "_sign"
+    )

pyoframe/variables.py

@@ -0,0 +1,193 @@
+"""
+File containing Variable class representing decision variables in optimization models.
+"""
+
+from __future__ import annotations
+from typing import Iterable
+
+import polars as pl
+
+from pyoframe.constraints import SupportsMath, Set
+
+from pyoframe.constants import COEF_KEY, SOLUTION_KEY, VAR_KEY, VType, VTypeValue
+from pyoframe.constraints import Expression
+from pyoframe.model_element import ModelElement
+from pyoframe.constraints import SetTypes
+from pyoframe.util import IdCounterMixin, get_obj_repr
+
+
+class Variable(ModelElement, SupportsMath, IdCounterMixin):
+    """
+    Represents one or many decision variable in an optimization model.
+
+    Parameters:
+        *indexing_sets: SetTypes (typically a DataFrame or Set)
+            If no indexing_sets are provided, a single variable with no dimensions is created.
+            Otherwise, a variable is created for each element in the Cartesian product of the indexing_sets (see Set for details on behaviour).
+        lb: float
+            The lower bound for all variables.
+        ub: float
+            The upper bound for all variables.
+        vtype: VType | VTypeValue
+            The type of the variable. Can be either a VType enum or a string. Default is VType.CONTINUOUS.
+
+    Examples:
+        >>> import pandas as pd
+        >>> from pyoframe import Variable
+        >>> df = pd.DataFrame({"dim1": [1, 1, 2, 2, 3, 3], "dim2": ["a", "b", "a", "b", "a", "b"]})
+        >>> Variable(df)
+        <Variable lb=-inf ub=inf size=6 dimensions={'dim1': 3, 'dim2': 2}>
+        [1,a]: x1
+        [1,b]: x2
+        [2,a]: x3
+        [2,b]: x4
+        [3,a]: x5
+        [3,b]: x6
+        >>> Variable(df[["dim1"]])
+        Traceback (most recent call last):
+        ...
+        ValueError: Duplicate rows found in input data.
+        >>> Variable(df[["dim1"]].drop_duplicates())
+        <Variable lb=-inf ub=inf size=3 dimensions={'dim1': 3}>
+        [1]: x7
+        [2]: x8
+        [3]: x9
+    """
+
+    # TODO: Breaking change, remove support for Iterable[AcceptableSets]
+    def __init__(
+        self,
+        *indexing_sets: SetTypes | Iterable[SetTypes],
+        lb: float = float("-inf"),
+        ub: float = float("inf"),
+        vtype: VType | VTypeValue = VType.CONTINUOUS,
+    ):
+        data = Set(*indexing_sets).data if len(indexing_sets) > 0 else pl.DataFrame()
+        data = self._assign_ids(data)
+
+        super().__init__(data)
+
+        self.vtype: VType = VType(vtype)
+
+        # Tightening the bounds is not strictly necessary, but it adds clarity
+        if self.vtype == VType.BINARY:
+            lb, ub = 0, 1
+
+        self.lb = lb
+        self.ub = ub
+
+    @classmethod
+    def get_id_column_name(cls):
+        return VAR_KEY
+
+    @property
+    def solution(self):
+        if SOLUTION_KEY not in self.data.columns:
+            raise ValueError(f"No solution solution found for Variable '{self.name}'.")
+        df = self.data.select(self.dimensions_unsafe + [SOLUTION_KEY])
+        if df.shape == (1, 1):
+            return df.item()
+        return df
+
+    @solution.setter
+    def solution(self, value):
+        assert sorted(value.columns) == sorted([SOLUTION_KEY, VAR_KEY])
+        df = self.data
+        if SOLUTION_KEY in self.data.columns:
+            df = df.drop(SOLUTION_KEY)
+        self._data = df.join(value, on=VAR_KEY, how="left", validate="1:1")
+
+    @property
+    def ids(self):
+        return self.data.select(self.dimensions_unsafe + [VAR_KEY])
+
+    def __repr__(self):
+        return (
+            get_obj_repr(
+                self, ("name", "lb", "ub"), size=self.data.height, dimensions=self.shape
+            )
+            + "\n"
+            + self.to_expr().to_str(max_line_len=80, max_rows=10)
+        )
+
+    def to_expr(self) -> Expression:
+        return self._new(self.data.drop(SOLUTION_KEY))
+
+    def _new(self, data: pl.DataFrame):
+        e = Expression(data.with_columns(pl.lit(1.0).alias(COEF_KEY)))
+        e._model = self._model
+        # We propogate the unmatched strategy intentionally. Without this a .keep_unmatched() on a variable would always be lost.
+        e.unmatched_strategy = self.unmatched_strategy
+        e.allowed_new_dims = self.allowed_new_dims
+        return e
+
+    def next(self, dim: str, wrap_around: bool = False) -> Expression:
+        """
+        Creates an expression where the variable at each index is the next variable in the specified dimension.
+
+        Parameters:
+            dim:
+                The dimension over which to shift the variable.
+            wrap_around:
+                If True, the last index in the dimension is connected to the first index.
+
+        Examples:
+            >>> import pandas as pd
+            >>> from pyoframe import Variable, Model
+            >>> time_dim = pd.DataFrame({"time": ["00:00", "06:00", "12:00", "18:00"]})
+            >>> space_dim = pd.DataFrame({"city": ["Toronto", "Berlin"]})
+            >>> m = Model()
+            >>> m.bat_charge = Variable(time_dim, space_dim)
+            >>> m.bat_flow = Variable(time_dim, space_dim)
+            >>> # Fails because the dimensions are not the same
+            >>> m.bat_charge + m.bat_flow == m.bat_charge.next("time")
+            Traceback (most recent call last):
+            ...
+            pyoframe._arithmetic.PyoframeError: Failed to add expressions:
+            <Expression size=8 dimensions={'time': 4, 'city': 2} terms=16> + <Expression size=6 dimensions={'city': 2, 'time': 3} terms=6>
+            Due to error:
+            Dataframe has unmatched values. If this is intentional, use .drop_unmatched() or .keep_unmatched()
+            shape: (2, 4)
+            ┌───────┬─────────┬────────────┬────────────┐
+            │ time  ┆ city    ┆ time_right ┆ city_right │
+            │ ---   ┆ ---     ┆ ---        ┆ ---        │
+            │ str   ┆ str     ┆ str        ┆ str        │
+            ╞═══════╪═════════╪════════════╪════════════╡
+            │ 18:00 ┆ Toronto ┆ null       ┆ null       │
+            │ 18:00 ┆ Berlin  ┆ null       ┆ null       │
+            └───────┴─────────┴────────────┴────────────┘
+
+            >>> (m.bat_charge + m.bat_flow).drop_unmatched() == m.bat_charge.next("time")
+            <Constraint sense='=' size=6 dimensions={'time': 3, 'city': 2} terms=18>
+            [00:00,Berlin]: bat_charge[00:00,Berlin] + bat_flow[00:00,Berlin] - bat_charge[06:00,Berlin] = 0
+            [00:00,Toronto]: bat_charge[00:00,Toronto] + bat_flow[00:00,Toronto] - bat_charge[06:00,Toronto] = 0
+            [06:00,Berlin]: bat_charge[06:00,Berlin] + bat_flow[06:00,Berlin] - bat_charge[12:00,Berlin] = 0
+            [06:00,Toronto]: bat_charge[06:00,Toronto] + bat_flow[06:00,Toronto] - bat_charge[12:00,Toronto] = 0
+            [12:00,Berlin]: bat_charge[12:00,Berlin] + bat_flow[12:00,Berlin] - bat_charge[18:00,Berlin] = 0
+            [12:00,Toronto]: bat_charge[12:00,Toronto] + bat_flow[12:00,Toronto] - bat_charge[18:00,Toronto] = 0
+
+            >>> (m.bat_charge + m.bat_flow) == m.bat_charge.next("time", wrap_around=True)
+            <Constraint sense='=' size=8 dimensions={'time': 4, 'city': 2} terms=24>
+            [00:00,Berlin]: bat_charge[00:00,Berlin] + bat_flow[00:00,Berlin] - bat_charge[06:00,Berlin] = 0
+            [00:00,Toronto]: bat_charge[00:00,Toronto] + bat_flow[00:00,Toronto] - bat_charge[06:00,Toronto] = 0
+            [06:00,Berlin]: bat_charge[06:00,Berlin] + bat_flow[06:00,Berlin] - bat_charge[12:00,Berlin] = 0
+            [06:00,Toronto]: bat_charge[06:00,Toronto] + bat_flow[06:00,Toronto] - bat_charge[12:00,Toronto] = 0
+            [12:00,Berlin]: bat_charge[12:00,Berlin] + bat_flow[12:00,Berlin] - bat_charge[18:00,Berlin] = 0
+            [12:00,Toronto]: bat_charge[12:00,Toronto] + bat_flow[12:00,Toronto] - bat_charge[18:00,Toronto] = 0
+            [18:00,Berlin]: bat_charge[18:00,Berlin] + bat_flow[18:00,Berlin] - bat_charge[00:00,Berlin] = 0
+            [18:00,Toronto]: bat_charge[18:00,Toronto] + bat_flow[18:00,Toronto] - bat_charge[00:00,Toronto] = 0
+        """
+
+        wrapped = self.data.select(dim).unique(maintain_order=True).sort(by=dim)
+        wrapped = wrapped.with_columns(pl.col(dim).shift(-1).alias("__next"))
+        if wrap_around:
+            wrapped = wrapped.with_columns(pl.col("__next").fill_null(pl.first(dim)))
+        else:
+            wrapped = wrapped.drop_nulls(dim)
+
+        expr = self.to_expr()
+        data = expr.data.rename({dim: "__prev"})
+        data = data.join(
+            wrapped, left_on="__prev", right_on="__next", how="inner"
+        ).drop(["__prev", "__next"])
+        return expr._new(data)

pyoframe-0.0.4.dist-info/LICENSE

@@ -0,0 +1,23 @@
+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
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.