TypeIs for isinstance

[OutSquareCapital]

Apologies if I'm missing something obvious, but I checked issues and PR's and haven't seen this mentioned explicitly.

Could isinstance use TypeIs?

With multiples checks it could return an union, with one type T a TypeIs[T].

I often find myself writing one-liner helpers functions that just call isinstance, see this script for example:

https://github.com/OutSquareCapital/pyochain/blob/master/scripts/check_docstrings.py

This both add boilerplate and a performance tax due to a double function call overhead.

I'm very often using lambdas with fluent interfaces, e.g

res = (
my_iterator
.map(lambda x: ...)
.filter(lambda x: isinstance(x, int)
)

Assuming my_iterator is an Iterator[Any], it would be fantastic if it could be narrowed to Iterator[int] without having to define a separate TypeIs function.

[Andrew5057]

TypeIs wouldn't fix this problem; it occurs at the lambda definition, which doesn't retain the type-guarding properties of the wrapped function. Consider this demo (mypy):

from collections.abc import Iterator
from typing import TypeIs

def is_int(obj: object) -> TypeIs[int]:
    return isinstance(obj, int)

def int_filter(it: Iterator[object]) -> Iterator[int]:
    return filter(is_int, it)

def lambda_int_filter(it: Iterator[object]) -> Iterator[int]:
    return filter(lambda x: is_int(x), it)

The bare is_int gets inferred correctly, but the lambda-wrapped one doesn't.

[jonathandung]

You can use int.__instancecheck__ instead of the lambda, but that doesn't solve the problem.

[jonathandung]

Maybe that can be mitigated by typing type.__instancecheck__ in builtins.pyi as follows:

    def __instancecheck__(self: type[_T], instance: Any, /) -> TypeGuard[_T]: ...

Where _T is an already existing type variable.

[OutSquareCapital]

RE Andrew:

My fluent interface is typed to return an Iterator[T] if the provided closure return a TypeGuard[T]/TypeIs[T], which work perfectly fine with pyright.

I'm not sure about mypy but I think about it as a bad type checker, especially regarding generics and inference handling, thus I didn't consider it.

In any case this would reduce boilerplate.

For example TypeIs on isinstance could mean that I could replace a def statement with an inline functools::partial call.

[OutSquareCapital]

You can use int.__instancecheck__ instead of the lambda, but that doesn't solve the problem.

Mhmh I did not know about this dunder anyways so thank you for this!

[JelleZijlstra]

I would not recommend using dunders like __instancecheck__ directly.

I believe isinstance() can't be fully typed with TypeIs because it accepts nested tuples, but we can try having an overload returning TypeIs for simple cases. I'm not sure whether that will help you though as the function is necessarily special-cased by type checkers. You might be better off asking your type checker to add the features you need.

[OutSquareCapital]

Something like that (obviously adapted for python 3.10)?

I'm not sure how to do it with UnionType.

from __future__ import annotations

import types
from typing import Any, TypeIs, overload

type ClassInfo[T] = type[T] | types.UnionType | tuple[ClassInfo[Any], ...]  # pyright: ignore[reportExplicitAny]


@overload
def is_instance[T](obj: object, class_or_tuple: type[T], /) -> TypeIs[T]: ...
@overload
def is_instance[T](obj: object, class_or_tuple: tuple[type[T]], /) -> TypeIs[T]: ...
@overload
def is_instance[T, T1](
    obj: object, class_or_tuple: tuple[type[T], type[T1]], /
) -> TypeIs[T | T1]: ...
@overload
def is_instance[T, T1, T2](
    obj: object, class_or_tuple: tuple[type[T], type[T1], type[T2]], /
) -> TypeIs[T | T1 | T2]: ...
@overload
def is_instance[T, T1, T2, T3](
    obj: object, class_or_tuple: tuple[type[T], type[T1], type[T2], type[T3]], /
) -> TypeIs[T | T1 | T2 | T3]: ...
@overload
def is_instance[T, T1, T2, T3, T4](
    obj: object,
    class_or_tuple: tuple[type[T], type[T1], type[T2], type[T3], type[T4]],
    /,
) -> TypeIs[T | T1 | T2 | T3 | T4]: ...
def is_instance(obj: object, class_or_tuple: ClassInfo[Any], /) -> bool:  # pyright: ignore[reportExplicitAny]
    return isinstance(obj, class_or_tuple)

Inferred types with basedpyright:

Yes type checkers supports could indeed be a good idea.

But I'm convinced the lowest effort/benefit ratio could come from typeshed first for simple cases, whereas type checkers could handle more complex patterns (like union types)

EDIT:
Concretely this does solve my original problem, just not with UnionType:

EDIT 2:
And it does work in my concrete use case with my library, without me having touched anything in the method signature:

EDIT 3:

Fixed 2nd overload, good catch @jonathandung

[jonathandung]

I'm sure you meant tuple[type[T]] for the second overload

[jonathandung]

@OutSquareCapital I will adapt your snippet and make a draft PR to see the primer output. It is unnecessary, however, to make ClassInfo generic, since the only place you ever used ClassInfo had it subscripted with Any.

[jonathandung]

If no new errors emerge, it would mean the type checker is essentially already doing what this change does, which would be sufficient cause for me to close the PR, in which event this issue should be closed too.

[jonathandung]

The change apparently changes the error codes from arg-type to call-overload in some cases, and changing the suppression comments just for this may be considered churn.

[OutSquareCapital]

Well this mean it exposes issues in code which is a good thing.
To me not having type narrowing on the builtin function explicitly made for this is a bit hard to understand if the justification is a few type ignore comments on a notoriously bad type checker (from my understanding it's mypy who's used in mypy primer?)

[jonathandung]

Yes, mypy_primer has a number of repos declared that it will run mypy on. But I wouldn't say this exposes issues, because in the output, some of the diff resulted from a previous suppression comment for arg-type no longer applying (to call-overload).

[jonathandung]

Besides, the original behaviour of mypy is expected and touched on in the typing spec. This says TypeIs narrowing on positive and negative branches can be thought of as similar to the type checker's implementation of isinstance narrowing, which means it is understood that type checkers narrow on isinstance without the explicit TypeIs, to my best understanding.