From 8018eb31a821905a6946ccd73ee454cbb8bb9a0c Mon Sep 17 00:00:00 2001 From: Jul Van den Broeck Date: Wed, 9 Jul 2025 15:07:45 +0200 Subject: [PATCH 01/20] :label: `sparse`: overhauled stubs for `diags_array`, `eye_array`, and their matrix equivalents --- .vscode/settings.json | 3 + scipy-stubs/sparse/_construct.pyi | 1828 ++++++++++++++++++++++++++--- tests/sparse/test_construct.pyi | 123 +- 3 files changed, 1773 insertions(+), 181 deletions(-) diff --git a/.vscode/settings.json b/.vscode/settings.json index c558cc65..dd6cb3f6 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -33,6 +33,9 @@ "editor.tabSize": 2, }, "dprint.path": ".venv/bin/dprint", + "code-runner.executorMap": { + "python": "cd \"$workspaceRoot\" && source \".venv/bin/activate\" && uvx basedpyright $fullFileName && python $fullFileName", + }, "mypy-type-checker.path": [ "uv", "run", diff --git a/scipy-stubs/sparse/_construct.pyi b/scipy-stubs/sparse/_construct.pyi index 2cf16e25..4f3ffd57 100644 --- a/scipy-stubs/sparse/_construct.pyi +++ b/scipy-stubs/sparse/_construct.pyi @@ -7,6 +7,10 @@ import numpy.typing as npt import optype.numpy as onp import optype.numpy.compat as npc import optype.typing as opt +from optype.numpy._any_dtype import f_cls +from optype.numpy._dtype import ToDType +from optype.numpy._dtype_attr import f8_code +from optype.numpy._scalar import floating64 from ._base import _spbase, sparray from ._bsr import bsr_array, bsr_matrix @@ -38,15 +42,16 @@ __all__ = [ "vstack", ] +_Numeric: TypeAlias = npc.number | np.bool_ +_AnyFloat64DTypeNotNone: TypeAlias = f_cls | ToDType[floating64] | f8_code + _T = TypeVar("_T") _SCT = TypeVar("_SCT", bound=_Numeric, default=Any) _SCT0 = TypeVar("_SCT0", bound=_Numeric) _ShapeT = TypeVar("_ShapeT", bound=tuple[int, *tuple[int, ...]], default=tuple[Any, ...]) -_Numeric: TypeAlias = npc.number | np.bool_ - -_ToArray1D: TypeAlias = Seq[_SCT] | onp.CanArrayND[_SCT] -_ToArray2D: TypeAlias = Seq[Seq[_SCT | int] | onp.CanArrayND[_SCT]] | onp.CanArrayND[_SCT] +_ToArray1D: TypeAlias = Seq[int | float | complex | _SCT] | onp.CanArrayND[_SCT] +_ToArray2D: TypeAlias = Seq[_ToArray1D[_SCT]] | onp.CanArrayND[_SCT] _ToSpMatrix: TypeAlias = spmatrix[_SCT] | _ToArray2D[_SCT] _ToSparse2D: TypeAlias = _spbase[_SCT, tuple[int, int]] | _ToArray2D[_SCT] @@ -74,7 +79,6 @@ _FmtDIA: TypeAlias = Literal["dia"] _FmtDOK: TypeAlias = Literal["dok"] _FmtLIL: TypeAlias = Literal["lil"] _FmtNonCOO: TypeAlias = Literal["bsr", "csc", "csr", "dia", "dok", "lil"] -_FmtNonDIA: TypeAlias = Literal["bsr", "coo", "csc", "csr", "dok", "lil"] _DataRVS: TypeAlias = Callable[[int], onp.ArrayND[_Numeric]] @@ -91,207 +95,1174 @@ def diags_array( diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], /, *, - offsets: onp.ToInt | onp.ToInt1D = 0, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, shape: _ToShape2D | None = None, format: _FmtDIA | None = None, dtype: None = None, -) -> dia_array[_SCT]: ... -@overload # diagonals: , dtype: None = ..., format: +) -> _DIAArray[_SCT]: ... +@overload # diagonals: , format: {"dia", None} = ..., dtype: bool-like def diags_array( diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], /, *, - offsets: onp.ToInt | onp.ToInt1D = 0, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, shape: _ToShape2D | None = None, - format: _FmtNonDIA, - dtype: None = None, -) -> _SpArray2D[_SCT]: ... -@overload # diagonals: , format: {"dia", None} = ..., dtype: int + format: _FmtDIA | None = None, + dtype: onp.AnyBoolDType, +) -> _DIAArray[np.bool_]: ... +@overload # diagonals: , format: {"dia", None} = ..., dtype: int-like def diags_array( - diagonals: onp.ToFloat1D | onp.ToFloat2D, + diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], /, *, - offsets: onp.ToInt | onp.ToInt1D = 0, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, shape: _ToShape2D | None = None, format: _FmtDIA | None = None, dtype: onp.AnyIntDType, -) -> dia_array[np.int_]: ... -@overload # diagonals: , format: , dtype: int +) -> _DIAArray[np.int_]: ... +@overload # diagonals: , format: {"dia", None} = ..., dtype: float64-like +def diags_array( + diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtDIA | None = None, + dtype: _AnyFloat64DTypeNotNone, +) -> _DIAArray[np.float64]: ... +@overload # diagonals: , format: {"dia", None} = ..., dtype: complex128-like +def diags_array( + diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtDIA | None = None, + dtype: onp.AnyComplex128DType, +) -> _DIAArray[np.complex128]: ... +@overload # diagonals: , format: {"dia", None} = ..., dtype: float64-like def diags_array( diagonals: onp.ToFloat1D | onp.ToFloat2D, /, *, - offsets: onp.ToInt | onp.ToInt1D = 0, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, shape: _ToShape2D | None = None, - format: _FmtNonDIA, - dtype: onp.AnyIntDType, -) -> _SpArray2D[np.int_]: ... -@overload # diagonals: , format: {"dia", None} = ..., dtype: float + format: _FmtDIA | None = None, + dtype: _AnyFloat64DTypeNotNone, +) -> _DIAArray[np.float64]: ... +@overload # diagonals: , format: {"dia", None} = ..., dtype: bool-like def diags_array( diagonals: onp.ToFloat1D | onp.ToFloat2D, /, *, - offsets: onp.ToInt | onp.ToInt1D = 0, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, shape: _ToShape2D | None = None, format: _FmtDIA | None = None, - dtype: onp.AnyFloat64DType, -) -> dia_array[np.float64]: ... -@overload # diagonals: , format: , dtype: float + dtype: onp.AnyBoolDType, +) -> _DIAArray[np.bool_]: ... +@overload # diagonals: , format: {"dia", None} = ..., dtype: int-like def diags_array( diagonals: onp.ToFloat1D | onp.ToFloat2D, /, *, - offsets: onp.ToInt | onp.ToInt1D = 0, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, shape: _ToShape2D | None = None, - format: _FmtNonDIA, - dtype: onp.AnyFloat64DType, -) -> _SpArray2D[np.float64]: ... -@overload # diagonals: , format: {"dia", None} = ..., dtype: complex + format: _FmtDIA | None = None, + dtype: onp.AnyIntDType, +) -> _DIAArray[np.int_]: ... +@overload # diagonals: , format: {"dia", None} = ..., dtype: complex128-like def diags_array( - diagonals: onp.ToComplex1D | onp.ToComplex2D, + diagonals: onp.ToFloat1D | onp.ToFloat2D, /, *, - offsets: onp.ToInt | onp.ToInt1D = 0, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, shape: _ToShape2D | None = None, format: _FmtDIA | None = None, dtype: onp.AnyComplex128DType, -) -> dia_array[np.complex128]: ... -@overload # diagonals: , format: , dtype: complex +) -> _DIAArray[np.complex128]: ... +@overload # diagonals: , format: {"dia", None} = ..., dtype: complex128-like def diags_array( diagonals: onp.ToComplex1D | onp.ToComplex2D, /, *, - offsets: onp.ToInt | onp.ToInt1D = 0, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, shape: _ToShape2D | None = None, - format: _FmtNonDIA, + format: _FmtDIA | None = None, dtype: onp.AnyComplex128DType, -) -> _SpArray2D[np.complex128]: ... +) -> _DIAArray[np.complex128]: ... @overload # diagonals: , format: {"dia", None} = ..., dtype: def diags_array( diagonals: onp.ToComplex1D | onp.ToComplex2D, /, *, - offsets: onp.ToInt | onp.ToInt1D = 0, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtDIA | None = None, + dtype: onp.ToDType[_SCT], +) -> _DIAArray[_SCT]: ... +@overload # diagonals: , format: {"dia", None} = ..., dtype: +def diags_array( + diagonals: onp.ToComplex1D | onp.ToComplex2D, + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, shape: _ToShape2D | None = None, format: _FmtDIA | None = None, + dtype: npt.DTypeLike, +) -> _DIAArray: ... + +# BSR +@overload # diagonals: , format: "bsr", dtype: None +def diags_array( + diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtBSR, + dtype: None = None, +) -> _BSRArray[_SCT]: ... +@overload # diagonals: , format: "bsr", dtype: bool-like +def diags_array( + diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtBSR, + dtype: onp.AnyBoolDType, +) -> _BSRArray[np.bool_]: ... +@overload # diagonals: , format: "bsr", dtype: int-like +def diags_array( + diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtBSR, + dtype: onp.AnyIntDType, +) -> _BSRArray[np.int_]: ... +@overload # diagonals: , format: "bsr", dtype: float64-like +def diags_array( + diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtBSR, + dtype: _AnyFloat64DTypeNotNone, +) -> _BSRArray[np.float64]: ... +@overload # diagonals: , format: "bsr", dtype: complex128-like +def diags_array( + diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtBSR, + dtype: onp.AnyComplex128DType, +) -> _BSRArray[np.complex128]: ... +@overload # diagonals: , format: "bsr", dtype: float64-like +def diags_array( + diagonals: onp.ToFloat1D | onp.ToFloat2D, + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtBSR, + dtype: _AnyFloat64DTypeNotNone, +) -> _BSRArray[np.float64]: ... +@overload # diagonals: , format: "bsr", dtype: bool-like +def diags_array( + diagonals: onp.ToFloat1D | onp.ToFloat2D, + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtBSR, + dtype: onp.AnyBoolDType, +) -> _BSRArray[np.bool_]: ... +@overload # diagonals: , format: "bsr", dtype: int-like +def diags_array( + diagonals: onp.ToFloat1D | onp.ToFloat2D, + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtBSR, + dtype: onp.AnyIntDType, +) -> _BSRArray[np.int_]: ... +@overload # diagonals: , format: "bsr", dtype: complex128-like +def diags_array( + diagonals: onp.ToFloat1D | onp.ToFloat2D, + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtBSR, + dtype: onp.AnyComplex128DType, +) -> _BSRArray[np.complex128]: ... +@overload # diagonals: , format: "bsr", dtype: complex128-like +def diags_array( + diagonals: onp.ToComplex1D | onp.ToComplex2D, + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtBSR, + dtype: onp.AnyComplex128DType, +) -> _BSRArray[np.complex128]: ... +@overload # diagonals: , format: "bsr", dtype: +def diags_array( + diagonals: onp.ToComplex1D | onp.ToComplex2D, + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtBSR, + dtype: onp.ToDType[_SCT], +) -> _BSRArray[_SCT]: ... +@overload # diagonals: , format: "bsr", dtype: +def diags_array( + diagonals: onp.ToComplex1D | onp.ToComplex2D, + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtBSR, + dtype: npt.DTypeLike, +) -> _BSRArray: ... + +# COO +@overload # diagonals: , format: "coo", dtype: None +def diags_array( + diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtCOO, + dtype: None = None, +) -> _COOArray2D[_SCT]: ... +@overload # diagonals: , format: "coo", dtype: bool-like +def diags_array( + diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtCOO, + dtype: onp.AnyBoolDType, +) -> _COOArray2D[np.bool_]: ... +@overload # diagonals: , format: "coo", dtype: int-like +def diags_array( + diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtCOO, + dtype: onp.AnyIntDType, +) -> _COOArray2D[np.int_]: ... +@overload # diagonals: , format: "coo", dtype: float64-like +def diags_array( + diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtCOO, + dtype: _AnyFloat64DTypeNotNone, +) -> _COOArray2D[np.float64]: ... +@overload # diagonals: , format: "coo", dtype: complex128-like +def diags_array( + diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtCOO, + dtype: onp.AnyComplex128DType, +) -> _COOArray2D[np.complex128]: ... +@overload # diagonals: , format: "coo", dtype: float64-like +def diags_array( + diagonals: onp.ToFloat1D | onp.ToFloat2D, + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtCOO, + dtype: _AnyFloat64DTypeNotNone, +) -> _COOArray2D[np.float64]: ... +@overload # diagonals: , format: "coo", dtype: bool-like +def diags_array( + diagonals: onp.ToFloat1D | onp.ToFloat2D, + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtCOO, + dtype: onp.AnyBoolDType, +) -> _COOArray2D[np.bool_]: ... +@overload # diagonals: , format: "coo", dtype: int-like +def diags_array( + diagonals: onp.ToFloat1D | onp.ToFloat2D, + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtCOO, + dtype: onp.AnyIntDType, +) -> _COOArray2D[np.int_]: ... +@overload # diagonals: , format: "coo", dtype: complex128-like +def diags_array( + diagonals: onp.ToFloat1D | onp.ToFloat2D, + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtCOO, + dtype: onp.AnyComplex128DType, +) -> _COOArray2D[np.complex128]: ... +@overload # diagonals: , format: "coo", dtype: complex128-like +def diags_array( + diagonals: onp.ToComplex1D | onp.ToComplex2D, + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtCOO, + dtype: onp.AnyComplex128DType, +) -> _COOArray2D[np.complex128]: ... + +# CSC +@overload # diagonals: , format: "csc", dtype: None +def diags_array( + diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtCSC, + dtype: None = None, +) -> _CSCArray[_SCT]: ... +@overload # diagonals: , format: "csc", dtype: bool-like +def diags_array( + diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtCSC, + dtype: onp.AnyBoolDType, +) -> _CSCArray[np.bool_]: ... +@overload # diagonals: , format: "csc", dtype: int-like +def diags_array( + diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtCSC, + dtype: onp.AnyIntDType, +) -> _CSCArray[np.int_]: ... +@overload # diagonals: , format: "csc", dtype: float64-like +def diags_array( + diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtCSC, + dtype: _AnyFloat64DTypeNotNone, +) -> _CSCArray[np.float64]: ... +@overload # diagonals: , format: "csc", dtype: complex128-like +def diags_array( + diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtCSC, + dtype: onp.AnyComplex128DType, +) -> _CSCArray[np.complex128]: ... +@overload # diagonals: , format: "csc", dtype: float64-like +def diags_array( + diagonals: onp.ToFloat1D | onp.ToFloat2D, + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtCSC, + dtype: _AnyFloat64DTypeNotNone, +) -> _CSCArray[np.float64]: ... +@overload # diagonals: , format: "csc", dtype: bool-like +def diags_array( + diagonals: onp.ToFloat1D | onp.ToFloat2D, + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtCSC, + dtype: onp.AnyBoolDType, +) -> _CSCArray[np.bool_]: ... +@overload # diagonals: , format: "csc", dtype: int-like +def diags_array( + diagonals: onp.ToFloat1D | onp.ToFloat2D, + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtCSC, + dtype: onp.AnyIntDType, +) -> _CSCArray[np.int_]: ... +@overload # diagonals: , format: "csc", dtype: complex128-like +def diags_array( + diagonals: onp.ToFloat1D | onp.ToFloat2D, + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtCSC, + dtype: onp.AnyComplex128DType, +) -> _CSCArray[np.complex128]: ... +@overload # diagonals: , format: "csc", dtype: complex128-like +def diags_array( + diagonals: onp.ToComplex1D | onp.ToComplex2D, + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtCSC, + dtype: onp.AnyComplex128DType, +) -> _CSCArray[np.complex128]: ... +@overload # diagonals: , format: "csc", dtype: +def diags_array( + diagonals: onp.ToComplex1D | onp.ToComplex2D, + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtCSC, dtype: onp.ToDType[_SCT], -) -> dia_array[_SCT]: ... -@overload # diagonals: , format: , dtype: +) -> _CSCArray[_SCT]: ... +@overload # diagonals: , format: "csc", dtype: def diags_array( diagonals: onp.ToComplex1D | onp.ToComplex2D, /, *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtCSC, + dtype: npt.DTypeLike, +) -> _CSCArray: ... + +# CSR +@overload # diagonals: , format: "csr", dtype: None +def diags_array( + diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtCSR, + dtype: None = None, +) -> _CSRArray2D[_SCT]: ... +@overload # diagonals: , format: "csr", dtype: bool-like +def diags_array( + diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtCSR, + dtype: onp.AnyBoolDType, +) -> _CSRArray2D[np.bool_]: ... +@overload # diagonals: , format: "csr", dtype: int-like +def diags_array( + diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtCSR, + dtype: onp.AnyIntDType, +) -> _CSRArray2D[np.int_]: ... +@overload # diagonals: , format: "csr", dtype: float64-like +def diags_array( + diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtCSR, + dtype: _AnyFloat64DTypeNotNone, +) -> _CSRArray2D[np.float64]: ... +@overload # diagonals: , format: "csr", dtype: complex128-like +def diags_array( + diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtCSR, + dtype: onp.AnyComplex128DType, +) -> _CSRArray2D[np.complex128]: ... +@overload # diagonals: , format: "csr", dtype: float64-like +def diags_array( + diagonals: onp.ToFloat1D | onp.ToFloat2D, + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtCSR, + dtype: _AnyFloat64DTypeNotNone, +) -> _CSRArray2D[np.float64]: ... +@overload # diagonals: , format: "csr", dtype: bool-like +def diags_array( + diagonals: onp.ToFloat1D | onp.ToFloat2D, + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtCSR, + dtype: onp.AnyBoolDType, +) -> _CSRArray2D[np.bool_]: ... +@overload # diagonals: , format: "csr", dtype: int-like +def diags_array( + diagonals: onp.ToFloat1D | onp.ToFloat2D, + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtCSR, + dtype: onp.AnyIntDType, +) -> _CSRArray2D[np.int_]: ... +@overload # diagonals: , format: "csr", dtype: complex128-like +def diags_array( + diagonals: onp.ToFloat1D | onp.ToFloat2D, + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtCSR, + dtype: onp.AnyComplex128DType, +) -> _CSRArray2D[np.complex128]: ... +@overload # diagonals: , format: "csr", dtype: complex128-like +def diags_array( + diagonals: onp.ToComplex1D | onp.ToComplex2D, + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtCSR, + dtype: onp.AnyComplex128DType, +) -> _CSRArray2D[np.complex128]: ... +@overload # diagonals: , format: "csr", dtype: +def diags_array( + diagonals: onp.ToComplex1D | onp.ToComplex2D, + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtCSR, + dtype: onp.ToDType[_SCT], +) -> _CSRArray2D[_SCT]: ... +@overload # diagonals: , format: "csr", dtype: +def diags_array( + diagonals: onp.ToComplex1D | onp.ToComplex2D, + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtCSR, + dtype: npt.DTypeLike, +) -> _CSRArray2D: ... + +# DOK +@overload # diagonals: , format: "dok", dtype: None +def diags_array( + diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtDOK, + dtype: None = None, +) -> _DOKArray2D[_SCT]: ... +@overload # diagonals: , format: "dok", dtype: bool-like +def diags_array( + diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtDOK, + dtype: onp.AnyBoolDType, +) -> _DOKArray2D[np.bool_]: ... +@overload # diagonals: , format: "dok", dtype: int-like +def diags_array( + diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtDOK, + dtype: onp.AnyIntDType, +) -> _DOKArray2D[np.int_]: ... +@overload # diagonals: , format: "dok", dtype: float64-like +def diags_array( + diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtDOK, + dtype: _AnyFloat64DTypeNotNone, +) -> _DOKArray2D[np.float64]: ... +@overload # diagonals: , format: "dok", dtype: complex128-like +def diags_array( + diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtDOK, + dtype: onp.AnyComplex128DType, +) -> _DOKArray2D[np.complex128]: ... +@overload # diagonals: , format: "dok", dtype: float64-like +def diags_array( + diagonals: onp.ToFloat1D | onp.ToFloat2D, + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtDOK, + dtype: _AnyFloat64DTypeNotNone, +) -> _DOKArray2D[np.float64]: ... +@overload # diagonals: , format: "dok", dtype: bool-like +def diags_array( + diagonals: onp.ToFloat1D | onp.ToFloat2D, + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtDOK, + dtype: onp.AnyBoolDType, +) -> _DOKArray2D[np.bool_]: ... +@overload # diagonals: , format: "dok", dtype: int-like +def diags_array( + diagonals: onp.ToFloat1D | onp.ToFloat2D, + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtDOK, + dtype: onp.AnyIntDType, +) -> _DOKArray2D[np.int_]: ... +@overload # diagonals: , format: "dok", dtype: complex128-like +def diags_array( + diagonals: onp.ToFloat1D | onp.ToFloat2D, + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtDOK, + dtype: onp.AnyComplex128DType, +) -> _DOKArray2D[np.complex128]: ... +@overload # diagonals: , format: "dok", dtype: complex128-like +def diags_array( + diagonals: onp.ToComplex1D | onp.ToComplex2D, + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtDOK, + dtype: onp.AnyComplex128DType, +) -> _DOKArray2D[np.complex128]: ... +@overload # diagonals: , format: "dok", dtype: +def diags_array( + diagonals: onp.ToComplex1D | onp.ToComplex2D, + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtDOK, + dtype: onp.ToDType[_SCT], +) -> _DOKArray2D[_SCT]: ... +@overload # diagonals: , format: "dok", dtype: +def diags_array( + diagonals: onp.ToComplex1D | onp.ToComplex2D, + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtDOK, + dtype: npt.DTypeLike, +) -> _DOKArray2D: ... + +# LIL +@overload # diagonals: , format: "lil", dtype: None +def diags_array( + diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtLIL, + dtype: None = None, +) -> _LILArray[_SCT]: ... +@overload # diagonals: , format: "lil", dtype: bool-like +def diags_array( + diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtLIL, + dtype: onp.AnyBoolDType, +) -> _LILArray[np.bool_]: ... +@overload # diagonals: , format: "lil", dtype: int-like +def diags_array( + diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtLIL, + dtype: onp.AnyIntDType, +) -> _LILArray[np.int_]: ... +@overload # diagonals: , format: "lil", dtype: float64-like +def diags_array( + diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtLIL, + dtype: _AnyFloat64DTypeNotNone, +) -> _LILArray[np.float64]: ... +@overload # diagonals: , format: "lil", dtype: complex128-like +def diags_array( + diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtLIL, + dtype: onp.AnyComplex128DType, +) -> _LILArray[np.complex128]: ... +@overload # diagonals: , format: "lil", dtype: float64-like +def diags_array( + diagonals: onp.ToFloat1D | onp.ToFloat2D, + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtLIL, + dtype: _AnyFloat64DTypeNotNone, +) -> _LILArray[np.float64]: ... +@overload # diagonals: , format: "lil", dtype: bool-like +def diags_array( + diagonals: onp.ToFloat1D | onp.ToFloat2D, + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtLIL, + dtype: onp.AnyBoolDType, +) -> _LILArray[np.bool_]: ... +@overload # diagonals: , format: "lil", dtype: int-like +def diags_array( + diagonals: onp.ToFloat1D | onp.ToFloat2D, + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtLIL, + dtype: onp.AnyIntDType, +) -> _LILArray[np.int_]: ... +@overload # diagonals: , format: "lil", dtype: complex128-like +def diags_array( + diagonals: onp.ToFloat1D | onp.ToFloat2D, + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtLIL, + dtype: onp.AnyComplex128DType, +) -> _LILArray[np.complex128]: ... +@overload # diagonals: , format: "lil", dtype: complex128-like +def diags_array( + diagonals: onp.ToComplex1D | onp.ToComplex2D, + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtLIL, + dtype: onp.AnyComplex128DType, +) -> _LILArray[np.complex128]: ... +@overload # diagonals: , format: "lil", dtype: +def diags_array( + diagonals: onp.ToComplex1D | onp.ToComplex2D, + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtLIL, + dtype: onp.ToDType[_SCT], +) -> _LILArray[_SCT]: ... +@overload # diagonals: , format: "lil", dtype: +def diags_array( + diagonals: onp.ToComplex1D | onp.ToComplex2D, + /, + *, + offsets: onp.ToInt | onp.ToIntStrict1D = 0, + shape: _ToShape2D | None = None, + format: _FmtLIL, + dtype: npt.DTypeLike, +) -> _LILArray: ... + +# NOTE: `diags_array` should be prefered over `diags` +@overload # diagonals: , format: {"dia", None} = ... +def diags( + diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + offsets: onp.ToInt | onp.ToInt1D = 0, + shape: _ToShape2D | None = None, + format: _FmtDIA | None = None, + dtype: onp.ToDType[_SCT] | None = None, +) -> dia_matrix[_SCT]: ... +@overload # diagonals: , format: "bsr" (positional) +def diags( + diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + offsets: onp.ToInt | onp.ToInt1D, + shape: _ToShape2D | None, + format: _FmtBSR, + dtype: onp.ToDType[_SCT] | None = None, +) -> bsr_matrix[_SCT]: ... +@overload # diagonals: , format: "bsr" (keyword) +def diags( + diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + offsets: onp.ToInt | onp.ToInt1D = 0, + shape: _ToShape2D | None = None, + *, + format: _FmtBSR, + dtype: onp.ToDType[_SCT] | None = None, +) -> bsr_matrix[_SCT]: ... +@overload # diagonals: , format: "coo" (positional) +def diags( + diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + offsets: onp.ToInt | onp.ToInt1D, + shape: _ToShape2D | None, + format: _FmtCOO, + dtype: onp.ToDType[_SCT] | None = None, +) -> coo_matrix[_SCT]: ... +@overload # diagonals: , format: "coo" (keyword) +def diags( + diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + offsets: onp.ToInt | onp.ToInt1D = 0, + shape: _ToShape2D | None = None, + *, + format: _FmtCOO, + dtype: onp.ToDType[_SCT] | None = None, +) -> coo_matrix[_SCT]: ... +@overload # diagonals: , format: "csr" (positional) +def diags( + diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + offsets: onp.ToInt | onp.ToInt1D, + shape: _ToShape2D | None, + format: _FmtCSR, + dtype: onp.ToDType[_SCT] | None = None, +) -> csr_matrix[_SCT]: ... +@overload # diagonals: , format: "csr" (keyword) +def diags( + diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + offsets: onp.ToInt | onp.ToInt1D = 0, + shape: _ToShape2D | None = None, + *, + format: _FmtCSR, + dtype: onp.ToDType[_SCT] | None = None, +) -> csr_matrix[_SCT]: ... +@overload # diagonals: , format: "csc" (positional) +def diags( + diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + offsets: onp.ToInt | onp.ToInt1D, + shape: _ToShape2D | None, + format: _FmtCSC, + dtype: onp.ToDType[_SCT] | None = None, +) -> csc_matrix[_SCT]: ... +@overload # diagonals: , format: "csc" (keyword) +def diags( + diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + offsets: onp.ToInt | onp.ToInt1D = 0, + shape: _ToShape2D | None = None, + *, + format: _FmtCSC, + dtype: onp.ToDType[_SCT] | None = None, +) -> csc_matrix[_SCT]: ... +@overload # diagonals: , format: "dok" (positional) +def diags( + diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + offsets: onp.ToInt | onp.ToInt1D, + shape: _ToShape2D | None, + format: _FmtDOK, + dtype: onp.ToDType[_SCT] | None = None, +) -> dok_matrix[_SCT]: ... +@overload # diagonals: , format: "dok" (keyword) +def diags( + diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + offsets: onp.ToInt | onp.ToInt1D = 0, + shape: _ToShape2D | None = None, + *, + format: _FmtDOK, + dtype: onp.ToDType[_SCT] | None = None, +) -> dok_matrix[_SCT]: ... +@overload # diagonals: , format: "lil" (positional) +def diags( + diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + offsets: onp.ToInt | onp.ToInt1D, + shape: _ToShape2D | None, + format: _FmtLIL, + dtype: onp.ToDType[_SCT] | None = None, +) -> lil_matrix[_SCT]: ... +@overload # diagonals: , format: "lil" (keyword) +def diags( + diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + offsets: onp.ToInt | onp.ToInt1D = 0, + shape: _ToShape2D | None = None, + *, + format: _FmtLIL, + dtype: onp.ToDType[_SCT] | None = None, +) -> lil_matrix[_SCT]: ... +@overload # diagonals: , format: {"dia", None} = ..., dtype: (positional) +def diags( + diagonals: onp.ToComplex1D | onp.ToComplex2D, + offsets: onp.ToInt | onp.ToInt1D, + shape: _ToShape2D | None, + format: _FmtDIA | None, + dtype: onp.ToDType[_SCT], +) -> dia_matrix[_SCT]: ... +@overload # diagonals: , format: {"dia", None} = ..., dtype: (keyword) +def diags( + diagonals: onp.ToComplex1D | onp.ToComplex2D, + offsets: onp.ToInt | onp.ToInt1D = 0, + shape: _ToShape2D | None = None, + format: _FmtDIA | None = None, + *, + dtype: onp.ToDType[_SCT], +) -> dia_matrix[_SCT]: ... +@overload # diagonals: , format: "bsr" (positional), dtype: +def diags( + diagonals: onp.ToComplex1D | onp.ToComplex2D, + offsets: onp.ToInt | onp.ToInt1D, + shape: _ToShape2D | None, + format: _FmtBSR, + dtype: onp.ToDType[_SCT], +) -> bsr_matrix[_SCT]: ... +@overload # diagonals: , format: "bsr" (keyword), dtype: +def diags( + diagonals: onp.ToComplex1D | onp.ToComplex2D, + offsets: onp.ToInt | onp.ToInt1D = 0, + shape: _ToShape2D | None = None, + *, + format: _FmtBSR, + dtype: onp.ToDType[_SCT], +) -> bsr_matrix[_SCT]: ... +@overload # diagonals: , format: "coo" (positional), dtype: +def diags( + diagonals: onp.ToComplex1D | onp.ToComplex2D, + offsets: onp.ToInt | onp.ToInt1D, + shape: _ToShape2D | None, + format: _FmtCOO, + dtype: onp.ToDType[_SCT], +) -> coo_matrix[_SCT]: ... +@overload # diagonals: , format: "coo" (keyword), dtype: +def diags( + diagonals: onp.ToComplex1D | onp.ToComplex2D, + offsets: onp.ToInt | onp.ToInt1D = 0, + shape: _ToShape2D | None = None, + *, + format: _FmtCOO, + dtype: onp.ToDType[_SCT], +) -> coo_matrix[_SCT]: ... +@overload # diagonals: , format: "csr" (positional), dtype: +def diags( + diagonals: onp.ToComplex1D | onp.ToComplex2D, + offsets: onp.ToInt | onp.ToInt1D, + shape: _ToShape2D | None, + format: _FmtCSR, + dtype: onp.ToDType[_SCT], +) -> csr_matrix[_SCT]: ... +@overload # diagonals: , format: "csr" (keyword), dtype: +def diags( + diagonals: onp.ToComplex1D | onp.ToComplex2D, + offsets: onp.ToInt | onp.ToInt1D = 0, + shape: _ToShape2D | None = None, + *, + format: _FmtCSR, + dtype: onp.ToDType[_SCT], +) -> csr_matrix[_SCT]: ... +@overload # diagonals: , format: "csc" (positional), dtype: +def diags( + diagonals: onp.ToComplex1D | onp.ToComplex2D, + offsets: onp.ToInt | onp.ToInt1D, + shape: _ToShape2D | None, + format: _FmtCSC, + dtype: onp.ToDType[_SCT], +) -> csc_matrix[_SCT]: ... +@overload # diagonals: , format: "csc" (keyword), dtype: +def diags( + diagonals: onp.ToComplex1D | onp.ToComplex2D, + offsets: onp.ToInt | onp.ToInt1D = 0, + shape: _ToShape2D | None = None, + *, + format: _FmtCSC, + dtype: onp.ToDType[_SCT], +) -> csc_matrix[_SCT]: ... +@overload # diagonals: , format: "dok" (positional), dtype: +def diags( + diagonals: onp.ToComplex1D | onp.ToComplex2D, + offsets: onp.ToInt | onp.ToInt1D, + shape: _ToShape2D | None, + format: _FmtDOK, + dtype: onp.ToDType[_SCT], +) -> dok_matrix[_SCT]: ... +@overload # diagonals: , format: "dok" (keyword), dtype: +def diags( + diagonals: onp.ToComplex1D | onp.ToComplex2D, + offsets: onp.ToInt | onp.ToInt1D = 0, + shape: _ToShape2D | None = None, + *, + format: _FmtDOK, + dtype: onp.ToDType[_SCT], +) -> dok_matrix[_SCT]: ... +@overload # diagonals: , format: "lil" (positional), dtype: +def diags( + diagonals: onp.ToComplex1D | onp.ToComplex2D, + offsets: onp.ToInt | onp.ToInt1D, + shape: _ToShape2D | None, + format: _FmtLIL, + dtype: onp.ToDType[_SCT], +) -> lil_matrix[_SCT]: ... +@overload # diagonals: , format: "lil" (keyword), dtype: +def diags( + diagonals: onp.ToComplex1D | onp.ToComplex2D, offsets: onp.ToInt | onp.ToInt1D = 0, shape: _ToShape2D | None = None, - format: _FmtNonDIA, + *, + format: _FmtLIL, dtype: onp.ToDType[_SCT], -) -> _SpArray2D[_SCT]: ... +) -> lil_matrix[_SCT]: ... @overload # diagonals: , format: {"dia", None} = ..., dtype: -def diags_array( +def diags( diagonals: onp.ToComplex1D | onp.ToComplex2D, - /, - *, offsets: onp.ToInt | onp.ToInt1D = 0, shape: _ToShape2D | None = None, format: _FmtDIA | None = None, dtype: npt.DTypeLike | None = None, -) -> dia_array: ... -@overload # diagonals: , format: , dtype: -def diags_array( +) -> dia_matrix: ... +@overload # diagonals: , format: "bsr" (positional), dtype: +def diags( diagonals: onp.ToComplex1D | onp.ToComplex2D, - /, - *, - offsets: onp.ToInt | onp.ToInt1D = 0, - shape: _ToShape2D | None = None, - format: _FmtNonDIA, + offsets: onp.ToInt | onp.ToInt1D, + shape: _ToShape2D | None, + format: _FmtBSR, dtype: npt.DTypeLike | None = None, -) -> _SpArray2D: ... - -# NOTE: `diags_array` should be prefered over `diags` -@overload # diagonals: , format: {"dia", None} = ... +) -> bsr_matrix: ... +@overload # diagonals: , format: "bsr" (keyword), dtype: def diags( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + diagonals: onp.ToComplex1D | onp.ToComplex2D, offsets: onp.ToInt | onp.ToInt1D = 0, shape: _ToShape2D | None = None, - format: _FmtDIA | None = None, - dtype: onp.ToDType[_SCT] | None = None, -) -> dia_matrix[_SCT]: ... -@overload # diagonals: , format: (positional) + *, + format: _FmtBSR, + dtype: npt.DTypeLike | None = None, +) -> bsr_matrix: ... +@overload # diagonals: , format: "coo" (positional), dtype: def diags( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + diagonals: onp.ToComplex1D | onp.ToComplex2D, offsets: onp.ToInt | onp.ToInt1D, shape: _ToShape2D | None, - format: _FmtNonDIA, - dtype: onp.ToDType[_SCT] | None = None, -) -> _SpMatrix[_SCT]: ... -@overload # diagonals: , format: (keyword) + format: _FmtCOO, + dtype: npt.DTypeLike | None = None, +) -> coo_matrix: ... +@overload # diagonals: , format: "coo" (keyword), dtype: def diags( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + diagonals: onp.ToComplex1D | onp.ToComplex2D, offsets: onp.ToInt | onp.ToInt1D = 0, shape: _ToShape2D | None = None, *, - format: _FmtNonDIA, - dtype: onp.ToDType[_SCT] | None = None, -) -> _SpMatrix[_SCT]: ... -@overload # diagonals: , format: {"dia", None} = ..., dtype: (positional) + format: _FmtCOO, + dtype: npt.DTypeLike | None = None, +) -> coo_matrix: ... +@overload # diagonals: , format: "csr" (positional), dtype: def diags( diagonals: onp.ToComplex1D | onp.ToComplex2D, offsets: onp.ToInt | onp.ToInt1D, shape: _ToShape2D | None, - format: _FmtDIA | None, - dtype: onp.ToDType[_SCT], -) -> dia_matrix[_SCT]: ... -@overload # diagonals: , format: {"dia", None} = ..., dtype: (keyword) + format: _FmtCSR, + dtype: npt.DTypeLike | None = None, +) -> csr_matrix: ... +@overload # diagonals: , format: "csr" (keyword), dtype: def diags( diagonals: onp.ToComplex1D | onp.ToComplex2D, offsets: onp.ToInt | onp.ToInt1D = 0, shape: _ToShape2D | None = None, - format: _FmtDIA | None = None, *, - dtype: onp.ToDType[_SCT], -) -> dia_matrix[_SCT]: ... -@overload # diagonals: , format: (positional), dtype: + format: _FmtCSR, + dtype: npt.DTypeLike | None = None, +) -> csr_matrix: ... +@overload # diagonals: , format: "csc" (positional), dtype: def diags( diagonals: onp.ToComplex1D | onp.ToComplex2D, offsets: onp.ToInt | onp.ToInt1D, shape: _ToShape2D | None, - format: _FmtNonDIA, - dtype: onp.ToDType[_SCT], -) -> _SpMatrix[_SCT]: ... -@overload # diagonals: , format: (keyword), dtype: + format: _FmtCSC, + dtype: npt.DTypeLike | None = None, +) -> csc_matrix: ... +@overload # diagonals: , format: "csc" (keyword), dtype: def diags( diagonals: onp.ToComplex1D | onp.ToComplex2D, offsets: onp.ToInt | onp.ToInt1D = 0, shape: _ToShape2D | None = None, *, - format: _FmtNonDIA, - dtype: onp.ToDType[_SCT], -) -> _SpMatrix[_SCT]: ... -@overload # diagonals: , format: {"dia", None} = ..., dtype: + format: _FmtCSC, + dtype: npt.DTypeLike | None = None, +) -> csc_matrix: ... +@overload # diagonals: , format: "dok" (positional), dtype: +def diags( + diagonals: onp.ToComplex1D | onp.ToComplex2D, + offsets: onp.ToInt | onp.ToInt1D, + shape: _ToShape2D | None, + format: _FmtDOK, + dtype: npt.DTypeLike | None = None, +) -> dok_matrix: ... +@overload # diagonals: , format: "dok" (keyword), dtype: def diags( diagonals: onp.ToComplex1D | onp.ToComplex2D, offsets: onp.ToInt | onp.ToInt1D = 0, shape: _ToShape2D | None = None, - format: _FmtDIA | None = None, + *, + format: _FmtDOK, dtype: npt.DTypeLike | None = None, -) -> dia_matrix: ... -@overload # diagonals: , format: (positional), dtype: +) -> dok_matrix: ... +@overload # diagonals: , format: "lil" (positional), dtype: def diags( diagonals: onp.ToComplex1D | onp.ToComplex2D, offsets: onp.ToInt | onp.ToInt1D, shape: _ToShape2D | None, - format: _FmtNonDIA, + format: _FmtLIL, dtype: npt.DTypeLike | None = None, -) -> _SpMatrix: ... -@overload # diagonals: , format: (keyword), dtype: +) -> lil_matrix: ... +@overload # diagonals: , format: "lil" (keyword), dtype: def diags( diagonals: onp.ToComplex1D | onp.ToComplex2D, offsets: onp.ToInt | onp.ToInt1D = 0, shape: _ToShape2D | None = None, *, - format: _FmtNonDIA, + format: _FmtLIL, dtype: npt.DTypeLike | None = None, -) -> _SpMatrix: ... +) -> lil_matrix: ... # NOTE: `diags_array` should be prefered over `spdiags` @overload @@ -311,13 +1282,22 @@ def spdiags( format: _FmtDIA | None = None, ) -> dia_matrix[_SCT]: ... @overload +def spdiags( + data: _ToArray1D[_SCT] | _ToArray2D[_SCT], diags: onp.ToInt | onp.ToInt1D, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtBSR +) -> bsr_matrix[_SCT]: ... +@overload def spdiags( data: _ToArray1D[_SCT] | _ToArray2D[_SCT], diags: onp.ToInt | onp.ToInt1D, - m: onp.ToJustInt, - n: onp.ToJustInt, - format: _FmtNonDIA, -) -> _SpMatrix[_SCT]: ... + m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, + n: None = None, + *, + format: _FmtBSR, +) -> bsr_matrix[_SCT]: ... +@overload +def spdiags( + data: _ToArray1D[_SCT] | _ToArray2D[_SCT], diags: onp.ToInt | onp.ToInt1D, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtCOO +) -> coo_matrix[_SCT]: ... @overload def spdiags( data: _ToArray1D[_SCT] | _ToArray2D[_SCT], @@ -325,16 +1305,68 @@ def spdiags( m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, n: None = None, *, - format: _FmtNonDIA, -) -> _SpMatrix[_SCT]: ... + format: _FmtCOO, +) -> coo_matrix[_SCT]: ... +@overload +def spdiags( + data: _ToArray1D[_SCT] | _ToArray2D[_SCT], diags: onp.ToInt | onp.ToInt1D, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtCSR +) -> csr_matrix[_SCT]: ... +@overload +def spdiags( + data: _ToArray1D[_SCT] | _ToArray2D[_SCT], + diags: onp.ToInt | onp.ToInt1D, + m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, + n: None = None, + *, + format: _FmtCSR, +) -> csr_matrix[_SCT]: ... +@overload +def spdiags( + data: _ToArray1D[_SCT] | _ToArray2D[_SCT], diags: onp.ToInt | onp.ToInt1D, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtCSC +) -> csc_matrix[_SCT]: ... +@overload +def spdiags( + data: _ToArray1D[_SCT] | _ToArray2D[_SCT], + diags: onp.ToInt | onp.ToInt1D, + m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, + n: None = None, + *, + format: _FmtCSC, +) -> csc_matrix[_SCT]: ... +@overload +def spdiags( + data: _ToArray1D[_SCT] | _ToArray2D[_SCT], diags: onp.ToInt | onp.ToInt1D, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtDOK +) -> dok_matrix[_SCT]: ... +@overload +def spdiags( + data: _ToArray1D[_SCT] | _ToArray2D[_SCT], + diags: onp.ToInt | onp.ToInt1D, + m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, + n: None = None, + *, + format: _FmtDOK, +) -> dok_matrix[_SCT]: ... +@overload +def spdiags( + data: _ToArray1D[_SCT] | _ToArray2D[_SCT], diags: onp.ToInt | onp.ToInt1D, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtLIL +) -> lil_matrix[_SCT]: ... +@overload +def spdiags( + data: _ToArray1D[_SCT] | _ToArray2D[_SCT], + diags: onp.ToInt | onp.ToInt1D, + m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, + n: None = None, + *, + format: _FmtLIL, +) -> lil_matrix[_SCT]: ... @overload def spdiags( data: onp.ToComplex1D | onp.ToComplex2D, diags: onp.ToInt | onp.ToInt1D, m: onp.ToJustInt, n: onp.ToJustInt, - format: _Format | None = None, -) -> _SpMatrix: ... + format: _FmtDIA | None = None, +) -> dia_matrix: ... @overload def spdiags( data: onp.ToComplex1D | onp.ToComplex2D, @@ -342,8 +1374,86 @@ def spdiags( m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, n: None = None, *, - format: _Format | None = None, -) -> _SpMatrix: ... + format: _FmtDIA | None = None, +) -> dia_matrix: ... +@overload +def spdiags( + data: onp.ToComplex1D | onp.ToComplex2D, diags: onp.ToInt | onp.ToInt1D, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtBSR +) -> bsr_matrix: ... +@overload +def spdiags( + data: onp.ToComplex1D | onp.ToComplex2D, + diags: onp.ToInt | onp.ToInt1D, + m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, + n: None = None, + *, + format: _FmtBSR, +) -> bsr_matrix: ... +@overload +def spdiags( + data: onp.ToComplex1D | onp.ToComplex2D, diags: onp.ToInt | onp.ToInt1D, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtCOO +) -> coo_matrix: ... +@overload +def spdiags( + data: onp.ToComplex1D | onp.ToComplex2D, + diags: onp.ToInt | onp.ToInt1D, + m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, + n: None = None, + *, + format: _FmtCOO, +) -> coo_matrix: ... +@overload +def spdiags( + data: onp.ToComplex1D | onp.ToComplex2D, diags: onp.ToInt | onp.ToInt1D, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtCSR +) -> csr_matrix: ... +@overload +def spdiags( + data: onp.ToComplex1D | onp.ToComplex2D, + diags: onp.ToInt | onp.ToInt1D, + m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, + n: None = None, + *, + format: _FmtCSR, +) -> csr_matrix: ... +@overload +def spdiags( + data: onp.ToComplex1D | onp.ToComplex2D, diags: onp.ToInt | onp.ToInt1D, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtCSC +) -> csc_matrix: ... +@overload +def spdiags( + data: onp.ToComplex1D | onp.ToComplex2D, + diags: onp.ToInt | onp.ToInt1D, + m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, + n: None = None, + *, + format: _FmtCSC, +) -> csc_matrix: ... +@overload +def spdiags( + data: onp.ToComplex1D | onp.ToComplex2D, diags: onp.ToInt | onp.ToInt1D, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtDOK +) -> dok_matrix: ... +@overload +def spdiags( + data: onp.ToComplex1D | onp.ToComplex2D, + diags: onp.ToInt | onp.ToInt1D, + m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, + n: None = None, + *, + format: _FmtDOK, +) -> dok_matrix: ... +@overload +def spdiags( + data: onp.ToComplex1D | onp.ToComplex2D, diags: onp.ToInt | onp.ToInt1D, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtLIL +) -> lil_matrix: ... +@overload +def spdiags( + data: onp.ToComplex1D | onp.ToComplex2D, + diags: onp.ToInt | onp.ToInt1D, + m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, + n: None = None, + *, + format: _FmtLIL, +) -> lil_matrix: ... # @overload # dtype like bool, format: None = ... @@ -358,70 +1468,260 @@ def identity(n: opt.AnyInt, dtype: onp.AnyComplex128DType, format: _FmtDIA | Non def identity(n: opt.AnyInt, dtype: onp.ToDType[_SCT], format: _FmtDIA | None = None) -> dia_matrix[_SCT]: ... @overload # dtype like , format: None = ... def identity(n: opt.AnyInt, dtype: npt.DTypeLike, format: _FmtDIA | None = None) -> dia_matrix[Incomplete]: ... -@overload # dtype like float, format: (positional) -def identity(n: opt.AnyInt, dtype: onp.AnyFloat64DType, format: _FmtNonDIA) -> _SpMatrix[np.float64]: ... -@overload # dtype like float (default), format: (keyword) -def identity(n: opt.AnyInt, dtype: onp.AnyFloat64DType = "d", *, format: _FmtNonDIA) -> _SpMatrix[np.float64]: ... -@overload # dtype like bool, format: -def identity(n: opt.AnyInt, dtype: onp.AnyBoolDType, format: _FmtNonDIA) -> _SpMatrix[np.bool_]: ... -@overload # dtype like int, format: -def identity(n: opt.AnyInt, dtype: onp.AnyIntDType, format: _FmtNonDIA) -> _SpMatrix[np.int_]: ... -@overload # dtype like complex, format: -def identity(n: opt.AnyInt, dtype: onp.AnyComplex128DType, format: _FmtNonDIA) -> _SpMatrix[np.complex128]: ... -@overload # dtype like , format: -def identity(n: opt.AnyInt, dtype: onp.ToDType[_SCT], format: _FmtNonDIA) -> _SpMatrix[_SCT]: ... -@overload # dtype like , fformat: -def identity(n: opt.AnyInt, dtype: npt.DTypeLike, format: _FmtNonDIA) -> _SpMatrix[Incomplete]: ... +@overload # dtype like float, format: "bsr" (positional) +def identity(n: opt.AnyInt, dtype: onp.AnyFloat64DType, format: _FmtBSR) -> bsr_matrix[np.float64]: ... +@overload # dtype like float, format: "coo" (positional) +def identity(n: opt.AnyInt, dtype: onp.AnyFloat64DType, format: _FmtCOO) -> coo_matrix[np.float64]: ... +@overload # dtype like float, format: "csc" (positional) +def identity(n: opt.AnyInt, dtype: onp.AnyFloat64DType, format: _FmtCSC) -> csc_matrix[np.float64]: ... +@overload # dtype like float, format: "csr" (positional) +def identity(n: opt.AnyInt, dtype: onp.AnyFloat64DType, format: _FmtCSR) -> csr_matrix[np.float64]: ... +@overload # dtype like float, format: "dok" (positional) +def identity(n: opt.AnyInt, dtype: onp.AnyFloat64DType, format: _FmtDOK) -> dok_matrix[np.float64]: ... +@overload # dtype like float, format: "lil" (positional) +def identity(n: opt.AnyInt, dtype: onp.AnyFloat64DType, format: _FmtLIL) -> lil_matrix[np.float64]: ... +@overload # dtype like float (default), format: "bsr" (keyword) +def identity(n: opt.AnyInt, dtype: onp.AnyFloat64DType = "d", *, format: _FmtBSR) -> bsr_matrix[np.float64]: ... +@overload # dtype like float (default), format: "coo" (keyword) +def identity(n: opt.AnyInt, dtype: onp.AnyFloat64DType = "d", *, format: _FmtCOO) -> coo_matrix[np.float64]: ... +@overload # dtype like float (default), format: "csc" (keyword) +def identity(n: opt.AnyInt, dtype: onp.AnyFloat64DType = "d", *, format: _FmtCSC) -> csc_matrix[np.float64]: ... +@overload # dtype like float (default), format: "csr" (keyword) +def identity(n: opt.AnyInt, dtype: onp.AnyFloat64DType = "d", *, format: _FmtCSR) -> csr_matrix[np.float64]: ... +@overload # dtype like float (default), format: "dok" (keyword) +def identity(n: opt.AnyInt, dtype: onp.AnyFloat64DType = "d", *, format: _FmtDOK) -> dok_matrix[np.float64]: ... +@overload # dtype like float (default), format: "lil" (keyword) +def identity(n: opt.AnyInt, dtype: onp.AnyFloat64DType = "d", *, format: _FmtLIL) -> lil_matrix[np.float64]: ... +@overload # dtype like bool, format: "bsr" +def identity(n: opt.AnyInt, dtype: onp.AnyBoolDType, format: _FmtBSR) -> bsr_matrix[np.bool_]: ... +@overload # dtype like bool, format: "coo" +def identity(n: opt.AnyInt, dtype: onp.AnyBoolDType, format: _FmtCOO) -> coo_matrix[np.bool_]: ... +@overload # dtype like bool, format: "csc" +def identity(n: opt.AnyInt, dtype: onp.AnyBoolDType, format: _FmtCSC) -> csc_matrix[np.bool_]: ... +@overload # dtype like bool, format: "csr" +def identity(n: opt.AnyInt, dtype: onp.AnyBoolDType, format: _FmtCSR) -> csr_matrix[np.bool_]: ... +@overload # dtype like bool, format: "dok" +def identity(n: opt.AnyInt, dtype: onp.AnyBoolDType, format: _FmtDOK) -> dok_matrix[np.bool_]: ... +@overload # dtype like bool, format: "lil" +def identity(n: opt.AnyInt, dtype: onp.AnyBoolDType, format: _FmtLIL) -> lil_matrix[np.bool_]: ... +@overload # dtype like int, format: "bsr" +def identity(n: opt.AnyInt, dtype: onp.AnyIntDType, format: _FmtBSR) -> bsr_matrix[np.int_]: ... +@overload # dtype like int, format: "coo" +def identity(n: opt.AnyInt, dtype: onp.AnyIntDType, format: _FmtCOO) -> coo_matrix[np.int_]: ... +@overload # dtype like int, format: "csc" +def identity(n: opt.AnyInt, dtype: onp.AnyIntDType, format: _FmtCSC) -> csc_matrix[np.int_]: ... +@overload # dtype like int, format: "csr" +def identity(n: opt.AnyInt, dtype: onp.AnyIntDType, format: _FmtCSR) -> csr_matrix[np.int_]: ... +@overload # dtype like int, format: "dok" +def identity(n: opt.AnyInt, dtype: onp.AnyIntDType, format: _FmtDOK) -> dok_matrix[np.int_]: ... +@overload # dtype like int, format: "lil" +def identity(n: opt.AnyInt, dtype: onp.AnyIntDType, format: _FmtLIL) -> lil_matrix[np.int_]: ... +@overload # dtype like complex, format: "bsr" +def identity(n: opt.AnyInt, dtype: onp.AnyComplex128DType, format: _FmtBSR) -> bsr_matrix[np.complex128]: ... +@overload # dtype like complex, format: "coo" +def identity(n: opt.AnyInt, dtype: onp.AnyComplex128DType, format: _FmtCOO) -> coo_matrix[np.complex128]: ... +@overload # dtype like complex, format: "csc" +def identity(n: opt.AnyInt, dtype: onp.AnyComplex128DType, format: _FmtCSC) -> csc_matrix[np.complex128]: ... +@overload # dtype like complex, format: "csr" +def identity(n: opt.AnyInt, dtype: onp.AnyComplex128DType, format: _FmtCSR) -> csr_matrix[np.complex128]: ... +@overload # dtype like complex, format: "dok" +def identity(n: opt.AnyInt, dtype: onp.AnyComplex128DType, format: _FmtDOK) -> dok_matrix[np.complex128]: ... +@overload # dtype like complex, format: "lil" +def identity(n: opt.AnyInt, dtype: onp.AnyComplex128DType, format: _FmtLIL) -> lil_matrix[np.complex128]: ... +@overload # dtype like , format: "bsr" +def identity(n: opt.AnyInt, dtype: onp.ToDType[_SCT], format: _FmtBSR) -> bsr_matrix[_SCT]: ... +@overload # dtype like , format: "coo" +def identity(n: opt.AnyInt, dtype: onp.ToDType[_SCT], format: _FmtCOO) -> coo_matrix[_SCT]: ... +@overload # dtype like , format: "csc" +def identity(n: opt.AnyInt, dtype: onp.ToDType[_SCT], format: _FmtCSC) -> csc_matrix[_SCT]: ... +@overload # dtype like , format: "csr" +def identity(n: opt.AnyInt, dtype: onp.ToDType[_SCT], format: _FmtCSR) -> csr_matrix[_SCT]: ... +@overload # dtype like , format: "dok" +def identity(n: opt.AnyInt, dtype: onp.ToDType[_SCT], format: _FmtDOK) -> dok_matrix[_SCT]: ... +@overload # dtype like , format: "lil" +def identity(n: opt.AnyInt, dtype: onp.ToDType[_SCT], format: _FmtLIL) -> lil_matrix[_SCT]: ... +@overload # dtype like , format: "bsr" +def identity(n: opt.AnyInt, dtype: npt.DTypeLike, format: _FmtBSR) -> bsr_matrix[Incomplete]: ... +@overload # dtype like , format: "coo" +def identity(n: opt.AnyInt, dtype: npt.DTypeLike, format: _FmtCOO) -> coo_matrix[Incomplete]: ... +@overload # dtype like , format: "csc" +def identity(n: opt.AnyInt, dtype: npt.DTypeLike, format: _FmtCSC) -> csc_matrix[Incomplete]: ... +@overload # dtype like , format: "csr" +def identity(n: opt.AnyInt, dtype: npt.DTypeLike, format: _FmtCSR) -> csr_matrix[Incomplete]: ... +@overload # dtype like , format: "dok" +def identity(n: opt.AnyInt, dtype: npt.DTypeLike, format: _FmtDOK) -> dok_matrix[Incomplete]: ... +@overload # dtype like , format: "lil" +def identity(n: opt.AnyInt, dtype: npt.DTypeLike, format: _FmtLIL) -> lil_matrix[Incomplete]: ... # @overload # dtype like bool, format: None = ... def eye_array( m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyBoolDType, format: _FmtDIA | None = None -) -> dia_array[np.bool_]: ... +) -> _DIAArray[np.bool_]: ... @overload # dtype like int, format: None = ... def eye_array( m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyIntDType, format: _FmtDIA | None = None -) -> dia_array[np.int_]: ... +) -> _DIAArray[np.int_]: ... @overload # dtype like float (default), format: None = ... def eye_array( m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyFloat64DType = ..., format: _FmtDIA | None = None -) -> dia_array[np.float64]: ... +) -> _DIAArray[np.float64]: ... @overload # dtype like complex, format: None = ... def eye_array( m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyComplex128DType, format: _FmtDIA | None = None -) -> dia_array[np.complex128]: ... +) -> _DIAArray[np.complex128]: ... @overload # dtype like , format: None = ... def eye_array( m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.ToDType[_SCT], format: _FmtDIA | None = None -) -> dia_array[_SCT]: ... +) -> _DIAArray[_SCT]: ... @overload # dtype like , format: None = ... def eye_array( m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: npt.DTypeLike, format: _FmtDIA | None = None -) -> dia_array[Incomplete]: ... -@overload # dtype like float (default), format: +) -> _DIAArray[Incomplete]: ... +@overload # dtype like float (default), format: "bsr" def eye_array( - m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyFloat64DType = ..., format: _FmtNonDIA -) -> _SpArray2D[np.float64]: ... -@overload # dtype like bool, format: + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyFloat64DType = ..., format: _FmtBSR +) -> _BSRArray[np.float64]: ... +@overload # dtype like float (default), format: "coo" def eye_array( - m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyBoolDType, format: _FmtNonDIA -) -> _SpArray2D[np.bool_]: ... -@overload # dtype like int, format: + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyFloat64DType = ..., format: _FmtCOO +) -> _COOArray2D[np.float64]: ... +@overload # dtype like float (default), format: "csc" def eye_array( - m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyIntDType, format: _FmtNonDIA -) -> _SpArray2D[np.int_]: ... -@overload # dtype like complex, format: + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyFloat64DType = ..., format: _FmtCSC +) -> _CSCArray[np.float64]: ... +@overload # dtype like float (default), format: "csr" def eye_array( - m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyComplex128DType, format: _FmtNonDIA -) -> _SpArray2D[np.complex128]: ... -@overload # dtype like , format: + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyFloat64DType = ..., format: _FmtCSR +) -> _CSRArray2D[np.float64]: ... +@overload # dtype like float (default), format: "dok" def eye_array( - m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.ToDType[_SCT], format: _FmtNonDIA -) -> _SpArray2D[_SCT]: ... -@overload # dtype like , fformat: + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyFloat64DType = ..., format: _FmtDOK +) -> _DOKArray2D[np.float64]: ... +@overload # dtype like float (default), format: "lil" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyFloat64DType = ..., format: _FmtLIL +) -> _LILArray[np.float64]: ... +@overload # dtype like bool, format: "bsr" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyBoolDType, format: _FmtBSR +) -> _BSRArray[np.bool_]: ... +@overload # dtype like bool, format: "coo" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyBoolDType, format: _FmtCOO +) -> _COOArray2D[np.bool_]: ... +@overload # dtype like bool, format: "csc" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyBoolDType, format: _FmtCSC +) -> _CSCArray[np.bool_]: ... +@overload # dtype like bool, format: "csr" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyBoolDType, format: _FmtCSR +) -> _CSRArray2D[np.bool_]: ... +@overload # dtype like bool, format: "dok" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyBoolDType, format: _FmtDOK +) -> _DOKArray2D[np.bool_]: ... +@overload # dtype like bool, format: "lil" def eye_array( - m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: npt.DTypeLike, format: _FmtNonDIA -) -> _SpArray2D[Incomplete]: ... + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyBoolDType, format: _FmtLIL +) -> _LILArray[np.bool_]: ... +@overload # dtype like int, format: "bsr" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyIntDType, format: _FmtBSR +) -> _BSRArray[np.int_]: ... +@overload # dtype like int, format: "coo" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyIntDType, format: _FmtCOO +) -> _COOArray2D[np.int_]: ... +@overload # dtype like int, format: "csc" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyIntDType, format: _FmtCSC +) -> _CSCArray[np.int_]: ... +@overload # dtype like int, format: "csr" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyIntDType, format: _FmtCSR +) -> _CSRArray2D[np.int_]: ... +@overload # dtype like int, format: "dok" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyIntDType, format: _FmtDOK +) -> _DOKArray2D[np.int_]: ... +@overload # dtype like int, format: "lil" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyIntDType, format: _FmtLIL +) -> _LILArray[np.int_]: ... +@overload # dtype like complex, format: "bsr" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyComplex128DType, format: _FmtBSR +) -> _BSRArray[np.complex128]: ... +@overload # dtype like complex, format: "coo" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyComplex128DType, format: _FmtCOO +) -> _COOArray2D[np.complex128]: ... +@overload # dtype like complex, format: "csc" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyComplex128DType, format: _FmtCSC +) -> _CSCArray[np.complex128]: ... +@overload # dtype like complex, format: "csr" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyComplex128DType, format: _FmtCSR +) -> _CSRArray2D[np.complex128]: ... +@overload # dtype like complex, format: "dok" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyComplex128DType, format: _FmtDOK +) -> _DOKArray2D[np.complex128]: ... +@overload # dtype like complex, format: "lil" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyComplex128DType, format: _FmtLIL +) -> _LILArray[np.complex128]: ... +@overload # dtype like , format: "bsr" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.ToDType[_SCT], format: _FmtBSR +) -> _BSRArray[_SCT]: ... +@overload # dtype like , format: "coo" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.ToDType[_SCT], format: _FmtCOO +) -> _COOArray2D[_SCT]: ... +@overload # dtype like , format: "csc" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.ToDType[_SCT], format: _FmtCSC +) -> _CSCArray[_SCT]: ... +@overload # dtype like , format: "csr" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.ToDType[_SCT], format: _FmtCSR +) -> _CSRArray2D[_SCT]: ... +@overload # dtype like , format: "dok" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.ToDType[_SCT], format: _FmtDOK +) -> _DOKArray2D[_SCT]: ... +@overload # dtype like , format: "lil" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.ToDType[_SCT], format: _FmtLIL +) -> _LILArray[_SCT]: ... +@overload # dtype like , format: "bsr" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: npt.DTypeLike, format: _FmtBSR +) -> _BSRArray[Incomplete]: ... +@overload # dtype like , format: "coo" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: npt.DTypeLike, format: _FmtCOO +) -> _COOArray2D[Incomplete]: ... +@overload # dtype like , format: "csc" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: npt.DTypeLike, format: _FmtCSC +) -> _CSCArray[Incomplete]: ... +@overload # dtype like , format: "csr" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: npt.DTypeLike, format: _FmtCSR +) -> _CSRArray2D[Incomplete]: ... +@overload # dtype like , format: "dok" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: npt.DTypeLike, format: _FmtDOK +) -> _DOKArray2D[Incomplete]: ... +@overload # dtype like , format: "lil" +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: npt.DTypeLike, format: _FmtLIL +) -> _LILArray[Incomplete]: ... # NOTE: `eye_array` should be prefered over `eye` @overload # dtype like float (default), default format @@ -468,50 +1768,222 @@ def eye( def eye( m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: npt.DTypeLike, format: _FmtDIA | None = None ) -> dia_matrix[Incomplete]: ... -@overload # dtype like float (default) +@overload # dtype like float (default), format: "bsr" def eye( - m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, dtype: onp.AnyFloat64DType = ..., format: _Format | None = None -) -> _SpMatrix[np.float64]: ... -@overload # dtype like bool (positional) + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, dtype: onp.AnyFloat64DType = ..., *, format: _FmtBSR +) -> bsr_matrix[np.float64]: ... +@overload # dtype like bool (positional), format: "bsr" +def eye(m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.AnyBoolDType, format: _FmtBSR) -> bsr_matrix[np.bool_]: ... +@overload # dtype like bool (keyword), format: "bsr" def eye( - m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.AnyBoolDType, format: _Format | None = None -) -> _SpMatrix[np.bool_]: ... -@overload # dtype like bool (keyword) + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyBoolDType, format: _FmtBSR +) -> bsr_matrix[np.bool_]: ... +@overload # dtype like int (positional), format: "bsr" +def eye(m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.AnyIntDType, format: _FmtBSR) -> bsr_matrix[np.int_]: ... +@overload # dtype like int (keyword), format: "bsr" def eye( - m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyBoolDType, format: _Format | None = None -) -> _SpMatrix[np.bool_]: ... -@overload # dtype like int (positional) + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyIntDType, format: _FmtBSR +) -> bsr_matrix[np.int_]: ... +@overload # dtype like complex (positional), format: "bsr" def eye( - m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.AnyIntDType, format: _Format | None = None -) -> _SpMatrix[np.int_]: ... -@overload # dtype like int (keyword) + m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.AnyComplex128DType, format: _FmtBSR +) -> bsr_matrix[np.complex128]: ... +@overload # dtype like complex (keyword), format: "bsr" def eye( - m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyIntDType, format: _Format | None = None -) -> _SpMatrix[np.int_]: ... -@overload # dtype like complex (positional) + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyComplex128DType, format: _FmtBSR +) -> bsr_matrix[np.complex128]: ... +@overload # dtype like (positional), format: "bsr" +def eye(m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.ToDType[_SCT], format: _FmtBSR) -> bsr_matrix[_SCT]: ... +@overload # dtype like (keyword), format: "bsr" def eye( - m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.AnyComplex128DType, format: _Format | None = None -) -> _SpMatrix[np.complex128]: ... -@overload # dtype like complex (keyword) + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.ToDType[_SCT], format: _FmtBSR +) -> bsr_matrix[_SCT]: ... +@overload # dtype like (positional), format: "bsr" +def eye(m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: npt.DTypeLike, format: _FmtBSR) -> bsr_matrix[Incomplete]: ... +@overload # dtype like (keyword), format: "bsr" def eye( - m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyComplex128DType, format: _Format | None = None -) -> _SpMatrix[np.complex128]: ... -@overload # dtype like (positional) + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: npt.DTypeLike, format: _FmtBSR +) -> bsr_matrix[Incomplete]: ... +@overload # dtype like float (default), format: "coo" def eye( - m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.ToDType[_SCT], format: _Format | None = None -) -> _SpMatrix[_SCT]: ... -@overload # dtype like (keyword) + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, dtype: onp.AnyFloat64DType = ..., *, format: _FmtCOO +) -> coo_matrix[np.float64]: ... +@overload # dtype like bool (positional), format: "coo" +def eye(m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.AnyBoolDType, format: _FmtCOO) -> coo_matrix[np.bool_]: ... +@overload # dtype like bool (keyword), format: "coo" def eye( - m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.ToDType[_SCT], format: _Format | None = None -) -> _SpMatrix[_SCT]: ... -@overload # dtype like (positional) + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyBoolDType, format: _FmtCOO +) -> coo_matrix[np.bool_]: ... +@overload # dtype like int (positional), format: "coo" +def eye(m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.AnyIntDType, format: _FmtCOO) -> coo_matrix[np.int_]: ... +@overload # dtype like int (keyword), format: "coo" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyIntDType, format: _FmtCOO +) -> coo_matrix[np.int_]: ... +@overload # dtype like complex (positional), format: "coo" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.AnyComplex128DType, format: _FmtCOO +) -> coo_matrix[np.complex128]: ... +@overload # dtype like complex (keyword), format: "coo" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyComplex128DType, format: _FmtCOO +) -> coo_matrix[np.complex128]: ... +@overload # dtype like (positional), format: "coo" +def eye(m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.ToDType[_SCT], format: _FmtCOO) -> coo_matrix[_SCT]: ... +@overload # dtype like (keyword), format: "coo" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.ToDType[_SCT], format: _FmtCOO +) -> coo_matrix[_SCT]: ... +@overload # dtype like (positional), format: "coo" +def eye(m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: npt.DTypeLike, format: _FmtCOO) -> coo_matrix[Incomplete]: ... +@overload # dtype like (keyword), format: "coo" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: npt.DTypeLike, format: _FmtCOO +) -> coo_matrix[Incomplete]: ... +@overload # dtype like float (default), format: "csc" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, dtype: onp.AnyFloat64DType = ..., *, format: _FmtCSC +) -> csc_matrix[np.float64]: ... +@overload # dtype like bool (positional), format: "csc" +def eye(m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.AnyBoolDType, format: _FmtCSC) -> csc_matrix[np.bool_]: ... +@overload # dtype like bool (keyword), format: "csc" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyBoolDType, format: _FmtCSC +) -> csc_matrix[np.bool_]: ... +@overload # dtype like int (positional), format: "csc" +def eye(m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.AnyIntDType, format: _FmtCSC) -> csc_matrix[np.int_]: ... +@overload # dtype like int (keyword), format: "csc" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyIntDType, format: _FmtCSC +) -> csc_matrix[np.int_]: ... +@overload # dtype like complex (positional), format: "csc" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.AnyComplex128DType, format: _FmtCSC +) -> csc_matrix[np.complex128]: ... +@overload # dtype like complex (keyword), format: "csc" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyComplex128DType, format: _FmtCSC +) -> csc_matrix[np.complex128]: ... +@overload # dtype like (positional), format: "csc" +def eye(m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.ToDType[_SCT], format: _FmtCSC) -> csc_matrix[_SCT]: ... +@overload # dtype like (keyword), format: "csc" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.ToDType[_SCT], format: _FmtCSC +) -> csc_matrix[_SCT]: ... +@overload # dtype like (positional), format: "csc" +def eye(m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: npt.DTypeLike, format: _FmtCSC) -> csc_matrix[Incomplete]: ... +@overload # dtype like (keyword), format: "csc" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: npt.DTypeLike, format: _FmtCSC +) -> csc_matrix[Incomplete]: ... +@overload # dtype like float (default), format: "csr" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, dtype: onp.AnyFloat64DType = ..., *, format: _FmtCSR +) -> csr_matrix[np.float64]: ... +@overload # dtype like bool (positional), format: "csr" +def eye(m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.AnyBoolDType, format: _FmtCSR) -> csr_matrix[np.bool_]: ... +@overload # dtype like bool (keyword), format: "csr" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyBoolDType, format: _FmtCSR +) -> csr_matrix[np.bool_]: ... +@overload # dtype like int (positional), format: "csr" +def eye(m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.AnyIntDType, format: _FmtCSR) -> csr_matrix[np.int_]: ... +@overload # dtype like int (keyword), format: "csr" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyIntDType, format: _FmtCSR +) -> csr_matrix[np.int_]: ... +@overload # dtype like complex (positional), format: "csr" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.AnyComplex128DType, format: _FmtCSR +) -> csr_matrix[np.complex128]: ... +@overload # dtype like complex (keyword), format: "csr" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyComplex128DType, format: _FmtCSR +) -> csr_matrix[np.complex128]: ... +@overload # dtype like (positional), format: "csr" +def eye(m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.ToDType[_SCT], format: _FmtCSR) -> csr_matrix[_SCT]: ... +@overload # dtype like (keyword), format: "csr" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.ToDType[_SCT], format: _FmtCSR +) -> csr_matrix[_SCT]: ... +@overload # dtype like (positional), format: "csr" +def eye(m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: npt.DTypeLike, format: _FmtCSR) -> csr_matrix[Incomplete]: ... +@overload # dtype like (keyword), format: "csr" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: npt.DTypeLike, format: _FmtCSR +) -> csr_matrix[Incomplete]: ... +@overload # dtype like float (default), format: "dok" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, dtype: onp.AnyFloat64DType = ..., *, format: _FmtDOK +) -> dok_matrix[np.float64]: ... +@overload # dtype like bool (positional), format: "dok" +def eye(m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.AnyBoolDType, format: _FmtDOK) -> dok_matrix[np.bool_]: ... +@overload # dtype like bool (keyword), format: "dok" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyBoolDType, format: _FmtDOK +) -> dok_matrix[np.bool_]: ... +@overload # dtype like int (positional), format: "dok" +def eye(m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.AnyIntDType, format: _FmtDOK) -> dok_matrix[np.int_]: ... +@overload # dtype like int (keyword), format: "dok" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyIntDType, format: _FmtDOK +) -> dok_matrix[np.int_]: ... +@overload # dtype like complex (positional), format: "dok" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.AnyComplex128DType, format: _FmtDOK +) -> dok_matrix[np.complex128]: ... +@overload # dtype like complex (keyword), format: "dok" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyComplex128DType, format: _FmtDOK +) -> dok_matrix[np.complex128]: ... +@overload # dtype like (positional), format: "dok" +def eye(m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.ToDType[_SCT], format: _FmtDOK) -> dok_matrix[_SCT]: ... +@overload # dtype like (keyword), format: "dok" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.ToDType[_SCT], format: _FmtDOK +) -> dok_matrix[_SCT]: ... +@overload # dtype like (positional), format: "dok" +def eye(m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: npt.DTypeLike, format: _FmtDOK) -> dok_matrix[Incomplete]: ... +@overload # dtype like (keyword), format: "dok" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: npt.DTypeLike, format: _FmtDOK +) -> dok_matrix[Incomplete]: ... +@overload # dtype like float (default), format: "lil" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, dtype: onp.AnyFloat64DType = ..., *, format: _FmtLIL +) -> lil_matrix[np.float64]: ... +@overload # dtype like bool (positional), format: "lil" +def eye(m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.AnyBoolDType, format: _FmtLIL) -> lil_matrix[np.bool_]: ... +@overload # dtype like bool (keyword), format: "lil" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyBoolDType, format: _FmtLIL +) -> lil_matrix[np.bool_]: ... +@overload # dtype like int (positional), format: "lil" +def eye(m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.AnyIntDType, format: _FmtLIL) -> lil_matrix[np.int_]: ... +@overload # dtype like int (keyword), format: "lil" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyIntDType, format: _FmtLIL +) -> lil_matrix[np.int_]: ... +@overload # dtype like complex (positional), format: "lil" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.AnyComplex128DType, format: _FmtLIL +) -> lil_matrix[np.complex128]: ... +@overload # dtype like complex (keyword), format: "lil" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyComplex128DType, format: _FmtLIL +) -> lil_matrix[np.complex128]: ... +@overload # dtype like (positional), format: "lil" +def eye(m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.ToDType[_SCT], format: _FmtLIL) -> lil_matrix[_SCT]: ... +@overload # dtype like (keyword), format: "lil" def eye( - m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: npt.DTypeLike, format: _Format | None = None -) -> _SpMatrix[Incomplete]: ... -@overload # dtype like (keyword) + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.ToDType[_SCT], format: _FmtLIL +) -> lil_matrix[_SCT]: ... +@overload # dtype like (positional), format: "lil" +def eye(m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: npt.DTypeLike, format: _FmtLIL) -> lil_matrix[Incomplete]: ... +@overload # dtype like (keyword), format: "lil" def eye( - m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: npt.DTypeLike, format: _Format | None = None -) -> _SpMatrix[Incomplete]: ... + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: npt.DTypeLike, format: _FmtLIL +) -> lil_matrix[Incomplete]: ... # @overload # A: spmatrix or 2d array-like, B: spmatrix or 2d array-like, format: {"bsr", None} = ... diff --git a/tests/sparse/test_construct.pyi b/tests/sparse/test_construct.pyi index e09f9424..90e2ca90 100644 --- a/tests/sparse/test_construct.pyi +++ b/tests/sparse/test_construct.pyi @@ -1,4 +1,4 @@ -from typing import assert_type +from typing import Any, assert_type import numpy as np @@ -36,28 +36,145 @@ int_list: list[int] ### # diags_array +assert_type(sparse.diags_array([1, 2]), sparse.dia_array[Any]) +assert_type(sparse.diags_array([[1, 2.0], [3j]], offsets=int_list), sparse.dia_array[Any]) assert_type(sparse.diags_array(dense_1d), sparse.dia_array[ScalarType]) -assert_type(sparse.diags_array([dense_1d, dense_1d]), sparse.dia_array[ScalarType]) +assert_type(sparse.diags_array(dense_1d.astype(np.float128)), sparse.dia_array[np.float128]) +assert_type(sparse.diags_array(dense_1d.astype(np.complex128)), sparse.dia_array[np.complex128]) +assert_type(sparse.diags_array(dense_2d, offsets=int_list), sparse.dia_array[ScalarType]) +assert_type(sparse.diags_array(dense_1d, dtype="bool"), sparse.dia_array[np.bool_]) +assert_type(sparse.diags_array(dense_2d, dtype="bool"), sparse.dia_array[np.bool_]) +assert_type(sparse.diags_array(dense_1d, dtype=int), sparse.dia_array[np.int_]) +assert_type(sparse.diags_array(dense_2d, dtype=int), sparse.dia_array[np.int_]) +assert_type(sparse.diags_array(dense_1d, dtype=np.float128), sparse.dia_array[np.float128]) +assert_type(sparse.diags_array(dense_2d, dtype=np.float128), sparse.dia_array[np.float128]) +assert_type(sparse.diags_array(dense_1d, dtype=" Date: Wed, 9 Jul 2025 16:20:23 +0200 Subject: [PATCH 02/20] Removed accidental push of VSCode settings --- .vscode/settings.json | 3 --- 1 file changed, 3 deletions(-) diff --git a/.vscode/settings.json b/.vscode/settings.json index dd6cb3f6..c558cc65 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -33,9 +33,6 @@ "editor.tabSize": 2, }, "dprint.path": ".venv/bin/dprint", - "code-runner.executorMap": { - "python": "cd \"$workspaceRoot\" && source \".venv/bin/activate\" && uvx basedpyright $fullFileName && python $fullFileName", - }, "mypy-type-checker.path": [ "uv", "run", From 1c9d44435e324f5eaae45e98e7d564c5338d8273 Mon Sep 17 00:00:00 2001 From: Jul Van den Broeck Date: Wed, 9 Jul 2025 17:57:37 +0200 Subject: [PATCH 03/20] Added type aliases and cleaned up overloads --- scipy-stubs/sparse/_construct.pyi | 1055 ++++------------------------- tests/sparse/test_construct.pyi | 6 +- 2 files changed, 151 insertions(+), 910 deletions(-) diff --git a/scipy-stubs/sparse/_construct.pyi b/scipy-stubs/sparse/_construct.pyi index 4f3ffd57..fd0579f7 100644 --- a/scipy-stubs/sparse/_construct.pyi +++ b/scipy-stubs/sparse/_construct.pyi @@ -4,13 +4,11 @@ from typing import Any, Literal, Protocol, TypeAlias, TypeVar, overload, type_ch import numpy as np import numpy.typing as npt +import optype as op import optype.numpy as onp import optype.numpy.compat as npc import optype.typing as opt -from optype.numpy._any_dtype import f_cls -from optype.numpy._dtype import ToDType from optype.numpy._dtype_attr import f8_code -from optype.numpy._scalar import floating64 from ._base import _spbase, sparray from ._bsr import bsr_array, bsr_matrix @@ -43,15 +41,15 @@ __all__ = [ ] _Numeric: TypeAlias = npc.number | np.bool_ -_AnyFloat64DTypeNotNone: TypeAlias = f_cls | ToDType[floating64] | f8_code +_AnyFloat64DTypeNotNone: TypeAlias = type[op.JustFloat] | onp.ToDType[npc.floating64] | f8_code _T = TypeVar("_T") _SCT = TypeVar("_SCT", bound=_Numeric, default=Any) _SCT0 = TypeVar("_SCT0", bound=_Numeric) _ShapeT = TypeVar("_ShapeT", bound=tuple[int, *tuple[int, ...]], default=tuple[Any, ...]) -_ToArray1D: TypeAlias = Seq[int | float | complex | _SCT] | onp.CanArrayND[_SCT] -_ToArray2D: TypeAlias = Seq[_ToArray1D[_SCT]] | onp.CanArrayND[_SCT] +_ToArray1D: TypeAlias = onp.ToArray1D[complex, _SCT] +_ToArray2D: TypeAlias = onp.ToArray2D[complex, _SCT] _ToSpMatrix: TypeAlias = spmatrix[_SCT] | _ToArray2D[_SCT] _ToSparse2D: TypeAlias = _spbase[_SCT, tuple[int, int]] | _ToArray2D[_SCT] @@ -80,6 +78,9 @@ _FmtDOK: TypeAlias = Literal["dok"] _FmtLIL: TypeAlias = Literal["lil"] _FmtNonCOO: TypeAlias = Literal["bsr", "csc", "csr", "dia", "dok", "lil"] +_Diag: TypeAlias = _ToArray1D[_SCT] | _ToArray2D[_SCT] +_Offsets: TypeAlias = onp.ToInt | onp.ToIntStrict1D + _DataRVS: TypeAlias = Callable[[int], onp.ArrayND[_Numeric]] _ToBlocks: TypeAlias = Seq[Seq[_spbase[_SCT] | None]] | onp.ArrayND[np.object_] @@ -92,100 +93,50 @@ class _DataSampler(Protocol): @overload # diagonals: , dtype: None = ..., format: {"dia", None} = ... def diags_array( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + diagonals: _Diag[_SCT], /, *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtDIA | None = None, dtype: None = None, ) -> _DIAArray[_SCT]: ... @overload # diagonals: , format: {"dia", None} = ..., dtype: bool-like def diags_array( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + diagonals: _Diag[_SCT], /, *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtDIA | None = None, dtype: onp.AnyBoolDType, ) -> _DIAArray[np.bool_]: ... @overload # diagonals: , format: {"dia", None} = ..., dtype: int-like def diags_array( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + diagonals: _Diag[_SCT], /, *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtDIA | None = None, dtype: onp.AnyIntDType, ) -> _DIAArray[np.int_]: ... @overload # diagonals: , format: {"dia", None} = ..., dtype: float64-like def diags_array( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + diagonals: _Diag[_SCT], /, *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtDIA | None = None, dtype: _AnyFloat64DTypeNotNone, ) -> _DIAArray[np.float64]: ... @overload # diagonals: , format: {"dia", None} = ..., dtype: complex128-like def diags_array( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], - /, - *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, - shape: _ToShape2D | None = None, - format: _FmtDIA | None = None, - dtype: onp.AnyComplex128DType, -) -> _DIAArray[np.complex128]: ... -@overload # diagonals: , format: {"dia", None} = ..., dtype: float64-like -def diags_array( - diagonals: onp.ToFloat1D | onp.ToFloat2D, - /, - *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, - shape: _ToShape2D | None = None, - format: _FmtDIA | None = None, - dtype: _AnyFloat64DTypeNotNone, -) -> _DIAArray[np.float64]: ... -@overload # diagonals: , format: {"dia", None} = ..., dtype: bool-like -def diags_array( - diagonals: onp.ToFloat1D | onp.ToFloat2D, - /, - *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, - shape: _ToShape2D | None = None, - format: _FmtDIA | None = None, - dtype: onp.AnyBoolDType, -) -> _DIAArray[np.bool_]: ... -@overload # diagonals: , format: {"dia", None} = ..., dtype: int-like -def diags_array( - diagonals: onp.ToFloat1D | onp.ToFloat2D, + diagonals: _Diag[_SCT], /, *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, - shape: _ToShape2D | None = None, - format: _FmtDIA | None = None, - dtype: onp.AnyIntDType, -) -> _DIAArray[np.int_]: ... -@overload # diagonals: , format: {"dia", None} = ..., dtype: complex128-like -def diags_array( - diagonals: onp.ToFloat1D | onp.ToFloat2D, - /, - *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, - shape: _ToShape2D | None = None, - format: _FmtDIA | None = None, - dtype: onp.AnyComplex128DType, -) -> _DIAArray[np.complex128]: ... -@overload # diagonals: , format: {"dia", None} = ..., dtype: complex128-like -def diags_array( - diagonals: onp.ToComplex1D | onp.ToComplex2D, - /, - *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtDIA | None = None, dtype: onp.AnyComplex128DType, @@ -195,7 +146,7 @@ def diags_array( diagonals: onp.ToComplex1D | onp.ToComplex2D, /, *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtDIA | None = None, dtype: onp.ToDType[_SCT], @@ -205,7 +156,7 @@ def diags_array( diagonals: onp.ToComplex1D | onp.ToComplex2D, /, *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtDIA | None = None, dtype: npt.DTypeLike, @@ -214,100 +165,32 @@ def diags_array( # BSR @overload # diagonals: , format: "bsr", dtype: None def diags_array( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], - /, - *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, - shape: _ToShape2D | None = None, - format: _FmtBSR, - dtype: None = None, + diagonals: _Diag[_SCT], /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtBSR, dtype: None = None ) -> _BSRArray[_SCT]: ... @overload # diagonals: , format: "bsr", dtype: bool-like def diags_array( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], - /, - *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, - shape: _ToShape2D | None = None, - format: _FmtBSR, - dtype: onp.AnyBoolDType, + diagonals: _Diag[_SCT], /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtBSR, dtype: onp.AnyBoolDType ) -> _BSRArray[np.bool_]: ... @overload # diagonals: , format: "bsr", dtype: int-like def diags_array( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], - /, - *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, - shape: _ToShape2D | None = None, - format: _FmtBSR, - dtype: onp.AnyIntDType, + diagonals: _Diag[_SCT], /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtBSR, dtype: onp.AnyIntDType ) -> _BSRArray[np.int_]: ... @overload # diagonals: , format: "bsr", dtype: float64-like def diags_array( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + diagonals: _Diag[_SCT], /, *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtBSR, dtype: _AnyFloat64DTypeNotNone, ) -> _BSRArray[np.float64]: ... @overload # diagonals: , format: "bsr", dtype: complex128-like def diags_array( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + diagonals: _Diag[_SCT], /, *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, - shape: _ToShape2D | None = None, - format: _FmtBSR, - dtype: onp.AnyComplex128DType, -) -> _BSRArray[np.complex128]: ... -@overload # diagonals: , format: "bsr", dtype: float64-like -def diags_array( - diagonals: onp.ToFloat1D | onp.ToFloat2D, - /, - *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, - shape: _ToShape2D | None = None, - format: _FmtBSR, - dtype: _AnyFloat64DTypeNotNone, -) -> _BSRArray[np.float64]: ... -@overload # diagonals: , format: "bsr", dtype: bool-like -def diags_array( - diagonals: onp.ToFloat1D | onp.ToFloat2D, - /, - *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, - shape: _ToShape2D | None = None, - format: _FmtBSR, - dtype: onp.AnyBoolDType, -) -> _BSRArray[np.bool_]: ... -@overload # diagonals: , format: "bsr", dtype: int-like -def diags_array( - diagonals: onp.ToFloat1D | onp.ToFloat2D, - /, - *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, - shape: _ToShape2D | None = None, - format: _FmtBSR, - dtype: onp.AnyIntDType, -) -> _BSRArray[np.int_]: ... -@overload # diagonals: , format: "bsr", dtype: complex128-like -def diags_array( - diagonals: onp.ToFloat1D | onp.ToFloat2D, - /, - *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, - shape: _ToShape2D | None = None, - format: _FmtBSR, - dtype: onp.AnyComplex128DType, -) -> _BSRArray[np.complex128]: ... -@overload # diagonals: , format: "bsr", dtype: complex128-like -def diags_array( - diagonals: onp.ToComplex1D | onp.ToComplex2D, - /, - *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtBSR, dtype: onp.AnyComplex128DType, @@ -317,7 +200,7 @@ def diags_array( diagonals: onp.ToComplex1D | onp.ToComplex2D, /, *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtBSR, dtype: onp.ToDType[_SCT], @@ -327,7 +210,7 @@ def diags_array( diagonals: onp.ToComplex1D | onp.ToComplex2D, /, *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtBSR, dtype: npt.DTypeLike, @@ -336,202 +219,86 @@ def diags_array( # COO @overload # diagonals: , format: "coo", dtype: None def diags_array( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], - /, - *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, - shape: _ToShape2D | None = None, - format: _FmtCOO, - dtype: None = None, + diagonals: _Diag[_SCT], /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCOO, dtype: None = None ) -> _COOArray2D[_SCT]: ... @overload # diagonals: , format: "coo", dtype: bool-like def diags_array( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], - /, - *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, - shape: _ToShape2D | None = None, - format: _FmtCOO, - dtype: onp.AnyBoolDType, + diagonals: _Diag[_SCT], /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCOO, dtype: onp.AnyBoolDType ) -> _COOArray2D[np.bool_]: ... @overload # diagonals: , format: "coo", dtype: int-like def diags_array( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], - /, - *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, - shape: _ToShape2D | None = None, - format: _FmtCOO, - dtype: onp.AnyIntDType, + diagonals: _Diag[_SCT], /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCOO, dtype: onp.AnyIntDType ) -> _COOArray2D[np.int_]: ... @overload # diagonals: , format: "coo", dtype: float64-like def diags_array( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + diagonals: _Diag[_SCT], /, *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCOO, dtype: _AnyFloat64DTypeNotNone, ) -> _COOArray2D[np.float64]: ... @overload # diagonals: , format: "coo", dtype: complex128-like def diags_array( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + diagonals: _Diag[_SCT], /, *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCOO, dtype: onp.AnyComplex128DType, ) -> _COOArray2D[np.complex128]: ... -@overload # diagonals: , format: "coo", dtype: float64-like -def diags_array( - diagonals: onp.ToFloat1D | onp.ToFloat2D, - /, - *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, - shape: _ToShape2D | None = None, - format: _FmtCOO, - dtype: _AnyFloat64DTypeNotNone, -) -> _COOArray2D[np.float64]: ... -@overload # diagonals: , format: "coo", dtype: bool-like -def diags_array( - diagonals: onp.ToFloat1D | onp.ToFloat2D, - /, - *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, - shape: _ToShape2D | None = None, - format: _FmtCOO, - dtype: onp.AnyBoolDType, -) -> _COOArray2D[np.bool_]: ... -@overload # diagonals: , format: "coo", dtype: int-like -def diags_array( - diagonals: onp.ToFloat1D | onp.ToFloat2D, - /, - *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, - shape: _ToShape2D | None = None, - format: _FmtCOO, - dtype: onp.AnyIntDType, -) -> _COOArray2D[np.int_]: ... -@overload # diagonals: , format: "coo", dtype: complex128-like +@overload # diagonals: , format: "coo", dtype: def diags_array( - diagonals: onp.ToFloat1D | onp.ToFloat2D, + diagonals: onp.ToComplex1D | onp.ToComplex2D, /, *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCOO, - dtype: onp.AnyComplex128DType, -) -> _COOArray2D[np.complex128]: ... -@overload # diagonals: , format: "coo", dtype: complex128-like + dtype: onp.ToDType[_SCT], +) -> _COOArray2D[_SCT]: ... +@overload # diagonals: , format: "coo", dtype: def diags_array( diagonals: onp.ToComplex1D | onp.ToComplex2D, /, *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCOO, - dtype: onp.AnyComplex128DType, -) -> _COOArray2D[np.complex128]: ... + dtype: npt.DTypeLike, +) -> _COOArray2D: ... # CSC @overload # diagonals: , format: "csc", dtype: None def diags_array( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], - /, - *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, - shape: _ToShape2D | None = None, - format: _FmtCSC, - dtype: None = None, + diagonals: _Diag[_SCT], /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCSC, dtype: None = None ) -> _CSCArray[_SCT]: ... @overload # diagonals: , format: "csc", dtype: bool-like def diags_array( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], - /, - *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, - shape: _ToShape2D | None = None, - format: _FmtCSC, - dtype: onp.AnyBoolDType, + diagonals: _Diag[_SCT], /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCSC, dtype: onp.AnyBoolDType ) -> _CSCArray[np.bool_]: ... @overload # diagonals: , format: "csc", dtype: int-like def diags_array( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], - /, - *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, - shape: _ToShape2D | None = None, - format: _FmtCSC, - dtype: onp.AnyIntDType, + diagonals: _Diag[_SCT], /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCSC, dtype: onp.AnyIntDType ) -> _CSCArray[np.int_]: ... @overload # diagonals: , format: "csc", dtype: float64-like def diags_array( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + diagonals: _Diag[_SCT], /, *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCSC, dtype: _AnyFloat64DTypeNotNone, ) -> _CSCArray[np.float64]: ... @overload # diagonals: , format: "csc", dtype: complex128-like def diags_array( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + diagonals: _Diag[_SCT], /, *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, - shape: _ToShape2D | None = None, - format: _FmtCSC, - dtype: onp.AnyComplex128DType, -) -> _CSCArray[np.complex128]: ... -@overload # diagonals: , format: "csc", dtype: float64-like -def diags_array( - diagonals: onp.ToFloat1D | onp.ToFloat2D, - /, - *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, - shape: _ToShape2D | None = None, - format: _FmtCSC, - dtype: _AnyFloat64DTypeNotNone, -) -> _CSCArray[np.float64]: ... -@overload # diagonals: , format: "csc", dtype: bool-like -def diags_array( - diagonals: onp.ToFloat1D | onp.ToFloat2D, - /, - *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, - shape: _ToShape2D | None = None, - format: _FmtCSC, - dtype: onp.AnyBoolDType, -) -> _CSCArray[np.bool_]: ... -@overload # diagonals: , format: "csc", dtype: int-like -def diags_array( - diagonals: onp.ToFloat1D | onp.ToFloat2D, - /, - *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, - shape: _ToShape2D | None = None, - format: _FmtCSC, - dtype: onp.AnyIntDType, -) -> _CSCArray[np.int_]: ... -@overload # diagonals: , format: "csc", dtype: complex128-like -def diags_array( - diagonals: onp.ToFloat1D | onp.ToFloat2D, - /, - *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, - shape: _ToShape2D | None = None, - format: _FmtCSC, - dtype: onp.AnyComplex128DType, -) -> _CSCArray[np.complex128]: ... -@overload # diagonals: , format: "csc", dtype: complex128-like -def diags_array( - diagonals: onp.ToComplex1D | onp.ToComplex2D, - /, - *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCSC, dtype: onp.AnyComplex128DType, @@ -541,7 +308,7 @@ def diags_array( diagonals: onp.ToComplex1D | onp.ToComplex2D, /, *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCSC, dtype: onp.ToDType[_SCT], @@ -551,7 +318,7 @@ def diags_array( diagonals: onp.ToComplex1D | onp.ToComplex2D, /, *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCSC, dtype: npt.DTypeLike, @@ -560,100 +327,32 @@ def diags_array( # CSR @overload # diagonals: , format: "csr", dtype: None def diags_array( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], - /, - *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, - shape: _ToShape2D | None = None, - format: _FmtCSR, - dtype: None = None, + diagonals: _Diag[_SCT], /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCSR, dtype: None = None ) -> _CSRArray2D[_SCT]: ... @overload # diagonals: , format: "csr", dtype: bool-like def diags_array( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], - /, - *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, - shape: _ToShape2D | None = None, - format: _FmtCSR, - dtype: onp.AnyBoolDType, + diagonals: _Diag[_SCT], /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCSR, dtype: onp.AnyBoolDType ) -> _CSRArray2D[np.bool_]: ... @overload # diagonals: , format: "csr", dtype: int-like def diags_array( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], - /, - *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, - shape: _ToShape2D | None = None, - format: _FmtCSR, - dtype: onp.AnyIntDType, + diagonals: _Diag[_SCT], /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCSR, dtype: onp.AnyIntDType ) -> _CSRArray2D[np.int_]: ... @overload # diagonals: , format: "csr", dtype: float64-like def diags_array( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + diagonals: _Diag[_SCT], /, *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCSR, dtype: _AnyFloat64DTypeNotNone, ) -> _CSRArray2D[np.float64]: ... @overload # diagonals: , format: "csr", dtype: complex128-like def diags_array( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], - /, - *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, - shape: _ToShape2D | None = None, - format: _FmtCSR, - dtype: onp.AnyComplex128DType, -) -> _CSRArray2D[np.complex128]: ... -@overload # diagonals: , format: "csr", dtype: float64-like -def diags_array( - diagonals: onp.ToFloat1D | onp.ToFloat2D, - /, - *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, - shape: _ToShape2D | None = None, - format: _FmtCSR, - dtype: _AnyFloat64DTypeNotNone, -) -> _CSRArray2D[np.float64]: ... -@overload # diagonals: , format: "csr", dtype: bool-like -def diags_array( - diagonals: onp.ToFloat1D | onp.ToFloat2D, + diagonals: _Diag[_SCT], /, *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, - shape: _ToShape2D | None = None, - format: _FmtCSR, - dtype: onp.AnyBoolDType, -) -> _CSRArray2D[np.bool_]: ... -@overload # diagonals: , format: "csr", dtype: int-like -def diags_array( - diagonals: onp.ToFloat1D | onp.ToFloat2D, - /, - *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, - shape: _ToShape2D | None = None, - format: _FmtCSR, - dtype: onp.AnyIntDType, -) -> _CSRArray2D[np.int_]: ... -@overload # diagonals: , format: "csr", dtype: complex128-like -def diags_array( - diagonals: onp.ToFloat1D | onp.ToFloat2D, - /, - *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, - shape: _ToShape2D | None = None, - format: _FmtCSR, - dtype: onp.AnyComplex128DType, -) -> _CSRArray2D[np.complex128]: ... -@overload # diagonals: , format: "csr", dtype: complex128-like -def diags_array( - diagonals: onp.ToComplex1D | onp.ToComplex2D, - /, - *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCSR, dtype: onp.AnyComplex128DType, @@ -663,7 +362,7 @@ def diags_array( diagonals: onp.ToComplex1D | onp.ToComplex2D, /, *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCSR, dtype: onp.ToDType[_SCT], @@ -673,7 +372,7 @@ def diags_array( diagonals: onp.ToComplex1D | onp.ToComplex2D, /, *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCSR, dtype: npt.DTypeLike, @@ -682,100 +381,32 @@ def diags_array( # DOK @overload # diagonals: , format: "dok", dtype: None def diags_array( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], - /, - *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, - shape: _ToShape2D | None = None, - format: _FmtDOK, - dtype: None = None, + diagonals: _Diag[_SCT], /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtDOK, dtype: None = None ) -> _DOKArray2D[_SCT]: ... @overload # diagonals: , format: "dok", dtype: bool-like def diags_array( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], - /, - *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, - shape: _ToShape2D | None = None, - format: _FmtDOK, - dtype: onp.AnyBoolDType, + diagonals: _Diag[_SCT], /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtDOK, dtype: onp.AnyBoolDType ) -> _DOKArray2D[np.bool_]: ... @overload # diagonals: , format: "dok", dtype: int-like def diags_array( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], - /, - *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, - shape: _ToShape2D | None = None, - format: _FmtDOK, - dtype: onp.AnyIntDType, + diagonals: _Diag[_SCT], /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtDOK, dtype: onp.AnyIntDType ) -> _DOKArray2D[np.int_]: ... @overload # diagonals: , format: "dok", dtype: float64-like def diags_array( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + diagonals: _Diag[_SCT], /, *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtDOK, dtype: _AnyFloat64DTypeNotNone, ) -> _DOKArray2D[np.float64]: ... @overload # diagonals: , format: "dok", dtype: complex128-like def diags_array( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + diagonals: _Diag[_SCT], /, *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, - shape: _ToShape2D | None = None, - format: _FmtDOK, - dtype: onp.AnyComplex128DType, -) -> _DOKArray2D[np.complex128]: ... -@overload # diagonals: , format: "dok", dtype: float64-like -def diags_array( - diagonals: onp.ToFloat1D | onp.ToFloat2D, - /, - *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, - shape: _ToShape2D | None = None, - format: _FmtDOK, - dtype: _AnyFloat64DTypeNotNone, -) -> _DOKArray2D[np.float64]: ... -@overload # diagonals: , format: "dok", dtype: bool-like -def diags_array( - diagonals: onp.ToFloat1D | onp.ToFloat2D, - /, - *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, - shape: _ToShape2D | None = None, - format: _FmtDOK, - dtype: onp.AnyBoolDType, -) -> _DOKArray2D[np.bool_]: ... -@overload # diagonals: , format: "dok", dtype: int-like -def diags_array( - diagonals: onp.ToFloat1D | onp.ToFloat2D, - /, - *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, - shape: _ToShape2D | None = None, - format: _FmtDOK, - dtype: onp.AnyIntDType, -) -> _DOKArray2D[np.int_]: ... -@overload # diagonals: , format: "dok", dtype: complex128-like -def diags_array( - diagonals: onp.ToFloat1D | onp.ToFloat2D, - /, - *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, - shape: _ToShape2D | None = None, - format: _FmtDOK, - dtype: onp.AnyComplex128DType, -) -> _DOKArray2D[np.complex128]: ... -@overload # diagonals: , format: "dok", dtype: complex128-like -def diags_array( - diagonals: onp.ToComplex1D | onp.ToComplex2D, - /, - *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtDOK, dtype: onp.AnyComplex128DType, @@ -785,7 +416,7 @@ def diags_array( diagonals: onp.ToComplex1D | onp.ToComplex2D, /, *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtDOK, dtype: onp.ToDType[_SCT], @@ -795,7 +426,7 @@ def diags_array( diagonals: onp.ToComplex1D | onp.ToComplex2D, /, *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtDOK, dtype: npt.DTypeLike, @@ -804,100 +435,32 @@ def diags_array( # LIL @overload # diagonals: , format: "lil", dtype: None def diags_array( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], - /, - *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, - shape: _ToShape2D | None = None, - format: _FmtLIL, - dtype: None = None, + diagonals: _Diag[_SCT], /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtLIL, dtype: None = None ) -> _LILArray[_SCT]: ... -@overload # diagonals: , format: "lil", dtype: bool-like -def diags_array( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], - /, - *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, - shape: _ToShape2D | None = None, - format: _FmtLIL, - dtype: onp.AnyBoolDType, -) -> _LILArray[np.bool_]: ... -@overload # diagonals: , format: "lil", dtype: int-like -def diags_array( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], - /, - *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, - shape: _ToShape2D | None = None, - format: _FmtLIL, - dtype: onp.AnyIntDType, -) -> _LILArray[np.int_]: ... -@overload # diagonals: , format: "lil", dtype: float64-like -def diags_array( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], - /, - *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, - shape: _ToShape2D | None = None, - format: _FmtLIL, - dtype: _AnyFloat64DTypeNotNone, -) -> _LILArray[np.float64]: ... -@overload # diagonals: , format: "lil", dtype: complex128-like -def diags_array( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], - /, - *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, - shape: _ToShape2D | None = None, - format: _FmtLIL, - dtype: onp.AnyComplex128DType, -) -> _LILArray[np.complex128]: ... -@overload # diagonals: , format: "lil", dtype: float64-like -def diags_array( - diagonals: onp.ToFloat1D | onp.ToFloat2D, - /, - *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, - shape: _ToShape2D | None = None, - format: _FmtLIL, - dtype: _AnyFloat64DTypeNotNone, -) -> _LILArray[np.float64]: ... -@overload # diagonals: , format: "lil", dtype: bool-like +@overload # diagonals: , format: "lil", dtype: bool-like def diags_array( - diagonals: onp.ToFloat1D | onp.ToFloat2D, - /, - *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, - shape: _ToShape2D | None = None, - format: _FmtLIL, - dtype: onp.AnyBoolDType, + diagonals: _Diag[_SCT], /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtLIL, dtype: onp.AnyBoolDType ) -> _LILArray[np.bool_]: ... -@overload # diagonals: , format: "lil", dtype: int-like +@overload # diagonals: , format: "lil", dtype: int-like def diags_array( - diagonals: onp.ToFloat1D | onp.ToFloat2D, - /, - *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, - shape: _ToShape2D | None = None, - format: _FmtLIL, - dtype: onp.AnyIntDType, + diagonals: _Diag[_SCT], /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtLIL, dtype: onp.AnyIntDType ) -> _LILArray[np.int_]: ... -@overload # diagonals: , format: "lil", dtype: complex128-like +@overload # diagonals: , format: "lil", dtype: float64-like def diags_array( - diagonals: onp.ToFloat1D | onp.ToFloat2D, + diagonals: _Diag[_SCT], /, *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtLIL, - dtype: onp.AnyComplex128DType, -) -> _LILArray[np.complex128]: ... -@overload # diagonals: , format: "lil", dtype: complex128-like + dtype: _AnyFloat64DTypeNotNone, +) -> _LILArray[np.float64]: ... +@overload # diagonals: , format: "lil", dtype: complex128-like def diags_array( - diagonals: onp.ToComplex1D | onp.ToComplex2D, + diagonals: _Diag[_SCT], /, *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtLIL, dtype: onp.AnyComplex128DType, @@ -907,7 +470,7 @@ def diags_array( diagonals: onp.ToComplex1D | onp.ToComplex2D, /, *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtLIL, dtype: onp.ToDType[_SCT], @@ -917,7 +480,7 @@ def diags_array( diagonals: onp.ToComplex1D | onp.ToComplex2D, /, *, - offsets: onp.ToInt | onp.ToIntStrict1D = 0, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtLIL, dtype: npt.DTypeLike, @@ -926,7 +489,7 @@ def diags_array( # NOTE: `diags_array` should be prefered over `diags` @overload # diagonals: , format: {"dia", None} = ... def diags( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + diagonals: _Diag[_SCT], offsets: onp.ToInt | onp.ToInt1D = 0, shape: _ToShape2D | None = None, format: _FmtDIA | None = None, @@ -934,7 +497,7 @@ def diags( ) -> dia_matrix[_SCT]: ... @overload # diagonals: , format: "bsr" (positional) def diags( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + diagonals: _Diag[_SCT], offsets: onp.ToInt | onp.ToInt1D, shape: _ToShape2D | None, format: _FmtBSR, @@ -942,7 +505,7 @@ def diags( ) -> bsr_matrix[_SCT]: ... @overload # diagonals: , format: "bsr" (keyword) def diags( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + diagonals: _Diag[_SCT], offsets: onp.ToInt | onp.ToInt1D = 0, shape: _ToShape2D | None = None, *, @@ -951,7 +514,7 @@ def diags( ) -> bsr_matrix[_SCT]: ... @overload # diagonals: , format: "coo" (positional) def diags( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + diagonals: _Diag[_SCT], offsets: onp.ToInt | onp.ToInt1D, shape: _ToShape2D | None, format: _FmtCOO, @@ -959,7 +522,7 @@ def diags( ) -> coo_matrix[_SCT]: ... @overload # diagonals: , format: "coo" (keyword) def diags( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + diagonals: _Diag[_SCT], offsets: onp.ToInt | onp.ToInt1D = 0, shape: _ToShape2D | None = None, *, @@ -968,7 +531,7 @@ def diags( ) -> coo_matrix[_SCT]: ... @overload # diagonals: , format: "csr" (positional) def diags( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + diagonals: _Diag[_SCT], offsets: onp.ToInt | onp.ToInt1D, shape: _ToShape2D | None, format: _FmtCSR, @@ -976,7 +539,7 @@ def diags( ) -> csr_matrix[_SCT]: ... @overload # diagonals: , format: "csr" (keyword) def diags( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + diagonals: _Diag[_SCT], offsets: onp.ToInt | onp.ToInt1D = 0, shape: _ToShape2D | None = None, *, @@ -985,7 +548,7 @@ def diags( ) -> csr_matrix[_SCT]: ... @overload # diagonals: , format: "csc" (positional) def diags( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + diagonals: _Diag[_SCT], offsets: onp.ToInt | onp.ToInt1D, shape: _ToShape2D | None, format: _FmtCSC, @@ -993,7 +556,7 @@ def diags( ) -> csc_matrix[_SCT]: ... @overload # diagonals: , format: "csc" (keyword) def diags( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + diagonals: _Diag[_SCT], offsets: onp.ToInt | onp.ToInt1D = 0, shape: _ToShape2D | None = None, *, @@ -1002,7 +565,7 @@ def diags( ) -> csc_matrix[_SCT]: ... @overload # diagonals: , format: "dok" (positional) def diags( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + diagonals: _Diag[_SCT], offsets: onp.ToInt | onp.ToInt1D, shape: _ToShape2D | None, format: _FmtDOK, @@ -1010,7 +573,7 @@ def diags( ) -> dok_matrix[_SCT]: ... @overload # diagonals: , format: "dok" (keyword) def diags( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + diagonals: _Diag[_SCT], offsets: onp.ToInt | onp.ToInt1D = 0, shape: _ToShape2D | None = None, *, @@ -1019,7 +582,7 @@ def diags( ) -> dok_matrix[_SCT]: ... @overload # diagonals: , format: "lil" (positional) def diags( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + diagonals: _Diag[_SCT], offsets: onp.ToInt | onp.ToInt1D, shape: _ToShape2D | None, format: _FmtLIL, @@ -1027,132 +590,13 @@ def diags( ) -> lil_matrix[_SCT]: ... @overload # diagonals: , format: "lil" (keyword) def diags( - diagonals: _ToArray1D[_SCT] | _ToArray2D[_SCT], + diagonals: _Diag[_SCT], offsets: onp.ToInt | onp.ToInt1D = 0, shape: _ToShape2D | None = None, *, format: _FmtLIL, dtype: onp.ToDType[_SCT] | None = None, ) -> lil_matrix[_SCT]: ... -@overload # diagonals: , format: {"dia", None} = ..., dtype: (positional) -def diags( - diagonals: onp.ToComplex1D | onp.ToComplex2D, - offsets: onp.ToInt | onp.ToInt1D, - shape: _ToShape2D | None, - format: _FmtDIA | None, - dtype: onp.ToDType[_SCT], -) -> dia_matrix[_SCT]: ... -@overload # diagonals: , format: {"dia", None} = ..., dtype: (keyword) -def diags( - diagonals: onp.ToComplex1D | onp.ToComplex2D, - offsets: onp.ToInt | onp.ToInt1D = 0, - shape: _ToShape2D | None = None, - format: _FmtDIA | None = None, - *, - dtype: onp.ToDType[_SCT], -) -> dia_matrix[_SCT]: ... -@overload # diagonals: , format: "bsr" (positional), dtype: -def diags( - diagonals: onp.ToComplex1D | onp.ToComplex2D, - offsets: onp.ToInt | onp.ToInt1D, - shape: _ToShape2D | None, - format: _FmtBSR, - dtype: onp.ToDType[_SCT], -) -> bsr_matrix[_SCT]: ... -@overload # diagonals: , format: "bsr" (keyword), dtype: -def diags( - diagonals: onp.ToComplex1D | onp.ToComplex2D, - offsets: onp.ToInt | onp.ToInt1D = 0, - shape: _ToShape2D | None = None, - *, - format: _FmtBSR, - dtype: onp.ToDType[_SCT], -) -> bsr_matrix[_SCT]: ... -@overload # diagonals: , format: "coo" (positional), dtype: -def diags( - diagonals: onp.ToComplex1D | onp.ToComplex2D, - offsets: onp.ToInt | onp.ToInt1D, - shape: _ToShape2D | None, - format: _FmtCOO, - dtype: onp.ToDType[_SCT], -) -> coo_matrix[_SCT]: ... -@overload # diagonals: , format: "coo" (keyword), dtype: -def diags( - diagonals: onp.ToComplex1D | onp.ToComplex2D, - offsets: onp.ToInt | onp.ToInt1D = 0, - shape: _ToShape2D | None = None, - *, - format: _FmtCOO, - dtype: onp.ToDType[_SCT], -) -> coo_matrix[_SCT]: ... -@overload # diagonals: , format: "csr" (positional), dtype: -def diags( - diagonals: onp.ToComplex1D | onp.ToComplex2D, - offsets: onp.ToInt | onp.ToInt1D, - shape: _ToShape2D | None, - format: _FmtCSR, - dtype: onp.ToDType[_SCT], -) -> csr_matrix[_SCT]: ... -@overload # diagonals: , format: "csr" (keyword), dtype: -def diags( - diagonals: onp.ToComplex1D | onp.ToComplex2D, - offsets: onp.ToInt | onp.ToInt1D = 0, - shape: _ToShape2D | None = None, - *, - format: _FmtCSR, - dtype: onp.ToDType[_SCT], -) -> csr_matrix[_SCT]: ... -@overload # diagonals: , format: "csc" (positional), dtype: -def diags( - diagonals: onp.ToComplex1D | onp.ToComplex2D, - offsets: onp.ToInt | onp.ToInt1D, - shape: _ToShape2D | None, - format: _FmtCSC, - dtype: onp.ToDType[_SCT], -) -> csc_matrix[_SCT]: ... -@overload # diagonals: , format: "csc" (keyword), dtype: -def diags( - diagonals: onp.ToComplex1D | onp.ToComplex2D, - offsets: onp.ToInt | onp.ToInt1D = 0, - shape: _ToShape2D | None = None, - *, - format: _FmtCSC, - dtype: onp.ToDType[_SCT], -) -> csc_matrix[_SCT]: ... -@overload # diagonals: , format: "dok" (positional), dtype: -def diags( - diagonals: onp.ToComplex1D | onp.ToComplex2D, - offsets: onp.ToInt | onp.ToInt1D, - shape: _ToShape2D | None, - format: _FmtDOK, - dtype: onp.ToDType[_SCT], -) -> dok_matrix[_SCT]: ... -@overload # diagonals: , format: "dok" (keyword), dtype: -def diags( - diagonals: onp.ToComplex1D | onp.ToComplex2D, - offsets: onp.ToInt | onp.ToInt1D = 0, - shape: _ToShape2D | None = None, - *, - format: _FmtDOK, - dtype: onp.ToDType[_SCT], -) -> dok_matrix[_SCT]: ... -@overload # diagonals: , format: "lil" (positional), dtype: -def diags( - diagonals: onp.ToComplex1D | onp.ToComplex2D, - offsets: onp.ToInt | onp.ToInt1D, - shape: _ToShape2D | None, - format: _FmtLIL, - dtype: onp.ToDType[_SCT], -) -> lil_matrix[_SCT]: ... -@overload # diagonals: , format: "lil" (keyword), dtype: -def diags( - diagonals: onp.ToComplex1D | onp.ToComplex2D, - offsets: onp.ToInt | onp.ToInt1D = 0, - shape: _ToShape2D | None = None, - *, - format: _FmtLIL, - dtype: onp.ToDType[_SCT], -) -> lil_matrix[_SCT]: ... @overload # diagonals: , format: {"dia", None} = ..., dtype: def diags( diagonals: onp.ToComplex1D | onp.ToComplex2D, @@ -1267,15 +711,11 @@ def diags( # NOTE: `diags_array` should be prefered over `spdiags` @overload def spdiags( - data: _ToArray1D[_SCT] | _ToArray2D[_SCT], - diags: onp.ToInt | onp.ToInt1D, - m: onp.ToJustInt, - n: onp.ToJustInt, - format: _FmtDIA | None = None, + data: _Diag[_SCT], diags: onp.ToInt | onp.ToInt1D, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtDIA | None = None ) -> dia_matrix[_SCT]: ... @overload def spdiags( - data: _ToArray1D[_SCT] | _ToArray2D[_SCT], + data: _Diag[_SCT], diags: onp.ToInt | onp.ToInt1D, m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, n: None = None, @@ -1283,11 +723,11 @@ def spdiags( ) -> dia_matrix[_SCT]: ... @overload def spdiags( - data: _ToArray1D[_SCT] | _ToArray2D[_SCT], diags: onp.ToInt | onp.ToInt1D, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtBSR + data: _Diag[_SCT], diags: onp.ToInt | onp.ToInt1D, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtBSR ) -> bsr_matrix[_SCT]: ... @overload def spdiags( - data: _ToArray1D[_SCT] | _ToArray2D[_SCT], + data: _Diag[_SCT], diags: onp.ToInt | onp.ToInt1D, m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, n: None = None, @@ -1296,11 +736,11 @@ def spdiags( ) -> bsr_matrix[_SCT]: ... @overload def spdiags( - data: _ToArray1D[_SCT] | _ToArray2D[_SCT], diags: onp.ToInt | onp.ToInt1D, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtCOO + data: _Diag[_SCT], diags: onp.ToInt | onp.ToInt1D, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtCOO ) -> coo_matrix[_SCT]: ... @overload def spdiags( - data: _ToArray1D[_SCT] | _ToArray2D[_SCT], + data: _Diag[_SCT], diags: onp.ToInt | onp.ToInt1D, m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, n: None = None, @@ -1309,11 +749,11 @@ def spdiags( ) -> coo_matrix[_SCT]: ... @overload def spdiags( - data: _ToArray1D[_SCT] | _ToArray2D[_SCT], diags: onp.ToInt | onp.ToInt1D, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtCSR + data: _Diag[_SCT], diags: onp.ToInt | onp.ToInt1D, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtCSR ) -> csr_matrix[_SCT]: ... @overload def spdiags( - data: _ToArray1D[_SCT] | _ToArray2D[_SCT], + data: _Diag[_SCT], diags: onp.ToInt | onp.ToInt1D, m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, n: None = None, @@ -1322,11 +762,11 @@ def spdiags( ) -> csr_matrix[_SCT]: ... @overload def spdiags( - data: _ToArray1D[_SCT] | _ToArray2D[_SCT], diags: onp.ToInt | onp.ToInt1D, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtCSC + data: _Diag[_SCT], diags: onp.ToInt | onp.ToInt1D, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtCSC ) -> csc_matrix[_SCT]: ... @overload def spdiags( - data: _ToArray1D[_SCT] | _ToArray2D[_SCT], + data: _Diag[_SCT], diags: onp.ToInt | onp.ToInt1D, m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, n: None = None, @@ -1335,11 +775,11 @@ def spdiags( ) -> csc_matrix[_SCT]: ... @overload def spdiags( - data: _ToArray1D[_SCT] | _ToArray2D[_SCT], diags: onp.ToInt | onp.ToInt1D, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtDOK + data: _Diag[_SCT], diags: onp.ToInt | onp.ToInt1D, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtDOK ) -> dok_matrix[_SCT]: ... @overload def spdiags( - data: _ToArray1D[_SCT] | _ToArray2D[_SCT], + data: _Diag[_SCT], diags: onp.ToInt | onp.ToInt1D, m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, n: None = None, @@ -1348,112 +788,17 @@ def spdiags( ) -> dok_matrix[_SCT]: ... @overload def spdiags( - data: _ToArray1D[_SCT] | _ToArray2D[_SCT], diags: onp.ToInt | onp.ToInt1D, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtLIL + data: _Diag[_SCT], diags: onp.ToInt | onp.ToInt1D, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtLIL ) -> lil_matrix[_SCT]: ... @overload def spdiags( - data: _ToArray1D[_SCT] | _ToArray2D[_SCT], + data: _Diag[_SCT], diags: onp.ToInt | onp.ToInt1D, m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, n: None = None, *, format: _FmtLIL, ) -> lil_matrix[_SCT]: ... -@overload -def spdiags( - data: onp.ToComplex1D | onp.ToComplex2D, - diags: onp.ToInt | onp.ToInt1D, - m: onp.ToJustInt, - n: onp.ToJustInt, - format: _FmtDIA | None = None, -) -> dia_matrix: ... -@overload -def spdiags( - data: onp.ToComplex1D | onp.ToComplex2D, - diags: onp.ToInt | onp.ToInt1D, - m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, - n: None = None, - *, - format: _FmtDIA | None = None, -) -> dia_matrix: ... -@overload -def spdiags( - data: onp.ToComplex1D | onp.ToComplex2D, diags: onp.ToInt | onp.ToInt1D, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtBSR -) -> bsr_matrix: ... -@overload -def spdiags( - data: onp.ToComplex1D | onp.ToComplex2D, - diags: onp.ToInt | onp.ToInt1D, - m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, - n: None = None, - *, - format: _FmtBSR, -) -> bsr_matrix: ... -@overload -def spdiags( - data: onp.ToComplex1D | onp.ToComplex2D, diags: onp.ToInt | onp.ToInt1D, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtCOO -) -> coo_matrix: ... -@overload -def spdiags( - data: onp.ToComplex1D | onp.ToComplex2D, - diags: onp.ToInt | onp.ToInt1D, - m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, - n: None = None, - *, - format: _FmtCOO, -) -> coo_matrix: ... -@overload -def spdiags( - data: onp.ToComplex1D | onp.ToComplex2D, diags: onp.ToInt | onp.ToInt1D, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtCSR -) -> csr_matrix: ... -@overload -def spdiags( - data: onp.ToComplex1D | onp.ToComplex2D, - diags: onp.ToInt | onp.ToInt1D, - m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, - n: None = None, - *, - format: _FmtCSR, -) -> csr_matrix: ... -@overload -def spdiags( - data: onp.ToComplex1D | onp.ToComplex2D, diags: onp.ToInt | onp.ToInt1D, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtCSC -) -> csc_matrix: ... -@overload -def spdiags( - data: onp.ToComplex1D | onp.ToComplex2D, - diags: onp.ToInt | onp.ToInt1D, - m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, - n: None = None, - *, - format: _FmtCSC, -) -> csc_matrix: ... -@overload -def spdiags( - data: onp.ToComplex1D | onp.ToComplex2D, diags: onp.ToInt | onp.ToInt1D, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtDOK -) -> dok_matrix: ... -@overload -def spdiags( - data: onp.ToComplex1D | onp.ToComplex2D, - diags: onp.ToInt | onp.ToInt1D, - m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, - n: None = None, - *, - format: _FmtDOK, -) -> dok_matrix: ... -@overload -def spdiags( - data: onp.ToComplex1D | onp.ToComplex2D, diags: onp.ToInt | onp.ToInt1D, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtLIL -) -> lil_matrix: ... -@overload -def spdiags( - data: onp.ToComplex1D | onp.ToComplex2D, - diags: onp.ToInt | onp.ToInt1D, - m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, - n: None = None, - *, - format: _FmtLIL, -) -> lil_matrix: ... # @overload # dtype like bool, format: None = ... @@ -1468,18 +813,6 @@ def identity(n: opt.AnyInt, dtype: onp.AnyComplex128DType, format: _FmtDIA | Non def identity(n: opt.AnyInt, dtype: onp.ToDType[_SCT], format: _FmtDIA | None = None) -> dia_matrix[_SCT]: ... @overload # dtype like , format: None = ... def identity(n: opt.AnyInt, dtype: npt.DTypeLike, format: _FmtDIA | None = None) -> dia_matrix[Incomplete]: ... -@overload # dtype like float, format: "bsr" (positional) -def identity(n: opt.AnyInt, dtype: onp.AnyFloat64DType, format: _FmtBSR) -> bsr_matrix[np.float64]: ... -@overload # dtype like float, format: "coo" (positional) -def identity(n: opt.AnyInt, dtype: onp.AnyFloat64DType, format: _FmtCOO) -> coo_matrix[np.float64]: ... -@overload # dtype like float, format: "csc" (positional) -def identity(n: opt.AnyInt, dtype: onp.AnyFloat64DType, format: _FmtCSC) -> csc_matrix[np.float64]: ... -@overload # dtype like float, format: "csr" (positional) -def identity(n: opt.AnyInt, dtype: onp.AnyFloat64DType, format: _FmtCSR) -> csr_matrix[np.float64]: ... -@overload # dtype like float, format: "dok" (positional) -def identity(n: opt.AnyInt, dtype: onp.AnyFloat64DType, format: _FmtDOK) -> dok_matrix[np.float64]: ... -@overload # dtype like float, format: "lil" (positional) -def identity(n: opt.AnyInt, dtype: onp.AnyFloat64DType, format: _FmtLIL) -> lil_matrix[np.float64]: ... @overload # dtype like float (default), format: "bsr" (keyword) def identity(n: opt.AnyInt, dtype: onp.AnyFloat64DType = "d", *, format: _FmtBSR) -> bsr_matrix[np.float64]: ... @overload # dtype like float (default), format: "coo" (keyword) @@ -1728,43 +1061,23 @@ def eye_array( def eye( m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, dtype: onp.AnyFloat64DType = ..., format: _FmtDIA | None = None ) -> dia_matrix[np.float64]: ... -@overload # dtype like bool (positional), default format -def eye( - m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.AnyBoolDType, format: _FmtDIA | None = None -) -> dia_matrix[np.bool_]: ... -@overload # dtype like bool (keyword), default format +@overload # dtype like bool, default format def eye( m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyBoolDType, format: _FmtDIA | None = None ) -> dia_matrix[np.bool_]: ... -@overload # dtype like int (positional), default format -def eye( - m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.AnyIntDType, format: _FmtDIA | None = None -) -> dia_matrix[np.int_]: ... -@overload # dtype like int (keyword), default format +@overload # dtype like int, default format def eye( m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyIntDType, format: _FmtDIA | None = None ) -> dia_matrix[np.int_]: ... -@overload # dtype like complex (positional), default format -def eye( - m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.AnyComplex128DType, format: _FmtDIA | None = None -) -> dia_matrix[np.complex128]: ... -@overload # dtype like complex (keyword), default format +@overload # dtype like complex, default format def eye( m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyComplex128DType, format: _FmtDIA | None = None ) -> dia_matrix[np.complex128]: ... -@overload # dtype like (positional), default format -def eye( - m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.ToDType[_SCT], format: _FmtDIA | None = None -) -> dia_matrix[_SCT]: ... -@overload # dtype like (keyword), default format +@overload # dtype like , default format def eye( m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.ToDType[_SCT], format: _FmtDIA | None = None ) -> dia_matrix[_SCT]: ... -@overload # dtype like (positional), default format -def eye( - m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: npt.DTypeLike, format: _FmtDIA | None = None -) -> dia_matrix[Incomplete]: ... -@overload # dtype like (keyword), default format +@overload # dtype like , default format def eye( m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: npt.DTypeLike, format: _FmtDIA | None = None ) -> dia_matrix[Incomplete]: ... @@ -1772,35 +1085,23 @@ def eye( def eye( m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, dtype: onp.AnyFloat64DType = ..., *, format: _FmtBSR ) -> bsr_matrix[np.float64]: ... -@overload # dtype like bool (positional), format: "bsr" -def eye(m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.AnyBoolDType, format: _FmtBSR) -> bsr_matrix[np.bool_]: ... -@overload # dtype like bool (keyword), format: "bsr" +@overload # dtype like bool, format: "bsr" def eye( m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyBoolDType, format: _FmtBSR ) -> bsr_matrix[np.bool_]: ... -@overload # dtype like int (positional), format: "bsr" -def eye(m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.AnyIntDType, format: _FmtBSR) -> bsr_matrix[np.int_]: ... -@overload # dtype like int (keyword), format: "bsr" +@overload # dtype like int, format: "bsr" def eye( m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyIntDType, format: _FmtBSR ) -> bsr_matrix[np.int_]: ... -@overload # dtype like complex (positional), format: "bsr" -def eye( - m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.AnyComplex128DType, format: _FmtBSR -) -> bsr_matrix[np.complex128]: ... -@overload # dtype like complex (keyword), format: "bsr" +@overload # dtype like complex, format: "bsr" def eye( m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyComplex128DType, format: _FmtBSR ) -> bsr_matrix[np.complex128]: ... -@overload # dtype like (positional), format: "bsr" -def eye(m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.ToDType[_SCT], format: _FmtBSR) -> bsr_matrix[_SCT]: ... -@overload # dtype like (keyword), format: "bsr" +@overload # dtype like , format: "bsr" def eye( m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.ToDType[_SCT], format: _FmtBSR ) -> bsr_matrix[_SCT]: ... -@overload # dtype like (positional), format: "bsr" -def eye(m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: npt.DTypeLike, format: _FmtBSR) -> bsr_matrix[Incomplete]: ... -@overload # dtype like (keyword), format: "bsr" +@overload # dtype like , format: "bsr" def eye( m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: npt.DTypeLike, format: _FmtBSR ) -> bsr_matrix[Incomplete]: ... @@ -1808,35 +1109,23 @@ def eye( def eye( m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, dtype: onp.AnyFloat64DType = ..., *, format: _FmtCOO ) -> coo_matrix[np.float64]: ... -@overload # dtype like bool (positional), format: "coo" -def eye(m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.AnyBoolDType, format: _FmtCOO) -> coo_matrix[np.bool_]: ... -@overload # dtype like bool (keyword), format: "coo" +@overload # dtype like bool, format: "coo" def eye( m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyBoolDType, format: _FmtCOO ) -> coo_matrix[np.bool_]: ... -@overload # dtype like int (positional), format: "coo" -def eye(m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.AnyIntDType, format: _FmtCOO) -> coo_matrix[np.int_]: ... -@overload # dtype like int (keyword), format: "coo" +@overload # dtype like int, format: "coo" def eye( m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyIntDType, format: _FmtCOO ) -> coo_matrix[np.int_]: ... -@overload # dtype like complex (positional), format: "coo" -def eye( - m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.AnyComplex128DType, format: _FmtCOO -) -> coo_matrix[np.complex128]: ... -@overload # dtype like complex (keyword), format: "coo" +@overload # dtype like complex, format: "coo" def eye( m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyComplex128DType, format: _FmtCOO ) -> coo_matrix[np.complex128]: ... -@overload # dtype like (positional), format: "coo" -def eye(m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.ToDType[_SCT], format: _FmtCOO) -> coo_matrix[_SCT]: ... -@overload # dtype like (keyword), format: "coo" +@overload # dtype like , format: "coo" def eye( m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.ToDType[_SCT], format: _FmtCOO ) -> coo_matrix[_SCT]: ... -@overload # dtype like (positional), format: "coo" -def eye(m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: npt.DTypeLike, format: _FmtCOO) -> coo_matrix[Incomplete]: ... -@overload # dtype like (keyword), format: "coo" +@overload # dtype like , format: "coo" def eye( m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: npt.DTypeLike, format: _FmtCOO ) -> coo_matrix[Incomplete]: ... @@ -1844,35 +1133,23 @@ def eye( def eye( m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, dtype: onp.AnyFloat64DType = ..., *, format: _FmtCSC ) -> csc_matrix[np.float64]: ... -@overload # dtype like bool (positional), format: "csc" -def eye(m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.AnyBoolDType, format: _FmtCSC) -> csc_matrix[np.bool_]: ... -@overload # dtype like bool (keyword), format: "csc" +@overload # dtype like bool, format: "csc" def eye( m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyBoolDType, format: _FmtCSC ) -> csc_matrix[np.bool_]: ... -@overload # dtype like int (positional), format: "csc" -def eye(m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.AnyIntDType, format: _FmtCSC) -> csc_matrix[np.int_]: ... -@overload # dtype like int (keyword), format: "csc" +@overload # dtype like int, format: "csc" def eye( m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyIntDType, format: _FmtCSC ) -> csc_matrix[np.int_]: ... -@overload # dtype like complex (positional), format: "csc" -def eye( - m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.AnyComplex128DType, format: _FmtCSC -) -> csc_matrix[np.complex128]: ... -@overload # dtype like complex (keyword), format: "csc" +@overload # dtype like complex, format: "csc" def eye( m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyComplex128DType, format: _FmtCSC ) -> csc_matrix[np.complex128]: ... -@overload # dtype like (positional), format: "csc" -def eye(m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.ToDType[_SCT], format: _FmtCSC) -> csc_matrix[_SCT]: ... -@overload # dtype like (keyword), format: "csc" +@overload # dtype like , format: "csc" def eye( m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.ToDType[_SCT], format: _FmtCSC ) -> csc_matrix[_SCT]: ... -@overload # dtype like (positional), format: "csc" -def eye(m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: npt.DTypeLike, format: _FmtCSC) -> csc_matrix[Incomplete]: ... -@overload # dtype like (keyword), format: "csc" +@overload # dtype like , format: "csc" def eye( m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: npt.DTypeLike, format: _FmtCSC ) -> csc_matrix[Incomplete]: ... @@ -1880,35 +1157,23 @@ def eye( def eye( m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, dtype: onp.AnyFloat64DType = ..., *, format: _FmtCSR ) -> csr_matrix[np.float64]: ... -@overload # dtype like bool (positional), format: "csr" -def eye(m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.AnyBoolDType, format: _FmtCSR) -> csr_matrix[np.bool_]: ... -@overload # dtype like bool (keyword), format: "csr" +@overload # dtype like bool, format: "csr" def eye( m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyBoolDType, format: _FmtCSR ) -> csr_matrix[np.bool_]: ... -@overload # dtype like int (positional), format: "csr" -def eye(m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.AnyIntDType, format: _FmtCSR) -> csr_matrix[np.int_]: ... -@overload # dtype like int (keyword), format: "csr" +@overload # dtype like int, format: "csr" def eye( m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyIntDType, format: _FmtCSR ) -> csr_matrix[np.int_]: ... -@overload # dtype like complex (positional), format: "csr" -def eye( - m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.AnyComplex128DType, format: _FmtCSR -) -> csr_matrix[np.complex128]: ... -@overload # dtype like complex (keyword), format: "csr" +@overload # dtype like complex, format: "csr" def eye( m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyComplex128DType, format: _FmtCSR ) -> csr_matrix[np.complex128]: ... -@overload # dtype like (positional), format: "csr" -def eye(m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.ToDType[_SCT], format: _FmtCSR) -> csr_matrix[_SCT]: ... -@overload # dtype like (keyword), format: "csr" +@overload # dtype like , format: "csr" def eye( m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.ToDType[_SCT], format: _FmtCSR ) -> csr_matrix[_SCT]: ... -@overload # dtype like (positional), format: "csr" -def eye(m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: npt.DTypeLike, format: _FmtCSR) -> csr_matrix[Incomplete]: ... -@overload # dtype like (keyword), format: "csr" +@overload # dtype like , format: "csr" def eye( m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: npt.DTypeLike, format: _FmtCSR ) -> csr_matrix[Incomplete]: ... @@ -1916,35 +1181,23 @@ def eye( def eye( m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, dtype: onp.AnyFloat64DType = ..., *, format: _FmtDOK ) -> dok_matrix[np.float64]: ... -@overload # dtype like bool (positional), format: "dok" -def eye(m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.AnyBoolDType, format: _FmtDOK) -> dok_matrix[np.bool_]: ... -@overload # dtype like bool (keyword), format: "dok" +@overload # dtype like bool, format: "dok" def eye( m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyBoolDType, format: _FmtDOK ) -> dok_matrix[np.bool_]: ... -@overload # dtype like int (positional), format: "dok" -def eye(m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.AnyIntDType, format: _FmtDOK) -> dok_matrix[np.int_]: ... -@overload # dtype like int (keyword), format: "dok" +@overload # dtype like int, format: "dok" def eye( m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyIntDType, format: _FmtDOK ) -> dok_matrix[np.int_]: ... -@overload # dtype like complex (positional), format: "dok" -def eye( - m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.AnyComplex128DType, format: _FmtDOK -) -> dok_matrix[np.complex128]: ... -@overload # dtype like complex (keyword), format: "dok" +@overload # dtype like complex, format: "dok" def eye( m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyComplex128DType, format: _FmtDOK ) -> dok_matrix[np.complex128]: ... -@overload # dtype like (positional), format: "dok" -def eye(m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.ToDType[_SCT], format: _FmtDOK) -> dok_matrix[_SCT]: ... -@overload # dtype like (keyword), format: "dok" +@overload # dtype like , format: "dok" def eye( m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.ToDType[_SCT], format: _FmtDOK ) -> dok_matrix[_SCT]: ... -@overload # dtype like (positional), format: "dok" -def eye(m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: npt.DTypeLike, format: _FmtDOK) -> dok_matrix[Incomplete]: ... -@overload # dtype like (keyword), format: "dok" +@overload # dtype like , format: "dok" def eye( m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: npt.DTypeLike, format: _FmtDOK ) -> dok_matrix[Incomplete]: ... @@ -1952,35 +1205,23 @@ def eye( def eye( m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, dtype: onp.AnyFloat64DType = ..., *, format: _FmtLIL ) -> lil_matrix[np.float64]: ... -@overload # dtype like bool (positional), format: "lil" -def eye(m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.AnyBoolDType, format: _FmtLIL) -> lil_matrix[np.bool_]: ... -@overload # dtype like bool (keyword), format: "lil" +@overload # dtype like bool, format: "lil" def eye( m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyBoolDType, format: _FmtLIL ) -> lil_matrix[np.bool_]: ... -@overload # dtype like int (positional), format: "lil" -def eye(m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.AnyIntDType, format: _FmtLIL) -> lil_matrix[np.int_]: ... -@overload # dtype like int (keyword), format: "lil" +@overload # dtype like int, format: "lil" def eye( m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyIntDType, format: _FmtLIL ) -> lil_matrix[np.int_]: ... -@overload # dtype like complex (positional), format: "lil" -def eye( - m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.AnyComplex128DType, format: _FmtLIL -) -> lil_matrix[np.complex128]: ... -@overload # dtype like complex (keyword), format: "lil" +@overload # dtype like complex, format: "lil" def eye( m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyComplex128DType, format: _FmtLIL ) -> lil_matrix[np.complex128]: ... -@overload # dtype like (positional), format: "lil" -def eye(m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: onp.ToDType[_SCT], format: _FmtLIL) -> lil_matrix[_SCT]: ... -@overload # dtype like (keyword), format: "lil" +@overload # dtype like , format: "lil" def eye( m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.ToDType[_SCT], format: _FmtLIL ) -> lil_matrix[_SCT]: ... -@overload # dtype like (positional), format: "lil" -def eye(m: opt.AnyInt, n: opt.AnyInt | None, k: int, dtype: npt.DTypeLike, format: _FmtLIL) -> lil_matrix[Incomplete]: ... -@overload # dtype like (keyword), format: "lil" +@overload # dtype like , format: "lil" def eye( m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: npt.DTypeLike, format: _FmtLIL ) -> lil_matrix[Incomplete]: ... diff --git a/tests/sparse/test_construct.pyi b/tests/sparse/test_construct.pyi index 90e2ca90..66ce4a3f 100644 --- a/tests/sparse/test_construct.pyi +++ b/tests/sparse/test_construct.pyi @@ -39,15 +39,15 @@ int_list: list[int] assert_type(sparse.diags_array([1, 2]), sparse.dia_array[Any]) assert_type(sparse.diags_array([[1, 2.0], [3j]], offsets=int_list), sparse.dia_array[Any]) assert_type(sparse.diags_array(dense_1d), sparse.dia_array[ScalarType]) -assert_type(sparse.diags_array(dense_1d.astype(np.float128)), sparse.dia_array[np.float128]) +assert_type(sparse.diags_array(dense_1d.astype(np.longdouble)), sparse.dia_array[np.longdouble]) assert_type(sparse.diags_array(dense_1d.astype(np.complex128)), sparse.dia_array[np.complex128]) assert_type(sparse.diags_array(dense_2d, offsets=int_list), sparse.dia_array[ScalarType]) assert_type(sparse.diags_array(dense_1d, dtype="bool"), sparse.dia_array[np.bool_]) assert_type(sparse.diags_array(dense_2d, dtype="bool"), sparse.dia_array[np.bool_]) assert_type(sparse.diags_array(dense_1d, dtype=int), sparse.dia_array[np.int_]) assert_type(sparse.diags_array(dense_2d, dtype=int), sparse.dia_array[np.int_]) -assert_type(sparse.diags_array(dense_1d, dtype=np.float128), sparse.dia_array[np.float128]) -assert_type(sparse.diags_array(dense_2d, dtype=np.float128), sparse.dia_array[np.float128]) +assert_type(sparse.diags_array(dense_1d, dtype=np.longdouble), sparse.dia_array[np.longdouble]) +assert_type(sparse.diags_array(dense_2d, dtype=np.longdouble), sparse.dia_array[np.longdouble]) assert_type(sparse.diags_array(dense_1d, dtype=" Date: Wed, 9 Jul 2025 18:19:29 +0200 Subject: [PATCH 04/20] Removed the strict typing on diagonal offsets --- scipy-stubs/sparse/_construct.pyi | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scipy-stubs/sparse/_construct.pyi b/scipy-stubs/sparse/_construct.pyi index fd0579f7..60f3bec2 100644 --- a/scipy-stubs/sparse/_construct.pyi +++ b/scipy-stubs/sparse/_construct.pyi @@ -79,7 +79,7 @@ _FmtLIL: TypeAlias = Literal["lil"] _FmtNonCOO: TypeAlias = Literal["bsr", "csc", "csr", "dia", "dok", "lil"] _Diag: TypeAlias = _ToArray1D[_SCT] | _ToArray2D[_SCT] -_Offsets: TypeAlias = onp.ToInt | onp.ToIntStrict1D +_Offsets: TypeAlias = onp.ToInt | onp.ToInt1D _DataRVS: TypeAlias = Callable[[int], onp.ArrayND[_Numeric]] From a5e06f3ea0d3b7d653a60649ec095c70dfa57052 Mon Sep 17 00:00:00 2001 From: Jul Van den Broeck Date: Wed, 9 Jul 2025 22:12:51 +0200 Subject: [PATCH 05/20] Renamed typing of input arrays for `_construct.pyi` functions + replaced custom type by `AnyFloat64DType` --- scipy-stubs/sparse/_construct.pyi | 251 +++++++++++++++++++++--------- 1 file changed, 178 insertions(+), 73 deletions(-) diff --git a/scipy-stubs/sparse/_construct.pyi b/scipy-stubs/sparse/_construct.pyi index 60f3bec2..85ae0c8b 100644 --- a/scipy-stubs/sparse/_construct.pyi +++ b/scipy-stubs/sparse/_construct.pyi @@ -4,11 +4,9 @@ from typing import Any, Literal, Protocol, TypeAlias, TypeVar, overload, type_ch import numpy as np import numpy.typing as npt -import optype as op import optype.numpy as onp import optype.numpy.compat as npc import optype.typing as opt -from optype.numpy._dtype_attr import f8_code from ._base import _spbase, sparray from ._bsr import bsr_array, bsr_matrix @@ -41,7 +39,6 @@ __all__ = [ ] _Numeric: TypeAlias = npc.number | np.bool_ -_AnyFloat64DTypeNotNone: TypeAlias = type[op.JustFloat] | onp.ToDType[npc.floating64] | f8_code _T = TypeVar("_T") _SCT = TypeVar("_SCT", bound=_Numeric, default=Any) @@ -50,6 +47,7 @@ _ShapeT = TypeVar("_ShapeT", bound=tuple[int, *tuple[int, ...]], default=tuple[A _ToArray1D: TypeAlias = onp.ToArray1D[complex, _SCT] _ToArray2D: TypeAlias = onp.ToArray2D[complex, _SCT] +_ToArray1D2D: TypeAlias = _ToArray1D[_SCT] | _ToArray2D[_SCT] _ToSpMatrix: TypeAlias = spmatrix[_SCT] | _ToArray2D[_SCT] _ToSparse2D: TypeAlias = _spbase[_SCT, tuple[int, int]] | _ToArray2D[_SCT] @@ -78,7 +76,6 @@ _FmtDOK: TypeAlias = Literal["dok"] _FmtLIL: TypeAlias = Literal["lil"] _FmtNonCOO: TypeAlias = Literal["bsr", "csc", "csr", "dia", "dok", "lil"] -_Diag: TypeAlias = _ToArray1D[_SCT] | _ToArray2D[_SCT] _Offsets: TypeAlias = onp.ToInt | onp.ToInt1D _DataRVS: TypeAlias = Callable[[int], onp.ArrayND[_Numeric]] @@ -93,7 +90,7 @@ class _DataSampler(Protocol): @overload # diagonals: , dtype: None = ..., format: {"dia", None} = ... def diags_array( - diagonals: _Diag[_SCT], + diagonals: _ToArray1D2D[_SCT], /, *, offsets: _Offsets = 0, @@ -103,7 +100,7 @@ def diags_array( ) -> _DIAArray[_SCT]: ... @overload # diagonals: , format: {"dia", None} = ..., dtype: bool-like def diags_array( - diagonals: _Diag[_SCT], + diagonals: _ToArray1D2D[_SCT], /, *, offsets: _Offsets = 0, @@ -113,7 +110,7 @@ def diags_array( ) -> _DIAArray[np.bool_]: ... @overload # diagonals: , format: {"dia", None} = ..., dtype: int-like def diags_array( - diagonals: _Diag[_SCT], + diagonals: _ToArray1D2D[_SCT], /, *, offsets: _Offsets = 0, @@ -123,17 +120,17 @@ def diags_array( ) -> _DIAArray[np.int_]: ... @overload # diagonals: , format: {"dia", None} = ..., dtype: float64-like def diags_array( - diagonals: _Diag[_SCT], + diagonals: _ToArray1D2D[_SCT], /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtDIA | None = None, - dtype: _AnyFloat64DTypeNotNone, + dtype: onp.AnyFloat64DType, ) -> _DIAArray[np.float64]: ... @overload # diagonals: , format: {"dia", None} = ..., dtype: complex128-like def diags_array( - diagonals: _Diag[_SCT], + diagonals: _ToArray1D2D[_SCT], /, *, offsets: _Offsets = 0, @@ -165,29 +162,47 @@ def diags_array( # BSR @overload # diagonals: , format: "bsr", dtype: None def diags_array( - diagonals: _Diag[_SCT], /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtBSR, dtype: None = None + diagonals: _ToArray1D2D[_SCT], + /, + *, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtBSR, + dtype: None = None, ) -> _BSRArray[_SCT]: ... @overload # diagonals: , format: "bsr", dtype: bool-like def diags_array( - diagonals: _Diag[_SCT], /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtBSR, dtype: onp.AnyBoolDType + diagonals: _ToArray1D2D[_SCT], + /, + *, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtBSR, + dtype: onp.AnyBoolDType, ) -> _BSRArray[np.bool_]: ... @overload # diagonals: , format: "bsr", dtype: int-like def diags_array( - diagonals: _Diag[_SCT], /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtBSR, dtype: onp.AnyIntDType + diagonals: _ToArray1D2D[_SCT], + /, + *, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtBSR, + dtype: onp.AnyIntDType, ) -> _BSRArray[np.int_]: ... @overload # diagonals: , format: "bsr", dtype: float64-like def diags_array( - diagonals: _Diag[_SCT], + diagonals: _ToArray1D2D[_SCT], /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtBSR, - dtype: _AnyFloat64DTypeNotNone, + dtype: onp.AnyFloat64DType, ) -> _BSRArray[np.float64]: ... @overload # diagonals: , format: "bsr", dtype: complex128-like def diags_array( - diagonals: _Diag[_SCT], + diagonals: _ToArray1D2D[_SCT], /, *, offsets: _Offsets = 0, @@ -219,29 +234,47 @@ def diags_array( # COO @overload # diagonals: , format: "coo", dtype: None def diags_array( - diagonals: _Diag[_SCT], /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCOO, dtype: None = None + diagonals: _ToArray1D2D[_SCT], + /, + *, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtCOO, + dtype: None = None, ) -> _COOArray2D[_SCT]: ... @overload # diagonals: , format: "coo", dtype: bool-like def diags_array( - diagonals: _Diag[_SCT], /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCOO, dtype: onp.AnyBoolDType + diagonals: _ToArray1D2D[_SCT], + /, + *, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtCOO, + dtype: onp.AnyBoolDType, ) -> _COOArray2D[np.bool_]: ... @overload # diagonals: , format: "coo", dtype: int-like def diags_array( - diagonals: _Diag[_SCT], /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCOO, dtype: onp.AnyIntDType + diagonals: _ToArray1D2D[_SCT], + /, + *, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtCOO, + dtype: onp.AnyIntDType, ) -> _COOArray2D[np.int_]: ... @overload # diagonals: , format: "coo", dtype: float64-like def diags_array( - diagonals: _Diag[_SCT], + diagonals: _ToArray1D2D[_SCT], /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCOO, - dtype: _AnyFloat64DTypeNotNone, + dtype: onp.AnyFloat64DType, ) -> _COOArray2D[np.float64]: ... @overload # diagonals: , format: "coo", dtype: complex128-like def diags_array( - diagonals: _Diag[_SCT], + diagonals: _ToArray1D2D[_SCT], /, *, offsets: _Offsets = 0, @@ -273,29 +306,47 @@ def diags_array( # CSC @overload # diagonals: , format: "csc", dtype: None def diags_array( - diagonals: _Diag[_SCT], /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCSC, dtype: None = None + diagonals: _ToArray1D2D[_SCT], + /, + *, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtCSC, + dtype: None = None, ) -> _CSCArray[_SCT]: ... @overload # diagonals: , format: "csc", dtype: bool-like def diags_array( - diagonals: _Diag[_SCT], /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCSC, dtype: onp.AnyBoolDType + diagonals: _ToArray1D2D[_SCT], + /, + *, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtCSC, + dtype: onp.AnyBoolDType, ) -> _CSCArray[np.bool_]: ... @overload # diagonals: , format: "csc", dtype: int-like def diags_array( - diagonals: _Diag[_SCT], /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCSC, dtype: onp.AnyIntDType + diagonals: _ToArray1D2D[_SCT], + /, + *, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtCSC, + dtype: onp.AnyIntDType, ) -> _CSCArray[np.int_]: ... @overload # diagonals: , format: "csc", dtype: float64-like def diags_array( - diagonals: _Diag[_SCT], + diagonals: _ToArray1D2D[_SCT], /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCSC, - dtype: _AnyFloat64DTypeNotNone, + dtype: onp.AnyFloat64DType, ) -> _CSCArray[np.float64]: ... @overload # diagonals: , format: "csc", dtype: complex128-like def diags_array( - diagonals: _Diag[_SCT], + diagonals: _ToArray1D2D[_SCT], /, *, offsets: _Offsets = 0, @@ -327,29 +378,47 @@ def diags_array( # CSR @overload # diagonals: , format: "csr", dtype: None def diags_array( - diagonals: _Diag[_SCT], /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCSR, dtype: None = None + diagonals: _ToArray1D2D[_SCT], + /, + *, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtCSR, + dtype: None = None, ) -> _CSRArray2D[_SCT]: ... @overload # diagonals: , format: "csr", dtype: bool-like def diags_array( - diagonals: _Diag[_SCT], /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCSR, dtype: onp.AnyBoolDType + diagonals: _ToArray1D2D[_SCT], + /, + *, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtCSR, + dtype: onp.AnyBoolDType, ) -> _CSRArray2D[np.bool_]: ... @overload # diagonals: , format: "csr", dtype: int-like def diags_array( - diagonals: _Diag[_SCT], /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCSR, dtype: onp.AnyIntDType + diagonals: _ToArray1D2D[_SCT], + /, + *, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtCSR, + dtype: onp.AnyIntDType, ) -> _CSRArray2D[np.int_]: ... @overload # diagonals: , format: "csr", dtype: float64-like def diags_array( - diagonals: _Diag[_SCT], + diagonals: _ToArray1D2D[_SCT], /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCSR, - dtype: _AnyFloat64DTypeNotNone, + dtype: onp.AnyFloat64DType, ) -> _CSRArray2D[np.float64]: ... @overload # diagonals: , format: "csr", dtype: complex128-like def diags_array( - diagonals: _Diag[_SCT], + diagonals: _ToArray1D2D[_SCT], /, *, offsets: _Offsets = 0, @@ -381,29 +450,47 @@ def diags_array( # DOK @overload # diagonals: , format: "dok", dtype: None def diags_array( - diagonals: _Diag[_SCT], /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtDOK, dtype: None = None + diagonals: _ToArray1D2D[_SCT], + /, + *, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtDOK, + dtype: None = None, ) -> _DOKArray2D[_SCT]: ... @overload # diagonals: , format: "dok", dtype: bool-like def diags_array( - diagonals: _Diag[_SCT], /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtDOK, dtype: onp.AnyBoolDType + diagonals: _ToArray1D2D[_SCT], + /, + *, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtDOK, + dtype: onp.AnyBoolDType, ) -> _DOKArray2D[np.bool_]: ... @overload # diagonals: , format: "dok", dtype: int-like def diags_array( - diagonals: _Diag[_SCT], /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtDOK, dtype: onp.AnyIntDType + diagonals: _ToArray1D2D[_SCT], + /, + *, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtDOK, + dtype: onp.AnyIntDType, ) -> _DOKArray2D[np.int_]: ... @overload # diagonals: , format: "dok", dtype: float64-like def diags_array( - diagonals: _Diag[_SCT], + diagonals: _ToArray1D2D[_SCT], /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtDOK, - dtype: _AnyFloat64DTypeNotNone, + dtype: onp.AnyFloat64DType, ) -> _DOKArray2D[np.float64]: ... @overload # diagonals: , format: "dok", dtype: complex128-like def diags_array( - diagonals: _Diag[_SCT], + diagonals: _ToArray1D2D[_SCT], /, *, offsets: _Offsets = 0, @@ -435,29 +522,47 @@ def diags_array( # LIL @overload # diagonals: , format: "lil", dtype: None def diags_array( - diagonals: _Diag[_SCT], /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtLIL, dtype: None = None + diagonals: _ToArray1D2D[_SCT], + /, + *, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtLIL, + dtype: None = None, ) -> _LILArray[_SCT]: ... @overload # diagonals: , format: "lil", dtype: bool-like def diags_array( - diagonals: _Diag[_SCT], /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtLIL, dtype: onp.AnyBoolDType + diagonals: _ToArray1D2D[_SCT], + /, + *, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtLIL, + dtype: onp.AnyBoolDType, ) -> _LILArray[np.bool_]: ... @overload # diagonals: , format: "lil", dtype: int-like def diags_array( - diagonals: _Diag[_SCT], /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtLIL, dtype: onp.AnyIntDType + diagonals: _ToArray1D2D[_SCT], + /, + *, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtLIL, + dtype: onp.AnyIntDType, ) -> _LILArray[np.int_]: ... @overload # diagonals: , format: "lil", dtype: float64-like def diags_array( - diagonals: _Diag[_SCT], + diagonals: _ToArray1D2D[_SCT], /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtLIL, - dtype: _AnyFloat64DTypeNotNone, + dtype: onp.AnyFloat64DType, ) -> _LILArray[np.float64]: ... @overload # diagonals: , format: "lil", dtype: complex128-like def diags_array( - diagonals: _Diag[_SCT], + diagonals: _ToArray1D2D[_SCT], /, *, offsets: _Offsets = 0, @@ -489,7 +594,7 @@ def diags_array( # NOTE: `diags_array` should be prefered over `diags` @overload # diagonals: , format: {"dia", None} = ... def diags( - diagonals: _Diag[_SCT], + diagonals: _ToArray1D2D[_SCT], offsets: onp.ToInt | onp.ToInt1D = 0, shape: _ToShape2D | None = None, format: _FmtDIA | None = None, @@ -497,7 +602,7 @@ def diags( ) -> dia_matrix[_SCT]: ... @overload # diagonals: , format: "bsr" (positional) def diags( - diagonals: _Diag[_SCT], + diagonals: _ToArray1D2D[_SCT], offsets: onp.ToInt | onp.ToInt1D, shape: _ToShape2D | None, format: _FmtBSR, @@ -505,7 +610,7 @@ def diags( ) -> bsr_matrix[_SCT]: ... @overload # diagonals: , format: "bsr" (keyword) def diags( - diagonals: _Diag[_SCT], + diagonals: _ToArray1D2D[_SCT], offsets: onp.ToInt | onp.ToInt1D = 0, shape: _ToShape2D | None = None, *, @@ -514,7 +619,7 @@ def diags( ) -> bsr_matrix[_SCT]: ... @overload # diagonals: , format: "coo" (positional) def diags( - diagonals: _Diag[_SCT], + diagonals: _ToArray1D2D[_SCT], offsets: onp.ToInt | onp.ToInt1D, shape: _ToShape2D | None, format: _FmtCOO, @@ -522,7 +627,7 @@ def diags( ) -> coo_matrix[_SCT]: ... @overload # diagonals: , format: "coo" (keyword) def diags( - diagonals: _Diag[_SCT], + diagonals: _ToArray1D2D[_SCT], offsets: onp.ToInt | onp.ToInt1D = 0, shape: _ToShape2D | None = None, *, @@ -531,7 +636,7 @@ def diags( ) -> coo_matrix[_SCT]: ... @overload # diagonals: , format: "csr" (positional) def diags( - diagonals: _Diag[_SCT], + diagonals: _ToArray1D2D[_SCT], offsets: onp.ToInt | onp.ToInt1D, shape: _ToShape2D | None, format: _FmtCSR, @@ -539,7 +644,7 @@ def diags( ) -> csr_matrix[_SCT]: ... @overload # diagonals: , format: "csr" (keyword) def diags( - diagonals: _Diag[_SCT], + diagonals: _ToArray1D2D[_SCT], offsets: onp.ToInt | onp.ToInt1D = 0, shape: _ToShape2D | None = None, *, @@ -548,7 +653,7 @@ def diags( ) -> csr_matrix[_SCT]: ... @overload # diagonals: , format: "csc" (positional) def diags( - diagonals: _Diag[_SCT], + diagonals: _ToArray1D2D[_SCT], offsets: onp.ToInt | onp.ToInt1D, shape: _ToShape2D | None, format: _FmtCSC, @@ -556,7 +661,7 @@ def diags( ) -> csc_matrix[_SCT]: ... @overload # diagonals: , format: "csc" (keyword) def diags( - diagonals: _Diag[_SCT], + diagonals: _ToArray1D2D[_SCT], offsets: onp.ToInt | onp.ToInt1D = 0, shape: _ToShape2D | None = None, *, @@ -565,7 +670,7 @@ def diags( ) -> csc_matrix[_SCT]: ... @overload # diagonals: , format: "dok" (positional) def diags( - diagonals: _Diag[_SCT], + diagonals: _ToArray1D2D[_SCT], offsets: onp.ToInt | onp.ToInt1D, shape: _ToShape2D | None, format: _FmtDOK, @@ -573,7 +678,7 @@ def diags( ) -> dok_matrix[_SCT]: ... @overload # diagonals: , format: "dok" (keyword) def diags( - diagonals: _Diag[_SCT], + diagonals: _ToArray1D2D[_SCT], offsets: onp.ToInt | onp.ToInt1D = 0, shape: _ToShape2D | None = None, *, @@ -582,7 +687,7 @@ def diags( ) -> dok_matrix[_SCT]: ... @overload # diagonals: , format: "lil" (positional) def diags( - diagonals: _Diag[_SCT], + diagonals: _ToArray1D2D[_SCT], offsets: onp.ToInt | onp.ToInt1D, shape: _ToShape2D | None, format: _FmtLIL, @@ -590,7 +695,7 @@ def diags( ) -> lil_matrix[_SCT]: ... @overload # diagonals: , format: "lil" (keyword) def diags( - diagonals: _Diag[_SCT], + diagonals: _ToArray1D2D[_SCT], offsets: onp.ToInt | onp.ToInt1D = 0, shape: _ToShape2D | None = None, *, @@ -711,11 +816,11 @@ def diags( # NOTE: `diags_array` should be prefered over `spdiags` @overload def spdiags( - data: _Diag[_SCT], diags: onp.ToInt | onp.ToInt1D, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtDIA | None = None + data: _ToArray1D2D[_SCT], diags: onp.ToInt | onp.ToInt1D, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtDIA | None = None ) -> dia_matrix[_SCT]: ... @overload def spdiags( - data: _Diag[_SCT], + data: _ToArray1D2D[_SCT], diags: onp.ToInt | onp.ToInt1D, m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, n: None = None, @@ -723,11 +828,11 @@ def spdiags( ) -> dia_matrix[_SCT]: ... @overload def spdiags( - data: _Diag[_SCT], diags: onp.ToInt | onp.ToInt1D, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtBSR + data: _ToArray1D2D[_SCT], diags: onp.ToInt | onp.ToInt1D, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtBSR ) -> bsr_matrix[_SCT]: ... @overload def spdiags( - data: _Diag[_SCT], + data: _ToArray1D2D[_SCT], diags: onp.ToInt | onp.ToInt1D, m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, n: None = None, @@ -736,11 +841,11 @@ def spdiags( ) -> bsr_matrix[_SCT]: ... @overload def spdiags( - data: _Diag[_SCT], diags: onp.ToInt | onp.ToInt1D, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtCOO + data: _ToArray1D2D[_SCT], diags: onp.ToInt | onp.ToInt1D, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtCOO ) -> coo_matrix[_SCT]: ... @overload def spdiags( - data: _Diag[_SCT], + data: _ToArray1D2D[_SCT], diags: onp.ToInt | onp.ToInt1D, m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, n: None = None, @@ -749,11 +854,11 @@ def spdiags( ) -> coo_matrix[_SCT]: ... @overload def spdiags( - data: _Diag[_SCT], diags: onp.ToInt | onp.ToInt1D, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtCSR + data: _ToArray1D2D[_SCT], diags: onp.ToInt | onp.ToInt1D, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtCSR ) -> csr_matrix[_SCT]: ... @overload def spdiags( - data: _Diag[_SCT], + data: _ToArray1D2D[_SCT], diags: onp.ToInt | onp.ToInt1D, m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, n: None = None, @@ -762,11 +867,11 @@ def spdiags( ) -> csr_matrix[_SCT]: ... @overload def spdiags( - data: _Diag[_SCT], diags: onp.ToInt | onp.ToInt1D, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtCSC + data: _ToArray1D2D[_SCT], diags: onp.ToInt | onp.ToInt1D, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtCSC ) -> csc_matrix[_SCT]: ... @overload def spdiags( - data: _Diag[_SCT], + data: _ToArray1D2D[_SCT], diags: onp.ToInt | onp.ToInt1D, m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, n: None = None, @@ -775,11 +880,11 @@ def spdiags( ) -> csc_matrix[_SCT]: ... @overload def spdiags( - data: _Diag[_SCT], diags: onp.ToInt | onp.ToInt1D, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtDOK + data: _ToArray1D2D[_SCT], diags: onp.ToInt | onp.ToInt1D, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtDOK ) -> dok_matrix[_SCT]: ... @overload def spdiags( - data: _Diag[_SCT], + data: _ToArray1D2D[_SCT], diags: onp.ToInt | onp.ToInt1D, m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, n: None = None, @@ -788,11 +893,11 @@ def spdiags( ) -> dok_matrix[_SCT]: ... @overload def spdiags( - data: _Diag[_SCT], diags: onp.ToInt | onp.ToInt1D, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtLIL + data: _ToArray1D2D[_SCT], diags: onp.ToInt | onp.ToInt1D, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtLIL ) -> lil_matrix[_SCT]: ... @overload def spdiags( - data: _Diag[_SCT], + data: _ToArray1D2D[_SCT], diags: onp.ToInt | onp.ToInt1D, m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, n: None = None, From 5f50692e7789d9c28af4f291f9573447d8ca751c Mon Sep 17 00:00:00 2001 From: Jul Van den Broeck Date: Mon, 14 Jul 2025 19:23:04 +0200 Subject: [PATCH 06/20] Improved type -related stubs for sequences of Python types --- scipy-stubs/sparse/_construct.pyi | 240 ++++++++++++++++++++---------- tests/sparse/test_construct.pyi | 12 +- 2 files changed, 167 insertions(+), 85 deletions(-) diff --git a/scipy-stubs/sparse/_construct.pyi b/scipy-stubs/sparse/_construct.pyi index 85ae0c8b..dcc0da91 100644 --- a/scipy-stubs/sparse/_construct.pyi +++ b/scipy-stubs/sparse/_construct.pyi @@ -3,6 +3,7 @@ from collections.abc import Callable, Iterable, Sequence as Seq from typing import Any, Literal, Protocol, TypeAlias, TypeVar, overload, type_check_only import numpy as np +import numpy._typing as _npt import numpy.typing as npt import optype.numpy as onp import optype.numpy.compat as npc @@ -38,18 +39,23 @@ __all__ = [ "vstack", ] -_Numeric: TypeAlias = npc.number | np.bool_ +_Numeric: TypeAlias = np.bool_ | npc.number _T = TypeVar("_T") +_PSCT = TypeVar("_PSCT", bound=int | float | complex, default=Any) _SCT = TypeVar("_SCT", bound=_Numeric, default=Any) _SCT0 = TypeVar("_SCT0", bound=_Numeric) _ShapeT = TypeVar("_ShapeT", bound=tuple[int, *tuple[int, ...]], default=tuple[Any, ...]) -_ToArray1D: TypeAlias = onp.ToArray1D[complex, _SCT] -_ToArray2D: TypeAlias = onp.ToArray2D[complex, _SCT] -_ToArray1D2D: TypeAlias = _ToArray1D[_SCT] | _ToArray2D[_SCT] -_ToSpMatrix: TypeAlias = spmatrix[_SCT] | _ToArray2D[_SCT] -_ToSparse2D: TypeAlias = _spbase[_SCT, tuple[int, int]] | _ToArray2D[_SCT] +_CanArray1D: TypeAlias = onp.CanArray1D[_SCT] +_CanArray2D: TypeAlias = onp.CanArray2D[_SCT] +_CanArray1D2D: TypeAlias = _CanArray1D[_SCT] | _CanArray2D[_SCT] + +_ToArray1D: TypeAlias = onp.ToArray1D[_PSCT, _SCT] +_ToArray2D: TypeAlias = onp.ToArray2D[_PSCT, _SCT] +_ToArray1D2D: TypeAlias = _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT] +_ToSpMatrix: TypeAlias = spmatrix[_SCT] | _ToArray2D[_PSCT, _SCT] +_ToSparse2D: TypeAlias = _spbase[_SCT, tuple[int, int]] | _ToArray2D[_PSCT, _SCT] _SpBase: TypeAlias = _spbase[_SCT, _ShapeT] | Any _SpMatrix: TypeAlias = spmatrix[_SCT] | Any @@ -76,6 +82,7 @@ _FmtDOK: TypeAlias = Literal["dok"] _FmtLIL: TypeAlias = Literal["lil"] _FmtNonCOO: TypeAlias = Literal["bsr", "csc", "csr", "dia", "dok", "lil"] +_ComplexSeq1D2D: TypeAlias = Seq[_PSCT] | Seq[Seq[_PSCT] | _PSCT] _Offsets: TypeAlias = onp.ToInt | onp.ToInt1D _DataRVS: TypeAlias = Callable[[int], onp.ArrayND[_Numeric]] @@ -87,10 +94,19 @@ class _DataSampler(Protocol): def __call__(self, /, *, size: int) -> onp.ArrayND[_Numeric]: ... ### - @overload # diagonals: , dtype: None = ..., format: {"dia", None} = ... def diags_array( - diagonals: _ToArray1D2D[_SCT], + diagonals: _ComplexSeq1D2D[_PSCT], + /, + *, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtDIA | None = None, + dtype: None = None, +) -> _DIAArray[np.number[_npt._64Bit, float | _PSCT]]: ... +@overload # diagonals: , dtype: None = ..., format: {"dia", None} = ... +def diags_array( + diagonals: _CanArray1D2D[_SCT], /, *, offsets: _Offsets = 0, @@ -100,7 +116,7 @@ def diags_array( ) -> _DIAArray[_SCT]: ... @overload # diagonals: , format: {"dia", None} = ..., dtype: bool-like def diags_array( - diagonals: _ToArray1D2D[_SCT], + diagonals: _CanArray1D2D[_SCT], /, *, offsets: _Offsets = 0, @@ -110,7 +126,7 @@ def diags_array( ) -> _DIAArray[np.bool_]: ... @overload # diagonals: , format: {"dia", None} = ..., dtype: int-like def diags_array( - diagonals: _ToArray1D2D[_SCT], + diagonals: _CanArray1D2D[_SCT], /, *, offsets: _Offsets = 0, @@ -120,7 +136,7 @@ def diags_array( ) -> _DIAArray[np.int_]: ... @overload # diagonals: , format: {"dia", None} = ..., dtype: float64-like def diags_array( - diagonals: _ToArray1D2D[_SCT], + diagonals: _CanArray1D2D[_SCT], /, *, offsets: _Offsets = 0, @@ -130,7 +146,7 @@ def diags_array( ) -> _DIAArray[np.float64]: ... @overload # diagonals: , format: {"dia", None} = ..., dtype: complex128-like def diags_array( - diagonals: _ToArray1D2D[_SCT], + diagonals: _CanArray1D2D[_SCT], /, *, offsets: _Offsets = 0, @@ -162,7 +178,17 @@ def diags_array( # BSR @overload # diagonals: , format: "bsr", dtype: None def diags_array( - diagonals: _ToArray1D2D[_SCT], + diagonals: _ComplexSeq1D2D[_PSCT], + /, + *, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtBSR, + dtype: None = None, +) -> _BSRArray[np.number[_npt._64Bit, float | _PSCT]]: ... +@overload # diagonals: , format: "bsr", dtype: None +def diags_array( + diagonals: _CanArray1D2D[_SCT], /, *, offsets: _Offsets = 0, @@ -172,7 +198,7 @@ def diags_array( ) -> _BSRArray[_SCT]: ... @overload # diagonals: , format: "bsr", dtype: bool-like def diags_array( - diagonals: _ToArray1D2D[_SCT], + diagonals: _CanArray1D2D[_SCT], /, *, offsets: _Offsets = 0, @@ -182,7 +208,7 @@ def diags_array( ) -> _BSRArray[np.bool_]: ... @overload # diagonals: , format: "bsr", dtype: int-like def diags_array( - diagonals: _ToArray1D2D[_SCT], + diagonals: _CanArray1D2D[_SCT], /, *, offsets: _Offsets = 0, @@ -192,7 +218,7 @@ def diags_array( ) -> _BSRArray[np.int_]: ... @overload # diagonals: , format: "bsr", dtype: float64-like def diags_array( - diagonals: _ToArray1D2D[_SCT], + diagonals: _CanArray1D2D[_SCT], /, *, offsets: _Offsets = 0, @@ -202,7 +228,7 @@ def diags_array( ) -> _BSRArray[np.float64]: ... @overload # diagonals: , format: "bsr", dtype: complex128-like def diags_array( - diagonals: _ToArray1D2D[_SCT], + diagonals: _CanArray1D2D[_SCT], /, *, offsets: _Offsets = 0, @@ -234,7 +260,17 @@ def diags_array( # COO @overload # diagonals: , format: "coo", dtype: None def diags_array( - diagonals: _ToArray1D2D[_SCT], + diagonals: _ComplexSeq1D2D[_PSCT], + /, + *, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtCOO, + dtype: None = None, +) -> _COOArray2D[np.number[_npt._64Bit, float | _PSCT]]: ... +@overload # diagonals: , format: "coo", dtype: None +def diags_array( + diagonals: _CanArray1D2D[_SCT], /, *, offsets: _Offsets = 0, @@ -244,7 +280,7 @@ def diags_array( ) -> _COOArray2D[_SCT]: ... @overload # diagonals: , format: "coo", dtype: bool-like def diags_array( - diagonals: _ToArray1D2D[_SCT], + diagonals: _CanArray1D2D[_SCT], /, *, offsets: _Offsets = 0, @@ -254,7 +290,7 @@ def diags_array( ) -> _COOArray2D[np.bool_]: ... @overload # diagonals: , format: "coo", dtype: int-like def diags_array( - diagonals: _ToArray1D2D[_SCT], + diagonals: _CanArray1D2D[_SCT], /, *, offsets: _Offsets = 0, @@ -264,7 +300,7 @@ def diags_array( ) -> _COOArray2D[np.int_]: ... @overload # diagonals: , format: "coo", dtype: float64-like def diags_array( - diagonals: _ToArray1D2D[_SCT], + diagonals: _CanArray1D2D[_SCT], /, *, offsets: _Offsets = 0, @@ -274,7 +310,7 @@ def diags_array( ) -> _COOArray2D[np.float64]: ... @overload # diagonals: , format: "coo", dtype: complex128-like def diags_array( - diagonals: _ToArray1D2D[_SCT], + diagonals: _CanArray1D2D[_SCT], /, *, offsets: _Offsets = 0, @@ -306,7 +342,17 @@ def diags_array( # CSC @overload # diagonals: , format: "csc", dtype: None def diags_array( - diagonals: _ToArray1D2D[_SCT], + diagonals: _ComplexSeq1D2D[_PSCT], + /, + *, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtCSC, + dtype: None = None, +) -> _CSCArray[np.number[_npt._64Bit, float | _PSCT]]: ... +@overload # diagonals: , format: "csc", dtype: None +def diags_array( + diagonals: _CanArray1D2D[_SCT], /, *, offsets: _Offsets = 0, @@ -316,7 +362,7 @@ def diags_array( ) -> _CSCArray[_SCT]: ... @overload # diagonals: , format: "csc", dtype: bool-like def diags_array( - diagonals: _ToArray1D2D[_SCT], + diagonals: _CanArray1D2D[_SCT], /, *, offsets: _Offsets = 0, @@ -326,7 +372,7 @@ def diags_array( ) -> _CSCArray[np.bool_]: ... @overload # diagonals: , format: "csc", dtype: int-like def diags_array( - diagonals: _ToArray1D2D[_SCT], + diagonals: _CanArray1D2D[_SCT], /, *, offsets: _Offsets = 0, @@ -336,7 +382,7 @@ def diags_array( ) -> _CSCArray[np.int_]: ... @overload # diagonals: , format: "csc", dtype: float64-like def diags_array( - diagonals: _ToArray1D2D[_SCT], + diagonals: _CanArray1D2D[_SCT], /, *, offsets: _Offsets = 0, @@ -346,7 +392,7 @@ def diags_array( ) -> _CSCArray[np.float64]: ... @overload # diagonals: , format: "csc", dtype: complex128-like def diags_array( - diagonals: _ToArray1D2D[_SCT], + diagonals: _CanArray1D2D[_SCT], /, *, offsets: _Offsets = 0, @@ -378,7 +424,17 @@ def diags_array( # CSR @overload # diagonals: , format: "csr", dtype: None def diags_array( - diagonals: _ToArray1D2D[_SCT], + diagonals: _ComplexSeq1D2D[_PSCT], + /, + *, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtCSR, + dtype: None = None, +) -> _CSRArray2D[np.number[_npt._64Bit, float | _PSCT]]: ... +@overload # diagonals: , format: "csr", dtype: None +def diags_array( + diagonals: _CanArray1D2D[_SCT], /, *, offsets: _Offsets = 0, @@ -388,7 +444,7 @@ def diags_array( ) -> _CSRArray2D[_SCT]: ... @overload # diagonals: , format: "csr", dtype: bool-like def diags_array( - diagonals: _ToArray1D2D[_SCT], + diagonals: _CanArray1D2D[_SCT], /, *, offsets: _Offsets = 0, @@ -398,7 +454,7 @@ def diags_array( ) -> _CSRArray2D[np.bool_]: ... @overload # diagonals: , format: "csr", dtype: int-like def diags_array( - diagonals: _ToArray1D2D[_SCT], + diagonals: _CanArray1D2D[_SCT], /, *, offsets: _Offsets = 0, @@ -408,7 +464,7 @@ def diags_array( ) -> _CSRArray2D[np.int_]: ... @overload # diagonals: , format: "csr", dtype: float64-like def diags_array( - diagonals: _ToArray1D2D[_SCT], + diagonals: _CanArray1D2D[_SCT], /, *, offsets: _Offsets = 0, @@ -418,7 +474,7 @@ def diags_array( ) -> _CSRArray2D[np.float64]: ... @overload # diagonals: , format: "csr", dtype: complex128-like def diags_array( - diagonals: _ToArray1D2D[_SCT], + diagonals: _CanArray1D2D[_SCT], /, *, offsets: _Offsets = 0, @@ -450,7 +506,17 @@ def diags_array( # DOK @overload # diagonals: , format: "dok", dtype: None def diags_array( - diagonals: _ToArray1D2D[_SCT], + diagonals: _ComplexSeq1D2D[_PSCT], + /, + *, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtDOK, + dtype: None = None, +) -> _DOKArray2D[np.number[_npt._64Bit, float | _PSCT]]: ... +@overload # diagonals: , format: "dok", dtype: None +def diags_array( + diagonals: _CanArray1D2D[_SCT], /, *, offsets: _Offsets = 0, @@ -460,7 +526,7 @@ def diags_array( ) -> _DOKArray2D[_SCT]: ... @overload # diagonals: , format: "dok", dtype: bool-like def diags_array( - diagonals: _ToArray1D2D[_SCT], + diagonals: _CanArray1D2D[_SCT], /, *, offsets: _Offsets = 0, @@ -470,7 +536,7 @@ def diags_array( ) -> _DOKArray2D[np.bool_]: ... @overload # diagonals: , format: "dok", dtype: int-like def diags_array( - diagonals: _ToArray1D2D[_SCT], + diagonals: _CanArray1D2D[_SCT], /, *, offsets: _Offsets = 0, @@ -480,7 +546,7 @@ def diags_array( ) -> _DOKArray2D[np.int_]: ... @overload # diagonals: , format: "dok", dtype: float64-like def diags_array( - diagonals: _ToArray1D2D[_SCT], + diagonals: _CanArray1D2D[_SCT], /, *, offsets: _Offsets = 0, @@ -490,7 +556,7 @@ def diags_array( ) -> _DOKArray2D[np.float64]: ... @overload # diagonals: , format: "dok", dtype: complex128-like def diags_array( - diagonals: _ToArray1D2D[_SCT], + diagonals: _CanArray1D2D[_SCT], /, *, offsets: _Offsets = 0, @@ -522,7 +588,17 @@ def diags_array( # LIL @overload # diagonals: , format: "lil", dtype: None def diags_array( - diagonals: _ToArray1D2D[_SCT], + diagonals: _ComplexSeq1D2D[_PSCT], + /, + *, + offsets: _Offsets = 0, + shape: _ToShape2D | None = None, + format: _FmtLIL, + dtype: None = None, +) -> _LILArray[np.number[_npt._64Bit, float | _PSCT]]: ... +@overload # diagonals: , format: "lil", dtype: None +def diags_array( + diagonals: _CanArray1D2D[_SCT], /, *, offsets: _Offsets = 0, @@ -532,7 +608,7 @@ def diags_array( ) -> _LILArray[_SCT]: ... @overload # diagonals: , format: "lil", dtype: bool-like def diags_array( - diagonals: _ToArray1D2D[_SCT], + diagonals: _CanArray1D2D[_SCT], /, *, offsets: _Offsets = 0, @@ -542,7 +618,7 @@ def diags_array( ) -> _LILArray[np.bool_]: ... @overload # diagonals: , format: "lil", dtype: int-like def diags_array( - diagonals: _ToArray1D2D[_SCT], + diagonals: _CanArray1D2D[_SCT], /, *, offsets: _Offsets = 0, @@ -552,7 +628,7 @@ def diags_array( ) -> _LILArray[np.int_]: ... @overload # diagonals: , format: "lil", dtype: float64-like def diags_array( - diagonals: _ToArray1D2D[_SCT], + diagonals: _CanArray1D2D[_SCT], /, *, offsets: _Offsets = 0, @@ -562,7 +638,7 @@ def diags_array( ) -> _LILArray[np.float64]: ... @overload # diagonals: , format: "lil", dtype: complex128-like def diags_array( - diagonals: _ToArray1D2D[_SCT], + diagonals: _CanArray1D2D[_SCT], /, *, offsets: _Offsets = 0, @@ -595,7 +671,7 @@ def diags_array( @overload # diagonals: , format: {"dia", None} = ... def diags( diagonals: _ToArray1D2D[_SCT], - offsets: onp.ToInt | onp.ToInt1D = 0, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtDIA | None = None, dtype: onp.ToDType[_SCT] | None = None, @@ -603,7 +679,7 @@ def diags( @overload # diagonals: , format: "bsr" (positional) def diags( diagonals: _ToArray1D2D[_SCT], - offsets: onp.ToInt | onp.ToInt1D, + offsets: _Offsets, shape: _ToShape2D | None, format: _FmtBSR, dtype: onp.ToDType[_SCT] | None = None, @@ -611,7 +687,7 @@ def diags( @overload # diagonals: , format: "bsr" (keyword) def diags( diagonals: _ToArray1D2D[_SCT], - offsets: onp.ToInt | onp.ToInt1D = 0, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, format: _FmtBSR, @@ -620,7 +696,7 @@ def diags( @overload # diagonals: , format: "coo" (positional) def diags( diagonals: _ToArray1D2D[_SCT], - offsets: onp.ToInt | onp.ToInt1D, + offsets: _Offsets, shape: _ToShape2D | None, format: _FmtCOO, dtype: onp.ToDType[_SCT] | None = None, @@ -628,7 +704,7 @@ def diags( @overload # diagonals: , format: "coo" (keyword) def diags( diagonals: _ToArray1D2D[_SCT], - offsets: onp.ToInt | onp.ToInt1D = 0, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, format: _FmtCOO, @@ -637,7 +713,7 @@ def diags( @overload # diagonals: , format: "csr" (positional) def diags( diagonals: _ToArray1D2D[_SCT], - offsets: onp.ToInt | onp.ToInt1D, + offsets: _Offsets, shape: _ToShape2D | None, format: _FmtCSR, dtype: onp.ToDType[_SCT] | None = None, @@ -645,7 +721,7 @@ def diags( @overload # diagonals: , format: "csr" (keyword) def diags( diagonals: _ToArray1D2D[_SCT], - offsets: onp.ToInt | onp.ToInt1D = 0, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, format: _FmtCSR, @@ -654,7 +730,7 @@ def diags( @overload # diagonals: , format: "csc" (positional) def diags( diagonals: _ToArray1D2D[_SCT], - offsets: onp.ToInt | onp.ToInt1D, + offsets: _Offsets, shape: _ToShape2D | None, format: _FmtCSC, dtype: onp.ToDType[_SCT] | None = None, @@ -662,7 +738,7 @@ def diags( @overload # diagonals: , format: "csc" (keyword) def diags( diagonals: _ToArray1D2D[_SCT], - offsets: onp.ToInt | onp.ToInt1D = 0, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, format: _FmtCSC, @@ -671,7 +747,7 @@ def diags( @overload # diagonals: , format: "dok" (positional) def diags( diagonals: _ToArray1D2D[_SCT], - offsets: onp.ToInt | onp.ToInt1D, + offsets: _Offsets, shape: _ToShape2D | None, format: _FmtDOK, dtype: onp.ToDType[_SCT] | None = None, @@ -679,7 +755,7 @@ def diags( @overload # diagonals: , format: "dok" (keyword) def diags( diagonals: _ToArray1D2D[_SCT], - offsets: onp.ToInt | onp.ToInt1D = 0, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, format: _FmtDOK, @@ -688,7 +764,7 @@ def diags( @overload # diagonals: , format: "lil" (positional) def diags( diagonals: _ToArray1D2D[_SCT], - offsets: onp.ToInt | onp.ToInt1D, + offsets: _Offsets, shape: _ToShape2D | None, format: _FmtLIL, dtype: onp.ToDType[_SCT] | None = None, @@ -696,7 +772,7 @@ def diags( @overload # diagonals: , format: "lil" (keyword) def diags( diagonals: _ToArray1D2D[_SCT], - offsets: onp.ToInt | onp.ToInt1D = 0, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, format: _FmtLIL, @@ -705,7 +781,7 @@ def diags( @overload # diagonals: , format: {"dia", None} = ..., dtype: def diags( diagonals: onp.ToComplex1D | onp.ToComplex2D, - offsets: onp.ToInt | onp.ToInt1D = 0, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtDIA | None = None, dtype: npt.DTypeLike | None = None, @@ -713,7 +789,7 @@ def diags( @overload # diagonals: , format: "bsr" (positional), dtype: def diags( diagonals: onp.ToComplex1D | onp.ToComplex2D, - offsets: onp.ToInt | onp.ToInt1D, + offsets: _Offsets, shape: _ToShape2D | None, format: _FmtBSR, dtype: npt.DTypeLike | None = None, @@ -721,7 +797,7 @@ def diags( @overload # diagonals: , format: "bsr" (keyword), dtype: def diags( diagonals: onp.ToComplex1D | onp.ToComplex2D, - offsets: onp.ToInt | onp.ToInt1D = 0, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, format: _FmtBSR, @@ -730,7 +806,7 @@ def diags( @overload # diagonals: , format: "coo" (positional), dtype: def diags( diagonals: onp.ToComplex1D | onp.ToComplex2D, - offsets: onp.ToInt | onp.ToInt1D, + offsets: _Offsets, shape: _ToShape2D | None, format: _FmtCOO, dtype: npt.DTypeLike | None = None, @@ -738,7 +814,7 @@ def diags( @overload # diagonals: , format: "coo" (keyword), dtype: def diags( diagonals: onp.ToComplex1D | onp.ToComplex2D, - offsets: onp.ToInt | onp.ToInt1D = 0, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, format: _FmtCOO, @@ -747,7 +823,7 @@ def diags( @overload # diagonals: , format: "csr" (positional), dtype: def diags( diagonals: onp.ToComplex1D | onp.ToComplex2D, - offsets: onp.ToInt | onp.ToInt1D, + offsets: _Offsets, shape: _ToShape2D | None, format: _FmtCSR, dtype: npt.DTypeLike | None = None, @@ -755,7 +831,7 @@ def diags( @overload # diagonals: , format: "csr" (keyword), dtype: def diags( diagonals: onp.ToComplex1D | onp.ToComplex2D, - offsets: onp.ToInt | onp.ToInt1D = 0, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, format: _FmtCSR, @@ -764,7 +840,7 @@ def diags( @overload # diagonals: , format: "csc" (positional), dtype: def diags( diagonals: onp.ToComplex1D | onp.ToComplex2D, - offsets: onp.ToInt | onp.ToInt1D, + offsets: _Offsets, shape: _ToShape2D | None, format: _FmtCSC, dtype: npt.DTypeLike | None = None, @@ -772,7 +848,7 @@ def diags( @overload # diagonals: , format: "csc" (keyword), dtype: def diags( diagonals: onp.ToComplex1D | onp.ToComplex2D, - offsets: onp.ToInt | onp.ToInt1D = 0, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, format: _FmtCSC, @@ -781,7 +857,7 @@ def diags( @overload # diagonals: , format: "dok" (positional), dtype: def diags( diagonals: onp.ToComplex1D | onp.ToComplex2D, - offsets: onp.ToInt | onp.ToInt1D, + offsets: _Offsets, shape: _ToShape2D | None, format: _FmtDOK, dtype: npt.DTypeLike | None = None, @@ -789,7 +865,7 @@ def diags( @overload # diagonals: , format: "dok" (keyword), dtype: def diags( diagonals: onp.ToComplex1D | onp.ToComplex2D, - offsets: onp.ToInt | onp.ToInt1D = 0, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, format: _FmtDOK, @@ -798,7 +874,7 @@ def diags( @overload # diagonals: , format: "lil" (positional), dtype: def diags( diagonals: onp.ToComplex1D | onp.ToComplex2D, - offsets: onp.ToInt | onp.ToInt1D, + offsets: _Offsets, shape: _ToShape2D | None, format: _FmtLIL, dtype: npt.DTypeLike | None = None, @@ -806,7 +882,7 @@ def diags( @overload # diagonals: , format: "lil" (keyword), dtype: def diags( diagonals: onp.ToComplex1D | onp.ToComplex2D, - offsets: onp.ToInt | onp.ToInt1D = 0, + offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, format: _FmtLIL, @@ -816,24 +892,24 @@ def diags( # NOTE: `diags_array` should be prefered over `spdiags` @overload def spdiags( - data: _ToArray1D2D[_SCT], diags: onp.ToInt | onp.ToInt1D, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtDIA | None = None + data: _ToArray1D2D[_SCT], diags: _Offsets, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtDIA | None = None ) -> dia_matrix[_SCT]: ... @overload def spdiags( data: _ToArray1D2D[_SCT], - diags: onp.ToInt | onp.ToInt1D, + diags: _Offsets, m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, n: None = None, format: _FmtDIA | None = None, ) -> dia_matrix[_SCT]: ... @overload def spdiags( - data: _ToArray1D2D[_SCT], diags: onp.ToInt | onp.ToInt1D, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtBSR + data: _ToArray1D2D[_SCT], diags: _Offsets, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtBSR ) -> bsr_matrix[_SCT]: ... @overload def spdiags( data: _ToArray1D2D[_SCT], - diags: onp.ToInt | onp.ToInt1D, + diags: _Offsets, m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, n: None = None, *, @@ -841,12 +917,12 @@ def spdiags( ) -> bsr_matrix[_SCT]: ... @overload def spdiags( - data: _ToArray1D2D[_SCT], diags: onp.ToInt | onp.ToInt1D, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtCOO + data: _ToArray1D2D[_SCT], diags: _Offsets, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtCOO ) -> coo_matrix[_SCT]: ... @overload def spdiags( data: _ToArray1D2D[_SCT], - diags: onp.ToInt | onp.ToInt1D, + diags: _Offsets, m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, n: None = None, *, @@ -854,12 +930,12 @@ def spdiags( ) -> coo_matrix[_SCT]: ... @overload def spdiags( - data: _ToArray1D2D[_SCT], diags: onp.ToInt | onp.ToInt1D, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtCSR + data: _ToArray1D2D[_SCT], diags: _Offsets, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtCSR ) -> csr_matrix[_SCT]: ... @overload def spdiags( data: _ToArray1D2D[_SCT], - diags: onp.ToInt | onp.ToInt1D, + diags: _Offsets, m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, n: None = None, *, @@ -867,12 +943,12 @@ def spdiags( ) -> csr_matrix[_SCT]: ... @overload def spdiags( - data: _ToArray1D2D[_SCT], diags: onp.ToInt | onp.ToInt1D, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtCSC + data: _ToArray1D2D[_SCT], diags: _Offsets, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtCSC ) -> csc_matrix[_SCT]: ... @overload def spdiags( data: _ToArray1D2D[_SCT], - diags: onp.ToInt | onp.ToInt1D, + diags: _Offsets, m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, n: None = None, *, @@ -880,12 +956,12 @@ def spdiags( ) -> csc_matrix[_SCT]: ... @overload def spdiags( - data: _ToArray1D2D[_SCT], diags: onp.ToInt | onp.ToInt1D, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtDOK + data: _ToArray1D2D[_SCT], diags: _Offsets, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtDOK ) -> dok_matrix[_SCT]: ... @overload def spdiags( data: _ToArray1D2D[_SCT], - diags: onp.ToInt | onp.ToInt1D, + diags: _Offsets, m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, n: None = None, *, @@ -893,12 +969,12 @@ def spdiags( ) -> dok_matrix[_SCT]: ... @overload def spdiags( - data: _ToArray1D2D[_SCT], diags: onp.ToInt | onp.ToInt1D, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtLIL + data: _ToArray1D2D[_SCT], diags: _Offsets, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtLIL ) -> lil_matrix[_SCT]: ... @overload def spdiags( data: _ToArray1D2D[_SCT], - diags: onp.ToInt | onp.ToInt1D, + diags: _Offsets, m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, n: None = None, *, diff --git a/tests/sparse/test_construct.pyi b/tests/sparse/test_construct.pyi index 66ce4a3f..e3994f69 100644 --- a/tests/sparse/test_construct.pyi +++ b/tests/sparse/test_construct.pyi @@ -1,6 +1,7 @@ -from typing import Any, assert_type +from typing import assert_type import numpy as np +from numpy._typing import _64Bit import scipy.sparse as sparse from ._types import ( @@ -36,8 +37,13 @@ int_list: list[int] ### # diags_array -assert_type(sparse.diags_array([1, 2]), sparse.dia_array[Any]) -assert_type(sparse.diags_array([[1, 2.0], [3j]], offsets=int_list), sparse.dia_array[Any]) +# TODO: find way to only return float64 for real numbers and complex128 if there is a single complex number inside the sequence +assert_type(sparse.diags_array([1, 2]), sparse.dia_array[np.number[_64Bit, int | float]]) +assert_type(sparse.diags_array([[1, 2], 2.0]), sparse.dia_array[np.number[_64Bit, float]]) +assert_type(sparse.diags_array([[1, 2.0], [2]]), sparse.dia_array[np.number[_64Bit, int | float]]) +assert_type(sparse.diags_array([3j, 5j]), sparse.dia_array[np.number[_64Bit, float | complex]]) +assert_type(sparse.diags_array([[1, 2.0], [3j]]), sparse.dia_array[np.number[_64Bit, float | complex]]) +assert_type(sparse.diags_array([[1, 2.0], 3j]), sparse.dia_array[np.number[_64Bit, float | complex]]) assert_type(sparse.diags_array(dense_1d), sparse.dia_array[ScalarType]) assert_type(sparse.diags_array(dense_1d.astype(np.longdouble)), sparse.dia_array[np.longdouble]) assert_type(sparse.diags_array(dense_1d.astype(np.complex128)), sparse.dia_array[np.complex128]) From 5c83eacf45c3afdeb2aebde6a3ff29d3b8c79350 Mon Sep 17 00:00:00 2001 From: Jul Van den Broeck Date: Mon, 14 Jul 2025 19:57:27 +0200 Subject: [PATCH 07/20] Workaround for mypy errors regarding TypeAlias --- scipy-stubs/sparse/_construct.pyi | 55 +++++++++++++++---------------- 1 file changed, 27 insertions(+), 28 deletions(-) diff --git a/scipy-stubs/sparse/_construct.pyi b/scipy-stubs/sparse/_construct.pyi index dcc0da91..9a37caf2 100644 --- a/scipy-stubs/sparse/_construct.pyi +++ b/scipy-stubs/sparse/_construct.pyi @@ -53,7 +53,6 @@ _CanArray1D2D: TypeAlias = _CanArray1D[_SCT] | _CanArray2D[_SCT] _ToArray1D: TypeAlias = onp.ToArray1D[_PSCT, _SCT] _ToArray2D: TypeAlias = onp.ToArray2D[_PSCT, _SCT] -_ToArray1D2D: TypeAlias = _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT] _ToSpMatrix: TypeAlias = spmatrix[_SCT] | _ToArray2D[_PSCT, _SCT] _ToSparse2D: TypeAlias = _spbase[_SCT, tuple[int, int]] | _ToArray2D[_PSCT, _SCT] @@ -670,7 +669,7 @@ def diags_array( # NOTE: `diags_array` should be prefered over `diags` @overload # diagonals: , format: {"dia", None} = ... def diags( - diagonals: _ToArray1D2D[_SCT], + diagonals: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtDIA | None = None, @@ -678,7 +677,7 @@ def diags( ) -> dia_matrix[_SCT]: ... @overload # diagonals: , format: "bsr" (positional) def diags( - diagonals: _ToArray1D2D[_SCT], + diagonals: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], offsets: _Offsets, shape: _ToShape2D | None, format: _FmtBSR, @@ -686,7 +685,7 @@ def diags( ) -> bsr_matrix[_SCT]: ... @overload # diagonals: , format: "bsr" (keyword) def diags( - diagonals: _ToArray1D2D[_SCT], + diagonals: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, @@ -695,7 +694,7 @@ def diags( ) -> bsr_matrix[_SCT]: ... @overload # diagonals: , format: "coo" (positional) def diags( - diagonals: _ToArray1D2D[_SCT], + diagonals: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], offsets: _Offsets, shape: _ToShape2D | None, format: _FmtCOO, @@ -703,7 +702,7 @@ def diags( ) -> coo_matrix[_SCT]: ... @overload # diagonals: , format: "coo" (keyword) def diags( - diagonals: _ToArray1D2D[_SCT], + diagonals: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, @@ -712,7 +711,7 @@ def diags( ) -> coo_matrix[_SCT]: ... @overload # diagonals: , format: "csr" (positional) def diags( - diagonals: _ToArray1D2D[_SCT], + diagonals: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], offsets: _Offsets, shape: _ToShape2D | None, format: _FmtCSR, @@ -720,7 +719,7 @@ def diags( ) -> csr_matrix[_SCT]: ... @overload # diagonals: , format: "csr" (keyword) def diags( - diagonals: _ToArray1D2D[_SCT], + diagonals: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, @@ -729,7 +728,7 @@ def diags( ) -> csr_matrix[_SCT]: ... @overload # diagonals: , format: "csc" (positional) def diags( - diagonals: _ToArray1D2D[_SCT], + diagonals: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], offsets: _Offsets, shape: _ToShape2D | None, format: _FmtCSC, @@ -737,7 +736,7 @@ def diags( ) -> csc_matrix[_SCT]: ... @overload # diagonals: , format: "csc" (keyword) def diags( - diagonals: _ToArray1D2D[_SCT], + diagonals: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, @@ -746,7 +745,7 @@ def diags( ) -> csc_matrix[_SCT]: ... @overload # diagonals: , format: "dok" (positional) def diags( - diagonals: _ToArray1D2D[_SCT], + diagonals: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], offsets: _Offsets, shape: _ToShape2D | None, format: _FmtDOK, @@ -754,7 +753,7 @@ def diags( ) -> dok_matrix[_SCT]: ... @overload # diagonals: , format: "dok" (keyword) def diags( - diagonals: _ToArray1D2D[_SCT], + diagonals: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, @@ -763,7 +762,7 @@ def diags( ) -> dok_matrix[_SCT]: ... @overload # diagonals: , format: "lil" (positional) def diags( - diagonals: _ToArray1D2D[_SCT], + diagonals: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], offsets: _Offsets, shape: _ToShape2D | None, format: _FmtLIL, @@ -771,7 +770,7 @@ def diags( ) -> lil_matrix[_SCT]: ... @overload # diagonals: , format: "lil" (keyword) def diags( - diagonals: _ToArray1D2D[_SCT], + diagonals: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, @@ -892,11 +891,11 @@ def diags( # NOTE: `diags_array` should be prefered over `spdiags` @overload def spdiags( - data: _ToArray1D2D[_SCT], diags: _Offsets, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtDIA | None = None + data: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], diags: _Offsets, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtDIA | None = None ) -> dia_matrix[_SCT]: ... @overload def spdiags( - data: _ToArray1D2D[_SCT], + data: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], diags: _Offsets, m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, n: None = None, @@ -904,11 +903,11 @@ def spdiags( ) -> dia_matrix[_SCT]: ... @overload def spdiags( - data: _ToArray1D2D[_SCT], diags: _Offsets, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtBSR + data: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], diags: _Offsets, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtBSR ) -> bsr_matrix[_SCT]: ... @overload def spdiags( - data: _ToArray1D2D[_SCT], + data: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], diags: _Offsets, m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, n: None = None, @@ -917,11 +916,11 @@ def spdiags( ) -> bsr_matrix[_SCT]: ... @overload def spdiags( - data: _ToArray1D2D[_SCT], diags: _Offsets, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtCOO + data: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], diags: _Offsets, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtCOO ) -> coo_matrix[_SCT]: ... @overload def spdiags( - data: _ToArray1D2D[_SCT], + data: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], diags: _Offsets, m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, n: None = None, @@ -930,11 +929,11 @@ def spdiags( ) -> coo_matrix[_SCT]: ... @overload def spdiags( - data: _ToArray1D2D[_SCT], diags: _Offsets, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtCSR + data: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], diags: _Offsets, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtCSR ) -> csr_matrix[_SCT]: ... @overload def spdiags( - data: _ToArray1D2D[_SCT], + data: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], diags: _Offsets, m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, n: None = None, @@ -943,11 +942,11 @@ def spdiags( ) -> csr_matrix[_SCT]: ... @overload def spdiags( - data: _ToArray1D2D[_SCT], diags: _Offsets, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtCSC + data: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], diags: _Offsets, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtCSC ) -> csc_matrix[_SCT]: ... @overload def spdiags( - data: _ToArray1D2D[_SCT], + data: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], diags: _Offsets, m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, n: None = None, @@ -956,11 +955,11 @@ def spdiags( ) -> csc_matrix[_SCT]: ... @overload def spdiags( - data: _ToArray1D2D[_SCT], diags: _Offsets, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtDOK + data: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], diags: _Offsets, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtDOK ) -> dok_matrix[_SCT]: ... @overload def spdiags( - data: _ToArray1D2D[_SCT], + data: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], diags: _Offsets, m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, n: None = None, @@ -969,11 +968,11 @@ def spdiags( ) -> dok_matrix[_SCT]: ... @overload def spdiags( - data: _ToArray1D2D[_SCT], diags: _Offsets, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtLIL + data: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], diags: _Offsets, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtLIL ) -> lil_matrix[_SCT]: ... @overload def spdiags( - data: _ToArray1D2D[_SCT], + data: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], diags: _Offsets, m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, n: None = None, From 3aec622e1c5b4394789dc545fcdcfa0490cff672 Mon Sep 17 00:00:00 2001 From: Jul Van den Broeck Date: Mon, 14 Jul 2025 19:59:01 +0200 Subject: [PATCH 08/20] Formatted with ruff --- scipy-stubs/sparse/_construct.pyi | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/scipy-stubs/sparse/_construct.pyi b/scipy-stubs/sparse/_construct.pyi index 9a37caf2..4b87b9f5 100644 --- a/scipy-stubs/sparse/_construct.pyi +++ b/scipy-stubs/sparse/_construct.pyi @@ -891,7 +891,11 @@ def diags( # NOTE: `diags_array` should be prefered over `spdiags` @overload def spdiags( - data: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], diags: _Offsets, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtDIA | None = None + data: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], + diags: _Offsets, + m: onp.ToJustInt, + n: onp.ToJustInt, + format: _FmtDIA | None = None, ) -> dia_matrix[_SCT]: ... @overload def spdiags( From 3c287a42e761db2bb780e08deb2f8363c12012b9 Mon Sep 17 00:00:00 2001 From: Jul Van den Broeck Date: Mon, 14 Jul 2025 20:23:32 +0200 Subject: [PATCH 09/20] Gave up on type hinting Python lists accurately, resorted to union of np.float64 or np.complex128 --- scipy-stubs/sparse/_construct.pyi | 15 +++++++-------- tests/sparse/test_construct.pyi | 13 ++++++------- 2 files changed, 13 insertions(+), 15 deletions(-) diff --git a/scipy-stubs/sparse/_construct.pyi b/scipy-stubs/sparse/_construct.pyi index 4b87b9f5..f623030a 100644 --- a/scipy-stubs/sparse/_construct.pyi +++ b/scipy-stubs/sparse/_construct.pyi @@ -3,7 +3,6 @@ from collections.abc import Callable, Iterable, Sequence as Seq from typing import Any, Literal, Protocol, TypeAlias, TypeVar, overload, type_check_only import numpy as np -import numpy._typing as _npt import numpy.typing as npt import optype.numpy as onp import optype.numpy.compat as npc @@ -102,7 +101,7 @@ def diags_array( shape: _ToShape2D | None = None, format: _FmtDIA | None = None, dtype: None = None, -) -> _DIAArray[np.number[_npt._64Bit, float | _PSCT]]: ... +) -> _DIAArray[np.float64] | _DIAArray[np.complex128]: ... @overload # diagonals: , dtype: None = ..., format: {"dia", None} = ... def diags_array( diagonals: _CanArray1D2D[_SCT], @@ -184,7 +183,7 @@ def diags_array( shape: _ToShape2D | None = None, format: _FmtBSR, dtype: None = None, -) -> _BSRArray[np.number[_npt._64Bit, float | _PSCT]]: ... +) -> _BSRArray[np.float64] | _BSRArray[np.complex128]: ... @overload # diagonals: , format: "bsr", dtype: None def diags_array( diagonals: _CanArray1D2D[_SCT], @@ -266,7 +265,7 @@ def diags_array( shape: _ToShape2D | None = None, format: _FmtCOO, dtype: None = None, -) -> _COOArray2D[np.number[_npt._64Bit, float | _PSCT]]: ... +) -> _COOArray2D[np.float64] | _COOArray2D[np.complex128]: ... @overload # diagonals: , format: "coo", dtype: None def diags_array( diagonals: _CanArray1D2D[_SCT], @@ -348,7 +347,7 @@ def diags_array( shape: _ToShape2D | None = None, format: _FmtCSC, dtype: None = None, -) -> _CSCArray[np.number[_npt._64Bit, float | _PSCT]]: ... +) -> _CSCArray[np.float64] | _CSCArray[np.complex128]: ... @overload # diagonals: , format: "csc", dtype: None def diags_array( diagonals: _CanArray1D2D[_SCT], @@ -430,7 +429,7 @@ def diags_array( shape: _ToShape2D | None = None, format: _FmtCSR, dtype: None = None, -) -> _CSRArray2D[np.number[_npt._64Bit, float | _PSCT]]: ... +) -> _CSRArray2D[np.float64] | _CSRArray2D[np.complex128]: ... @overload # diagonals: , format: "csr", dtype: None def diags_array( diagonals: _CanArray1D2D[_SCT], @@ -512,7 +511,7 @@ def diags_array( shape: _ToShape2D | None = None, format: _FmtDOK, dtype: None = None, -) -> _DOKArray2D[np.number[_npt._64Bit, float | _PSCT]]: ... +) -> _DOKArray2D[np.float64] | _DOKArray2D[np.complex128]: ... @overload # diagonals: , format: "dok", dtype: None def diags_array( diagonals: _CanArray1D2D[_SCT], @@ -594,7 +593,7 @@ def diags_array( shape: _ToShape2D | None = None, format: _FmtLIL, dtype: None = None, -) -> _LILArray[np.number[_npt._64Bit, float | _PSCT]]: ... +) -> _LILArray[np.float64] | _LILArray[np.complex128]: ... @overload # diagonals: , format: "lil", dtype: None def diags_array( diagonals: _CanArray1D2D[_SCT], diff --git a/tests/sparse/test_construct.pyi b/tests/sparse/test_construct.pyi index e3994f69..afe04594 100644 --- a/tests/sparse/test_construct.pyi +++ b/tests/sparse/test_construct.pyi @@ -1,7 +1,6 @@ from typing import assert_type import numpy as np -from numpy._typing import _64Bit import scipy.sparse as sparse from ._types import ( @@ -38,12 +37,12 @@ int_list: list[int] ### # diags_array # TODO: find way to only return float64 for real numbers and complex128 if there is a single complex number inside the sequence -assert_type(sparse.diags_array([1, 2]), sparse.dia_array[np.number[_64Bit, int | float]]) -assert_type(sparse.diags_array([[1, 2], 2.0]), sparse.dia_array[np.number[_64Bit, float]]) -assert_type(sparse.diags_array([[1, 2.0], [2]]), sparse.dia_array[np.number[_64Bit, int | float]]) -assert_type(sparse.diags_array([3j, 5j]), sparse.dia_array[np.number[_64Bit, float | complex]]) -assert_type(sparse.diags_array([[1, 2.0], [3j]]), sparse.dia_array[np.number[_64Bit, float | complex]]) -assert_type(sparse.diags_array([[1, 2.0], 3j]), sparse.dia_array[np.number[_64Bit, float | complex]]) +assert_type(sparse.diags_array([1, 2]), sparse.dia_array[np.float64] | sparse.dia_array[np.complex128]) +assert_type(sparse.diags_array([[1, 2], 2.0]), sparse.dia_array[np.float64] | sparse.dia_array[np.complex128]) +assert_type(sparse.diags_array([[1, 2.0], [2]]), sparse.dia_array[np.float64] | sparse.dia_array[np.complex128]) +assert_type(sparse.diags_array([3j, 5j]), sparse.dia_array[np.float64] | sparse.dia_array[np.complex128]) +assert_type(sparse.diags_array([[1, 2.0], [3j]]), sparse.dia_array[np.float64] | sparse.dia_array[np.complex128]) +assert_type(sparse.diags_array([[1, 2.0], 3j]), sparse.dia_array[np.float64] | sparse.dia_array[np.complex128]) assert_type(sparse.diags_array(dense_1d), sparse.dia_array[ScalarType]) assert_type(sparse.diags_array(dense_1d.astype(np.longdouble)), sparse.dia_array[np.longdouble]) assert_type(sparse.diags_array(dense_1d.astype(np.complex128)), sparse.dia_array[np.complex128]) From 5808bf55cf578d5707f0d962a20ebb0d7bf73b74 Mon Sep 17 00:00:00 2001 From: Jul Van den Broeck Date: Wed, 16 Jul 2025 22:44:49 +0200 Subject: [PATCH 10/20] Cleaned up unused type variables + changed back to original _ToArray*D --- .vscode/settings.json | 2 + scipy-stubs/sparse/_construct.pyi | 193 ++++++++++++------------------ tests/sparse/test_construct.pyi | 2 - 3 files changed, 77 insertions(+), 120 deletions(-) diff --git a/.vscode/settings.json b/.vscode/settings.json index c558cc65..2a765c76 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -42,4 +42,6 @@ "--refresh-package=scipy-stubs", "mypy", ], + "python.languageServer": "None", + "python.analysis.typeCheckingMode": "off", } diff --git a/scipy-stubs/sparse/_construct.pyi b/scipy-stubs/sparse/_construct.pyi index f623030a..66eb9a17 100644 --- a/scipy-stubs/sparse/_construct.pyi +++ b/scipy-stubs/sparse/_construct.pyi @@ -41,19 +41,16 @@ __all__ = [ _Numeric: TypeAlias = np.bool_ | npc.number _T = TypeVar("_T") -_PSCT = TypeVar("_PSCT", bound=int | float | complex, default=Any) _SCT = TypeVar("_SCT", bound=_Numeric, default=Any) _SCT0 = TypeVar("_SCT0", bound=_Numeric) _ShapeT = TypeVar("_ShapeT", bound=tuple[int, *tuple[int, ...]], default=tuple[Any, ...]) -_CanArray1D: TypeAlias = onp.CanArray1D[_SCT] -_CanArray2D: TypeAlias = onp.CanArray2D[_SCT] -_CanArray1D2D: TypeAlias = _CanArray1D[_SCT] | _CanArray2D[_SCT] - -_ToArray1D: TypeAlias = onp.ToArray1D[_PSCT, _SCT] -_ToArray2D: TypeAlias = onp.ToArray2D[_PSCT, _SCT] -_ToSpMatrix: TypeAlias = spmatrix[_SCT] | _ToArray2D[_PSCT, _SCT] -_ToSparse2D: TypeAlias = _spbase[_SCT, tuple[int, int]] | _ToArray2D[_PSCT, _SCT] +_ToArray1D: TypeAlias = Seq[_SCT] | onp.CanArrayND[_SCT] +_ToArray2D: TypeAlias = Seq[Seq[_SCT] | onp.CanArray1D[_SCT]] | onp.CanArray2D[_SCT] +_ToArray1D2D: TypeAlias = _ToArray1D[_SCT] | _ToArray2D[_SCT] +_CanArray1D2D: TypeAlias = onp.CanArray1D[_SCT] | onp.CanArray2D[_SCT] +_ToSpMatrix: TypeAlias = spmatrix[_SCT] | _ToArray2D[_SCT] +_ToSparse2D: TypeAlias = _spbase[_SCT, tuple[int, int]] | _ToArray2D[_SCT] _SpBase: TypeAlias = _spbase[_SCT, _ShapeT] | Any _SpMatrix: TypeAlias = spmatrix[_SCT] | Any @@ -80,7 +77,7 @@ _FmtDOK: TypeAlias = Literal["dok"] _FmtLIL: TypeAlias = Literal["lil"] _FmtNonCOO: TypeAlias = Literal["bsr", "csc", "csr", "dia", "dok", "lil"] -_ComplexSeq1D2D: TypeAlias = Seq[_PSCT] | Seq[Seq[_PSCT] | _PSCT] +_ComplexSeq1D2D: TypeAlias = Seq[Seq[complex] | complex] _Offsets: TypeAlias = onp.ToInt | onp.ToInt1D _DataRVS: TypeAlias = Callable[[int], onp.ArrayND[_Numeric]] @@ -94,7 +91,7 @@ class _DataSampler(Protocol): ### @overload # diagonals: , dtype: None = ..., format: {"dia", None} = ... def diags_array( - diagonals: _ComplexSeq1D2D[_PSCT], + diagonals: _ComplexSeq1D2D, /, *, offsets: _Offsets = 0, @@ -114,7 +111,7 @@ def diags_array( ) -> _DIAArray[_SCT]: ... @overload # diagonals: , format: {"dia", None} = ..., dtype: bool-like def diags_array( - diagonals: _CanArray1D2D[_SCT], + diagonals: onp.CanArray1D | onp.CanArray2D, /, *, offsets: _Offsets = 0, @@ -124,7 +121,7 @@ def diags_array( ) -> _DIAArray[np.bool_]: ... @overload # diagonals: , format: {"dia", None} = ..., dtype: int-like def diags_array( - diagonals: _CanArray1D2D[_SCT], + diagonals: onp.CanArray1D | onp.CanArray2D, /, *, offsets: _Offsets = 0, @@ -134,7 +131,7 @@ def diags_array( ) -> _DIAArray[np.int_]: ... @overload # diagonals: , format: {"dia", None} = ..., dtype: float64-like def diags_array( - diagonals: _CanArray1D2D[_SCT], + diagonals: onp.CanArray1D | onp.CanArray2D, /, *, offsets: _Offsets = 0, @@ -144,7 +141,7 @@ def diags_array( ) -> _DIAArray[np.float64]: ... @overload # diagonals: , format: {"dia", None} = ..., dtype: complex128-like def diags_array( - diagonals: _CanArray1D2D[_SCT], + diagonals: onp.CanArray1D | onp.CanArray2D, /, *, offsets: _Offsets = 0, @@ -176,17 +173,11 @@ def diags_array( # BSR @overload # diagonals: , format: "bsr", dtype: None def diags_array( - diagonals: _ComplexSeq1D2D[_PSCT], - /, - *, - offsets: _Offsets = 0, - shape: _ToShape2D | None = None, - format: _FmtBSR, - dtype: None = None, + diagonals: _ComplexSeq1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtBSR, dtype: None = None ) -> _BSRArray[np.float64] | _BSRArray[np.complex128]: ... @overload # diagonals: , format: "bsr", dtype: None def diags_array( - diagonals: _CanArray1D2D[_SCT], + diagonals: onp.CanArray1D[_SCT] | onp.CanArray2D[_SCT], /, *, offsets: _Offsets = 0, @@ -196,7 +187,7 @@ def diags_array( ) -> _BSRArray[_SCT]: ... @overload # diagonals: , format: "bsr", dtype: bool-like def diags_array( - diagonals: _CanArray1D2D[_SCT], + diagonals: onp.CanArray1D | onp.CanArray2D, /, *, offsets: _Offsets = 0, @@ -206,7 +197,7 @@ def diags_array( ) -> _BSRArray[np.bool_]: ... @overload # diagonals: , format: "bsr", dtype: int-like def diags_array( - diagonals: _CanArray1D2D[_SCT], + diagonals: onp.CanArray1D | onp.CanArray2D, /, *, offsets: _Offsets = 0, @@ -216,7 +207,7 @@ def diags_array( ) -> _BSRArray[np.int_]: ... @overload # diagonals: , format: "bsr", dtype: float64-like def diags_array( - diagonals: _CanArray1D2D[_SCT], + diagonals: onp.CanArray1D | onp.CanArray2D, /, *, offsets: _Offsets = 0, @@ -226,7 +217,7 @@ def diags_array( ) -> _BSRArray[np.float64]: ... @overload # diagonals: , format: "bsr", dtype: complex128-like def diags_array( - diagonals: _CanArray1D2D[_SCT], + diagonals: onp.CanArray1D | onp.CanArray2D, /, *, offsets: _Offsets = 0, @@ -258,17 +249,11 @@ def diags_array( # COO @overload # diagonals: , format: "coo", dtype: None def diags_array( - diagonals: _ComplexSeq1D2D[_PSCT], - /, - *, - offsets: _Offsets = 0, - shape: _ToShape2D | None = None, - format: _FmtCOO, - dtype: None = None, + diagonals: _ComplexSeq1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCOO, dtype: None = None ) -> _COOArray2D[np.float64] | _COOArray2D[np.complex128]: ... @overload # diagonals: , format: "coo", dtype: None def diags_array( - diagonals: _CanArray1D2D[_SCT], + diagonals: onp.CanArray1D[_SCT] | onp.CanArray2D[_SCT], /, *, offsets: _Offsets = 0, @@ -278,7 +263,7 @@ def diags_array( ) -> _COOArray2D[_SCT]: ... @overload # diagonals: , format: "coo", dtype: bool-like def diags_array( - diagonals: _CanArray1D2D[_SCT], + diagonals: onp.CanArray1D | onp.CanArray2D, /, *, offsets: _Offsets = 0, @@ -288,7 +273,7 @@ def diags_array( ) -> _COOArray2D[np.bool_]: ... @overload # diagonals: , format: "coo", dtype: int-like def diags_array( - diagonals: _CanArray1D2D[_SCT], + diagonals: onp.CanArray1D | onp.CanArray2D, /, *, offsets: _Offsets = 0, @@ -298,7 +283,7 @@ def diags_array( ) -> _COOArray2D[np.int_]: ... @overload # diagonals: , format: "coo", dtype: float64-like def diags_array( - diagonals: _CanArray1D2D[_SCT], + diagonals: onp.CanArray1D | onp.CanArray2D, /, *, offsets: _Offsets = 0, @@ -308,7 +293,7 @@ def diags_array( ) -> _COOArray2D[np.float64]: ... @overload # diagonals: , format: "coo", dtype: complex128-like def diags_array( - diagonals: _CanArray1D2D[_SCT], + diagonals: onp.CanArray1D | onp.CanArray2D, /, *, offsets: _Offsets = 0, @@ -340,17 +325,11 @@ def diags_array( # CSC @overload # diagonals: , format: "csc", dtype: None def diags_array( - diagonals: _ComplexSeq1D2D[_PSCT], - /, - *, - offsets: _Offsets = 0, - shape: _ToShape2D | None = None, - format: _FmtCSC, - dtype: None = None, + diagonals: _ComplexSeq1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCSC, dtype: None = None ) -> _CSCArray[np.float64] | _CSCArray[np.complex128]: ... @overload # diagonals: , format: "csc", dtype: None def diags_array( - diagonals: _CanArray1D2D[_SCT], + diagonals: onp.CanArray1D[_SCT] | onp.CanArray2D[_SCT], /, *, offsets: _Offsets = 0, @@ -360,7 +339,7 @@ def diags_array( ) -> _CSCArray[_SCT]: ... @overload # diagonals: , format: "csc", dtype: bool-like def diags_array( - diagonals: _CanArray1D2D[_SCT], + diagonals: onp.CanArray1D | onp.CanArray2D, /, *, offsets: _Offsets = 0, @@ -370,7 +349,7 @@ def diags_array( ) -> _CSCArray[np.bool_]: ... @overload # diagonals: , format: "csc", dtype: int-like def diags_array( - diagonals: _CanArray1D2D[_SCT], + diagonals: onp.CanArray1D | onp.CanArray2D, /, *, offsets: _Offsets = 0, @@ -380,7 +359,7 @@ def diags_array( ) -> _CSCArray[np.int_]: ... @overload # diagonals: , format: "csc", dtype: float64-like def diags_array( - diagonals: _CanArray1D2D[_SCT], + diagonals: onp.CanArray1D | onp.CanArray2D, /, *, offsets: _Offsets = 0, @@ -390,7 +369,7 @@ def diags_array( ) -> _CSCArray[np.float64]: ... @overload # diagonals: , format: "csc", dtype: complex128-like def diags_array( - diagonals: _CanArray1D2D[_SCT], + diagonals: onp.CanArray1D | onp.CanArray2D, /, *, offsets: _Offsets = 0, @@ -422,17 +401,11 @@ def diags_array( # CSR @overload # diagonals: , format: "csr", dtype: None def diags_array( - diagonals: _ComplexSeq1D2D[_PSCT], - /, - *, - offsets: _Offsets = 0, - shape: _ToShape2D | None = None, - format: _FmtCSR, - dtype: None = None, + diagonals: _ComplexSeq1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCSR, dtype: None = None ) -> _CSRArray2D[np.float64] | _CSRArray2D[np.complex128]: ... @overload # diagonals: , format: "csr", dtype: None def diags_array( - diagonals: _CanArray1D2D[_SCT], + diagonals: onp.CanArray1D[_SCT] | onp.CanArray2D[_SCT], /, *, offsets: _Offsets = 0, @@ -442,7 +415,7 @@ def diags_array( ) -> _CSRArray2D[_SCT]: ... @overload # diagonals: , format: "csr", dtype: bool-like def diags_array( - diagonals: _CanArray1D2D[_SCT], + diagonals: onp.CanArray1D | onp.CanArray2D, /, *, offsets: _Offsets = 0, @@ -452,7 +425,7 @@ def diags_array( ) -> _CSRArray2D[np.bool_]: ... @overload # diagonals: , format: "csr", dtype: int-like def diags_array( - diagonals: _CanArray1D2D[_SCT], + diagonals: onp.CanArray1D | onp.CanArray2D, /, *, offsets: _Offsets = 0, @@ -462,7 +435,7 @@ def diags_array( ) -> _CSRArray2D[np.int_]: ... @overload # diagonals: , format: "csr", dtype: float64-like def diags_array( - diagonals: _CanArray1D2D[_SCT], + diagonals: onp.CanArray1D | onp.CanArray2D, /, *, offsets: _Offsets = 0, @@ -472,7 +445,7 @@ def diags_array( ) -> _CSRArray2D[np.float64]: ... @overload # diagonals: , format: "csr", dtype: complex128-like def diags_array( - diagonals: _CanArray1D2D[_SCT], + diagonals: onp.CanArray1D | onp.CanArray2D, /, *, offsets: _Offsets = 0, @@ -504,17 +477,11 @@ def diags_array( # DOK @overload # diagonals: , format: "dok", dtype: None def diags_array( - diagonals: _ComplexSeq1D2D[_PSCT], - /, - *, - offsets: _Offsets = 0, - shape: _ToShape2D | None = None, - format: _FmtDOK, - dtype: None = None, + diagonals: _ComplexSeq1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtDOK, dtype: None = None ) -> _DOKArray2D[np.float64] | _DOKArray2D[np.complex128]: ... @overload # diagonals: , format: "dok", dtype: None def diags_array( - diagonals: _CanArray1D2D[_SCT], + diagonals: onp.CanArray1D[_SCT] | onp.CanArray2D[_SCT], /, *, offsets: _Offsets = 0, @@ -524,7 +491,7 @@ def diags_array( ) -> _DOKArray2D[_SCT]: ... @overload # diagonals: , format: "dok", dtype: bool-like def diags_array( - diagonals: _CanArray1D2D[_SCT], + diagonals: onp.CanArray1D | onp.CanArray2D, /, *, offsets: _Offsets = 0, @@ -534,7 +501,7 @@ def diags_array( ) -> _DOKArray2D[np.bool_]: ... @overload # diagonals: , format: "dok", dtype: int-like def diags_array( - diagonals: _CanArray1D2D[_SCT], + diagonals: onp.CanArray1D | onp.CanArray2D, /, *, offsets: _Offsets = 0, @@ -544,7 +511,7 @@ def diags_array( ) -> _DOKArray2D[np.int_]: ... @overload # diagonals: , format: "dok", dtype: float64-like def diags_array( - diagonals: _CanArray1D2D[_SCT], + diagonals: onp.CanArray1D | onp.CanArray2D, /, *, offsets: _Offsets = 0, @@ -554,7 +521,7 @@ def diags_array( ) -> _DOKArray2D[np.float64]: ... @overload # diagonals: , format: "dok", dtype: complex128-like def diags_array( - diagonals: _CanArray1D2D[_SCT], + diagonals: onp.CanArray1D | onp.CanArray2D, /, *, offsets: _Offsets = 0, @@ -586,17 +553,11 @@ def diags_array( # LIL @overload # diagonals: , format: "lil", dtype: None def diags_array( - diagonals: _ComplexSeq1D2D[_PSCT], - /, - *, - offsets: _Offsets = 0, - shape: _ToShape2D | None = None, - format: _FmtLIL, - dtype: None = None, + diagonals: _ComplexSeq1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtLIL, dtype: None = None ) -> _LILArray[np.float64] | _LILArray[np.complex128]: ... @overload # diagonals: , format: "lil", dtype: None def diags_array( - diagonals: _CanArray1D2D[_SCT], + diagonals: onp.CanArray1D[_SCT] | onp.CanArray2D[_SCT], /, *, offsets: _Offsets = 0, @@ -606,7 +567,7 @@ def diags_array( ) -> _LILArray[_SCT]: ... @overload # diagonals: , format: "lil", dtype: bool-like def diags_array( - diagonals: _CanArray1D2D[_SCT], + diagonals: onp.CanArray1D | onp.CanArray2D, /, *, offsets: _Offsets = 0, @@ -616,7 +577,7 @@ def diags_array( ) -> _LILArray[np.bool_]: ... @overload # diagonals: , format: "lil", dtype: int-like def diags_array( - diagonals: _CanArray1D2D[_SCT], + diagonals: onp.CanArray1D | onp.CanArray2D, /, *, offsets: _Offsets = 0, @@ -626,7 +587,7 @@ def diags_array( ) -> _LILArray[np.int_]: ... @overload # diagonals: , format: "lil", dtype: float64-like def diags_array( - diagonals: _CanArray1D2D[_SCT], + diagonals: onp.CanArray1D | onp.CanArray2D, /, *, offsets: _Offsets = 0, @@ -636,7 +597,7 @@ def diags_array( ) -> _LILArray[np.float64]: ... @overload # diagonals: , format: "lil", dtype: complex128-like def diags_array( - diagonals: _CanArray1D2D[_SCT], + diagonals: onp.CanArray1D | onp.CanArray2D, /, *, offsets: _Offsets = 0, @@ -668,7 +629,7 @@ def diags_array( # NOTE: `diags_array` should be prefered over `diags` @overload # diagonals: , format: {"dia", None} = ... def diags( - diagonals: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], + diagonals: _ToArray1D2D[_SCT], offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtDIA | None = None, @@ -676,7 +637,7 @@ def diags( ) -> dia_matrix[_SCT]: ... @overload # diagonals: , format: "bsr" (positional) def diags( - diagonals: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], + diagonals: _ToArray1D2D[_SCT], offsets: _Offsets, shape: _ToShape2D | None, format: _FmtBSR, @@ -684,7 +645,7 @@ def diags( ) -> bsr_matrix[_SCT]: ... @overload # diagonals: , format: "bsr" (keyword) def diags( - diagonals: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], + diagonals: _ToArray1D2D[_SCT], offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, @@ -693,7 +654,7 @@ def diags( ) -> bsr_matrix[_SCT]: ... @overload # diagonals: , format: "coo" (positional) def diags( - diagonals: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], + diagonals: _ToArray1D2D[_SCT], offsets: _Offsets, shape: _ToShape2D | None, format: _FmtCOO, @@ -701,7 +662,7 @@ def diags( ) -> coo_matrix[_SCT]: ... @overload # diagonals: , format: "coo" (keyword) def diags( - diagonals: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], + diagonals: _ToArray1D2D[_SCT], offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, @@ -710,7 +671,7 @@ def diags( ) -> coo_matrix[_SCT]: ... @overload # diagonals: , format: "csr" (positional) def diags( - diagonals: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], + diagonals: _ToArray1D2D[_SCT], offsets: _Offsets, shape: _ToShape2D | None, format: _FmtCSR, @@ -718,7 +679,7 @@ def diags( ) -> csr_matrix[_SCT]: ... @overload # diagonals: , format: "csr" (keyword) def diags( - diagonals: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], + diagonals: _ToArray1D2D[_SCT], offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, @@ -727,7 +688,7 @@ def diags( ) -> csr_matrix[_SCT]: ... @overload # diagonals: , format: "csc" (positional) def diags( - diagonals: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], + diagonals: _ToArray1D2D[_SCT], offsets: _Offsets, shape: _ToShape2D | None, format: _FmtCSC, @@ -735,7 +696,7 @@ def diags( ) -> csc_matrix[_SCT]: ... @overload # diagonals: , format: "csc" (keyword) def diags( - diagonals: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], + diagonals: _ToArray1D2D[_SCT], offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, @@ -744,7 +705,7 @@ def diags( ) -> csc_matrix[_SCT]: ... @overload # diagonals: , format: "dok" (positional) def diags( - diagonals: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], + diagonals: _ToArray1D2D[_SCT], offsets: _Offsets, shape: _ToShape2D | None, format: _FmtDOK, @@ -752,7 +713,7 @@ def diags( ) -> dok_matrix[_SCT]: ... @overload # diagonals: , format: "dok" (keyword) def diags( - diagonals: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], + diagonals: _ToArray1D2D[_SCT], offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, @@ -761,7 +722,7 @@ def diags( ) -> dok_matrix[_SCT]: ... @overload # diagonals: , format: "lil" (positional) def diags( - diagonals: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], + diagonals: _ToArray1D2D[_SCT], offsets: _Offsets, shape: _ToShape2D | None, format: _FmtLIL, @@ -769,7 +730,7 @@ def diags( ) -> lil_matrix[_SCT]: ... @overload # diagonals: , format: "lil" (keyword) def diags( - diagonals: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], + diagonals: _ToArray1D2D[_SCT], offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, @@ -890,15 +851,11 @@ def diags( # NOTE: `diags_array` should be prefered over `spdiags` @overload def spdiags( - data: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], - diags: _Offsets, - m: onp.ToJustInt, - n: onp.ToJustInt, - format: _FmtDIA | None = None, + data: _ToArray1D2D[_SCT], diags: _Offsets, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtDIA | None = None ) -> dia_matrix[_SCT]: ... @overload def spdiags( - data: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], + data: _ToArray1D2D[_SCT], diags: _Offsets, m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, n: None = None, @@ -906,11 +863,11 @@ def spdiags( ) -> dia_matrix[_SCT]: ... @overload def spdiags( - data: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], diags: _Offsets, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtBSR + data: _ToArray1D2D[_SCT], diags: _Offsets, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtBSR ) -> bsr_matrix[_SCT]: ... @overload def spdiags( - data: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], + data: _ToArray1D2D[_SCT], diags: _Offsets, m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, n: None = None, @@ -919,11 +876,11 @@ def spdiags( ) -> bsr_matrix[_SCT]: ... @overload def spdiags( - data: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], diags: _Offsets, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtCOO + data: _ToArray1D2D[_SCT], diags: _Offsets, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtCOO ) -> coo_matrix[_SCT]: ... @overload def spdiags( - data: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], + data: _ToArray1D2D[_SCT], diags: _Offsets, m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, n: None = None, @@ -932,11 +889,11 @@ def spdiags( ) -> coo_matrix[_SCT]: ... @overload def spdiags( - data: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], diags: _Offsets, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtCSR + data: _ToArray1D2D[_SCT], diags: _Offsets, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtCSR ) -> csr_matrix[_SCT]: ... @overload def spdiags( - data: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], + data: _ToArray1D2D[_SCT], diags: _Offsets, m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, n: None = None, @@ -945,11 +902,11 @@ def spdiags( ) -> csr_matrix[_SCT]: ... @overload def spdiags( - data: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], diags: _Offsets, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtCSC + data: _ToArray1D2D[_SCT], diags: _Offsets, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtCSC ) -> csc_matrix[_SCT]: ... @overload def spdiags( - data: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], + data: _ToArray1D2D[_SCT], diags: _Offsets, m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, n: None = None, @@ -958,11 +915,11 @@ def spdiags( ) -> csc_matrix[_SCT]: ... @overload def spdiags( - data: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], diags: _Offsets, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtDOK + data: _ToArray1D2D[_SCT], diags: _Offsets, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtDOK ) -> dok_matrix[_SCT]: ... @overload def spdiags( - data: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], + data: _ToArray1D2D[_SCT], diags: _Offsets, m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, n: None = None, @@ -971,11 +928,11 @@ def spdiags( ) -> dok_matrix[_SCT]: ... @overload def spdiags( - data: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], diags: _Offsets, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtLIL + data: _ToArray1D2D[_SCT], diags: _Offsets, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtLIL ) -> lil_matrix[_SCT]: ... @overload def spdiags( - data: _ToArray1D[_PSCT, _SCT] | _ToArray2D[_PSCT, _SCT], + data: _ToArray1D2D[_SCT], diags: _Offsets, m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, n: None = None, diff --git a/tests/sparse/test_construct.pyi b/tests/sparse/test_construct.pyi index afe04594..8a6b0cd8 100644 --- a/tests/sparse/test_construct.pyi +++ b/tests/sparse/test_construct.pyi @@ -203,8 +203,6 @@ assert_type(sparse.kronsum(any_mat, any_mat), sparse.csr_matrix[ScalarType]) assert_type(sparse.kronsum(any_mat, any_arr), sparse.csr_array[ScalarType]) assert_type(sparse.kronsum(any_arr, any_mat), sparse.csr_array[ScalarType]) assert_type(sparse.kronsum(any_arr, any_arr), sparse.csr_array[ScalarType]) -assert_type(sparse.kronsum(any_mat, [[1, 2], [3, 4]]), sparse.csr_matrix[ScalarType]) -assert_type(sparse.kronsum(any_arr, [[1, 2], [3, 4]]), sparse.csr_array[ScalarType]) assert_type(sparse.kronsum(dense_2d, any_arr), sparse.csr_array[ScalarType]) assert_type(sparse.kronsum(any_arr, dense_2d), sparse.csr_array[ScalarType]) assert_type(sparse.kronsum(any_arr, any_arr, format="bsr"), sparse.bsr_array[ScalarType]) From f643769b4def517a352aa2da1d7ad1f3debd3093 Mon Sep 17 00:00:00 2001 From: juvdnbro Date: Thu, 17 Jul 2025 09:52:27 +0200 Subject: [PATCH 11/20] Improved type aliases + removed VSCode settings --- .vscode/settings.json | 2 - scipy-stubs/sparse/_construct.pyi | 195 +++++++++++++++--------------- 2 files changed, 98 insertions(+), 99 deletions(-) diff --git a/.vscode/settings.json b/.vscode/settings.json index 2a765c76..c558cc65 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -42,6 +42,4 @@ "--refresh-package=scipy-stubs", "mypy", ], - "python.languageServer": "None", - "python.analysis.typeCheckingMode": "off", } diff --git a/scipy-stubs/sparse/_construct.pyi b/scipy-stubs/sparse/_construct.pyi index 66eb9a17..8bf2fa35 100644 --- a/scipy-stubs/sparse/_construct.pyi +++ b/scipy-stubs/sparse/_construct.pyi @@ -45,10 +45,10 @@ _SCT = TypeVar("_SCT", bound=_Numeric, default=Any) _SCT0 = TypeVar("_SCT0", bound=_Numeric) _ShapeT = TypeVar("_ShapeT", bound=tuple[int, *tuple[int, ...]], default=tuple[Any, ...]) -_ToArray1D: TypeAlias = Seq[_SCT] | onp.CanArrayND[_SCT] +_ToArray1D: TypeAlias = Seq[_SCT] | onp.CanArray1D[_SCT] _ToArray2D: TypeAlias = Seq[Seq[_SCT] | onp.CanArray1D[_SCT]] | onp.CanArray2D[_SCT] _ToArray1D2D: TypeAlias = _ToArray1D[_SCT] | _ToArray2D[_SCT] -_CanArray1D2D: TypeAlias = onp.CanArray1D[_SCT] | onp.CanArray2D[_SCT] +_CanArray1D2D: TypeAlias = onp.CanArrayND[_SCT, tuple[int] | tuple[int, int]] _ToSpMatrix: TypeAlias = spmatrix[_SCT] | _ToArray2D[_SCT] _ToSparse2D: TypeAlias = _spbase[_SCT, tuple[int, int]] | _ToArray2D[_SCT] @@ -78,6 +78,7 @@ _FmtLIL: TypeAlias = Literal["lil"] _FmtNonCOO: TypeAlias = Literal["bsr", "csc", "csr", "dia", "dok", "lil"] _ComplexSeq1D2D: TypeAlias = Seq[Seq[complex] | complex] +_ToComplex1D2D: TypeAlias = onp.ToComplex1D | onp.ToComplex2D _Offsets: TypeAlias = onp.ToInt | onp.ToInt1D _DataRVS: TypeAlias = Callable[[int], onp.ArrayND[_Numeric]] @@ -89,7 +90,7 @@ class _DataSampler(Protocol): def __call__(self, /, *, size: int) -> onp.ArrayND[_Numeric]: ... ### -@overload # diagonals: , dtype: None = ..., format: {"dia", None} = ... +@overload # diagonals: , dtype: None, format: "dia" | None def diags_array( diagonals: _ComplexSeq1D2D, /, @@ -99,7 +100,7 @@ def diags_array( format: _FmtDIA | None = None, dtype: None = None, ) -> _DIAArray[np.float64] | _DIAArray[np.complex128]: ... -@overload # diagonals: , dtype: None = ..., format: {"dia", None} = ... +@overload # diagonals: , dtype: None, format: "dia" | None def diags_array( diagonals: _CanArray1D2D[_SCT], /, @@ -109,9 +110,9 @@ def diags_array( format: _FmtDIA | None = None, dtype: None = None, ) -> _DIAArray[_SCT]: ... -@overload # diagonals: , format: {"dia", None} = ..., dtype: bool-like +@overload # diagonals: , format: "dia" | None, dtype: bool-like def diags_array( - diagonals: onp.CanArray1D | onp.CanArray2D, + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, @@ -119,9 +120,9 @@ def diags_array( format: _FmtDIA | None = None, dtype: onp.AnyBoolDType, ) -> _DIAArray[np.bool_]: ... -@overload # diagonals: , format: {"dia", None} = ..., dtype: int-like +@overload # diagonals: , format: "dia" | None, dtype: int-like def diags_array( - diagonals: onp.CanArray1D | onp.CanArray2D, + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, @@ -129,9 +130,9 @@ def diags_array( format: _FmtDIA | None = None, dtype: onp.AnyIntDType, ) -> _DIAArray[np.int_]: ... -@overload # diagonals: , format: {"dia", None} = ..., dtype: float64-like +@overload # diagonals: , format: "dia" | None, dtype: float64-like def diags_array( - diagonals: onp.CanArray1D | onp.CanArray2D, + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, @@ -139,9 +140,9 @@ def diags_array( format: _FmtDIA | None = None, dtype: onp.AnyFloat64DType, ) -> _DIAArray[np.float64]: ... -@overload # diagonals: , format: {"dia", None} = ..., dtype: complex128-like +@overload # diagonals: , format: "dia" | None, dtype: complex128-like def diags_array( - diagonals: onp.CanArray1D | onp.CanArray2D, + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, @@ -149,9 +150,9 @@ def diags_array( format: _FmtDIA | None = None, dtype: onp.AnyComplex128DType, ) -> _DIAArray[np.complex128]: ... -@overload # diagonals: , format: {"dia", None} = ..., dtype: +@overload # diagonals: , format: "dia" | None, dtype: def diags_array( - diagonals: onp.ToComplex1D | onp.ToComplex2D, + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, @@ -159,9 +160,9 @@ def diags_array( format: _FmtDIA | None = None, dtype: onp.ToDType[_SCT], ) -> _DIAArray[_SCT]: ... -@overload # diagonals: , format: {"dia", None} = ..., dtype: +@overload # diagonals: , format: "dia" | None, dtype: def diags_array( - diagonals: onp.ToComplex1D | onp.ToComplex2D, + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, @@ -171,7 +172,7 @@ def diags_array( ) -> _DIAArray: ... # BSR -@overload # diagonals: , format: "bsr", dtype: None +@overload # diagonals: , format: "bsr", dtype: None def diags_array( diagonals: _ComplexSeq1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtBSR, dtype: None = None ) -> _BSRArray[np.float64] | _BSRArray[np.complex128]: ... @@ -185,9 +186,9 @@ def diags_array( format: _FmtBSR, dtype: None = None, ) -> _BSRArray[_SCT]: ... -@overload # diagonals: , format: "bsr", dtype: bool-like +@overload # diagonals: , format: "bsr", dtype: bool-like def diags_array( - diagonals: onp.CanArray1D | onp.CanArray2D, + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, @@ -195,9 +196,9 @@ def diags_array( format: _FmtBSR, dtype: onp.AnyBoolDType, ) -> _BSRArray[np.bool_]: ... -@overload # diagonals: , format: "bsr", dtype: int-like +@overload # diagonals: , format: "bsr", dtype: int-like def diags_array( - diagonals: onp.CanArray1D | onp.CanArray2D, + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, @@ -205,9 +206,9 @@ def diags_array( format: _FmtBSR, dtype: onp.AnyIntDType, ) -> _BSRArray[np.int_]: ... -@overload # diagonals: , format: "bsr", dtype: float64-like +@overload # diagonals: , format: "bsr", dtype: float64-like def diags_array( - diagonals: onp.CanArray1D | onp.CanArray2D, + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, @@ -215,9 +216,9 @@ def diags_array( format: _FmtBSR, dtype: onp.AnyFloat64DType, ) -> _BSRArray[np.float64]: ... -@overload # diagonals: , format: "bsr", dtype: complex128-like +@overload # diagonals: , format: "bsr", dtype: complex128-like def diags_array( - diagonals: onp.CanArray1D | onp.CanArray2D, + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, @@ -227,7 +228,7 @@ def diags_array( ) -> _BSRArray[np.complex128]: ... @overload # diagonals: , format: "bsr", dtype: def diags_array( - diagonals: onp.ToComplex1D | onp.ToComplex2D, + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, @@ -237,7 +238,7 @@ def diags_array( ) -> _BSRArray[_SCT]: ... @overload # diagonals: , format: "bsr", dtype: def diags_array( - diagonals: onp.ToComplex1D | onp.ToComplex2D, + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, @@ -247,7 +248,7 @@ def diags_array( ) -> _BSRArray: ... # COO -@overload # diagonals: , format: "coo", dtype: None +@overload # diagonals: , format: "coo", dtype: None def diags_array( diagonals: _ComplexSeq1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCOO, dtype: None = None ) -> _COOArray2D[np.float64] | _COOArray2D[np.complex128]: ... @@ -261,9 +262,9 @@ def diags_array( format: _FmtCOO, dtype: None = None, ) -> _COOArray2D[_SCT]: ... -@overload # diagonals: , format: "coo", dtype: bool-like +@overload # diagonals: , format: "coo", dtype: bool-like def diags_array( - diagonals: onp.CanArray1D | onp.CanArray2D, + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, @@ -271,9 +272,9 @@ def diags_array( format: _FmtCOO, dtype: onp.AnyBoolDType, ) -> _COOArray2D[np.bool_]: ... -@overload # diagonals: , format: "coo", dtype: int-like +@overload # diagonals: , format: "coo", dtype: int-like def diags_array( - diagonals: onp.CanArray1D | onp.CanArray2D, + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, @@ -281,9 +282,9 @@ def diags_array( format: _FmtCOO, dtype: onp.AnyIntDType, ) -> _COOArray2D[np.int_]: ... -@overload # diagonals: , format: "coo", dtype: float64-like +@overload # diagonals: , format: "coo", dtype: float64-like def diags_array( - diagonals: onp.CanArray1D | onp.CanArray2D, + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, @@ -291,9 +292,9 @@ def diags_array( format: _FmtCOO, dtype: onp.AnyFloat64DType, ) -> _COOArray2D[np.float64]: ... -@overload # diagonals: , format: "coo", dtype: complex128-like +@overload # diagonals: , format: "coo", dtype: complex128-like def diags_array( - diagonals: onp.CanArray1D | onp.CanArray2D, + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, @@ -303,7 +304,7 @@ def diags_array( ) -> _COOArray2D[np.complex128]: ... @overload # diagonals: , format: "coo", dtype: def diags_array( - diagonals: onp.ToComplex1D | onp.ToComplex2D, + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, @@ -313,7 +314,7 @@ def diags_array( ) -> _COOArray2D[_SCT]: ... @overload # diagonals: , format: "coo", dtype: def diags_array( - diagonals: onp.ToComplex1D | onp.ToComplex2D, + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, @@ -323,7 +324,7 @@ def diags_array( ) -> _COOArray2D: ... # CSC -@overload # diagonals: , format: "csc", dtype: None +@overload # diagonals: , format: "csc", dtype: None def diags_array( diagonals: _ComplexSeq1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCSC, dtype: None = None ) -> _CSCArray[np.float64] | _CSCArray[np.complex128]: ... @@ -337,9 +338,9 @@ def diags_array( format: _FmtCSC, dtype: None = None, ) -> _CSCArray[_SCT]: ... -@overload # diagonals: , format: "csc", dtype: bool-like +@overload # diagonals: , format: "csc", dtype: bool-like def diags_array( - diagonals: onp.CanArray1D | onp.CanArray2D, + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, @@ -347,9 +348,9 @@ def diags_array( format: _FmtCSC, dtype: onp.AnyBoolDType, ) -> _CSCArray[np.bool_]: ... -@overload # diagonals: , format: "csc", dtype: int-like +@overload # diagonals: , format: "csc", dtype: int-like def diags_array( - diagonals: onp.CanArray1D | onp.CanArray2D, + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, @@ -357,9 +358,9 @@ def diags_array( format: _FmtCSC, dtype: onp.AnyIntDType, ) -> _CSCArray[np.int_]: ... -@overload # diagonals: , format: "csc", dtype: float64-like +@overload # diagonals: , format: "csc", dtype: float64-like def diags_array( - diagonals: onp.CanArray1D | onp.CanArray2D, + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, @@ -367,9 +368,9 @@ def diags_array( format: _FmtCSC, dtype: onp.AnyFloat64DType, ) -> _CSCArray[np.float64]: ... -@overload # diagonals: , format: "csc", dtype: complex128-like +@overload # diagonals: , format: "csc", dtype: complex128-like def diags_array( - diagonals: onp.CanArray1D | onp.CanArray2D, + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, @@ -379,7 +380,7 @@ def diags_array( ) -> _CSCArray[np.complex128]: ... @overload # diagonals: , format: "csc", dtype: def diags_array( - diagonals: onp.ToComplex1D | onp.ToComplex2D, + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, @@ -389,7 +390,7 @@ def diags_array( ) -> _CSCArray[_SCT]: ... @overload # diagonals: , format: "csc", dtype: def diags_array( - diagonals: onp.ToComplex1D | onp.ToComplex2D, + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, @@ -399,7 +400,7 @@ def diags_array( ) -> _CSCArray: ... # CSR -@overload # diagonals: , format: "csr", dtype: None +@overload # diagonals: , format: "csr", dtype: None def diags_array( diagonals: _ComplexSeq1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCSR, dtype: None = None ) -> _CSRArray2D[np.float64] | _CSRArray2D[np.complex128]: ... @@ -413,9 +414,9 @@ def diags_array( format: _FmtCSR, dtype: None = None, ) -> _CSRArray2D[_SCT]: ... -@overload # diagonals: , format: "csr", dtype: bool-like +@overload # diagonals: , format: "csr", dtype: bool-like def diags_array( - diagonals: onp.CanArray1D | onp.CanArray2D, + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, @@ -423,9 +424,9 @@ def diags_array( format: _FmtCSR, dtype: onp.AnyBoolDType, ) -> _CSRArray2D[np.bool_]: ... -@overload # diagonals: , format: "csr", dtype: int-like +@overload # diagonals: , format: "csr", dtype: int-like def diags_array( - diagonals: onp.CanArray1D | onp.CanArray2D, + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, @@ -433,9 +434,9 @@ def diags_array( format: _FmtCSR, dtype: onp.AnyIntDType, ) -> _CSRArray2D[np.int_]: ... -@overload # diagonals: , format: "csr", dtype: float64-like +@overload # diagonals: , format: "csr", dtype: float64-like def diags_array( - diagonals: onp.CanArray1D | onp.CanArray2D, + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, @@ -443,9 +444,9 @@ def diags_array( format: _FmtCSR, dtype: onp.AnyFloat64DType, ) -> _CSRArray2D[np.float64]: ... -@overload # diagonals: , format: "csr", dtype: complex128-like +@overload # diagonals: , format: "csr", dtype: complex128-like def diags_array( - diagonals: onp.CanArray1D | onp.CanArray2D, + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, @@ -455,7 +456,7 @@ def diags_array( ) -> _CSRArray2D[np.complex128]: ... @overload # diagonals: , format: "csr", dtype: def diags_array( - diagonals: onp.ToComplex1D | onp.ToComplex2D, + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, @@ -465,7 +466,7 @@ def diags_array( ) -> _CSRArray2D[_SCT]: ... @overload # diagonals: , format: "csr", dtype: def diags_array( - diagonals: onp.ToComplex1D | onp.ToComplex2D, + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, @@ -475,7 +476,7 @@ def diags_array( ) -> _CSRArray2D: ... # DOK -@overload # diagonals: , format: "dok", dtype: None +@overload # diagonals: , format: "dok", dtype: None def diags_array( diagonals: _ComplexSeq1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtDOK, dtype: None = None ) -> _DOKArray2D[np.float64] | _DOKArray2D[np.complex128]: ... @@ -489,9 +490,9 @@ def diags_array( format: _FmtDOK, dtype: None = None, ) -> _DOKArray2D[_SCT]: ... -@overload # diagonals: , format: "dok", dtype: bool-like +@overload # diagonals: , format: "dok", dtype: bool-like def diags_array( - diagonals: onp.CanArray1D | onp.CanArray2D, + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, @@ -499,9 +500,9 @@ def diags_array( format: _FmtDOK, dtype: onp.AnyBoolDType, ) -> _DOKArray2D[np.bool_]: ... -@overload # diagonals: , format: "dok", dtype: int-like +@overload # diagonals: , format: "dok", dtype: int-like def diags_array( - diagonals: onp.CanArray1D | onp.CanArray2D, + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, @@ -509,9 +510,9 @@ def diags_array( format: _FmtDOK, dtype: onp.AnyIntDType, ) -> _DOKArray2D[np.int_]: ... -@overload # diagonals: , format: "dok", dtype: float64-like +@overload # diagonals: , format: "dok", dtype: float64-like def diags_array( - diagonals: onp.CanArray1D | onp.CanArray2D, + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, @@ -519,9 +520,9 @@ def diags_array( format: _FmtDOK, dtype: onp.AnyFloat64DType, ) -> _DOKArray2D[np.float64]: ... -@overload # diagonals: , format: "dok", dtype: complex128-like +@overload # diagonals: , format: "dok", dtype: complex128-like def diags_array( - diagonals: onp.CanArray1D | onp.CanArray2D, + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, @@ -531,7 +532,7 @@ def diags_array( ) -> _DOKArray2D[np.complex128]: ... @overload # diagonals: , format: "dok", dtype: def diags_array( - diagonals: onp.ToComplex1D | onp.ToComplex2D, + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, @@ -541,7 +542,7 @@ def diags_array( ) -> _DOKArray2D[_SCT]: ... @overload # diagonals: , format: "dok", dtype: def diags_array( - diagonals: onp.ToComplex1D | onp.ToComplex2D, + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, @@ -551,7 +552,7 @@ def diags_array( ) -> _DOKArray2D: ... # LIL -@overload # diagonals: , format: "lil", dtype: None +@overload # diagonals: , format: "lil", dtype: None def diags_array( diagonals: _ComplexSeq1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtLIL, dtype: None = None ) -> _LILArray[np.float64] | _LILArray[np.complex128]: ... @@ -565,9 +566,9 @@ def diags_array( format: _FmtLIL, dtype: None = None, ) -> _LILArray[_SCT]: ... -@overload # diagonals: , format: "lil", dtype: bool-like +@overload # diagonals: , format: "lil", dtype: bool-like def diags_array( - diagonals: onp.CanArray1D | onp.CanArray2D, + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, @@ -575,9 +576,9 @@ def diags_array( format: _FmtLIL, dtype: onp.AnyBoolDType, ) -> _LILArray[np.bool_]: ... -@overload # diagonals: , format: "lil", dtype: int-like +@overload # diagonals: , format: "lil", dtype: int-like def diags_array( - diagonals: onp.CanArray1D | onp.CanArray2D, + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, @@ -585,9 +586,9 @@ def diags_array( format: _FmtLIL, dtype: onp.AnyIntDType, ) -> _LILArray[np.int_]: ... -@overload # diagonals: , format: "lil", dtype: float64-like +@overload # diagonals: , format: "lil", dtype: float64-like def diags_array( - diagonals: onp.CanArray1D | onp.CanArray2D, + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, @@ -595,9 +596,9 @@ def diags_array( format: _FmtLIL, dtype: onp.AnyFloat64DType, ) -> _LILArray[np.float64]: ... -@overload # diagonals: , format: "lil", dtype: complex128-like +@overload # diagonals: , format: "lil", dtype: complex128-like def diags_array( - diagonals: onp.CanArray1D | onp.CanArray2D, + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, @@ -607,7 +608,7 @@ def diags_array( ) -> _LILArray[np.complex128]: ... @overload # diagonals: , format: "lil", dtype: def diags_array( - diagonals: onp.ToComplex1D | onp.ToComplex2D, + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, @@ -617,7 +618,7 @@ def diags_array( ) -> _LILArray[_SCT]: ... @overload # diagonals: , format: "lil", dtype: def diags_array( - diagonals: onp.ToComplex1D | onp.ToComplex2D, + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, @@ -627,7 +628,7 @@ def diags_array( ) -> _LILArray: ... # NOTE: `diags_array` should be prefered over `diags` -@overload # diagonals: , format: {"dia", None} = ... +@overload # diagonals: , format: "dia" | None def diags( diagonals: _ToArray1D2D[_SCT], offsets: _Offsets = 0, @@ -737,9 +738,9 @@ def diags( format: _FmtLIL, dtype: onp.ToDType[_SCT] | None = None, ) -> lil_matrix[_SCT]: ... -@overload # diagonals: , format: {"dia", None} = ..., dtype: +@overload # diagonals: , format: "dia" | None, dtype: def diags( - diagonals: onp.ToComplex1D | onp.ToComplex2D, + diagonals: _ToComplex1D2D, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtDIA | None = None, @@ -747,7 +748,7 @@ def diags( ) -> dia_matrix: ... @overload # diagonals: , format: "bsr" (positional), dtype: def diags( - diagonals: onp.ToComplex1D | onp.ToComplex2D, + diagonals: _ToComplex1D2D, offsets: _Offsets, shape: _ToShape2D | None, format: _FmtBSR, @@ -755,7 +756,7 @@ def diags( ) -> bsr_matrix: ... @overload # diagonals: , format: "bsr" (keyword), dtype: def diags( - diagonals: onp.ToComplex1D | onp.ToComplex2D, + diagonals: _ToComplex1D2D, offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, @@ -764,7 +765,7 @@ def diags( ) -> bsr_matrix: ... @overload # diagonals: , format: "coo" (positional), dtype: def diags( - diagonals: onp.ToComplex1D | onp.ToComplex2D, + diagonals: _ToComplex1D2D, offsets: _Offsets, shape: _ToShape2D | None, format: _FmtCOO, @@ -772,7 +773,7 @@ def diags( ) -> coo_matrix: ... @overload # diagonals: , format: "coo" (keyword), dtype: def diags( - diagonals: onp.ToComplex1D | onp.ToComplex2D, + diagonals: _ToComplex1D2D, offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, @@ -781,7 +782,7 @@ def diags( ) -> coo_matrix: ... @overload # diagonals: , format: "csr" (positional), dtype: def diags( - diagonals: onp.ToComplex1D | onp.ToComplex2D, + diagonals: _ToComplex1D2D, offsets: _Offsets, shape: _ToShape2D | None, format: _FmtCSR, @@ -789,7 +790,7 @@ def diags( ) -> csr_matrix: ... @overload # diagonals: , format: "csr" (keyword), dtype: def diags( - diagonals: onp.ToComplex1D | onp.ToComplex2D, + diagonals: _ToComplex1D2D, offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, @@ -798,7 +799,7 @@ def diags( ) -> csr_matrix: ... @overload # diagonals: , format: "csc" (positional), dtype: def diags( - diagonals: onp.ToComplex1D | onp.ToComplex2D, + diagonals: _ToComplex1D2D, offsets: _Offsets, shape: _ToShape2D | None, format: _FmtCSC, @@ -806,7 +807,7 @@ def diags( ) -> csc_matrix: ... @overload # diagonals: , format: "csc" (keyword), dtype: def diags( - diagonals: onp.ToComplex1D | onp.ToComplex2D, + diagonals: _ToComplex1D2D, offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, @@ -815,7 +816,7 @@ def diags( ) -> csc_matrix: ... @overload # diagonals: , format: "dok" (positional), dtype: def diags( - diagonals: onp.ToComplex1D | onp.ToComplex2D, + diagonals: _ToComplex1D2D, offsets: _Offsets, shape: _ToShape2D | None, format: _FmtDOK, @@ -823,7 +824,7 @@ def diags( ) -> dok_matrix: ... @overload # diagonals: , format: "dok" (keyword), dtype: def diags( - diagonals: onp.ToComplex1D | onp.ToComplex2D, + diagonals: _ToComplex1D2D, offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, @@ -832,7 +833,7 @@ def diags( ) -> dok_matrix: ... @overload # diagonals: , format: "lil" (positional), dtype: def diags( - diagonals: onp.ToComplex1D | onp.ToComplex2D, + diagonals: _ToComplex1D2D, offsets: _Offsets, shape: _ToShape2D | None, format: _FmtLIL, @@ -840,7 +841,7 @@ def diags( ) -> lil_matrix: ... @overload # diagonals: , format: "lil" (keyword), dtype: def diags( - diagonals: onp.ToComplex1D | onp.ToComplex2D, + diagonals: _ToComplex1D2D, offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, From 119cb70e5bbab2b8a0dae579d6d89556179490de Mon Sep 17 00:00:00 2001 From: juvdnbro Date: Thu, 17 Jul 2025 09:57:05 +0200 Subject: [PATCH 12/20] Formatted with `ruff` + `known dtype` -> `known` --- scipy-stubs/sparse/_construct.pyi | 136 +++++++++--------------------- 1 file changed, 38 insertions(+), 98 deletions(-) diff --git a/scipy-stubs/sparse/_construct.pyi b/scipy-stubs/sparse/_construct.pyi index 8bf2fa35..a3a1b91d 100644 --- a/scipy-stubs/sparse/_construct.pyi +++ b/scipy-stubs/sparse/_construct.pyi @@ -78,7 +78,7 @@ _FmtLIL: TypeAlias = Literal["lil"] _FmtNonCOO: TypeAlias = Literal["bsr", "csc", "csr", "dia", "dok", "lil"] _ComplexSeq1D2D: TypeAlias = Seq[Seq[complex] | complex] -_ToComplex1D2D: TypeAlias = onp.ToComplex1D | onp.ToComplex2D +_ToComplex1D2D: TypeAlias = onp.ToComplex1D | onp.ToComplex2D _Offsets: TypeAlias = onp.ToInt | onp.ToInt1D _DataRVS: TypeAlias = Callable[[int], onp.ArrayND[_Numeric]] @@ -100,7 +100,7 @@ def diags_array( format: _FmtDIA | None = None, dtype: None = None, ) -> _DIAArray[np.float64] | _DIAArray[np.complex128]: ... -@overload # diagonals: , dtype: None, format: "dia" | None +@overload # diagonals: , dtype: None, format: "dia" | None def diags_array( diagonals: _CanArray1D2D[_SCT], /, @@ -238,13 +238,7 @@ def diags_array( ) -> _BSRArray[_SCT]: ... @overload # diagonals: , format: "bsr", dtype: def diags_array( - diagonals: _ToComplex1D2D, - /, - *, - offsets: _Offsets = 0, - shape: _ToShape2D | None = None, - format: _FmtBSR, - dtype: npt.DTypeLike, + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtBSR, dtype: npt.DTypeLike ) -> _BSRArray: ... # COO @@ -314,13 +308,7 @@ def diags_array( ) -> _COOArray2D[_SCT]: ... @overload # diagonals: , format: "coo", dtype: def diags_array( - diagonals: _ToComplex1D2D, - /, - *, - offsets: _Offsets = 0, - shape: _ToShape2D | None = None, - format: _FmtCOO, - dtype: npt.DTypeLike, + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCOO, dtype: npt.DTypeLike ) -> _COOArray2D: ... # CSC @@ -390,13 +378,7 @@ def diags_array( ) -> _CSCArray[_SCT]: ... @overload # diagonals: , format: "csc", dtype: def diags_array( - diagonals: _ToComplex1D2D, - /, - *, - offsets: _Offsets = 0, - shape: _ToShape2D | None = None, - format: _FmtCSC, - dtype: npt.DTypeLike, + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCSC, dtype: npt.DTypeLike ) -> _CSCArray: ... # CSR @@ -466,13 +448,7 @@ def diags_array( ) -> _CSRArray2D[_SCT]: ... @overload # diagonals: , format: "csr", dtype: def diags_array( - diagonals: _ToComplex1D2D, - /, - *, - offsets: _Offsets = 0, - shape: _ToShape2D | None = None, - format: _FmtCSR, - dtype: npt.DTypeLike, + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCSR, dtype: npt.DTypeLike ) -> _CSRArray2D: ... # DOK @@ -542,13 +518,7 @@ def diags_array( ) -> _DOKArray2D[_SCT]: ... @overload # diagonals: , format: "dok", dtype: def diags_array( - diagonals: _ToComplex1D2D, - /, - *, - offsets: _Offsets = 0, - shape: _ToShape2D | None = None, - format: _FmtDOK, - dtype: npt.DTypeLike, + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtDOK, dtype: npt.DTypeLike ) -> _DOKArray2D: ... # LIL @@ -618,13 +588,7 @@ def diags_array( ) -> _LILArray[_SCT]: ... @overload # diagonals: , format: "lil", dtype: def diags_array( - diagonals: _ToComplex1D2D, - /, - *, - offsets: _Offsets = 0, - shape: _ToShape2D | None = None, - format: _FmtLIL, - dtype: npt.DTypeLike, + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtLIL, dtype: npt.DTypeLike ) -> _LILArray: ... # NOTE: `diags_array` should be prefered over `diags` @@ -748,11 +712,7 @@ def diags( ) -> dia_matrix: ... @overload # diagonals: , format: "bsr" (positional), dtype: def diags( - diagonals: _ToComplex1D2D, - offsets: _Offsets, - shape: _ToShape2D | None, - format: _FmtBSR, - dtype: npt.DTypeLike | None = None, + diagonals: _ToComplex1D2D, offsets: _Offsets, shape: _ToShape2D | None, format: _FmtBSR, dtype: npt.DTypeLike | None = None ) -> bsr_matrix: ... @overload # diagonals: , format: "bsr" (keyword), dtype: def diags( @@ -765,11 +725,7 @@ def diags( ) -> bsr_matrix: ... @overload # diagonals: , format: "coo" (positional), dtype: def diags( - diagonals: _ToComplex1D2D, - offsets: _Offsets, - shape: _ToShape2D | None, - format: _FmtCOO, - dtype: npt.DTypeLike | None = None, + diagonals: _ToComplex1D2D, offsets: _Offsets, shape: _ToShape2D | None, format: _FmtCOO, dtype: npt.DTypeLike | None = None ) -> coo_matrix: ... @overload # diagonals: , format: "coo" (keyword), dtype: def diags( @@ -782,11 +738,7 @@ def diags( ) -> coo_matrix: ... @overload # diagonals: , format: "csr" (positional), dtype: def diags( - diagonals: _ToComplex1D2D, - offsets: _Offsets, - shape: _ToShape2D | None, - format: _FmtCSR, - dtype: npt.DTypeLike | None = None, + diagonals: _ToComplex1D2D, offsets: _Offsets, shape: _ToShape2D | None, format: _FmtCSR, dtype: npt.DTypeLike | None = None ) -> csr_matrix: ... @overload # diagonals: , format: "csr" (keyword), dtype: def diags( @@ -799,11 +751,7 @@ def diags( ) -> csr_matrix: ... @overload # diagonals: , format: "csc" (positional), dtype: def diags( - diagonals: _ToComplex1D2D, - offsets: _Offsets, - shape: _ToShape2D | None, - format: _FmtCSC, - dtype: npt.DTypeLike | None = None, + diagonals: _ToComplex1D2D, offsets: _Offsets, shape: _ToShape2D | None, format: _FmtCSC, dtype: npt.DTypeLike | None = None ) -> csc_matrix: ... @overload # diagonals: , format: "csc" (keyword), dtype: def diags( @@ -816,11 +764,7 @@ def diags( ) -> csc_matrix: ... @overload # diagonals: , format: "dok" (positional), dtype: def diags( - diagonals: _ToComplex1D2D, - offsets: _Offsets, - shape: _ToShape2D | None, - format: _FmtDOK, - dtype: npt.DTypeLike | None = None, + diagonals: _ToComplex1D2D, offsets: _Offsets, shape: _ToShape2D | None, format: _FmtDOK, dtype: npt.DTypeLike | None = None ) -> dok_matrix: ... @overload # diagonals: , format: "dok" (keyword), dtype: def diags( @@ -833,11 +777,7 @@ def diags( ) -> dok_matrix: ... @overload # diagonals: , format: "lil" (positional), dtype: def diags( - diagonals: _ToComplex1D2D, - offsets: _Offsets, - shape: _ToShape2D | None, - format: _FmtLIL, - dtype: npt.DTypeLike | None = None, + diagonals: _ToComplex1D2D, offsets: _Offsets, shape: _ToShape2D | None, format: _FmtLIL, dtype: npt.DTypeLike | None = None ) -> lil_matrix: ... @overload # diagonals: , format: "lil" (keyword), dtype: def diags( @@ -1496,76 +1436,76 @@ def vstack(blocks: Seq[_CanStackAs[Any, _T]], format: None = None, *, dtype: npt def vstack(blocks: Seq[_spbase], format: _Format, dtype: npt.DTypeLike | None = None) -> Incomplete: ... # TODO(jorenham): Use `_CanStack` here, which requires a way to map matrix types to array types. -@overload # blocks: , format: , dtype: +@overload # blocks: , format: , dtype: def block_array(blocks: _ToBlocks[_SCT], *, format: _FmtCOO | None = None, dtype: None = None) -> _COOArray2D[_SCT]: ... -@overload # blocks: , format: , dtype: +@overload # blocks: , format: , dtype: def block_array(blocks: _ToBlocks, *, format: _FmtCOO | None = None, dtype: onp.ToDType[_SCT]) -> _COOArray2D[_SCT]: ... -@overload # blocks: , format: , dtype: +@overload # blocks: , format: , dtype: def block_array(blocks: _ToBlocks, *, format: _FmtCOO | None = None, dtype: npt.DTypeLike) -> _COOArray2D: ... -@overload # blocks: , format: , dtype: +@overload # blocks: , format: , dtype: def block_array(blocks: _ToBlocks[_SCT], *, format: _FmtNonCOO, dtype: None = None) -> _SpArray2D[_SCT]: ... -@overload # blocks: , format: , dtype: +@overload # blocks: , format: , dtype: def block_array(blocks: _ToBlocks, *, format: _FmtNonCOO, dtype: onp.ToDType[_SCT]) -> _SpArray2D[_SCT]: ... -@overload # blocks: , format: , dtype: +@overload # blocks: , format: , dtype: def block_array(blocks: _ToBlocks, *, format: _FmtNonCOO, dtype: npt.DTypeLike) -> _SpArray2D: ... # TODO(jorenham): Use `_CanStack` here, which requires a way to map array types to matrix types. -@overload # blocks: , format: , dtype: +@overload # blocks: , format: , dtype: def bmat(blocks: Seq[Seq[sparray[_SCT]]], format: _FmtCOO | None = None, dtype: None = None) -> _COOArray2D[_SCT]: ... -@overload # blocks: , format: , dtype: +@overload # blocks: , format: , dtype: def bmat(blocks: Seq[Seq[spmatrix[_SCT]]], format: _FmtCOO | None = None, dtype: None = None) -> coo_matrix[_SCT]: ... -@overload # sparray, blocks: , format: , dtype: (positional) +@overload # sparray, blocks: , format: , dtype: (positional) def bmat(blocks: _ToBlocks, format: _FmtCOO | None, dtype: onp.ToDType[_SCT]) -> _COOArray2D[_SCT] | coo_matrix[_SCT]: ... -@overload # sparray, blocks: , format: , dtype: (keyword) +@overload # sparray, blocks: , format: , dtype: (keyword) def bmat( blocks: _ToBlocks, format: _FmtCOO | None = None, *, dtype: onp.ToDType[_SCT] ) -> _COOArray2D[_SCT] | coo_matrix[_SCT]: ... -@overload # sparray, blocks: , format: , dtype: +@overload # sparray, blocks: , format: , dtype: def bmat( blocks: _ToBlocks[_SCT], format: _FmtCOO | None = None, dtype: npt.DTypeLike | None = None ) -> _COOArray2D[_SCT] | coo_matrix[_SCT]: ... -@overload # sparray, blocks: , format: , dtype: +@overload # sparray, blocks: , format: , dtype: def bmat(blocks: Seq[Seq[sparray[_SCT]]], format: _Format, dtype: None = None) -> _SpArray2D[_SCT]: ... -@overload # sparray, blocks: , format: , dtype: +@overload # sparray, blocks: , format: , dtype: def bmat(blocks: Seq[Seq[spmatrix[_SCT]]], format: _Format, dtype: None = None) -> _SpMatrix[_SCT]: ... -@overload # sparray, blocks: , format: , dtype: +@overload # sparray, blocks: , format: , dtype: def bmat(blocks: _ToBlocks, format: _Format, dtype: onp.ToDType[_SCT]) -> _SpBase2D[_SCT]: ... -@overload # sparray, blocks: , format: , dtype: +@overload # sparray, blocks: , format: , dtype: def bmat(blocks: _ToBlocks, format: _Format, dtype: npt.DTypeLike) -> _SpBase2D: ... # TODO(jorenham): Add support for non-COO formats. -@overload # mats: +@overload # mats: def block_diag(mats: Iterable[sparray[_SCT]], format: _FmtCOO | None = None, dtype: None = None) -> _COOArray2D[_SCT]: ... -@overload # mats: +@overload # mats: def block_diag(mats: Iterable[spmatrix[_SCT]], format: _FmtCOO | None = None, dtype: None = None) -> coo_matrix[_SCT]: ... -@overload # mats: +@overload # mats: def block_diag( mats: Iterable[_spbase[_SCT] | onp.ArrayND[_SCT]], format: _FmtCOO | None = None, dtype: None = None ) -> _COOArray2D[_SCT] | coo_matrix[_SCT]: ... -@overload # mats: , dtype: (positional) +@overload # mats: , dtype: (positional) def block_diag(mats: Iterable[sparray], format: _FmtCOO | None, dtype: onp.ToDType[_SCT]) -> coo_array[_SCT, tuple[int, int]]: ... -@overload # mats: , dtype: (keyword) +@overload # mats: , dtype: (keyword) def block_diag(mats: Iterable[sparray], format: _FmtCOO | None = None, *, dtype: onp.ToDType[_SCT]) -> _COOArray2D[_SCT]: ... -@overload # mats: , dtype: (positional) +@overload # mats: , dtype: (positional) def block_diag( mats: Iterable[spmatrix | onp.ArrayND[_Numeric] | complex | Seq[onp.ToComplex] | Seq[onp.ToComplex1D]], format: _FmtCOO | None, dtype: onp.ToDType[_SCT], ) -> coo_matrix[_SCT]: ... -@overload # mats: , dtype: (keyword) +@overload # mats: , dtype: (keyword) def block_diag( mats: Iterable[spmatrix | onp.ArrayND[_Numeric] | complex | Seq[onp.ToComplex] | Seq[onp.ToComplex1D]], format: _FmtCOO | None = None, *, dtype: onp.ToDType[_SCT], ) -> coo_matrix[_SCT]: ... -@overload # mats: , dtype: (positional) +@overload # mats: , dtype: (positional) def block_diag( mats: Iterable[_spbase | onp.ArrayND[_Numeric] | complex | Seq[onp.ToComplex] | Seq[onp.ToComplex1D]], format: _FmtCOO | None, dtype: onp.ToDType[_SCT], ) -> _COOArray2D[_SCT] | coo_matrix[_SCT]: ... -@overload # mats: , dtype: (keyword) +@overload # mats: , dtype: (keyword) def block_diag( mats: Iterable[_spbase | onp.ArrayND[_Numeric] | complex | Seq[onp.ToComplex] | Seq[onp.ToComplex1D]], format: _FmtCOO | None = None, From 235fcc17674aab00328caf4429a171531a6c0390 Mon Sep 17 00:00:00 2001 From: Jul Van den Broeck Date: Fri, 18 Jul 2025 00:50:33 +0200 Subject: [PATCH 13/20] Restructured `_construct.pyi` and cleaned up comments --- scipy-stubs/sparse/_construct.pyi | 1654 ++++++++++++++--------------- 1 file changed, 826 insertions(+), 828 deletions(-) diff --git a/scipy-stubs/sparse/_construct.pyi b/scipy-stubs/sparse/_construct.pyi index a3a1b91d..f4757777 100644 --- a/scipy-stubs/sparse/_construct.pyi +++ b/scipy-stubs/sparse/_construct.pyi @@ -57,7 +57,6 @@ _SpMatrix: TypeAlias = spmatrix[_SCT] | Any _SpArray: TypeAlias = sparray[_SCT, _ShapeT] | Any _SpBase2D: TypeAlias = _SpBase[_SCT, tuple[int, int]] -_SpArray1D: TypeAlias = _SpArray[_SCT, tuple[int]] _SpArray2D: TypeAlias = _SpArray[_SCT, tuple[int, int]] _BSRArray: TypeAlias = bsr_array[_SCT] @@ -90,7 +89,7 @@ class _DataSampler(Protocol): def __call__(self, /, *, size: int) -> onp.ArrayND[_Numeric]: ... ### -@overload # diagonals: , dtype: None, format: "dia" | None +@overload # diagonals: , format: "dia" | None, dtype: None def diags_array( diagonals: _ComplexSeq1D2D, /, @@ -100,7 +99,33 @@ def diags_array( format: _FmtDIA | None = None, dtype: None = None, ) -> _DIAArray[np.float64] | _DIAArray[np.complex128]: ... -@overload # diagonals: , dtype: None, format: "dia" | None +@overload # diagonals: , format: "bsr", dtype: None +def diags_array( + diagonals: _ComplexSeq1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtBSR, dtype: None = None +) -> _BSRArray[np.float64] | _BSRArray[np.complex128]: ... +@overload # diagonals: , format: "coo", dtype: None +def diags_array( + diagonals: _ComplexSeq1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCOO, dtype: None = None +) -> _COOArray2D[np.float64] | _COOArray2D[np.complex128]: ... +@overload # diagonals: , format: "csc", dtype: None +def diags_array( + diagonals: _ComplexSeq1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCSC, dtype: None = None +) -> _CSCArray[np.float64] | _CSCArray[np.complex128]: ... +@overload # diagonals: , format: "csr", dtype: None +def diags_array( + diagonals: _ComplexSeq1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCSR, dtype: None = None +) -> _CSRArray2D[np.float64] | _CSRArray2D[np.complex128]: ... +@overload # diagonals: , format: "dok", dtype: None +def diags_array( + diagonals: _ComplexSeq1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtDOK, dtype: None = None +) -> _DOKArray2D[np.float64] | _DOKArray2D[np.complex128]: ... +@overload # diagonals: , format: "lil", dtype: None +def diags_array( + diagonals: _ComplexSeq1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtLIL, dtype: None = None +) -> _LILArray[np.float64] | _LILArray[np.complex128]: ... + +# +@overload # diagonals: , format: "dia" | None, dtype: None def diags_array( diagonals: _CanArray1D2D[_SCT], /, @@ -110,82 +135,78 @@ def diags_array( format: _FmtDIA | None = None, dtype: None = None, ) -> _DIAArray[_SCT]: ... -@overload # diagonals: , format: "dia" | None, dtype: bool-like +@overload # diagonals: , format: "bsr", dtype: None def diags_array( - diagonals: _ToComplex1D2D, + diagonals: onp.CanArray1D[_SCT] | onp.CanArray2D[_SCT], /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, - format: _FmtDIA | None = None, - dtype: onp.AnyBoolDType, -) -> _DIAArray[np.bool_]: ... -@overload # diagonals: , format: "dia" | None, dtype: int-like + format: _FmtBSR, + dtype: None = None, +) -> _BSRArray[_SCT]: ... +@overload # diagonals: , format: "coo", dtype: None def diags_array( - diagonals: _ToComplex1D2D, + diagonals: onp.CanArray1D[_SCT] | onp.CanArray2D[_SCT], /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, - format: _FmtDIA | None = None, - dtype: onp.AnyIntDType, -) -> _DIAArray[np.int_]: ... -@overload # diagonals: , format: "dia" | None, dtype: float64-like + format: _FmtCOO, + dtype: None = None, +) -> _COOArray2D[_SCT]: ... +@overload # diagonals: , format: "csc", dtype: None def diags_array( - diagonals: _ToComplex1D2D, + diagonals: onp.CanArray1D[_SCT] | onp.CanArray2D[_SCT], /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, - format: _FmtDIA | None = None, - dtype: onp.AnyFloat64DType, -) -> _DIAArray[np.float64]: ... -@overload # diagonals: , format: "dia" | None, dtype: complex128-like + format: _FmtCSC, + dtype: None = None, +) -> _CSCArray[_SCT]: ... +@overload # diagonals: , format: "csr", dtype: None def diags_array( - diagonals: _ToComplex1D2D, + diagonals: onp.CanArray1D[_SCT] | onp.CanArray2D[_SCT], /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, - format: _FmtDIA | None = None, - dtype: onp.AnyComplex128DType, -) -> _DIAArray[np.complex128]: ... -@overload # diagonals: , format: "dia" | None, dtype: + format: _FmtCSR, + dtype: None = None, +) -> _CSRArray2D[_SCT]: ... +@overload # diagonals: , format: "dok", dtype: None def diags_array( - diagonals: _ToComplex1D2D, + diagonals: onp.CanArray1D[_SCT] | onp.CanArray2D[_SCT], /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, - format: _FmtDIA | None = None, - dtype: onp.ToDType[_SCT], -) -> _DIAArray[_SCT]: ... -@overload # diagonals: , format: "dia" | None, dtype: + format: _FmtDOK, + dtype: None = None, +) -> _DOKArray2D[_SCT]: ... +@overload # diagonals: , format: "lil", dtype: None def diags_array( - diagonals: _ToComplex1D2D, + diagonals: onp.CanArray1D[_SCT] | onp.CanArray2D[_SCT], /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, - format: _FmtDIA | None = None, - dtype: npt.DTypeLike, -) -> _DIAArray: ... + format: _FmtLIL, + dtype: None = None, +) -> _LILArray[_SCT]: ... -# BSR -@overload # diagonals: , format: "bsr", dtype: None -def diags_array( - diagonals: _ComplexSeq1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtBSR, dtype: None = None -) -> _BSRArray[np.float64] | _BSRArray[np.complex128]: ... -@overload # diagonals: , format: "bsr", dtype: None +# +@overload # diagonals: , format: "dia" | None, dtype: bool-like def diags_array( - diagonals: onp.CanArray1D[_SCT] | onp.CanArray2D[_SCT], + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, - format: _FmtBSR, - dtype: None = None, -) -> _BSRArray[_SCT]: ... + format: _FmtDIA | None = None, + dtype: onp.AnyBoolDType, +) -> _DIAArray[np.bool_]: ... @overload # diagonals: , format: "bsr", dtype: bool-like def diags_array( diagonals: _ToComplex1D2D, @@ -196,87 +217,79 @@ def diags_array( format: _FmtBSR, dtype: onp.AnyBoolDType, ) -> _BSRArray[np.bool_]: ... -@overload # diagonals: , format: "bsr", dtype: int-like +@overload # diagonals: , format: "coo", dtype: bool-like def diags_array( diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, - format: _FmtBSR, - dtype: onp.AnyIntDType, -) -> _BSRArray[np.int_]: ... -@overload # diagonals: , format: "bsr", dtype: float64-like + format: _FmtCOO, + dtype: onp.AnyBoolDType, +) -> _COOArray2D[np.bool_]: ... +@overload # diagonals: , format: "csc", dtype: bool-like def diags_array( diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, - format: _FmtBSR, - dtype: onp.AnyFloat64DType, -) -> _BSRArray[np.float64]: ... -@overload # diagonals: , format: "bsr", dtype: complex128-like + format: _FmtCSC, + dtype: onp.AnyBoolDType, +) -> _CSCArray[np.bool_]: ... +@overload # diagonals: , format: "csr", dtype: bool-like def diags_array( diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, - format: _FmtBSR, - dtype: onp.AnyComplex128DType, -) -> _BSRArray[np.complex128]: ... -@overload # diagonals: , format: "bsr", dtype: + format: _FmtCSR, + dtype: onp.AnyBoolDType, +) -> _CSRArray2D[np.bool_]: ... +@overload # diagonals: , format: "dok", dtype: bool-like def diags_array( diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, - format: _FmtBSR, - dtype: onp.ToDType[_SCT], -) -> _BSRArray[_SCT]: ... -@overload # diagonals: , format: "bsr", dtype: -def diags_array( - diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtBSR, dtype: npt.DTypeLike -) -> _BSRArray: ... - -# COO -@overload # diagonals: , format: "coo", dtype: None -def diags_array( - diagonals: _ComplexSeq1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCOO, dtype: None = None -) -> _COOArray2D[np.float64] | _COOArray2D[np.complex128]: ... -@overload # diagonals: , format: "coo", dtype: None + format: _FmtDOK, + dtype: onp.AnyBoolDType, +) -> _DOKArray2D[np.bool_]: ... +@overload # diagonals: , format: "lil", dtype: bool-like def diags_array( - diagonals: onp.CanArray1D[_SCT] | onp.CanArray2D[_SCT], + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, - format: _FmtCOO, - dtype: None = None, -) -> _COOArray2D[_SCT]: ... -@overload # diagonals: , format: "coo", dtype: bool-like + format: _FmtLIL, + dtype: onp.AnyBoolDType, +) -> _LILArray[np.bool_]: ... + +# +@overload # diagonals: , format: "dia" | None, dtype: int-like def diags_array( diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, - format: _FmtCOO, - dtype: onp.AnyBoolDType, -) -> _COOArray2D[np.bool_]: ... -@overload # diagonals: , format: "coo", dtype: int-like + format: _FmtDIA | None = None, + dtype: onp.AnyIntDType, +) -> _DIAArray[np.int_]: ... +@overload # diagonals: , format: "bsr", dtype: int-like def diags_array( diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, - format: _FmtCOO, + format: _FmtBSR, dtype: onp.AnyIntDType, -) -> _COOArray2D[np.int_]: ... -@overload # diagonals: , format: "coo", dtype: float64-like +) -> _BSRArray[np.int_]: ... +@overload # diagonals: , format: "coo", dtype: int-like def diags_array( diagonals: _ToComplex1D2D, /, @@ -284,89 +297,81 @@ def diags_array( offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCOO, - dtype: onp.AnyFloat64DType, -) -> _COOArray2D[np.float64]: ... -@overload # diagonals: , format: "coo", dtype: complex128-like + dtype: onp.AnyIntDType, +) -> _COOArray2D[np.int_]: ... +@overload # diagonals: , format: "csc", dtype: int-like def diags_array( diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, - format: _FmtCOO, - dtype: onp.AnyComplex128DType, -) -> _COOArray2D[np.complex128]: ... -@overload # diagonals: , format: "coo", dtype: + format: _FmtCSC, + dtype: onp.AnyIntDType, +) -> _CSCArray[np.int_]: ... +@overload # diagonals: , format: "csr", dtype: int-like def diags_array( diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, - format: _FmtCOO, - dtype: onp.ToDType[_SCT], -) -> _COOArray2D[_SCT]: ... -@overload # diagonals: , format: "coo", dtype: -def diags_array( - diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCOO, dtype: npt.DTypeLike -) -> _COOArray2D: ... - -# CSC -@overload # diagonals: , format: "csc", dtype: None -def diags_array( - diagonals: _ComplexSeq1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCSC, dtype: None = None -) -> _CSCArray[np.float64] | _CSCArray[np.complex128]: ... -@overload # diagonals: , format: "csc", dtype: None + format: _FmtCSR, + dtype: onp.AnyIntDType, +) -> _CSRArray2D[np.int_]: ... +@overload # diagonals: , format: "dok", dtype: int-like def diags_array( - diagonals: onp.CanArray1D[_SCT] | onp.CanArray2D[_SCT], + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, - format: _FmtCSC, - dtype: None = None, -) -> _CSCArray[_SCT]: ... -@overload # diagonals: , format: "csc", dtype: bool-like + format: _FmtDOK, + dtype: onp.AnyIntDType, +) -> _DOKArray2D[np.int_]: ... +@overload # diagonals: , format: "lil", dtype: int-like def diags_array( diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, - format: _FmtCSC, - dtype: onp.AnyBoolDType, -) -> _CSCArray[np.bool_]: ... -@overload # diagonals: , format: "csc", dtype: int-like + format: _FmtLIL, + dtype: onp.AnyIntDType, +) -> _LILArray[np.int_]: ... + +# +@overload # diagonals: , format: "dia" | None, dtype: float64-like def diags_array( diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, - format: _FmtCSC, - dtype: onp.AnyIntDType, -) -> _CSCArray[np.int_]: ... -@overload # diagonals: , format: "csc", dtype: float64-like + format: _FmtDIA | None = None, + dtype: onp.AnyFloat64DType, +) -> _DIAArray[np.float64]: ... +@overload # diagonals: , format: "bsr", dtype: float64-like def diags_array( diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, - format: _FmtCSC, + format: _FmtBSR, dtype: onp.AnyFloat64DType, -) -> _CSCArray[np.float64]: ... -@overload # diagonals: , format: "csc", dtype: complex128-like +) -> _BSRArray[np.float64]: ... +@overload # diagonals: , format: "coo", dtype: float64-like def diags_array( diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, - format: _FmtCSC, - dtype: onp.AnyComplex128DType, -) -> _CSCArray[np.complex128]: ... -@overload # diagonals: , format: "csc", dtype: + format: _FmtCOO, + dtype: onp.AnyFloat64DType, +) -> _COOArray2D[np.float64]: ... +@overload # diagonals: , format: "csc", dtype: float64-like def diags_array( diagonals: _ToComplex1D2D, /, @@ -374,109 +379,91 @@ def diags_array( offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCSC, - dtype: onp.ToDType[_SCT], -) -> _CSCArray[_SCT]: ... -@overload # diagonals: , format: "csc", dtype: -def diags_array( - diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCSC, dtype: npt.DTypeLike -) -> _CSCArray: ... - -# CSR -@overload # diagonals: , format: "csr", dtype: None -def diags_array( - diagonals: _ComplexSeq1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCSR, dtype: None = None -) -> _CSRArray2D[np.float64] | _CSRArray2D[np.complex128]: ... -@overload # diagonals: , format: "csr", dtype: None + dtype: onp.AnyFloat64DType, +) -> _CSCArray[np.float64]: ... +@overload # diagonals: , format: "csr", dtype: float64-like def diags_array( - diagonals: onp.CanArray1D[_SCT] | onp.CanArray2D[_SCT], + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCSR, - dtype: None = None, -) -> _CSRArray2D[_SCT]: ... -@overload # diagonals: , format: "csr", dtype: bool-like + dtype: onp.AnyFloat64DType, +) -> _CSRArray2D[np.float64]: ... +@overload # diagonals: , format: "dok", dtype: float64-like def diags_array( diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, - format: _FmtCSR, - dtype: onp.AnyBoolDType, -) -> _CSRArray2D[np.bool_]: ... -@overload # diagonals: , format: "csr", dtype: int-like + format: _FmtDOK, + dtype: onp.AnyFloat64DType, +) -> _DOKArray2D[np.float64]: ... +@overload # diagonals: , format: "lil", dtype: float64-like def diags_array( diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, - format: _FmtCSR, - dtype: onp.AnyIntDType, -) -> _CSRArray2D[np.int_]: ... -@overload # diagonals: , format: "csr", dtype: float64-like + format: _FmtLIL, + dtype: onp.AnyFloat64DType, +) -> _LILArray[np.float64]: ... + +# +@overload # diagonals: , format: "dia" | None, dtype: complex128-like def diags_array( diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, - format: _FmtCSR, - dtype: onp.AnyFloat64DType, -) -> _CSRArray2D[np.float64]: ... -@overload # diagonals: , format: "csr", dtype: complex128-like + format: _FmtDIA | None = None, + dtype: onp.AnyComplex128DType, +) -> _DIAArray[np.complex128]: ... +@overload # diagonals: , format: "bsr", dtype: complex128-like def diags_array( diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, - format: _FmtCSR, + format: _FmtBSR, dtype: onp.AnyComplex128DType, -) -> _CSRArray2D[np.complex128]: ... -@overload # diagonals: , format: "csr", dtype: +) -> _BSRArray[np.complex128]: ... +@overload # diagonals: , format: "coo", dtype: complex128-like def diags_array( diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, - format: _FmtCSR, - dtype: onp.ToDType[_SCT], -) -> _CSRArray2D[_SCT]: ... -@overload # diagonals: , format: "csr", dtype: -def diags_array( - diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCSR, dtype: npt.DTypeLike -) -> _CSRArray2D: ... - -# DOK -@overload # diagonals: , format: "dok", dtype: None -def diags_array( - diagonals: _ComplexSeq1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtDOK, dtype: None = None -) -> _DOKArray2D[np.float64] | _DOKArray2D[np.complex128]: ... -@overload # diagonals: , format: "dok", dtype: None + format: _FmtCOO, + dtype: onp.AnyComplex128DType, +) -> _COOArray2D[np.complex128]: ... +@overload # diagonals: , format: "csc", dtype: complex128-like def diags_array( - diagonals: onp.CanArray1D[_SCT] | onp.CanArray2D[_SCT], + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, - format: _FmtDOK, - dtype: None = None, -) -> _DOKArray2D[_SCT]: ... -@overload # diagonals: , format: "dok", dtype: bool-like + format: _FmtCSC, + dtype: onp.AnyComplex128DType, +) -> _CSCArray[np.complex128]: ... +@overload # diagonals: , format: "csr", dtype: complex128-like def diags_array( diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, - format: _FmtDOK, - dtype: onp.AnyBoolDType, -) -> _DOKArray2D[np.bool_]: ... -@overload # diagonals: , format: "dok", dtype: int-like + format: _FmtCSR, + dtype: onp.AnyComplex128DType, +) -> _CSRArray2D[np.complex128]: ... +@overload # diagonals: , format: "dok", dtype: complex128-like def diags_array( diagonals: _ToComplex1D2D, /, @@ -484,89 +471,81 @@ def diags_array( offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtDOK, - dtype: onp.AnyIntDType, -) -> _DOKArray2D[np.int_]: ... -@overload # diagonals: , format: "dok", dtype: float64-like + dtype: onp.AnyComplex128DType, +) -> _DOKArray2D[np.complex128]: ... +@overload # diagonals: , format: "lil", dtype: complex128-like def diags_array( diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, - format: _FmtDOK, - dtype: onp.AnyFloat64DType, -) -> _DOKArray2D[np.float64]: ... -@overload # diagonals: , format: "dok", dtype: complex128-like + format: _FmtLIL, + dtype: onp.AnyComplex128DType, +) -> _LILArray[np.complex128]: ... + +# +@overload # diagonals: , format: "dia" | None, dtype: def diags_array( diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, - format: _FmtDOK, - dtype: onp.AnyComplex128DType, -) -> _DOKArray2D[np.complex128]: ... -@overload # diagonals: , format: "dok", dtype: + format: _FmtDIA | None = None, + dtype: onp.ToDType[_SCT], +) -> _DIAArray[_SCT]: ... +@overload # diagonals: , format: "bsr", dtype: def diags_array( diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, - format: _FmtDOK, + format: _FmtBSR, dtype: onp.ToDType[_SCT], -) -> _DOKArray2D[_SCT]: ... -@overload # diagonals: , format: "dok", dtype: -def diags_array( - diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtDOK, dtype: npt.DTypeLike -) -> _DOKArray2D: ... - -# LIL -@overload # diagonals: , format: "lil", dtype: None -def diags_array( - diagonals: _ComplexSeq1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtLIL, dtype: None = None -) -> _LILArray[np.float64] | _LILArray[np.complex128]: ... -@overload # diagonals: , format: "lil", dtype: None +) -> _BSRArray[_SCT]: ... +@overload # diagonals: , format: "coo", dtype: def diags_array( - diagonals: onp.CanArray1D[_SCT] | onp.CanArray2D[_SCT], + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, - format: _FmtLIL, - dtype: None = None, -) -> _LILArray[_SCT]: ... -@overload # diagonals: , format: "lil", dtype: bool-like + format: _FmtCOO, + dtype: onp.ToDType[_SCT], +) -> _COOArray2D[_SCT]: ... +@overload # diagonals: , format: "csc", dtype: def diags_array( diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, - format: _FmtLIL, - dtype: onp.AnyBoolDType, -) -> _LILArray[np.bool_]: ... -@overload # diagonals: , format: "lil", dtype: int-like + format: _FmtCSC, + dtype: onp.ToDType[_SCT], +) -> _CSCArray[_SCT]: ... +@overload # diagonals: , format: "csr", dtype: def diags_array( diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, - format: _FmtLIL, - dtype: onp.AnyIntDType, -) -> _LILArray[np.int_]: ... -@overload # diagonals: , format: "lil", dtype: float64-like + format: _FmtCSR, + dtype: onp.ToDType[_SCT], +) -> _CSRArray2D[_SCT]: ... +@overload # diagonals: , format: "dok", dtype: def diags_array( diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, - format: _FmtLIL, - dtype: onp.AnyFloat64DType, -) -> _LILArray[np.float64]: ... -@overload # diagonals: , format: "lil", dtype: complex128-like + format: _FmtDOK, + dtype: onp.ToDType[_SCT], +) -> _DOKArray2D[_SCT]: ... +@overload # diagonals: , format: "lil", dtype: def diags_array( diagonals: _ToComplex1D2D, /, @@ -574,134 +553,119 @@ def diags_array( offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtLIL, - dtype: onp.AnyComplex128DType, -) -> _LILArray[np.complex128]: ... -@overload # diagonals: , format: "lil", dtype: + dtype: onp.ToDType[_SCT], +) -> _LILArray[_SCT]: ... + +# +@overload # diagonals: , format: "dia" | None, dtype: def diags_array( diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, - format: _FmtLIL, - dtype: onp.ToDType[_SCT], -) -> _LILArray[_SCT]: ... + format: _FmtDIA | None = None, + dtype: npt.DTypeLike, +) -> _DIAArray: ... +@overload # diagonals: , format: "bsr", dtype: +def diags_array( + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtBSR, dtype: npt.DTypeLike +) -> _BSRArray: ... +@overload # diagonals: , format: "coo", dtype: +def diags_array( + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCOO, dtype: npt.DTypeLike +) -> _COOArray2D: ... +@overload # diagonals: , format: "csc", dtype: +def diags_array( + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCSC, dtype: npt.DTypeLike +) -> _CSCArray: ... +@overload # diagonals: , format: "csr", dtype: +def diags_array( + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtCSR, dtype: npt.DTypeLike +) -> _CSRArray2D: ... +@overload # diagonals: , format: "dok", dtype: +def diags_array( + diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtDOK, dtype: npt.DTypeLike +) -> _DOKArray2D: ... @overload # diagonals: , format: "lil", dtype: def diags_array( diagonals: _ToComplex1D2D, /, *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtLIL, dtype: npt.DTypeLike ) -> _LILArray: ... +### # NOTE: `diags_array` should be prefered over `diags` @overload # diagonals: , format: "dia" | None def diags( diagonals: _ToArray1D2D[_SCT], + /, + *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtDIA | None = None, dtype: onp.ToDType[_SCT] | None = None, ) -> dia_matrix[_SCT]: ... -@overload # diagonals: , format: "bsr" (positional) +@overload # diagonals: , format: "bsr" def diags( diagonals: _ToArray1D2D[_SCT], - offsets: _Offsets, + /, + *, + offsets: _Offsets = 0, shape: _ToShape2D | None, format: _FmtBSR, dtype: onp.ToDType[_SCT] | None = None, ) -> bsr_matrix[_SCT]: ... -@overload # diagonals: , format: "bsr" (keyword) +@overload # diagonals: , format: "coo" def diags( diagonals: _ToArray1D2D[_SCT], - offsets: _Offsets = 0, - shape: _ToShape2D | None = None, + /, *, - format: _FmtBSR, - dtype: onp.ToDType[_SCT] | None = None, -) -> bsr_matrix[_SCT]: ... -@overload # diagonals: , format: "coo" (positional) -def diags( - diagonals: _ToArray1D2D[_SCT], - offsets: _Offsets, + offsets: _Offsets = 0, shape: _ToShape2D | None, format: _FmtCOO, dtype: onp.ToDType[_SCT] | None = None, ) -> coo_matrix[_SCT]: ... -@overload # diagonals: , format: "coo" (keyword) +@overload # diagonals: , format: "csr" def diags( diagonals: _ToArray1D2D[_SCT], - offsets: _Offsets = 0, - shape: _ToShape2D | None = None, + /, *, - format: _FmtCOO, - dtype: onp.ToDType[_SCT] | None = None, -) -> coo_matrix[_SCT]: ... -@overload # diagonals: , format: "csr" (positional) -def diags( - diagonals: _ToArray1D2D[_SCT], - offsets: _Offsets, + offsets: _Offsets = 0, shape: _ToShape2D | None, format: _FmtCSR, dtype: onp.ToDType[_SCT] | None = None, ) -> csr_matrix[_SCT]: ... -@overload # diagonals: , format: "csr" (keyword) +@overload # diagonals: , format: "csc" def diags( diagonals: _ToArray1D2D[_SCT], - offsets: _Offsets = 0, - shape: _ToShape2D | None = None, + /, *, - format: _FmtCSR, - dtype: onp.ToDType[_SCT] | None = None, -) -> csr_matrix[_SCT]: ... -@overload # diagonals: , format: "csc" (positional) -def diags( - diagonals: _ToArray1D2D[_SCT], - offsets: _Offsets, + offsets: _Offsets = 0, shape: _ToShape2D | None, format: _FmtCSC, dtype: onp.ToDType[_SCT] | None = None, ) -> csc_matrix[_SCT]: ... -@overload # diagonals: , format: "csc" (keyword) +@overload # diagonals: , format: "dok" def diags( diagonals: _ToArray1D2D[_SCT], - offsets: _Offsets = 0, - shape: _ToShape2D | None = None, + /, *, - format: _FmtCSC, - dtype: onp.ToDType[_SCT] | None = None, -) -> csc_matrix[_SCT]: ... -@overload # diagonals: , format: "dok" (positional) -def diags( - diagonals: _ToArray1D2D[_SCT], - offsets: _Offsets, + offsets: _Offsets = 0, shape: _ToShape2D | None, format: _FmtDOK, dtype: onp.ToDType[_SCT] | None = None, ) -> dok_matrix[_SCT]: ... -@overload # diagonals: , format: "dok" (keyword) +@overload # diagonals: , format: "lil" def diags( diagonals: _ToArray1D2D[_SCT], - offsets: _Offsets = 0, - shape: _ToShape2D | None = None, + /, *, - format: _FmtDOK, - dtype: onp.ToDType[_SCT] | None = None, -) -> dok_matrix[_SCT]: ... -@overload # diagonals: , format: "lil" (positional) -def diags( - diagonals: _ToArray1D2D[_SCT], - offsets: _Offsets, - shape: _ToShape2D | None, - format: _FmtLIL, - dtype: onp.ToDType[_SCT] | None = None, -) -> lil_matrix[_SCT]: ... -@overload # diagonals: , format: "lil" (keyword) -def diags( - diagonals: _ToArray1D2D[_SCT], offsets: _Offsets = 0, - shape: _ToShape2D | None = None, - *, + shape: _ToShape2D | None, format: _FmtLIL, dtype: onp.ToDType[_SCT] | None = None, ) -> lil_matrix[_SCT]: ... + +# @overload # diagonals: , format: "dia" | None, dtype: def diags( diagonals: _ToComplex1D2D, @@ -710,91 +674,100 @@ def diags( format: _FmtDIA | None = None, dtype: npt.DTypeLike | None = None, ) -> dia_matrix: ... -@overload # diagonals: , format: "bsr" (positional), dtype: -def diags( - diagonals: _ToComplex1D2D, offsets: _Offsets, shape: _ToShape2D | None, format: _FmtBSR, dtype: npt.DTypeLike | None = None -) -> bsr_matrix: ... -@overload # diagonals: , format: "bsr" (keyword), dtype: +@overload # diagonals: , format: "bsr", dtype: def diags( diagonals: _ToComplex1D2D, - offsets: _Offsets = 0, - shape: _ToShape2D | None = None, + /, *, + offsets: _Offsets = 0, + shape: _ToShape2D | None, format: _FmtBSR, dtype: npt.DTypeLike | None = None, ) -> bsr_matrix: ... -@overload # diagonals: , format: "coo" (positional), dtype: -def diags( - diagonals: _ToComplex1D2D, offsets: _Offsets, shape: _ToShape2D | None, format: _FmtCOO, dtype: npt.DTypeLike | None = None -) -> coo_matrix: ... -@overload # diagonals: , format: "coo" (keyword), dtype: +@overload # diagonals: , format: "coo", dtype: def diags( diagonals: _ToComplex1D2D, - offsets: _Offsets = 0, - shape: _ToShape2D | None = None, + /, *, + offsets: _Offsets = 0, + shape: _ToShape2D | None, format: _FmtCOO, dtype: npt.DTypeLike | None = None, ) -> coo_matrix: ... -@overload # diagonals: , format: "csr" (positional), dtype: -def diags( - diagonals: _ToComplex1D2D, offsets: _Offsets, shape: _ToShape2D | None, format: _FmtCSR, dtype: npt.DTypeLike | None = None -) -> csr_matrix: ... -@overload # diagonals: , format: "csr" (keyword), dtype: +@overload # diagonals: , format: "csr", dtype: def diags( diagonals: _ToComplex1D2D, - offsets: _Offsets = 0, - shape: _ToShape2D | None = None, + /, *, + offsets: _Offsets = 0, + shape: _ToShape2D | None, format: _FmtCSR, dtype: npt.DTypeLike | None = None, ) -> csr_matrix: ... -@overload # diagonals: , format: "csc" (positional), dtype: -def diags( - diagonals: _ToComplex1D2D, offsets: _Offsets, shape: _ToShape2D | None, format: _FmtCSC, dtype: npt.DTypeLike | None = None -) -> csc_matrix: ... -@overload # diagonals: , format: "csc" (keyword), dtype: +@overload # diagonals: , format: "csc", dtype: def diags( diagonals: _ToComplex1D2D, - offsets: _Offsets = 0, - shape: _ToShape2D | None = None, + /, *, + offsets: _Offsets = 0, + shape: _ToShape2D | None, format: _FmtCSC, dtype: npt.DTypeLike | None = None, ) -> csc_matrix: ... -@overload # diagonals: , format: "dok" (positional), dtype: -def diags( - diagonals: _ToComplex1D2D, offsets: _Offsets, shape: _ToShape2D | None, format: _FmtDOK, dtype: npt.DTypeLike | None = None -) -> dok_matrix: ... -@overload # diagonals: , format: "dok" (keyword), dtype: +@overload # diagonals: , format: "dok" dtype: def diags( diagonals: _ToComplex1D2D, - offsets: _Offsets = 0, - shape: _ToShape2D | None = None, + /, *, + offsets: _Offsets = 0, + shape: _ToShape2D | None, format: _FmtDOK, dtype: npt.DTypeLike | None = None, ) -> dok_matrix: ... -@overload # diagonals: , format: "lil" (positional), dtype: -def diags( - diagonals: _ToComplex1D2D, offsets: _Offsets, shape: _ToShape2D | None, format: _FmtLIL, dtype: npt.DTypeLike | None = None -) -> lil_matrix: ... -@overload # diagonals: , format: "lil" (keyword), dtype: +@overload # diagonals: , format: "lil", dtype: def diags( diagonals: _ToComplex1D2D, - offsets: _Offsets = 0, - shape: _ToShape2D | None = None, + /, *, + offsets: _Offsets = 0, + shape: _ToShape2D | None, format: _FmtLIL, dtype: npt.DTypeLike | None = None, ) -> lil_matrix: ... +### # NOTE: `diags_array` should be prefered over `spdiags` @overload def spdiags( data: _ToArray1D2D[_SCT], diags: _Offsets, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtDIA | None = None ) -> dia_matrix[_SCT]: ... @overload +def spdiags( + data: _ToArray1D2D[_SCT], diags: _Offsets, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtBSR +) -> bsr_matrix[_SCT]: ... +@overload +def spdiags( + data: _ToArray1D2D[_SCT], diags: _Offsets, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtCOO +) -> coo_matrix[_SCT]: ... +@overload +def spdiags( + data: _ToArray1D2D[_SCT], diags: _Offsets, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtCSC +) -> csc_matrix[_SCT]: ... +@overload +def spdiags( + data: _ToArray1D2D[_SCT], diags: _Offsets, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtCSR +) -> csr_matrix[_SCT]: ... +@overload +def spdiags( + data: _ToArray1D2D[_SCT], diags: _Offsets, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtDOK +) -> dok_matrix[_SCT]: ... +@overload +def spdiags( + data: _ToArray1D2D[_SCT], diags: _Offsets, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtLIL +) -> lil_matrix[_SCT]: ... + +# +@overload def spdiags( data: _ToArray1D2D[_SCT], diags: _Offsets, @@ -803,10 +776,6 @@ def spdiags( format: _FmtDIA | None = None, ) -> dia_matrix[_SCT]: ... @overload -def spdiags( - data: _ToArray1D2D[_SCT], diags: _Offsets, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtBSR -) -> bsr_matrix[_SCT]: ... -@overload def spdiags( data: _ToArray1D2D[_SCT], diags: _Offsets, @@ -816,10 +785,6 @@ def spdiags( format: _FmtBSR, ) -> bsr_matrix[_SCT]: ... @overload -def spdiags( - data: _ToArray1D2D[_SCT], diags: _Offsets, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtCOO -) -> coo_matrix[_SCT]: ... -@overload def spdiags( data: _ToArray1D2D[_SCT], diags: _Offsets, @@ -829,21 +794,13 @@ def spdiags( format: _FmtCOO, ) -> coo_matrix[_SCT]: ... @overload -def spdiags( - data: _ToArray1D2D[_SCT], diags: _Offsets, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtCSR -) -> csr_matrix[_SCT]: ... -@overload def spdiags( data: _ToArray1D2D[_SCT], diags: _Offsets, m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, n: None = None, *, - format: _FmtCSR, -) -> csr_matrix[_SCT]: ... -@overload -def spdiags( - data: _ToArray1D2D[_SCT], diags: _Offsets, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtCSC + format: _FmtCSC, ) -> csc_matrix[_SCT]: ... @overload def spdiags( @@ -852,12 +809,8 @@ def spdiags( m: tuple[onp.ToJustInt, onp.ToJustInt] | None = None, n: None = None, *, - format: _FmtCSC, -) -> csc_matrix[_SCT]: ... -@overload -def spdiags( - data: _ToArray1D2D[_SCT], diags: _Offsets, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtDOK -) -> dok_matrix[_SCT]: ... + format: _FmtCSR, +) -> csr_matrix[_SCT]: ... @overload def spdiags( data: _ToArray1D2D[_SCT], @@ -868,10 +821,6 @@ def spdiags( format: _FmtDOK, ) -> dok_matrix[_SCT]: ... @overload -def spdiags( - data: _ToArray1D2D[_SCT], diags: _Offsets, m: onp.ToJustInt, n: onp.ToJustInt, format: _FmtLIL -) -> lil_matrix[_SCT]: ... -@overload def spdiags( data: _ToArray1D2D[_SCT], diags: _Offsets, @@ -881,434 +830,465 @@ def spdiags( format: _FmtLIL, ) -> lil_matrix[_SCT]: ... -# -@overload # dtype like bool, format: None = ... -def identity(n: opt.AnyInt, dtype: onp.AnyBoolDType, format: _FmtDIA | None = None) -> dia_matrix[np.bool_]: ... -@overload # dtype like int, format: None = ... -def identity(n: opt.AnyInt, dtype: onp.AnyIntDType, format: _FmtDIA | None = None) -> dia_matrix[np.int_]: ... -@overload # dtype like float (default), format: None = ... +### +@overload # dtype: float64-like (default), format: "dia" | None def identity(n: opt.AnyInt, dtype: onp.AnyFloat64DType = "d", format: _FmtDIA | None = None) -> dia_matrix[np.float64]: ... -@overload # dtype like complex, format: None = ... -def identity(n: opt.AnyInt, dtype: onp.AnyComplex128DType, format: _FmtDIA | None = None) -> dia_matrix[np.complex128]: ... -@overload # dtype like , format: None = ... -def identity(n: opt.AnyInt, dtype: onp.ToDType[_SCT], format: _FmtDIA | None = None) -> dia_matrix[_SCT]: ... -@overload # dtype like , format: None = ... -def identity(n: opt.AnyInt, dtype: npt.DTypeLike, format: _FmtDIA | None = None) -> dia_matrix[Incomplete]: ... -@overload # dtype like float (default), format: "bsr" (keyword) +@overload # dtype: float64-like (default), format: "bsr" def identity(n: opt.AnyInt, dtype: onp.AnyFloat64DType = "d", *, format: _FmtBSR) -> bsr_matrix[np.float64]: ... -@overload # dtype like float (default), format: "coo" (keyword) +@overload # dtype: float64-like (default), format: "coo" def identity(n: opt.AnyInt, dtype: onp.AnyFloat64DType = "d", *, format: _FmtCOO) -> coo_matrix[np.float64]: ... -@overload # dtype like float (default), format: "csc" (keyword) +@overload # dtype: float64-like (default), format: "csc" def identity(n: opt.AnyInt, dtype: onp.AnyFloat64DType = "d", *, format: _FmtCSC) -> csc_matrix[np.float64]: ... -@overload # dtype like float (default), format: "csr" (keyword) +@overload # dtype: float64-like (default), format: "csr" def identity(n: opt.AnyInt, dtype: onp.AnyFloat64DType = "d", *, format: _FmtCSR) -> csr_matrix[np.float64]: ... -@overload # dtype like float (default), format: "dok" (keyword) +@overload # dtype: float64-like (default), format: "dok" def identity(n: opt.AnyInt, dtype: onp.AnyFloat64DType = "d", *, format: _FmtDOK) -> dok_matrix[np.float64]: ... -@overload # dtype like float (default), format: "lil" (keyword) +@overload # dtype: float64-like (default), format: "lil" def identity(n: opt.AnyInt, dtype: onp.AnyFloat64DType = "d", *, format: _FmtLIL) -> lil_matrix[np.float64]: ... -@overload # dtype like bool, format: "bsr" + +# +@overload # dtype: bool-like, format: "dia" | None +def identity(n: opt.AnyInt, dtype: onp.AnyBoolDType, format: _FmtDIA | None = None) -> dia_matrix[np.bool_]: ... +@overload # dtype: bool-like, format: "bsr" def identity(n: opt.AnyInt, dtype: onp.AnyBoolDType, format: _FmtBSR) -> bsr_matrix[np.bool_]: ... -@overload # dtype like bool, format: "coo" +@overload # dtype: bool-like, format: "coo" def identity(n: opt.AnyInt, dtype: onp.AnyBoolDType, format: _FmtCOO) -> coo_matrix[np.bool_]: ... -@overload # dtype like bool, format: "csc" +@overload # dtype: bool-like, format: "csc" def identity(n: opt.AnyInt, dtype: onp.AnyBoolDType, format: _FmtCSC) -> csc_matrix[np.bool_]: ... -@overload # dtype like bool, format: "csr" +@overload # dtype: bool-like, format: "csr" def identity(n: opt.AnyInt, dtype: onp.AnyBoolDType, format: _FmtCSR) -> csr_matrix[np.bool_]: ... -@overload # dtype like bool, format: "dok" +@overload # dtype: bool-like, format: "dok" def identity(n: opt.AnyInt, dtype: onp.AnyBoolDType, format: _FmtDOK) -> dok_matrix[np.bool_]: ... -@overload # dtype like bool, format: "lil" +@overload # dtype: bool-like, format: "lil" def identity(n: opt.AnyInt, dtype: onp.AnyBoolDType, format: _FmtLIL) -> lil_matrix[np.bool_]: ... -@overload # dtype like int, format: "bsr" + +# +@overload # dtype: int-like, format: "dia" | None +def identity(n: opt.AnyInt, dtype: onp.AnyIntDType, format: _FmtDIA | None = None) -> dia_matrix[np.int_]: ... +@overload # dtype: int-like, format: "bsr" def identity(n: opt.AnyInt, dtype: onp.AnyIntDType, format: _FmtBSR) -> bsr_matrix[np.int_]: ... -@overload # dtype like int, format: "coo" +@overload # dtype: int-like, format: "coo" def identity(n: opt.AnyInt, dtype: onp.AnyIntDType, format: _FmtCOO) -> coo_matrix[np.int_]: ... -@overload # dtype like int, format: "csc" +@overload # dtype: int-like, format: "csc" def identity(n: opt.AnyInt, dtype: onp.AnyIntDType, format: _FmtCSC) -> csc_matrix[np.int_]: ... -@overload # dtype like int, format: "csr" +@overload # dtype: int-like, format: "csr" def identity(n: opt.AnyInt, dtype: onp.AnyIntDType, format: _FmtCSR) -> csr_matrix[np.int_]: ... -@overload # dtype like int, format: "dok" +@overload # dtype: int-like, format: "dok" def identity(n: opt.AnyInt, dtype: onp.AnyIntDType, format: _FmtDOK) -> dok_matrix[np.int_]: ... -@overload # dtype like int, format: "lil" +@overload # dtype: int-like, format: "lil" def identity(n: opt.AnyInt, dtype: onp.AnyIntDType, format: _FmtLIL) -> lil_matrix[np.int_]: ... -@overload # dtype like complex, format: "bsr" + +# +@overload # dtype: complex128-like, format: "dia" | None +def identity(n: opt.AnyInt, dtype: onp.AnyComplex128DType, format: _FmtDIA | None = None) -> dia_matrix[np.complex128]: ... +@overload # dtype: complex128-like, format: "bsr" def identity(n: opt.AnyInt, dtype: onp.AnyComplex128DType, format: _FmtBSR) -> bsr_matrix[np.complex128]: ... -@overload # dtype like complex, format: "coo" +@overload # dtype: complex128-like, format: "coo" def identity(n: opt.AnyInt, dtype: onp.AnyComplex128DType, format: _FmtCOO) -> coo_matrix[np.complex128]: ... -@overload # dtype like complex, format: "csc" +@overload # dtype: complex128-like, format: "csc" def identity(n: opt.AnyInt, dtype: onp.AnyComplex128DType, format: _FmtCSC) -> csc_matrix[np.complex128]: ... -@overload # dtype like complex, format: "csr" +@overload # dtype: complex128-like, format: "csr" def identity(n: opt.AnyInt, dtype: onp.AnyComplex128DType, format: _FmtCSR) -> csr_matrix[np.complex128]: ... -@overload # dtype like complex, format: "dok" +@overload # dtype: complex128-like, format: "dok" def identity(n: opt.AnyInt, dtype: onp.AnyComplex128DType, format: _FmtDOK) -> dok_matrix[np.complex128]: ... -@overload # dtype like complex, format: "lil" +@overload # dtype: complex128-like, format: "lil" def identity(n: opt.AnyInt, dtype: onp.AnyComplex128DType, format: _FmtLIL) -> lil_matrix[np.complex128]: ... -@overload # dtype like , format: "bsr" + +# +@overload # dtype: , format: "dia" | None +def identity(n: opt.AnyInt, dtype: onp.ToDType[_SCT], format: _FmtDIA | None = None) -> dia_matrix[_SCT]: ... +@overload # dtype: , format: "bsr" def identity(n: opt.AnyInt, dtype: onp.ToDType[_SCT], format: _FmtBSR) -> bsr_matrix[_SCT]: ... -@overload # dtype like , format: "coo" +@overload # dtype: , format: "coo" def identity(n: opt.AnyInt, dtype: onp.ToDType[_SCT], format: _FmtCOO) -> coo_matrix[_SCT]: ... -@overload # dtype like , format: "csc" +@overload # dtype: , format: "csc" def identity(n: opt.AnyInt, dtype: onp.ToDType[_SCT], format: _FmtCSC) -> csc_matrix[_SCT]: ... -@overload # dtype like , format: "csr" +@overload # dtype: , format: "csr" def identity(n: opt.AnyInt, dtype: onp.ToDType[_SCT], format: _FmtCSR) -> csr_matrix[_SCT]: ... -@overload # dtype like , format: "dok" +@overload # dtype: , format: "dok" def identity(n: opt.AnyInt, dtype: onp.ToDType[_SCT], format: _FmtDOK) -> dok_matrix[_SCT]: ... -@overload # dtype like , format: "lil" +@overload # dtype: , format: "lil" def identity(n: opt.AnyInt, dtype: onp.ToDType[_SCT], format: _FmtLIL) -> lil_matrix[_SCT]: ... -@overload # dtype like , format: "bsr" + +# +@overload # dtype: , format: "dia" | None +def identity(n: opt.AnyInt, dtype: npt.DTypeLike, format: _FmtDIA | None = None) -> dia_matrix[Incomplete]: ... +@overload # dtype: , format: "bsr" def identity(n: opt.AnyInt, dtype: npt.DTypeLike, format: _FmtBSR) -> bsr_matrix[Incomplete]: ... -@overload # dtype like , format: "coo" +@overload # dtype: , format: "coo" def identity(n: opt.AnyInt, dtype: npt.DTypeLike, format: _FmtCOO) -> coo_matrix[Incomplete]: ... -@overload # dtype like , format: "csc" +@overload # dtype: , format: "csc" def identity(n: opt.AnyInt, dtype: npt.DTypeLike, format: _FmtCSC) -> csc_matrix[Incomplete]: ... -@overload # dtype like , format: "csr" +@overload # dtype: , format: "csr" def identity(n: opt.AnyInt, dtype: npt.DTypeLike, format: _FmtCSR) -> csr_matrix[Incomplete]: ... -@overload # dtype like , format: "dok" +@overload # dtype: , format: "dok" def identity(n: opt.AnyInt, dtype: npt.DTypeLike, format: _FmtDOK) -> dok_matrix[Incomplete]: ... -@overload # dtype like , format: "lil" +@overload # dtype: , format: "lil" def identity(n: opt.AnyInt, dtype: npt.DTypeLike, format: _FmtLIL) -> lil_matrix[Incomplete]: ... -# -@overload # dtype like bool, format: None = ... -def eye_array( - m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyBoolDType, format: _FmtDIA | None = None -) -> _DIAArray[np.bool_]: ... -@overload # dtype like int, format: None = ... -def eye_array( - m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyIntDType, format: _FmtDIA | None = None -) -> _DIAArray[np.int_]: ... -@overload # dtype like float (default), format: None = ... +### +@overload # dtype: float64-like (default), format: "dia" | None def eye_array( m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyFloat64DType = ..., format: _FmtDIA | None = None ) -> _DIAArray[np.float64]: ... -@overload # dtype like complex, format: None = ... -def eye_array( - m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyComplex128DType, format: _FmtDIA | None = None -) -> _DIAArray[np.complex128]: ... -@overload # dtype like , format: None = ... -def eye_array( - m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.ToDType[_SCT], format: _FmtDIA | None = None -) -> _DIAArray[_SCT]: ... -@overload # dtype like , format: None = ... -def eye_array( - m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: npt.DTypeLike, format: _FmtDIA | None = None -) -> _DIAArray[Incomplete]: ... -@overload # dtype like float (default), format: "bsr" +@overload # dtype: float64-like (default), format: "bsr" def eye_array( m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyFloat64DType = ..., format: _FmtBSR ) -> _BSRArray[np.float64]: ... -@overload # dtype like float (default), format: "coo" +@overload # dtype: float64-like (default), format: "coo" def eye_array( m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyFloat64DType = ..., format: _FmtCOO ) -> _COOArray2D[np.float64]: ... -@overload # dtype like float (default), format: "csc" +@overload # dtype: float64-like (default), format: "csc" def eye_array( m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyFloat64DType = ..., format: _FmtCSC ) -> _CSCArray[np.float64]: ... -@overload # dtype like float (default), format: "csr" +@overload # dtype: float64-like (default), format: "csr" def eye_array( m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyFloat64DType = ..., format: _FmtCSR ) -> _CSRArray2D[np.float64]: ... -@overload # dtype like float (default), format: "dok" +@overload # dtype: float64-like (default), format: "dok" def eye_array( m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyFloat64DType = ..., format: _FmtDOK ) -> _DOKArray2D[np.float64]: ... -@overload # dtype like float (default), format: "lil" +@overload # dtype: float64-like (default), format: "lil" def eye_array( m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyFloat64DType = ..., format: _FmtLIL ) -> _LILArray[np.float64]: ... -@overload # dtype like bool, format: "bsr" + +# +@overload # dtype: bool-like, format: "dia" | None +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyBoolDType, format: _FmtDIA | None = None +) -> _DIAArray[np.bool_]: ... +@overload # dtype: bool-like, format: "bsr" def eye_array( m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyBoolDType, format: _FmtBSR ) -> _BSRArray[np.bool_]: ... -@overload # dtype like bool, format: "coo" +@overload # dtype: bool-like, format: "coo" def eye_array( m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyBoolDType, format: _FmtCOO ) -> _COOArray2D[np.bool_]: ... -@overload # dtype like bool, format: "csc" +@overload # dtype: bool-like, format: "csc" def eye_array( m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyBoolDType, format: _FmtCSC ) -> _CSCArray[np.bool_]: ... -@overload # dtype like bool, format: "csr" +@overload # dtype: bool-like, format: "csr" def eye_array( m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyBoolDType, format: _FmtCSR ) -> _CSRArray2D[np.bool_]: ... -@overload # dtype like bool, format: "dok" +@overload # dtype: bool-like, format: "dok" def eye_array( m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyBoolDType, format: _FmtDOK ) -> _DOKArray2D[np.bool_]: ... -@overload # dtype like bool, format: "lil" +@overload # dtype: bool-like, format: "lil" def eye_array( m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyBoolDType, format: _FmtLIL ) -> _LILArray[np.bool_]: ... -@overload # dtype like int, format: "bsr" + +# +@overload # dtype: int-like, format: "dia" | None +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyIntDType, format: _FmtDIA | None = None +) -> _DIAArray[np.int_]: ... +@overload # dtype: int-like, format: "bsr" def eye_array( m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyIntDType, format: _FmtBSR ) -> _BSRArray[np.int_]: ... -@overload # dtype like int, format: "coo" +@overload # dtype: int-like, format: "coo" def eye_array( m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyIntDType, format: _FmtCOO ) -> _COOArray2D[np.int_]: ... -@overload # dtype like int, format: "csc" +@overload # dtype: int-like, format: "csc" def eye_array( m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyIntDType, format: _FmtCSC ) -> _CSCArray[np.int_]: ... -@overload # dtype like int, format: "csr" +@overload # dtype: int-like, format: "csr" def eye_array( m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyIntDType, format: _FmtCSR ) -> _CSRArray2D[np.int_]: ... -@overload # dtype like int, format: "dok" +@overload # dtype: int-like, format: "dok" def eye_array( m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyIntDType, format: _FmtDOK ) -> _DOKArray2D[np.int_]: ... -@overload # dtype like int, format: "lil" +@overload # dtype: int-like, format: "lil" def eye_array( m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyIntDType, format: _FmtLIL ) -> _LILArray[np.int_]: ... -@overload # dtype like complex, format: "bsr" + +# +@overload # dtype: complex128-like, format: "dia" | None +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyComplex128DType, format: _FmtDIA | None = None +) -> _DIAArray[np.complex128]: ... +@overload # dtype: complex128-like, format: "bsr" def eye_array( m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyComplex128DType, format: _FmtBSR ) -> _BSRArray[np.complex128]: ... -@overload # dtype like complex, format: "coo" +@overload # dtype: complex128-like, format: "coo" def eye_array( m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyComplex128DType, format: _FmtCOO ) -> _COOArray2D[np.complex128]: ... -@overload # dtype like complex, format: "csc" +@overload # dtype: complex128-like, format: "csc" def eye_array( m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyComplex128DType, format: _FmtCSC ) -> _CSCArray[np.complex128]: ... -@overload # dtype like complex, format: "csr" +@overload # dtype: complex128-like, format: "csr" def eye_array( m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyComplex128DType, format: _FmtCSR ) -> _CSRArray2D[np.complex128]: ... -@overload # dtype like complex, format: "dok" +@overload # dtype: complex128-like, format: "dok" def eye_array( m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyComplex128DType, format: _FmtDOK ) -> _DOKArray2D[np.complex128]: ... -@overload # dtype like complex, format: "lil" +@overload # dtype: complex128-like, format: "lil" def eye_array( m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.AnyComplex128DType, format: _FmtLIL ) -> _LILArray[np.complex128]: ... -@overload # dtype like , format: "bsr" + +# +@overload # dtype: , format: "dia" | None +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.ToDType[_SCT], format: _FmtDIA | None = None +) -> _DIAArray[_SCT]: ... +@overload # dtype: , format: "bsr" def eye_array( m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.ToDType[_SCT], format: _FmtBSR ) -> _BSRArray[_SCT]: ... -@overload # dtype like , format: "coo" +@overload # dtype: , format: "coo" def eye_array( m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.ToDType[_SCT], format: _FmtCOO ) -> _COOArray2D[_SCT]: ... -@overload # dtype like , format: "csc" +@overload # dtype: , format: "csc" def eye_array( m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.ToDType[_SCT], format: _FmtCSC ) -> _CSCArray[_SCT]: ... -@overload # dtype like , format: "csr" +@overload # dtype: , format: "csr" def eye_array( m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.ToDType[_SCT], format: _FmtCSR ) -> _CSRArray2D[_SCT]: ... -@overload # dtype like , format: "dok" +@overload # dtype: , format: "dok" def eye_array( m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.ToDType[_SCT], format: _FmtDOK ) -> _DOKArray2D[_SCT]: ... -@overload # dtype like , format: "lil" +@overload # dtype: , format: "lil" def eye_array( m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: onp.ToDType[_SCT], format: _FmtLIL ) -> _LILArray[_SCT]: ... -@overload # dtype like , format: "bsr" + +# +@overload # dtype: , format: "dia" | None +def eye_array( + m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: npt.DTypeLike, format: _FmtDIA | None = None +) -> _DIAArray[Incomplete]: ... +@overload # dtype: , format: "bsr" def eye_array( m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: npt.DTypeLike, format: _FmtBSR ) -> _BSRArray[Incomplete]: ... -@overload # dtype like , format: "coo" +@overload # dtype: , format: "coo" def eye_array( m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: npt.DTypeLike, format: _FmtCOO ) -> _COOArray2D[Incomplete]: ... -@overload # dtype like , format: "csc" +@overload # dtype: , format: "csc" def eye_array( m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: npt.DTypeLike, format: _FmtCSC ) -> _CSCArray[Incomplete]: ... -@overload # dtype like , format: "csr" +@overload # dtype: , format: "csr" def eye_array( m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: npt.DTypeLike, format: _FmtCSR ) -> _CSRArray2D[Incomplete]: ... -@overload # dtype like , format: "dok" +@overload # dtype: , format: "dok" def eye_array( m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: npt.DTypeLike, format: _FmtDOK ) -> _DOKArray2D[Incomplete]: ... -@overload # dtype like , format: "lil" +@overload # dtype: , format: "lil" def eye_array( m: opt.AnyInt, n: opt.AnyInt | None = None, *, k: int = 0, dtype: npt.DTypeLike, format: _FmtLIL ) -> _LILArray[Incomplete]: ... +### # NOTE: `eye_array` should be prefered over `eye` -@overload # dtype like float (default), default format +@overload # dtype: float64-like (default), format: "dia" | None def eye( m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, dtype: onp.AnyFloat64DType = ..., format: _FmtDIA | None = None ) -> dia_matrix[np.float64]: ... -@overload # dtype like bool, default format -def eye( - m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyBoolDType, format: _FmtDIA | None = None -) -> dia_matrix[np.bool_]: ... -@overload # dtype like int, default format -def eye( - m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyIntDType, format: _FmtDIA | None = None -) -> dia_matrix[np.int_]: ... -@overload # dtype like complex, default format -def eye( - m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyComplex128DType, format: _FmtDIA | None = None -) -> dia_matrix[np.complex128]: ... -@overload # dtype like , default format -def eye( - m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.ToDType[_SCT], format: _FmtDIA | None = None -) -> dia_matrix[_SCT]: ... -@overload # dtype like , default format -def eye( - m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: npt.DTypeLike, format: _FmtDIA | None = None -) -> dia_matrix[Incomplete]: ... -@overload # dtype like float (default), format: "bsr" +@overload # dtype: float64-like (default), format: "bsr" def eye( m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, dtype: onp.AnyFloat64DType = ..., *, format: _FmtBSR ) -> bsr_matrix[np.float64]: ... -@overload # dtype like bool, format: "bsr" +@overload # dtype: float64-like (default), format: "coo" def eye( - m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyBoolDType, format: _FmtBSR -) -> bsr_matrix[np.bool_]: ... -@overload # dtype like int, format: "bsr" + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, dtype: onp.AnyFloat64DType = ..., *, format: _FmtCOO +) -> coo_matrix[np.float64]: ... +@overload # dtype: float64-like (default), format: "csc" def eye( - m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyIntDType, format: _FmtBSR -) -> bsr_matrix[np.int_]: ... -@overload # dtype like complex, format: "bsr" + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, dtype: onp.AnyFloat64DType = ..., *, format: _FmtCSC +) -> csc_matrix[np.float64]: ... +@overload # dtype: float64-like (default), format: "csr" def eye( - m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyComplex128DType, format: _FmtBSR -) -> bsr_matrix[np.complex128]: ... -@overload # dtype like , format: "bsr" + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, dtype: onp.AnyFloat64DType = ..., *, format: _FmtCSR +) -> csr_matrix[np.float64]: ... +@overload # dtype: float64-like (default), format: "dok" def eye( - m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.ToDType[_SCT], format: _FmtBSR -) -> bsr_matrix[_SCT]: ... -@overload # dtype like , format: "bsr" + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, dtype: onp.AnyFloat64DType = ..., *, format: _FmtDOK +) -> dok_matrix[np.float64]: ... +@overload # dtype: float64-like (default), format: "lil" def eye( - m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: npt.DTypeLike, format: _FmtBSR -) -> bsr_matrix[Incomplete]: ... -@overload # dtype like float (default), format: "coo" + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, dtype: onp.AnyFloat64DType = ..., *, format: _FmtLIL +) -> lil_matrix[np.float64]: ... + +# +@overload # dtype: bool-like, format: "dia" | None def eye( - m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, dtype: onp.AnyFloat64DType = ..., *, format: _FmtCOO -) -> coo_matrix[np.float64]: ... -@overload # dtype like bool, format: "coo" + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyBoolDType, format: _FmtDIA | None = None +) -> dia_matrix[np.bool_]: ... +@overload # dtype: bool-like, format: "bsr" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyBoolDType, format: _FmtBSR +) -> bsr_matrix[np.bool_]: ... +@overload # dtype: bool-like, format: "coo" def eye( m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyBoolDType, format: _FmtCOO ) -> coo_matrix[np.bool_]: ... -@overload # dtype like int, format: "coo" +@overload # dtype: bool-like, format: "csc" def eye( - m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyIntDType, format: _FmtCOO -) -> coo_matrix[np.int_]: ... -@overload # dtype like complex, format: "coo" + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyBoolDType, format: _FmtCSC +) -> csc_matrix[np.bool_]: ... +@overload # dtype: bool-like, format: "csr" def eye( - m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyComplex128DType, format: _FmtCOO -) -> coo_matrix[np.complex128]: ... -@overload # dtype like , format: "coo" + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyBoolDType, format: _FmtCSR +) -> csr_matrix[np.bool_]: ... +@overload # dtype: bool-like, format: "dok" def eye( - m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.ToDType[_SCT], format: _FmtCOO -) -> coo_matrix[_SCT]: ... -@overload # dtype like , format: "coo" + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyBoolDType, format: _FmtDOK +) -> dok_matrix[np.bool_]: ... +@overload # dtype: bool-like, format: "lil" def eye( - m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: npt.DTypeLike, format: _FmtCOO -) -> coo_matrix[Incomplete]: ... -@overload # dtype like float (default), format: "csc" + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyBoolDType, format: _FmtLIL +) -> lil_matrix[np.bool_]: ... + +# +@overload # dtype: int-like, format: "dia" | None def eye( - m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, dtype: onp.AnyFloat64DType = ..., *, format: _FmtCSC -) -> csc_matrix[np.float64]: ... -@overload # dtype like bool, format: "csc" + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyIntDType, format: _FmtDIA | None = None +) -> dia_matrix[np.int_]: ... +@overload # dtype: int-like, format: "bsr" def eye( - m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyBoolDType, format: _FmtCSC -) -> csc_matrix[np.bool_]: ... -@overload # dtype like int, format: "csc" + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyIntDType, format: _FmtBSR +) -> bsr_matrix[np.int_]: ... +@overload # dtype: int-like, format: "coo" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyIntDType, format: _FmtCOO +) -> coo_matrix[np.int_]: ... +@overload # dtype: int-like, format: "csc" def eye( m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyIntDType, format: _FmtCSC ) -> csc_matrix[np.int_]: ... -@overload # dtype like complex, format: "csc" +@overload # dtype: int-like, format: "csr" def eye( - m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyComplex128DType, format: _FmtCSC -) -> csc_matrix[np.complex128]: ... -@overload # dtype like , format: "csc" + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyIntDType, format: _FmtCSR +) -> csr_matrix[np.int_]: ... +@overload # dtype: int-like, format: "dok" def eye( - m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.ToDType[_SCT], format: _FmtCSC -) -> csc_matrix[_SCT]: ... -@overload # dtype like , format: "csc" + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyIntDType, format: _FmtDOK +) -> dok_matrix[np.int_]: ... +@overload # dtype: int-like, format: "lil" def eye( - m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: npt.DTypeLike, format: _FmtCSC -) -> csc_matrix[Incomplete]: ... -@overload # dtype like float (default), format: "csr" + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyIntDType, format: _FmtLIL +) -> lil_matrix[np.int_]: ... + +# +@overload # dtype: complex128-like, format: "dia" | None def eye( - m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, dtype: onp.AnyFloat64DType = ..., *, format: _FmtCSR -) -> csr_matrix[np.float64]: ... -@overload # dtype like bool, format: "csr" + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyComplex128DType, format: _FmtDIA | None = None +) -> dia_matrix[np.complex128]: ... +@overload # dtype: complex128-like, format: "bsr" def eye( - m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyBoolDType, format: _FmtCSR -) -> csr_matrix[np.bool_]: ... -@overload # dtype like int, format: "csr" + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyComplex128DType, format: _FmtBSR +) -> bsr_matrix[np.complex128]: ... +@overload # dtype: complex128-like, format: "coo" def eye( - m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyIntDType, format: _FmtCSR -) -> csr_matrix[np.int_]: ... -@overload # dtype like complex, format: "csr" + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyComplex128DType, format: _FmtCOO +) -> coo_matrix[np.complex128]: ... +@overload # dtype: complex128-like, format: "csc" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyComplex128DType, format: _FmtCSC +) -> csc_matrix[np.complex128]: ... +@overload # dtype: complex128-like, format: "csr" def eye( m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyComplex128DType, format: _FmtCSR ) -> csr_matrix[np.complex128]: ... -@overload # dtype like , format: "csr" +@overload # dtype: complex128-like, format: "dok" def eye( - m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.ToDType[_SCT], format: _FmtCSR -) -> csr_matrix[_SCT]: ... -@overload # dtype like , format: "csr" + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyComplex128DType, format: _FmtDOK +) -> dok_matrix[np.complex128]: ... +@overload # dtype: complex128-like, format: "lil" def eye( - m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: npt.DTypeLike, format: _FmtCSR -) -> csr_matrix[Incomplete]: ... -@overload # dtype like float (default), format: "dok" + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyComplex128DType, format: _FmtLIL +) -> lil_matrix[np.complex128]: ... + +# +@overload # dtype: , format: "dia" | None def eye( - m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, dtype: onp.AnyFloat64DType = ..., *, format: _FmtDOK -) -> dok_matrix[np.float64]: ... -@overload # dtype like bool, format: "dok" + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.ToDType[_SCT], format: _FmtDIA | None = None +) -> dia_matrix[_SCT]: ... +@overload # dtype: , format: "bsr" def eye( - m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyBoolDType, format: _FmtDOK -) -> dok_matrix[np.bool_]: ... -@overload # dtype like int, format: "dok" + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.ToDType[_SCT], format: _FmtBSR +) -> bsr_matrix[_SCT]: ... +@overload # dtype: , format: "coo" def eye( - m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyIntDType, format: _FmtDOK -) -> dok_matrix[np.int_]: ... -@overload # dtype like complex, format: "dok" + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.ToDType[_SCT], format: _FmtCOO +) -> coo_matrix[_SCT]: ... +@overload # dtype: , format: "csc" def eye( - m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyComplex128DType, format: _FmtDOK -) -> dok_matrix[np.complex128]: ... -@overload # dtype like , format: "dok" + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.ToDType[_SCT], format: _FmtCSC +) -> csc_matrix[_SCT]: ... +@overload # dtype: , format: "csr" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.ToDType[_SCT], format: _FmtCSR +) -> csr_matrix[_SCT]: ... +@overload # dtype: , format: "dok" def eye( m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.ToDType[_SCT], format: _FmtDOK ) -> dok_matrix[_SCT]: ... -@overload # dtype like , format: "dok" +@overload # dtype: , format: "lil" def eye( - m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: npt.DTypeLike, format: _FmtDOK -) -> dok_matrix[Incomplete]: ... -@overload # dtype like float (default), format: "lil" + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.ToDType[_SCT], format: _FmtLIL +) -> lil_matrix[_SCT]: ... + +# +@overload # dtype: , format: "dia" | None def eye( - m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, dtype: onp.AnyFloat64DType = ..., *, format: _FmtLIL -) -> lil_matrix[np.float64]: ... -@overload # dtype like bool, format: "lil" + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: npt.DTypeLike, format: _FmtDIA | None = None +) -> dia_matrix[Incomplete]: ... +@overload # dtype: , format: "bsr" def eye( - m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyBoolDType, format: _FmtLIL -) -> lil_matrix[np.bool_]: ... -@overload # dtype like int, format: "lil" + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: npt.DTypeLike, format: _FmtBSR +) -> bsr_matrix[Incomplete]: ... +@overload # dtype: , format: "coo" def eye( - m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyIntDType, format: _FmtLIL -) -> lil_matrix[np.int_]: ... -@overload # dtype like complex, format: "lil" + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: npt.DTypeLike, format: _FmtCOO +) -> coo_matrix[Incomplete]: ... +@overload # dtype: , format: "csc" def eye( - m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.AnyComplex128DType, format: _FmtLIL -) -> lil_matrix[np.complex128]: ... -@overload # dtype like , format: "lil" + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: npt.DTypeLike, format: _FmtCSC +) -> csc_matrix[Incomplete]: ... +@overload # dtype: , format: "csr" def eye( - m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: onp.ToDType[_SCT], format: _FmtLIL -) -> lil_matrix[_SCT]: ... -@overload # dtype like , format: "lil" + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: npt.DTypeLike, format: _FmtCSR +) -> csr_matrix[Incomplete]: ... +@overload # dtype: , format: "dok" +def eye( + m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: npt.DTypeLike, format: _FmtDOK +) -> dok_matrix[Incomplete]: ... +@overload # dtype: , format: "lil" def eye( m: opt.AnyInt, n: opt.AnyInt | None = None, k: int = 0, *, dtype: npt.DTypeLike, format: _FmtLIL ) -> lil_matrix[Incomplete]: ... -# -@overload # A: spmatrix or 2d array-like, B: spmatrix or 2d array-like, format: {"bsr", None} = ... +### +@overload # A: spmatrix or 2d array-like, B: spmatrix or 2d array-like, format: "bsr" | None def kron(A: _ToSpMatrix[_SCT], B: _ToSpMatrix[_SCT], format: _FmtBSR | None = None) -> bsr_matrix[_SCT]: ... @overload # A: spmatrix or 2d array-like, B: spmatrix or 2d array-like, format: "coo" def kron(A: _ToSpMatrix[_SCT], B: _ToSpMatrix[_SCT], format: _FmtCOO) -> coo_matrix[_SCT]: ... @@ -1322,7 +1302,9 @@ def kron(A: _ToSpMatrix[_SCT], B: _ToSpMatrix[_SCT], format: _FmtDIA) -> dia_mat def kron(A: _ToSpMatrix[_SCT], B: _ToSpMatrix[_SCT], format: _FmtDOK) -> dok_matrix[_SCT]: ... @overload # A: spmatrix or 2d array-like, B: spmatrix or 2d array-like, format: "lil" def kron(A: _ToSpMatrix[_SCT], B: _ToSpMatrix[_SCT], format: _FmtLIL) -> lil_matrix[_SCT]: ... -@overload # A: sparray, B: 2D sparse, format: {"bsr", None} = ... + +# +@overload # A: sparray, B: 2D sparse, format: "bsr" | None def kron(A: sparray[_SCT, tuple[int, int]], B: _ToSparse2D[_SCT], format: _FmtBSR | None = None) -> _BSRArray[_SCT]: ... @overload # A: sparray, B: sparse, format: "coo" def kron(A: sparray[_SCT, tuple[int, int]], B: _ToSparse2D[_SCT], format: _FmtCOO) -> _COOArray2D[_SCT]: ... @@ -1336,7 +1318,9 @@ def kron(A: sparray[_SCT, tuple[int, int]], B: _ToSparse2D[_SCT], format: _FmtDI def kron(A: sparray[_SCT, tuple[int, int]], B: _ToSparse2D[_SCT], format: _FmtDOK) -> _DOKArray2D[_SCT]: ... @overload # A: sparray, B: sparse, format: "lil" def kron(A: sparray[_SCT, tuple[int, int]], B: _ToSparse2D[_SCT], format: _FmtLIL) -> _LILArray[_SCT]: ... -@overload # A: sparse, B: sparray, format: {"bsr", None} = ... + +# +@overload # A: sparse, B: sparray, format: "bsr" | None def kron(A: _ToSparse2D[_SCT], B: sparray[_SCT, tuple[int, int]], format: _FmtBSR | None = None) -> _BSRArray[_SCT]: ... @overload # A: sparray, B: sparse, format: "coo" def kron(A: _ToSparse2D[_SCT], B: sparray[_SCT, tuple[int, int]], format: _FmtCOO) -> _COOArray2D[_SCT]: ... @@ -1353,8 +1337,9 @@ def kron(A: _ToSparse2D[_SCT], B: sparray[_SCT, tuple[int, int]], format: _FmtLI @overload # A: unknown array-like, B: unknown array-like (catch-all) def kron(A: onp.ToComplex2D, B: onp.ToComplex2D, format: _Format | None = None) -> _SpBase2D[Incomplete]: ... +### # NOTE: The `overload-overlap` mypy errors are false positives. -@overload # A: spmatrix or 2d array-like, B: spmatrix or 2d array-like, format: {"csr", None} = ... +@overload # A: spmatrix or 2d array-like, B: spmatrix or 2d array-like, format: "csr" | None def kronsum(A: _ToSpMatrix[_SCT], B: _ToSpMatrix[_SCT], format: _FmtCSR | None = None) -> csr_matrix[_SCT]: ... @overload # A: spmatrix or 2d array-like, B: spmatrix or 2d array-like, format: "bsr" def kronsum(A: _ToSpMatrix[_SCT], B: _ToSpMatrix[_SCT], format: _FmtBSR) -> bsr_matrix[_SCT]: ... @@ -1368,7 +1353,9 @@ def kronsum(A: _ToSpMatrix[_SCT], B: _ToSpMatrix[_SCT], format: _FmtDIA) -> dia_ def kronsum(A: _ToSpMatrix[_SCT], B: _ToSpMatrix[_SCT], format: _FmtDOK) -> dok_matrix[_SCT]: ... @overload # A: spmatrix or 2d array-like, B: spmatrix or 2d array-like, format: "lil" def kronsum(A: _ToSpMatrix[_SCT], B: _ToSpMatrix[_SCT], format: _FmtLIL) -> lil_matrix[_SCT]: ... -@overload # A: sparray, B: sparse, format: {"csr", None} = ... + +# +@overload # A: sparray, B: sparse, format: "csr" | None def kronsum(A: sparray[_SCT, tuple[int, int]], B: _ToSparse2D[_SCT], format: _FmtCSR | None = None) -> _CSRArray2D[_SCT]: ... @overload # A: sparray, B: sparse, format: "bsr" def kronsum(A: sparray[_SCT, tuple[int, int]], B: _ToSparse2D[_SCT], format: _FmtBSR) -> _BSRArray[_SCT]: ... @@ -1382,7 +1369,9 @@ def kronsum(A: sparray[_SCT, tuple[int, int]], B: _ToSparse2D[_SCT], format: _Fm def kronsum(A: sparray[_SCT, tuple[int, int]], B: _ToSparse2D[_SCT], format: _FmtDOK) -> _DOKArray2D[_SCT]: ... @overload # A: sparray, B: sparse, format: "lil" def kronsum(A: sparray[_SCT, tuple[int, int]], B: _ToSparse2D[_SCT], format: _FmtLIL) -> _LILArray[_SCT]: ... -@overload # A: sparse, B: sparray, format: {"csr", None} = ... + +# +@overload # A: sparse, B: sparray, format: "csr" | None def kronsum(A: _ToSparse2D[_SCT], B: sparray[_SCT, tuple[int, int]], format: _FmtCSR | None = None) -> _CSRArray2D[_SCT]: ... @overload # A: sparse, B: sparray, format: "bsr" def kronsum(A: _ToSparse2D[_SCT], B: sparray[_SCT, tuple[int, int]], format: _FmtBSR) -> _BSRArray[_SCT]: ... @@ -1399,134 +1388,165 @@ def kronsum(A: _ToSparse2D[_SCT], B: sparray[_SCT, tuple[int, int]], format: _Fm @overload # A: unknown array-like, B: unknown array-like (catch-all) def kronsum(A: onp.ToComplex2D, B: onp.ToComplex2D, format: _Format | None = None) -> _SpBase2D[Incomplete]: ... +### # NOTE: keep in sync with `vstack` @overload # sparray, format: , dtype: def hstack(blocks: Seq[_CanStack[_T]], format: None = None, dtype: None = None) -> _T: ... -@overload # sparray, format: , dtype: T (keyword) +@overload # sparray, format: , dtype: def hstack(blocks: Seq[_CanStackAs[_SCT0, _T]], format: None = None, *, dtype: onp.ToDType[_SCT0]) -> _T: ... -@overload # sparray, format: , dtype: bool_ (keyword) +@overload # sparray, format: , dtype: bool-like def hstack(blocks: Seq[_CanStackAs[np.bool_, _T]], format: None = None, *, dtype: onp.AnyBoolDType) -> _T: ... -@overload # sparray, format: , dtype: int_ (keyword) +@overload # sparray, format: , dtype: int-like def hstack(blocks: Seq[_CanStackAs[np.int_, _T]], format: None = None, *, dtype: onp.AnyIntDType) -> _T: ... -@overload # sparray, format: , dtype: float64 (keyword) +@overload # sparray, format: , dtype: float64-like def hstack(blocks: Seq[_CanStackAs[np.float64, _T]], format: None = None, *, dtype: onp.AnyFloat64DType) -> _T: ... -@overload # sparray, format: , dtype: complex128 (keyword) +@overload # sparray, format: , dtype: complex128-like def hstack(blocks: Seq[_CanStackAs[np.complex128, _T]], format: None = None, *, dtype: onp.AnyComplex128DType) -> _T: ... -@overload # sparray, format: , dtype: complex128-like (keyword) +@overload # sparray, format: , dtype: def hstack(blocks: Seq[_CanStackAs[Any, _T]], format: None = None, *, dtype: npt.DTypeLike) -> _T: ... @overload # TODO(jorenham): Support for `format=...` def hstack(blocks: Seq[_spbase], format: _Format, dtype: npt.DTypeLike | None = None) -> Incomplete: ... +### # NOTE: keep in sync with `vstack` @overload # sparray, format: , dtype: def vstack(blocks: Seq[_CanStack[_T]], format: None = None, dtype: None = None) -> _T: ... -@overload # sparray, format: , dtype: T (keyword) +@overload # sparray, format: , dtype: def vstack(blocks: Seq[_CanStackAs[_SCT0, _T]], format: None = None, *, dtype: onp.ToDType[_SCT0]) -> _T: ... -@overload # sparray, format: , dtype: bool_ (keyword) +@overload # sparray, format: , dtype: bool-like def vstack(blocks: Seq[_CanStackAs[np.bool_, _T]], format: None = None, *, dtype: onp.AnyBoolDType) -> _T: ... -@overload # sparray, format: , dtype: int_ (keyword) +@overload # sparray, format: , dtype: int-like def vstack(blocks: Seq[_CanStackAs[np.int_, _T]], format: None = None, *, dtype: onp.AnyIntDType) -> _T: ... -@overload # sparray, format: , dtype: float64 (keyword) +@overload # sparray, format: , dtype: float64-like def vstack(blocks: Seq[_CanStackAs[np.float64, _T]], format: None = None, *, dtype: onp.AnyFloat64DType) -> _T: ... -@overload # sparray, format: , dtype: complex128 (keyword) +@overload # sparray, format: , dtype: complex128-like def vstack(blocks: Seq[_CanStackAs[np.complex128, _T]], format: None = None, *, dtype: onp.AnyComplex128DType) -> _T: ... -@overload # sparray, format: , dtype: complex128-like (keyword) +@overload # sparray, format: , dtype: def vstack(blocks: Seq[_CanStackAs[Any, _T]], format: None = None, *, dtype: npt.DTypeLike) -> _T: ... @overload # TODO(jorenham): Support for `format=...` def vstack(blocks: Seq[_spbase], format: _Format, dtype: npt.DTypeLike | None = None) -> Incomplete: ... +### # TODO(jorenham): Use `_CanStack` here, which requires a way to map matrix types to array types. @overload # blocks: , format: , dtype: -def block_array(blocks: _ToBlocks[_SCT], *, format: _FmtCOO | None = None, dtype: None = None) -> _COOArray2D[_SCT]: ... -@overload # blocks: , format: , dtype: -def block_array(blocks: _ToBlocks, *, format: _FmtCOO | None = None, dtype: onp.ToDType[_SCT]) -> _COOArray2D[_SCT]: ... -@overload # blocks: , format: , dtype: -def block_array(blocks: _ToBlocks, *, format: _FmtCOO | None = None, dtype: npt.DTypeLike) -> _COOArray2D: ... +def block_array(blocks: _ToBlocks[_SCT], format: _FmtCOO | None = None, dtype: None = None) -> _COOArray2D[_SCT]: ... @overload # blocks: , format: , dtype: -def block_array(blocks: _ToBlocks[_SCT], *, format: _FmtNonCOO, dtype: None = None) -> _SpArray2D[_SCT]: ... +def block_array(blocks: _ToBlocks[_SCT], format: _FmtNonCOO, dtype: None = None) -> _SpArray2D[_SCT]: ... + +# +@overload # blocks: , format: , dtype: +def block_array(blocks: _ToBlocks, format: _FmtCOO | None = None, *, dtype: onp.ToDType[_SCT]) -> _COOArray2D[_SCT]: ... @overload # blocks: , format: , dtype: def block_array(blocks: _ToBlocks, *, format: _FmtNonCOO, dtype: onp.ToDType[_SCT]) -> _SpArray2D[_SCT]: ... + +# +@overload # blocks: , format: , dtype: +def block_array(blocks: _ToBlocks, format: _FmtCOO | None = None, *, dtype: npt.DTypeLike) -> _COOArray2D: ... @overload # blocks: , format: , dtype: -def block_array(blocks: _ToBlocks, *, format: _FmtNonCOO, dtype: npt.DTypeLike) -> _SpArray2D: ... +def block_array(blocks: _ToBlocks, format: _FmtNonCOO, dtype: npt.DTypeLike) -> _SpArray2D: ... +### # TODO(jorenham): Use `_CanStack` here, which requires a way to map array types to matrix types. @overload # blocks: , format: , dtype: def bmat(blocks: Seq[Seq[sparray[_SCT]]], format: _FmtCOO | None = None, dtype: None = None) -> _COOArray2D[_SCT]: ... +@overload # blocks: , format: , dtype: +def bmat(blocks: Seq[Seq[sparray[_SCT]]], format: _FmtNonCOO, dtype: None = None) -> _SpArray2D[_SCT]: ... + +# @overload # blocks: , format: , dtype: def bmat(blocks: Seq[Seq[spmatrix[_SCT]]], format: _FmtCOO | None = None, dtype: None = None) -> coo_matrix[_SCT]: ... -@overload # sparray, blocks: , format: , dtype: (positional) -def bmat(blocks: _ToBlocks, format: _FmtCOO | None, dtype: onp.ToDType[_SCT]) -> _COOArray2D[_SCT] | coo_matrix[_SCT]: ... -@overload # sparray, blocks: , format: , dtype: (keyword) +@overload # blocks: , format: , dtype: +def bmat(blocks: Seq[Seq[spmatrix[_SCT]]], format: _FmtNonCOO, dtype: None = None) -> _SpMatrix[_SCT]: ... + +# +@overload # blocks: , format: , dtype: (keyword) def bmat( - blocks: _ToBlocks, format: _FmtCOO | None = None, *, dtype: onp.ToDType[_SCT] + blocks: _ToBlocks, /, format: _FmtCOO | None = None, *, dtype: onp.ToDType[_SCT] ) -> _COOArray2D[_SCT] | coo_matrix[_SCT]: ... -@overload # sparray, blocks: , format: , dtype: +@overload # blocks: , format: , dtype: (keyword) +def bmat(blocks: _ToBlocks, /, *, format: _FmtNonCOO, dtype: onp.ToDType[_SCT]) -> _COOArray2D[_SCT] | coo_matrix[_SCT]: ... + +# +@overload # blocks: , format: , dtype: (positional) +def bmat(blocks: _ToBlocks, format: _FmtCOO | None, dtype: onp.ToDType[_SCT]) -> _COOArray2D[_SCT] | coo_matrix[_SCT]: ... +@overload # blocks: , format: , dtype: (positional) +def bmat(blocks: _ToBlocks, format: _FmtNonCOO, dtype: onp.ToDType[_SCT]) -> _SpBase2D[_SCT]: ... + +# +@overload # blocks: , format: , dtype: def bmat( blocks: _ToBlocks[_SCT], format: _FmtCOO | None = None, dtype: npt.DTypeLike | None = None ) -> _COOArray2D[_SCT] | coo_matrix[_SCT]: ... -@overload # sparray, blocks: , format: , dtype: -def bmat(blocks: Seq[Seq[sparray[_SCT]]], format: _Format, dtype: None = None) -> _SpArray2D[_SCT]: ... -@overload # sparray, blocks: , format: , dtype: -def bmat(blocks: Seq[Seq[spmatrix[_SCT]]], format: _Format, dtype: None = None) -> _SpMatrix[_SCT]: ... -@overload # sparray, blocks: , format: , dtype: -def bmat(blocks: _ToBlocks, format: _Format, dtype: onp.ToDType[_SCT]) -> _SpBase2D[_SCT]: ... -@overload # sparray, blocks: , format: , dtype: -def bmat(blocks: _ToBlocks, format: _Format, dtype: npt.DTypeLike) -> _SpBase2D: ... +@overload # blocks: , format: , dtype: +def bmat(blocks: _ToBlocks[_SCT], format: _FmtNonCOO, dtype: npt.DTypeLike) -> _SpBase2D[_SCT]: ... +### # TODO(jorenham): Add support for non-COO formats. -@overload # mats: +@overload # mats: , format: , dtype: None def block_diag(mats: Iterable[sparray[_SCT]], format: _FmtCOO | None = None, dtype: None = None) -> _COOArray2D[_SCT]: ... -@overload # mats: + +# +@overload # mats: , format: , dtype: None def block_diag(mats: Iterable[spmatrix[_SCT]], format: _FmtCOO | None = None, dtype: None = None) -> coo_matrix[_SCT]: ... -@overload # mats: + +# +@overload # mats: , format: , dtype: None def block_diag( mats: Iterable[_spbase[_SCT] | onp.ArrayND[_SCT]], format: _FmtCOO | None = None, dtype: None = None ) -> _COOArray2D[_SCT] | coo_matrix[_SCT]: ... -@overload # mats: , dtype: (positional) -def block_diag(mats: Iterable[sparray], format: _FmtCOO | None, dtype: onp.ToDType[_SCT]) -> coo_array[_SCT, tuple[int, int]]: ... -@overload # mats: , dtype: (keyword) + +# +@overload # mats: , format: , dtype: (keyword) def block_diag(mats: Iterable[sparray], format: _FmtCOO | None = None, *, dtype: onp.ToDType[_SCT]) -> _COOArray2D[_SCT]: ... -@overload # mats: , dtype: (positional) +@overload # mats: , format: , dtype: (positional) +def block_diag(mats: Iterable[sparray], format: _FmtCOO | None, dtype: onp.ToDType[_SCT]) -> coo_array[_SCT, tuple[int, int]]: ... + +# +@overload # mats: , format: , dtype: (keyword) def block_diag( mats: Iterable[spmatrix | onp.ArrayND[_Numeric] | complex | Seq[onp.ToComplex] | Seq[onp.ToComplex1D]], - format: _FmtCOO | None, + format: _FmtCOO | None = None, + *, dtype: onp.ToDType[_SCT], ) -> coo_matrix[_SCT]: ... -@overload # mats: , dtype: (keyword) +@overload # mats: , format: , dtype: (positional) def block_diag( mats: Iterable[spmatrix | onp.ArrayND[_Numeric] | complex | Seq[onp.ToComplex] | Seq[onp.ToComplex1D]], - format: _FmtCOO | None = None, - *, + format: _FmtCOO | None, dtype: onp.ToDType[_SCT], ) -> coo_matrix[_SCT]: ... -@overload # mats: , dtype: (positional) + +# +@overload # mats: , format: , dtype: (keyword) def block_diag( mats: Iterable[_spbase | onp.ArrayND[_Numeric] | complex | Seq[onp.ToComplex] | Seq[onp.ToComplex1D]], - format: _FmtCOO | None, + format: _FmtCOO | None = None, + *, dtype: onp.ToDType[_SCT], ) -> _COOArray2D[_SCT] | coo_matrix[_SCT]: ... -@overload # mats: , dtype: (keyword) +@overload # mats: , format: , dtype: (positional) def block_diag( mats: Iterable[_spbase | onp.ArrayND[_Numeric] | complex | Seq[onp.ToComplex] | Seq[onp.ToComplex1D]], - format: _FmtCOO | None = None, - *, + format: _FmtCOO | None, dtype: onp.ToDType[_SCT], ) -> _COOArray2D[_SCT] | coo_matrix[_SCT]: ... -@overload # catch-all + +# +@overload # mats: , format: , dtype: def block_diag( mats: Iterable[_spbase | onp.ArrayND[_Numeric] | complex | Seq[onp.ToComplex] | Seq[onp.ToComplex1D]], format: _FmtCOO | None = None, dtype: npt.DTypeLike | None = None, ) -> _COOArray2D[_SCT] | coo_matrix[Any]: ... -@overload # catch-all +@overload # mats: , format: , dtype: def block_diag( mats: Iterable[_spbase | onp.ArrayND[_Numeric] | complex | Seq[onp.ToComplex] | Seq[onp.ToComplex1D]], - format: _Format | None = None, + format: _FmtNonCOO | None = None, dtype: npt.DTypeLike | None = None, ) -> Incomplete: ... -# -@overload # shape: T, dtype: , format: +### +@overload # shape: T, format: , dtype: def random_array( shape: _ShapeT, *, @@ -1537,130 +1557,93 @@ def random_array( random_state: onp.random.ToRNG | None = None, data_sampler: _DataSampler | None = None, ) -> coo_array[np.float64, _ShapeT]: ... -@overload # shape: T, dtype: , format: -def random_array( - shape: _ShapeT, - *, - density: float | npc.floating = 0.01, - format: _FmtCOO = "coo", - dtype: onp.ToDType[_SCT], - rng: onp.random.ToRNG | None = None, - random_state: onp.random.ToRNG | None = None, - data_sampler: _DataSampler | None = None, -) -> coo_array[_SCT, _ShapeT]: ... -@overload # shape: T, dtype: complex, format: +@overload # shape: T, format: , dtype: def random_array( shape: _ShapeT, *, density: float | npc.floating = 0.01, - format: _FmtCOO = "coo", - dtype: onp.AnyComplex128DType, + format: _FmtNonCOO, + dtype: onp.AnyFloat64DType | None = None, rng: onp.random.ToRNG | None = None, random_state: onp.random.ToRNG | None = None, data_sampler: _DataSampler | None = None, -) -> coo_array[np.complex128, _ShapeT]: ... -@overload # shape: T, dtype: , format: +) -> _SpArray[np.float64, _ShapeT]: ... + +# +@overload # shape: T, format: , dtype: def random_array( shape: _ShapeT, *, density: float | npc.floating = 0.01, format: _FmtCOO = "coo", - dtype: npt.DTypeLike, - rng: onp.random.ToRNG | None = None, - random_state: onp.random.ToRNG | None = None, - data_sampler: _DataSampler | None = None, -) -> coo_array[Any, _ShapeT]: ... -@overload # shape: T, dtype: -def random_array( - shape: tuple[int], - *, - density: float | npc.floating = 0.01, - format: _Format = "coo", - dtype: onp.AnyFloat64DType | None = None, - rng: onp.random.ToRNG | None = None, - random_state: onp.random.ToRNG | None = None, - data_sampler: _DataSampler | None = None, -) -> _SpArray1D[np.float64]: ... -@overload # shape: 2d, dtype: -def random_array( - shape: tuple[int, int], - *, - density: float | npc.floating = 0.01, - format: _Format = "coo", - dtype: onp.AnyFloat64DType | None = None, - rng: onp.random.ToRNG | None = None, - random_state: onp.random.ToRNG | None = None, - data_sampler: _DataSampler | None = None, -) -> _SpArray2D[np.float64]: ... -@overload # shape: 1d, dtype: -def random_array( - shape: tuple[int], - *, - density: float | npc.floating = 0.01, - format: _Format = "coo", dtype: onp.ToDType[_SCT], rng: onp.random.ToRNG | None = None, random_state: onp.random.ToRNG | None = None, data_sampler: _DataSampler | None = None, -) -> _SpArray1D[_SCT]: ... -@overload # shape: 2d, dtype: +) -> coo_array[_SCT, _ShapeT]: ... +@overload # shape: T, format: , dtype: def random_array( - shape: tuple[int, int], + shape: _ShapeT, *, density: float | npc.floating = 0.01, - format: _Format = "coo", + format: _FmtNonCOO, dtype: onp.ToDType[_SCT], rng: onp.random.ToRNG | None = None, random_state: onp.random.ToRNG | None = None, data_sampler: _DataSampler | None = None, -) -> _SpArray2D[_SCT]: ... -@overload # shape: 1d, dtype: complex +) -> _SpArray[_SCT, _ShapeT]: ... + +# +@overload # shape: T, format: , dtype: complex def random_array( - shape: tuple[int], + shape: _ShapeT, *, density: float | npc.floating = 0.01, - format: _Format = "coo", + format: _FmtCOO = "coo", dtype: onp.AnyComplex128DType, rng: onp.random.ToRNG | None = None, random_state: onp.random.ToRNG | None = None, data_sampler: _DataSampler | None = None, -) -> _SpArray1D[np.complex128]: ... -@overload # shape: 2d, dtype: complex +) -> coo_array[np.complex128, _ShapeT]: ... +@overload # shape: T, format: , dtype: complex def random_array( - shape: tuple[int, int], + shape: _ShapeT, *, density: float | npc.floating = 0.01, - format: _Format = "coo", + format: _FmtNonCOO, dtype: onp.AnyComplex128DType, rng: onp.random.ToRNG | None = None, random_state: onp.random.ToRNG | None = None, data_sampler: _DataSampler | None = None, -) -> _SpArray2D[np.complex128]: ... -@overload # shape: 1d, dtype: +) -> _SpArray[np.complex128, _ShapeT]: ... + +# +@overload # shape: T, format: , dtype: def random_array( - shape: tuple[int], + shape: _ShapeT, *, density: float | npc.floating = 0.01, - format: _Format = "coo", + format: _FmtCOO = "coo", dtype: npt.DTypeLike, rng: onp.random.ToRNG | None = None, random_state: onp.random.ToRNG | None = None, data_sampler: _DataSampler | None = None, -) -> _SpArray1D: ... -@overload # shape: 2d, dtype: +) -> coo_array[Any, _ShapeT]: ... +@overload # shape: T, format: , dtype: def random_array( - shape: tuple[int, int], + shape: _ShapeT, *, density: float | npc.floating = 0.01, - format: _Format = "coo", + format: _FmtNonCOO, dtype: npt.DTypeLike, rng: onp.random.ToRNG | None = None, random_state: onp.random.ToRNG | None = None, data_sampler: _DataSampler | None = None, -) -> _SpArray2D: ... +) -> _SpArray[Any, _ShapeT]: ... +### # NOTE: `random_array` should be prefered over `random` -@overload # dtype: , format: +@overload # format: , dtype: def random( m: opt.AnyInt, n: opt.AnyInt, @@ -1669,22 +1652,21 @@ def random( dtype: onp.AnyFloat64DType | None = None, rng: onp.random.ToRNG | None = None, data_rvs: _DataRVS | None = None, - *, - random_state: onp.random.ToRNG | None = None, ) -> coo_matrix[np.float64]: ... -@overload # dtype: (positional), format: +@overload # format: , dtype: def random( m: opt.AnyInt, n: opt.AnyInt, - density: float | npc.floating, - format: _FmtCOO, - dtype: onp.ToDType[_SCT], + density: float | npc.floating = 0.01, + *, + format: _FmtNonCOO, + dtype: onp.AnyFloat64DType | None = None, rng: onp.random.ToRNG | None = None, data_rvs: _DataRVS | None = None, - *, - random_state: onp.random.ToRNG | None = None, -) -> coo_matrix[_SCT]: ... -@overload # dtype: (keyword), format: +) -> _SpMatrix[np.float64]: ... + +# +@overload # format: , dtype: (keyword) def random( m: opt.AnyInt, n: opt.AnyInt, @@ -1694,119 +1676,123 @@ def random( dtype: onp.ToDType[_SCT], rng: onp.random.ToRNG | None = None, data_rvs: _DataRVS | None = None, - random_state: onp.random.ToRNG | None = None, ) -> coo_matrix[_SCT]: ... -@overload # dtype: complex (positional), format: +@overload # format: , dtype: (keyword) +def random( + m: opt.AnyInt, + n: opt.AnyInt, + density: float | npc.floating = 0.01, + *, + format: _FmtNonCOO, + dtype: onp.ToDType[_SCT], + rng: onp.random.ToRNG | None = None, + data_rvs: _DataRVS | None = None, +) -> _SpMatrix[_SCT]: ... + +# +@overload # format: , dtype: (positional) def random( m: opt.AnyInt, n: opt.AnyInt, density: float | npc.floating, format: _FmtCOO, - dtype: onp.AnyComplex128DType, + dtype: onp.ToDType[_SCT], rng: onp.random.ToRNG | None = None, data_rvs: _DataRVS | None = None, - *, - random_state: onp.random.ToRNG | None = None, -) -> coo_matrix[np.complex128]: ... -@overload # dtype: complex (keyword), format: +) -> coo_matrix[_SCT]: ... +@overload # format: , dtype: (positional) def random( m: opt.AnyInt, n: opt.AnyInt, - density: float | npc.floating = 0.01, - format: _FmtCOO = "coo", - *, - dtype: onp.AnyComplex128DType, + density: float | npc.floating, + format: _FmtNonCOO, + dtype: onp.ToDType[_SCT], rng: onp.random.ToRNG | None = None, data_rvs: _DataRVS | None = None, - random_state: onp.random.ToRNG | None = None, -) -> coo_matrix[np.complex128]: ... -@overload # dtype: , format: +) -> _SpMatrix[_SCT]: ... + +# +@overload # format: , dtype: complex (keyword) def random( m: opt.AnyInt, n: opt.AnyInt, density: float | npc.floating = 0.01, format: _FmtCOO = "coo", - dtype: npt.DTypeLike | None = None, + *, + dtype: onp.AnyComplex128DType, rng: onp.random.ToRNG | None = None, data_rvs: _DataRVS | None = None, - *, - random_state: onp.random.ToRNG | None = None, -) -> coo_matrix: ... -@overload # dtype: +) -> coo_matrix[np.complex128]: ... +@overload # format: , dtype: complex (keyword) def random( m: opt.AnyInt, n: opt.AnyInt, density: float | npc.floating = 0.01, - format: _Format = ..., - dtype: onp.AnyFloat64DType | None = None, + *, + format: _FmtNonCOO, + dtype: onp.AnyComplex128DType, rng: onp.random.ToRNG | None = None, data_rvs: _DataRVS | None = None, - *, - random_state: onp.random.ToRNG | None = None, -) -> _SpMatrix[np.float64]: ... -@overload # dtype: (positional) +) -> _SpMatrix[np.complex128]: ... + +# +@overload # format: , dtype: complex (positional) def random( m: opt.AnyInt, n: opt.AnyInt, density: float | npc.floating, - format: _Format, - dtype: onp.ToDType[_SCT], + format: _FmtCOO, + dtype: onp.AnyComplex128DType, rng: onp.random.ToRNG | None = None, data_rvs: _DataRVS | None = None, - *, - random_state: onp.random.ToRNG | None = None, -) -> _SpMatrix[_SCT]: ... -@overload # dtype: (keyword) +) -> coo_matrix[np.complex128]: ... +@overload # format: , dtype: complex (positional) def random( m: opt.AnyInt, n: opt.AnyInt, - density: float | npc.floating = 0.01, - format: _Format = ..., - *, - dtype: onp.ToDType[_SCT], + density: float | npc.floating, + format: _FmtNonCOO, + dtype: onp.AnyComplex128DType, rng: onp.random.ToRNG | None = None, data_rvs: _DataRVS | None = None, - random_state: onp.random.ToRNG | None = None, -) -> _SpMatrix[_SCT]: ... -@overload # dtype: complex (positional) +) -> _SpMatrix[np.complex128]: ... + +# +@overload # format: , dtype: def random( m: opt.AnyInt, n: opt.AnyInt, - density: float | npc.floating, - format: _Format, - dtype: onp.AnyComplex128DType, + density: float | npc.floating = 0.01, + format: _FmtCOO = "coo", + dtype: npt.DTypeLike | None = None, rng: onp.random.ToRNG | None = None, data_rvs: _DataRVS | None = None, - *, - random_state: onp.random.ToRNG | None = None, -) -> _SpMatrix[np.complex128]: ... -@overload # dtype: complex (keyword) +) -> coo_matrix: ... +@overload # format: (keyword), dtype: def random( m: opt.AnyInt, n: opt.AnyInt, density: float | npc.floating = 0.01, - format: _Format = ..., *, - dtype: onp.AnyComplex128DType, + format: _FmtNonCOO, + dtype: npt.DTypeLike | None = None, rng: onp.random.ToRNG | None = None, data_rvs: _DataRVS | None = None, - random_state: onp.random.ToRNG | None = None, -) -> _SpMatrix[np.complex128]: ... -@overload # dtype: +) -> _SpMatrix: ... +@overload # format: (positional), dtype: def random( m: opt.AnyInt, n: opt.AnyInt, - density: float | npc.floating = 0.01, - format: _Format = ..., + density: float | npc.floating, + format: _FmtNonCOO, dtype: npt.DTypeLike | None = None, rng: onp.random.ToRNG | None = None, data_rvs: _DataRVS | None = None, - *, - random_state: onp.random.ToRNG | None = None, ) -> _SpMatrix: ... +### # NOTE: `random_array` should be prefered over `rand` -@overload # dtype: , format: +@overload # format: , dtype: def rand( m: opt.AnyInt, n: opt.AnyInt, @@ -1814,21 +1800,20 @@ def rand( format: _FmtCOO = "coo", dtype: onp.AnyFloat64DType | None = None, rng: onp.random.ToRNG | None = None, - *, - random_state: onp.random.ToRNG | None = None, ) -> coo_matrix[np.float64]: ... -@overload # dtype: (positional), format: +@overload # format: , dtype: def rand( m: opt.AnyInt, n: opt.AnyInt, - density: float | npc.floating, - format: _FmtCOO, - dtype: onp.ToDType[_SCT], - rng: onp.random.ToRNG | None = None, + density: float | npc.floating = 0.01, *, - random_state: onp.random.ToRNG | None = None, -) -> coo_matrix[_SCT]: ... -@overload # dtype: (keyword), format: + format: _FmtNonCOO, + dtype: onp.AnyFloat64DType | None = None, + rng: onp.random.ToRNG | None = None, +) -> _SpMatrix[np.float64]: ... + +# +@overload # format: , dtype: (keyword) def rand( m: opt.AnyInt, n: opt.AnyInt, @@ -1837,20 +1822,40 @@ def rand( *, dtype: onp.ToDType[_SCT], rng: onp.random.ToRNG | None = None, - random_state: onp.random.ToRNG | None = None, ) -> coo_matrix[_SCT]: ... -@overload # dtype: complex (positional), format: +@overload # format: , dtype: (keyword) +def rand( + m: opt.AnyInt, + n: opt.AnyInt, + density: float | npc.floating = 0.01, + *, + format: _FmtNonCOO, + dtype: onp.ToDType[_SCT], + rng: onp.random.ToRNG | None = None, +) -> _SpMatrix[_SCT]: ... + +# +@overload # format: , dtype: (positional) def rand( m: opt.AnyInt, n: opt.AnyInt, density: float | npc.floating, format: _FmtCOO, - dtype: onp.AnyComplex128DType, + dtype: onp.ToDType[_SCT], rng: onp.random.ToRNG | None = None, - *, - random_state: onp.random.ToRNG | None = None, -) -> coo_matrix[np.complex128]: ... -@overload # dtype: complex (keyword), format: +) -> coo_matrix[_SCT]: ... +@overload # format: , dtype: (positional) +def rand( + m: opt.AnyInt, + n: opt.AnyInt, + density: float | npc.floating, + format: _FmtNonCOO, + dtype: onp.ToDType[_SCT], + rng: onp.random.ToRNG | None = None, +) -> _SpMatrix[_SCT]: ... + +# +@overload # format: , dtype: complex (keyword) def rand( m: opt.AnyInt, n: opt.AnyInt, @@ -1859,71 +1864,64 @@ def rand( *, dtype: onp.AnyComplex128DType, rng: onp.random.ToRNG | None = None, - random_state: onp.random.ToRNG | None = None, ) -> coo_matrix[np.complex128]: ... -@overload # dtype: +@overload # format: , dtype: complex (keyword) def rand( m: opt.AnyInt, n: opt.AnyInt, density: float | npc.floating = 0.01, - format: _Format = "coo", - dtype: onp.AnyFloat64DType | None = None, - rng: onp.random.ToRNG | None = None, *, - random_state: onp.random.ToRNG | None = None, -) -> _SpMatrix[np.float64]: ... -@overload # dtype: (positional) + format: _FmtNonCOO, + dtype: onp.AnyComplex128DType, + rng: onp.random.ToRNG | None = None, +) -> _SpMatrix[np.complex128]: ... + +# +@overload # format: , dtype: complex (positional) def rand( m: opt.AnyInt, n: opt.AnyInt, density: float | npc.floating, - format: _Format, - dtype: onp.ToDType[_SCT], + format: _FmtCOO, + dtype: onp.AnyComplex128DType, rng: onp.random.ToRNG | None = None, - *, - random_state: onp.random.ToRNG | None = None, -) -> _SpMatrix[_SCT]: ... -@overload # dtype: (keyword) +) -> coo_matrix[np.complex128]: ... +@overload # format: , dtype: complex (positional) def rand( m: opt.AnyInt, n: opt.AnyInt, - density: float | npc.floating = 0.01, - format: _Format = "coo", - *, - dtype: onp.ToDType[_SCT], + density: float | npc.floating, + format: _FmtNonCOO, + dtype: onp.AnyComplex128DType, rng: onp.random.ToRNG | None = None, - random_state: onp.random.ToRNG | None = None, -) -> _SpMatrix[_SCT]: ... -@overload # dtype: complex (positional) +) -> _SpMatrix[np.complex128]: ... + +# +@overload # format: , dtype: def rand( m: opt.AnyInt, n: opt.AnyInt, - density: float | npc.floating, - format: _Format, - dtype: onp.AnyComplex128DType, + density: float | npc.floating = 0.01, + format: _FmtCOO = "coo", + dtype: npt.DTypeLike | None = None, rng: onp.random.ToRNG | None = None, - *, - random_state: onp.random.ToRNG | None = None, -) -> _SpMatrix[np.complex128]: ... -@overload # dtype: complex (keyword) +) -> coo_matrix: ... +@overload # format: (keyword), dtype: def rand( m: opt.AnyInt, n: opt.AnyInt, density: float | npc.floating = 0.01, - format: _Format = "coo", *, - dtype: onp.AnyComplex128DType, + format: _FmtNonCOO, + dtype: npt.DTypeLike | None = None, rng: onp.random.ToRNG | None = None, - random_state: onp.random.ToRNG | None = None, -) -> _SpMatrix[np.complex128]: ... -@overload # dtype: +) -> _SpMatrix: ... +@overload # format: (positional), dtype: def rand( m: opt.AnyInt, n: opt.AnyInt, - density: float | npc.floating = 0.01, - format: _Format = "coo", + density: float | npc.floating, + format: _FmtNonCOO, dtype: npt.DTypeLike | None = None, rng: onp.random.ToRNG | None = None, - *, - random_state: onp.random.ToRNG | None = None, ) -> _SpMatrix: ... From 30bc0f1bbc28959c567b705b9c8a054c8dfe15a5 Mon Sep 17 00:00:00 2001 From: Jul Van den Broeck Date: Fri, 18 Jul 2025 00:52:44 +0200 Subject: [PATCH 14/20] Forgot substitution of `coo_array` with type alias --- scipy-stubs/sparse/_construct.pyi | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scipy-stubs/sparse/_construct.pyi b/scipy-stubs/sparse/_construct.pyi index f4757777..5c5131a8 100644 --- a/scipy-stubs/sparse/_construct.pyi +++ b/scipy-stubs/sparse/_construct.pyi @@ -1499,7 +1499,7 @@ def block_diag( @overload # mats: , format: , dtype: (keyword) def block_diag(mats: Iterable[sparray], format: _FmtCOO | None = None, *, dtype: onp.ToDType[_SCT]) -> _COOArray2D[_SCT]: ... @overload # mats: , format: , dtype: (positional) -def block_diag(mats: Iterable[sparray], format: _FmtCOO | None, dtype: onp.ToDType[_SCT]) -> coo_array[_SCT, tuple[int, int]]: ... +def block_diag(mats: Iterable[sparray], format: _FmtCOO | None, dtype: onp.ToDType[_SCT]) -> _COOArray2D[_SCT]: ... # @overload # mats: , format: , dtype: (keyword) From b89ed9a87a44244fbce0c360e26b82f1745cc24f Mon Sep 17 00:00:00 2001 From: Jul Van den Broeck Date: Fri, 18 Jul 2025 01:24:04 +0200 Subject: [PATCH 15/20] Added `random_state` again --- scipy-stubs/sparse/_construct.pyi | 40 +++++++++++++++++++++++++++++++ 1 file changed, 40 insertions(+) diff --git a/scipy-stubs/sparse/_construct.pyi b/scipy-stubs/sparse/_construct.pyi index 5c5131a8..68400192 100644 --- a/scipy-stubs/sparse/_construct.pyi +++ b/scipy-stubs/sparse/_construct.pyi @@ -1652,6 +1652,8 @@ def random( dtype: onp.AnyFloat64DType | None = None, rng: onp.random.ToRNG | None = None, data_rvs: _DataRVS | None = None, + *, + random_state: onp.random.ToRNG | None = None, ) -> coo_matrix[np.float64]: ... @overload # format: , dtype: def random( @@ -1663,6 +1665,7 @@ def random( dtype: onp.AnyFloat64DType | None = None, rng: onp.random.ToRNG | None = None, data_rvs: _DataRVS | None = None, + random_state: onp.random.ToRNG | None = None, ) -> _SpMatrix[np.float64]: ... # @@ -1676,6 +1679,7 @@ def random( dtype: onp.ToDType[_SCT], rng: onp.random.ToRNG | None = None, data_rvs: _DataRVS | None = None, + random_state: onp.random.ToRNG | None = None, ) -> coo_matrix[_SCT]: ... @overload # format: , dtype: (keyword) def random( @@ -1687,6 +1691,7 @@ def random( dtype: onp.ToDType[_SCT], rng: onp.random.ToRNG | None = None, data_rvs: _DataRVS | None = None, + random_state: onp.random.ToRNG | None = None, ) -> _SpMatrix[_SCT]: ... # @@ -1699,6 +1704,8 @@ def random( dtype: onp.ToDType[_SCT], rng: onp.random.ToRNG | None = None, data_rvs: _DataRVS | None = None, + *, + random_state: onp.random.ToRNG | None = None, ) -> coo_matrix[_SCT]: ... @overload # format: , dtype: (positional) def random( @@ -1709,6 +1716,8 @@ def random( dtype: onp.ToDType[_SCT], rng: onp.random.ToRNG | None = None, data_rvs: _DataRVS | None = None, + *, + random_state: onp.random.ToRNG | None = None, ) -> _SpMatrix[_SCT]: ... # @@ -1722,6 +1731,7 @@ def random( dtype: onp.AnyComplex128DType, rng: onp.random.ToRNG | None = None, data_rvs: _DataRVS | None = None, + random_state: onp.random.ToRNG | None = None, ) -> coo_matrix[np.complex128]: ... @overload # format: , dtype: complex (keyword) def random( @@ -1733,6 +1743,7 @@ def random( dtype: onp.AnyComplex128DType, rng: onp.random.ToRNG | None = None, data_rvs: _DataRVS | None = None, + random_state: onp.random.ToRNG | None = None, ) -> _SpMatrix[np.complex128]: ... # @@ -1745,6 +1756,8 @@ def random( dtype: onp.AnyComplex128DType, rng: onp.random.ToRNG | None = None, data_rvs: _DataRVS | None = None, + *, + random_state: onp.random.ToRNG | None = None, ) -> coo_matrix[np.complex128]: ... @overload # format: , dtype: complex (positional) def random( @@ -1755,6 +1768,8 @@ def random( dtype: onp.AnyComplex128DType, rng: onp.random.ToRNG | None = None, data_rvs: _DataRVS | None = None, + *, + random_state: onp.random.ToRNG | None = None, ) -> _SpMatrix[np.complex128]: ... # @@ -1767,6 +1782,8 @@ def random( dtype: npt.DTypeLike | None = None, rng: onp.random.ToRNG | None = None, data_rvs: _DataRVS | None = None, + *, + random_state: onp.random.ToRNG | None = None, ) -> coo_matrix: ... @overload # format: (keyword), dtype: def random( @@ -1778,6 +1795,7 @@ def random( dtype: npt.DTypeLike | None = None, rng: onp.random.ToRNG | None = None, data_rvs: _DataRVS | None = None, + random_state: onp.random.ToRNG | None = None, ) -> _SpMatrix: ... @overload # format: (positional), dtype: def random( @@ -1788,6 +1806,8 @@ def random( dtype: npt.DTypeLike | None = None, rng: onp.random.ToRNG | None = None, data_rvs: _DataRVS | None = None, + *, + random_state: onp.random.ToRNG | None = None, ) -> _SpMatrix: ... ### @@ -1800,6 +1820,8 @@ def rand( format: _FmtCOO = "coo", dtype: onp.AnyFloat64DType | None = None, rng: onp.random.ToRNG | None = None, + *, + random_state: onp.random.ToRNG | None = None, ) -> coo_matrix[np.float64]: ... @overload # format: , dtype: def rand( @@ -1810,6 +1832,7 @@ def rand( format: _FmtNonCOO, dtype: onp.AnyFloat64DType | None = None, rng: onp.random.ToRNG | None = None, + random_state: onp.random.ToRNG | None = None, ) -> _SpMatrix[np.float64]: ... # @@ -1822,6 +1845,7 @@ def rand( *, dtype: onp.ToDType[_SCT], rng: onp.random.ToRNG | None = None, + random_state: onp.random.ToRNG | None = None, ) -> coo_matrix[_SCT]: ... @overload # format: , dtype: (keyword) def rand( @@ -1832,6 +1856,7 @@ def rand( format: _FmtNonCOO, dtype: onp.ToDType[_SCT], rng: onp.random.ToRNG | None = None, + random_state: onp.random.ToRNG | None = None, ) -> _SpMatrix[_SCT]: ... # @@ -1843,6 +1868,8 @@ def rand( format: _FmtCOO, dtype: onp.ToDType[_SCT], rng: onp.random.ToRNG | None = None, + *, + random_state: onp.random.ToRNG | None = None, ) -> coo_matrix[_SCT]: ... @overload # format: , dtype: (positional) def rand( @@ -1852,6 +1879,8 @@ def rand( format: _FmtNonCOO, dtype: onp.ToDType[_SCT], rng: onp.random.ToRNG | None = None, + *, + random_state: onp.random.ToRNG | None = None, ) -> _SpMatrix[_SCT]: ... # @@ -1864,6 +1893,7 @@ def rand( *, dtype: onp.AnyComplex128DType, rng: onp.random.ToRNG | None = None, + random_state: onp.random.ToRNG | None = None, ) -> coo_matrix[np.complex128]: ... @overload # format: , dtype: complex (keyword) def rand( @@ -1874,6 +1904,7 @@ def rand( format: _FmtNonCOO, dtype: onp.AnyComplex128DType, rng: onp.random.ToRNG | None = None, + random_state: onp.random.ToRNG | None = None, ) -> _SpMatrix[np.complex128]: ... # @@ -1885,6 +1916,8 @@ def rand( format: _FmtCOO, dtype: onp.AnyComplex128DType, rng: onp.random.ToRNG | None = None, + *, + random_state: onp.random.ToRNG | None = None, ) -> coo_matrix[np.complex128]: ... @overload # format: , dtype: complex (positional) def rand( @@ -1894,6 +1927,8 @@ def rand( format: _FmtNonCOO, dtype: onp.AnyComplex128DType, rng: onp.random.ToRNG | None = None, + *, + random_state: onp.random.ToRNG | None = None, ) -> _SpMatrix[np.complex128]: ... # @@ -1905,6 +1940,8 @@ def rand( format: _FmtCOO = "coo", dtype: npt.DTypeLike | None = None, rng: onp.random.ToRNG | None = None, + *, + random_state: onp.random.ToRNG | None = None, ) -> coo_matrix: ... @overload # format: (keyword), dtype: def rand( @@ -1915,6 +1952,7 @@ def rand( format: _FmtNonCOO, dtype: npt.DTypeLike | None = None, rng: onp.random.ToRNG | None = None, + random_state: onp.random.ToRNG | None = None, ) -> _SpMatrix: ... @overload # format: (positional), dtype: def rand( @@ -1924,4 +1962,6 @@ def rand( format: _FmtNonCOO, dtype: npt.DTypeLike | None = None, rng: onp.random.ToRNG | None = None, + *, + random_state: onp.random.ToRNG | None = None, ) -> _SpMatrix: ... From 2d5c278adeb6f742e2570d2a70e90a78b8455911 Mon Sep 17 00:00:00 2001 From: Jul Van den Broeck Date: Fri, 18 Jul 2025 02:05:47 +0200 Subject: [PATCH 16/20] Fixed missing diags overloads, still some false positives... --- scipy-stubs/sparse/_construct.pyi | 141 ++++++++++++++---------------- tests/sparse/test_construct.pyi | 16 ++-- 2 files changed, 74 insertions(+), 83 deletions(-) diff --git a/scipy-stubs/sparse/_construct.pyi b/scipy-stubs/sparse/_construct.pyi index 68400192..2613c125 100644 --- a/scipy-stubs/sparse/_construct.pyi +++ b/scipy-stubs/sparse/_construct.pyi @@ -137,7 +137,7 @@ def diags_array( ) -> _DIAArray[_SCT]: ... @overload # diagonals: , format: "bsr", dtype: None def diags_array( - diagonals: onp.CanArray1D[_SCT] | onp.CanArray2D[_SCT], + diagonals: _CanArray1D2D[_SCT], /, *, offsets: _Offsets = 0, @@ -147,7 +147,7 @@ def diags_array( ) -> _BSRArray[_SCT]: ... @overload # diagonals: , format: "coo", dtype: None def diags_array( - diagonals: onp.CanArray1D[_SCT] | onp.CanArray2D[_SCT], + diagonals: _CanArray1D2D[_SCT], /, *, offsets: _Offsets = 0, @@ -157,7 +157,7 @@ def diags_array( ) -> _COOArray2D[_SCT]: ... @overload # diagonals: , format: "csc", dtype: None def diags_array( - diagonals: onp.CanArray1D[_SCT] | onp.CanArray2D[_SCT], + diagonals: _CanArray1D2D[_SCT], /, *, offsets: _Offsets = 0, @@ -167,7 +167,7 @@ def diags_array( ) -> _CSCArray[_SCT]: ... @overload # diagonals: , format: "csr", dtype: None def diags_array( - diagonals: onp.CanArray1D[_SCT] | onp.CanArray2D[_SCT], + diagonals: _CanArray1D2D[_SCT], /, *, offsets: _Offsets = 0, @@ -177,7 +177,7 @@ def diags_array( ) -> _CSRArray2D[_SCT]: ... @overload # diagonals: , format: "dok", dtype: None def diags_array( - diagonals: onp.CanArray1D[_SCT] | onp.CanArray2D[_SCT], + diagonals: _CanArray1D2D[_SCT], /, *, offsets: _Offsets = 0, @@ -187,7 +187,7 @@ def diags_array( ) -> _DOKArray2D[_SCT]: ... @overload # diagonals: , format: "lil", dtype: None def diags_array( - diagonals: onp.CanArray1D[_SCT] | onp.CanArray2D[_SCT], + diagonals: _CanArray1D2D[_SCT], /, *, offsets: _Offsets = 0, @@ -594,75 +594,72 @@ def diags_array( ### # NOTE: `diags_array` should be prefered over `diags` -@overload # diagonals: , format: "dia" | None +@overload # diagonals: , format: "dia" | None, dtype: None def diags( diagonals: _ToArray1D2D[_SCT], - /, - *, offsets: _Offsets = 0, shape: _ToShape2D | None = None, format: _FmtDIA | None = None, - dtype: onp.ToDType[_SCT] | None = None, + dtype: None = None, ) -> dia_matrix[_SCT]: ... -@overload # diagonals: , format: "bsr" +@overload # diagonals: , format: "bsr", dtype: None def diags( - diagonals: _ToArray1D2D[_SCT], - /, - *, - offsets: _Offsets = 0, - shape: _ToShape2D | None, - format: _FmtBSR, - dtype: onp.ToDType[_SCT] | None = None, + diagonals: _ToArray1D2D[_SCT], offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, format: _FmtBSR, dtype: None = None ) -> bsr_matrix[_SCT]: ... -@overload # diagonals: , format: "coo" +@overload # diagonals: , format: "coo", dtype: None def diags( - diagonals: _ToArray1D2D[_SCT], - /, - *, - offsets: _Offsets = 0, - shape: _ToShape2D | None, - format: _FmtCOO, - dtype: onp.ToDType[_SCT] | None = None, + diagonals: _ToArray1D2D[_SCT], offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, format: _FmtCOO, dtype: None = None ) -> coo_matrix[_SCT]: ... -@overload # diagonals: , format: "csr" +@overload # diagonals: , format: "csc", dtype: None def diags( - diagonals: _ToArray1D2D[_SCT], - /, - *, - offsets: _Offsets = 0, - shape: _ToShape2D | None, - format: _FmtCSR, - dtype: onp.ToDType[_SCT] | None = None, + diagonals: _ToArray1D2D[_SCT], offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, format: _FmtCSC, dtype: None = None +) -> csc_matrix[_SCT]: ... +@overload # diagonals: , format: "csr", dtype: None +def diags( + diagonals: _ToArray1D2D[_SCT], offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, format: _FmtCSR, dtype: None = None ) -> csr_matrix[_SCT]: ... -@overload # diagonals: , format: "csc" +@overload # diagonals: , format: "dok", dtype: None def diags( - diagonals: _ToArray1D2D[_SCT], - /, - *, + diagonals: _ToArray1D2D[_SCT], offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, format: _FmtDOK, dtype: None = None +) -> dok_matrix[_SCT]: ... +@overload # diagonals: , format: "lil", dtype: None +def diags( + diagonals: _ToArray1D2D[_SCT], offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, format: _FmtLIL, dtype: None = None +) -> lil_matrix[_SCT]: ... + +# +@overload # diagonals: , format: "dia" | None, dtype: +def diags( + diagonals: _ToArray1D2D, offsets: _Offsets = 0, - shape: _ToShape2D | None, - format: _FmtCSC, - dtype: onp.ToDType[_SCT] | None = None, + shape: _ToShape2D | None = None, + format: _FmtDIA | None = None, + *, + dtype: onp.ToDType[_SCT], +) -> dia_matrix[_SCT]: ... +@overload # diagonals: , format: "bsr", dtype: +def diags( + diagonals: _ToArray1D2D, offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, format: _FmtBSR, dtype: onp.ToDType[_SCT] +) -> bsr_matrix[_SCT]: ... +@overload # diagonals: , format: "coo", dtype: +def diags( + diagonals: _ToArray1D2D, offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, format: _FmtCOO, dtype: onp.ToDType[_SCT] +) -> coo_matrix[_SCT]: ... +@overload # diagonals: , format: "csr", dtype: +def diags( + diagonals: _ToArray1D2D, offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, format: _FmtCSR, dtype: onp.ToDType[_SCT] +) -> csr_matrix[_SCT]: ... +@overload # diagonals: , format: "csc", dtype: +def diags( + diagonals: _ToArray1D2D, offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, format: _FmtCSC, dtype: onp.ToDType[_SCT] ) -> csc_matrix[_SCT]: ... -@overload # diagonals: , format: "dok" +@overload # diagonals: , format: "dok", dtype: def diags( - diagonals: _ToArray1D2D[_SCT], - /, - *, - offsets: _Offsets = 0, - shape: _ToShape2D | None, - format: _FmtDOK, - dtype: onp.ToDType[_SCT] | None = None, + diagonals: _ToArray1D2D, offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, format: _FmtDOK, dtype: onp.ToDType[_SCT] ) -> dok_matrix[_SCT]: ... -@overload # diagonals: , format: "lil" +@overload # diagonals: , format: "lil", dtype: def diags( - diagonals: _ToArray1D2D[_SCT], - /, - *, - offsets: _Offsets = 0, - shape: _ToShape2D | None, - format: _FmtLIL, - dtype: onp.ToDType[_SCT] | None = None, + diagonals: _ToArray1D2D, offsets: _Offsets = 0, shape: _ToShape2D | None = None, *, format: _FmtLIL, dtype: onp.ToDType[_SCT] ) -> lil_matrix[_SCT]: ... # @@ -677,60 +674,54 @@ def diags( @overload # diagonals: , format: "bsr", dtype: def diags( diagonals: _ToComplex1D2D, - /, - *, offsets: _Offsets = 0, - shape: _ToShape2D | None, + shape: _ToShape2D | None = None, + *, format: _FmtBSR, dtype: npt.DTypeLike | None = None, ) -> bsr_matrix: ... @overload # diagonals: , format: "coo", dtype: def diags( diagonals: _ToComplex1D2D, - /, - *, offsets: _Offsets = 0, - shape: _ToShape2D | None, + shape: _ToShape2D | None = None, + *, format: _FmtCOO, dtype: npt.DTypeLike | None = None, ) -> coo_matrix: ... @overload # diagonals: , format: "csr", dtype: def diags( diagonals: _ToComplex1D2D, - /, - *, offsets: _Offsets = 0, - shape: _ToShape2D | None, + shape: _ToShape2D | None = None, + *, format: _FmtCSR, dtype: npt.DTypeLike | None = None, ) -> csr_matrix: ... @overload # diagonals: , format: "csc", dtype: def diags( diagonals: _ToComplex1D2D, - /, - *, offsets: _Offsets = 0, - shape: _ToShape2D | None, + shape: _ToShape2D | None = None, + *, format: _FmtCSC, dtype: npt.DTypeLike | None = None, ) -> csc_matrix: ... @overload # diagonals: , format: "dok" dtype: def diags( diagonals: _ToComplex1D2D, - /, - *, offsets: _Offsets = 0, - shape: _ToShape2D | None, + shape: _ToShape2D | None = None, + *, format: _FmtDOK, dtype: npt.DTypeLike | None = None, ) -> dok_matrix: ... @overload # diagonals: , format: "lil", dtype: def diags( diagonals: _ToComplex1D2D, - /, - *, offsets: _Offsets = 0, - shape: _ToShape2D | None, + shape: _ToShape2D | None = None, + *, format: _FmtLIL, dtype: npt.DTypeLike | None = None, ) -> lil_matrix: ... diff --git a/tests/sparse/test_construct.pyi b/tests/sparse/test_construct.pyi index 8a6b0cd8..8b12e6a7 100644 --- a/tests/sparse/test_construct.pyi +++ b/tests/sparse/test_construct.pyi @@ -70,14 +70,14 @@ assert_type(sparse.diags(dense_1d, format="csc"), sparse.csc_matrix[ScalarType]) assert_type(sparse.diags(dense_1d, format="csr"), sparse.csr_matrix[ScalarType]) assert_type(sparse.diags(dense_1d, format="dia"), sparse.dia_matrix[ScalarType]) assert_type(sparse.diags(dense_1d, format="dok"), sparse.dok_matrix[ScalarType]) -assert_type(sparse.diags(dense_1d, int_list, (5, 5), "lil"), sparse.lil_matrix[ScalarType]) -assert_type(sparse.diags(dense_1d, int_list, (5, 5), "bsr"), sparse.bsr_matrix[ScalarType]) -assert_type(sparse.diags(dense_1d, int_list, (5, 5), "coo"), sparse.coo_matrix[ScalarType]) -assert_type(sparse.diags(dense_1d, int_list, (5, 5), "csc"), sparse.csc_matrix[ScalarType]) -assert_type(sparse.diags(dense_1d, int_list, (5, 5), "csr"), sparse.csr_matrix[ScalarType]) -assert_type(sparse.diags(dense_1d, int_list, (5, 5), "dia"), sparse.dia_matrix[ScalarType]) -assert_type(sparse.diags(dense_1d, int_list, (5, 5), "dok"), sparse.dok_matrix[ScalarType]) -assert_type(sparse.diags(dense_1d, int_list, (5, 5), "lil"), sparse.lil_matrix[ScalarType]) +assert_type(sparse.diags(dense_1d, int_list, (5, 5), format="lil"), sparse.lil_matrix[ScalarType]) +assert_type(sparse.diags(dense_1d, int_list, (5, 5), format="bsr"), sparse.bsr_matrix[ScalarType]) +assert_type(sparse.diags(dense_1d, int_list, (5, 5), format="coo"), sparse.coo_matrix[ScalarType]) +assert_type(sparse.diags(dense_1d, int_list, (5, 5), format="csc"), sparse.csc_matrix[ScalarType]) +assert_type(sparse.diags(dense_1d, int_list, (5, 5), format="csr"), sparse.csr_matrix[ScalarType]) +assert_type(sparse.diags(dense_1d, int_list, (5, 5), format="dia"), sparse.dia_matrix[ScalarType]) +assert_type(sparse.diags(dense_1d, int_list, (5, 5), format="dok"), sparse.dok_matrix[ScalarType]) +assert_type(sparse.diags(dense_1d, int_list, (5, 5), format="lil"), sparse.lil_matrix[ScalarType]) assert_type(sparse.diags(dense_2d), sparse.dia_matrix[ScalarType]) assert_type(sparse.diags(dense_2d, format="bsr"), sparse.bsr_matrix[ScalarType]) assert_type(sparse.diags(dense_2d, format="coo"), sparse.coo_matrix[ScalarType]) From 161419321c7d74df6446ba176c92b3a7bc963f97 Mon Sep 17 00:00:00 2001 From: Jul Van den Broeck Date: Fri, 18 Jul 2025 02:10:43 +0200 Subject: [PATCH 17/20] Fixed signatures of block_array --- scipy-stubs/sparse/_construct.pyi | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/scipy-stubs/sparse/_construct.pyi b/scipy-stubs/sparse/_construct.pyi index 2613c125..487e5302 100644 --- a/scipy-stubs/sparse/_construct.pyi +++ b/scipy-stubs/sparse/_construct.pyi @@ -1420,21 +1420,21 @@ def vstack(blocks: Seq[_spbase], format: _Format, dtype: npt.DTypeLike | None = ### # TODO(jorenham): Use `_CanStack` here, which requires a way to map matrix types to array types. @overload # blocks: , format: , dtype: -def block_array(blocks: _ToBlocks[_SCT], format: _FmtCOO | None = None, dtype: None = None) -> _COOArray2D[_SCT]: ... +def block_array(blocks: _ToBlocks[_SCT], *, format: _FmtCOO | None = None, dtype: None = None) -> _COOArray2D[_SCT]: ... @overload # blocks: , format: , dtype: -def block_array(blocks: _ToBlocks[_SCT], format: _FmtNonCOO, dtype: None = None) -> _SpArray2D[_SCT]: ... +def block_array(blocks: _ToBlocks[_SCT], *, format: _FmtNonCOO, dtype: None = None) -> _SpArray2D[_SCT]: ... # @overload # blocks: , format: , dtype: -def block_array(blocks: _ToBlocks, format: _FmtCOO | None = None, *, dtype: onp.ToDType[_SCT]) -> _COOArray2D[_SCT]: ... +def block_array(blocks: _ToBlocks, *, format: _FmtCOO | None = None, dtype: onp.ToDType[_SCT]) -> _COOArray2D[_SCT]: ... @overload # blocks: , format: , dtype: def block_array(blocks: _ToBlocks, *, format: _FmtNonCOO, dtype: onp.ToDType[_SCT]) -> _SpArray2D[_SCT]: ... # @overload # blocks: , format: , dtype: -def block_array(blocks: _ToBlocks, format: _FmtCOO | None = None, *, dtype: npt.DTypeLike) -> _COOArray2D: ... +def block_array(blocks: _ToBlocks, *, format: _FmtCOO | None = None, dtype: npt.DTypeLike) -> _COOArray2D: ... @overload # blocks: , format: , dtype: -def block_array(blocks: _ToBlocks, format: _FmtNonCOO, dtype: npt.DTypeLike) -> _SpArray2D: ... +def block_array(blocks: _ToBlocks, *, format: _FmtNonCOO, dtype: npt.DTypeLike) -> _SpArray2D: ... ### # TODO(jorenham): Use `_CanStack` here, which requires a way to map array types to matrix types. From d35128e3d44865213bd23297713da9a27b813887 Mon Sep 17 00:00:00 2001 From: Jul Van den Broeck Date: Fri, 18 Jul 2025 02:19:28 +0200 Subject: [PATCH 18/20] Fixed bmat signatures --- scipy-stubs/sparse/_construct.pyi | 12 +++--------- 1 file changed, 3 insertions(+), 9 deletions(-) diff --git a/scipy-stubs/sparse/_construct.pyi b/scipy-stubs/sparse/_construct.pyi index 487e5302..2e9a70d3 100644 --- a/scipy-stubs/sparse/_construct.pyi +++ b/scipy-stubs/sparse/_construct.pyi @@ -1450,17 +1450,11 @@ def bmat(blocks: Seq[Seq[spmatrix[_SCT]]], format: _FmtCOO | None = None, dtype: def bmat(blocks: Seq[Seq[spmatrix[_SCT]]], format: _FmtNonCOO, dtype: None = None) -> _SpMatrix[_SCT]: ... # -@overload # blocks: , format: , dtype: (keyword) +@overload # blocks: , format: , dtype: def bmat( - blocks: _ToBlocks, /, format: _FmtCOO | None = None, *, dtype: onp.ToDType[_SCT] + blocks: _ToBlocks, format: _FmtCOO | None = None, *, dtype: onp.ToDType[_SCT] ) -> _COOArray2D[_SCT] | coo_matrix[_SCT]: ... -@overload # blocks: , format: , dtype: (keyword) -def bmat(blocks: _ToBlocks, /, *, format: _FmtNonCOO, dtype: onp.ToDType[_SCT]) -> _COOArray2D[_SCT] | coo_matrix[_SCT]: ... - -# -@overload # blocks: , format: , dtype: (positional) -def bmat(blocks: _ToBlocks, format: _FmtCOO | None, dtype: onp.ToDType[_SCT]) -> _COOArray2D[_SCT] | coo_matrix[_SCT]: ... -@overload # blocks: , format: , dtype: (positional) +@overload # blocks: , format: , dtype: def bmat(blocks: _ToBlocks, format: _FmtNonCOO, dtype: onp.ToDType[_SCT]) -> _SpBase2D[_SCT]: ... # From e23c6c048b5ccd33eb2976a1268ceef900cda074 Mon Sep 17 00:00:00 2001 From: Jul Van den Broeck Date: Fri, 18 Jul 2025 12:54:11 +0200 Subject: [PATCH 19/20] Added missing comma in comment --- scipy-stubs/sparse/_construct.pyi | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scipy-stubs/sparse/_construct.pyi b/scipy-stubs/sparse/_construct.pyi index 2e9a70d3..d4866a09 100644 --- a/scipy-stubs/sparse/_construct.pyi +++ b/scipy-stubs/sparse/_construct.pyi @@ -707,7 +707,7 @@ def diags( format: _FmtCSC, dtype: npt.DTypeLike | None = None, ) -> csc_matrix: ... -@overload # diagonals: , format: "dok" dtype: +@overload # diagonals: , format: "dok", dtype: def diags( diagonals: _ToComplex1D2D, offsets: _Offsets = 0, From a3ba142bfc79b8a3b2b1a17a6a887dabc6f7eb2d Mon Sep 17 00:00:00 2001 From: Jul Van den Broeck Date: Fri, 18 Jul 2025 13:44:44 +0200 Subject: [PATCH 20/20] Added TODOs + moved type aliases together --- scipy-stubs/sparse/_construct.pyi | 5 +++-- tests/sparse/test_construct.pyi | 2 +- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/scipy-stubs/sparse/_construct.pyi b/scipy-stubs/sparse/_construct.pyi index d4866a09..0cf8845d 100644 --- a/scipy-stubs/sparse/_construct.pyi +++ b/scipy-stubs/sparse/_construct.pyi @@ -38,13 +38,13 @@ __all__ = [ "vstack", ] -_Numeric: TypeAlias = np.bool_ | npc.number - _T = TypeVar("_T") _SCT = TypeVar("_SCT", bound=_Numeric, default=Any) _SCT0 = TypeVar("_SCT0", bound=_Numeric) _ShapeT = TypeVar("_ShapeT", bound=tuple[int, *tuple[int, ...]], default=tuple[Any, ...]) +_Numeric: TypeAlias = np.bool_ | npc.number + _ToArray1D: TypeAlias = Seq[_SCT] | onp.CanArray1D[_SCT] _ToArray2D: TypeAlias = Seq[Seq[_SCT] | onp.CanArray1D[_SCT]] | onp.CanArray2D[_SCT] _ToArray1D2D: TypeAlias = _ToArray1D[_SCT] | _ToArray2D[_SCT] @@ -76,6 +76,7 @@ _FmtDOK: TypeAlias = Literal["dok"] _FmtLIL: TypeAlias = Literal["lil"] _FmtNonCOO: TypeAlias = Literal["bsr", "csc", "csr", "dia", "dok", "lil"] +# TODO(julvandenbroeck): find a way to separate float and complex _ComplexSeq1D2D: TypeAlias = Seq[Seq[complex] | complex] _ToComplex1D2D: TypeAlias = onp.ToComplex1D | onp.ToComplex2D _Offsets: TypeAlias = onp.ToInt | onp.ToInt1D diff --git a/tests/sparse/test_construct.pyi b/tests/sparse/test_construct.pyi index 8b12e6a7..d68c8182 100644 --- a/tests/sparse/test_construct.pyi +++ b/tests/sparse/test_construct.pyi @@ -27,6 +27,7 @@ shape_1d: tuple[int] shape_2d: tuple[int, int] shape_3d: tuple[int, int, int] +# TODO(julvandenbroeck): add tests for arrays with unknown shape, like np.ndarray[tuple[int, ...], np.dtype[ScalarType]] dense_1d: np.ndarray[tuple[int], np.dtype[ScalarType]] dense_2d: np.ndarray[tuple[int, int], np.dtype[ScalarType]] @@ -36,7 +37,6 @@ int_list: list[int] ### # diags_array -# TODO: find way to only return float64 for real numbers and complex128 if there is a single complex number inside the sequence assert_type(sparse.diags_array([1, 2]), sparse.dia_array[np.float64] | sparse.dia_array[np.complex128]) assert_type(sparse.diags_array([[1, 2], 2.0]), sparse.dia_array[np.float64] | sparse.dia_array[np.complex128]) assert_type(sparse.diags_array([[1, 2.0], [2]]), sparse.dia_array[np.float64] | sparse.dia_array[np.complex128])