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

pyoframe/_model.py

@@ -20,8 +20,8 @@ from pyoframe._constants import (
     VType,
     _Solver,
 )
-from pyoframe._core import Constraint, SupportsToExpr, Variable
-from pyoframe._model_element import ModelElement, ModelElementWithId
+from pyoframe._core import Constraint, Operable, Variable
+from pyoframe._model_element import BaseBlock
 from pyoframe._objective import Objective
 from pyoframe._utils import Container, NamedVariableMapper, for_solvers, get_obj_repr
 
@@ -76,7 +76,7 @@ class Model:
         "_var_map",
         "name",
         "solver",
-        "poi",
+        "_poi",
         "_params",
         "params",
         "_attr",
@@ -99,21 +99,27 @@ class Model:
         print_uses_variable_names: bool = True,
         sense: ObjSense | ObjSenseValue | None = None,
     ):
-        self.poi, self.solver = Model._create_poi_model(solver, solver_env)
+        self._poi, self.solver = Model._create_poi_model(solver, solver_env)
         self.solver_name: str = self.solver.name
         self._variables: list[Variable] = []
         self._constraints: list[Constraint] = []
         self.sense: ObjSense | None = ObjSense(sense) if sense is not None else None
         self._objective: Objective | None = None
-        self._var_map = (
-            NamedVariableMapper(Variable) if print_uses_variable_names else None
-        )
+        self._var_map = NamedVariableMapper() if print_uses_variable_names else None
         self.name: str | None = name
 
         self._params = Container(self._set_param, self._get_param)
         self._attr = Container(self._set_attr, self._get_attr)
         self._solver_uses_variable_names = solver_uses_variable_names
 
+    @property
+    def poi(self):
+        """The underlying PyOptInterface model used to interact with the solver.
+
+        Modifying the underlying model directly is not recommended and may lead to unexpected behaviors.
+        """
+        return self._poi
+
     @property
     def solver_uses_variable_names(self):
         """Whether to pass human-readable variable names to the solver."""
