Comment modifier dynamiquement la classe de base de cas au moment de l'exécution?

Ok, encore une fois, ce n'est pas quelque chose que vous devrait le faire normalement, ceci est à titre informatif seulement.

Où Python recherche d'une méthode sur une instance de l'objet est déterminée par la __mro__ attribut de la classe qui définit un objet (le M méthode R esolution O rder attribut). Ainsi, si l'on pouvait modifier la __mro__ de Person, nous aimerions obtenir le comportement désiré. Quelque chose comme:

setattr(Person, '__mro__', (Person, Friendly, object))

Le problème est que __mro__ est un attribut lecture seule, et donc setattr ne fonctionne pas. Peut-être que si vous êtes un Python gourou, il y a un moyen de contourner cela, mais clairement, je manque de statut de gourou que je ne peux pas penser à une.

Une solution de contournement possible est tout simplement de redéfinir la classe:

def modify_Person_to_be_friendly():
    # so that we're modifying the global identifier 'Person'
    global Person

    # now just redefine the class using type(), specifying that the new
    # class should inherit from Friendly and have all attributes from
    # our old Person class
    Person = type('Person', (Friendly,), dict(Person.__dict__)) 

def main():
    modify_Person_to_be_friendly()
    p = Person()
    p.hello()  # works!

Ce que ce n'est pas faire est de modifier tout créé précédemment Person instances pour avoir le hello() méthode. Par exemple (juste en modifiant main()):

def main():
    oldperson = Person()
    ModifyPersonToBeFriendly()
    p = Person()
    p.hello()  
    # works!  But:
    oldperson.hello()
    # does not

Si les détails de la type appel ne sont pas clairs, alors lisez la e-satis "excellente réponse sur" Ce qui est une métaclasse en Python?'.

Je ne peux pas se porter garant pour les conséquences, mais que ce code fait ce que vous voulez à py2.7.2.

class Friendly(object):
    def hello(self):
        print 'Hello'

class Person(object): pass

# we can't change the original classes, so we replace them
class newFriendly: pass
newFriendly.__dict__ = dict(Friendly.__dict__)
Friendly = newFriendly
class newPerson: pass
newPerson.__dict__ = dict(Person.__dict__)
Person = newPerson

p = Person()
Person.__bases__ = (Friendly,)
p.hello()  # prints "Hello"

Nous savons que cela est possible. Cool. Mais nous ne serons jamais à l'utiliser!

J'ai besoin d'une solution pour cela:

• Fonctionne avec Python 2 (>= 2,7) et Python 3 (>= 3.2).
• Permet à la classe des bases d'être changé après dynamiquement l'importation d'une dépendance.
• Permet à la classe des bases d'être modifiés à partir de l'unité de test de code.
• Travaille avec des types qui ont une coutume métaclasse.
• Permet encore unittest.mock.patch de fonctionner comme prévu.

Voici ce que je suis venu avec:

def ensure_class_bases_begin_with(namespace, class_name, base_class):
    """ Ensure the named class's bases start with the base class.

        :param namespace: The namespace containing the class name.
        :param class_name: The name of the class to alter.
        :param base_class: The type to be the first base class for the
            newly created type.
        :return: ``None``.

        Call this function after ensuring `base_class` is
        available, before using the class named by `class_name`.

        """
    existing_class = namespace[class_name]
    assert isinstance(existing_class, type)

    bases = list(existing_class.__bases__)
    if base_class is bases[0]:
        # Already bound to a type with the right bases.
        return
    bases.insert(0, base_class)

    new_class_namespace = existing_class.__dict__.copy()
    # Type creation will assign the correct ‘__dict__’ attribute.
    del new_class_namespace['__dict__']

    metaclass = existing_class.__metaclass__
    new_class = metaclass(class_name, tuple(bases), new_class_namespace)

    namespace[class_name] = new_class

Utilisé comme cela, au sein de l'application:

# foo.py

# Type `Bar` is not available at first, so can't inherit from it yet.
class Foo(object):
    __metaclass__ = type

    def __init__(self):
        self.frob = "spam"

    def __unicode__(self): return "Foo"

# … later …
import bar
ensure_class_bases_begin_with(
        namespace=globals(),
        class_name=str('Foo'),   # `str` type differs on Python 2 vs. 3.
        base_class=bar.Bar)

Utiliser comme cela de l'intérieur de l'unité de test de code:

# test_foo.py

""" Unit test for `foo` module. """

import unittest
import mock

import foo
import bar

ensure_class_bases_begin_with(
        namespace=foo.__dict__,
        class_name=str('Foo'),   # `str` type differs on Python 2 vs. 3.
        base_class=bar.Bar)


class Foo_TestCase(unittest.TestCase):
    """ Test cases for `Foo` class. """

    def setUp(self):
        patcher_unicode = mock.patch.object(
                foo.Foo, '__unicode__')
        patcher_unicode.start()
        self.addCleanup(patcher_unicode.stop)

        self.test_instance = foo.Foo()

        patcher_frob = mock.patch.object(
                self.test_instance, 'frob')
        patcher_frob.start()
        self.addCleanup(patcher_frob.stop)

    def test_instantiate(self):
        """ Should create an instance of `Foo`. """
        instance = foo.Foo()