Instantiate children class from parent without changing parent code

Question

First of all, here is my (pseudo) code:

somemodule.py:

class parentclass(object):
 def __init__(self):
 if(not prevent_infinite_reursion) #Just to make shure this is not a problem ;)
 self.somefunction()
 def somefunction():
 # ... deep down in a function ...
 # I want to "monkey patch" to call constructor of childclass, 
 # not parentclass
 parentclass() 

othermodule.py

from somemodule import parentclass
class childclass(parentclass):
 def __init__(self):
 # ... some preprocessing ...
 super(childclass, self).__init__()

The problem is, i want to monkey patch parent class, so it would call constructor of childclass, without changing code of somemodule.py. It doesn't matter if it's patched only in class instance(that's shure better) or globally.

I know i can override somefunction, but it contains too many lines of code, for this being sane.

Thanks!

• abarnert: You want all attempts to construct a parentclass to instead construct a childclass, or only attempts within parentclass, or only this specific attempt within parentclass.somefunction, or one of the latter two but only when self is a childclass?
• offlinehacker: Well any of this, so i will appreciate any kind of answer, but the best would be attempts in parentclass.
• abarnert: Actually, that's probably the most difficult possibility. But let me think about it...
• Lauritz V. Thaulow: I covered this in my very first answer on StackOverflow, though it replaces all occurances of parentclass().
• abarnert: I can think of two horribly hacky things that might work: (1) Replace each method of parentclass with a wrapper that patches out __new__, calls the original, and restores __new__. (2) Replace each method of parentclass with a wrapper that runs the original inside a modified globals where parentclass has been replaced by childclass. But I don't think either of these is a good enough idea to be worth coding.

Answer 1

You could use mock.patch for this:

class childclass(parentclass):
 def somefunction(self):
 with patch('somemodule.parentclass', childclass):
 super(childclass, self).somefunction()

• abarnert: A nice clean way to do my "horribly hacky thing (1)".
• offlinehacker: Hm it doesn't work in my case, because parentclass is eventually a children of some other class and parent of parentclass new method gets called and it creates parentclass instead of supposedly patched child class, will try to find how to manage that.
• Lauritz V. Thaulow: @offlinehacker You can patch the __new__ method as well. Also it might help to read where to patch.
• offlinehacker: @LauritzV.Thaulow eventually it worked like a charm with patching __new__ of a top class. This one was hard. Thanks!