Merge pull request #184 from jorenham/refactor/onp

use the conventional `optype` import aliases

Author: jorenham

pyproject.toml

@@ -187,7 +187,7 @@ force-exclude = true
 target-version = "py310"
 # https://typing.readthedocs.io/en/latest/guides/writing_stubs.html#maximum-line-length
 line-length = 130
-src = ["scipy-stubs", "codemods.py"]
+src = ["scipy-stubs", "codegen"]
 
 [tool.ruff.format]
 line-ending = "lf"
@@ -236,15 +236,9 @@ select = [
 [tool.ruff.lint.flake8-import-conventions]
 banned-from = [
     "numpy",
-    "numpy.emath",
-    "numpy.fft",
-    "numpy.linalg",
     "numpy.ma",
-    "numpy.polynomial",
-    "numpy.random",
-    "numpy.rec",
     "numpy.typing",
-    "numpy.strings",
+    "optype",
     "optype.numpy",
     "optype.typing",
 ]
@@ -255,7 +249,7 @@ banned-from = [
 "numpy.typing" = "npt"
 "optype" = "op"
 "optype.typing" = "opt"
-"optype.numpy" = "onpt"
+"optype.numpy" = "onp"
 
 [tool.ruff.lint.isort]
 combine-as-imports = true

scipy-stubs/_lib/_array_api.pyi

@@ -4,7 +4,7 @@ from typing_extensions import TypeVar
 
 import numpy as np
 import numpy.typing as npt
-import optype.numpy as onpt
+import optype.numpy as onp
 from scipy._typing import AnyBool, OrderKACF
 
 __all__ = ["_asarray", "array_namespace", "device", "size"]
@@ -72,6 +72,6 @@ def device(x: _HasDevice[_DeviceT], /) -> _DeviceT: ...
 @overload
 def size(x: _HasShape[tuple[()] | tuple[_0, ...]]) -> _0: ...
 @overload
-def size(x: _HasShape[tuple[_SizeT] | onpt.AtLeast1D[_SizeT, _1] | tuple[_1, _SizeT]]) -> _SizeT: ...
+def size(x: _HasShape[tuple[_SizeT] | onp.AtLeast1D[_SizeT, _1] | tuple[_1, _SizeT]]) -> _SizeT: ...
 @overload
 def size(x: _HasShape) -> int: ...

scipy-stubs/_lib/_util.pyi

@@ -7,9 +7,9 @@ from typing_extensions import TypeVar, override
 import numpy as np
 import numpy.typing as npt
 import optype as op
-import optype.numpy as onpt
+import optype.numpy as onp
 from numpy._typing import _ArrayLikeInt
-from numpy.random import Generator as Generator  # noqa: ICN003
+from numpy.random import Generator as Generator
 from scipy._typing import RNG, EnterSelfMixin
 
 _AnyRNG = TypeVar("_AnyRNG", np.random.RandomState, np.random.Generator)
@@ -96,7 +96,7 @@ def rng_integers(
     low: _ArrayLikeInt,
     high: _ArrayLikeInt | None = None,
     size: tuple[()] | None = None,
-    dtype: onpt.AnyIntegerDType = "int64",
+    dtype: onp.AnyIntegerDType = "int64",
     endpoint: op.CanBool = False,
 ) -> np.integer[Any]: ...
 @overload
@@ -105,7 +105,7 @@ def rng_integers(
     low: _ArrayLikeInt,
     high: _ArrayLikeInt | None = None,
     size: op.CanIndex | Sequence[op.CanIndex] | None = None,
-    dtype: onpt.AnyIntegerDType = "int64",
+    dtype: onp.AnyIntegerDType = "int64",
     endpoint: op.CanBool = False,
 ) -> np.integer[Any] | npt.NDArray[np.integer[Any]]: ...
 

scipy-stubs/_typing.pyi

@@ -8,7 +8,7 @@ from typing_extensions import LiteralString, Self, TypeVar
 
 import numpy as np
 import optype as op
-import optype.numpy as onpt
+import optype.numpy as onp
 
 __all__ = [
     "RNG",
@@ -59,7 +59,7 @@ UntypedTuple: TypeAlias = tuple[Untyped, ...]
 UntypedList: TypeAlias = list[Untyped]
 UntypedDict: TypeAlias = dict[Untyped, Untyped]
 UntypedCallable: TypeAlias = Callable[..., Untyped]
-UntypedArray: TypeAlias = onpt.Array[Any, np.generic]
+UntypedArray: TypeAlias = onp.Array[Any, np.generic]
 
 # I/O
 _ByteSOrStr = TypeVar("_ByteSOrStr", bytes, str)

scipy-stubs/cluster/hierarchy.pyi

@@ -5,7 +5,7 @@ from typing_extensions import TypeVar, override
 
 import numpy as np
 import numpy.typing as npt
-import optype.numpy as onpt
+import optype.numpy as onp
 from scipy._lib._disjoint_set import DisjointSet
 from scipy.spatial.distance import _MetricCallback, _MetricKind
 
@@ -47,7 +47,7 @@ __all__ = [
 _T = TypeVar("_T")
 _SCT = TypeVar("_SCT", bound=np.number[Any], default=np.float64)
 _LinkageMethod: TypeAlias = Literal["single", "complete", "average", "weighted", "centroid", "median", "ward"]
-_LinkageArray: TypeAlias = onpt.Array[tuple[int, int], _SCT]
+_LinkageArray: TypeAlias = onp.Array[tuple[int, int], _SCT]
 _ClusterCriterion: TypeAlias = Literal["inconsistent", "distance", "maxclust", "monocrit", "maxclust_monocrit"]
 _SortOrder: TypeAlias = Literal["ascending", "descending"]
 
@@ -64,16 +64,16 @@ class _DendrogramResult(TypedDict):
 
 class ClusterWarning(UserWarning): ...
 
-def int_floor(arr: onpt.AnyArray, xp: ModuleType) -> int: ...
-def single(y: onpt.AnyArray) -> _LinkageArray: ...
-def complete(y: onpt.AnyArray) -> _LinkageArray: ...
-def average(y: onpt.AnyArray) -> _LinkageArray: ...
-def weighted(y: onpt.AnyArray) -> _LinkageArray: ...
-def centroid(y: onpt.AnyArray) -> _LinkageArray: ...
-def median(y: onpt.AnyArray) -> _LinkageArray: ...
-def ward(y: onpt.AnyArray) -> _LinkageArray: ...
+def int_floor(arr: onp.AnyArray, xp: ModuleType) -> int: ...
+def single(y: onp.AnyArray) -> _LinkageArray: ...
+def complete(y: onp.AnyArray) -> _LinkageArray: ...
+def average(y: onp.AnyArray) -> _LinkageArray: ...
+def weighted(y: onp.AnyArray) -> _LinkageArray: ...
+def centroid(y: onp.AnyArray) -> _LinkageArray: ...
+def median(y: onp.AnyArray) -> _LinkageArray: ...
+def ward(y: onp.AnyArray) -> _LinkageArray: ...
 def linkage(
-    y: onpt.AnyArray,
+    y: onp.AnyArray,
     method: _LinkageMethod = "single",
     metric: _MetricKind | _MetricCallback = "euclidean",
     optimal_ordering: bool = False,
@@ -109,61 +109,61 @@ class ClusterNode:
     def pre_order(self, /, func: Callable[[ClusterNode], _T]) -> list[_T]: ...
 
 def cut_tree(
-    Z: onpt.AnyArray,
+    Z: onp.AnyArray,
     n_clusters: Sequence[int] | npt.NDArray[np.integer[Any]] | None = None,
     height: Sequence[float] | npt.NDArray[np.integer[Any] | np.floating[Any]] | None = None,
-) -> onpt.Array[tuple[int, int], np.int64]: ...
+) -> onp.Array[tuple[int, int], np.int64]: ...
 @overload
-def to_tree(Z: onpt.AnyArray, rd: Literal[False] = False) -> ClusterNode: ...
+def to_tree(Z: onp.AnyArray, rd: Literal[False] = False) -> ClusterNode: ...
 @overload
-def to_tree(Z: onpt.AnyArray, rd: Literal[True]) -> tuple[ClusterNode, list[ClusterNode]]: ...
+def to_tree(Z: onp.AnyArray, rd: Literal[True]) -> tuple[ClusterNode, list[ClusterNode]]: ...
 def optimal_leaf_ordering(
-    Z: onpt.AnyArray,
-    y: onpt.AnyArray,
+    Z: onp.AnyArray,
+    y: onp.AnyArray,
     metric: _MetricKind | _MetricCallback = "euclidean",
 ) -> _LinkageArray: ...
 @overload
-def cophenet(Z: onpt.AnyArray, Y: None = None) -> onpt.Array[tuple[int], np.float64]: ...
+def cophenet(Z: onp.AnyArray, Y: None = None) -> onp.Array[tuple[int], np.float64]: ...
 @overload
 def cophenet(
-    Z: onpt.AnyArray,
-    Y: onpt.AnyArray,
-) -> tuple[onpt.Array[tuple[int], np.float64], onpt.Array[tuple[int], np.float64]]: ...
-def inconsistent(Z: onpt.AnyArray, d: int = 2) -> _LinkageArray: ...
-def from_mlab_linkage(Z: onpt.AnyArray) -> _LinkageArray: ...
-def to_mlab_linkage(Z: onpt.AnyArray) -> _LinkageArray: ...
-def is_monotonic(Z: onpt.AnyArray) -> bool: ...
-def is_valid_im(R: onpt.AnyArray, warning: bool = False, throw: bool = False, name: str | None = None) -> bool: ...
-def is_valid_linkage(Z: onpt.AnyArray, warning: bool = False, throw: bool = False, name: str | None = None) -> bool: ...
-def num_obs_linkage(Z: onpt.AnyArray) -> int: ...
-def correspond(Z: onpt.AnyArray, Y: onpt.AnyArray) -> bool: ...
+    Z: onp.AnyArray,
+    Y: onp.AnyArray,
+) -> tuple[onp.Array[tuple[int], np.float64], onp.Array[tuple[int], np.float64]]: ...
+def inconsistent(Z: onp.AnyArray, d: int = 2) -> _LinkageArray: ...
+def from_mlab_linkage(Z: onp.AnyArray) -> _LinkageArray: ...
+def to_mlab_linkage(Z: onp.AnyArray) -> _LinkageArray: ...
+def is_monotonic(Z: onp.AnyArray) -> bool: ...
+def is_valid_im(R: onp.AnyArray, warning: bool = False, throw: bool = False, name: str | None = None) -> bool: ...
+def is_valid_linkage(Z: onp.AnyArray, warning: bool = False, throw: bool = False, name: str | None = None) -> bool: ...
+def num_obs_linkage(Z: onp.AnyArray) -> int: ...
+def correspond(Z: onp.AnyArray, Y: onp.AnyArray) -> bool: ...
 def fcluster(
-    Z: onpt.AnyArray,
+    Z: onp.AnyArray,
     t: float | np.floating[Any] | np.integer[Any],
     criterion: _ClusterCriterion = "inconsistent",
     depth: int = 2,
-    R: onpt.AnyArray | None = None,
-    monocrit: onpt.AnyArray | None = None,
-) -> onpt.Array[tuple[int], np.int32]: ...
+    R: onp.AnyArray | None = None,
+    monocrit: onp.AnyArray | None = None,
+) -> onp.Array[tuple[int], np.int32]: ...
 def fclusterdata(
-    X: onpt.AnyArray,
+    X: onp.AnyArray,
     t: float | np.floating[Any] | np.integer[Any],
     criterion: _ClusterCriterion = "inconsistent",
     metric: _MetricKind | _MetricCallback = "euclidean",
     depth: int = 2,
     method: _LinkageMethod = "single",
-    R: onpt.AnyArray | None = None,
-) -> onpt.Array[tuple[int], np.int32]: ...
-def leaves_list(Z: onpt.AnyArray) -> onpt.Array[tuple[int], np.int32]: ...
+    R: onp.AnyArray | None = None,
+) -> onp.Array[tuple[int], np.int32]: ...
+def leaves_list(Z: onp.AnyArray) -> onp.Array[tuple[int], np.int32]: ...
 def set_link_color_palette(palette: list[str] | tuple[str, ...] | None) -> None: ...
 def dendrogram(
-    Z: onpt.AnyArray,
+    Z: onp.AnyArray,
     p: int = 30,
     truncate_mode: Literal["lastp", "level"] | None = None,
     color_threshold: float | np.floating[Any] | None = None,
     get_leaves: bool = True,
     orientation: Literal["top", "bottom", "left", "right"] = "top",
-    labels: onpt.AnyArray | None = None,
+    labels: onp.AnyArray | None = None,
     count_sort: _SortOrder | bool = False,
     distance_sort: _SortOrder | bool = False,
     show_leaf_counts: bool = True,
@@ -177,8 +177,8 @@ def dendrogram(
     ax: _MatplotlibAxes | None = None,
     above_threshold_color: str = "C0",
 ) -> _DendrogramResult: ...
-def is_isomorphic(T1: onpt.AnyArray, T2: onpt.AnyArray) -> bool: ...
-def maxdists(Z: onpt.AnyArray) -> onpt.Array[tuple[int], np.float64]: ...
-def maxinconsts(Z: onpt.AnyArray, R: onpt.AnyArray) -> onpt.Array[tuple[int], np.float64]: ...
-def maxRstat(Z: onpt.AnyArray, R: onpt.AnyArray, i: int) -> onpt.Array[tuple[int], np.float64]: ...
-def leaders(Z: onpt.AnyArray, T: onpt.AnyArray) -> tuple[onpt.Array[tuple[int], np.int32], onpt.Array[tuple[int], np.int32]]: ...
+def is_isomorphic(T1: onp.AnyArray, T2: onp.AnyArray) -> bool: ...
+def maxdists(Z: onp.AnyArray) -> onp.Array[tuple[int], np.float64]: ...
+def maxinconsts(Z: onp.AnyArray, R: onp.AnyArray) -> onp.Array[tuple[int], np.float64]: ...
+def maxRstat(Z: onp.AnyArray, R: onp.AnyArray, i: int) -> onp.Array[tuple[int], np.float64]: ...
+def leaders(Z: onp.AnyArray, T: onp.AnyArray) -> tuple[onp.Array[tuple[int], np.int32], onp.Array[tuple[int], np.int32]]: ...

scipy-stubs/cluster/vq.pyi

@@ -4,30 +4,30 @@ from typing_extensions import TypeVar
 
 import numpy as np
 import numpy.typing as npt
-import optype.numpy as onpt
+import optype.numpy as onp
 
 __all__ = ["kmeans", "kmeans2", "vq", "whiten"]
 
 _SCT_fc = TypeVar("_SCT_fc", bound=np.inexact[Any])
-_ArrayLike_1d_fc: TypeAlias = onpt.AnyNumberArray | Sequence[complex | np.number[Any]]
-_ArrayLike_2d_fc: TypeAlias = onpt.AnyNumberArray | Sequence[Sequence[complex | np.number[Any]]]
+_ArrayLike_1d_fc: TypeAlias = onp.AnyNumberArray | Sequence[complex | np.number[Any]]
+_ArrayLike_2d_fc: TypeAlias = onp.AnyNumberArray | Sequence[Sequence[complex | np.number[Any]]]
 
 class ClusterError(Exception): ...
 
 @overload
-def whiten(obs: npt.NDArray[_SCT_fc], check_finite: bool = True) -> onpt.Array[tuple[int, int], _SCT_fc]: ...
+def whiten(obs: npt.NDArray[_SCT_fc], check_finite: bool = True) -> onp.Array[tuple[int, int], _SCT_fc]: ...
 @overload
-def whiten(obs: _ArrayLike_2d_fc, check_finite: bool = True) -> onpt.Array[tuple[int, int], np.inexact[Any]]: ...
+def whiten(obs: _ArrayLike_2d_fc, check_finite: bool = True) -> onp.Array[tuple[int, int], np.inexact[Any]]: ...
 def vq(
     obs: _ArrayLike_2d_fc,
     code_book: _ArrayLike_2d_fc,
     check_finite: bool = True,
-) -> tuple[onpt.Array[tuple[int], np.int32 | np.intp], onpt.Array[tuple[int], _SCT_fc]]: ...
+) -> tuple[onp.Array[tuple[int], np.int32 | np.intp], onp.Array[tuple[int], _SCT_fc]]: ...
 def py_vq(
     obs: _ArrayLike_2d_fc,
     code_book: _ArrayLike_2d_fc,
     check_finite: bool = True,
-) -> tuple[onpt.Array[tuple[int], np.intp], onpt.Array[tuple[int], _SCT_fc]]: ...
+) -> tuple[onp.Array[tuple[int], np.intp], onp.Array[tuple[int], _SCT_fc]]: ...
 def kmeans(
     obs: _ArrayLike_2d_fc,
     k_or_guess: npt.ArrayLike,
@@ -36,7 +36,7 @@ def kmeans(
     check_finite: bool = True,
     *,
     seed: int | np.random.Generator | np.random.RandomState | None = None,
-) -> tuple[onpt.Array[tuple[int, int], np.inexact[Any]], float]: ...
+) -> tuple[onp.Array[tuple[int, int], np.inexact[Any]], float]: ...
 def kmeans2(
     data: _ArrayLike_1d_fc | _ArrayLike_2d_fc,
     k: npt.ArrayLike,
@@ -47,4 +47,4 @@ def kmeans2(
     check_finite: bool = True,
     *,
     seed: int | np.random.Generator | np.random.RandomState | None = None,
-) -> tuple[onpt.Array[tuple[int, int], np.inexact[Any]], onpt.Array[tuple[int], np.int32]]: ...
+) -> tuple[onp.Array[tuple[int, int], np.inexact[Any]], onp.Array[tuple[int], np.int32]]: ...

scipy-stubs/fft/_backend.pyi

@@ -2,7 +2,7 @@ from collections.abc import Mapping, Sequence
 from typing import Any, ClassVar, Protocol, final, type_check_only
 from typing_extensions import TypeVar
 
-from optype import CanWith
+import optype as op
 
 _RT_co = TypeVar("_RT_co", covariant=True, default=Any)
 
@@ -19,5 +19,5 @@ class _ScipyBackend(_BaseBackend): ...
 
 def set_global_backend(backend: _BaseBackend, coerce: bool = False, only: bool = False, try_last: bool = False) -> None: ...
 def register_backend(backend: _BaseBackend) -> None: ...
-def set_backend(backend: _BaseBackend, coerce: bool = False, only: bool = False) -> CanWith[None]: ...
-def skip_backend(backend: _BaseBackend) -> CanWith[None]: ...
+def set_backend(backend: _BaseBackend, coerce: bool = False, only: bool = False) -> op.CanWith[None]: ...
+def skip_backend(backend: _BaseBackend) -> op.CanWith[None]: ...