(This is a long post, but the question is simple. Most of this is just me enumerating what I've already tried.)
Someone wrote a library that creates and manipulates `Node`s. I would like to write another layer on top of this, to make trees that behave just like the library's trees, but whose nodes have some extra methods. "Subclass!" is the classic OO answer, and my first instinct. Problem: I never instantiate `Node` myself. `Node`s are created somewhere deep inside the library, and there's no way to tell it "don't use `Node`, use this class instead." Does anyone know a programming pattern that solves this problem? (That's it! That's the question. Everything after this is descriptions of solutions I'm not happy enough with.) "Write a wrapper!" is my next instinct. Basically, class MyNode(object): ... def foo(self, *args, **kwargs): return self.node.foo(*args, **kwargs) def bar(self, *args, **kwargs): return self.node.bar(*args, **kwargs) ... This would be tedious, but acceptable, if I knew how to make `MyNode.parent` and `MyNode.children` return `MyNode`s instead of `Node`s. Every way I've thought of makes me cringe: - Make `MyNode` maintain its own parent/child info, and keep it in lock-step with the underlying `Node`'s parent/child info. Objection: this is a lot of work, and just begging to get out of sync. - Give every wrapped `Node` a `_wrapper` attribute, specifying the wrapping `MyNode` instance. Then `MyNode.children` would return `[child._wrapper for child in self._node.children]`. Objection: it just feels weird adding custom attributes to objects. - Have a global registry mapping `Node`s to their corresponding `MyNode` wrappers. Then `MyNode.children` would return `[MyNode.wrappers[child] for child in self.node.children]`. Objection: I've been trained not to like global state. My last idea is that my approach is *entirely* wrong: I shouldn't be trying to make the tree's nodes instances of my own class -- I should just use the existing library's `Node` class, and write my library in a functional style. Don't define `MyNode.foo()`, instead define `mylibrary.foo(my_node)`. I've got nothing against functional programming, but mixing it so closely with OO would, I think, result in a confusing, schizophrenic interface. Last possibly relevant fact: the library I want to extend is `xml.dom.minidom`. By `Node` I mean `Element`, and the specific methods I want to add will modify attributes used for CSS/JavaScript. Thank you very much! -Spencer -- https://mail.python.org/mailman/listinfo/python-list