def __init__(self, *anon, **mval): #{{{
prop, values = self.p, self.v
if not isinstance(prop, MultiValueProperties):
raise TypeError("%s object is not a valid properties object" %prop.__class__.__name__)
elif not isinstance(values, MultiValueValues):
raise TypeError("%s object is not a valid values object" %values.__class__.__name__)
if not anon and not mval:
raise ValueError("Cannot create empty mval")
block = ['__get__', '__getitem__']
reserved = [n for n in mval if n in block + dir(object)]
if reserved:
raise AttributeError("The following attribute names are reserved: %s" %', '.join(reserved))
tfunc, eqfunc = self._mktfunc(), self._mkeqfunc()
if [a for a in (tfunc, eqfunc) if not iscallable(a)]:
raise TypeError("Attempt to set transform or equals function to a non-callable")
anon = ((k, v) for k, v in enumerate(anon))
mval = mdict(anon, mval)
mval.clearmerged()
# object.__setattr__(self, '_mval', mval)
# object.__setattr__(self, '_tfunc', tfunc)
# object.__setattr__(self, '_eqfunc', eqfunc)
osetattr(self, '_mval', mval)
osetattr(self, '_tfunc', tfunc)
osetattr(self, '_eqfunc', eqfunc)
def __init__(self, *anon, **mval): #{{{
super(EvalMixin, self).__init__(*anon, **mval)
mval = self._mval
for v in mval.itervalues():
if not iscallable(v):
mval.clear()
raise TypeError("'%s' object is not callable" %v.__class__.__name__)
object.__setattr__(self, '_eqfunc', lambda s, o: bool(s(o)))
def _getset_eqfunc(self, *args): #{{{
mval = self._mval()
if not args:
func = mval._eqfunc
return func
func = args[0]
if not iscallable(func):
raise TypeError("Equals function is not callable")
# object.__setattr__(mval, '_eqfunc', func)
osetattr(mval, '_eqfunc', func)
def _getset_transformer(self, *args): #{{{
mval = self._mval()
if not args:
func = mval._tfunc
return func
func = args[0]
if not iscallable(func):
raise TypeError("Transform function is not callable")
# object.__setattr__(mval, '_tfunc', func)
osetattr(mval, '_tfunc', func)
def _anyall_func(self, args): #{{{
f = None
if not args:
f = lambda v: bool(v)
else:
if len(args) > 1:
raise TypeError('any() takes at most 1 argument (%i given)' %len(args))
f = func = args[0]
if iscallable(func):
f = lambda v: bool(func(v))
else:
raise TypeError("Compare function must be callable")
return f
def __new__(cls, classname, bases, clsdict): #{{{
if not isbasemetaclass(bases, cls):
return super(MetaProxy, cls).__new__(cls, classname, bases, clsdict)
proxyattr = clsdict.pop('proxyattr')
curobj = proxyattr.proxyobj
retproxy = proxyattr.return_proxy
if not isinstance(retproxy, tuple):
retproxy = tuple(retproxy)
can_weakref = proxyattr.weakref
clsproxy = isclass(curobj)
proxyinst = None
if clsproxy:
proxyinst = {}
# Set setattr
temp_attr = {}
def __setattr__(self, name, val): #{{{
try:
obj = _ga(self, '__proxyinst__')
except KeyError:
obj = curobj
if clsproxy and obj is curobj:
sid = id(self)
vars = temp_attr.setdefault(sid, {})
vars[name] = val
else:
try:
setattr(obj, name, val)
except AttributeError:
_sa(self, name, val)
# End def #}}}
def __delattr__(self, name): #{{{
try:
obj = _ga(self, '__proxyinst__')
except KeyError:
obj = curobj
if clsproxy and obj is curobj:
sid = id(self)
vars = temp_attr.setdefault(sid, {})
try:
vars.pop(name)
except KeyError:
raise AttributeError()
else:
try:
delattr(obj, name)
except AttributeError:
if name in dir(self):
_da(self, name)
else:
raise
# End def #}}}
clsdict['__setattr__'] = __setattr__
clsdict['__delattr__'] = __delattr__
instblock = ('__new__', '__init__', '__getattribute__', '__setattr__',
'__delattr__')
instblock_retproxy = instblock + retproxy
block = ('__class__', '__slots__', '__proxyinst__') + instblock
# Set getattribute
def __getattribute__(self, name): #{{{
sid = id(self)
if proxyinst is None:
obj = curobj
else:
obj = proxyinst.get(sid, curobj)
# obj = _ga(self, '__proxyinst__')
if clsproxy:
if obj is curobj:
vars = temp_attr.setdefault(sid, {})
if name in vars:
return vars[name]
if name == '__class__' and not clsproxy:
return _ga(obj, name)
try:
ret = _ga(self, name)
except AttributeError:
ret = _ga(obj, name)
return ret
# End def #}}}
clsdict['__getattribute__'] = __getattribute__
clsdict['__proxyinst__'] = property(lambda s: curobj)
if clsproxy:
# proxyinst = {}
def __init__(self, *args, **kwargs): #{{{
sid = id(self)
proxyinst[sid] = inst = curobj(*args, **kwargs)
vars = temp_attr.setdefault(sid, {})
pi = vars.popitem
while vars:
setattr(self, *pi())
temp_attr.pop(sid)
# End def #}}}
clsdict['__init__'] = __init__
clsdict['__proxyinst__'] = property(lambda s: proxyinst[id(s)])
if can_weakref:
objslots = getattr(curobj, '__slots__', None)
curslots = clsdict['__slots__']
if not isbuiltin(curobj) and (objslots is None or '__weakref__' in objslots):
clsdict['__slots__'] += curslots + ('__weakref__',)
attrblock = block if clsproxy else instblock
for n in dir(curobj):
if n in attrblock:
continue
attr = getattr(curobj, n)
if iscallable(attr) and not isclass(attr):
res = None
if isclassmethod(attr):
res = _mkproxycallable(attr, n, clsproxy, retproxy, classmethod)
elif isfunction(attr):
res = _mkproxycallable(attr,n, clsproxy, retproxy, staticmethod)
else:
res = _mkproxycallable(attr, n, clsproxy, retproxy, usewraps=False)
clsdict[n] = res
else:
clsdict[n] = attr
if clsproxy:
classname = curobj.__name__
return super(MetaProxy, cls).__new__(cls, classname, bases, clsdict)
def init_query(self, f): #{{{
if not iscallable(f):
return (lambda i: i== f)
else:
return f
