def remove_node(_node):
del self.id_dict[_node._id]
self.nodes.remove(_node)
self.type_dict[get_typename(_node)].remove(_node)
if self.type_dict[get_typename(_node)] == []:
self.node_types.remove(get_typename(_node))
del self.type_dict[get_typename(_node)]
def remove_node(_node):
del self.id_dict[_node._id]
self.nodes.remove(_node)
self.type_dict[get_typename(_node)].remove(_node)
if self.type_dict[get_typename(_node)] == []:
self.node_types.remove(get_typename(_node))
del self.type_dict[get_typename(_node)]
def test_get_typename():
from syn.base_utils import get_typename
class Foo(object):
pass
assert get_typename(Foo) == 'Foo'
assert get_typename(Foo()) == 'Foo'
def test_get_typename():
from syn.base_utils import get_typename
class Foo(object):
pass
assert get_typename(Foo) == 'Foo'
assert get_typename(Foo()) == 'Foo'
def add_node(_node):
if _node._id is None:
_node._id = self.node_counter()
self.id_dict[_node._id] = _node
self.nodes.append(_node)
if get_typename(_node) not in self.node_types:
self.node_types.append(get_typename(_node))
if get_typename(_node) not in self.type_dict:
self.type_dict[get_typename(_node)] = []
self.type_dict[get_typename(_node)].append(_node)
def add_node(_node):
if _node._id is None:
_node._id = self.node_counter()
self.id_dict[_node._id] = _node
self.nodes.append(_node)
if get_typename(_node) not in self.node_types:
self.node_types.append(get_typename(_node))
if get_typename(_node) not in self.type_dict:
self.type_dict[get_typename(_node)] = []
self.type_dict[get_typename(_node)].append(_node)
def _serialize_dict(cls, typ, **kwargs):
if typ in SER_BUILTINS:
mod = 'six.moves.builtins'
else:
mod = get_mod(typ)
return {SER_KEYS.name: get_typename(typ), SER_KEYS.mod: mod}
def estr(self, **kwargs):
'''Should return a string that can eval into an equivalent object'''
if hasmethod(self.obj, '_estr'):
return escape_for_eval(self.obj._estr(**kwargs))
objstr = escape_for_eval(quote_string(str(self.obj)))
return '{}({})'.format(get_typename(self.obj), objstr)
def from_ast(ast, **kwargs):
try:
cls = AST_REGISTRY[type(ast)]
except KeyError:
raise AstUnsupported(get_typename(ast))
kwargs.update(cls._from_ast_kwargs(ast, **kwargs))
return cls.from_ast(ast, **kwargs)
def _repr_template(self):
dct = self.to_dict()
dct['__name__'] = get_typename(self)
dct['__mod__'] = get_mod(self)
template = self._opts.repr_template
return template.format(**dct)
def _repr_template(self):
dct = self.to_dict()
dct['__name__'] = get_typename(self)
dct['__mod__'] = get_mod(self)
template = self._opts.repr_template
return template.format(**dct)
def from_ast(ast, **kwargs):
try:
cls = AST_REGISTRY[type(ast)]
except KeyError:
raise AstUnsupported(get_typename(ast))
kwargs.update(cls._from_ast_kwargs(ast, **kwargs))
return cls.from_ast(ast, **kwargs)
def search_rootward(self,
node=do_nothing,
stop_test=do_nothing,
_return=identity,
current_node='root',
**kwargs):
self._check_search_kwarg_types(kwargs)
if current_node == 'root':
current_node = self.root
node(current_node)
if stop_test(current_node):
return _return(current_node)
for nodetype, function in kwargs.items():
if get_typename(current_node) == nodetype:
function(current_node)
if current_node is self.root:
return
parent = current_node.parent()
return self.search_rootward(node, stop_test, _return, parent, **kwargs)
def estr(self, **kwargs):
parts = [
"{}: {}".format(estr(key, **kwargs), estr(value, **kwargs))
for key, value in self.obj.items()
]
ret = '{' + ', '.join(parts) + '}'
ret = '{}({})'.format(get_typename(self.obj), ret)
return escape_for_eval(ret)
def __repr__(self):
if self._opts.repr_template:
return self._repr_template()
out = '<' + get_mod(self) + '.' + get_typename(self) + ' '
out += str(self.to_dict(exclude=['repr_exclude']))
out += '>'
return out
def __repr__(self):
if self._opts.repr_template:
return self._repr_template()
out = '<' + get_mod(self) + '.' + get_typename(self) + ' '
out += str(self.to_dict(exclude=['repr_exclude']))
out += '>'
return out
def _register_ast(cls):
if cls._class_data.dct.get('ast', None) is None:
cls.ast = getattr(ast, get_typename(cls), None)
key = cls.ast
if key is not None and key is not NoAST:
if key in AST_REGISTRY:
raise TypeError("Class already registered for ast node '{}'"
.format(key))
AST_REGISTRY[key] = cls
def func(obj, *args, **kwargs):
logger = kwargs.get('logger', None)
if logger:
event = self.event_type(s=get_typename(obj), obj=obj)
logger.push(event)
ret = f(obj, *args, **kwargs)
if logger:
event.ret = ret
logger.pop()
return ret
def _register_ast(cls):
if cls._class_data.dct.get('ast', None) is None:
cls.ast = getattr(ast, get_typename(cls), None)
key = cls.ast
if key is not None and key is not NoAST:
if key in AST_REGISTRY:
raise TypeError(
"Class already registered for ast node '{}'".format(key))
AST_REGISTRY[key] = cls
def func(obj, *args, **kwargs):
logger = kwargs.get('logger', None)
if logger:
event = self.event_type(s=get_typename(obj), obj=obj)
logger.push(event)
ret = f(obj, *args, **kwargs)
if logger:
event.ret = ret
logger.pop()
return ret
def istr(self, pretty=False, indent=0, toplevel=False):
'''Returns a string that, if evaluated, produces an equivalent object.'''
ret = '{}('.format(get_typename(self))
if pretty and toplevel and indent:
ret = (' ' * indent) + ret
base = ','
if pretty:
indent += len(ret)
base += '\n' + ' ' * indent
else:
base += ' '
ret += self._istr_attrs(base, pretty, indent) + ')'
return ret
def istr(self, pretty=False, indent=0, toplevel=False):
'''Returns a string that, if evaluated, produces an equivalent object.'''
ret = '{}('.format(get_typename(self))
if pretty and toplevel and indent:
ret = (' ' * indent) + ret
base = ','
if pretty:
indent += len(ret)
base += '\n' + ' ' * indent
else:
base += ' '
ret += self._istr_attrs(base, pretty, indent) + ')'
return ret
def __init__(self, *args):
super(TypeMeta, self).__init__(*args)
# Prevent erroneous type registrations
if self.type is object and get_typename(self) != 'Type':
self.type = None
# Register type
if self.type is not None:
TYPE_REGISTRY[self.type] = self
# Populate ser_kwargmap as needed
if self.ser_kwargs and not self.ser_kwargmap:
for kwarg in self.ser_kwargs:
if kwarg not in self.ser_kwargmap.values():
self.ser_kwargmap[kwarg] = kwarg
def _generate_documentation_signature(cls, attrs):
sig = get_typename(cls) + '('
strs = []
for attr in attrs:
obj = cls._attrs[attr]
s = attr
if obj.default:
s += '=' + str(obj.default)
if obj.optional:
s = '[' + s + ']'
strs.append(s)
strs.append('**kwargs')
sig += ', '.join(strs)
sig += ')'
return sig
def _generate_documentation_signature(cls, attrs):
sig = get_typename(cls) + '('
strs = []
for attr in attrs:
obj = cls._attrs[attr]
s = attr
if obj.default:
s += '=' + str(obj.default)
if obj.optional:
s = '[' + s + ']'
strs.append(s)
strs.append('**kwargs')
sig += ', '.join(strs)
sig += ')'
return sig
def depth_first(self, node = do_nothing,
stop_test = do_nothing,
_return = identity,
current_node = 'root',
**kwargs):
self._check_search_kwarg_types(kwargs)
if current_node == 'root':
current_node = self.root
node(current_node)
if stop_test(current_node):
return _return(current_node)
for nodetype, function in kwargs.items():
if get_typename(current_node) == nodetype:
function(current_node)
for child in current_node.children():
ret = self.depth_first(node, stop_test, _return, child, **kwargs)
if ret:
return ret
def depth_first(self,
node=do_nothing,
stop_test=do_nothing,
_return=identity,
current_node='root',
**kwargs):
self._check_search_kwarg_types(kwargs)
if current_node == 'root':
current_node = self.root
node(current_node)
if stop_test(current_node):
return _return(current_node)
for nodetype, function in kwargs.items():
if get_typename(current_node) == nodetype:
function(current_node)
for child in current_node.children():
ret = self.depth_first(node, stop_test, _return, child, **kwargs)
if ret:
return ret
def search_rootward(self, node = do_nothing,
stop_test = do_nothing,
_return = identity,
current_node = 'root',
**kwargs):
self._check_search_kwarg_types(kwargs)
if current_node == 'root':
current_node = self.root
node(current_node)
if stop_test(current_node):
return _return(current_node)
for nodetype, function in kwargs.items():
if get_typename(current_node) == nodetype:
function(current_node)
if current_node is self.root:
return
parent = current_node.parent()
return self.search_rootward(node, stop_test, _return, parent, **kwargs)
def _plaintext(self, **kwargs):
return get_typename(self) + '(' + self.s
def _estr(self, **kwargs):
kwargs = {attr: estr(val) for attr, val in pairs(self, **kwargs)}
argstr = ','.join('{}={}'.format(attr, val) for attr, val in kwargs.items())
return '{}({})'.format(get_typename(self), argstr)
def _plaintext(self, **kwargs):
return get_typename(self) + '(' + self.s
def display(self, **kwargs):
return 'ClassWrapper({})'.format(get_typename(self.type))
def emit(self, **kwargs):
ret = self._indent(**kwargs)
ret += get_typename(self).lower()
return ret
def estr(self, **kwargs):
parts = [estr(item, **kwargs) for item in self.obj]
ret = '[' + ', '.join(parts) + ']'
ret = '{}({})'.format(get_typename(self.obj), ret)
return escape_for_eval(ret)
def _estr(self, **kwargs):
kwargs = {attr: estr(val) for attr, val in pairs(self, **kwargs)}
argstr = ','.join('{}={}'.format(attr, val)
for attr, val in kwargs.items())
return '{}({})'.format(get_typename(self), argstr)
def tree_tst_1(treecls):
cls = treecls._attrs.types['root'].type
clsname = get_typename(cls)
n1 = cls(_name='n1', _id=0)
n2 = cls(_name='n2', _id=1)
n3 = cls(_name='n3', _id=2)
n4 = cls(_name='n4', _id=3)
n5 = cls(_name='n5', _id=4)
n6 = cls(_name='n6', _id=5)
n1.add_child(n2)
n1.add_child(n3)
assert list(n1.siblings()) == []
assert list(n2.siblings()) == [n3]
assert list(n3.siblings()) == [n2]
obj = treecls(n1)
check_idempotence(obj)
assert obj.nodes == [n1, n2, n3]
assert obj.node_types == [clsname]
assert obj.id_dict == {0: n1, 1: n2, 2: n3}
assert obj.type_dict == {clsname: [n1, n2, n3]}
assert_raises(TreeError, obj.add_node, n3)
assert_raises(TreeError, obj.add_node, n4, parent=n5)
obj.add_node(n4, parent=n3)
assert n4 in obj.nodes
assert n4 in n3._children
assert n4._parent is n3
assert_raises(TreeError, obj.add_node, n5, parent_id=100)
obj.add_node(n5, parent_id=1)
assert n5 in obj.nodes
assert n5 in n2._children
assert n5._parent is n2
obj.add_node(n6)
assert n6 in obj.nodes
assert n6 in n5._children
assert n6._parent is n5
assert obj.nodes == [n1, n2, n3, n4, n5, n6]
assert obj.node_types == [clsname]
assert obj.id_dict == {0: n1, 1: n2, 2: n3, 3: n4, 4: n5, 5: n6}
assert obj.type_dict == {clsname: [n1, n2, n3, n4, n5, n6]}
for _id, node in enumerate([n1, n2, n3, n4, n5, n6]):
assert obj.get_node_by_id(_id) == obj._get_node_by_id(_id)
assert obj.get_node_by_id(_id) == node
assert obj.get_node_by_id(100) is None
assert obj.get_node_by_id(-1) is None
assert_raises(TypeError, obj.depth_first, FooType=do_nothing)
assert_raises(TypeError, obj._check_search_kwarg_types, {Tst2: do_nothing})
assert_raises(TypeError, obj._check_search_kwarg_types, {0: do_nothing})
assert list(n1.descendants()) == [n2, n5, n6, n3, n4]
accum = []
def collect(node):
accum.append(node._id)
obj.depth_first(collect)
assert accum == [0, 1, 4, 5, 2, 3]
accum = []
obj.depth_first(**{clsname: collect})
assert accum == [0, 1, 4, 5, 2, 3]
accum = []
obj.search_rootward(collect)
assert accum == [0]
accum = []
obj.search_rootward(**{'current_node': n5, clsname: collect})
assert accum == [4, 1, 0]
def stop(node):
return node._id == 3
def get(node):
return node._name
assert obj.depth_first(stop_test=stop, _return=get) == 'n4'
assert obj.search_rootward(stop_test=stop, _return=get) is None
assert obj.search_rootward(current_node=n4, stop_test=stop,
_return=get) == 'n4'
assert obj.search_rootward(current_node=n6, stop_test=stop,
_return=get) is None
n7 = cls(_name='n7', _id=6)
n8 = cls(_name='n8', _id=7)
n7.add_child(n8)
obj.replace_node(n5, n7)
assert n2._children == [n7]
assert n7._parent is n2
assert n7._children == [n8]
assert n8._parent is n7
assert n5._children == [n6]
assert n6._parent is n5
assert n5._parent is None
assert obj.nodes == [n1, n2, n3, n4, n7, n8]
assert obj.node_types == [clsname]
assert obj.id_dict == {0: n1, 1: n2, 2: n3, 3: n4, 6: n7, 7: n8}
assert obj.type_dict == {clsname: [n1, n2, n3, n4, n7, n8]}
assert_raises(TreeError, obj.remove_node, n5)
assert_raises(TreeError, obj.replace_node, n5, n7)
obj.remove_node(n2)
assert n1._children == [n3]
assert n2._parent is None
assert n2._children == [n7]
assert n7._parent is n2
assert obj.nodes == [n1, n3, n4]
assert obj.node_types == [clsname]
assert obj.id_dict == {0: n1, 2: n3, 3: n4}
assert obj.type_dict == {clsname: [n1, n3, n4]}
assert_raises(TreeError, obj.replace_node, n1, n7)
assert_raises(TreeError, obj.replace_node, n3, n7)
obj.replace_node(n1, n2)
assert n1._children == [n3]
assert n3._parent is n1
assert obj.root is n2
assert obj.nodes == [n2, n7, n8]
assert obj.node_types == [clsname]
assert obj.id_dict == {1: n2, 6: n7, 7: n8}
assert obj.type_dict == {clsname: [n2, n7, n8]}
obj.rebuild()
assert obj.root is n2
assert obj.nodes == [n2, n7, n8]
assert obj.node_types == [clsname]
assert obj.id_dict == {1: n2, 6: n7, 7: n8}
assert obj.type_dict == {clsname: [n2, n7, n8]}
obj.remove_node(n2)
assert obj.root is None
assert obj.nodes == []
assert obj.node_types == []
assert obj.id_dict == {}
assert obj.type_dict == {}
def _estr(self, **kwargs):
a = estr(self.a, **kwargs)
b = estr(self.b, **kwargs)
return '{}({},{})'.format(get_typename(self), a, b)
def _rstr(self, **kwargs):
return '{}({},{})'.format(get_typename(self.obj),
rstr(self.obj.a),
rstr(self.obj.b))
def estr(self, **kwargs):
parts = [estr(item, **kwargs) for item in self.obj]
ret = '[' + ', '.join(parts) + ']'
ret = '{}({})'.format(get_typename(self.obj), ret)
return escape_for_eval(ret)
def emit(self, **kwargs):
ret = self._indent(**kwargs)
ret += get_typename(self).lower()
return ret
def display(self, **kwargs):
return 'ClassWrapper({})'.format(get_typename(self.type))
def estr(self, **kwargs):
parts = ["{}: {}".format(estr(key, **kwargs), estr(value, **kwargs))
for key, value in self.obj.items()]
ret = '{' + ', '.join(parts) + '}'
ret = '{}({})'.format(get_typename(self.obj), ret)
return escape_for_eval(ret)
def tree_tst_1(treecls):
cls = treecls._attrs.types['root'].type
clsname = get_typename(cls)
n1 = cls(_name='n1', _id=0)
n2 = cls(_name='n2', _id=1)
n3 = cls(_name='n3', _id=2)
n4 = cls(_name='n4', _id=3)
n5 = cls(_name='n5', _id=4)
n6 = cls(_name='n6', _id=5)
n1.add_child(n2)
n1.add_child(n3)
assert list(n1.siblings()) == []
assert list(n2.siblings()) == [n3]
assert list(n3.siblings()) == [n2]
obj = treecls(n1)
check_idempotence(obj)
assert obj.nodes == [n1, n2, n3]
assert obj.node_types == [clsname]
assert obj.id_dict == {0: n1, 1: n2, 2: n3}
assert obj.type_dict == {clsname: [n1, n2, n3]}
assert_raises(TreeError, obj.add_node, n3)
assert_raises(TreeError, obj.add_node, n4, parent=n5)
obj.add_node(n4, parent=n3)
assert n4 in obj.nodes
assert n4 in n3._children
assert n4._parent is n3
assert_raises(TreeError, obj.add_node, n5, parent_id=100)
obj.add_node(n5, parent_id=1)
assert n5 in obj.nodes
assert n5 in n2._children
assert n5._parent is n2
obj.add_node(n6)
assert n6 in obj.nodes
assert n6 in n5._children
assert n6._parent is n5
assert obj.nodes == [n1, n2, n3, n4, n5, n6]
assert obj.node_types == [clsname]
assert obj.id_dict == {0: n1, 1: n2, 2: n3, 3:n4, 4:n5, 5:n6}
assert obj.type_dict == {clsname: [n1, n2, n3, n4, n5, n6]}
for _id,node in enumerate([n1, n2, n3, n4, n5, n6]):
assert obj.get_node_by_id(_id) == obj._get_node_by_id(_id)
assert obj.get_node_by_id(_id) == node
assert obj.get_node_by_id(100) is None
assert obj.get_node_by_id(-1) is None
assert_raises(TypeError, obj.depth_first, FooType = do_nothing)
assert_raises(TypeError, obj._check_search_kwarg_types,
{Tst2: do_nothing})
assert_raises(TypeError, obj._check_search_kwarg_types, {0: do_nothing})
assert list(n1.descendants()) == [n2, n5, n6, n3, n4]
accum = []
def collect(node):
accum.append(node._id)
obj.depth_first(collect)
assert accum == [0, 1, 4, 5, 2, 3]
accum = []
obj.depth_first(**{clsname: collect})
assert accum == [0, 1, 4, 5, 2, 3]
accum = []
obj.search_rootward(collect)
assert accum == [0]
accum = []
obj.search_rootward(**{'current_node': n5,
clsname: collect})
assert accum == [4, 1, 0]
def stop(node):
return node._id == 3
def get(node):
return node._name
assert obj.depth_first(stop_test = stop, _return = get) == 'n4'
assert obj.search_rootward(stop_test = stop, _return = get) is None
assert obj.search_rootward(current_node = n4, stop_test = stop,
_return = get) == 'n4'
assert obj.search_rootward(current_node = n6, stop_test = stop,
_return = get) is None
n7 = cls(_name='n7', _id=6)
n8 = cls(_name='n8', _id=7)
n7.add_child(n8)
obj.replace_node(n5, n7)
assert n2._children == [n7]
assert n7._parent is n2
assert n7._children == [n8]
assert n8._parent is n7
assert n5._children == [n6]
assert n6._parent is n5
assert n5._parent is None
assert obj.nodes == [n1, n2, n3, n4, n7, n8]
assert obj.node_types == [clsname]
assert obj.id_dict == {0: n1, 1: n2, 2: n3, 3:n4, 6:n7, 7:n8}
assert obj.type_dict == {clsname: [n1, n2, n3, n4, n7, n8]}
assert_raises(TreeError, obj.remove_node, n5)
assert_raises(TreeError, obj.replace_node, n5, n7)
obj.remove_node(n2)
assert n1._children == [n3]
assert n2._parent is None
assert n2._children == [n7]
assert n7._parent is n2
assert obj.nodes == [n1, n3, n4]
assert obj.node_types == [clsname]
assert obj.id_dict == {0: n1, 2: n3, 3:n4}
assert obj.type_dict == {clsname: [n1, n3, n4]}
assert_raises(TreeError, obj.replace_node, n1, n7)
assert_raises(TreeError, obj.replace_node, n3, n7)
obj.replace_node(n1, n2)
assert n1._children == [n3]
assert n3._parent is n1
assert obj.root is n2
assert obj.nodes == [n2, n7, n8]
assert obj.node_types == [clsname]
assert obj.id_dict == {1: n2, 6: n7, 7:n8}
assert obj.type_dict == {clsname: [n2, n7, n8]}
obj.rebuild()
assert obj.root is n2
assert obj.nodes == [n2, n7, n8]
assert obj.node_types == [clsname]
assert obj.id_dict == {1: n2, 6: n7, 7:n8}
assert obj.type_dict == {clsname: [n2, n7, n8]}
obj.remove_node(n2)
assert obj.root is None
assert obj.nodes == []
assert obj.node_types == []
assert obj.id_dict == {}
assert obj.type_dict == {}
def _rstr(self, **kwargs):
return '{}({},{})'.format(get_typename(self.obj), rstr(self.obj.a),
rstr(self.obj.b))
def _estr(self, **kwargs):
a = estr(self.a, **kwargs)
b = estr(self.b, **kwargs)
return '{}({},{})'.format(get_typename(self), a, b)
def display(self):
return get_typename(self.type)
def estr(self, **kwargs):
encoding = kwargs.get('encoding', 'utf-8')
objstr = escape_for_eval(quote_string(self.obj.encode(encoding)))
objstr += '.decode("{}")'.format(encoding)
return '{}({})'.format(get_typename(self.obj), objstr)
