Changing the base class of a class with __new__

Question

I would like to change the base class of a class at runtime using __new__. I looked as hard as I could, but I couldn't figure it out.

class A(object): pass

class B(object): pass

class C(B): 

    some_attribute_in_c='hello'

    def __new__(cls):
        cls.__bases=(A,) #some code here to change the base class
        return super(C,cls).__new__(A)

x=C()
x.some_attribute_in_c #return Error: x has no attribute 'some_attribute_in_c'

What is the proper code to put in __new__() so that the last line return 'hello' and x is an instance of C with base class A.

ADDED
My use case is the following.

class Pet(object):
    some_attribute_in_pet='I\'m a pet.'

class Dog(Pet):
    some_attribute_in_species='My species is dog.'

class Cat(Pet):
    some_attribute_in_species='My species is cat.'

class PetBuyer(Pet):

    def __new__(cls,desired_animal):
        animal_bought=globals[desired_animal]
        cls.__bases=(animal_bought,) #some code here to change the base class
        return super(PetBuyer,cls).__new__(animal_bought)

    def __init__(self,desired_animal):
        print self.some_attribute_in_pet
        print self.some_attribute_in_species

x = PetBuyer('Dog')

I would like the last line to print.

I'm a pet.
My species is dog.

My goal is to use __new__() in PetBuyer like a factory for the animals class. My reason for doing this are that the syntax PetBuyer('Dog') is convenient in my program.

ADDED2
My reason for doing this is the following. What I have to code is complex for me in the sense that, per see, I cannot infer the proper class design. So I resort to code my problem in anyway I can an refactor as I better understand it. However, with the situation that arise above, it will be too early for me to refactor. I have yet to understand the interaction between some components of my problem, and changing the base class at runtime will help me to do it. I will be more comfortable for refactoring afterward.

Answer 1

When you are overriding __new__ that class is already in existence, anyway __new__ is used to create instances of a given class, what you want can be done via a metaclass, which can act like a factory for classes

e.g.

class A(object): pass

class B(object): pass

class M(type):
    def __new__(cls, clsname, bases, attribs):
        # change bases
        bases = (A,)
        return type(clsname, bases, attribs)

class C(B): 
    __metaclass__ = M    
    some_attribute_in_c='hello'

print C.__bases__
x = C()
print isinstance(x, A)
print x.some_attribute_in_c

output:

(<class '__main__.A'>,)
True
hello

After seeing OP's edit I will say forget all of the above, you don't need any metaclass, just a simple PetBuyer class which is composed of (has a) Pet , so question is why can't you just pass the pet to PetBuyer e.g.

class Pet(object):
    some_attribute_in_pet='I\'m a pet.'

class Dog(Pet):
    some_attribute_in_species='My species is dog.'

class Cat(Pet):
    some_attribute_in_species='My species is cat.'

class PetBuyer(Pet):

    def __init__(self, pet):
        self.pet = pet

        print self.pet.some_attribute_in_pet
        print self.pet.some_attribute_in_species

x = PetBuyer(Dog())

I also do not understand why you need to change the class of PetBuyer, is bad design IMO

Answer 2

Based on your new information, it sounds like you need to create types dynamically. You certainly are not obligated to create a class suite to describe those types, you can create them at run time by calling the type function directly:

def make_thingy(bases):
    new_thingy_class = type("???", bases, {})
    new_thingy_instance = new_thingy_class()
    print new_thingy_instance.some_attribute_in_pet
    print new_thingy_instance.some_attribute_in_species
    return new_thingy_instance

x = new_thingy(Dog)

Answer 3

The immediate answer to my question as provided by TokenMacGuy and hinted by delnan is

class Pet(object):
    pet_attribute='I\'m a pet.'

class Dog(Pet):
    species_attribute='My species is dog.'

class Cat(Pet):
    species_attribute='My species is cat.'

class NewThingy(object):

    def __new__(cls,desired_base):
        x = type(desired_base.__name__+'NewThingy',
                 (NewThingy,desired_base),{})
        return super(NewThingy,cls).__new__(x,cls)

    def __init__(self,desired_base):
        print self.pet_attribute
        print self.species_attribute

x = NewThingy(Dog)

This prints

I'm a pet.
My species is dog.