♻️ reduce reliance on "fake" *._typing modules (#731)

Author: jorenham

scipy-stubs/_lib/_elementwise_iterative_method.pyi

@@ -9,7 +9,6 @@ import optype.numpy as onp
 import optype.numpy.compat as npc
 
 from ._util import _RichResult
-from scipy._typing import Falsy
 
 ###
 
@@ -38,7 +37,7 @@ def _initialize(
     func: _FuncRealT,
     xs: Sequence[onp.ToFloat1D],
     args: tuple[onp.ToFloat1D, ...],
-    complex_ok: Falsy = False,
+    complex_ok: onp.ToFalse = False,
     preserve_shape: bool | None = None,
     xp: _ModuleT | None = None,
 ) -> tuple[

scipy-stubs/_lib/_threadsafety.pyi

@@ -1,16 +1,17 @@
 from collections.abc import Callable
 from typing_extensions import TypeVar
 
-from scipy._typing import EnterNoneMixin
+from scipy._typing import ExitMixin
 
 __all__ = ["ReentrancyError", "ReentrancyLock", "non_reentrant"]
 
 _FT = TypeVar("_FT", bound=Callable[..., object])
 
 class ReentrancyError(RuntimeError): ...
 
-class ReentrancyLock(EnterNoneMixin):
+class ReentrancyLock(ExitMixin):
     def __init__(self, /, err_msg: str) -> None: ...
+    def __enter__(self, /) -> None: ...
     def decorate(self, /, func: _FT) -> _FT: ...
 
 def non_reentrant(err_msg: str | None = None) -> Callable[[_FT], _FT]: ...

scipy-stubs/_lib/_uarray/_backend.pyi

@@ -4,7 +4,9 @@ from types import NotImplementedType
 from typing import Any, ClassVar, Final, Generic, Literal, Protocol, TypeAlias, TypedDict, final, overload, type_check_only
 from typing_extensions import ParamSpec, TypeVar, Unpack
 
-from scipy._typing import AnyBool, EnterNoneMixin
+import optype.numpy as onp
+
+from scipy._typing import ExitMixin
 
 __all__ = [
     "BackendNotImplementedError",
@@ -71,12 +73,14 @@ ArgumentReplacerType: TypeAlias = Callable[
 class _BackendState: ...
 
 @final
-class _SetBackendContext(EnterNoneMixin):
+class _SetBackendContext(ExitMixin):
     def __init__(self, /, *args: object, **kwargs: object) -> None: ...
+    def __enter__(self, /) -> None: ...
 
 @final
-class _SkipBackendContext(EnterNoneMixin):
+class _SkipBackendContext(ExitMixin):
     def __init__(self, /, *args: object, **kwargs: object) -> None: ...
+    def __enter__(self, /) -> None: ...
 
 @final
 class _Function(Generic[_Tss, _T_co]):
@@ -96,7 +100,7 @@ class Dispatchable(Generic[_T_co]):
     type: _DispatchType[_T_co]
     coercible: Final[bool]
 
-    def __init__(self, /, value: _T_co, dispatch_type: _DispatchType[_T_co], coercible: AnyBool = True) -> None: ...
+    def __init__(self, /, value: _T_co, dispatch_type: _DispatchType[_T_co], coercible: onp.ToBool = True) -> None: ...
     @overload
     def __getitem__(self, index: Literal[1, -1], /) -> _T_co: ...
     @overload
@@ -124,15 +128,15 @@ def generate_multimethod(
 ) -> _Function[_Tss, _T]: ...
 
 #
-def set_backend(backend: _Backend, coerce: AnyBool = False, only: AnyBool = False) -> _SetBackendContext: ...
+def set_backend(backend: _Backend, coerce: onp.ToBool = False, only: onp.ToBool = False) -> _SetBackendContext: ...
 def skip_backend(backend: _Backend) -> _SkipBackendContext: ...
 
 #
 def set_global_backend(
-    backend: _Backend, coerce: AnyBool = False, only: AnyBool = False, *, try_last: AnyBool = False
+    backend: _Backend, coerce: onp.ToBool = False, only: onp.ToBool = False, *, try_last: onp.ToBool = False
 ) -> None: ...
 def register_backend(backend: _Backend) -> None: ...
-def clear_backends(domain: str | None, registered: AnyBool = True, globals: AnyBool = False) -> None: ...
+def clear_backends(domain: str | None, registered: onp.ToBool = True, globals: onp.ToBool = False) -> None: ...
 
 #
 def mark_as(dispatch_type: type[_T] | str) -> Callable[[_T], Dispatchable[_T]]: ...
@@ -144,37 +148,37 @@ def all_of_type(
 @overload
 def wrap_single_convertor(
     convert_single: Callable[[_V, _DispatchType[_V], bool], _C],
-) -> Callable[[Iterable[Dispatchable[_V]], AnyBool], list[_C]]: ...
+) -> Callable[[Iterable[Dispatchable[_V]], onp.ToBool], list[_C]]: ...
 @overload
 def wrap_single_convertor(
     convert_single: Callable[[_V, _DispatchType[_V], bool], NotImplementedType],
-) -> Callable[[Iterable[Dispatchable[_V]], AnyBool], NotImplementedType]: ...
+) -> Callable[[Iterable[Dispatchable[_V]], onp.ToBool], NotImplementedType]: ...
 @overload
 def wrap_single_convertor(
     convert_single: Callable[[_V, _DispatchType[_V], bool], _C | NotImplementedType],
-) -> Callable[[Iterable[Dispatchable[_V]], AnyBool], list[_C] | NotImplementedType]: ...
+) -> Callable[[Iterable[Dispatchable[_V]], onp.ToBool], list[_C] | NotImplementedType]: ...
 @overload
 def wrap_single_convertor_instance(
     convert_single: Callable[[_S, _V, _DispatchType[_V], bool], _C],
-) -> Callable[[_S, Iterable[Dispatchable[_V]], AnyBool], list[_C]]: ...
+) -> Callable[[_S, Iterable[Dispatchable[_V]], onp.ToBool], list[_C]]: ...
 @overload
 def wrap_single_convertor_instance(
     convert_single: Callable[[_S, _V, _DispatchType[_V], bool], NotImplementedType],
-) -> Callable[[_S, Iterable[Dispatchable[_V]], AnyBool], NotImplementedType]: ...
+) -> Callable[[_S, Iterable[Dispatchable[_V]], onp.ToBool], NotImplementedType]: ...
 @overload
 def wrap_single_convertor_instance(
     convert_single: Callable[[_S, _V, _DispatchType[_V], bool], _C | NotImplementedType],
-) -> Callable[[_S, Iterable[Dispatchable[_V]], AnyBool], list[_C] | NotImplementedType]: ...
+) -> Callable[[_S, Iterable[Dispatchable[_V]], onp.ToBool], list[_C] | NotImplementedType]: ...
 
 #
 def determine_backend(
-    value: _V, dispatch_type: _DispatchType[_V], *, domain: str, only: AnyBool = True, coerce: AnyBool = False
+    value: _V, dispatch_type: _DispatchType[_V], *, domain: str, only: onp.ToBool = True, coerce: onp.ToBool = False
 ) -> _SetBackendContext: ...
 def determine_backend_multi(
     dispatchables: Iterable[_V | Dispatchable[_V]],
     *,
     domain: str,
-    only: AnyBool = True,
-    coerce: AnyBool = False,
+    only: onp.ToBool = True,
+    coerce: onp.ToBool = False,
     **kwargs: Unpack[_DetermineBackendMultiKwargs[_T]],
 ) -> _SetBackendContext: ...

