Trapping numeric operators

[John Dell'Aquila]

I want to trap numeric operators (+ * % etc.) so that my new style
classes can handle them generically, similar to __getattr__ in an old
style class.

I've never done any metaprogramming before but I'm thinking of using
the below metaclass to accomplish this. It reads a class variable,
implements_oper ators, to determine which methods handle various
operators, then inserts closures to call the generic methods with
disambiguating parameters (the name of the magic method and the
corresponding operator built-in, if it can be determined).

Is this a reasonable approach or an abuse of metaclasses? Any comments
would be deeply appreciated.

Thanks,
John

import operator # the metaclass
class metaOperator(ty pe):
def __new__(cls, classname, bases, classdict):
fnDict = classdict['implements_ope rators']
for fn in fnDict.iterkeys ():
for magicName in fnDict[fn]:
for opName in (magicName, '__%s'%magicNam e[3:]):
# try magicName else assume in-place/right
# and strip out the presumptive 'i'/'r'
try:
op = getattr(operato r, opName)
break
except AttributeError:
pass
else:
op = None
classdict[magicName] = (
lambda self, other=None, name=magicName, op=op, fn=fn:
fn(self, other, name, op)
)
return type.__new__(cl s, classname, bases, classdict)

class Q(object): # a sketch of its use
__metaclass__ = metaOperator

def binop(self, other, name, op): pass
def ibinop(self, other, name, op): pass
def unop(self, other, name, op): pass

implements_oper ators = {
binop: ('__add__','__s ub__','__mul__' ,'__div__'),
ibinop: ('__iadd__','__ isub__','__imul __','__idiv__') ,
unop: ('__neg__','__p os__','__abs__' ,'__invert__'),
}

[John Dell'Aquila]

The lambda wrapper does impose the overhead of an extra function call:
classdict[magicName] = (
lambda self, other=None, name=magicName, op=op, fn=fn:
fn(self, other, name, op)
)

I could eliminate that by stubbing out the closure and inserting the
code block directly into it:
stub = lambda self, other=None, name=magicName, op=op: self
stub.func_code = fn.func_code
classdict[magicName] = stub

What do folks think -- useful trick or too squirrelly to countenance?