Skip to content

🎨 workaround for path-dependent pyright bug by shuffling disjoint overloads #745

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 3 commits into from
Jul 15, 2025
Merged

🎨 workaround for path-dependent pyright bug by shuffling disjoint overloads #745

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
3499cf3
♻️ `linalg`: simplified `_misc` dtypes, and explicit `Any` dtypes
jorenham Jul 15, 2025
436ad97
♻️ `fft`: shuffle (disjoint) `[i]fft*` overloads to avoid triggering …
jorenham Jul 15, 2025
efd1592
🎨 `cluster.vq`: simplify and shuffle overloads to avoid triggering a …
jorenham Jul 15, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
61 changes: 33 additions & 28 deletions scipy-stubs/cluster/vq.pyi
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,4 +1,4 @@
from collections.abc import Callable
from collections.abc import Callable, Sequence
from types import ModuleType
from typing import Final, Literal, TypeAlias, overload
from typing_extensions import TypeVar
Expand All @@ -9,12 +9,17 @@ import optype.numpy.compat as npc

__all__ = ["kmeans", "kmeans2", "vq", "whiten"]

_InexactT = TypeVar("_InexactT", bound=npc.inexact)

_InitMethod: TypeAlias = Literal["random", "points", "++", "matrix"]
_MissingMethod: TypeAlias = Literal["warn", "raise"]

_InexactT = TypeVar("_InexactT", bound=npc.inexact)
_ToFloat32_2D: TypeAlias = onp.ToArray2D[int, np.float32 | np.float16 | npc.integer16 | npc.integer8]
_AsFloat64_2D: TypeAlias = onp.ToArray2D[float, npc.floating64 | npc.integer]
_PyFloatMax2D: TypeAlias = Sequence[float] | Sequence[Sequence[float]]

###
# NOTE: DO NOT RE-ORDER THE OVERLOADS WITH a `# type: ignore`, otherwise it'll trigger a pernicious bug in pyright (1.1.403).

class ClusterError(Exception): ...

Expand All @@ -25,14 +30,14 @@ def whiten(obs: onp.ArrayND[np.bool_ | npc.integer], check_finite: bool | None =
def whiten(obs: onp.ArrayND[_InexactT], check_finite: bool | None = None) -> onp.Array2D[_InexactT]: ...

#
@overload # float32
def vq( # type: ignore[overload-overlap]
obs: onp.CanArrayND[np.float32], code_book: _ToFloat32_2D, check_finite: bool = True
) -> tuple[onp.Array1D[np.int32], onp.Array1D[np.float32]]: ...
@overload # float64
def vq(
obs: onp.ToJustFloat64_2D, code_book: onp.ToInt2D | onp.ToFloat64_2D, check_finite: bool = True
obs: onp.ToJustFloat64_2D, code_book: _AsFloat64_2D, check_finite: bool = True
) -> tuple[onp.Array1D[np.int32], onp.Array1D[np.float64]]: ...
@overload # float32
def vq(
obs: onp.CanArrayND[np.float32], code_book: onp.ToInt2D | onp.CanArrayND[np.float16 | np.float32], check_finite: bool = True
) -> tuple[onp.Array1D[np.int32], onp.Array1D[np.float32]]: ...
@overload # floating
def vq(
obs: onp.ToJustFloat2D, code_book: onp.ToFloat2D, check_finite: bool = True
Expand All @@ -49,32 +54,32 @@ def py_vq(
) -> tuple[onp.Array1D[np.intp], onp.Array1D[npc.floating]]: ...

#
@overload # float64
def kmeans(
obs: onp.ToJustFloat64_2D,
k_or_guess: onp.ToJustInt | onp.ToFloat64_ND,
@overload # float32
def kmeans( # type: ignore[overload-overlap]
obs: onp.CanArrayND[np.float32],
k_or_guess: int | _ToFloat32_2D,
iter: int = 20,
thresh: float = 1e-5,
check_finite: bool = True,
*,
seed: onp.random.ToRNG | None = None,
rng: onp.random.ToRNG | None = None,
) -> tuple[onp.Array2D[np.float64], np.float64]: ...
@overload # float32
) -> tuple[onp.Array2D[np.float32], np.float32]: ...
@overload # float64
def kmeans(
obs: onp.CanArrayND[np.float32],
k_or_guess: onp.ToJustInt | onp.ToFloatND,
obs: onp.ToJustFloat64_2D,
k_or_guess: int | _AsFloat64_2D,
iter: int = 20,
thresh: float = 1e-5,
check_finite: bool = True,
*,
seed: onp.random.ToRNG | None = None,
rng: onp.random.ToRNG | None = None,
) -> tuple[onp.Array2D[np.float32], np.float32]: ...
) -> tuple[onp.Array2D[np.float64], np.float64]: ...
@overload # floating
def kmeans(
obs: onp.ToJustFloat2D,
k_or_guess: onp.ToJustInt | onp.ToFloatND,
k_or_guess: int | onp.ToFloat2D,
iter: int = 20,
thresh: float = 1e-5,
check_finite: bool = True,
Expand Down Expand Up @@ -104,10 +109,10 @@ def _missing_raise() -> None: ... # undocumented
_valid_miss_meth: Final[dict[str, Callable[[], None]]] = ... # undocumented

#
@overload # float64
def kmeans2(
data: onp.ToJustFloat64_1D | onp.ToJustFloat64_2D,
k: onp.ToJustInt | onp.ToFloatND,
@overload # float32
def kmeans2( # type: ignore[overload-overlap]
data: onp.CanArrayND[np.float32],
k: int | _ToFloat32_2D,
iter: int = 10,
thresh: float = 1e-5,
minit: _InitMethod = "random",
Expand All @@ -116,11 +121,11 @@ def kmeans2(
*,
seed: onp.random.ToRNG | None = None,
rng: onp.random.ToRNG | None = None,
) -> tuple[onp.Array2D[np.float64], onp.Array1D[np.int32]]: ...
@overload # float32
) -> tuple[onp.Array2D[np.float32], onp.Array1D[np.int32]]: ...
@overload # float64
def kmeans2(
data: onp.CanArrayND[np.float32],
k: onp.ToJustInt | onp.ToFloatND,
data: onp.CanArrayND[np.float64] | _PyFloatMax2D,
k: int | _AsFloat64_2D,
iter: int = 10,
thresh: float = 1e-5,
minit: _InitMethod = "random",
Expand All @@ -129,11 +134,11 @@ def kmeans2(
*,
seed: onp.random.ToRNG | None = None,
rng: onp.random.ToRNG | None = None,
) -> tuple[onp.Array2D[np.float32], onp.Array1D[np.int32]]: ...
) -> tuple[onp.Array2D[np.float64], onp.Array1D[np.int32]]: ...
@overload # floating
def kmeans2(
data: onp.ToJustFloat1D | onp.ToJustFloat2D,
k: onp.ToJustInt | onp.ToFloatND,
data: onp.CanArrayND[npc.floating] | _PyFloatMax2D,
k: int | onp.ToFloat2D,
iter: int = 10,
thresh: float = 1e-5,
minit: _InitMethod = "random",
Expand Down
Loading