Monkey-patching class with inherited classes in Python

Question

After reading the answers to the question about monkey-patching classes in Python I tried to apply the advised solution to the following case.

Imagine that we have a module a.py

class A(object):
    def foo(self):
        print(1)

class AA(A):
    pass

and let us try to monkey patch it as follows. It works when we monkey patch class A:

>>> import a
>>> class B(object):
...     def foo(self):
...             print(3)
... 
>>> a.A = B
>>> x = a.A()
>>> x.foo()
3

But if we try the inherited class, it turns to be not patched:

>>> y = a.AA()
>>> y.foo()
1

Is there any way to monkey patch the class with all its inherited classes?

EDIT

For now, the best solution for me is as follows:

>>> class AB(B, a.AA):
...     pass
... 
>>> a.AA = AB
>>> x = a.AA()
>>> x.foo()
3

Any complex structure of a.AA will be inherited and the only difference between AB and a.AA will be the foo() method. In this way, we don't modify any internal class attributes (like __base__ or __dict__). The only remaining drawback is that we need to do that for each of the inherited classes.

Is it the best way to do this?

I'm not sure if this is actually possible because you can't change base classes dynamically. (You can get a list of subclasses using `A.__subclasses__()`.) — Maximouse, Mar 06 '20 at 12:02
@IlyaPalachev After `a.A = B`, you can do `class AB(A, AA): pass ; AA = AB`. — stovfl, Mar 06 '20 at 17:08
@stovfl Thank you! This seems to be the best solution, and it works for me. — Ilya Palachev, Mar 09 '20 at 01:20

chepner · Accepted Answer · 2020-03-07T14:23:16.357

4

You need to explicitly overwrite the tuple of base classes in a.AA, though I don't recommend modifying classes like this.

>>> import a
>>> class B:
...   def foo(self):
...     print(2)
...
>>> a.AA.__bases__ = (B,)
>>> a.AA().foo()
2

This will also be reflected in a.A.__subclasses__() (although I am not entirely sure as to how that works; the fact that it is a method suggests that it computes this somehow at runtime, rather than simply returning a value that was modified by the original definition of AA).

It appears that the bases classes in a class statement are simply remembered, rather than used, until some operation needs them (e.g. during attribute lookup). There may be some other subtle corner cases that aren't handled as smoothly: caveat programmator.

edited Mar 07 '20 at 14:23

answered Mar 07 '20 at 14:15

chepner

497,756
71
530
681

If we are going to modify each class that inherits from A, then it seems better to do as @stovfl has suggested: `class AB(A, AA): pass ; AA = AB`. Do you know which way is better? – Ilya Palachev Mar 09 '20 at 02:38
1

I wouldn't recommend either approach as a general technique, without knowing more about the exact class hierarchy I am trying to patch. – chepner Mar 09 '20 at 11:50

Monkey-patching class with inherited classes in Python

1 Answers1