Mypy appeasement

Author: jessegrabowski

pytensor/link/numba/dispatch/slinalg.py

@@ -361,16 +361,16 @@ def xlamch_impl(kind: str = "E") -> Callable[[str], float]:
 
     def impl(kind: str = "E") -> float:
         KIND = val_to_int_ptr(ord(kind))
-        return numba_lamch(KIND)
+        return numba_lamch(KIND)  # type: ignore
 
     return impl
 
 
 def _xlange(A: np.ndarray, order: str | None = None) -> float:
     """
-    Placeholder for computing the norm of a matrix; used by linalg.solve. Not used by pytensor to numbify graphs.
+    Placeholder for computing the norm of a matrix; used by linalg.solve. Will never be called in python mode.
     """
-    pass
+    return  # type: ignore
 
 
 @overload(_xlange)
@@ -388,19 +388,20 @@ def xlange_impl(
     numba_lange = _LAPACK().numba_xlange(dtype)
 
     def impl(A: np.ndarray, order: str | None = None):
-        _M, _N = np.int32(A.shape[-2:])
+        _M, _N = np.int32(A.shape[-2:])  # type: ignore
+
         A_copy = _copy_to_fortran_order(A)
 
-        M = val_to_int_ptr(_M)
-        N = val_to_int_ptr(_N)
-        LDA = val_to_int_ptr(_M)
+        M = val_to_int_ptr(_M)  # type: ignore
+        N = val_to_int_ptr(_N)  # type: ignore
+        LDA = val_to_int_ptr(_M)  # type: ignore
 
         NORM = (
             val_to_int_ptr(ord(order))
             if order is not None
             else val_to_int_ptr(ord("1"))
         )
-        WORK = np.empty(_M, dtype=dtype)
+        WORK = np.empty(_M, dtype=dtype)  # type: ignore
 
         result = numba_lange(
             NORM, M, N, A_copy.view(w_type).ctypes, LDA, WORK.view(w_type).ctypes
@@ -416,7 +417,7 @@ def _xgecon(A: np.ndarray, A_norm: float, norm: str) -> tuple[np.ndarray, int]:
     Placeholder for computing the condition number of a matrix; used by linalg.solve. Not used by pytensor to numbify
     graphs.
     """
-    pass
+    return  # type: ignore
 
 
 @overload(_xgecon)
@@ -468,7 +469,7 @@ def _getrf(A, overwrite_a=False) -> tuple[np.ndarray, np.ndarray, int]:
 
     # TODO: Implement an LU_factor Op, then dispatch to this function in numba mode.
     """
-    pass
+    return  # type: ignore
 
 
 @overload(_getrf)
@@ -484,17 +485,17 @@ def getrf_impl(
     def impl(
         A: np.ndarray, overwrite_a: bool = False
     ) -> tuple[np.ndarray, np.ndarray, int]:
-        _M, _N = np.int32(A.shape[-2:])
+        _M, _N = np.int32(A.shape[-2:])  # type: ignore
 
         if not overwrite_a:
             A_copy = _copy_to_fortran_order(A)
         else:
             A_copy = A
 
-        M = val_to_int_ptr(_M)
-        N = val_to_int_ptr(_N)
-        LDA = val_to_int_ptr(_M)
-        IPIV = np.empty(_N, dtype=np.int32)
+        M = val_to_int_ptr(_M)  # type: ignore
+        N = val_to_int_ptr(_N)  # type: ignore
+        LDA = val_to_int_ptr(_M)  # type: ignore
+        IPIV = np.empty(_N, dtype=np.int32)  # type: ignore
         INFO = val_to_int_ptr(0)
 
         numba_getrf(M, N, A_copy.view(w_type).ctypes, LDA, IPIV.ctypes, INFO)
@@ -512,7 +513,7 @@ def _getrs(
 
     # TODO: Implement an LU_solve Op, then dispatch to this function in numba mode.
     """
-    pass
+    return  # type: ignore
 
 
 @overload(_getrs)
@@ -580,8 +581,9 @@ def _solve_gen(
     overwrite_b: bool,
     check_finite: bool,
     transposed: bool,
-) -> np.ndarray:
-    """Thin wrapper around scipy.linalg.solve. Used as an overload target for numba to avoid unexpected side-effects."""
+):
+    """Thin wrapper around scipy.linalg.solve. Used as an overload target for numba to avoid unexpected side-effects
+    for users who import pytensor."""
     return linalg.solve(
         A,
         B,
@@ -646,7 +648,7 @@ def _sysv(
     """
     Placeholder for solving a linear system with a symmetric matrix; used by linalg.solve.
     """
-    pass
+    return  # type: ignore
 
 
 @overload(_sysv)
@@ -665,7 +667,7 @@ def sysv_impl(
     def impl(
         A: np.ndarray, B: np.ndarray, lower: bool, overwrite_a: bool, overwrite_b: bool
     ):
-        _LDA, _N = np.int32(A.shape[-2:])
+        _LDA, _N = np.int32(A.shape[-2:])  # type: ignore
         _solve_check_input_shapes(A, B)
 
         if not overwrite_a:
@@ -685,11 +687,11 @@ def impl(
         NRHS = 1 if B_is_1d else int(B.shape[-1])
 
         UPLO = val_to_int_ptr(ord("L") if lower else ord("U"))
-        N = val_to_int_ptr(_N)
+        N = val_to_int_ptr(_N)  # type: ignore
         NRHS = val_to_int_ptr(NRHS)
-        LDA = val_to_int_ptr(_LDA)
-        IPIV = np.empty(_N, dtype=np.int32)
-        LDB = val_to_int_ptr(_N)
+        LDA = val_to_int_ptr(_LDA)  # type: ignore
+        IPIV = np.empty(_N, dtype=np.int32)  # type: ignore
+        LDB = val_to_int_ptr(_N)  # type: ignore
         WORK = np.empty(1, dtype=dtype)
         LWORK = val_to_int_ptr(-1)
         INFO = val_to_int_ptr(0)
@@ -737,9 +739,10 @@ def impl(
 
 def _sycon(A: np.ndarray, ipiv: np.ndarray, anorm: float) -> tuple[np.ndarray, int]:
     """
-    Placeholder for computing the condition number of a symmetric matrix; used by linalg.solve.
+    Placeholder for computing the condition number of a symmetric matrix; used by linalg.solve. Never called in
+    python mode.
     """
-    pass
+    return  # type: ignore
 
 
 @overload(_sycon)
@@ -791,7 +794,7 @@ def _solve_symmetric(
     overwrite_b: bool,
     check_finite: bool,
     transposed: bool,
-) -> np.ndarray:
+):
     """Thin wrapper around scipy.linalg.solve for symmetric matrices. Used as an overload target for numba to avoid
     unexpected side-effects when users import pytensor."""
     return linalg.solve(
@@ -854,7 +857,7 @@ def _posv(
     """
     Placeholder for solving a linear system with a positive-definite matrix; used by linalg.solve.
     """
-    pass
+    return  # type: ignore
 
 
 @overload(_posv)
@@ -936,7 +939,7 @@ def _pocon(A: np.ndarray, anorm: float) -> tuple[np.ndarray, int]:
     Placeholder for computing the condition number of a cholesky-factorized positive-definite matrix. Used by
     linalg.solve when assume_a = "pos".
     """
-    pass
+    return  # type: ignore
 
 
 @overload(_pocon)
@@ -987,7 +990,7 @@ def _solve_psd(
     overwrite_b: bool,
     check_finite: bool,
     transposed: bool,
-) -> np.ndarray:
+):
     """Thin wrapper around scipy.linalg.solve for positive-definite matrices. Used as an overload target for numba to
     avoid unexpected side-effects when users import pytensor."""
     return linalg.solve(