class Doc: # base class def __mod__(self, other): other = self.mod.getdoc(other) return self.mapchildren(lambda x: x % other) def __rmod__(self, other): return self.mod.getdoc(other) % self def __str__(self): return self.getstr() def __eq__(self, other): if not isinstance(other, self.__class__): return 0 return str(self) == str(other) def __hash__(self): return hash(str(self)) def shortest(self): return self.mapchildren(lambda x: x.shortest()) class Anon(Doc): def __init__(self, mod, obj): self.mod = mod self.obj = obj def getstr(self): return repr(self.obj) def mapchildren(self, f): return self class Source(Doc): def __init__(self, mod, text): self.mod = mod self.text = text def getstr(self): return self.text def mapchildren(self, f): return self class Attribute(Doc): def __init__(self, mod, obj, name): self.mod = mod self.obj = obj self.name = name def __mod__(self, other): if self.obj is other: return self.mod.rootattribute(other, self.name) return self.mapchildren(lambda x: x % other) def getstr(self): return '%s.%s' % (self.obj.getstr(), self.name) def mapchildren(self, f): return self.__class__(self.mod, f(self.obj), self.name) class RootAttribute(Doc): def __init__(self, mod, obj, name): self.mod = mod self.obj = obj self.name = name def getstr(self): return '%s' % (self.name,) def mapchildren(self, f): return self class BinaryOp(Doc): table = { 'and': '&', 'or': '|', 'sub': '-', 'mul': '*', 'pow': '**', 'lshift': '<<', 'rshift': '>>', } def __init__(self, mod, op, a, b): self.mod = mod self.op = op self.a = a self.b = b def getstr(self): return '%s %s %s' % (self.a.getstr(), self.table[self.op], self.b.getstr()) def mapchildren(self, f): return self.__class__(self.mod, self.op, f(self.a), f(self.b)) class UnaryOp(Doc): table = { 'invert': '~', 'neg': '-', 'pos': '+', } def __init__(self, mod, op, a): self.mod = mod self.op = op self.a = a def getstr(self): return '%s %s' % (self.table[self.op], self.a.getstr()) def mapchildren(self, f): return self.__class__(self.mod, self.op, f(self.a)) class CallFunc(Doc): def __init__(self, mod, obj, *args, **kwds): self.mod = mod self.obj = obj self.args = args self.kwds = kwds def getstr(self): return '%s(%s%s)' % ( self.obj.getstr(), ', '.join([x.getstr() for x in self.args]), ', '.join(['%s=%s' % (k, v.getstr()) for k, v in list(self.kwds.items())])) def mapchildren(self, f): obj = f(self.obj) args = [f(a) for a in self.args] kwds = dict([(k, f(v)) for (k, v) in list(self.kwds.items())]) return self.__class__(self.mod, obj, *args, **kwds) class Multi(Doc): def __init__(self, mod, set): self.mod = mod self.str = '{%s}' % ', '.join([x.getstr() for x in set]) self.set = set def getstr(self): return self.str def mapchildren(self, f): return self.__class__(self.mod, dict([(f(x), 1) for x in self.set])) def shortest(self): ls = None for a in self.set: a = a.shortest() l = len(a.getstr()) if ls is None or l < ls: ls = l st = a return st class Root(Doc): def __init__(self, mod, name=''): self.mod = mod self.name = name def __call__(self, name): return self.__class__(self.mod, name) def mapchildren(self, f): return self def getstr(self): return self.name class Tuple(Doc): def __init__(self, mod, *args): self.mod = mod self.args = args def mapchildren(self, f): return self.__class__(self.mod, *[f(x) for x in self.args]) def getstr(self): x = '(%s)' % ', '.join([x.getstr() for x in self.args]) if len(self.args) == 1: x = x[:-1]+',)' return x class DocError(Exception): pass class _GLUECLAMP_: def add_origin(self, obj, origin): o = getattr(obj, '_origin_', None) if o is None: obj._origin_ = origin else: obj._origin_ = self.multi(o, origin) return obj def add_wrapdict(self, obj, doc): wd = self.wrapdict o = wd.get(id(obj)) if o is None: o = (obj, doc) else: o = (obj, self.multi(o[1], doc)) wd[id(obj)] = o return obj def anon(self, obj): return Anon(self, obj) def attribute(self, obj, name): return Attribute(self, self.getdoc(obj), name) def binop(self, op, a, b): return BinaryOp(self, op, self.getdoc(a), self.getdoc(b)) def callfunc(self, obj, *args, **kwds): getdoc = self.getdoc obj = getdoc(obj) args = [getdoc(a) for a in args] kwds = dict([(k, getdoc(v)) for (k, v) in list(kwds.items())]) return CallFunc(self, obj, *args, **kwds) def getdoc(self, obj): if isinstance(obj, Doc): return obj w = getattr(obj, '_origin_', None) if isinstance(w, Doc): return w w = self.wrapdict.get(id(obj)) if w is not None: return w[1] if isinstance(obj, tuple): return self.tuple(*obj) return self.anon(obj) def multi(self, a, b): a = self.getdoc(a) b = self.getdoc(b) if isinstance(a, Multi): set = a.set.copy() if len(set) > 4: return a else: set = {a: 1} if isinstance(b, Multi): set.update(b.set) else: set[b] = 1 return Multi(self, set) def _get_root(self): return Root(self) def rootattribute(self, root, name): return RootAttribute(self, self.getdoc(root), name) def source(self, text): return Source(self, text) def tuple(self, *args): return Tuple(self, *[self.getdoc(x) for x in args]) def unop(self, op, a): return UnaryOp(self, op, self.getdoc(a)) def wrap(self, obj, doc): assert obj is not self._parent.UniSet.UniSet w = getattr(obj, '_derive_origin_', None) if w is not None: if getattr(w, 'im_self', None) is obj or isinstance(w, self._root.types.MethodType): obj = w(doc) elif w == 'ADD': obj = self.add_origin(obj, doc) else: raise DocError( "Doc.wrap: attribute '_derive_origin_' has invalid value") elif isinstance(obj, self._root.types.MethodType): obj = self.wrap_method(obj, doc) elif isinstance(obj, self._root.types.FunctionType): obj = self.wrap_function(obj, doc) else: obj = self.add_wrapdict(obj, doc) return obj def _get_wrapdict(self): return {} def wrap_function(mod, obj, doc): def f(*args, **kwds): r = obj(*args, **kwds) r = mod.wrap(r, mod.callfunc(doc, *args, **kwds)) return r f._origin_ = doc return f def wrap_method(mod, obj, doc): im_func = obj.__func__ def f(self, *args, **kwds): r = im_func(self, *args, **kwds) r = mod.wrap(r, mod.callfunc(doc, *args, **kwds)) return r return mod._root.types.MethodType(f, obj.__self__)