Linting: Tighten Ruff rules

pyhope/__init__.py

@@ -27,23 +27,27 @@
 # Standard libraries
 # ----------------------------------------------------------------------------------------------------------------------------------
 from collections import namedtuple
+from collections.abc import Callable
 from contextlib import contextmanager
 from functools import update_wrapper
 from typing import final
+from typing import ParamSpec, TypeVar
 # ----------------------------------------------------------------------------------------------------------------------------------
 # Third-party libraries
 # ----------------------------------------------------------------------------------------------------------------------------------
 # ----------------------------------------------------------------------------------------------------------------------------------
 # Local imports
 # ----------------------------------------------------------------------------------------------------------------------------------
+P = ParamSpec('P')
+R = TypeVar(  'R')
 # ==================================================================================================================================
 
 
-def _staticwrapper(func):
+def _staticwrapper(func: Callable[P, R]) -> Callable[P, R]:
     """ Custom helper to lift the (annotations, doc, etc.) to the staticmethod
     """
     # Create a wrapper that carries the metadata
-    def wrapper(*args, **kwargs):
+    def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
         return func(*args, **kwargs)
 
     # Lift metadata (annotations, doc, etc.) to the wrapper
@@ -150,34 +154,33 @@ def Mesh(*args: str, stdout: bool = False, stderr: bool = True):
                 raise ValueError(f'Mesh file not a valid HDF5 file: {arg}')
 
         # Suppress output to standard output
-        with ExitStack() as stack:
-            with open(os.devnull, 'w') as null:
-                if not stdout:
-                    stack.enter_context(redirect_stdout(null))
-                if not stderr:
-                    stack.enter_context(redirect_stderr(null))
-
-                # Perform the reduced PyHOPE initialization
-                with DefineConfig() as dc:
-                    config.prms = dc
-                    DefineCommon()
-                    DefineIO()
-                    DefineMesh()
-
-                with ReadConfig(args[0]) as rc:
-                    config.params = rc
-
-                # Read-in required parameters
-                InitCommon()
-                InitIO()
-                InitMesh()
-
-                # Generate the actual mesh
-                GenerateMesh()
-
-                # Build our data structures
-                GenerateSides()
-                ConnectMesh()
+        with ExitStack() as stack, open(os.devnull, 'w') as null:
+            if not stdout:
+                stack.enter_context(redirect_stdout(null))
+            if not stderr:
+                stack.enter_context(redirect_stderr(null))
+
+            # Perform the reduced PyHOPE initialization
+            with DefineConfig() as dc:
+                config.prms = dc
+                DefineCommon()
+                DefineIO()
+                DefineMesh()
+
+            with ReadConfig(args[0]) as rc:
+                config.params = rc
+
+            # Read-in required parameters
+            InitCommon()
+            InitIO()
+            InitMesh()
+
+            # Generate the actual mesh
+            GenerateMesh()
+
+            # Build our data structures
+            GenerateSides()
+            ConnectMesh()
 
         # Export mesh variables
         mesh  = mesh_vars.mesh

pyhope/basis/basis_connect.py

