Skip to content

spaghetti error reports in scipy-stubs #1219

Closed
Bug
Closed
spaghetti error reports in scipy-stubs#1219
Bug
Assignees
yangdanny97
Labels
staletypechecking

Description

@jorenham
jorenham
opened on Oct 1, 2025

For example:

ERROR Class member `_rv_continuous_0.stats` overrides parent class `rv_continuous` in an inconsistent manner [bad-override]
   --> scipy-stubs/stats/_distn_infrastructure.pyi:929:9
    |
929 |     def stats(self, /, loc: onp.ToFloat, scale: onp.ToFloat, moment: _Moment1) -> _Float: ...
    |         ^^^^^
    |
  `_rv_continuous_0.stats` has type `BoundMethod[_rv_continuous_0, Overload[(self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], scale: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], moment: Literal['k', 'm', 's', 'v']) -> float | float64, (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 0, scale: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 1, *, moment: Literal['k', 'm', 's', 'v']) -> float | float64, (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 0, scale: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 1, moment: Literal['km', 'ks', 'kv', 'mk', 'ms', 'mv', 'sk', 'sm', 'sv', 'vk', 'vm', 'vs'] = 'mv') -> tuple[float | float64, float | float64], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], scale: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], moment: Literal['kms', 'kmv', 'ksm', 'ksv', 'kvm', 'kvs', 'mks', 'mkv', 'msk', 'msv', 'mvk', 'mvs', 'skm', 'skv', 'smk', 'smv', 'svk', 'svm', 'vkm', 'vks', 'vmk', 'vms', 'vsk', 'vsm']) -> tuple[float | float64, float | float64, float | float64], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 0, scale: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 1, *, moment: Literal['kms', 'kmv', 'ksm', 'ksv', 'kvm', 'kvs', 'mks', 'mkv', 'msk', 'msv', 'mvk', 'mvs', 'skm', 'skv', 'smk', 'smv', 'svk', 'svm', 'vkm', 'vks', 'vmk', 'vms', 'vsk', 'vsm']) -> tuple[float | float64, float | float64, float | float64], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], scale: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], moment: Literal['kmsv', 'kmvs', 'ksmv', 'ksvm', 'kvms', 'kvsm', 'mksv', 'mkvs', 'mskv', 'msvk', 'mvks', 'mvsk', 'skmv', 'skvm', 'smkv', 'smvk', 'svkm', 'svmk', 'vkms', 'vksm', 'vmks', 'vmsk', 'vskm', 'vsmk']) -> tuple[float | float64, float | float64, float | float64, float | float64], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 0, scale: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 1, *, moment: Literal['kmsv', 'kmvs', 'ksmv', 'ksvm', 'kvms', 'kvsm', 'mksv', 'mkvs', 'mskv', 'msvk', 'mvks', 'mvsk', 'skmv', 'skvm', 'smkv', 'smvk', 'svkm', 'svmk', 'vkms', 'vksm', 'vmks', 'vmsk', 'vskm', 'vsmk']) -> tuple[float | float64, float | float64, float | float64, float | float64], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], moment: Literal['k', 'm', 's', 'v']) -> ndarray[tuple[Any, ...], dtype[float64]], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], moment: Literal['km', 'ks', 'kv', 'mk', 'ms', 'mv', 'sk', 'sm', 'sv', 'vk', 'vm', 'vs'] = 'mv') -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], moment: Literal['kms', 'kmv', 'ksm', 'ksv', 'kvm', 'kvs', 'mks', 'mkv', 'msk', 'msv', 'mvk', 'mvs', 'skm', 'skv', 'smk', 'smv', 'svk', 'svm', 'vkm', 'vks', 'vmk', 'vms', 'vsk', 'vsm']) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], moment: Literal['kmsv', 'kmvs', 'ksmv', 'ksvm', 'kvms', 'kvsm', 'mksv', 'mkvs', 'mskv', 'msvk', 'mvks', 'mvsk', 'skmv', 'skvm', 'smkv', 'smvk', 'svkm', 'svmk', 'vkms', 'vksm', 'vmks', 'vmsk', 'vskm', 'vsmk']) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 0, *, scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], moment: Literal['k', 'm', 's', 'v']) -> ndarray[tuple[Any, ...], dtype[float64]], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 0, *, scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], moment: Literal['km', 'ks', 'kv', 'mk', 'ms', 'mv', 'sk', 'sm', 'sv', 'vk', 'vm', 'vs'] = 'mv') -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 0, *, scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], moment: Literal['kms', 'kmv', 'ksm', 'ksv', 'kvm', 'kvs', 'mks', 'mkv', 'msk', 'msv', 'mvk', 'mvs', 'skm', 'skv', 'smk', 'smv', 'svk', 'svm', 'vkm', 'vks', 'vmk', 'vms', 'vsk', 'vsm']) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 0, *, scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], moment: Literal['kmsv', 'kmvs', 'ksmv', 'ksvm', 'kvms', 'kvsm', 'mksv', 'mkvs', 'mskv', 'msvk', 'mvks', 'mvsk', 'skmv', 'skvm', 'smkv', 'smvk', 'svkm', 'svmk', 'vkms', 'vksm', 'vmks', 'vmsk', 'vskm', 'vsmk']) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], moment: Literal['k', 'm', 's', 'v']) -> ndarray[tuple[Any, ...], dtype[float64]], (self: _rv_continuous_0, /, loc: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 1, *, moment: Literal['k', 'm', 's', 'v']) -> ndarray[tuple[Any, ...], dtype[float64]], (self: _rv_continuous_0, /, loc: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 1, moment: Literal['km', 'ks', 'kv', 'mk', 'ms', 'mv', 'sk', 'sm', 'sv', 'vk', 'vm', 'vs'] = 'mv') -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], moment: Literal['kms', 'kmv', 'ksm', 'ksv', 'kvm', 'kvs', 'mks', 'mkv', 'msk', 'msv', 'mvk', 'mvs', 'skm', 'skv', 'smk', 'smv', 'svk', 'svm', 'vkm', 'vks', 'vmk', 'vms', 'vsk', 'vsm']) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 1, *, moment: Literal['kms', 'kmv', 'ksm', 'ksv', 'kvm', 'kvs', 'mks', 'mkv', 'msk', 'msv', 'mvk', 'mvs', 'skm', 'skv', 'smk', 'smv', 'svk', 'svm', 'vkm', 'vks', 'vmk', 'vms', 'vsk', 'vsm']) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], moment: Literal['kmsv', 'kmvs', 'ksmv', 'ksvm', 'kvms', 'kvsm', 'mksv', 'mkvs', 'mskv', 'msvk', 'mvks', 'mvsk', 'skmv', 'skvm', 'smkv', 'smvk', 'svkm', 'svmk', 'vkms', 'vksm', 'vmks', 'vmsk', 'vskm', 'vsmk']) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 1, *, moment: Literal['kmsv', 'kmvs', 'ksmv', 'ksvm', 'kvms', 'kvsm', 'mksv', 'mkvs', 'mskv', 'msvk', 'mvks', 'mvsk', 'skmv', 'skvm', 'smkv', 'smvk', 'svkm', 'svmk', 'vkms', 'vksm', 'vmks', 'vmsk', 'vskm', 'vsmk']) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]]]]`, which is not assignable to `BoundMethod[_rv_continuous_0, Overload[(self: _rv_continuous_0, /, *args: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], *, moment: Literal['k', 'm', 's', 'v'], **kwds: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any]) -> float | float64, (self: _rv_continuous_0, /, *args: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], *, moment: Literal['km', 'ks', 'kv', 'mk', 'ms', 'mv', 'sk', 'sm', 'sv', 'vk', 'vm', 'vs'] = ..., **kwds: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any]) -> tuple[float | float64, float | float64], (self: _rv_continuous_0, /, *args: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], *, moment: Literal['kms', 'kmv', 'ksm', 'ksv', 'kvm', 'kvs', 'mks', 'mkv', 'msk', 'msv', 'mvk', 'mvs', 'skm', 'skv', 'smk', 'smv', 'svk', 'svm', 'vkm', 'vks', 'vmk', 'vms', 'vsk', 'vsm'], **kwds: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any]) -> tuple[float | float64, float | float64, float | float64], (self: _rv_continuous_0, /, *args: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], *, moment: Literal['kmsv', 'kmvs', 'ksmv', 'ksvm', 'kvms', 'kvsm', 'mksv', 'mkvs', 'mskv', 'msvk', 'mvks', 'mvsk', 'skmv', 'skvm', 'smkv', 'smvk', 'svkm', 'svmk', 'vkms', 'vksm', 'vmks', 'vmsk', 'vskm', 'vsmk'], **kwds: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any]) -> tuple[float | float64, float | float64, float | float64, float | float64], (self: _rv_continuous_0, /, *args: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], *, moment: Literal['k', 'm', 's', 'v'], **kwds: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any]) -> float | float64 | ndarray[tuple[Any, ...], dtype[float64]], (self: _rv_continuous_0, /, *args: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], *, moment: Literal['km', 'ks', 'kv', 'mk', 'ms', 'mv', 'sk', 'sm', 'sv', 'vk', 'vm', 'vs'] = ..., **kwds: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any]) -> tuple[float | float64 | ndarray[tuple[Any, ...], dtype[float64]], float | float64 | ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, *args: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], *, moment: Literal['kms', 'kmv', 'ksm', 'ksv', 'kvm', 'kvs', 'mks', 'mkv', 'msk', 'msv', 'mvk', 'mvs', 'skm', 'skv', 'smk', 'smv', 'svk', 'svm', 'vkm', 'vks', 'vmk', 'vms', 'vsk', 'vsm'], **kwds: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any]) -> tuple[float | float64 | ndarray[tuple[Any, ...], dtype[float64]], float | float64 | ndarray[tuple[Any, ...], dtype[float64]], float | float64 | ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, *args: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], *, moment: Literal['kmsv', 'kmvs', 'ksmv', 'ksvm', 'kvms', 'kvsm', 'mksv', 'mkvs', 'mskv', 'msvk', 'mvks', 'mvsk', 'skmv', 'skvm', 'smkv', 'smvk', 'svkm', 'svmk', 'vkms', 'vksm', 'vmks', 'vmsk', 'vskm', 'vsmk'], **kwds: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any]) -> tuple[float | float64 | ndarray[tuple[Any, ...], dtype[float64]], float | float64 | ndarray[tuple[Any, ...], dtype[float64]], float | float64 | ndarray[tuple[Any, ...], dtype[float64]], float | float64 | ndarray[tuple[Any, ...], dtype[float64]]]]]`, the type of `rv_continuous.stats`