scipy-stubs/_lib/_util.pyi

@@ -2,7 +2,7 @@ import multiprocessing.pool as mpp
 import sys
 import types
 from collections.abc import Callable, Iterable, Sequence
-from typing import Any, Concatenate, Final, Generic, Literal, NamedTuple, Never, TypeAlias, overload
+from typing import Any, Concatenate, Final, Generic, Literal, NamedTuple, Never, Self, TypeAlias, overload
 from typing_extensions import TypeVar, override
 
 import numpy as np
@@ -11,7 +11,7 @@ import optype.numpy as onp
 import optype.numpy.compat as npc
 from numpy.random import Generator as Generator  # implicit re-export
 
-from scipy._typing import RNG, EnterSelfMixin
+from scipy._typing import ExitMixin
 
 _AnyRNGT = TypeVar("_AnyRNGT", np.random.RandomState, np.random.Generator)
 
@@ -71,11 +71,12 @@ class _FunctionWrapper(Generic[_T_contra, _T_co]):
     def __init__(self, /, f: Callable[Concatenate[_T_contra, ...], _T_co], args: tuple[object, ...]) -> None: ...
     def __call__(self, /, x: _T_contra) -> _T_co: ...
 
-class MapWrapper(EnterSelfMixin):
+class MapWrapper(ExitMixin):
     pool: int | mpp.Pool | None
 
     def __init__(self, /, pool: Callable[[Callable[[_VT], _RT], Iterable[_VT]], Iterable[_RT]] | int = 1) -> None: ...
     def __call__(self, /, func: Callable[[_VT], _RT], iterable: Iterable[_VT]) -> Iterable[_RT]: ...
+    def __enter__(self, /) -> Self: ...
     def terminate(self, /) -> None: ...
     def join(self, /) -> None: ...
     def close(self, /) -> None: ...
