How to extend Type or how to type a wrapper class

[patrick91]

Hi everyone! I'm trying to type a decorator that returns a Wrapper class of another class. The idea is that
I have a wrapper class that only adds a couple of properties to the original class, something like this:

from typing import Type, TypeVar, Generic

_T = TypeVar("_T")

class Wrapper(Generic[_T]):
    wrap: Type[_T]
    enhanced: bool = True

    def __init__(self, cls: Type[_T]) -> None:
        self.wrap = cls

   def __call__(self, *args, **kwargs): ...

def enhance(cls:  Type[_T]) ->  Type[_T]:
    return Wrapper(cls)  # type: ignore


class X:
    ...

EnhanceX = enhance(X)

reveal_type(EnhanceX)
reveal_type(EnhanceX.enhanced)

The user using the class doesn't really need to know that it has been "enhanced", as it should work as it was before.

My initial idea was to extend Type from typings, but that's not possible. What would you suggest to do here?
Should I type all the methods on Wrapper to basically behave as if they were from self.wrap? not sure if that's actually possibile

There's also a possibility where I'm doing something silly with what I'm trying to do, but it should make sense for my use case 😊

[sobolevn]

The user using the class doesn't really need to know that it has been "enhanced", as it should work as it was before.

I don't undestand this one.

In your current example X and EnhanceX are two very different things:

class X:
    class_prop = 1

EnhanceX = enhance(X)

1, X is a type, EnhanceX is an instance
2. any (potential) X.class_prop calls won't work

I can't find similarities between them. Can you please provide more details?

[patrick91]

Sure, the idea is that EnhanceX becomes a proxy to X. An alternative approach I was taking at the beginning was by doing something like this:

def enhance(cls:  Type[_T]) ->  Type[_T]:
    setattr(cls, 'enhanced', True)
    return cls

but this approach doesn't work well as it doesn't allow you to use enhance multiple times on a class.

The final thing I want to achieve is a decorator that can be applied to a class and returns the same class, with some additional attributes so I can inspect them later, but for the end user of the library it doesn't matter much that these attributes are there, they should still be able to use the class as if it were not decorated :)

Does this make sense? :D

[sobolevn]

Something like this in TypeScript?

class Some {
    a!: number;
}

interface Wrapper {
    x: number;
}

declare function wrap<R>(cls: { new(): R }): { new(): R & Wrapper };

const WrappedSome = wrap(Some);

const a = new WrappedSome().a; // ok
const x = new WrappedSome().x; // ok
const y = new WrappedSome().y; // error: Property 'y' does not exist on type 'Some & Wrapper'.

https://www.typescriptlang.org/play?noImplicitAny=false&strictFunctionTypes=false#code/MYGwhgzhAEDKD2BbAptA3gWAFDV9MAhAFzQB2ArogEbIBOA3NgL7bYCWpALnQGZjCoA6rTAAHUXXTY80AB4kK1Ooywss2ACbJQYWqh7lSwTm3iloAdxGiAPACUANNADC0ZLO6kNMNGWQWACgBKEjtoJgA+ANAIEl9Sf2DQ8JD0P0DUsIAyaGExCVpwlWxgMwhOXOsJDQQUaABeS2sA2uQg4qxS0nL8BvTK-OQapGRggDowemgAemnoeABrErKK2T6EiwHxIdbx2SnZ+aXOlegAT3X-LerdoLGzg7m6WnhaEgAFF4LOC4ByM9+0A08GQMFI8Aq7jYPTM0B+Emgv1a0ByeW2tF+YyAA

[patrick91]

@sobolevn sorry for the late reply, yes it should be something like that!

[sobolevn]

Intersection types are not yet supported: #213 😞

But, this is doable with a mypy plugin.