Like so? Code sample in pyright playground

This does seem to work with pyright, mypy seems to bug out on any new call with K≠str. Also:

_m0 = Foo.new(bar=3)
reveal_type(_m0) # "Foo[str, Unknown]"

Any idea why it fails to bind V=int (or possibly V=Literal[3])?

Just to make sure that I get this right, when you say:

The types of class-scoped type variables are inferred from argument types only when you call *a constructor.* This doesn't work for other methods.

What exactly counts as *a constructor*? Only the standard constructor metaclass.__call__/__new__/__init__?

Well, actually, ... it does seem to produce the desired inference if we define new inside a custom metaclass. 🤓 Code sample in pyright playground

I guess this makes sense insofar as that if we were to access, say, some generic class-attributes inside .new, it wouldn't be clear what their types are inside the constructor itself.

So if we want full type-checking for a custom constructor, one either should use a function defined outside the class, a @staticmethod or a custom metaclass (if we need access to certain class-variables at construction time).

Learned something new today, thanks as always for your insights.

Though I have to say, having to define metaclasses makes this whole thing quite un-ergonomic. In fact, there seems to be another type-checker divergence here:

Code sample in pyright playground, https://mypy-play.net/?mypy=latest&python=3.13&gist=d902e42012932c4a8892c75c46d170d4

from typing import Self
class Vector[T]:
 @classmethod
 def from_list(cls, x: list[T]) -> Self: ...
# shows mypy: Vector[str], pyright: Vector[Unknown] 
reveal_type(Vector.from_list(["abc"]))

Would you consider mypy's inference in the example above a bug then?

Yes, Foo.new binds Foo[Any, Any] to the new method.

The typing specs IMO are silent rather than clear on this. The only examples of omitting generics I see are

• At the end of Generics: Introduction:

  def count_truthy(elements: list[Any]) -> int: 
   return sum(1 for elem in elements if elem) 

  This is equivalent to omitting the generic notation and just saying elements: list.

• Behavior when Type Parameters are not Specified

In both of these examples, the omission resulting in an implicit parameterisation by Any is in the context of an annotation expression, not a value expression. Foo.new, on the other hand, is a value expression, and we're not accessing .new as Foo[Any, Any].new; Foo is certainly not equivalent to the generic alias Foo[Any, Any] at runtime, and I think assuming this could lead to divergent behaviour between static and runtime type-checking.