apply type hint convention for python >= 3.10

Author: FabianHofmann

linopy/common.py

@@ -117,7 +117,7 @@ def get_from_iterable(lst: DimsLike | None, index: int) -> Any | None:
     """
     if lst is None:
         return None
-    if isinstance(lst, (Sequence, Iterable)):
+    if isinstance(lst, Sequence | Iterable):
         lst = list(lst)
     else:
         lst = [lst]
@@ -210,7 +210,7 @@ def numpy_to_dataarray(
         return DataArray(arr.item(), coords=coords, dims=dims, **kwargs)
 
     ndim = max(arr.ndim, 0 if coords is None else len(coords))
-    if isinstance(dims, (Iterable, Sequence)):
+    if isinstance(dims, Iterable | Sequence):
         dims = list(dims)
     elif dims is not None:
         dims = [dims]
@@ -250,11 +250,11 @@ def as_dataarray(
         DataArray:
             The converted DataArray.
     """
-    if isinstance(arr, (pd.Series, pd.DataFrame)):
+    if isinstance(arr, pd.Series | pd.DataFrame):
         arr = pandas_to_dataarray(arr, coords=coords, dims=dims, **kwargs)
     elif isinstance(arr, np.ndarray):
         arr = numpy_to_dataarray(arr, coords=coords, dims=dims, **kwargs)
-    elif isinstance(arr, (np.number, int, float, str, bool, list)):
+    elif isinstance(arr, np.number | int | float | str | bool | list):
         arr = DataArray(arr, coords=coords, dims=dims, **kwargs)
 
     elif not isinstance(arr, DataArray):