@@ -100,7 +101,7 @@ def check_random_state(seed: onp.ToJustInt | types.ModuleType | None) -> np.rand
 #
 @overload
 def rng_integers(
-    gen: RNG | None,
+    gen: onp.random.RNG | None,
     low: onp.ToInt,
     high: onp.ToInt | None = None,
     size: tuple[()] | None = None,
@@ -109,7 +110,7 @@ def rng_integers(
 ) -> npc.integer: ...
 @overload
 def rng_integers(
-    gen: RNG | None,
+    gen: onp.random.RNG | None,
     low: onp.ToInt | onp.ToIntND,
     high: onp.ToInt | onp.ToIntND | None = None,
     size: op.CanIndex | Sequence[op.CanIndex] | None = None,

scipy-stubs/_typing.pyi

@@ -1,123 +1,16 @@
-# NOTE: This private(!) module only exists in `if typing.TYPE_CHECKING: ...` and in `.pyi` stubs
+# NOTE(scipy-stubs): This private module should not be used outside of scipy-stubs
 
-from _typeshed import Incomplete
-from collections.abc import Iterator, Sequence
-from os import PathLike
+from collections.abc import Sequence
 from types import TracebackType
-from typing import IO, Literal, LiteralString, Protocol, Self, SupportsIndex, TypeAlias, overload, type_check_only
-from typing_extensions import TypeVar
+from typing import SupportsIndex, TypeAlias, final, type_check_only
 
-import numpy as np
-import optype as op
-import optype.numpy as onp
-import optype.numpy.compat as npc
-
-__all__ = [
-    "RNG",
-    "Alternative",
-    "AnyBool",
-    "AnyShape",
-    "ByteOrder",
-    "Casting",
-    "ConvMode",
-    "EnterNoneMixin",
-    "EnterSelfMixin",
-    "Falsy",
-    "FileLike",
-    "FileModeRW",
-    "FileModeRWA",
-    "FileName",
-    "NanPolicy",
-    "OrderCF",
-    "OrderKACF",
-    "SequenceNotStr",
-    "ToRNG",
-    "Truthy",
-    "_FortranFunction",
-]
+__all__ = "AnyShape", "ExitMixin"
 
 # helper mixins
 @type_check_only
-class EnterSelfMixin:
-    def __enter__(self, /) -> Self: ...
-    def __exit__(self, /, type: type[BaseException] | None, value: BaseException | None, tb: TracebackType | None) -> None: ...
-
-@type_check_only
-class EnterNoneMixin:
-    def __enter__(self, /) -> None: ...
+class ExitMixin:
+    @final
     def __exit__(self, /, type: type[BaseException] | None, value: BaseException | None, tb: TracebackType | None) -> None: ...
 
-# used in `scipy.linalg.blas` and `scipy.linalg.lapack`
-@type_check_only
-class _FortranFunction(Protocol):
-    @property
-    def dtype(self, /) -> np.dtype[Incomplete]: ...
-    @property
-    def int_dtype(self, /) -> np.dtype[npc.integer]: ...
-    @property
-    def module_name(self, /) -> LiteralString: ...
-    @property
-    def prefix(self, /) -> LiteralString: ...
-    @property
-    def typecode(self, /) -> LiteralString: ...
-    def __call__(self, /, *args: object, **kwargs: object) -> Incomplete: ...
-
-_VT_co = TypeVar("_VT_co", covariant=True)
-
-# A slightly modified variant from https://github.com/python/typing/issues/256#issuecomment-1442633430
-# This works because `str.__contains__` does not accept object (either in typeshed or at runtime)
-@type_check_only
-class SequenceNotStr(Protocol[_VT_co]):
-    @overload
-    def __getitem__(self, index: SupportsIndex, /) -> _VT_co: ...
-    @overload
-    def __getitem__(self, index: slice, /) -> Sequence[_VT_co]: ...
-    def __iter__(self, /) -> Iterator[_VT_co]: ...
-    def __reversed__(self, /) -> Iterator[_VT_co]: ...
-    def __contains__(self, value: object, /) -> bool: ...  # <-- the trick
-    def __len__(self, /) -> int: ...
-    def index(self, value: object, start: int = 0, stop: int = ..., /) -> int: ...
-    def count(self, value: object, /) -> int: ...
-
-# I/O
-_ByteSOrStr = TypeVar("_ByteSOrStr", bytes, str)
-FileName: TypeAlias = str | PathLike[str]
-FileLike: TypeAlias = FileName | IO[_ByteSOrStr]
-FileModeRW: TypeAlias = Literal["r", "w"]
-FileModeRWA: TypeAlias = Literal[FileModeRW, "a"]
-
-# TODO(jorenham): Include `np.bool[L[False]]` once we have `numpy>=2.2`
-Falsy: TypeAlias = Literal[False, 0]
-Truthy: TypeAlias = Literal[True, 1]
-
-# keep in sync with `numpy._typing._scalars`
-AnyBool: TypeAlias = bool | np.bool_ | Literal[0, 1]
-
 # equivalent to `numpy._typing._shape._ShapeLike`
-AnyShape: TypeAlias = op.CanIndex | Sequence[op.CanIndex]
-
-RNG: TypeAlias = np.random.Generator | np.random.RandomState
-# NOTE: This is less incorrect and more accurate than the current `np.random.default_rng` `seed` param annotation.
-ToRNG: TypeAlias = (
-    int
-    | npc.integer
-    | np.timedelta64
-    | onp.ArrayND[npc.integer | np.timedelta64 | np.flexible | np.object_]
-    | np.random.SeedSequence
-    | np.random.BitGenerator
-    | RNG
-    | None
-)
-
-# numpy literals
-ByteOrder: TypeAlias = Literal["S", "<", "little", ">", "big", "=", "native", "|", "I"]
-OrderCF: TypeAlias = Literal["C", "F"]
-OrderKACF: TypeAlias = Literal["K", "A", OrderCF]
-Casting: TypeAlias = Literal["no", "equiv", "safe", "same_kind", "unsafe"]
-ConvMode: TypeAlias = Literal["valid", "same", "full"]
-
-# scipy literals
-NanPolicy: TypeAlias = Literal["raise", "propagate", "omit"]
-Alternative: TypeAlias = Literal["two-sided", "less", "greater"]
-NormalizationMode: TypeAlias = Literal["backward", "ortho", "forward"]
-DCTType: TypeAlias = Literal[1, 2, 3, 4]
+AnyShape: TypeAlias = SupportsIndex | Sequence[SupportsIndex]

scipy-stubs/cluster/hierarchy.pyi

@@ -9,7 +9,6 @@ import optype.numpy as onp
 import optype.numpy.compat as npc
 
 from scipy._lib._disjoint_set import DisjointSet
-from scipy._typing import Falsy, Truthy
 from scipy.spatial.distance import _Metric
 
 __all__ = [
@@ -133,9 +132,9 @@ def cut_tree(
 
 #
 @overload
-def to_tree(Z: onp.ToArray2D, rd: Falsy = False) -> ClusterNode: ...
+def to_tree(Z: onp.ToArray2D, rd: onp.ToFalse = False) -> ClusterNode: ...
 @overload
-def to_tree(Z: onp.ToArray2D, rd: Truthy) -> tuple[ClusterNode, list[ClusterNode]]: ...
+def to_tree(Z: onp.ToArray2D, rd: onp.ToTrue) -> tuple[ClusterNode, list[ClusterNode]]: ...
 
 #
 def optimal_leaf_ordering(Z: onp.ToArray2D, y: onp.ToArrayND, metric: _Metric = "euclidean") -> _LinkageArray: ...

scipy-stubs/fft/_realtransforms.pyi

@@ -5,7 +5,8 @@ import optype as op
 import optype.numpy as onp
 import optype.numpy.compat as npc
 
-from scipy._typing import AnyShape, DCTType, NormalizationMode
+from ._typing import DCTType, NormalizationMode
+from scipy._typing import AnyShape
 
 __all__ = ["dct", "dctn", "dst", "dstn", "idct", "idctn", "idst", "idstn"]
 
@@ -16,7 +17,6 @@ _ToIntOrND: TypeAlias = onp.ToInt | onp.ToIntND
 _FloatND: TypeAlias = onp.ArrayND[np.float32 | np.float64 | np.longdouble]  # doesn't include `numpy.float16`
 
 ###
-
 # NOTE: These have (almost) identical signatures, so be sure to keep them in sync.
 
 @overload

scipy-stubs/fft/_realtransforms_backend.pyi

@@ -6,7 +6,8 @@ import optype.numpy as onp
 import optype.numpy.compat as npc
 
 from ._realtransforms import dct, dctn, dst, dstn, idct, idst
-from scipy._typing import AnyShape, DCTType, NormalizationMode
+from ._typing import DCTType, NormalizationMode
+from scipy._typing import AnyShape
 
 __all__ = ["dct", "dctn", "dst", "dstn", "idct", "idctn", "idst", "idstn"]
 

scipy-stubs/fft/_typing.pyi

@@ -0,0 +1,8 @@
+# NOTE(scipy-stubs): This private module should not be used outside of scipy-stubs
+
+from typing import Literal, TypeAlias
+
+__all__ = "DCTType", "NormalizationMode"
+
+DCTType: TypeAlias = Literal[1, 2, 3, 4]
+NormalizationMode: TypeAlias = Literal["backward", "ortho", "forward"]