feat: add stricter ruff rules

Author: mrava87

docs/source/conf.py

@@ -1,11 +1,9 @@
-# -*- coding: utf-8 -*-
-import sys
-import os
 import datetime
-
-from sphinx_gallery.sorting import ExampleTitleSortKey
+import os
+import sys
 
 from pyproximal import __version__
+from sphinx_gallery.sorting import ExampleTitleSortKey
 
 # Sphinx needs to be able to import the package to use autodoc and
 # get the version number
@@ -93,17 +91,17 @@
 # General information about the project
 year = datetime.date.today().year
 project = "PyProximal"
-copyright = "{}, PyLops Development Team".format(year)
+copyright = f"{year}, PyLops Development Team"
 
 # Version
 version = __version__
 if len(version.split("+")) > 1 or version == "unknown":
     version = "dev"
 
 # These enable substitutions using |variable| in the rst files
-rst_epilog = """
+rst_epilog = f"""
 .. |year| replace:: {year}
-""".format(year=year)
+"""
 
 html_static_path = ["_static"]
 html_last_updated_fmt = "%b %d, %Y"
@@ -146,7 +144,11 @@
     "doc_path": "docs/source",
     "galleries": sphinx_gallery_conf["gallery_dirs"],
     "gallery_dir": dict(
-        zip(sphinx_gallery_conf["gallery_dirs"], sphinx_gallery_conf["examples_dirs"])
+        zip(
+            sphinx_gallery_conf["gallery_dirs"],
+            sphinx_gallery_conf["examples_dirs"],
+            strict=False,
+        )
     ),
     "github_project": "PyLops",
     "github_repo": "pyproximal",

examples/plot_concave_penalties.py

@@ -7,7 +7,6 @@
 
 import matplotlib.pyplot as plt
 import numpy as np
-
 import pyproximal
 
 plt.close("all")

examples/plot_dykstra.py

@@ -15,7 +15,6 @@
 from matplotlib.colors import to_rgba
 from matplotlib.patches import Circle, Rectangle
 from pylops import MatrixMult
-
 from pyproximal.projection import BoxProj, EuclideanBallProj, GenericIntersectionProj
 from pyproximal.proximal import L1, L2, Box, EuclideanBall, GenericIntersectionProx, Sum
 

examples/plot_indicators.py

@@ -8,7 +8,6 @@
 
 import matplotlib.pyplot as plt
 import numpy as np
-
 import pyproximal
 
 plt.close("all")

examples/plot_norms.py

@@ -14,7 +14,6 @@
 import matplotlib.pyplot as plt
 import numpy as np
 import pylops
-
 import pyproximal
 
 plt.close("all")

examples/plot_quadratic.py

@@ -15,7 +15,6 @@
 import matplotlib.pyplot as plt
 import numpy as np
 import pylops
-
 import pyproximal
 
 plt.close("all")

pyproject.toml

@@ -82,7 +82,25 @@ python_files = ["pytests/*.py"]
 
 [tool.ruff]
 src = ["pyproximal"]
+exclude = ["pyproximal/version.py", ]
 line-length = 88
