Propagate a generic type hint starting at the base class

[Ricyteach]

(Typing not-quite-novice, but possibly intermediate, here.; cross-post from SO.)

I know that I can have a generic parent class and child class, like this:

from typing import Generic, TypeVar


T = TypeVar('T')


class Parent(Generic[T]):
    member_x: T


class Child1(Parent[T]):
    pass

Now let's say I have many child classes, Child2, Child3, etc, which all inherit from Parent[T]. Inside of my_module.py, I can give them all typing information like this:

# my_module.py
from project.my_types import Child1, Child2, Child3

T = float

obj1 = Child1[T]()
obj1.member_x = 1  # no typecheck error

obj2 = Child2[T]()
obj2.member_x = 2  # no typecheck error

obj3 = Child3[T]()
obj3.member_x = '3'  # typecheck error!!

But what I would like to do is tell the type checker that in my_module, ALL of the instances that are from child classes of Parent should have member_x the type, float, and then just write the code ignoring typing syntax after that, like so:

# my_module.py
from project.my_types import Parent, Child1, Child2, Child3

# incantation goes here informing type checker that the type T for Parent and all its children is `float`

obj1 = Child1()
obj1.member_x = 1  # no typecheck error

obj2 = Child2()
obj2.member_x = 2  # no typecheck error

obj3 = Child3()
obj3.member_x = '3'  # typecheck error!!

Can I do it? Or is this just a dumb thing to want to do?

[JelleZijlstra]

That seems extremely specific and unusual and I don't think any type system would provide a feature to do this.

The closest you can come is writing a child class class IntParent(Parent[float]) and inheriting all your child classes from it.

[Ricyteach]

My gut was that this is the case but it's good to have confirmation from someone who knows way more than me. Thanks!

[Ricyteach]

BTW in case anyone is interested: the situation is that I'm using the type as a stand-in for (VERY simple) unit system. So for example:

from typing import Generic, TypeVar

Unit = TypeVar("Unit")

class Circle(Generic[Unit]):
    radius: Unit
    diameter: Unit

Then later:

class LengthValue(float):
    unit: str
    def __new__(cls, value, unit):
        return super().__new__(cls, value)
    def __init__(self, value, unit):
        self.unit = unit

def meter(v) -> LengthValue:
    return LengthValue(v, "meter")

c = Circle[LengthValue]()

c.radius = 1  # typecheck error, yay!
c.radius = meter(1)  # correct

I have a lot of geometric objects like Circle (Rectangle etc etc). Was thinking it would be nice to specify my LengthValue type somewhere as the unit system for all these objects across an entire project/module, without having to re-define a bunch of Typed... classes, eg:

from generic_geo import Circle, Rectangle
from unit_system import LengthValue

class TypedCircle(Circle[LengthValue]):
    pass

class TypedRectangle(Rectangle[LengthValue]):
    pass

[JelleZijlstra]

It might not help much, but you don't actually have to write all those classes, you can just create type aliases with TypedCircle = Circle[LengthValue].

[Ricyteach]

It helps a little bit. Yeah I should have realized that. Thanks again!

[gandhis1]

Doesn't PEP 696 – Type defaults for TypeVarLikes effectively address this?

[Ricyteach]

Hadn't seen that PEP. Does the PEP allow you to change/specify the default dynamically, at mypy runtime?

EDIT: maybe something like this:

# __init__.py
from my_project.my_crappy_units_implementation import LengthValue
from package.type_info import T

T.default = LengthValue