@@ -493,7 +493,7 @@ def fill_missing_coords(
 
     """
     ds = ds.copy()
-    if not isinstance(ds, (Dataset, DataArray)):
+    if not isinstance(ds, Dataset | DataArray):
         raise TypeError(f"Expected xarray.DataArray or xarray.Dataset, got {type(ds)}.")
 
     skip_dims = [] if fill_helper_dims else HELPER_DIMS
@@ -807,7 +807,7 @@ def print_coord(coord: dict[str, Any] | Iterable[Any]) -> str:
     # Convert each coordinate component to string
     formatted = []
     for value in values:
-        if isinstance(value, (list, tuple)):
+        if isinstance(value, list | tuple):
             formatted.append(f"({', '.join(str(x) for x in value)})")
         else:
             formatted.append(str(value))
@@ -946,11 +946,9 @@ def is_constant(func: Callable[..., Any]) -> Callable[..., Any]:
     def wrapper(self: Any, arg: Any) -> Any:
         if isinstance(
             arg,
-            (
-                variables.Variable,
-                variables.ScalarVariable,
-                expressions.LinearExpression,
-            ),
+            variables.Variable
+            | variables.ScalarVariable
+            | expressions.LinearExpression,
         ):
             raise TypeError(f"Assigned rhs must be a constant, got {type(arg)}).")
         return func(self, arg)
@@ -1061,7 +1059,7 @@ def align(
     finisher: list[partial[Any] | Callable[[Any], Any]] = []
     das: list[Any] = []
     for obj in objects:
-        if isinstance(obj, (LinearExpression, QuadraticExpression)):
+        if isinstance(obj, LinearExpression | QuadraticExpression):
             finisher.append(partial(obj.__class__, model=obj.model))
             das.append(obj.data)
         elif isinstance(obj, Variable):

linopy/constraints.py

@@ -940,7 +940,7 @@ def get_name_by_label(self, label: int | float) -> str:
         name : str
             Name of the containing constraint.
         """
-        if not isinstance(label, (float, int)) or label < 0:
+        if not isinstance(label, float | int) or label < 0:
             raise ValueError("Label must be a positive number.")
         for name, ds in self.items():
             if label in ds.labels:
@@ -1084,7 +1084,7 @@ def __init__(
         """
         Initialize a anonymous scalar constraint.
         """
-        if not isinstance(rhs, (int, float, np.floating, np.integer)):
+        if not isinstance(rhs, int | float | np.floating | np.integer):
             raise TypeError(f"Assigned rhs must be a constant, got {type(rhs)}).")
         self._lhs = lhs
         self._sign = sign

linopy/matrices.py

@@ -32,7 +32,7 @@ def create_vector(
     """Create a vector of a size equal to the maximum index plus one."""
     if shape is None:
         max_value = indices.max()
-        if not isinstance(max_value, (np.integer, int)):
+        if not isinstance(max_value, np.integer | int):
             raise ValueError("Indices must be integers.")
         shape = max_value + 1
     vector = np.full(shape, fill_value)

linopy/monkey_patch_xarray.py

@@ -29,11 +29,9 @@ def __mul__(
 ) -> DataArray | NotImplementedType:
     if isinstance(
         other,
-        (
-            variables.Variable,
-            expressions.LinearExpression,
-            expressions.QuadraticExpression,
-        ),
+        variables.Variable
+        | expressions.LinearExpression
+        | expressions.QuadraticExpression,
     ):
         return NotImplemented
     return unpatched_method(da, other)

linopy/objective.py

@@ -175,11 +175,11 @@ def expression(
         """
         Sets the expression of the objective.
         """
-        if isinstance(expr, (list, tuple)):
+        if isinstance(expr, list | tuple):
             expr = self.model.linexpr(*expr)
 
         if not isinstance(
-            expr, (expressions.LinearExpression, expressions.QuadraticExpression)
+            expr, expressions.LinearExpression | expressions.QuadraticExpression
         ):
             raise ValueError(
                 f"Invalid type of `expr` ({type(expr)})."
@@ -263,7 +263,7 @@ def __sub__(self, expr: LinearExpression | Objective) -> Objective:
 
     def __mul__(self, expr: ConstantLike) -> Objective:
         # only allow scalar multiplication
-        if not isinstance(expr, (int, float, np.floating, np.integer)):
+        if not isinstance(expr, int | float | np.floating | np.integer):
             raise ValueError("Invalid type for multiplication.")
         return Objective(self.expression * expr, self.model, self.sense)
 
@@ -272,6 +272,6 @@ def __neg__(self) -> Objective:
 
     def __truediv__(self, expr: ConstantLike) -> Objective:
         # only allow scalar division
-        if not isinstance(expr, (int, float, np.floating, np.integer)):
+        if not isinstance(expr, int | float | np.floating | np.integer):
             raise ValueError("Invalid type for division.")
         return Objective(self.expression / expr, self.model, self.sense)

linopy/types.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import sys
 from collections.abc import Hashable, Iterable, Mapping, Sequence
 from pathlib import Path
 from typing import TYPE_CHECKING, Union
@@ -11,12 +10,6 @@
 from xarray import DataArray
 from xarray.core.coordinates import DataArrayCoordinates, DatasetCoordinates
 
-if sys.version_info >= (3, 10):
-    from types import EllipsisType, NotImplementedType
-else:
-    EllipsisType = type(Ellipsis)
-    NotImplementedType = type(NotImplemented)
-
 if TYPE_CHECKING:
     from linopy.constraints import AnonymousScalarConstraint, Constraint
     from linopy.expressions import (
@@ -27,15 +20,15 @@
     from linopy.variables import ScalarVariable, Variable
 
 # Type aliases using Union for Python 3.9 compatibility
-CoordsLike = Union[
+CoordsLike = Union[  # noqa: UP007
     Sequence[Sequence | Index | DataArray],
     Mapping,
     DataArrayCoordinates,
     DatasetCoordinates,
 ]
-DimsLike = Union[str, Iterable[Hashable]]
+DimsLike = Union[str, Iterable[Hashable]]  # noqa: UP007
 
-ConstantLike = Union[
+ConstantLike = Union[  # noqa: UP007
     int,
     float,
     numpy.floating,
@@ -45,14 +38,14 @@
     Series,
     DataFrame,
 ]
-SignLike = Union[str, numpy.ndarray, DataArray, Series, DataFrame]
+SignLike = Union[str, numpy.ndarray, DataArray, Series, DataFrame]  # noqa: UP007
 VariableLike = Union["ScalarVariable", "Variable"]
 ExpressionLike = Union[
     "ScalarLinearExpression",
     "LinearExpression",
     "QuadraticExpression",
 ]
 ConstraintLike = Union["Constraint", "AnonymousScalarConstraint"]
-MaskLike = Union[numpy.ndarray, DataArray, Series, DataFrame]
-SideLike = Union[ConstantLike, VariableLike, ExpressionLike]
-PathLike = Union[str, Path]
+MaskLike = Union[numpy.ndarray, DataArray, Series, DataFrame]  # noqa: UP007
+SideLike = Union[ConstantLike, VariableLike, ExpressionLike]  # noqa: UP007
+PathLike = Union[str, Path]  # noqa: UP007

linopy/variables.py

@@ -400,7 +400,7 @@ def __mul__(self, other: SideLike) -> ExpressionLike:
         Multiply variables with a coefficient, variable, or expression.
         """
         try:
-            if isinstance(other, (Variable, ScalarVariable)):
+            if isinstance(other, Variable | ScalarVariable):
                 return self.to_linexpr() * other
 
             return self.to_linexpr(other)
@@ -449,7 +449,7 @@ def __div__(
         """
         Divide variables with a coefficient.
         """
-        if isinstance(other, (expressions.LinearExpression, Variable)):
+        if isinstance(other, expressions.LinearExpression | Variable):
             raise TypeError(
                 "unsupported operand type(s) for /: "
                 f"{type(self)} and {type(other)}. "
@@ -1028,7 +1028,7 @@ def where(
             _other = other.data
         elif isinstance(other, ScalarVariable):
             _other = {"labels": other.label, "lower": other.lower, "upper": other.upper}
-        elif isinstance(other, (dict, Dataset)):
+        elif isinstance(other, dict | Dataset):
             _other = other
         else:
             raise ValueError(
@@ -1432,7 +1432,7 @@ def get_name_by_label(self, label: int) -> str:
         name : str
             Name of the containing variable.
         """
-        if not isinstance(label, (float, int, np.integer)) or label < 0:
+        if not isinstance(label, float | int | np.integer) or label < 0:
             raise ValueError("Label must be a positive number.")
         for name, labels in self.labels.items():
             if label in labels:
@@ -1564,7 +1564,7 @@ def model(self) -> Model:
         return self._model
 
     def to_scalar_linexpr(self, coeff: int | float = 1) -> ScalarLinearExpression:
-        if not isinstance(coeff, (int, np.integer, float)):
+        if not isinstance(coeff, int | np.integer | float):
             raise TypeError(f"Coefficient must be a numeric value, got {type(coeff)}.")
         return expressions.ScalarLinearExpression((coeff,), (self.label,), self.model)
 
@@ -1588,7 +1588,7 @@ def __mul__(self, coeff: int | float) -> ScalarLinearExpression:
         return self.to_scalar_linexpr(coeff)
 
     def __rmul__(self, coeff: int | float) -> ScalarLinearExpression:
-        if isinstance(coeff, (Variable, ScalarVariable)):
+        if isinstance(coeff, Variable | ScalarVariable):
             return NotImplemented
         return self.to_scalar_linexpr(coeff)