+target-version = "py310"
+
+[tool.ruff.lint]
+select = [
+  "E",   # pycodestyle errors
+  "F",   # pyflakes
+  "W",   # pycodestyle warnings
+  "B",   # flake8-bugbear
+  "EM",  # flake8-errmsg
+  "UP",  # pyupgrade
+  "I"    # isort
+]
+ignore = [
+  "E501",  # line too long (handled by formatter like Black)
+  "I001",  # allow usorted imports
+  "UP031", # use of old '%' formatting instead of f-strings
+]
 
 [tool.ruff.lint.per-file-ignores]
 "__init__.py" = [
@@ -102,10 +120,10 @@ mypy_path = "pyproximal"
 strict = true
 enable_error_code = ["ignore-without-code", "redundant-expr", "truthy-bool"]
 disable_error_code = ["untyped-decorator"]
-warn_unreachable = true
 allow_redefinition = true
 disallow_untyped_defs = true
 disallow_incomplete_defs = true
+warn_unreachable = false
 
 [[tool.mypy.overrides]]
 module = ["cupy.*", "numpy.*", "numba.*", "pylops.*", "scipy.*", "scooby.*", "pyproximal.*"]

pyproximal/ProxOperator.py

@@ -1,4 +1,5 @@
-from typing import TYPE_CHECKING, Any, Callable, Optional, Union
+from typing import TYPE_CHECKING, Any, Optional, Union
+from collections.abc import Callable
 
 import numpy as np
 from pylops.utils.typing import NDArray
@@ -19,13 +20,14 @@ def _check_tau(func: Callable[..., NDArray]) -> Callable[..., NDArray]:
 
     def wrapper(*args: Any, **kwargs: Any) -> Any:
         if np.any(args[2] <= 0):
-            raise ValueError("tau must be positive")
+            msg = "tau must be positive"
+            raise ValueError(msg)
         return func(*args, **kwargs)
 
     return wrapper
 
 
-class ProxOperator(object):
+class ProxOperator:
     r"""Common interface for proximal operators of a function.
 
     This class defines the overarching structure of any proximal operator. It
@@ -87,10 +89,11 @@ def __call__(self, x: NDArray) -> bool | float | int:
         Subclasses should implement this. Returns the
         value of the function.
         """
-        raise NotImplementedError(
+        msg = (
             "This ProxOperator's __call__ method "
             "must be implemented by subclasses to return a float."
         )
+        raise NotImplementedError(msg)
 
     @_check_tau
     def _prox_moreau(self, x: NDArray, tau: float, **kwargs: Any) -> NDArray:
@@ -207,7 +210,8 @@ def affine_addition(self, v: NDArray) -> "ProxOperator":
         if isinstance(v, (np.ndarray, cp_dtype)):
             return _SumOperator(self, v)
         else:
-            raise NotImplementedError("v must be a numpy.ndarray or cupy.ndarray")
+            msg = "v must be a numpy.ndarray or cupy.ndarray"
+            raise NotImplementedError(msg)
 
     def postcomposition(self, sigma: float) -> "ProxOperator":
         r"""Postcomposition
@@ -235,7 +239,8 @@ def postcomposition(self, sigma: float) -> "ProxOperator":
         if isinstance(sigma, float):
             return _PostcompositionOperator(self, sigma)
         else:
-            raise NotImplementedError("sigma must be of type float")
+            msg = "sigma must be of type float"
+            raise NotImplementedError(msg)
 
     def precomposition(self, a: float, b: float | NDArray) -> "ProxOperator":
         r"""Precomposition
@@ -264,11 +269,8 @@ def precomposition(self, a: float, b: float | NDArray) -> "ProxOperator":
         if isinstance(a, float) and isinstance(b, (float, np.ndarray, cp_dtype)):  # type: ignore[redundant-expr]
             return _PrecompositionOperator(self, a, b)
         else:
-            raise NotImplementedError(
-                "a must be of type float and b "
-                "must be of type float or "
-                "numpy.ndarray"
-            )
+            msg = "a must be of type float and b must be of type float or numpy.ndarray"
+            raise NotImplementedError(msg)
 
     def chain(self, g: "ProxOperator") -> "ProxOperator":
         r"""Chain
@@ -336,7 +338,8 @@ def __init__(self, f: ProxOperator, v: NDArray) -> None:
         # if not isinstance(f, ProxOperator):
         #    raise ValueError('First input must be a ProxOperator')
         if not isinstance(v, (np.ndarray, cp_dtype)):
-            raise ValueError("Second input must be a numpy.ndarray or cupy.ndarray")
+            msg = "Second input must be a numpy.ndarray or cupy.ndarray"
+            raise ValueError(msg)
         self.f, self.v = f, v
         super().__init__(None, f.hasgrad)
 
@@ -375,7 +378,8 @@ def __init__(self, f: ProxOperator, sigma: float) -> None:
         # if not isinstance(f, ProxOperator):
         #    raise ValueError('First input must be a ProxOperator')
         if not isinstance(sigma, float):
-            raise ValueError("Second input must be a float")
+            msg = "Second input must be a float"
+            raise ValueError(msg)
         self.f, self.sigma = f, sigma
         super().__init__(None, f.hasgrad)
 
@@ -395,11 +399,11 @@ def __init__(self, f: ProxOperator, a: float, b: float | NDArray) -> None:
         # if not isinstance(f, ProxOperator):
         #    raise ValueError('First input must be a ProxOperator')
         if not isinstance(a, float):
-            raise ValueError("Second input must be a float")
+            msg = "Second input must be a float"
+            raise ValueError(msg)
         if not isinstance(b, (float, np.ndarray, cp_dtype)):
-            raise ValueError(
-                "Third input must be a float, numpy.ndarray, or cupy.ndarray"
-            )
+            msg = "Third input must be a float, numpy.ndarray, or cupy.ndarray"
+            raise ValueError(msg)
         self.f, self.a, self.b = f, a, b
         super().__init__(None, f.hasgrad)
 

pyproximal/optimization/bregman.py

@@ -1,6 +1,7 @@
 import time
 from copy import deepcopy
-from typing import TYPE_CHECKING, Any, Callable, Dict, Optional
+from typing import TYPE_CHECKING, Any, Optional
+from collections.abc import Callable
 
 import numpy as np
 from pylops.utils.typing import NDArray
@@ -22,9 +23,9 @@ def Bregman(
     warm: bool = False,
     tolx: float = 1e-10,
     tolf: float = 1e-10,
-    bregcallback: Optional[Callable[[NDArray], None]] = None,
+    bregcallback: Callable[[NDArray], None] | None = None,
     show: bool = False,
-    **kwargs_solver: Dict[str, Any],
+    **kwargs_solver: dict[str, Any],
 ) -> NDArray:
     r"""Bregman iterations with Proximal Solver
 

pyproximal/optimization/palm.py

@@ -1,5 +1,5 @@
 import time
-from typing import Callable, List, Optional, Tuple
+from collections.abc import Callable
 
 import numpy as np
 from pylops.utils.typing import NDArray
@@ -9,14 +9,14 @@
 
 
 def _backtracking(
-    x: List[NDArray],
+    x: list[NDArray],
     tau: float,
     H: BilinearOperator,
-    proxf: Optional[ProxOperator],
+    proxf: ProxOperator | None,
     ix: int,
     beta: float = 0.5,
     niterback: int = 10,
-) -> Tuple[NDArray, float]:
+) -> tuple[NDArray, float]:
     r"""Backtracking
 
     Line-search algorithm for finding step sizes in PALM algorithms when
@@ -27,7 +27,7 @@ def _backtracking(
 
     def ftilde(
         x: NDArray,
-        y: List[NDArray],
+        y: list[NDArray],
         f: BilinearOperator,
         g: NDArray,
         tau: float,
@@ -59,18 +59,18 @@ def ftilde(
 
 def PALM(
     H: BilinearOperator,
-    proxf: Optional[ProxOperator],
-    proxg: Optional[ProxOperator],
+    proxf: ProxOperator | None,
+    proxg: ProxOperator | None,
     x0: NDArray,
     y0: NDArray,
-    gammaf: Optional[float] = 1.0,
-    gammag: Optional[float] = 1.0,
+    gammaf: float | None = 1.0,
+    gammag: float | None = 1.0,
     beta: float = 0.5,
     niter: int = 10,
     niterback: int = 100,
-    callback: Optional[Callable[[NDArray, NDArray], None]] = None,
+    callback: Callable[[NDArray, NDArray], None] | None = None,
     show: bool = False,
-) -> Tuple[NDArray, NDArray]:
+) -> tuple[NDArray, NDArray]:
     r"""Proximal Alternating Linearized Minimization
 
     Solves the following minimization problem using the Proximal Alternating
@@ -220,19 +220,19 @@ def PALM(
 
 def iPALM(
     H: BilinearOperator,
-    proxf: Optional[ProxOperator],
-    proxg: Optional[ProxOperator],
+    proxf: ProxOperator | None,
+    proxg: ProxOperator | None,
     x0: NDArray,
     y0: NDArray,
-    gammaf: Optional[float] = 1.0,
-    gammag: Optional[float] = 1.0,
-    a: List[float] = [1.0, 1.0],
+    gammaf: float | None = 1.0,
+    gammag: float | None = 1.0,
+    a: tuple[float, float] = (1.0, 1.0),
     beta: float = 0.5,
     niter: int = 10,
     niterback: int = 100,
-    callback: Optional[Callable[[NDArray, NDArray], None]] = None,
+    callback: Callable[[NDArray, NDArray], None] | None = None,
     show: bool = False,
-) -> Tuple[NDArray, NDArray]:
+) -> tuple[NDArray, NDArray]:
     r"""Inertial Proximal Alternating Linearized Minimization
 
     Solves the following minimization problem using the Inertial Proximal