Question

I’ve got a base class where I want to handle __add__() and want to support when __add__ing two subclass instances – that is have the methods of both subclasses in the resulting instance.

import copy

class Base(dict):
    def __init__(self, **data):
        self.update(data)

    def __add__(self, other):
        result = copy.deepcopy(self)
        result.update(other)
        # how do I now join the methods?
        return result

class A(Base):
    def a(self):
        print "test a"

class B(Base):
    def b(self):
        print "test b"


if __name__ == '__main__':
    a = A(a=1, b=2)
    b = B(c=1)
    c = a + b
    c.b() # should work
    c.a() # should work

Edit: To be more specific: I’ve got a class Hosts that holds a dict(host01=.., host02=..) (hence the subclassing of dict) – this offers some base methods such as run_ssh_commmand_on_all_hosts()

Now I’ve got a subclass HostsLoadbalancer that holds some special methods such as drain(), and I’ve got a class HostsNagios that holds some nagios-specific methods.

What I’m doing then, is something like:

nagios_hosts = nagios.gethosts()
lb_hosts = loadbalancer.gethosts()
hosts = nagios_hosts + lb_hosts
hosts.run_ssh_command_on_all_hosts('uname')
hosts.drain() # method of HostsLoadbalancer - drains just the loadbalancer-hosts
hosts.acknoledge_downtime() # method of NagiosHosts - does this just for the nagios hosts, is overlapping

What is the best solution for this problem?

I think I can somehow “copy all methods” – like this:
for x in dir(other):
setattr(self, x, getattr(other, x))

Am I on the right track? Or should I use Abstract Base Classes?

Answer 1

In general this is a bad idea. You’re trying to inject methods into a type. That being said, you can certainly do this in python, but you’ll have to realize that you want to create a new type each time you do this. Here’s an example:

import copy

class Base(dict):
    global_class_cache = {}

    def __init__(self, **data):
        self.local_data = data

    def __add__(self, other):
        new_instance = self._new_type((type(self), type(other)))()
        new_instance.update(copy.deepcopy(self).__dict__)
        new_instance.update(copy.deepcopy(other).__dict__)
        return new_instance

    def _new_type(self, parents):
        parents = tuple(parents)
        if parents not in Base.global_class_cache:
            name = '_'.join(cls.__name__ for cls in parents)
            Base.global_class_cache[parents] = type(name, parents, {})
        return Base.global_class_cache[parents]

class A(Base):
    def a(self):
        print "test a"

class B(Base):
    def b(self):
        print "test b"


if __name__ == '__main__':
    a = A(a=1, b=2)
    b = B(c=1)
    c = a + b
    c.b() # should work
    c.a() # should work
    print c.__class__.__name__

UPDATE
I’ve updated the example to remove manually moving the methods — we’re using mixins here.