class BTTest(Base): _attrs = dict(a=Attr(int, 1, group='hash_exclude'), b=Attr(float, 1.2, internal=True), c=Attr(str, 'abc', groups=('hash_exclude', 'generate_exclude'), internal=True))
class Logger(Tree): _opts = dict(init_validate=True) _attrs = dict(root=Attr(Event), current_parent=Attr(Event)) @init_hook def _init(self): if type(self.root) is Node: self.root = Event() if not hasattr(self, 'current_parent'): self.current_parent = self.root def add(self, event): self.add_node(event, parent=self.current_parent) def plaintext(self, **kwargs): return self.root.plaintext(**kwargs) def pop(self): ret = self.current_parent self.current_parent = ret._parent return ret def push(self, event): self.add(event) self.current_parent = event def reset(self): self.current_parent = self.root
class F(B): _seq_opts = dict(init_order=('d', 'e')) _attrs = dict(d=Attr(float, internal=True, init=lambda self: self.a + self.b), e=Attr(float, internal=True, init=lambda self: self.d + self.a))
class Position(Predicate): _attrs = dict(pos=Attr(int), start_offset=Attr(int, 0), pos_attr=Attr(STR, POSITION)) _opts = dict(args=('pos', )) def eval(self, node, **kwargs): pos = getattr(node, self.pos_attr) return pos == (self.pos - self.start_offset)
class ADOC(Base): '''Some documentation.''' _attrs = dict(a=Attr(int, doc='attr a'), b=Attr(float, optional=True), c=Attr(int, 2, optional=True, doc='attr c')) _opts = dict(args=('a', 'b', 'c')) def __init__(self, *args, **kwargs): '''Some more documentation.''' super(ADOC, self).__init__(*args, **kwargs)
class BuiltinFunction(Function): _attrs = dict(body=Attr(Callable), python=Attr(Callable), pass_kwargs=Attr(bool, False)) def call(self, env, **kwargs): args = [env[arg.name] for arg in self.signature] if self.pass_kwargs: return self.body(*args, **kwargs) return self.body(*args)
class Sibling(Axis): _attrs = dict(following=Attr(bool, False), preceding=Attr(bool, False)) _opts = dict(one_true=[('following', 'preceding')]) def iterate(self, node, **kwargs): for k, s in enumerate( node.siblings(following=self.following, preceding=self.preceding, axis=True)): with assign(s, POSITION, k): yield s
class I(B): _seq_opts = SeqDict() _attrs = dict(d=Attr(float, internal=True), e=Attr(float, internal=True)) def _foo(self): self.d = self.a * self.b def _bar(self): self.e = self.d + 2 _seq_opts.init_hooks = ('_foo', '_bar')
class TransformEvent(StringEvent): _attrs = dict(obj=Attr(object), ret=Attr(object, optional=True)) _opts = dict(optional_none=True) def display(self, depth=None): pre = ' ' * depth ret = pre + self._plaintext() + ' ({})\n'.format(self._id) if self.obj: ret += self.obj.viewable().pretty(indent=depth) if self.ret: ret += '\n' ret += self.ret.viewable().pretty(indent=depth) return ret
class Following(Axis): _attrs = dict(include_self=Attr(bool, False)) def iterate(self, node, **kwargs): for k, f in enumerate(node.following()): with assign(f, POSITION, k): yield f
class Preceding(Axis): _attrs = dict(include_self=Attr(bool, False)) def iterate(self, node, **kwargs): for k, p in enumerate(node.preceding()): with assign(p, POSITION, k): yield p
class Ancestor(Axis): _attrs = dict(include_self=Attr(bool, False)) def iterate(self, node, **kwargs): for k, a in enumerate(node.ancestors(include_self=self.include_self)): with assign(a, POSITION, k): yield a
class Descendant(Axis): _attrs = dict(include_self=Attr(bool, False)) def iterate(self, node, **kwargs): for k, d in enumerate( node.descendants(include_self=self.include_self)): with assign(d, POSITION, k): yield d
class CT4(Base): _attrs = dict(a=Attr(int)) @classmethod def _coerce_hook(cls, value): value['a'] += 1 _seq_opts = dict(coerce_hooks=('_coerce_hook', ))
class AltAttrs(Base, Harvester): _opts = dict(init_validate=True, args=('a', )) _attrs = dict(a=Attr(int, doc='abc')) @pre_create_hook def _harvest_attrs(clsdata): getfunc(Harvester._harvest_attrs)(clsdata) clsdata['dct']['d'] = ''.join( attr for attr, value in sorted(clsdata['dct']['_attrs'].items()))
class Function(SyntagmathonNode): _attrs = dict(name=Attr((Variable, STR)), signature=Attr(List(Variable)), body=Attr((List(SyntagmathonNode), tuple)), placeholder=Attr(bool, False)) _opts = dict(args=('name', 'signature', 'body')) def __call__(self, *args_, **kwargs): args = {} for k, arg in enumerate(args_): args[self.signature[k].name] = arg for key, value in kwargs.items(): if key in args: raise TypeError("Parameter {} specified twice".format(key)) args[key] = value return Call(self, args) def call(self, env, **kwargs): return eval(self.body, env, **kwargs) def eval(self, env, **kwargs): env[self.get_name()] = self return self def get_name(self): return self.name if isinstance(self.name, STR) else self.name.name def to_python(self, **kwargs): from syn.python.b import Arguments, FunctionDef, Pass if VER < '3': args = Arguments( [to_python(arg, **kwargs) for arg in self.signature]) else: from syn.python.b import Arg args = Arguments([Arg(arg.name) for arg in self.signature]) body = to_python(self.body, **kwargs) if not body: body = [Pass()] body[-1] = body[-1].as_return() return FunctionDef(self.name, args, body)
class I4(I): _attrs = dict(f=Attr(int)) @init_hook @setstate_hook def _baz(self): if not hasattr(self, 'f'): self.f = self.a else: self.f += 1
class Frame(Base): _attrs = dict(globals=Attr(dict, init=lambda self: dict()), locals=Attr(dict, init=lambda self: dict())) _opts = dict(init_validate=True) def __getitem__(self, key): if key in self.locals: return self.locals[key] elif key in self.globals: return self.globals[key] raise KeyError(key) def __setitem__(self, key, value): self.locals[key] = value def __delitem__(self, key): if key in self.locals: del self.locals[key] elif key in self.globals: del self.globals[key] else: raise KeyError(key) def __iter__(self): return iter(sorted(set(self.locals) | set(self.globals))) def __len__(self): return len(set(self.locals) | set(self.globals)) def items(self): for key in self: yield key, self[key] def gensym(self): pass def set_global(self, key, value): self.globals[key] = value def update(self, dct): for key, value in dct.items(): self[key] = value
class GenSym(Base): _attrs = dict(names=Attr(set, init=lambda self: set()), counter=Attr(Counter, init=lambda self: Counter())) _opts = dict(args=('names', ), init_validate=True) def add(self, name): self.names.add(name) def _generate(self): return '_gensym_{}'.format(self.counter()) def generate(self): ret = self._generate() while ret in self.names: ret = self._generate() self.add(ret) return ret def update(self, names): self.names.update(names)
class Type(Query): _attrs = dict(type=Attr(Type_, AnyType())) _opts = dict(args=('type', )) @init_hook def _dispatch_type(self): if not isinstance(self.type, Type_): self.type = Type_.dispatch(self.type) def iterate(self, node, **kwargs): if self.type.query(node): yield node
class Call(SyntagmathonNode): _attrs = dict(func=Attr(Function), args=Attr(dict)) _opts = dict(args=('func', 'args')) def eval(self, env, **kwargs): func = self.func args = { name: eval(value, env, **kwargs) for name, value in self.args.items() } if func.placeholder: func = env[self.func.get_name()] names = [name.name for name in self.func.signature] args = { func.signature[names.index(name)].name: value for name, value in args.items() } env.push(args) if kwargs.get('trace', False): depth = kwargs.get('depth', 0) pre = kwargs.get('tab', ' ') * depth argstr = ', '.join('{}={}'.format(name, value) for name, value in args.items()) print(pre + '{}({})'.format(func.get_name(), argstr)) kwargs['depth'] = depth + 1 ret = func.call(env, **kwargs) env.pop() return ret def to_python(self, **kwargs): from syn.python.b import Call, Name args = [ to_python(self.args[arg.name], **kwargs) for arg in self.func.signature ] if hasattr(self.func, 'python'): return self.func.python(*args, **kwargs) func = Name(self.func.name) return Call(func, args)
class Env(Base): _attrs = dict(frames=Attr(List(Frame), init=lambda self: list([Frame()]))) _opts = dict(init_validate=True) current_frame = property(lambda self: self.frames[-1]) def __getitem__(self, key): return self.current_frame[key] def __setitem__(self, key, value): self.current_frame[key] = value def __delitem__(self, key): del self.current_frame[key] def __iter__(self): return iter(self.current_frame) def __len__(self): return len(self.current_frame) def items(self): for item in self.current_frame.items(): yield item def gensym(self): pass def globals(self): return dict(self.current_frame.globals) def locals(self): return dict(self.current_frame.locals) def push(self, dct): globs = self.globals() globs.update(self.locals()) self.frames.append(Frame(globals=globs, locals=dct)) def pop(self): return self.frames.pop() def set_global(self, key, value): self.current_frame.set_global(key, value) def update(self, dct): self.current_frame.update(dct)
class PythonTree(Tree): _opts = dict(init_validate=True) _attrs = dict(root=Attr(RootNode)) def abstract(self): def op(node): node.lineno = None ret = deepcopy(self) ret.depth_first(op) return ret def emit(self, **kwargs): return self.root.emit(**kwargs) def to_ast(self, **kwargs): return self.root.to_ast(**kwargs)
class Variable(SyntagmathonNode): _attrs = dict(name=Attr(STR)) _opts = dict(args=('name', )) def __call__(self, *args): from .function import Function names = enum(str, max_enum=len(args)) func = Function(self.name, [Variable(name) for name in names], [], placeholder=True) return func(*args) def eval(self, env, **kwargs): return env[self.name] def to_python(self, **kwargs): from syn.python.b import Name return Name(self.name)
class LW3(ListWrapper): _attrs = dict(a=Attr(int), b=Attr(float))
class Value(Query): _attrs = dict(value=Attr(None)) _opts = dict(max_len=0, args=('value', )) def __call__(self, node, **kwargs): return self.value
class Name(Predicate): _attrs = dict(name=Attr(STR), name_attr=Attr(STR, '_name')) _opts = dict(args=('name', )) def eval(self, node, **kwargs): return getattr(node, self.name_attr) == self.name
class LWGT3(LWGT1): _attrs = dict(_list=Attr(Schema(Sequence(int, float, int))))
class RNVTree(Tree): _attrs = dict(root=Attr(Root1))
class LWPA(ListWrapper): _opts = dict(max_len=3, args=['a', 'b'], init_validate=True) _attrs = dict(a=Attr(int), b=Attr(float, default=3.2))