Fix all reportAttributeAccessIssue (#336)

pyproject.toml

@@ -110,7 +110,6 @@ reportUnsupportedDunderAll = "error"
 
 # Error reports to fix in code
 reportAssertTypeFailure = "none" # TODO
-reportAttributeAccessIssue = "none" # TODO
 reportGeneralTypeIssues = "none" # TODO
 
 [tool.mypy]

stubs/matplotlib/_mathtext.pyi

@@ -4,9 +4,8 @@ from sre_parse import State
 from tkinter.tix import HList
 from typing import Literal
 
-from matplotlib.mathtext import MathtextBackend
-
 from .font_manager import FontProperties
+from .mathtext import MathtextBackend
 
 def get_unicode_index(symbol: str, math: bool = True) -> int: ...
 

stubs/matplotlib/axes/_axes.pyi

@@ -9,15 +9,6 @@ from matplotlib.artist import Artist
 from matplotlib.axes._secondary_axes import SecondaryAxis
 from matplotlib.axis import XAxis, YAxis
 from matplotlib.backend_tools import Cursors
-from matplotlib.collections import (
-    BrokenBarHCollection,
-    Collection,
-    EventCollection,
-    LineCollection,
-    PathCollection,
-    PolyCollection,
-    QuadMesh,
-)
 from matplotlib.colors import Colormap, Normalize
 from matplotlib.container import BarContainer, ErrorbarContainer, StemContainer
 from matplotlib.contour import QuadContourSet
@@ -34,6 +25,15 @@ from matplotlib.text import Annotation, Text
 from matplotlib.ticker import Formatter
 from matplotlib.transforms import Bbox, BboxTransformTo, Transform
 
+from ..collections import (
+    BrokenBarHCollection,
+    Collection,
+    EventCollection,
+    LineCollection,
+    PathCollection,
+    PolyCollection,
+    QuadMesh,
+)
 from ._base import _AxesBase
 
 class Axes(_AxesBase):

stubs/matplotlib/backends/_backend_tk.pyi

@@ -1,7 +1,6 @@
 import tkinter as tk
 from typing import Literal, Sequence
 
-from matplotlib import backend_tools
 from matplotlib._api import classproperty
 from matplotlib._typing import *
 from matplotlib.backend_bases import (
@@ -13,6 +12,8 @@ from matplotlib.backend_bases import (
     _Backend,
 )
 
+from .. import backend_tools
+
 backend_version: float = ...
 cursord: dict[backend_tools.Cursors, str] = ...
 
@@ -50,8 +51,8 @@ class FigureCanvasTk(FigureCanvasBase):
 class FigureManagerTk(FigureManagerBase):
     canvas: FigureCanvasBase
     num: int | str
-    toolbar: tk.Toolbar
-    window: tk.Window
+    toolbar: NavigationToolbar2
+    window: tk.Tk
 
     def __init__(self, canvas, num, window) -> None: ...
     @classmethod
@@ -64,7 +65,7 @@ class FigureManagerTk(FigureManagerBase):
     def full_screen_toggle(self) -> None: ...
 
 class NavigationToolbar2Tk(NavigationToolbar2, tk.Frame):
-    window: tk.Window = ...
+    window: tk.Tk = ...
     def __init__(self, canvas: FigureCanvasBase, window=..., *, pack_toolbar: bool = True) -> None: ...
     def pan(self, *args) -> None: ...
     def zoom(self, *args) -> None: ...

stubs/matplotlib/backends/backend_gtk3.pyi

@@ -2,10 +2,10 @@ from typing import Callable, Type
 
 # PyGObject is not easily installable on Windows, let tests pass as-is
 from gi.repository import Gtk  # pyright: ignore[reportMissingImports]
-from matplotlib import backend_tools
 from matplotlib._api import classproperty
 from matplotlib.backend_bases import FigureCanvasBase, ToolContainerBase
 
+from .. import backend_tools
 from ._backend_gtk import TimerGTK as TimerGTK3, _BackendGTK, _FigureManagerGTK, _NavigationToolbar2GTK
 
 class __getattr__:

stubs/matplotlib/backends/backend_qt.pyi

@@ -1,6 +1,5 @@
 from typing import Any, Type
 
-from matplotlib import backend_tools
 from matplotlib._api import classproperty
 from matplotlib.backend_bases import (
     FigureCanvasBase,
@@ -11,15 +10,15 @@ from matplotlib.backend_bases import (
     ToolContainerBase,
     _Backend,
 )
-from matplotlib.backend_tools import Cursors
 from matplotlib.transforms import Bbox
 
+from .. import backend_tools
 from .qt_compat import QtCore, QtWidgets
 
 backend_version = ...
 SPECIAL_KEYS: dict = ...
 
-cursord: dict[Cursors, Any] = ...
+cursord: dict[backend_tools.Cursors, Any] = ...
 
 class __getattr__:
     qApp = ...
@@ -36,7 +35,7 @@ class FigureCanvasQT(QtWidgets.QWidget, FigureCanvasBase):
 
     def __init__(self, figure=...) -> None: ...
     def showEvent(self, event) -> None: ...
-    def set_cursor(self, cursor: Cursors) -> None: ...
+    def set_cursor(self, cursor: backend_tools.Cursors) -> None: ...
     def enterEvent(self, event) -> None: ...
     def leaveEvent(self, event) -> None: ...
     def mouseEventCoords(self, pos) -> tuple[float, float]: ...

stubs/matplotlib/backends/qt_compat.pyi

@@ -1,5 +1,11 @@
+from typing import Any, TypeAlias
+
 QT_API_PYQT6: str = ...
 QT_API_PYSIDE6: str = ...
 QT_API_PYQT5: str = ...
 QT_API_PYSIDE2: str = ...
 QT_API_ENV: str = ...
+
+__version__: str
+QtCore: TypeAlias = Any
+QtWidgets: Any

stubs/matplotlib/widgets.pyi

@@ -15,7 +15,6 @@ from numpy import float64, ndarray
 from numpy.typing import ArrayLike
 from PIL.Image import Image
 
-from . import _api, _docstring, backend_tools, cbook, colors, ticker, transforms
 from ._typing import Color
 from .artist import Artist
 from .lines import Line2D
@@ -374,9 +373,6 @@ class LassoSelector(_SelectorWidget):
         props: Mapping | None = None,
         button: MouseButton | Sequence[MouseButton] | None = None,
     ): ...
-    @_api.deprecated("3.5", alternative="press")
-    def onpress(self, event): ...
-    def onrelease(self, event): ...
 
 class PolygonSelector(_SelectorWidget):
     def __init__(

stubs/sklearn/_build_utils/pre_build_helpers.pyi

@@ -5,7 +5,5 @@ import sys
 import tempfile
 import textwrap
 
-from setuptools.command.build_ext import customize_compiler as customize_compiler, new_compiler as new_compiler
-
 def compile_test_program(code, extra_preargs: list = [], extra_postargs: list = []): ...
 def basic_check_build(): ...

stubs/sklearn/cross_decomposition/_pls.pyi

@@ -3,7 +3,6 @@ from numbers import Integral as Integral, Real as Real
 from typing import ClassVar, Literal, TypeVar
 
 from numpy import ndarray
-from scipy.linalg import pinv as pinv2, pinv2 as pinv2, svd
 
 from .._typing import ArrayLike, Float, Int, MatrixLike
 from ..base import BaseEstimator, ClassNamePrefixFeaturesOutMixin, MultiOutputMixin, RegressorMixin, TransformerMixin

stubs/sklearn/utils/fixes.pyi

@@ -9,7 +9,10 @@ import sklearn
 import threadpoolctl
 from numpy import percentile as percentile
 from scipy.linalg import eigh as _eigh
-from scipy.optimize.linesearch import line_search_wolfe1 as line_search_wolfe1, line_search_wolfe2 as line_search_wolfe2
+from scipy.optimize._linesearch import (  # explicitly re-exported
+    line_search_wolfe1 as line_search_wolfe1,
+    line_search_wolfe2 as line_search_wolfe2,
+)
 from threadpoolctl import _ThreadpoolLimiter
 
 from ..externals._lobpcg import lobpcg as lobpcg

stubs/sklearn/utils/optimize.pyi

@@ -3,7 +3,6 @@ import warnings
 import numpy as np
 
 from ..exceptions import ConvergenceWarning as ConvergenceWarning
-from .fixes import line_search_wolfe1 as line_search_wolfe1, line_search_wolfe2 as line_search_wolfe2
 
 # This is a modified file from scipy.optimize
 # Original authors: Travis Oliphant, Eric Jones

stubs/sklearn/utils/validation.pyi

@@ -15,7 +15,6 @@ from numpy import ndarray
 from numpy.core.numeric import ComplexWarning as ComplexWarning
 from numpy.random.mtrand import RandomState
 from pandas import DataFrame
-from pandas.api.types import is_sparse as is_sparse
 from scipy.sparse import spmatrix
 from scipy.sparse._coo import coo_matrix
 

stubs/sympy-stubs/__init__.pyi

@@ -122,6 +122,7 @@ from sympy.core import (
     seterr,
     symbols,
     sympify,
+    trailing,
     use,
     var,
     vectorize,
@@ -526,7 +527,6 @@ from sympy.ntheory import (
     sqrt_mod,
     sqrt_mod_iter,
     totient,
-    trailing,
 )
 from sympy.parsing import parse_expr
 from sympy.plotting import plot, plot_backends, plot_implicit, plot_parametric, textplot

stubs/sympy-stubs/core/__init__.pyi

@@ -28,6 +28,7 @@ from sympy.core.function import (
     expand_trig,
     nfloat,
 )
+from sympy.core.intfunc import integer_log, integer_nthroot
 from sympy.core.kind import BooleanKind, NumberKind, UndefinedKind
 from sympy.core.mod import Mod
 from sympy.core.mul import Mul, prod
@@ -53,7 +54,7 @@ from sympy.core.numbers import (
     zoo,
 )
 from sympy.core.parameters import evaluate
-from sympy.core.power import Pow, integer_log, integer_nthroot
+from sympy.core.power import Pow
 from sympy.core.relational import (
     Eq,
     Equality,

stubs/sympy-stubs/core/evalf.pyi

@@ -1,4 +1,5 @@
-from typing import Any, Callable, Dict as tDict, List, Optional, Self, Tuple as tTuple, Type, Union as tUnion, overload
+from typing import Any, Callable, Dict as tDict, List, Optional, Tuple as tTuple, Type, Union as tUnion, overload
+from typing_extensions import Self
 
 from sympy.concrete.products import Product
 from sympy.concrete.summations import Sum

stubs/sympy-stubs/matrices/__init__.pyi

@@ -1,4 +1,4 @@
-from sympy.matrices.common import MatrixKind, NonSquareMatrixError, ShapeError
+from sympy.matrices.common import NonSquareMatrixError, ShapeError
 from sympy.matrices.dense import (
     GramSchmidt,
     MutableDenseMatrix,
@@ -63,7 +63,8 @@ from sympy.matrices.expressions import (
     trace,
 )
 from sympy.matrices.immutable import ImmutableDenseMatrix, ImmutableSparseMatrix
-from sympy.matrices.matrices import DeferredVector, MatrixBase
+from sympy.matrices.kind import MatrixKind
+from sympy.matrices.matrixbase import DeferredVector, MatrixBase
 from sympy.matrices.sparse import MutableSparseMatrix
 from sympy.matrices.sparsetools import banded
 from sympy.matrices.utilities import dotprodsimp

stubs/sympy-stubs/matrices/common.pyi

@@ -0,0 +1,196 @@
+from typing import Any
+
+from sympy.core.logic import FuzzyBool
+
+class _MatrixDeprecatedMeta(type):
+    def __instancecheck__(cls, instance): ...
+
+class MatrixRequired(metaclass=_MatrixDeprecatedMeta):
+    rows: int
+    cols: int
+    def __init_subclass__(cls, **kwargs) -> None: ...
+    def __eq__(self, other): ...
+    def __getitem__(self, key) -> None: ...
+    def __len__(self) -> int: ...
+    @property
+    def shape(self) -> None: ...
+
+class MatrixShaping(MatrixRequired):
+    def col_del(self, col): ...
+    def col_insert(self, pos, other): ...
+    def col_join(self, other): ...
+    def col(self, j): ...
+    def extract(self, rowsList, colsList): ...
+    def get_diag_blocks(self): ...
+    @classmethod
+    def hstack(cls, *args): ...
+    def reshape(self, rows, cols): ...
+    def row_del(self, row): ...
+    def row_insert(self, pos, other): ...
+    def row_join(self, other): ...
+    def diagonal(self, k: int = 0): ...
+    def row(self, i): ...
+    @property
+    def shape(self): ...
+    def todok(self): ...
+    def tolist(self): ...
+    def todod(M): ...
+    def vec(self): ...
+    def vech(self, diagonal: bool = True, check_symmetry: bool = True): ...
+    @classmethod
+    def vstack(cls, *args): ...
+
+class MatrixSpecial(MatrixRequired):
+    @classmethod
+    def diag(
+        kls,
+        *args,
+        strict: bool = False,
+        unpack: bool = True,
+        rows: Any | None = None,
+        cols: Any | None = None,
+        **kwargs,
+    ): ...
+    @classmethod
+    def eye(kls, rows, cols: Any | None = None, **kwargs): ...
+    @classmethod
+    def jordan_block(kls, size: Any | None = None, eigenvalue: Any | None = None, *, band: str = "upper", **kwargs): ...
+    @classmethod
+    def ones(kls, rows, cols: Any | None = None, **kwargs): ...
+    @classmethod
+    def zeros(kls, rows, cols: Any | None = None, **kwargs): ...
+    @classmethod
+    def companion(kls, poly): ...
+    @classmethod
+    def wilkinson(kls, n, **kwargs): ...
+
+class MatrixProperties(MatrixRequired):
+    def atoms(self, *types): ...
+    @property
+    def free_symbols(self): ...
+    def has(self, *patterns): ...
+    def is_anti_symmetric(self, simplify: bool = True): ...
+    def is_diagonal(self): ...
+    @property
+    def is_weakly_diagonally_dominant(self): ...
+    @property
+    def is_strongly_diagonally_dominant(self): ...
+    @property
+    def is_hermitian(self): ...
+    @property
+    def is_Identity(self) -> FuzzyBool: ...
+    @property
+    def is_lower_hessenberg(self): ...
+    @property
+    def is_lower(self): ...
+    @property
+    def is_square(self): ...
+    def is_symbolic(self): ...
+    def is_symmetric(self, simplify: bool = True): ...
+    @property
+    def is_upper_hessenberg(self): ...
+    @property
+    def is_upper(self): ...
+    @property
+    def is_zero_matrix(self): ...
+    def values(self): ...
+
+class MatrixOperations(MatrixRequired):
+    def adjoint(self): ...
+    def applyfunc(self, f): ...
+    def as_real_imag(self, deep: bool = True, **hints): ...
+    def conjugate(self): ...
+    def doit(self, **hints): ...
+    def evalf(
+        self,
+        n: int = 15,
+        subs: Any | None = None,
+        maxn: int = 100,
+        chop: bool = False,
+        strict: bool = False,
+        quad: Any | None = None,
+        verbose: bool = False,
+    ): ...
+    def expand(
+        self,
+        deep: bool = True,
+        modulus: Any | None = None,
+        power_base: bool = True,
+        power_exp: bool = True,
+        mul: bool = True,
+        log: bool = True,
+        multinomial: bool = True,
+        basic: bool = True,
+        **hints,
+    ): ...
+    @property
+    def H(self): ...
+    def permute(self, perm, orientation: str = "rows", direction: str = "forward"): ...
+    def permute_cols(self, swaps, direction: str = "forward"): ...
+    def permute_rows(self, swaps, direction: str = "forward"): ...
+    def refine(self, assumptions: bool = True): ...
+    def replace(self, F, G, map: bool = False, simultaneous: bool = True, exact: Any | None = None): ...
+    def rot90(self, k: int = 1): ...
+    def simplify(self, **kwargs): ...
+    def subs(self, *args, **kwargs): ...
+    def trace(self): ...
+    def transpose(self): ...
+    @property
+    def T(self): ...
+    @property
+    def C(self): ...
+    def n(self, *args, **kwargs): ...
+    def xreplace(self, rule): ...
+    def upper_triangular(self, k: int = 0): ...
+    def lower_triangular(self, k: int = 0): ...
+
+class MatrixArithmetic(MatrixRequired):
+    def __abs__(self): ...
+    def __add__(self, other): ...
+    def __truediv__(self, other): ...
+    def __matmul__(self, other): ...
+    def __mod__(self, other): ...
+    def __mul__(self, other): ...
+    def multiply(self, other, dotprodsimp: Any | None = None): ...
+    def multiply_elementwise(self, other): ...
+    def __neg__(self): ...
+    def __pow__(self, exp): ...
+    def pow(self, exp, method: Any | None = None): ...
+    def __radd__(self, other): ...
+    def __rmatmul__(self, other): ...
+    def __rmul__(self, other): ...
+    def rmultiply(self, other, dotprodsimp: Any | None = None): ...
+    def __rsub__(self, a): ...
+    def __sub__(self, a): ...
+
+class MatrixCommon(MatrixArithmetic, MatrixOperations, MatrixProperties, MatrixSpecial, MatrixShaping): ...
+
+class _MinimalMatrix:
+    is_MatrixLike: bool
+    zero: Any
+    one: Any
+    is_Matrix: bool
+    is_MatrixExpr: bool
+    mat: Any
+    def __init__(self, rows, cols: Any | None = None, mat: Any | None = None, copy: bool = False) -> None: ...
+    def __getitem__(self, key): ...
+    def __eq__(self, other): ...
+    def __len__(self) -> int: ...
+    @property
+    def shape(self): ...
+
+class _CastableMatrix:
+    def as_mutable(self): ...
+    def as_immutable(self): ...
+
+class _MatrixWrapper:
+    is_Matrix: bool
+    is_MatrixLike: bool
+    mat: Any
+    shape: Any
+    def __init__(self, mat, shape) -> None: ...
+    def __getitem__(self, key): ...
+    def __iter__(self): ...
+
+def a2idx(j, n: Any | None = None): ...
+def classof(A, B): ...

stubs/sympy-stubs/matrices/expressions/matexpr.pyi

@@ -7,7 +7,6 @@ from sympy.core.expr import Expr
 from sympy.core.function import UndefinedFunction
 from sympy.core.logic import FuzzyBool
 from sympy.matrices import Matrix
-from sympy.matrices.common import MatrixKind
 from sympy.matrices.expressions.applyfunc import ElementwiseApplyFunction
 from sympy.matrices.expressions.determinant import Determinant
 from sympy.matrices.expressions.inverse import Inverse
@@ -18,6 +17,7 @@ from sympy.matrices.expressions.slice import MatrixSlice
 from sympy.matrices.expressions.special import GenericIdentity, GenericZeroMatrix, Identity
 from sympy.matrices.expressions.transpose import Transpose
 from sympy.matrices.immutable import ImmutableDenseMatrix
+from sympy.matrices.kind import MatrixKind
 from sympy.series.order import Order
 
 class MatrixExpr(Expr):

stubs/sympy-stubs/matrices/kind.pyi

@@ -0,0 +1,7 @@
+from sympy.core.kind import Kind
+
+class MatrixKind(Kind):
+    def __new__(cls, element_kind=...): ...
+
+def num_mat_mul(k1, k2): ...
+def mat_mat_mul(k1, k2): ...

stubs/sympy-stubs/matrices/matrixbase.pyi

@@ -0,0 +1,305 @@
+from _typeshed import Incomplete
+
+from sympy.core.logic import FuzzyBool
+from sympy.core.symbol import Symbol
+from sympy.matrices.kind import MatrixKind
+from sympy.printing.defaults import Printable
+from sympy.utilities.iterables import NotIterable
+
+__doctest_requires__: Incomplete
+
+class MatrixBase(Printable):
+    __array_priority__: int
+    is_Matrix: bool
+    zero: Incomplete
+    one: Incomplete
+    rows: int
+    cols: int
+    def __eq__(self, other): ...
+    def __getitem__(self, key) -> None: ...
+    @property
+    def shape(self): ...
+    def col_del(self, col): ...
+    def col_insert(self, pos, other): ...
+    def col_join(self, other): ...
+    def col(self, j): ...
+    def extract(self, rowsList, colsList): ...
+    def get_diag_blocks(self): ...
+    @classmethod
+    def hstack(cls, *args): ...
+    def reshape(self, rows, cols): ...
+    def row_del(self, row): ...
+    def row_insert(self, pos, other): ...
+    def row_join(self, other): ...
+    def diagonal(self, k: int = 0): ...
+    def row(self, i): ...
+    def todok(self): ...
+    @classmethod
+    def from_dok(cls, rows, cols, dok): ...
+    def tolist(self): ...
+    def todod(M): ...
+    def vec(self): ...
+    def vech(self, diagonal: bool = True, check_symmetry: bool = True): ...
+    @classmethod
+    def vstack(cls, *args): ...
+    @classmethod
+    def diag(
+        kls,
+        *args,
+        strict: bool = False,
+        unpack: bool = True,
+        rows: Incomplete | None = None,
+        cols: Incomplete | None = None,
+        **kwargs,
+    ): ...
+    @classmethod
+    def eye(kls, rows, cols: Incomplete | None = None, **kwargs): ...
+    @classmethod
+    def jordan_block(
+        kls, size: Incomplete | None = None, eigenvalue: Incomplete | None = None, *, band: str = "upper", **kwargs
+    ): ...
+    @classmethod
+    def ones(kls, rows, cols: Incomplete | None = None, **kwargs): ...
+    @classmethod
+    def zeros(kls, rows, cols: Incomplete | None = None, **kwargs): ...
+    @classmethod
+    def companion(kls, poly): ...
+    @classmethod
+    def wilkinson(kls, n, **kwargs): ...
+    def atoms(self, *types): ...
+    @property
+    def free_symbols(self): ...
+    def has(self, *patterns): ...
+    def is_anti_symmetric(self, simplify: bool = True): ...
+    def is_diagonal(self): ...
+    @property
+    def is_weakly_diagonally_dominant(self): ...
+    @property
+    def is_strongly_diagonally_dominant(self): ...
+    @property
+    def is_hermitian(self): ...
+    @property
+    def is_Identity(self) -> FuzzyBool: ...
+    @property
+    def is_lower_hessenberg(self): ...
+    @property
+    def is_lower(self): ...
+    @property
+    def is_square(self): ...
+    def is_symbolic(self): ...
+    def is_symmetric(self, simplify: bool = True): ...
+    @property
+    def is_upper_hessenberg(self): ...
+    @property
+    def is_upper(self): ...
+    @property
+    def is_zero_matrix(self): ...
+    def values(self): ...
+    def iter_values(self): ...
+    def iter_items(self): ...
+    def adjoint(self): ...
+    def applyfunc(self, f): ...
+    def as_real_imag(self, deep: bool = True, **hints): ...
+    def conjugate(self): ...
+    def doit(self, **hints): ...
+    def evalf(
+        self,
+        n: int = 15,
+        subs: Incomplete | None = None,
+        maxn: int = 100,
+        chop: bool = False,
+        strict: bool = False,
+        quad: Incomplete | None = None,
+        verbose: bool = False,
+    ): ...
+    def expand(
+        self,
+        deep: bool = True,
+        modulus: Incomplete | None = None,
+        power_base: bool = True,
+        power_exp: bool = True,
+        mul: bool = True,
+        log: bool = True,
+        multinomial: bool = True,
+        basic: bool = True,
+        **hints,
+    ): ...
+    @property
+    def H(self): ...
+    def permute(self, perm, orientation: str = "rows", direction: str = "forward"): ...
+    def permute_cols(self, swaps, direction: str = "forward"): ...
+    def permute_rows(self, swaps, direction: str = "forward"): ...
+    def refine(self, assumptions: bool = True): ...
+    def replace(self, F, G, map: bool = False, simultaneous: bool = True, exact: Incomplete | None = None): ...
+    def rot90(self, k: int = 1): ...
+    def simplify(self, **kwargs): ...
+    def subs(self, *args, **kwargs): ...
+    def trace(self): ...
+    def transpose(self): ...
+    @property
+    def T(self): ...
+    @property
+    def C(self): ...
+    def n(self, *args, **kwargs): ...
+    def xreplace(self, rule): ...
+    def upper_triangular(self, k: int = 0): ...
+    def lower_triangular(self, k: int = 0): ...
+    def __abs__(self): ...
+    def __add__(self, other): ...
+    def __truediv__(self, other): ...
+    def __matmul__(self, other): ...
+    def __mod__(self, other): ...
+    def __mul__(self, other): ...
+    def multiply(self, other, dotprodsimp: Incomplete | None = None): ...
+    def multiply_elementwise(self, other): ...
+    def __neg__(self): ...
+    def __pow__(self, exp): ...
+    def pow(self, exp, method: Incomplete | None = None): ...
+    def __radd__(self, other): ...
+    def __rmatmul__(self, other): ...
+    def __rmul__(self, other): ...
+    def rmultiply(self, other, dotprodsimp: Incomplete | None = None): ...
+    def __rsub__(self, a): ...
+    def __sub__(self, a): ...
+    def adjugate(self, method: str = "berkowitz"): ...
+    def charpoly(self, x: str = "lambda", simplify=...): ...
+    def cofactor(self, i, j, method: str = "berkowitz"): ...
+    def cofactor_matrix(self, method: str = "berkowitz"): ...
+    def det(self, method: str = "bareiss", iszerofunc: Incomplete | None = None): ...
+    def per(self): ...
+    def minor(self, i, j, method: str = "berkowitz"): ...
+    def minor_submatrix(self, i, j): ...
+    def echelon_form(self, iszerofunc=..., simplify: bool = False, with_pivots: bool = False): ...
+    @property
+    def is_echelon(self): ...
+    def rank(self, iszerofunc=..., simplify: bool = False): ...
+    def rref_rhs(self, rhs): ...
+    def rref(self, iszerofunc=..., simplify: bool = False, pivots: bool = True, normalize_last: bool = True): ...
+    def elementary_col_op(
+        self,
+        op: str = "n->kn",
+        col: Incomplete | None = None,
+        k: Incomplete | None = None,
+        col1: Incomplete | None = None,
+        col2: Incomplete | None = None,
+    ): ...
+    def elementary_row_op(
+        self,
+        op: str = "n->kn",
+        row: Incomplete | None = None,
+        k: Incomplete | None = None,
+        row1: Incomplete | None = None,
+        row2: Incomplete | None = None,
+    ): ...
+    def columnspace(self, simplify: bool = False): ...
+    def nullspace(self, simplify: bool = False, iszerofunc=...): ...
+    def rowspace(self, simplify: bool = False): ...
+    @classmethod
+    def orthogonalize(cls, *vecs, **kwargs): ...
+    def eigenvals(self, error_when_incomplete: bool = True, **flags): ...
+    def eigenvects(self, error_when_incomplete: bool = True, iszerofunc=..., **flags): ...
+    def is_diagonalizable(self, reals_only: bool = False, **kwargs): ...
+    def diagonalize(self, reals_only: bool = False, sort: bool = False, normalize: bool = False): ...
+    def bidiagonalize(self, upper: bool = True): ...
+    def bidiagonal_decomposition(self, upper: bool = True): ...
+    @property
+    def is_positive_definite(self): ...
+    @property
+    def is_positive_semidefinite(self): ...
+    @property
+    def is_negative_definite(self): ...
+    @property
+    def is_negative_semidefinite(self): ...
+    @property
+    def is_indefinite(self): ...
+    def jordan_form(self, calc_transform: bool = True, **kwargs): ...
+    def left_eigenvects(self, **flags): ...
+    def singular_values(self): ...
+    def diff(self, *args, evaluate: bool = True, **kwargs): ...
+    def integrate(self, *args, **kwargs): ...
+    def jacobian(self, X): ...
+    def limit(self, *args): ...
+    def berkowitz_charpoly(self, x=..., simplify=...): ...
+    def berkowitz_det(self): ...
+    def berkowitz_eigenvals(self, **flags): ...
+    def berkowitz_minors(self): ...
+    def berkowitz(self): ...
+    def cofactorMatrix(self, method: str = "berkowitz"): ...
+    def det_bareis(self): ...
+    def det_LU_decomposition(self): ...
+    def jordan_cell(self, eigenval, n): ...
+    def jordan_cells(self, calc_transformation: bool = True): ...
+    def minorEntry(self, i, j, method: str = "berkowitz"): ...
+    def minorMatrix(self, i, j): ...
+    def permuteBkwd(self, perm): ...
+    def permuteFwd(self, perm): ...
+    @property
+    def kind(self) -> MatrixKind: ...
+    def flat(self): ...
+    def __array__(self, dtype=..., copy: Incomplete | None = None): ...
+    def __len__(self) -> int: ...
+    @classmethod
+    def irregular(cls, ntop, *matrices, **kwargs): ...
+    def add(self, b): ...
+    def condition_number(self): ...
+    def copy(self): ...
+    def cross(self, b): ...
+    def hat(self): ...
+    def vee(self): ...
+    @property
+    def D(self): ...
+    def dot(self, b, hermitian: Incomplete | None = None, conjugate_convention: Incomplete | None = None): ...
+    def dual(self): ...
+    def analytic_func(self, f, x): ...
+    def exp(self): ...
+    def log(self, simplify=...): ...
+    def is_nilpotent(self): ...
+    def key2bounds(self, keys): ...
+    def key2ij(self, key): ...
+    def normalized(self, iszerofunc=...): ...
+    def norm(self, ord: Incomplete | None = None): ...
+    def print_nonzero(self, symb: str = "X") -> None: ...
+    def project(self, v): ...
+    def table(
+        self, printer, rowstart: str = "[", rowend: str = "]", rowsep: str = "\n", colsep: str = ", ", align: str = "right"
+    ): ...
+    def rank_decomposition(self, iszerofunc=..., simplify: bool = False): ...
+    def cholesky(self, hermitian: bool = True) -> None: ...
+    def LDLdecomposition(self, hermitian: bool = True) -> None: ...
+    def LUdecomposition(self, iszerofunc=..., simpfunc: Incomplete | None = None, rankcheck: bool = False): ...
+    def LUdecomposition_Simple(self, iszerofunc=..., simpfunc: Incomplete | None = None, rankcheck: bool = False): ...
+    def LUdecompositionFF(self): ...
+    def singular_value_decomposition(self): ...
+    def QRdecomposition(self): ...
+    def upper_hessenberg_decomposition(self): ...
+    def diagonal_solve(self, rhs): ...
+    def lower_triangular_solve(self, rhs) -> None: ...
+    def upper_triangular_solve(self, rhs) -> None: ...
+    def cholesky_solve(self, rhs): ...
+    def LDLsolve(self, rhs): ...
+    def LUsolve(self, rhs, iszerofunc=...): ...
+    def QRsolve(self, b): ...
+    def gauss_jordan_solve(self, B, freevar: bool = False): ...
+    def pinv_solve(self, B, arbitrary_matrix: Incomplete | None = None): ...
+    def cramer_solve(self, rhs, det_method: str = "laplace"): ...
+    def solve(self, rhs, method: str = "GJ"): ...
+    def solve_least_squares(self, rhs, method: str = "CH"): ...
+    def pinv(self, method: str = "RD"): ...
+    def inverse_ADJ(self, iszerofunc=...): ...
+    def inverse_BLOCK(self, iszerofunc=...): ...
+    def inverse_GE(self, iszerofunc=...): ...
+    def inverse_LU(self, iszerofunc=...): ...
+    def inverse_CH(self, iszerofunc=...): ...
+    def inverse_LDL(self, iszerofunc=...): ...
+    def inverse_QR(self, iszerofunc=...): ...
+    def inv(self, method: Incomplete | None = None, iszerofunc=..., try_block_diag: bool = False): ...
+    def connected_components(self): ...
+    def connected_components_decomposition(self): ...
+    def strongly_connected_components(self): ...
+    def strongly_connected_components_decomposition(self, lower: bool = True): ...
+
+def classof(A, B): ...
+def a2idx(j, n: Incomplete | None = None): ...
+
+class DeferredVector(Symbol, NotIterable):
+    def __getitem__(self, i): ...

stubs/sympy-stubs/matrices/repmatrix.pyi

@@ -2,8 +2,8 @@ from typing import Any
 from typing_extensions import Self
 
 from sympy import MatrixBase
-from sympy.matrices.common import MatrixKind
 from sympy.matrices.expressions.matexpr import MatrixElement
+from sympy.matrices.kind import MatrixKind
 from sympy.polys.matrices import DomainMatrix
 
 class RepMatrix(MatrixBase):

stubs/sympy-stubs/ntheory/__init__.pyi

@@ -1,3 +1,4 @@
+from sympy.core import trailing
 from sympy.ntheory.continued_fraction import (
     continued_fraction,
     continued_fraction_convergents,
@@ -20,7 +21,6 @@ from sympy.ntheory.factor_ import (
     is_abundant,
     is_amicable,
     is_deficient,
-    is_mersenne_prime,
     is_perfect,
     mersenne_prime_exponent,
     multiplicity,
@@ -35,7 +35,6 @@ from sympy.ntheory.factor_ import (
     proper_divisors,
     reduced_totient,
     totient,
-    trailing,
 )
 from sympy.ntheory.generate import (
     Sieve,
@@ -53,7 +52,7 @@ from sympy.ntheory.generate import (
 )
 from sympy.ntheory.multinomial import binomial_coefficients, binomial_coefficients_list, multinomial_coefficients
 from sympy.ntheory.partitions_ import npartitions
-from sympy.ntheory.primetest import is_gaussian_prime, isprime
+from sympy.ntheory.primetest import is_gaussian_prime, is_mersenne_prime, isprime
 from sympy.ntheory.qs import qs
 from sympy.ntheory.residue_ntheory import (
     discrete_log,

stubs/sympy-stubs/polys/polyclasses.pyi

@@ -1,5 +1,6 @@
 from types import NotImplementedType
-from typing import Any, Callable, Literal, Never, Self
+from typing import Any, Callable, Literal
+from typing_extensions import Self
 
 from sympy.core.sympify import CantSympify
 from sympy.external.gmpy import GROUND_TYPES

stubs/sympy-stubs/polys/rings.pyi

@@ -1,6 +1,6 @@
 from types import NotImplementedType
-from typing import Any, Iterator, Literal, Self
-from typing_extensions import LiteralString
+from typing import Any, Iterator, Literal
+from typing_extensions import LiteralString, Self
 
 from sympy.core.sympify import CantSympify
 from sympy.polys.compatibility import IPolys

stubs/sympy-stubs/utilities/iterables.pyi

@@ -1,6 +1,7 @@
 from collections import defaultdict
 from itertools import chain, combinations, combinations_with_replacement, permutations, product, product as cartes  # noqa: F401
-from typing import Any, Generator, Iterator, Literal, Never, NoReturn
+from typing import Any, Generator, Iterator, Literal, NoReturn
+from typing_extensions import Never
 
 from sympy import Basic, Symbol
 from sympy.utilities.decorator import deprecated

stubs/vispy/app/application.pyi

@@ -10,7 +10,6 @@ import sys
 
 from .. import config
 from ..util import logger
-from . import backends
 from .base import BaseApplicationBackend as ApplicationBackend  # noqa
 
 class Application(object):

stubs/vispy/visuals/graphs/layouts/circular.pyi

@@ -1,8 +1,6 @@
 import numpy as np
 from numpy.typing import ArrayLike, NDArray
 
-from ..util import _straight_line_vertices, issparse
-
 # -*- coding: utf-8 -*-
 # Copyright (c) Vispy Development Team. All Rights Reserved.
 # Distributed under the (new) BSD License. See LICENSE.txt for more info.

stubs/vispy/visuals/text/_sdf_gpu.pyi

@@ -1,7 +1,7 @@
 import numpy as np
 from numpy.typing import ArrayLike
 
-from ...gloo import FrameBuffer, Program, Texture2D, VertexBuffer, set_state, set_viewport
+from ...gloo import Texture2D
 
 # -*- coding: utf-8 -*-
 

utils/validate_stubs.py

@@ -274,7 +274,6 @@ def compare_args(real: Item, stub: Item, owner: Optional[str] = None):
     if not (isinstance(stub.object_, Callable) and isinstance(real.object_, Callable)):  # type: ignore[arg-type]
         print(f"Can't compare args for non-callables. real: {real.object_}; stub: {stub.object_}")
         return
-
     if owner is None:
         owner = ""
     elif owner and owner[-1] != ".":