如何更改活动对象的 isinstance() 行为？

Question

I want to change the behavior of isinstance for a live python object.

One solution is to create a simple wrapper like the following, but I do not like it:

class Widget:
    def __init__(self, obj):
        self.inner_self = obj

lizard = ['head', 'nose', 'tail']
wlizard = Widget(lizard)
assert(isinstance(wlizard, Widget)) # no assertion error thrown 

What I don't like about this particular wrapper, is that we must extract the lizard from wlizard before we can use the lizard again

try:
    wlizard[0]
except:
    print('sorry, wlizard doesn\'t behave like a lizard')

lizard = wlizard.inner_self
print(lizard[0]) # works fine

What I really want is for wlizard to behave exactly like lizard except that isinstance returns True for wlizard and it returns false for lizard .

The following sort-of works, but has some drawbacks:

class Widget:
    pass

def MakeAWidget(obj):

    class Blah(type(obj), Widget):
        pass
        # inherits type(obj)'s __init__ method

    wobj = Blah(obj)  # calls type(obj)'s copy constructor
    return wobj

One problem is that this only works if type(obj) 's __init__() method takes in more than just self ; in particular, that __init__ can take in an instance of type(obj) , and when it does, it copies the attributes of obj into self . I would like something that works even if obj does not have a copy constructor. Something like the following might be possible to force the existence of a copy-constructor:

import copy
class Blah(type(obj), Widget):
    def __init__(*args, **kwargs):
        if isinstance(args[0], type(obj)):
            self = copy.deepcopy(args[0])
            return self
        return super(type(self), self).__init__(*args, **kwargs)

However, I would rather not copy the object, only modify it in-place. Something like the following might be possible, but I am not sure what __BLAH__ would be:

obj = ['apple', 'pear', 'banana']
assert(not isinstance(obj, Widget)) # no error thrown    
obj.__BLAH__.append('Widget')
assert(isinstance(obj, Widget))  # no error thrown

Answer 1

Here's something I think does what you want. The wrap() function dynamically creates a class which is derived from the class of the obj argument passed to it, and then returns an instance of that class created from it. This assumes the class of obj supports copy construction (initialization from an instance of the same — or derived — class).

def wrap(obj):
    class MetaClass(type):
        def __new__(mcls, classname, bases, classdict):
            wrapped_classname = '_%s_%s' % ('Wrapped', type(obj).__name__)
            return type.__new__(mcls, wrapped_classname, (type(obj),)+bases, classdict)

    class Wrapped(metaclass=MetaClass):
        pass

    return Wrapped(obj)

lizard = ['head', 'nose', 'tail']
wlizard = wrap(lizard)
print(type(wlizard).__name__)     # -> _Wrapped_list
print(isinstance(wlizard, list))  # -> True

try:
    wlizard[0]
except Exception as exc:
    print(exc)
    print("sorry, wlizard doesn't behave like lizard")
else:
    print('wlizard[0] worked')

Answer 2

I think this is exactly what you want. This solution allows you to decorate any object so that the wrapper instance gets all the methods and attributes of the wrapped one.

This is a metaclass of the wrapper:

class WrapperMeta(type):
    @classmethod
    def __new_getattr(mcs, method, inst):
        if method is None:
            method = object.__getattribute__

        def new_method(self, key):
            try:
                return method(self, key)
            except AttributeError:
                return method(inst.wrappee.fget(self), key)
        return new_method

    def __new__(mcs, name, bases, kwargs):
        if not bases:
            bases = (object,)
        if len(bases) != 1:
            raise TypeError("Wrapper can wrap only one class")
        if type(kwargs.get("wrappee")) != property:
            raise AttributeError("wrapper class must have a \"wrappee\" property")

        inst = type.__new__(mcs, name, bases, kwargs)
        inst.__getattribute__ = mcs.__new_getattr(inst.__getattribute__, inst)
        return inst

It requires a wrapper to have exactly one parent class (the one you want to wrap), to have "wrappee" property and overrides __getattribute__ in a way you need.

This is a base class:

class VeryImportantClass:
    def __init__(self):
        self.a = 1

    def very_important_function(self, n):
        return n + self.a

This is a wrapper class:

class Wrapper(VeryImportantClass, metaclass=WrapperMeta):
    def __init__(self, vii):
        self._vii = vii

    @property
    def wrappee(self):
        return self._vii

    def very_important_addition(self, n):
        return n - self.a * 4

And that is the result:

vii = VeryImportantClass()
vii = Wrapper(vii)
print(vii.very_important_function(5))  # 6
print(vii.very_important_addition(1))  # -3
print(isinstance(vii, VeryImportantClass))  # True