Generic nested classes

[BaconPancakes]

I currently have the following:

import abc

class Foo[H](abc.ABC):
    @staticmethod
    def my_fun(helper: H):
         ...

I want to achieve an interface that users can implement while also allowing them to specify a user-defined class to use as an argument to my_fun.

class BarHelper:
    y: float = 10
    
class Bar(Foo[BarHelper])
    @staticmethod
    @override
    def my_fun(helper: BarHelper):
        assert(10==helper.y)
        

However, it would be nice if I could nest FooHelper from within Foo somehow to avoid having to have loose classes (FooHelper, BarHelper, BobHelper) since many of these could live in the same module.

So, somehow:

class NewFoo(abc.ABC):
    class Helper(abc.ABC):
        ...

    @staticmethod
    def my_fun(helper: Helper):
        ...

class NewBar(NewFoo):
    class Helper:    # type error
        y: float = 10
        
    @staticmethod
    @typing.override
    def my_fun(helper: Helper):  # type error
        assert(10==helper.y)

I think what I'm looking for is to have a generic nested Class type bound to the parent class.

This StackOverflow answer seems to have an idea but it doesn't type check in pyright so I'm not sure if it's sound.

Code sample in pyright playground

from typing import Generic, TypeVar, cast


N = TypeVar("N", bound="Base.Nested")


class Base(Generic[N]):
    nested_instance: N

    class Nested:
        pass

    def __init__(self) -> None:
        self.nested_instance = cast(N, self.Nested())


class Sub(Base["Sub.Nested"]):
    class Nested(Base.Nested):
        pass

Any ideas?

[erictraut]

This code won't type check because you've created a circularity. Resolving the type of Base requires the evaluation of H which requires the evaluation of Base.Nested (which is effectively Base[Any].Nested), and that requires the evaluation of Base.

The code also redefines Nested in a subclass, which isn't allowed. The use of cast here is also a sign that the code is being modeled incorrectly from a typing standpoint.

I've seen other people try to use this design pattern, and it doesn't work well with static type checking. If you want your code to work well with static typing, I recommend exploring alternatives.