I've got a class, located in a separate module, which I can't change.
from module import MyClass
class ReplaceClass(object)
...
MyClass = ReplaceClass
This doesn't change MyClass anywhere else but this file. However if I add a method to the class like this
def bar():
print 123
MyClass.foo = bar
it will work, but the foo method will be available everywhere else as well.
How can I replace the class completely instead of replacing the method?
import module
class ReplaceClass(object):
....
module.MyClass = ReplaceClass
module.MyClass
Avoid the from ... import (horrid;-) way to get barenames when what you need most often are qualified names. Once you do things the right Pythonic way:
import module
class ReplaceClass(object): ...
module.MyClass = ReplaceClass
This way, you're monkeypatching the module object, which is what you need and will work when that module is used for others. With the from ... form, you just don't have the module object (one way to look at the glaring defect of most people's use of from ...) and so you're obviously worse off;-);
The one way in which I recommend using the from statement is to import a module from within a package:
from some.package.here import amodule
so you're still getting the module object and will use qualified names for all the names in that module.
module.MyClass=, though it will replace the class in the module, won't replace the class in any other modules that have already done from module import MyClass. They'll have their own separate copies. Monkey-patching is bad mmkay; from module import is also bad mmkay; both at the same time is a recipe for stuff-going-wrong.
from module import MyClass, finding and monkeying around with all of them is somewhere between "a mess" and "impossible" (gc.get_referrers can sometimes help... but not always!-). Yeah, they're both bad practice, but sometimes monkeypatching CAN be the least of evils, while creating "artificial barenames" with the from statement can always be dispensed with.
from module import MyClass?I am but an egg . . . . Perhaps it is obvious to not-newbies, but I needed the from some.package.module import module idiom.
I had to modify one method of GenerallyHelpfulClass. This failed:
import some.package.module
class SpeciallyHelpfulClass(some.package.module.GenerallyHelpfulClass):
def general_method(self):...
some.package.module.GenerallyHelpfulClass = SpeciallyHelpfulClass
The code ran, but didn't use the behaviors overloaded onto SpeciallyHelpfulClass.
This worked:
from some.package import module
class SpeciallyHelpfulClass(module.GenerallyHelpfulClass):
def general_method(self):...
module.GenerallyHelpfulClass = SpeciallyHelpfulClass
I speculate that the from ... import idiom 'gets the module', as Alex wrote, as it will be picked up by other modules in the package. Speculating further, the longer dotted reference seems to bring the module into the namespace with the import by long dotted reference, but doesn't change the module used by other namespaces. Thus changes to the import module would only appear in the name space where they were made. It's as if there were two copies of the same module, each available under slightly different references.
import some_module_name
class MyClass(object):
... #copy/paste source class and update/add your logic
some_module_name.MyClass = MyClass
Its preferable not to change the name of class while replacing, because somehow someone may have referenced them using getattr - which will result in fail like below
getattr(some_module_name, 'MyClass') --> which will fail if you have replaced MyClass by ReplaceClass !
as foo does nothing to help. 2) your argument about getattr is not just confusing (because of your inconsistent use of names) but wrong as well and confuses the name of the class with the class itself. if I import somemodule; somemodule.someclass = someotherclass, then at a later point, in another module, getattr(somemodule, 'someclass') will return someotherclass which is exactly what OP wants. 3) copy-paste programming is ugly and error-prone.
getattr Also, why can't we inherit from a class that we're about to 'replace'? class A(object):pass; class B(A): pass; A = B; a = A().