Does anyone know how if in #Python it is possible to define a generic class that infers the type of the generic from an attribute?

Something like this:

```
T = TypeVar("T")
class Example(Generic[T]):
Config: type[T]
configuration: T

class SubExample(Example):
Config = str

reveal_type(SubExample().configuration)
```

currently Pylance and Mypy complain about Example not being passed the TypeVar, I wonder if there's a different way to achieve this 👀

@patrick you want the parameterized generic instance Example[str] to be “inferred” by the tools? I don’t think this is ever likely to be implemented. It’s a long stretch.

I think this is why dataclasses generate code rather than demand this amount of reasoning from the type checkers.

@patrick We used to call this "Uber Super Meta Programming." Not writing the application, but writing classes that make it easier to create the classes that implement the application.

It's not wrong, but it's so bafflingly indirect that it breaks the tools.

@slott56 mmh, maybe the design I have is bad, basically I'm writing a tool that supports plugins (which are Python classes), these plugins can be configurable (there's a base class that has the validation for the config.

I basically wanted to make sure that a plugin's configuration was properly typed without having to define the configuration type (since we are defining the configuration class already)

@slott56 Here's what I'm working with: https://github.com/autopub/autopub/pull/31/commits/58bb262c1b31f51887

@patrick This is often better done with a "registery"

@myregistery.PlugIn
class YourWhatever:
...

This lets the registery object vet the plug-in for all the required features.

Further. It can involve metaclass operations to inject features.

@slott56 thanks! I'll think about it, I'm not sure the register pattern solves my problem 😊

@patrick it moves the problem out of fussing with the type system into writing a meta class that injects the needed features. The problem remains, but it might be more solvable.