Fix mypy type checking issues

- Add type assertion in expressions.py to clarify pandas Series type
- Keep necessary type: ignore[assignment] comments in test files where intentional type mismatches are tested
- Remove Python 3.9 from classifiers in pyproject.toml (was part of staged changes)
- Update model.py and expressions.py to use union types with | operator

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: FabianHofmann

linopy/expressions.py

@@ -129,7 +129,7 @@ def _exprwrap(
 def _expr_unwrap(
     maybe_expr: Any | LinearExpression | QuadraticExpression,
 ) -> Any:
-    if isinstance(maybe_expr, (LinearExpression, QuadraticExpression)):
+    if isinstance(maybe_expr, LinearExpression | QuadraticExpression):
         return maybe_expr.data
 
     return maybe_expr
@@ -249,6 +249,8 @@ def sum(self, use_fallback: bool = False, **kwargs: Any) -> LinearExpression:
                 orig_group = group
                 group = group.apply(tuple, axis=1).map(int_map)
 
+            # At this point, group is always a pandas Series
+            assert isinstance(group, pd.Series)
             group_dim = group.index.name
 
             arrays = [group, group.groupby(group).cumcount()]
@@ -529,13 +531,11 @@ def __div__(self: GenericExpression, other: SideLike) -> GenericExpression:
         try:
             if isinstance(
                 other,
-                (
-                    variables.Variable,
-                    variables.ScalarVariable,
-                    LinearExpression,
-                    ScalarLinearExpression,
-                    QuadraticExpression,
-                ),
+                variables.Variable
+                | variables.ScalarVariable
+                | LinearExpression
+                | ScalarLinearExpression
+                | QuadraticExpression,
             ):
                 raise TypeError(
                     "unsupported operand type(s) for /: "
@@ -930,7 +930,7 @@ def where(
                 _other = FILL_VALUE
             else:
                 _other = None
-        elif isinstance(other, (int, float, DataArray)):
+        elif isinstance(other, int | float | DataArray):
             _other = {**self._fill_value, "const": other}
         else:
             _other = _expr_unwrap(other)
@@ -970,7 +970,7 @@ def fillna(
             A new object with missing values filled with the given value.
         """
         value = _expr_unwrap(value)
-        if isinstance(value, (DataArray, np.floating, np.integer, int, float)):
+        if isinstance(value, DataArray | np.floating | np.integer | int | float):
             value = {"const": value}
         return self.__class__(self.data.fillna(value), self.model)
 
@@ -1362,10 +1362,10 @@ def __mul__(
             return other.__rmul__(self)
 
         try:
-            if isinstance(other, (variables.Variable, variables.ScalarVariable)):
+            if isinstance(other, variables.Variable | variables.ScalarVariable):
                 other = other.to_linexpr()
 
-            if isinstance(other, (LinearExpression, ScalarLinearExpression)):
+            if isinstance(other, LinearExpression | ScalarLinearExpression):
                 return self._multiply_by_linear_expression(other)
             else:
                 return self._multiply_by_constant(other)
@@ -1403,7 +1403,7 @@ def __matmul__(
         """
         Matrix multiplication with other, similar to xarray dot.
         """
-        if not isinstance(other, (LinearExpression, variables.Variable)):
+        if not isinstance(other, LinearExpression | variables.Variable):
             other = as_dataarray(other, coords=self.coords, dims=self.coord_dims)
 
         common_dims = list(set(self.coord_dims).intersection(other.dims))
@@ -1620,7 +1620,7 @@ def process_one(
                 # assume first element is coefficient and second is variable
                 c, v = t
                 if isinstance(v, variables.ScalarVariable):
-                    if not isinstance(c, (int, float)):
+                    if not isinstance(c, int | float):
                         raise TypeError(
                             "Expected int or float as coefficient of scalar variable (first element of tuple)."
                         )
@@ -1703,12 +1703,10 @@ def __mul__(self, other: SideLike) -> QuadraticExpression:
         """
         if isinstance(
             other,
-            (
-                BaseExpression,
-                ScalarLinearExpression,
-                variables.Variable,
-                variables.ScalarVariable,
-            ),
+            BaseExpression
+            | ScalarLinearExpression
+            | variables.Variable
+            | variables.ScalarVariable,
         ):
             raise TypeError(
                 "unsupported operand type(s) for *: "
@@ -1787,12 +1785,10 @@ def __matmul__(
         """
         if isinstance(
             other,
-            (
-                BaseExpression,
-                ScalarLinearExpression,
-                variables.Variable,
-                variables.ScalarVariable,
-            ),
+            BaseExpression
+            | ScalarLinearExpression
+            | variables.Variable
+            | variables.ScalarVariable,
         ):
             raise TypeError(
                 "Higher order non-linear expressions are not yet supported."
@@ -1915,9 +1911,9 @@ def as_expression(
     ValueError
         If object cannot be converted to LinearExpression.
     """
-    if isinstance(obj, (LinearExpression, QuadraticExpression)):
+    if isinstance(obj, LinearExpression | QuadraticExpression):
         return obj
-    elif isinstance(obj, (variables.Variable, variables.ScalarVariable)):
+    elif isinstance(obj, variables.Variable | variables.ScalarVariable):
         return obj.to_linexpr()
     else:
         try:
@@ -2134,7 +2130,7 @@ def __neg__(self) -> ScalarLinearExpression:
         )
 
     def __mul__(self, other: float | int) -> ScalarLinearExpression:
-        if not isinstance(other, (int, float, np.number)):
+        if not isinstance(other, int | float | np.number):
             raise TypeError(
                 f"unsupported operand type(s) for *: {type(self)} and {type(other)}"
             )
@@ -2147,7 +2143,7 @@ def __rmul__(self, other: int) -> ScalarLinearExpression:
         return self.__mul__(other)
 
     def __div__(self, other: float | int) -> ScalarLinearExpression:
-        if not isinstance(other, (int, float, np.number)):
+        if not isinstance(other, int | float | np.number):
             raise TypeError(
                 f"unsupported operand type(s) for /: {type(self)} and {type(other)}"
             )
@@ -2157,23 +2153,23 @@ def __truediv__(self, other: float | int) -> ScalarLinearExpression:
         return self.__div__(other)
 
     def __le__(self, other: int | float) -> AnonymousScalarConstraint:
-        if not isinstance(other, (int, float, np.number)):
+        if not isinstance(other, int | float | np.number):
             raise TypeError(
                 f"unsupported operand type(s) for <=: {type(self)} and {type(other)}"
             )
 
         return constraints.AnonymousScalarConstraint(self, LESS_EQUAL, other)
 
     def __ge__(self, other: int | float) -> AnonymousScalarConstraint:
-        if not isinstance(other, (int, float, np.number)):
+        if not isinstance(other, int | float | np.number):
             raise TypeError(
                 f"unsupported operand type(s) for >=: {type(self)} and {type(other)}"
             )
 
         return constraints.AnonymousScalarConstraint(self, GREATER_EQUAL, other)
 
     def __eq__(self, other: int | float) -> AnonymousScalarConstraint:  # type: ignore
-        if not isinstance(other, (int, float, np.number)):
+        if not isinstance(other, int | float | np.number):
             raise TypeError(
                 f"unsupported operand type(s) for ==: {type(self)} and {type(other)}"
             )

linopy/model.py

@@ -317,7 +317,7 @@ def solver_dir(self) -> Path:
 
     @solver_dir.setter
     def solver_dir(self, value: str | Path) -> None:
-        if not isinstance(value, (str, Path)):
+        if not isinstance(value, str | Path):
             raise TypeError("'solver_dir' must path-like.")
         self._solver_dir = Path(value)
 
@@ -614,7 +614,7 @@ def add_constraints(
             if sign is None or rhs is None:
                 raise ValueError(msg_sign_rhs_not_none)
             data = lhs.to_constraint(sign, rhs).data
-        elif isinstance(lhs, (list, tuple)):
+        elif isinstance(lhs, list | tuple):
             if sign is None or rhs is None:
                 raise ValueError(msg_sign_rhs_none)
             data = self.linexpr(*lhs).to_constraint(sign, rhs).data
@@ -633,7 +633,7 @@ def add_constraints(
             if sign is not None or rhs is not None:
                 raise ValueError(msg_sign_rhs_none)
             data = lhs.data
-        elif isinstance(lhs, (Variable, ScalarVariable, ScalarLinearExpression)):
+        elif isinstance(lhs, Variable | ScalarVariable | ScalarLinearExpression):
             if sign is None or rhs is None:
                 raise ValueError(msg_sign_rhs_not_none)
             data = lhs.to_linexpr().to_constraint(sign, rhs).data

pyproject.toml

@@ -10,7 +10,6 @@ readme = "README.md"
 authors = [{ name = "Fabian Hofmann", email = "fabianmarikhofmann@gmail.com" }]
 license = { file = "LICENSE" }
 classifiers = [
-    "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",

test/test_constraint.py

@@ -310,7 +310,7 @@ def test_constraint_rhs_getter(c: linopy.constraints.Constraint) -> None:
 def test_constraint_vars_setter(
     c: linopy.constraints.Constraint, x: linopy.Variable
 ) -> None:
-    c.vars = x  # type: ignore
+    c.vars = x  # type: ignore[assignment]
     assert_equal(c.vars, x.labels)
 
 
@@ -329,7 +329,7 @@ def test_constraint_vars_setter_invalid(
 
 
 def test_constraint_coeffs_setter(c: linopy.constraints.Constraint) -> None:
-    c.coeffs = 3  # type: ignore
+    c.coeffs = 3  # type: ignore[assignment]
     assert (c.coeffs == 3).all()
 
 
@@ -345,32 +345,32 @@ def test_constraint_lhs_setter(
 def test_constraint_lhs_setter_with_variable(
     c: linopy.constraints.Constraint, x: linopy.Variable
 ) -> None:
-    c.lhs = x  # type: ignore
+    c.lhs = x  # type: ignore[assignment]
     assert c.lhs.nterm == 1
 
 
 def test_constraint_lhs_setter_with_constant(c: linopy.constraints.Constraint) -> None:
     sizes = c.sizes
-    c.lhs = 10  # type: ignore
+    c.lhs = 10  # type: ignore[assignment]
     assert (c.rhs == -10).all()
     assert c.lhs.nterm == 0
     assert c.sizes["first"] == sizes["first"]
 
 
 def test_constraint_sign_setter(c: linopy.constraints.Constraint) -> None:
-    c.sign = EQUAL  # type: ignore
+    c.sign = EQUAL  # type: ignore[assignment]
     assert (c.sign == EQUAL).all()
 
 
 def test_constraint_sign_setter_alternative(c: linopy.constraints.Constraint) -> None:
-    c.sign = long_EQUAL  # type: ignore
+    c.sign = long_EQUAL  # type: ignore[assignment]
     assert (c.sign == EQUAL).all()
 
 
 def test_constraint_sign_setter_invalid(c: linopy.constraints.Constraint) -> None:
     # Test that assigning lhs with other type that LinearExpression raises TypeError
     with pytest.raises(ValueError):
-        c.sign = "asd"  # type: ignore
+        c.sign = "asd"  # type: ignore[assignment]
 
 
 def test_constraint_rhs_setter(c: linopy.constraints.Constraint) -> None:
@@ -392,7 +392,7 @@ def test_constraint_rhs_setter_with_variable(
 def test_constraint_rhs_setter_with_expression(
     c: linopy.constraints.Constraint, x: linopy.Variable, y: linopy.Variable
 ) -> None:
-    c.rhs = x + y  # type: ignore
+    c.rhs = x + y  # type: ignore[assignment]
     assert (c.rhs == 0).all()
     assert (c.coeffs.isel({c.term_dim: -1}) == -1).all()
     assert c.lhs.nterm == 3
@@ -401,7 +401,7 @@ def test_constraint_rhs_setter_with_expression(
 def test_constraint_rhs_setter_with_expression_and_constant(
     c: linopy.constraints.Constraint, x: linopy.Variable
 ) -> None:
-    c.rhs = x + 1  # type: ignore
+    c.rhs = x + 1  # type: ignore[assignment]
     assert (c.rhs == 1).all()
     assert (c.coeffs.sum(c.term_dim) == 0).all()
     assert c.lhs.nterm == 2

test/test_linear_expression.py

@@ -1151,7 +1151,7 @@ def test_merge(x: Variable, y: Variable, z: Variable) -> None:
     assert res.sel(dim_1=0).vars[2].item() == -1
 
     with pytest.warns(DeprecationWarning):
-        merge(expr1, expr2)  # type: ignore
+        merge(expr1, expr2)  # type: ignore[arg-type]
 
 
 def test_linear_expression_outer_sum(x: Variable, y: Variable) -> None:

test/test_optimization.py

@@ -129,7 +129,7 @@ def model_with_inf() -> Model:
     m.add_constraints(x + y, GREATER_EQUAL, 10)
     m.add_constraints(1 * x, "<=", np.inf)
 
-    m.objective = 2 * x + y  # type: ignore
+    m.objective = 2 * x + y  # type: ignore[assignment]
 
     return m
 
@@ -142,7 +142,7 @@ def model_with_duplicated_variables() -> Model:
     x = m.add_variables(coords=[lower.index], name="x")
 
     m.add_constraints(x + x, GREATER_EQUAL, 10)
-    m.objective = 1 * x  # type: ignore
+    m.objective = 1 * x  # type: ignore[assignment]
 
     return m
 
@@ -157,7 +157,7 @@ def model_with_non_aligned_variables() -> Model:
     y = m.add_variables(lower=lower, coords=[lower.index], name="y")
 
     m.add_constraints(x + y, GREATER_EQUAL, 10.5)
-    m.objective = 1 * x + 0.5 * y  # type: ignore
+    m.objective = 1 * x + 0.5 * y  # type: ignore[assignment]
 
     return m
 
@@ -270,9 +270,9 @@ def modified_model() -> Model:
 
     c = m.add_constraints(x + y, GREATER_EQUAL, 10)
 
-    y.lower = 9  # type: ignore
+    y.lower = 9  # type: ignore[assignment]
     c.lhs = 2 * x + y
-    m.objective = 2 * x + y  # type: ignore
+    m.objective = 2 * x + y  # type: ignore[assignment]
 
     return m
 

test/test_quadratic_expression.py

@@ -303,7 +303,7 @@ def test_quadratic_expression_to_matrix(model: Model, x: Variable, y: Variable)
 
 def test_matrices_matrix(model: Model, x: Variable, y: Variable) -> None:
     expr = 10 * x * y
-    model.objective = expr  # type: ignore
+    model.objective = expr  # type: ignore[assignment]
 
     Q = model.matrices.Q
     assert isinstance(Q, csc_matrix)
@@ -314,7 +314,7 @@ def test_matrices_matrix_mixed_linear_and_quadratic(
     model: Model, x: Variable, y: Variable
 ) -> None:
     quad_expr = x * y + x
-    model.objective = quad_expr + x  # type: ignore
+    model.objective = quad_expr + x  # type: ignore[assignment]
 
     Q = model.matrices.Q
     assert isinstance(Q, csc_matrix)

test/test_variable.py

@@ -128,12 +128,12 @@ def test_variable_lower_getter(z: linopy.Variable) -> None:
 
 
 def test_variable_upper_setter(z: linopy.Variable) -> None:
-    z.upper = 20  # type: ignore
+    z.upper = 20  # type: ignore[assignment]
     assert z.upper.item() == 20
 
 
 def test_variable_lower_setter(z: linopy.Variable) -> None:
-    z.lower = 8  # type: ignore
+    z.lower = 8  # type: ignore[assignment]
     assert z.lower == 8