Proper way to specialize generic class in classmethod?

[HarukaMa]

Continuation of #5449.

So basically, it seems the definition of "specialize" differs between the type checking and the runtime in class methods; while the class is declared specialized by the static type checkers, the cls param in the class method does not hold the type info in the runtime.

For example, the code:

class A(Generic[T]):
    @classmethod
    def m(cls) -> Self:
        return cls()

# The type of `cls` in this case is `A[int]`.
A[int].m()

# The type of `cls` in this case is `A[Unknown]`.
A.m()

The cls here doesn't have any accessible type info (got "erased") regardless of the way of calling the method, so the resulting instance of A has no type info associated with it as well. I know you would need to use library internal attributes to access them, but my code currently relies on the type info to work correctly.

Is it not possible to do this with static type checking right now or am I missing something obvious?

My current ugly workaround to avoid relying on impl. details, but should be irrelavent here

class TypedGenericAlias(GenericAlias):
    def __getattribute__(self, item: str):
        attr = super().__getattribute__(item)
        if isinstance(attr, MethodType):
            return partial(attr, types=get_args(self))
        return attr

    def __call__(self, *args: Any, **kwargs: Any):
        kwargs["types"] = get_args(self)
        return super().__call__(*args, **kwargs)

def access_generic_type(c: Any):

    def _tp_cache(func: Callable[..., Any], *, max_size: int | None = None):
        cache = lru_cache(max_size)(func)

        def wrapper(*args: Any, **kwargs: Any):
            try:
                return cache(*args, **kwargs)
            except TypeError:
                return func(*args, **kwargs)

        return wrapper

    # noinspection PyUnresolvedReferences
    def __class_getitem__(cls: Any, item: str):
        if not (hasattr(super(cls, cls), "__class_getitem__") and callable(super(cls, cls).__class_getitem__)): # type: ignore
            raise TypeError
        __generic_alias = super(cls, cls).__class_getitem__(item) # type: ignore
        args = get_args(__generic_alias)
        if not args:
            raise TypeError
        return TypedGenericAlias(cls, get_args(__generic_alias))

    def inject_types(f: Callable[..., Any]):
        def wrapper(self: Any, *args: Any, **kwargs: Any):
            if f is object.__new__:
                return f(self)
            if "types" in kwargs:
                types = kwargs.pop("types")
                self.types = types
            return f(self, *args, **kwargs)
        return wrapper

    c.__class_getitem__ = _tp_cache(__class_getitem__.__get__(c), max_size=1024)
    c.__new__ = inject_types(c.__new__)
    c.__init__ = inject_types(c.__init__)
    return c

[erictraut]

Specialization is a static type concept, not a runtime concept. Specializations are erased at runtime. Specialization information may be available at runtime in some cases if you happen to know the internals of how Python implements generics, but this won't match static typing in all cases. If your code is relying on this behavior, you're going to run into many problems beyond the issue with cls.

For example, if you instantiate the generic class A above with the statement a = A(), there will be no indication at runtime that the static type of a is A[Unknown] (or A[Any]). If you use the statement a = A[int](), then a.__class__ will still be A (since the int type argument is erased), but a.__orig_class__ will refer to a _GenericAlias that indicates that the original class was A[int].

Is it not possible to do this with static type checking right now or am I missing something obvious?

If I understand your goal correctly, you're trying to use the internal implementation machinery of generics to add runtime specialization information, effectively building _GenericAlias instances. Do I have that correct? That sounds very hacky to me.

[HarukaMa]

It indeed is very hacky, but now I'm using types.GenericAlias, not typing._GenericAlias. Considering subclassing GenericAlias is explicitly allowed, I'd guess I could hook it up to do more things and it won't fall into "implementation details" anymore?

EDIT: oops, should use the reply box above but accidentally created a new comment

[erictraut]

I can speak authoritatively when it comes to static typing, but I'm not an expert on runtime type checking or the internals of the Python runtime that were used to graft static types onto a previously-untyped language. @JelleZijlstra has significant expertise in this area, so he may be able to provide a better answer to your question.

[JelleZijlstra]

Your solution looks reasonably robust but type checkers aren't expected to understand code that sets __class_getitem__ explicitly.