@@ -125,8 +131,9 @@ class Model:
 
         Several model attributes are common across all solvers making it easy to switch between solvers (see supported attributes for
         [Gurobi](https://metab0t.github.io/PyOptInterface/gurobi.html#supported-model-attribute),
-        [HiGHS](https://metab0t.github.io/PyOptInterface/highs.html), and
-        [Ipopt](https://metab0t.github.io/PyOptInterface/ipopt.html)).
+        [HiGHS](https://metab0t.github.io/PyOptInterface/highs.html),
+        [Ipopt](https://metab0t.github.io/PyOptInterface/ipopt.html)), and
+        [COPT](https://metab0t.github.io/PyOptInterface/copt.html).
 
         We additionally support all of [Gurobi's attributes](https://docs.gurobi.com/projects/optimizer/en/current/reference/attributes.html#sec:Attributes) when using Gurobi.
 
@@ -161,7 +168,8 @@ class Model:
         See the list of available parameters for
         [Gurobi](https://docs.gurobi.com/projects/optimizer/en/current/reference/parameters.html#sec:Parameters),
         [HiGHS](https://ergo-code.github.io/HiGHS/stable/options/definitions/),
-        and [Ipopt](https://coin-or.github.io/Ipopt/OPTIONS.html).
+        [Ipopt](https://coin-or.github.io/Ipopt/OPTIONS.html),
+        and [COPT](https://guide.coap.online/copt/en-doc/parameter.html).
 
         Examples:
             For example, if you'd like to use Gurobi's barrier method, you can set the `Method` parameter:
@@ -226,7 +234,7 @@ class Model:
                 from pyoptinterface import ipopt
             except ModuleNotFoundError as e:  # pragma: no cover
                 raise ModuleNotFoundError(
-                    "Failed to import the Ipopt solver. Did you run `pip install pyoptinterface[ipopt]`?"
+                    "Failed to import the Ipopt solver. Did you run `pip install pyoptinterface[nlp]`?"
                 ) from e
 
             try:
@@ -237,6 +245,18 @@ class Model:
                         "Could not find the Ipopt solver. Are you sure you've properly installed it and added it to your PATH?"
                     ) from e
                 raise e
+        elif solver.name == "copt":
+            from pyoptinterface import copt
+
+            if solver_env is None:
+                env = copt.Env()
+            else:
+                # COPT uses EnvConfig for configuration
+                env_config = copt.EnvConfig()
+                for key, value in solver_env.items():
+                    env_config.set(key, value)
+                env = copt.Env(env_config)
+            model = copt.Model(env)
         else:
             raise ValueError(
                 f"Solver {solver} not recognized or supported."
@@ -315,7 +335,7 @@ class Model:
             ValueError: Objective is not defined.
             >>> m.maximize = m.X
             >>> m.objective
-            <Objective terms=1 type=linear>
+            <Objective (linear) terms=1>
             X
 
         See Also:
@@ -326,7 +346,7 @@ class Model:
         return self._objective
 
     @objective.setter
-    def objective(self, value: SupportsToExpr | float | int):
+    def objective(self, value: Operable):
         if self.has_objective and (
             not isinstance(value, Objective) or not value._constructive
         ):
@@ -344,7 +364,7 @@ class Model:
         return self._objective
 
     @minimize.setter
-    def minimize(self, value: SupportsToExpr | float | int):
+    def minimize(self, value: Operable):
         if self.sense is None:
             self.sense = ObjSense.MIN
         if self.sense != ObjSense.MIN:
@@ -359,7 +379,7 @@ class Model:
         return self._objective
 
     @maximize.setter
-    def maximize(self, value: SupportsToExpr | float | int):
+    def maximize(self, value: Operable):
         if self.sense is None:
             self.sense = ObjSense.MAX
         if self.sense != ObjSense.MAX:
@@ -368,17 +388,14 @@ class Model:
 
     def __setattr__(self, __name: str, __value: Any) -> None:
         if __name not in Model._reserved_attributes and not isinstance(
-            __value, (ModelElement, pl.DataFrame, pd.DataFrame)
+            __value, (BaseBlock, 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, ...)"
+                f"Cannot set attribute '{__name}' on the model because it isn't a subtype of BaseBlock (e.g. Variable, Constraint, ...)"
             )
 
-        if (
-            isinstance(__value, ModelElement)
-            and __name not in Model._reserved_attributes
-        ):
-            if isinstance(__value, ModelElementWithId):
+        if isinstance(__value, BaseBlock) and __name not in Model._reserved_attributes:
+            if __value._get_id_column_name() is not None:
                 assert not hasattr(self, __name), (
                     f"Cannot create {__name} since it was already created."
                 )
@@ -400,7 +417,7 @@ class Model:
     def __repr__(self) -> str:
         return get_obj_repr(
             self,
-            self.name,
+            f"'{self.name}'" if self.name is not None else None,
             vars=len(self.variables),
             constrs=len(self.constraints),
             has_objective=self.has_objective,
@@ -431,7 +448,10 @@ class Model:
         """
         if not self.solver.supports_write:
             raise NotImplementedError(f"{self.solver.name} does not support .write()")
-        if not self.solver_uses_variable_names and self.solver.block_auto_names:
+        if (
+            not self.solver_uses_variable_names
+            and self.solver.accelerate_with_repeat_names
+        ):
             raise ValueError(
                 f"{self.solver.name} requires solver_uses_variable_names=True to use .write()"
             )
@@ -488,10 +508,10 @@ class Model:
 
     @for_solvers("gurobi", "copt")
     def compute_IIS(self):
-        """Gurobi only: Computes the Irreducible Infeasible Set (IIS) of the model.
+        """Gurobi and COPT only: 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.
+        !!! warning "Gurobi and COPT only"
+            This method only works with the Gurobi and COPT solver. Open an issue if you'd like to see support for other solvers.
 
         Examples:
             >>> m = pf.Model("gurobi")
@@ -548,7 +568,7 @@ class Model:
             self.poi.set_raw_parameter(name, value)
         except KeyError as e:
             raise KeyError(
-                f"Unknown parameter: '{name}'. See https://bravos-power.github.io/pyoframe/learn/getting-started/solver-access/ for a list of valid parameters."
+                f"Unknown parameter: '{name}'. See https://bravos-power.github.io/pyoframe/latest/learn/getting-started/solver-access/ for a list of valid parameters."
             ) from e
 
     def _get_param(self, name):
@@ -556,7 +576,7 @@ class Model:
             return self.poi.get_raw_parameter(name)
         except KeyError as e:
             raise KeyError(
-                f"Unknown parameter: '{name}'. See https://bravos-power.github.io/pyoframe/learn/getting-started/solver-access/ for a list of valid parameters."
+                f"Unknown parameter: '{name}'. See https://bravos-power.github.io/pyoframe/latest/learn/getting-started/solver-access/ for a list of valid parameters."
             ) from e
 
     def _set_attr(self, name, value):

pyoframe/_model_element.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from abc import ABC, abstractmethod
+from abc import ABC
 from typing import TYPE_CHECKING
 
 import polars as pl
@@ -10,17 +10,17 @@ 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,
+    Config,
 )
 
 if TYPE_CHECKING:  # pragma: no cover
     from pyoframe import Model
 
 
-class ModelElement(ABC):
+class BaseBlock(ABC):
     """The base class for elements of a Model such as [][pyoframe.Variable] and [][pyoframe.Constraint]."""
 
     def __init__(self, data: pl.DataFrame, name="unnamed") -> None:
@@ -41,13 +41,15 @@ class ModelElement(ABC):
         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})
+            data = data.cast({VAR_KEY: Config.id_dtype})
         if QUAD_VAR_KEY in data.columns:
-            data = data.cast({QUAD_VAR_KEY: KEY_TYPE})
+            data = data.cast({QUAD_VAR_KEY: Config.id_dtype})
 
         self._data = data
         self._model: Model | None = None
         self.name: str = name  # gets overwritten if object is added to model
+        """A user-friendly name that is displayed when printing the object or in error messages.
+        When an object is added to a model, this name is updated to the name used in the model."""
 
     def _on_add_to_model(self, model: Model, name: str):
         self.name = name
@@ -77,6 +79,26 @@ class ModelElement(ABC):
         """
         return _get_dimensions(self.data)
 
+    @property
+    def dimensionless(self) -> bool:
+        """Whether the object has no dimensions.
+
+        Examples:
+            A variable with no dimensions
+            >>> pf.Variable().dimensionless
+            True
+
+            A variable with dimensions of "hour" and "city"
+            >>> pf.Variable(
+            ...     [
+            ...         {"hour": ["00:00", "06:00", "12:00", "18:00"]},
+            ...         {"city": ["Toronto", "Berlin", "Paris"]},
+            ...     ]
+            ... ).dimensionless
+            False
+        """
+        return self.dimensions is None
+
     @property
     def _dimensions_unsafe(self) -> list[str]:
         """Same as `dimensions` but returns an empty list if there are no dimensions instead of `None`.
@@ -90,7 +112,7 @@ class ModelElement(ABC):
 
     @property
     def shape(self) -> dict[str, int]:
-        """The number of indices in each dimension.
+        """The number of distinct labels in each dimension.
 
         Examples:
             A variable with no dimensions
@@ -151,17 +173,11 @@ class ModelElement(ABC):
             return 1
         return self.data.select(dims).n_unique()
 
-
-class ModelElementWithId(ModelElement):
-    """Extends ModelElement with 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
+        id_col = self._get_id_column_name()
+        assert id_col is not None, "Cannot check for IDs if no ID column is defined."
+        return id_col in self.data.columns
 
     def _assert_has_ids(self):
         if not self._has_ids:
@@ -170,6 +186,6 @@ class ModelElementWithId(ModelElement):
             )
 
     @classmethod
-    @abstractmethod
-    def _get_id_column_name(cls) -> str:
-        """Returns the name of the column containing the IDs."""
+    def _get_id_column_name(cls) -> str | None:
+        """Subclasses should override to indicate that `data` contains an ID column."""
+        return None

pyoframe/_monkey_patch.py

@@ -5,15 +5,15 @@ 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
+from pyoframe._core import BaseOperableBlock
+from pyoframe._param import Param
 
 
 def _patch_class(cls):
     def _patch_method(func):
         @wraps(func)
         def wrapper(self, other):
-            if isinstance(other, SupportsMath):
+            if isinstance(other, BaseOperableBlock):
                 return NotImplemented
             return func(self, other)
 
@@ -24,57 +24,15 @@ def _patch_class(cls):
     cls.__sub__ = _patch_method(cls.__sub__)
     cls.__le__ = _patch_method(cls.__le__)
     cls.__ge__ = _patch_method(cls.__ge__)
+    cls.__lt__ = _patch_method(cls.__lt__)
+    cls.__gt__ = _patch_method(cls.__gt__)
     cls.__contains__ = _patch_method(cls.__contains__)
 
 
-def polars_df_to_expr(self: pl.DataFrame) -> Expression:
-    """Converts a [polars](https://pola.rs/) `DataFrame` to a Pyoframe [Expression][pyoframe.Expression] by using the last column for values and the previous columns as dimensions.
-
-    See [Special Functions](../learn/concepts/special-functions.md#dataframeto_expr) for more details.
-
-    Examples:
-        >>> import polars as pl
-        >>> df = pl.DataFrame({"x": [1, 2, 3], "y": [4, 5, 6], "z": [7, 8, 9]})
-        >>> df.to_expr()
-        <Expression height=3 terms=3 type=constant>
-        ┌─────┬─────┬────────────┐
-        │ x   ┆ y   ┆ expression │
-        │ (3) ┆ (3) ┆            │
-        ╞═════╪═════╪════════════╡
-        │ 1   ┆ 4   ┆ 7          │
-        │ 2   ┆ 5   ┆ 8          │
-        │ 3   ┆ 6   ┆ 9          │
-        └─────┴─────┴────────────┘
-    """
-    name = self.columns[-1]
-    return Expression(
-        self.rename({name: COEF_KEY})
-        .drop_nulls(COEF_KEY)
-        .with_columns(pl.lit(CONST_TERM).alias(VAR_KEY)),
-        name=name,
-    )
-
-
-def pandas_df_to_expr(self: pd.DataFrame) -> Expression:
-    """Same as [`polars.DataFrame.to_expr`](./polars.DataFrame.to_expr.md), but for [pandas](https://pandas.pydata.org/) DataFrames."""
-    return polars_df_to_expr(pl.from_pandas(self))
-
-
 def patch_dataframe_libraries():
-    """Patches 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 = polars_df_to_expr
-    pd.DataFrame.to_expr = pandas_df_to_expr
-    # TODO make a set instead!
-    pl.Series.to_expr = lambda self: self.to_frame().to_expr()
-    pd.Series.to_expr = lambda self: self.to_frame().reset_index().to_expr()
+    pl.DataFrame.to_expr = lambda self: Param(self)  # type: ignore
+    pd.DataFrame.to_expr = lambda self: Param(self)  # type: ignore
+    pd.Series.to_expr = lambda self: Param(self)  # type: ignore

pyoframe/_objective.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import pyoptinterface as poi
 
 from pyoframe._constants import ObjSense
-from pyoframe._core import Expression, SupportsToExpr
+from pyoframe._core import Expression, Operable
 
 
 # TODO don't subclass Expression to avoid a bunch of unnecessary functions being available.
@@ -20,7 +20,7 @@ class Objective(Expression):
         >>> m.con = m.A + m.B <= 10
         >>> m.maximize = 2 * m.B + 4
         >>> m.maximize
-        <Objective terms=2 type=linear>
+        <Objective (linear) terms=2>
         2 B +4
 
         The objective value can be retrieved with from the solver once the model is solved using `.value`.
@@ -62,14 +62,12 @@ class Objective(Expression):
         ValueError: An objective already exists. Use += or -= to modify it.
     """
 
-    def __init__(
-        self, expr: SupportsToExpr | int | float, _constructive: bool = False
-    ) -> None:
+    def __init__(self, expr: Operable, _constructive: bool = False) -> None:
         self._constructive = _constructive
         if isinstance(expr, (int, float)):
             expr = Expression.constant(expr)
         else:
-            expr = expr.to_expr()
+            expr = expr.to_expr()  # TODO don't rely on monkey patch
         super().__init__(expr.data, name="objective")
         self._model = expr._model
         if self.dimensions is not None:

pyoframe/_param.py

@@ -0,0 +1,99 @@
+"""Defines the function for creating model parameters."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pandas as pd
+import polars as pl
+
+from pyoframe._constants import COEF_KEY, CONST_TERM, VAR_KEY
+from pyoframe._core import Expression
+
+
+def Param(
+    data: pl.DataFrame | pd.DataFrame | pd.Series | dict | str | Path,
+) -> Expression:
+    """Creates a model parameter, i.e. an [Expression][pyoframe.Expression] that doesn't involve any variables.
+
+    A Parameter can be created from a DataFrame, CSV file, Parquet file, data dictionary, or a Pandas Series.
+
+    !!! info "`Param` is a function, not a class"
+        Technically, `Param(data)` is a function that returns an [Expression][pyoframe.Expression], not a class.
+        However, for consistency with other modeling frameworks, we provide it as a class-like function (i.e. an uppercase function).
+
+    !!! tip "Smart naming"
+        If a Param is not given a name (i.e. if it is not assigned to a model: `m.my_name = Param(...)`),
+        then its [name][pyoframe._model_element.BaseBlock.name] is inferred from the name of the column in `data` that contains the parameter values.
+        This makes debugging models with inline parameters easier.
+
+    Args:
+        data: The data to use for the parameter.
+
+            If `data` is a polars or pandas `DataFrame`, the last column will be treated as the values of the parameter, and all other columns as labels.
+
+            If `data` is a string or `Path`, it will be interpreted as a path to a CSV or Parquet file that will be read and used as a `DataFrame`. The file extension must be `.csv` or `.parquet`.
+
+            If `data` is a `pandas.Series`, the index(es) will be treated as columns for labels and the series values as the parameter values.
+
+            If `data` is of any other type (e.g. a dictionary), it will be used as if you had called `Param(pl.DataFrame(data))`.
+
+    Returns:
+        An Expression representing the parameter.
+
+    Examples:
+        >>> m = pf.Model()
+        >>> m.fixed_cost = pf.Param({"plant": ["A", "B"], "cost": [1000, 1500]})
+        >>> m.fixed_cost
+        <Expression (parameter) height=2 terms=2>
+        ┌───────┬────────────┐
+        │ plant ┆ expression │
+        │ (2)   ┆            │
+        ╞═══════╪════════════╡
+        │ A     ┆ 1000       │
+        │ B     ┆ 1500       │
+        └───────┴────────────┘
+
+        Since `Param` simply returns an Expression, you can use it in building larger expressions as usual:
+
+        >>> m.variable_cost = pf.Param(
+        ...     pl.DataFrame({"plant": ["A", "B"], "cost": [50, 60]})
+        ... )
+        >>> m.total_cost = m.fixed_cost + m.variable_cost
+        >>> m.total_cost
+        <Expression (parameter) height=2 terms=2>
+        ┌───────┬────────────┐
+        │ plant ┆ expression │
+        │ (2)   ┆            │
+        ╞═══════╪════════════╡
+        │ A     ┆ 1050       │
+        │ B     ┆ 1560       │
+        └───────┴────────────┘
+    """
+    if isinstance(data, pd.Series):
+        data = data.to_frame().reset_index()
+    if isinstance(data, pd.DataFrame):
+        data = pl.from_pandas(data)
+
+    if isinstance(data, (str, Path)):
+        data = Path(data)
+        if data.suffix.lower() == ".csv":
+            data = pl.read_csv(data)
+        elif data.suffix.lower() in {".parquet"}:
+            data = pl.read_parquet(data)
+        else:
+            raise NotImplementedError(
+                f"Could not create parameter. Unsupported file format: {data.suffix}"
+            )
+
+    if not isinstance(data, pl.DataFrame):
+        data = pl.DataFrame(data)
+
+    value_col = data.columns[-1]
+
+    return Expression(
+        data.rename({value_col: COEF_KEY})
+        .drop_nulls(COEF_KEY)
+        .with_columns(pl.lit(CONST_TERM).alias(VAR_KEY)),
+        name=value_col,
+    )

pyoframe/_utils.py

@@ -21,9 +21,8 @@ from pyoframe._constants import (
 )
 
 if TYPE_CHECKING:  # pragma: no cover
-    from pyoframe._core import SupportsMath
+    from pyoframe._core import BaseOperableBlock
     from pyoframe._model import Variable
-    from pyoframe._model_element import ModelElementWithId
 
 if sys.version_info >= (3, 10):
     pairwise = itertools.pairwise
@@ -43,7 +42,7 @@ def get_obj_repr(obj: object, *props: str | None, **kwargs):
 
     See usage for examples.
     """
-    props_str = " ".join(f"'{v}'" for v in props if v is not None)
+    props_str = " ".join(v for v in props 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)
@@ -245,7 +244,7 @@ def cast_coef_to_string(
     return df
 
 
-def unwrap_single_values(func):
+def unwrap_single_values(func) -> pl.DataFrame | Any:
     """Returns the DataFrame unless it is a single value in which case return the value."""
 
     @wraps(func)
@@ -303,23 +302,23 @@ class NamedVariableMapper:
         >>> m = pf.Model()
         >>> m.foo = pf.Variable(pl.DataFrame({"t": range(4)}))
         >>> m.foo.sum()
-        <Expression terms=4 type=linear>
+        <Expression (linear) terms=4>
         foo[0] + foo[1] + foo[2] + foo[3]
     """
 
     CONST_TERM_NAME = "_ONE"
     NAME_COL = "__name"
 
-    def __init__(self, cls: type[ModelElementWithId]) -> None:
+    def __init__(self) -> 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},
+            schema={self._ID_COL: Config.id_dtype, 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},
+                schema={self._ID_COL: Config.id_dtype, self.NAME_COL: pl.String},
             )
         )
 
@@ -375,15 +374,15 @@ def for_solvers(*solvers: str):
     return decorator
 
 
-# TODO: rename and change to return_expr once Set is split away from SupportsMath
-def return_new(func: Callable[..., pl.DataFrame]) -> Callable[..., SupportsMath]:
+# TODO: rename and change to return_expr once Set is split away from BaseOperableBlock
+def return_new(func: Callable[..., pl.DataFrame]) -> Callable[..., BaseOperableBlock]:
     """Decorator that upcasts the returned DataFrame to an Expression.
 
     Requires the first argument (self) to support self._new().
     """
 
     @wraps(func)
-    def wrapper(self: SupportsMath, *args, **kwargs):
+    def wrapper(self: BaseOperableBlock, *args, **kwargs):
         result = func(self, *args, **kwargs)
         return self._new(result, name=f"{self.name}.{func.__name__}(…)")
 

pyoframe/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '1.0.0a0'
-__version_tuple__ = version_tuple = (1, 0, 0, 'a0')
+__version__ = version = '1.1.0'
+__version_tuple__ = version_tuple = (1, 1, 0)
 
 __commit_id__ = commit_id = None