Dynamically determine base classes on instantiation

[Thomas Bach]

Hi list,

I'm confronted with a strang problem I cannot find a clean solution
for. To me it seems like I need meta-classes. Anyway, I stucked a bit
deeper in that topic and couldn't find a proper solution neither. But,
judge for yourselve.

I want a class that determines on instantiating its base classes
dynamically. Consider the following two use cases

a = Foo(['a', 'list'])  # returns an instance that behaves like a list
assert len(a) == 2
assert a[0] == 'a'
assert a == ['a', 'list']
assert isinstance(a, list) # This would be nice, but no must-have

b = Foo({'blah': 8}) # returns an instance that behaves like a dict
assert b['blah'] == 'blah'
assert b == {'blah': 8}
assert isinstance(b, dict) # again, no must-have

a.do_something()   # common function to both instances as defined
b.do_something()   # in the Foo class


What I'm currently doing something like the following:

class Foo(object):

    def __init__(self, obj):
        self._obj = obj

    def __len__(self):
        return len(self._obj)

    def __getitem__(self, name):
        return self._obj[name]

    # …

    def do_something(self):
        # do something on self._obj
        pass

Which seems ugly. Is there a way to provide the functions of `list'
and `dict' in Foo's look-up path without having to write all the
stubs myself?

Regards,
	Thomas Bach.