which in "reality" looks like

    # overrides of rv_generic
    @overload  # loc: 0-d, scale: 0-d, moments: 1 (positional)
    def stats(self, /, loc: onp.ToFloat, scale: onp.ToFloat, moment: _Moment1) -> _Float: ...
    @overload  # loc: 0-d, scale: 0-d, moments: 1 (keyword)
    def stats(self, /, loc: onp.ToFloat = 0, scale: onp.ToFloat = 1, *, moment: _Moment1) -> _Float: ...
    @overload  # loc: 0-d, scale: 0-d, moments: 2 (default)
    def stats(self, /, loc: onp.ToFloat = 0, scale: onp.ToFloat = 1, moment: _Moment2 = "mv") -> _Tuple2[_Float]: ...
    @overload  # loc: 0-d, scale: 0-d, moments: 3 (positional)
    def stats(self, /, loc: onp.ToFloat, scale: onp.ToFloat, moment: _Moment3) -> _Tuple3[_Float]: ...
    @overload  # loc: 0-d, scale: 0-d, moments: 3 (keyword)
    def stats(self, /, loc: onp.ToFloat = 0, scale: onp.ToFloat = 1, *, moment: _Moment3) -> _Tuple3[_Float]: ...
    @overload  # loc: 0-d, scale: 0-d, moments: 4 (positional)
    def stats(self, /, loc: onp.ToFloat, scale: onp.ToFloat, moment: _Moment4) -> _Tuple4[_Float]: ...
    @overload  # loc: 0-d, scale: 0-d, moments: 4 (keyword)
    def stats(self, /, loc: onp.ToFloat = 0, scale: onp.ToFloat = 1, *, moment: _Moment4) -> _Tuple4[_Float]: ...

    #
    @overload  # loc: 0-d, scale: n-d (positional), moments: 1
    def stats(self, /, loc: onp.ToFloat, scale: onp.ToFloatND, moment: _Moment1) -> _FloatND: ...
    @overload  # loc: 0-d, scale: n-d (positional), moments: 2 (default)
    def stats(self, /, loc: onp.ToFloat, scale: onp.ToFloatND, moment: _Moment2 = "mv") -> _Tuple2[_FloatND]: ...
    @overload  # loc: 0-d, scale: n-d (positional), moments: 3
    def stats(self, /, loc: onp.ToFloat, scale: onp.ToFloatND, moment: _Moment3) -> _Tuple3[_FloatND]: ...
    @overload  # loc: 0-d, scale: n-d (positional), moments: 4
    def stats(self, /, loc: onp.ToFloat, scale: onp.ToFloatND, moment: _Moment4) -> _Tuple4[_FloatND]: ...

    #
    @overload  # loc: 0-d, scale: n-d (keyword), moments: 1
    def stats(self, /, loc: onp.ToFloat = 0, *, scale: onp.ToFloatND, moment: _Moment1) -> _FloatND: ...
    @overload  # loc: 0-d, scale: n-d (keyword), moments: 2 (default)
    def stats(self, /, loc: onp.ToFloat = 0, *, scale: onp.ToFloatND, moment: _Moment2 = "mv") -> _Tuple2[_FloatND]: ...
    @overload  # loc: 0-d, scale: n-d (keyword), moments: 3
    def stats(self, /, loc: onp.ToFloat = 0, *, scale: onp.ToFloatND, moment: _Moment3) -> _Tuple3[_FloatND]: ...
    @overload  # loc: 0-d, scale: n-d (keyword), moments: 4
    def stats(self, /, loc: onp.ToFloat = 0, *, scale: onp.ToFloatND, moment: _Moment4) -> _Tuple4[_FloatND]: ...

    #
    @overload  # loc: n-d, scale: ?-d, moments: 1 (positional)
    def stats(self, /, loc: onp.ToFloatND, scale: _ToFloatOrND, moment: _Moment1) -> _FloatND: ...
    @overload  # loc: n-d, scale: ?-d, moments: 1 (keyword)
    def stats(self, /, loc: onp.ToFloatND, scale: _ToFloatOrND = 1, *, moment: _Moment1) -> _FloatND: ...
    @overload  # loc: n-d, scale: ?-d, moments: 2 (default)
    def stats(self, /, loc: onp.ToFloatND, scale: _ToFloatOrND = 1, moment: _Moment2 = "mv") -> _Tuple2[_FloatND]: ...
    @overload  # loc: n-d, scale: ?-d, moments: 3 (positional)
    def stats(self, /, loc: onp.ToFloatND, scale: _ToFloatOrND, moment: _Moment3) -> _Tuple3[_FloatND]: ...
    @overload  # loc: n-d, scale: ?-d, moments: 3 (keyword)
    def stats(self, /, loc: onp.ToFloatND, scale: _ToFloatOrND = 1, *, moment: _Moment3) -> _Tuple3[_FloatND]: ...
    @overload  # loc: n-d, scale: ?-d, moments: 4 (positional)
    def stats(self, /, loc: onp.ToFloatND, scale: _ToFloatOrND, moment: _Moment4) -> _Tuple4[_FloatND]: ...
    @overload  # loc: n-d, scale: ?-d, moments: 4 (keyword)
    def stats(self, /, loc: onp.ToFloatND, scale: _ToFloatOrND = 1, *, moment: _Moment4) -> _Tuple4[_FloatND]: ...