@@ -83,7 +83,7 @@ def check_sides(elem,
         # Sanity check the flip with the other nodes
         elem0  = elems[side[0].elemID]
         elem1  = elems[side[1].elemID]
-        if elem1.type % 100 != 8:
+        if elem1.type % 10 != 8:
             continue
 
         # Map the meshio nodes to the tensor-product nodes
@@ -95,7 +95,7 @@ def check_sides(elem,
         try:
             # Translate to periodic nodes if required
             if side[0].bcid is not None and side[1].bcid is not None and bcs[side[1].bcid].type[0] == 1:
-                nbNodes = np.vectorize(lambda s: mesh_vars.periNodes[(s, bcs[side[1].bcid].name)], otypes=[int])(nbNodes)
+                nbNodes = np.vectorize(lambda s, side=side: mesh_vars.periNodes[(s, bcs[side[1].bcid].name)], otypes=[int])(nbNodes)
             # Check if the node IDs match
             success = np.array_equal(nodes, nbNodes)
         # Fallback to comparison of physical coordinates
@@ -157,8 +157,8 @@ def CheckConnect() -> None:
     elems:     Final[list] = mesh_vars.elems
 
     # Only consider hexahedrons
-    if any(cast(int, e.type) % 100 != 8 for e in elems):
-        elemTypes = list(set([e.type for e in elems if e.type % 100 != 8]))
+    if any(cast(int, e.type) % 10 != 8 for e in elems):
+        elemTypes = list({e.type for e in elems if e.type % 10 != 8})
         print(hopout.warn('Ignored element type: {}'.format(
             [re.sub(r"\d+$", "", mesh_vars.ELEMTYPE.inam[e][0]) for e in elemTypes]
         )))
@@ -192,7 +192,7 @@ def CheckConnect() -> None:
             if side.connection is None or side.sideType < 0:
                 continue
             # Big mortar side is counted once
-            elif side.connection < 0:
+            if side.connection < 0:
                 nconn += 1
             # Internal side: only count the canonical representative and ignore virtual mortar sides
             elif side.connection >= 0:
@@ -220,16 +220,16 @@ def CheckConnect() -> None:
             # Print the information
             strLen  = max(len(str(side.sideID+1)), len(str(nbside.sideID+1)))
             print(hopout.warn(f'> Element {  elem.elemID+1:>{strLen}}, Side {  side.face}, Side {  side.sideID+1:>{strLen}}'))  # noqa: E501
-            print(hopout.warn('- Coordinates  : [' + ' '.join('{:12.3f}'.format(s) for s in points[  nodes[ 0,  0]]) + ']'))    # noqa: E271
-            print(hopout.warn('- Coordinates  : [' + ' '.join('{:12.3f}'.format(s) for s in points[  nodes[ 0, -1]]) + ']'))    # noqa: E271
-            print(hopout.warn('- Coordinates  : [' + ' '.join('{:12.3f}'.format(s) for s in points[  nodes[-1,  0]]) + ']'))    # noqa: E271
-            print(hopout.warn('- Coordinates  : [' + ' '.join('{:12.3f}'.format(s) for s in points[  nodes[-1, -1]]) + ']'))    # noqa: E271
+            print(hopout.warn('- Coordinates  : [' + ' '.join(f'{s:12.3f}' for s in points[  nodes[ 0,  0]]) + ']'))    # noqa: E271
+            print(hopout.warn('- Coordinates  : [' + ' '.join(f'{s:12.3f}' for s in points[  nodes[ 0, -1]]) + ']'))    # noqa: E271
+            print(hopout.warn('- Coordinates  : [' + ' '.join(f'{s:12.3f}' for s in points[  nodes[-1,  0]]) + ']'))    # noqa: E271
+            print(hopout.warn('- Coordinates  : [' + ' '.join(f'{s:12.3f}' for s in points[  nodes[-1, -1]]) + ']'))    # noqa: E271
             # print()
             print(hopout.warn(f'> Element {nbelem.elemID+1:>{strLen}}, Side {nbside.face}, Side {nbside.sideID+1:>{strLen}}'))  # noqa: E501
-            print(hopout.warn('- Coordinates  : [' + ' '.join('{:12.3f}'.format(s) for s in points[nbnodes[ 0,  0]]) + ']'))    # noqa: E271
-            print(hopout.warn('- Coordinates  : [' + ' '.join('{:12.3f}'.format(s) for s in points[nbnodes[ 0, -1]]) + ']'))    # noqa: E271
-            print(hopout.warn('- Coordinates  : [' + ' '.join('{:12.3f}'.format(s) for s in points[nbnodes[-1,  0]]) + ']'))    # noqa: E271
-            print(hopout.warn('- Coordinates  : [' + ' '.join('{:12.3f}'.format(s) for s in points[nbnodes[-1, -1]]) + ']'))    # noqa: E271
+            print(hopout.warn('- Coordinates  : [' + ' '.join(f'{s:12.3f}' for s in points[nbnodes[ 0,  0]]) + ']'))    # noqa: E271
+            print(hopout.warn('- Coordinates  : [' + ' '.join(f'{s:12.3f}' for s in points[nbnodes[ 0, -1]]) + ']'))    # noqa: E271
+            print(hopout.warn('- Coordinates  : [' + ' '.join(f'{s:12.3f}' for s in points[nbnodes[-1,  0]]) + ']'))    # noqa: E271
+            print(hopout.warn('- Coordinates  : [' + ' '.join(f'{s:12.3f}' for s in points[nbnodes[-1, -1]]) + ']'))    # noqa: E271
 
         hopout.warning(f'Connectivity check failed for {len(results)} / {nconn} connections!')
         sys.exit(1)

pyhope/basis/basis_jacobian.py

@@ -52,10 +52,9 @@
 def evaluate_jacobian_dispatch(nodeCoords, VdmGLtoAP, D_EqToGL, elem_type):
     if elem_type in SIMPLEX_TYPES:
         return evaluate_jacobian_simplex(nodeCoords, VdmGLtoAP, D_EqToGL)
-    elif elem_type == HEX_TYPE:
+    if elem_type == HEX_TYPE:
         return evaluate_jacobian(        nodeCoords, VdmGLtoAP, D_EqToGL)
-    else:
-        raise ValueError(f"Unsupported element type {elem_type}")
+    raise ValueError(f"Unsupported element type {elem_type}")
 
 
 def plot_histogram(data: npt.NDArray[np.float64]) -> None:
@@ -155,7 +154,7 @@ def CheckJacobians() -> None:
     nGeo:      Final[int]  = mesh_vars.nGeo + 1
     elems:     Final[list] = mesh_vars.elems
     nodes:     Final[npt.NDArray[np.float64]] = mesh_vars.mesh.points
-    elemBases: Final[set]  = set([e.type % 100 for e in elems])
+    elemBases: Final[set]  = {e.type % 10 for e in elems}
 
     # Compute the equidistant point set used by meshIO
     xEq_fn      = {4: lambda: equi_nodes_tetra(nGeo),                                          # Tetrahedron
@@ -201,7 +200,7 @@ def CheckJacobians() -> None:
     # Pre-compute LINTEN mappings for all element types
     linCache  = {}
     elemOrder = 100 if mesh_vars.nGeo == 1 else 200
-    elemTypes = tuple([s + elemOrder for s in elemBases])
+    elemTypes = tuple(s + elemOrder for s in elemBases)
     for elemType in elemTypes:
         try:
             _, mapLin = LINTEN(elemType, order=mesh_vars.nGeo)
@@ -213,7 +212,7 @@ def CheckJacobians() -> None:
 
     for elem in elems:
         elemType = elem.type
-        elemBase = int(elemType) % 100
+        elemBase = int(elemType) % 10
 
         # Get the mapping
         mapLin = linCache[elemType]

pyhope/basis/basis_watertight.py

@@ -151,7 +151,7 @@ def check_sides(elem,
             continue
 
         # Big mortar side
-        elif side.connection < 0:
+        if side.connection < 0:
             mortarType = abs(side.connection)
             # INFO: This should be faster but I could not confirm the speedup in practice
             # nSurf   = eval_nsurf(np.moveaxis( points[  nodes], 2, 0), VdmEqToGP, DGP, weights)
@@ -288,8 +288,8 @@ def CheckWatertight() -> None:
     # checked   = np.zeros((len(sides)), dtype=bool)
 
     # Only consider hexahedrons
-    if any(e.type % 100 != 8 for e in elems):
-        elemTypes = list(set([e.type for e in elems if e.type % 100 != 8]))
+    if any(e.type % 10 != 8 for e in elems):
+        elemTypes = list({e.type for e in elems if e.type % 10 != 8})
         print(hopout.warn('Ignored element type: {}'.format(
             [re.sub(r"\d+$", "", mesh_vars.ELEMTYPE.inam[e][0]) for e in elemTypes]
         )))
@@ -323,7 +323,7 @@ def CheckWatertight() -> None:
             if side.connection is None or side.sideType < 0:
                 continue
             # Big mortar side is counted once
-            elif side.connection < 0:
+            if side.connection < 0:
                 nconn += 1
             # Internal side: only count the canonical representative and ignore virtual mortar sides
             elif side.connection >= 0:
@@ -348,24 +348,24 @@ def CheckWatertight() -> None:
             print()
             # Check if side is oriented inwards
             errStr  =      'Side is oriented inwards!' if nSurfErr < 0 \
-                  else 'Surface normals are not within tolerance {:9.6e} > {:9.6e}'.format(nSurfErr, tol)
+                  else f'Surface normals are not within tolerance {nSurfErr:9.6e} > {tol:9.6e}'
             print(hopout.warn(errStr, length=len(errStr)+16))
 
             # Print the information
             strLen  = max(len(str(side.sideID+1)), len(str(nbside.sideID+1)))
             print(hopout.warn(f'> Element {  elem.elemID+1:>{strLen}}, Side {  side.face}, Side {  side.sideID+1:>{strLen}}'))  # noqa: E501
-            print(hopout.warn('> Normal vector: [' + ' '.join('{:12.3f}'.format(s) for s in   nSurf) + ']'))                    # noqa: E271
-            print(hopout.warn('- Coordinates  : [' + ' '.join('{:12.3f}'.format(s) for s in points[  nodes[ 0,  0]]) + ']'))    # noqa: E271
-            print(hopout.warn('- Coordinates  : [' + ' '.join('{:12.3f}'.format(s) for s in points[  nodes[ 0, -1]]) + ']'))    # noqa: E271
-            print(hopout.warn('- Coordinates  : [' + ' '.join('{:12.3f}'.format(s) for s in points[  nodes[-1,  0]]) + ']'))    # noqa: E271
-            print(hopout.warn('- Coordinates  : [' + ' '.join('{:12.3f}'.format(s) for s in points[  nodes[-1, -1]]) + ']'))    # noqa: E271
+            print(hopout.warn('> Normal vector: [' + ' '.join(f'{s:12.3f}' for s in   nSurf) + ']'))                    # noqa: E271
+            print(hopout.warn('- Coordinates  : [' + ' '.join(f'{s:12.3f}' for s in points[  nodes[ 0,  0]]) + ']'))    # noqa: E271
+            print(hopout.warn('- Coordinates  : [' + ' '.join(f'{s:12.3f}' for s in points[  nodes[ 0, -1]]) + ']'))    # noqa: E271
+            print(hopout.warn('- Coordinates  : [' + ' '.join(f'{s:12.3f}' for s in points[  nodes[-1,  0]]) + ']'))    # noqa: E271
+            print(hopout.warn('- Coordinates  : [' + ' '.join(f'{s:12.3f}' for s in points[  nodes[-1, -1]]) + ']'))    # noqa: E271
             # print()
             print(hopout.warn(f'> Element {nbelem.elemID+1:>{strLen}}, Side {nbside.face}, Side {nbside.sideID+1:>{strLen}}'))  # noqa: E501
-            print(hopout.warn('> Normal vector: [' + ' '.join('{:12.3f}'.format(s) for s in nbnSurf) + ']'))                    # noqa: E271
-            print(hopout.warn('- Coordinates  : [' + ' '.join('{:12.3f}'.format(s) for s in points[nbnodes[ 0,  0]]) + ']'))    # noqa: E271
-            print(hopout.warn('- Coordinates  : [' + ' '.join('{:12.3f}'.format(s) for s in points[nbnodes[ 0, -1]]) + ']'))    # noqa: E271
-            print(hopout.warn('- Coordinates  : [' + ' '.join('{:12.3f}'.format(s) for s in points[nbnodes[-1,  0]]) + ']'))    # noqa: E271
-            print(hopout.warn('- Coordinates  : [' + ' '.join('{:12.3f}'.format(s) for s in points[nbnodes[-1, -1]]) + ']'))    # noqa: E271
+            print(hopout.warn('> Normal vector: [' + ' '.join(f'{s:12.3f}' for s in nbnSurf) + ']'))                    # noqa: E271
+            print(hopout.warn('- Coordinates  : [' + ' '.join(f'{s:12.3f}' for s in points[nbnodes[ 0,  0]]) + ']'))    # noqa: E271
+            print(hopout.warn('- Coordinates  : [' + ' '.join(f'{s:12.3f}' for s in points[nbnodes[ 0, -1]]) + ']'))    # noqa: E271
+            print(hopout.warn('- Coordinates  : [' + ' '.join(f'{s:12.3f}' for s in points[nbnodes[-1,  0]]) + ']'))    # noqa: E271
+            print(hopout.warn('- Coordinates  : [' + ' '.join(f'{s:12.3f}' for s in points[nbnodes[-1, -1]]) + ']'))    # noqa: E271
 
         hopout.error(f'Watertightness check failed for {len(results)} / {nconn} connections!')
 

pyhope/check/check_health.py

@@ -111,7 +111,7 @@ def GmshVersion() -> tuple[Union[Version, bool, None], Union[str, None]]:
 
     if path:
         try:
-            p   = subprocess.run([path, '--info'], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, timeout=5)
+            p   = subprocess.run([path, '--info'], capture_output=True, text=True, timeout=5, check=True)
             raw = (p.stdout or '') + "\n" + (p.stderr or '')
             # Parse version from the Version line if present
             v   = _ParseVersion(raw)
@@ -172,7 +172,7 @@ def DependencyVersion(program: str) -> Optional[Version | bool]:
     if path:
         for flag in ('--version', '-V', 'version', '-v'):
             try:
-                p = subprocess.run([path, flag], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, timeout=5)
+                p = subprocess.run([path, flag], capture_output=True, text=True, timeout=5, check=True)
             except Exception:
                 continue
 
@@ -339,7 +339,7 @@ def CheckHealth() -> None:
     # For optional dependencies, split the first part
     opts = [p.split(';')[0] for p in pkgs if len(p.split(';')) >  1]  # noqa: E272
 
-    all_pkg_names = sorted(list(set([program] + [_PackageExtractName(p) for p in deps + opts])))
+    all_pkg_names = sorted(set([program] + [_PackageExtractName(p) for p in deps + opts]))
 
     # Fetch all versions in parallel
     with ThreadPoolExecutor(max_workers=10) as executor:
@@ -349,7 +349,7 @@ def CheckHealth() -> None:
 
         # Query PyPI for all packages
         pypi_results = list(executor.map(PyPIVersion, all_pkg_names))
-        pypi_map     = dict(zip(all_pkg_names, pypi_results))
+        pypi_map     = dict(zip(all_pkg_names, pypi_results, strict=True))
 
         # Display system and packages sections
         hopout.small_banner('System')

pyhope/check/check_install.py

@@ -37,6 +37,7 @@
 # ----------------------------------------------------------------------------------------------------------------------------------
 import h5py
 import numpy as np
+import pathlib
 # ----------------------------------------------------------------------------------------------------------------------------------
 # Local imports
 # ----------------------------------------------------------------------------------------------------------------------------------
@@ -102,9 +103,8 @@ def _make_request(url : str,
                         bar.title( '│               Downloading tests')
                     # Retry the request
                     continue
-                else:
-                    # Re-raise other HTTP errors
-                    raise
+                # Re-raise other HTTP errors
+                raise
 
     apiURL = f'https://api.github.com/repos/{user}/{repo}/contents/{path}?ref={branch}'
 
@@ -145,8 +145,7 @@ def _make_request(url : str,
                         content = lfs_u.read()
 
                 # Write the final content (either regular file or LFS file) to disk
-                with open(subPath, 'wb') as f:
-                    f.write(content)
+                pathlib.Path(subPath).write_bytes(content)
 
             case 'dir':
                 # Recursively call the function for subdirectories
@@ -275,10 +274,9 @@ def CheckInstall(path: Optional[str] = None) -> None:
 
             # Suppress output to standard output
             try:
-                with open(os.devnull, 'w') as null, redirect_stdout(null):
-                    # All code that should have silent stdout here
-                    with ReadConfig(parameter) as rc:
-                        params = rc
+                # All code that should have silent stdout here
+                with open(os.devnull, 'w') as null, redirect_stdout(null), ReadConfig(parameter) as rc:
+                    params = rc
             except Exception:
                 # Config read failed
                 bar.step()
@@ -374,7 +372,7 @@ def CheckInstall(path: Optional[str] = None) -> None:
                     # Load the stats from the TOML file
                     if  h5stats  is not None \
                     and tomlData is not None \
-                    and key in tomlData.keys():  # noqa: E271, E272
+                    and key in tomlData:  # noqa: E271, E272
                         # Fallback tolerances:
                         if 'GlobalNodeIDs' in key:
                             # GlobalNodeIDs are susceptible to rounding issues

pyhope/common/common_parallel.py

@@ -27,8 +27,9 @@
 # ----------------------------------------------------------------------------------------------------------------------------------
 import sys
 import traceback
+from collections.abc import Callable
 from multiprocessing import Pool, Queue, Process
-from typing import Callable, Union
+from typing import Union
 # ----------------------------------------------------------------------------------------------------------------------------------
 # Third-party libraries
 # ----------------------------------------------------------------------------------------------------------------------------------