Very occasionally, I write code where I'm given an object of some class (usually from a library call), but I wish to use additional methods on that class as though they had been defined there. In some languages (Objective-C shines in this regard with categories), you can do this very naturally. In Python, most people probably resort to monkey patching to accomplish this.

This is Probably An Anti-Pattern

I want to preface this with an admission that I have no idea if this will generally work (please comment if you know of a reason why it won't!), and that I suspect that this is a horrible idea. And yet, here we go:

import copy

class Base(object):
    def __init__(self):
        self.base_init = True

    def foo(self):
        return 'base foo'

    def bar(self):
        return 'base bar'

class Child(Base):
    def __new__(cls, other):
        if isinstance(other, Base):
            other = copy.copy(other)
            other.__class__ = Child
            return other
        return object.__new__(cls)

    def __init__(self, other):
        self.child_init = True

    def bar(self):
        return 'child bar'

b = Base()
assert b.base_init == True
assert == 'base foo'
assert == 'base bar'
assert b.__class__ == Base

c = Child(b)
assert c.base_init == True
assert c.child_init == True
assert == 'base foo'
assert == 'child bar'
assert c.__class__ == Child
assert b.__class__ == Base

Have I made some glaring mistake? Is there something obviously wrong with this, other than the abuse of the language inherent in trying to do such a thing?

Edit: Thanks to Jesse Davis for the suggestion to use copy.copy. Also see the Stackoverflow question which inspired this post.