https://github.com/scipy/scipy-stubs/blob/a9a9d611c907da0330569e224f0ce83b0fd93454/scipy-stubs/stats/_distn_infrastructure.pyi#L928-L941

This amount of overloads might look pretty ridiculous, but truth be told, methods like this one are pretty common in scipy-stubs (I try to keep in under 64 overloads though 😅).

Anyway, I think it would help a lot if pyrefly wouldn't "expand" the type-aliases, and just print their names.

Activity

  1. connernilsen commented on Oct 2, 2025

    @connernilsen
    connernilsen
    on Oct 2, 2025
    Contributor

    Thanks for reporting this @jorenham! Definitely an unreadable resolve type, though I'm not too sure about how that should be handled. Maybe try to match the closest overloads and show only those?

    Thoughts @stroxler, @yangdanny97, @rchen152?

  2. connernilsen
    added
    typechecking
    User
    on Oct 2, 2025
  3. connernilsen
    added the
    Bug
    issue type on Oct 2, 2025

  4. yangdanny97 commented on Oct 2, 2025

    @yangdanny97
    yangdanny97
    on Oct 2, 2025
    Collaborator

    if pyrefly wouldn't "expand" the type-aliases, and just print their names.

    This sounds like a good idea, we can expand them if the type we're printing is just that type alias, but if they're nested inside some other type I think we can print the name

    pyrefly/crates/pyrefly_types/src/types.rs

    Line 357 in 513c79b

    pub fn fmt_with_type<'a, D: Display + 'a>(

  5. yangdanny97
    self-assigned this
    on Oct 2, 2025
  6. meta-codesync
    added a commit that references this issue on Oct 2, 2025

    improve display for type aliases

    64a8155

  7. yangdanny97 commented on Oct 6, 2025

    @yangdanny97
    yangdanny97
    on Oct 6, 2025
    Collaborator

    The type alias printing improvements are included in v0.36.0 from today. When you get a chance to try it, please let me know how it is and what else we can improve on!

  8. jorenham commented on Oct 7, 2025

    @jorenham
    jorenham
    on Oct 7, 2025
    CollaboratorAuthor

    The same error is now reported as follows

    ERROR Class member `_rv_continuous_0.stats` overrides parent class `rv_continuous` in an inconsistent manner [bad-override]
   --> scipy-stubs/stats/_distn_infrastructure.pyi:929:9
    |
929 |     def stats(self, /, loc: onp.ToFloat, scale: onp.ToFloat, moment: _Moment1) -> _Float: ...
    |         ^^^^^
    |
  `_rv_continuous_0.stats` has type `BoundMethod[_rv_continuous_0, Overload[(self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], scale: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], moment: Literal['k', 'm', 's', 'v']) -> float | float64, (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 0, scale: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 1, *, moment: Literal['k', 'm', 's', 'v']) -> float | float64, (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 0, scale: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 1, moment: Literal['km', 'ks', 'kv', 'mk', 'ms', 'mv', 'sk', 'sm', 'sv', 'vk', 'vm', 'vs'] = 'mv') -> tuple[float | float64, float | float64], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], scale: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], moment: Literal['kms', 'kmv', 'ksm', 'ksv', 'kvm', 'kvs', 'mks', 'mkv', 'msk', 'msv', 'mvk', 'mvs', 'skm', 'skv', 'smk', 'smv', 'svk', 'svm', 'vkm', 'vks', 'vmk', 'vms', 'vsk', 'vsm']) -> tuple[float | float64, float | float64, float | float64], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 0, scale: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 1, *, moment: Literal['kms', 'kmv', 'ksm', 'ksv', 'kvm', 'kvs', 'mks', 'mkv', 'msk', 'msv', 'mvk', 'mvs', 'skm', 'skv', 'smk', 'smv', 'svk', 'svm', 'vkm', 'vks', 'vmk', 'vms', 'vsk', 'vsm']) -> tuple[float | float64, float | float64, float | float64], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], scale: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], moment: Literal['kmsv', 'kmvs', 'ksmv', 'ksvm', 'kvms', 'kvsm', 'mksv', 'mkvs', 'mskv', 'msvk', 'mvks', 'mvsk', 'skmv', 'skvm', 'smkv', 'smvk', 'svkm', 'svmk', 'vkms', 'vksm', 'vmks', 'vmsk', 'vskm', 'vsmk']) -> tuple[float | float64, float | float64, float | float64, float | float64], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 0, scale: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 1, *, moment: Literal['kmsv', 'kmvs', 'ksmv', 'ksvm', 'kvms', 'kvsm', 'mksv', 'mkvs', 'mskv', 'msvk', 'mvks', 'mvsk', 'skmv', 'skvm', 'smkv', 'smvk', 'svkm', 'svmk', 'vkms', 'vksm', 'vmks', 'vmsk', 'vskm', 'vsmk']) -> tuple[float | float64, float | float64, float | float64, float | float64], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], moment: Literal['k', 'm', 's', 'v']) -> ndarray[tuple[Any, ...], dtype[float64]], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], moment: Literal['km', 'ks', 'kv', 'mk', 'ms', 'mv', 'sk', 'sm', 'sv', 'vk', 'vm', 'vs'] = 'mv') -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], moment: Literal['kms', 'kmv', 'ksm', 'ksv', 'kvm', 'kvs', 'mks', 'mkv', 'msk', 'msv', 'mvk', 'mvs', 'skm', 'skv', 'smk', 'smv', 'svk', 'svm', 'vkm', 'vks', 'vmk', 'vms', 'vsk', 'vsm']) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], moment: Literal['kmsv', 'kmvs', 'ksmv', 'ksvm', 'kvms', 'kvsm', 'mksv', 'mkvs', 'mskv', 'msvk', 'mvks', 'mvsk', 'skmv', 'skvm', 'smkv', 'smvk', 'svkm', 'svmk', 'vkms', 'vksm', 'vmks', 'vmsk', 'vskm', 'vsmk']) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 0, *, scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], moment: Literal['k', 'm', 's', 'v']) -> ndarray[tuple[Any, ...], dtype[float64]], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 0, *, scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], moment: Literal['km', 'ks', 'kv', 'mk', 'ms', 'mv', 'sk', 'sm', 'sv', 'vk', 'vm', 'vs'] = 'mv') -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 0, *, scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], moment: Literal['kms', 'kmv', 'ksm', 'ksv', 'kvm', 'kvs', 'mks', 'mkv', 'msk', 'msv', 'mvk', 'mvs', 'skm', 'skv', 'smk', 'smv', 'svk', 'svm', 'vkm', 'vks', 'vmk', 'vms', 'vsk', 'vsm']) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 0, *, scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], moment: Literal['kmsv', 'kmvs', 'ksmv', 'ksvm', 'kvms', 'kvsm', 'mksv', 'mkvs', 'mskv', 'msvk', 'mvks', 'mvsk', 'skmv', 'skvm', 'smkv', 'smvk', 'svkm', 'svmk', 'vkms', 'vksm', 'vmks', 'vmsk', 'vskm', 'vsmk']) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], moment: Literal['k', 'm', 's', 'v']) -> ndarray[tuple[Any, ...], dtype[float64]], (self: _rv_continuous_0, /, loc: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 1, *, moment: Literal['k', 'm', 's', 'v']) -> ndarray[tuple[Any, ...], dtype[float64]], (self: _rv_continuous_0, /, loc: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 1, moment: Literal['km', 'ks', 'kv', 'mk', 'ms', 'mv', 'sk', 'sm', 'sv', 'vk', 'vm', 'vs'] = 'mv') -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], moment: Literal['kms', 'kmv', 'ksm', 'ksv', 'kvm', 'kvs', 'mks', 'mkv', 'msk', 'msv', 'mvk', 'mvs', 'skm', 'skv', 'smk', 'smv', 'svk', 'svm', 'vkm', 'vks', 'vmk', 'vms', 'vsk', 'vsm']) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 1, *, moment: Literal['kms', 'kmv', 'ksm', 'ksv', 'kvm', 'kvs', 'mks', 'mkv', 'msk', 'msv', 'mvk', 'mvs', 'skm', 'skv', 'smk', 'smv', 'svk', 'svm', 'vkm', 'vks', 'vmk', 'vms', 'vsk', 'vsm']) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], moment: Literal['kmsv', 'kmvs', 'ksmv', 'ksvm', 'kvms', 'kvsm', 'mksv', 'mkvs', 'mskv', 'msvk', 'mvks', 'mvsk', 'skmv', 'skvm', 'smkv', 'smvk', 'svkm', 'svmk', 'vkms', 'vksm', 'vmks', 'vmsk', 'vskm', 'vsmk']) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 1, *, moment: Literal['kmsv', 'kmvs', 'ksmv', 'ksvm', 'kvms', 'kvsm', 'mksv', 'mkvs', 'mskv', 'msvk', 'mvks', 'mvsk', 'skmv', 'skvm', 'smkv', 'smvk', 'svkm', 'svmk', 'vkms', 'vksm', 'vmks', 'vmsk', 'vskm', 'vsmk']) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]]]]`, which is not assignable to `BoundMethod[_rv_continuous_0, Overload[(self: _rv_continuous_0, /, *args: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], *, moment: Literal['k', 'm', 's', 'v'], **kwds: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any]) -> float | float64, (self: _rv_continuous_0, /, *args: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], *, moment: Literal['km', 'ks', 'kv', 'mk', 'ms', 'mv', 'sk', 'sm', 'sv', 'vk', 'vm', 'vs'] = ..., **kwds: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any]) -> tuple[float | float64, float | float64], (self: _rv_continuous_0, /, *args: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], *, moment: Literal['kms', 'kmv', 'ksm', 'ksv', 'kvm', 'kvs', 'mks', 'mkv', 'msk', 'msv', 'mvk', 'mvs', 'skm', 'skv', 'smk', 'smv', 'svk', 'svm', 'vkm', 'vks', 'vmk', 'vms', 'vsk', 'vsm'], **kwds: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any]) -> tuple[float | float64, float | float64, float | float64], (self: _rv_continuous_0, /, *args: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], *, moment: Literal['kmsv', 'kmvs', 'ksmv', 'ksvm', 'kvms', 'kvsm', 'mksv', 'mkvs', 'mskv', 'msvk', 'mvks', 'mvsk', 'skmv', 'skvm', 'smkv', 'smvk', 'svkm', 'svmk', 'vkms', 'vksm', 'vmks', 'vmsk', 'vskm', 'vsmk'], **kwds: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any]) -> tuple[float | float64, float | float64, float | float64, float | float64], (self: _rv_continuous_0, /, *args: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], *, moment: Literal['k', 'm', 's', 'v'], **kwds: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any]) -> float | float64 | ndarray[tuple[Any, ...], dtype[float64]], (self: _rv_continuous_0, /, *args: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], *, moment: Literal['km', 'ks', 'kv', 'mk', 'ms', 'mv', 'sk', 'sm', 'sv', 'vk', 'vm', 'vs'] = ..., **kwds: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any]) -> tuple[float | float64 | ndarray[tuple[Any, ...], dtype[float64]], float | float64 | ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, *args: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], *, moment: Literal['kms', 'kmv', 'ksm', 'ksv', 'kvm', 'kvs', 'mks', 'mkv', 'msk', 'msv', 'mvk', 'mvs', 'skm', 'skv', 'smk', 'smv', 'svk', 'svm', 'vkm', 'vks', 'vmk', 'vms', 'vsk', 'vsm'], **kwds: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any]) -> tuple[float | float64 | ndarray[tuple[Any, ...], dtype[float64]], float | float64 | ndarray[tuple[Any, ...], dtype[float64]], float | float64 | ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, *args: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], *, moment: Literal['kmsv', 'kmvs', 'ksmv', 'ksvm', 'kvms', 'kvsm', 'mksv', 'mkvs', 'mskv', 'msvk', 'mvks', 'mvsk', 'skmv', 'skvm', 'smkv', 'smvk', 'svkm', 'svmk', 'vkms', 'vksm', 'vmks', 'vmsk', 'vskm', 'vsmk'], **kwds: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any]) -> tuple[float | float64 | ndarray[tuple[Any, ...], dtype[float64]], float | float64 | ndarray[tuple[Any, ...], dtype[float64]], float | float64 | ndarray[tuple[Any, ...], dtype[float64]], float | float64 | ndarray[tuple[Any, ...], dtype[float64]]]]]`, the type of `rv_continuous.stats`

    I don't think there's a difference. (I double checked that this is indeed pyrefly 0.36.1.)

    I've created a demo-PR so you can see for yourself: scipy/scipy-stubs#921

  9. yangdanny97 commented on Oct 7, 2025

    @yangdanny97
    yangdanny97
    on Oct 7, 2025
    Collaborator

    Hum, maybe the type alias gets expanded before we get to that point. Will investigate further, sorry about that!

  10. jorenham commented on Oct 8, 2025

    @jorenham
    jorenham
    on Oct 8, 2025
    CollaboratorAuthor

    Hum, maybe the type alias gets expanded before we get to that point. Will investigate further, sorry about that!

    Haha no worries; I'm glad that you're working on it, and don't mind helping :)

  11. meta-codesync
    added a commit that references this issue on Oct 15, 2025

    add test case showing incorrect type alias expansion

    05ba204
  12. yangdanny97
    added a parent issue on Oct 27, 2025

  13. github-actions commented on Oct 29, 2025

    @github-actions
    github-actionsBot
    on Oct 29, 2025 – with GitHub Actions

    This issue has someone assigned, but has not had recent activity for more than 2 weeks.

    If you are still working on this issue, please add a comment so everyone knows. Otherwise, please unassign yourself and allow someone else to take over.

    Thank you for your contributions!

  14. github-actions
    added
    stale
    on Oct 29, 2025

  15. 15 remaining items

  16. yangdanny97
    added 2 commits that reference this issue on Nov 25, 2025

    add optional display name to Type::Union

    7605a26

    add optional display name to Type::Union

    a201444
  17. meta-codesync
    added a commit that references this issue on Nov 25, 2025

    add optional display name to Type::Union

    4fdc6e5
  18. Karman-singh15
    added a commit that references this issue on Nov 27, 2025

    add optional display name to Type::Union

    935f9bc

  19. yangdanny97 commented on Dec 3, 2025

    @yangdanny97
    yangdanny97
    on Dec 3, 2025
    Collaborator

    The latest release should have the union type alias display changes - let me know if that makes things a bit more readable for you!

  20. jorenham commented on Dec 3, 2025

    @jorenham
    jorenham
    on Dec 3, 2025
    CollaboratorAuthor

    Before, the error message was 16,276 characters wide. Now, that's 4,932 — so it shrunk by a factor of 3.3 🎉.

    For comparison, here's the before & after:

    ERROR Class member `_rv_continuous_0.stats` overrides parent class `rv_continuous` in an inconsistent manner [bad-override]
   --> scipy-stubs/stats/_distn_infrastructure.pyi:929:9
    |
929 |     def stats(self, /, loc: onp.ToFloat, scale: onp.ToFloat, moment: _Moment1) -> _Float: ...
    |         ^^^^^
    |
  `_rv_continuous_0.stats` has type `BoundMethod[_rv_continuous_0, Overload[(self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], scale: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], moment: Literal['k', 'm', 's', 'v']) -> float | float64, (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 0, scale: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 1, *, moment: Literal['k', 'm', 's', 'v']) -> float | float64, (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 0, scale: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 1, moment: Literal['km', 'ks', 'kv', 'mk', 'ms', 'mv', 'sk', 'sm', 'sv', 'vk', 'vm', 'vs'] = 'mv') -> tuple[float | float64, float | float64], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], scale: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], moment: Literal['kms', 'kmv', 'ksm', 'ksv', 'kvm', 'kvs', 'mks', 'mkv', 'msk', 'msv', 'mvk', 'mvs', 'skm', 'skv', 'smk', 'smv', 'svk', 'svm', 'vkm', 'vks', 'vmk', 'vms', 'vsk', 'vsm']) -> tuple[float | float64, float | float64, float | float64], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 0, scale: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 1, *, moment: Literal['kms', 'kmv', 'ksm', 'ksv', 'kvm', 'kvs', 'mks', 'mkv', 'msk', 'msv', 'mvk', 'mvs', 'skm', 'skv', 'smk', 'smv', 'svk', 'svm', 'vkm', 'vks', 'vmk', 'vms', 'vsk', 'vsm']) -> tuple[float | float64, float | float64, float | float64], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], scale: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], moment: Literal['kmsv', 'kmvs', 'ksmv', 'ksvm', 'kvms', 'kvsm', 'mksv', 'mkvs', 'mskv', 'msvk', 'mvks', 'mvsk', 'skmv', 'skvm', 'smkv', 'smvk', 'svkm', 'svmk', 'vkms', 'vksm', 'vmks', 'vmsk', 'vskm', 'vsmk']) -> tuple[float | float64, float | float64, float | float64, float | float64], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 0, scale: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 1, *, moment: Literal['kmsv', 'kmvs', 'ksmv', 'ksvm', 'kvms', 'kvsm', 'mksv', 'mkvs', 'mskv', 'msvk', 'mvks', 'mvsk', 'skmv', 'skvm', 'smkv', 'smvk', 'svkm', 'svmk', 'vkms', 'vksm', 'vmks', 'vmsk', 'vskm', 'vsmk']) -> tuple[float | float64, float | float64, float | float64, float | float64], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], moment: Literal['k', 'm', 's', 'v']) -> ndarray[tuple[Any, ...], dtype[float64]], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], moment: Literal['km', 'ks', 'kv', 'mk', 'ms', 'mv', 'sk', 'sm', 'sv', 'vk', 'vm', 'vs'] = 'mv') -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], moment: Literal['kms', 'kmv', 'ksm', 'ksv', 'kvm', 'kvs', 'mks', 'mkv', 'msk', 'msv', 'mvk', 'mvs', 'skm', 'skv', 'smk', 'smv', 'svk', 'svm', 'vkm', 'vks', 'vmk', 'vms', 'vsk', 'vsm']) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], moment: Literal['kmsv', 'kmvs', 'ksmv', 'ksvm', 'kvms', 'kvsm', 'mksv', 'mkvs', 'mskv', 'msvk', 'mvks', 'mvsk', 'skmv', 'skvm', 'smkv', 'smvk', 'svkm', 'svmk', 'vkms', 'vksm', 'vmks', 'vmsk', 'vskm', 'vsmk']) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 0, *, scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], moment: Literal['k', 'm', 's', 'v']) -> ndarray[tuple[Any, ...], dtype[float64]], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 0, *, scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], moment: Literal['km', 'ks', 'kv', 'mk', 'ms', 'mv', 'sk', 'sm', 'sv', 'vk', 'vm', 'vs'] = 'mv') -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 0, *, scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], moment: Literal['kms', 'kmv', 'ksm', 'ksv', 'kvm', 'kvs', 'mks', 'mkv', 'msk', 'msv', 'mvk', 'mvs', 'skm', 'skv', 'smk', 'smv', 'svk', 'svm', 'vkm', 'vks', 'vmk', 'vms', 'vsk', 'vsm']) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 0, *, scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], moment: Literal['kmsv', 'kmvs', 'ksmv', 'ksvm', 'kvms', 'kvsm', 'mksv', 'mkvs', 'mskv', 'msvk', 'mvks', 'mvsk', 'skmv', 'skvm', 'smkv', 'smvk', 'svkm', 'svmk', 'vkms', 'vksm', 'vmks', 'vmsk', 'vskm', 'vsmk']) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], moment: Literal['k', 'm', 's', 'v']) -> ndarray[tuple[Any, ...], dtype[float64]], (self: _rv_continuous_0, /, loc: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 1, *, moment: Literal['k', 'm', 's', 'v']) -> ndarray[tuple[Any, ...], dtype[float64]], (self: _rv_continuous_0, /, loc: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 1, moment: Literal['km', 'ks', 'kv', 'mk', 'ms', 'mv', 'sk', 'sm', 'sv', 'vk', 'vm', 'vs'] = 'mv') -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], moment: Literal['kms', 'kmv', 'ksm', 'ksv', 'kvm', 'kvs', 'mks', 'mkv', 'msk', 'msv', 'mvk', 'mvs', 'skm', 'skv', 'smk', 'smv', 'svk', 'svm', 'vkm', 'vks', 'vmk', 'vms', 'vsk', 'vsm']) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 1, *, moment: Literal['kms', 'kmv', 'ksm', 'ksv', 'kvm', 'kvs', 'mks', 'mkv', 'msk', 'msv', 'mvk', 'mvs', 'skm', 'skv', 'smk', 'smv', 'svk', 'svm', 'vkm', 'vks', 'vmk', 'vms', 'vsk', 'vsm']) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], moment: Literal['kmsv', 'kmvs', 'ksmv', 'ksvm', 'kvms', 'kvsm', 'mksv', 'mkvs', 'mskv', 'msvk', 'mvks', 'mvsk', 'skmv', 'skvm', 'smkv', 'smvk', 'svkm', 'svmk', 'vkms', 'vksm', 'vmks', 'vmsk', 'vskm', 'vsmk']) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]], scale: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any] = 1, *, moment: Literal['kmsv', 'kmvs', 'ksmv', 'ksvm', 'kvms', 'kvsm', 'mksv', 'mkvs', 'mskv', 'msvk', 'mvks', 'mvsk', 'skmv', 'skvm', 'smkv', 'smvk', 'svkm', 'svmk', 'vkms', 'vksm', 'vmks', 'vmsk', 'vskm', 'vsmk']) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]]]]`, which is not assignable to `BoundMethod[_rv_continuous_0, Overload[(self: _rv_continuous_0, /, *args: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], *, moment: Literal['k', 'm', 's', 'v'], **kwds: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any]) -> float | float64, (self: _rv_continuous_0, /, *args: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], *, moment: Literal['km', 'ks', 'kv', 'mk', 'ms', 'mv', 'sk', 'sm', 'sv', 'vk', 'vm', 'vs'] = ..., **kwds: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any]) -> tuple[float | float64, float | float64], (self: _rv_continuous_0, /, *args: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], *, moment: Literal['kms', 'kmv', 'ksm', 'ksv', 'kvm', 'kvs', 'mks', 'mkv', 'msk', 'msv', 'mvk', 'mvs', 'skm', 'skv', 'smk', 'smv', 'svk', 'svm', 'vkm', 'vks', 'vmk', 'vms', 'vsk', 'vsm'], **kwds: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any]) -> tuple[float | float64, float | float64, float | float64], (self: _rv_continuous_0, /, *args: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], *, moment: Literal['kmsv', 'kmvs', 'ksmv', 'ksvm', 'kvms', 'kvsm', 'mksv', 'mkvs', 'mskv', 'msvk', 'mvks', 'mvsk', 'skmv', 'skvm', 'smkv', 'smvk', 'svkm', 'svmk', 'vkms', 'vksm', 'vmks', 'vmsk', 'vskm', 'vsmk'], **kwds: numpy.bool[builtins.bool] | float | floating[Any] | integer[Any]) -> tuple[float | float64, float | float64, float | float64, float | float64], (self: _rv_continuous_0, /, *args: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], *, moment: Literal['k', 'm', 's', 'v'], **kwds: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any]) -> float | float64 | ndarray[tuple[Any, ...], dtype[float64]], (self: _rv_continuous_0, /, *args: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], *, moment: Literal['km', 'ks', 'kv', 'mk', 'ms', 'mv', 'sk', 'sm', 'sv', 'vk', 'vm', 'vs'] = ..., **kwds: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any]) -> tuple[float | float64 | ndarray[tuple[Any, ...], dtype[float64]], float | float64 | ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, *args: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], *, moment: Literal['kms', 'kmv', 'ksm', 'ksv', 'kvm', 'kvs', 'mks', 'mkv', 'msk', 'msv', 'mvk', 'mvs', 'skm', 'skv', 'smk', 'smv', 'svk', 'svm', 'vkm', 'vks', 'vmk', 'vms', 'vsk', 'vsm'], **kwds: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any]) -> tuple[float | float64 | ndarray[tuple[Any, ...], dtype[float64]], float | float64 | ndarray[tuple[Any, ...], dtype[float64]], float | float64 | ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, *args: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any], *, moment: Literal['kmsv', 'kmvs', 'ksmv', 'ksvm', 'kvms', 'kvsm', 'mksv', 'mkvs', 'mskv', 'msvk', 'mvks', 'mvsk', 'skmv', 'skvm', 'smkv', 'smvk', 'svkm', 'svmk', 'vkms', 'vksm', 'vmks', 'vmsk', 'vskm', 'vsmk'], **kwds: SequenceND[_CanArray[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | float] | _CanArrayND[numpy.bool[builtins.bool] | floating[Any] | integer[Any]] | numpy.bool[builtins.bool] | float | floating[Any] | integer[Any]) -> tuple[float | float64 | ndarray[tuple[Any, ...], dtype[float64]], float | float64 | ndarray[tuple[Any, ...], dtype[float64]], float | float64 | ndarray[tuple[Any, ...], dtype[float64]], float | float64 | ndarray[tuple[Any, ...], dtype[float64]]]]]`, the type of `rv_continuous.stats`

    ERROR Class member `_rv_continuous_0.stats` overrides parent class `rv_continuous` in an inconsistent manner [bad-override]
   --> scipy-stubs/stats/_distn_infrastructure.pyi:929:9
    |
929 |     def stats(self, /, loc: onp.ToFloat, scale: onp.ToFloat, moment: _Moment1) -> _Float: ...
    |         ^^^^^
    |
  `_rv_continuous_0.stats` has type `BoundMethod[_rv_continuous_0, Overload[(self: _rv_continuous_0, /, loc: ToFloat, scale: ToFloat, moment: _Moment1) -> _Float, (self: _rv_continuous_0, /, loc: ToFloat = 0, scale: ToFloat = 1, *, moment: _Moment1) -> _Float, (self: _rv_continuous_0, /, loc: ToFloat = 0, scale: ToFloat = 1, moment: _Moment2 = 'mv') -> tuple[_Float, _Float], (self: _rv_continuous_0, /, loc: ToFloat, scale: ToFloat, moment: _Moment3) -> tuple[_Float, _Float, _Float], (self: _rv_continuous_0, /, loc: ToFloat = 0, scale: ToFloat = 1, *, moment: _Moment3) -> tuple[_Float, _Float, _Float], (self: _rv_continuous_0, /, loc: ToFloat, scale: ToFloat, moment: _Moment4) -> tuple[_Float, _Float, _Float, _Float], (self: _rv_continuous_0, /, loc: ToFloat = 0, scale: ToFloat = 1, *, moment: _Moment4) -> tuple[_Float, _Float, _Float, _Float], (self: _rv_continuous_0, /, loc: ToFloat, scale: ToFloatND, moment: _Moment1) -> ndarray[tuple[Any, ...], dtype[float64]], (self: _rv_continuous_0, /, loc: ToFloat, scale: ToFloatND, moment: _Moment2 = 'mv') -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: ToFloat, scale: ToFloatND, moment: _Moment3) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: ToFloat, scale: ToFloatND, moment: _Moment4) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: ToFloat = 0, *, scale: ToFloatND, moment: _Moment1) -> ndarray[tuple[Any, ...], dtype[float64]], (self: _rv_continuous_0, /, loc: ToFloat = 0, *, scale: ToFloatND, moment: _Moment2 = 'mv') -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: ToFloat = 0, *, scale: ToFloatND, moment: _Moment3) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: ToFloat = 0, *, scale: ToFloatND, moment: _Moment4) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: ToFloatND, scale: _ToFloatOrND, moment: _Moment1) -> ndarray[tuple[Any, ...], dtype[float64]], (self: _rv_continuous_0, /, loc: ToFloatND, scale: _ToFloatOrND = 1, *, moment: _Moment1) -> ndarray[tuple[Any, ...], dtype[float64]], (self: _rv_continuous_0, /, loc: ToFloatND, scale: _ToFloatOrND = 1, moment: _Moment2 = 'mv') -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: ToFloatND, scale: _ToFloatOrND, moment: _Moment3) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: ToFloatND, scale: _ToFloatOrND = 1, *, moment: _Moment3) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: ToFloatND, scale: _ToFloatOrND, moment: _Moment4) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]], (self: _rv_continuous_0, /, loc: ToFloatND, scale: _ToFloatOrND = 1, *, moment: _Moment4) -> tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]]]]`, which is not assignable to `BoundMethod[_rv_continuous_0, Overload[(self: _rv_continuous_0, /, *args: ToFloat, *, moment: _Moment1, **kwds: ToFloat) -> _Float, (self: _rv_continuous_0, /, *args: ToFloat, *, moment: _Moment2 = ..., **kwds: ToFloat) -> tuple[_Float, _Float], (self: _rv_continuous_0, /, *args: ToFloat, *, moment: _Moment3, **kwds: ToFloat) -> tuple[_Float, _Float, _Float], (self: _rv_continuous_0, /, *args: ToFloat, *, moment: _Moment4, **kwds: ToFloat) -> tuple[_Float, _Float, _Float, _Float], (self: _rv_continuous_0, /, *args: _ToFloatOrND, *, moment: _Moment1, **kwds: _ToFloatOrND) -> _FloatOrND, (self: _rv_continuous_0, /, *args: _ToFloatOrND, *, moment: _Moment2 = ..., **kwds: _ToFloatOrND) -> tuple[_FloatOrND, _FloatOrND], (self: _rv_continuous_0, /, *args: _ToFloatOrND, *, moment: _Moment3, **kwds: _ToFloatOrND) -> tuple[_FloatOrND, _FloatOrND, _FloatOrND], (self: _rv_continuous_0, /, *args: _ToFloatOrND, *, moment: _Moment4, **kwds: _ToFloatOrND) -> tuple[_FloatOrND, _FloatOrND, _FloatOrND, _FloatOrND]]]`, the type of `rv_continuous.stats`

    Unless I'm mistaken, this is more readable/concise than either of the three other static type-checkers are able to report it as 👌.

    It's still a lot to digest, but I wouldn't know how to decrease the length any further than this.
    What might help for readability, is formatting it so that the individual overloads are printed on separate lines. Is something like that within the realm of feasibility?

  21. yangdanny97 commented on Dec 3, 2025

    @yangdanny97
    yangdanny97
    on Dec 3, 2025
    Collaborator

    Re: overloads on separate lines, #1447 attempts to do this, tho I see @rchen152 had some concerns w/ that change.

    There's also something else I was thinking about, which is replacing common prefixes/suffixes in the parameter list with ... when printing, to better highlight the mismatch. I'm not sure how big of a difference it would make in practice, but worth a try.

  22. rchen152 commented on Dec 4, 2025

    @rchen152
    rchen152
    on Dec 4, 2025
    Contributor

    @yangdanny97 That PR is for something different; it re-formats no-matching-overload by taking every overload (which is already on its own line) and further splitting them up to one-parameter-per-line.

    If I understand correctly, the request here is to print BoundMethod[foo, Overload[(...) -> _Float, (...) -> _Float, ...]] with one overload per line, which I have no objections to.

  23. jorenham commented on Dec 4, 2025

    @jorenham
    jorenham
    on Dec 4, 2025
    CollaboratorAuthor

    If I understand correctly, the request here is to print BoundMethod[foo, Overload[(...) -> _Float, (...) -> _Float, ...]] with one overload per line

    that's right

  24. github-actions commented on Dec 19, 2025

    @github-actions
    github-actionsBot
    on Dec 19, 2025 – with GitHub Actions

    This issue has someone assigned, but has not had recent activity for more than 2 weeks.

    If you are still working on this issue, please add a comment so everyone knows. Otherwise, please unassign yourself and allow someone else to take over.

    Thank you for your contributions!

  25. github-actions
    added
    stale
    on Dec 19, 2025
  26. meta-codesync
    added a commit that references this issue on Jan 6, 2026

    display overloads & bound method overloads on multiple lines if it's …

    7c62516
  27. yangdanny97
    removed
    user
    on Jan 13, 2026

  28. rchen152 commented on Jan 14, 2026

    @rchen152
    rchen152
    on Jan 14, 2026
    Contributor

    I think this is fixed? The last open item was to put each overload on its own line, which was done in 7c62516.

  29. rchen152
    closed this as completedon Jan 14, 2026
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Assignees

Labels

staletypechecking

Type

Bug

Projects

No projects

    Milestone

    No milestone

    Relationships

    None yet

    Development

    No branches or pull requests

    Issue actions