def nodes2str(edge):
"""Convert a collection of nodes to a string representation (no outer parenthesis)."""
node_strings = []
for node in edge:
if sym.sym_type(node) == sym.SymbolType.EDGE:
node_strings.append(edge2str(node))
else:
node_strings.append(str(node))
return ' '.join(node_strings)
def edge2str(edge, namespaces=True):
"""Convert an edge to its string representation."""
if sym.sym_type(edge) == sym.SymbolType.EDGE:
return '(%s)' % nodes2str(edge, namespaces)
else:
if namespaces:
return str(edge)
else:
return str(sym.root(edge))
def symbols(edge):
"""Return set of symbols contained in edge."""
if sym.sym_type(edge) == sym.SymbolType.EDGE:
symbs = set()
for entity in edge:
for symb in symbols(entity):
symbs.add(symb)
return symbs
else:
return {edge}
def depth(edge):
"""Returns maximal depth of the edge, a symbol has depth 0"""
if sym.sym_type(edge) == sym.SymbolType.EDGE:
max_d = 0
for item in edge:
d = depth(item)
if d > max_d:
max_d = d
return max_d + 1
else:
return 0
def nodes2str(edge, namespaces=True):
"""Convert a collection of nodes to a string representation (no outer parenthesis)."""
node_strings = []
for node in edge:
if sym.sym_type(node) == sym.SymbolType.EDGE:
node_strings.append(edge2str(node, namespaces))
else:
if namespaces:
node_strings.append(str(node))
else:
node_strings.append(str(sym.root(node)))
return ' '.join(node_strings)
def synonyms(hg, symbol):
syns1 = [
edge[2]
for edge in hg.pattern2edges((const.are_synonyms, symbol, None))
if sym.sym_type(edge[2]) == SymbolType.CONCEPT
]
syns2 = [
edge[1]
for edge in hg.pattern2edges((const.are_synonyms, None, symbol))
if sym.sym_type(edge[1]) == SymbolType.CONCEPT
]
syns3 = [
edge[2]
for edge in hg.pattern2edges((const.have_same_lemma, symbol, None))
if sym.sym_type(edge[2]) == SymbolType.CONCEPT
]
syns4 = [
edge[1]
for edge in hg.pattern2edges((const.have_same_lemma, None, symbol))
if sym.sym_type(edge[1]) == SymbolType.CONCEPT
]
return {symbol}.union(syns1).union(syns2).union(syns3).union(syns4)
def html(hg, eid):
vertex = ed.str2edge(eid)
if sym.sym_type(vertex) == sym.SymbolType.EDGE:
title = edge_html(hg, vertex)
else:
title = '<h1>%s</h1>' % sym.symbol2str(eid)
return """
<div class="container" role="main">
<div class="page-header">
%s
<h4>%s</h4>
</div>
%s
</div>
""" % (title, eid, edges_html(hg, vertex))
def add(self, edge, timestamp=-1):
"""Adds an edge to the hypergraph if it does not exist yet."""
edge_key = vertex2key(edge)
if not self.exists_key(edge_key):
self.inc_counter('edge_count')
self.inc_counter('total_degree', by=len(edge))
for vert in edge:
vert_key = vertex2key(vert)
if not self.inc_attribute_key(vert_key, 'd'):
if sym.sym_type(vert) == sym.SymbolType.EDGE:
self.inc_counter('edge_count')
else:
self.inc_counter('symbol_count')
self.add_key(vert_key, {'d': 1, 't': timestamp})
self.add_key(edge_key, {'d': 0, 't': timestamp})
self.write_edge_permutations(edge)
return edge
def edge_to_visual(hg, edge, depth):
rels = edge[0]
entities = edge[1:]
if sym.sym_type(rels) != sym.SymbolType.EDGE:
rels = (rels, )
visual_edge = []
if len(entities) == 1 and len(rels) == 1:
visual_edge.append(
edge_html(hg,
rels[0],
show_degree=False,
outer=False,
rel=True,
depth=depth + 1))
visual_edge.append(
edge_html(hg,
entities[0],
show_degree=False,
outer=False,
rel=False,
depth=depth + 1))
else:
for i in range(len(entities)):
visual_edge.append(
edge_html(hg,
entities[i],
show_degree=False,
outer=False,
rel=False,
depth=depth + 1))
if len(rels) > i:
visual_edge.append(
edge_html(hg,
rels[i],
show_degree=False,
outer=False,
rel=True,
depth=depth + 1))
if depth > 0:
zoom_in_html = '<a href="/vertex?id=%s">%s</a>'\
% (urllib.parse.quote_plus(ed.edge2str(edge)),
'<span class="glyphicon glyphicon-zoom-in zoom-in" aria-hidden="true" />')
visual_edge.append(zoom_in_html)
return visual_edge
def edge_html(hg, edge, show_degree=False, outer=True, rel=False, depth=0):
if sym.sym_type(edge) == sym.SymbolType.EDGE:
depth_class = 'depth%s' % str(depth)
html_edge = '<div class="hyperedge %s">%s</div>' % (
depth_class, ' '.join(edge_to_visual(hg, edge, depth)))
if outer:
extra_html = ''
if show_degree:
degree = hg.degree(edge)
extra_html = '<span class="badge">%s</span>' % degree
html_outer = '<a href="/vertex?id=%s">%s</a>'\
% (urllib.parse.quote_plus(ed.edge2str(edge)),
'<span class="glyphicon glyphicon-zoom-out zoom-out" aria-hidden="true" />')
html_edge = '<div class="outer-hyperedge">%s%s%s</div>' % (
html_edge, html_outer, extra_html)
return html_edge
else:
return symbol_html(edge, rel)
def edge2str(edge):
"""Convert an edge to its string representation."""
if sym.sym_type(edge) == sym.SymbolType.EDGE:
return '(%s)' % nodes2str(edge)
else:
return str(edge)
def test_sym_type(self):
self.assertEqual(sym.sym_type('graphbrain/1'), sym.SymbolType.CONCEPT)
self.assertEqual(sym.sym_type(42), sym.SymbolType.INTEGER)
self.assertEqual(sym.sym_type(-7.9), sym.SymbolType.FLOAT)
self.assertEqual(sym.sym_type('http://graphbrain.org'), sym.SymbolType.URL)
self.assertEqual(sym.sym_type('https://graphbrain.org'), sym.SymbolType.URL)
def test_sym_type(self):
self.assertEqual(sym.sym_type('graphbrain/1'), sym.SymbolType.CONCEPT)
self.assertEqual(sym.sym_type(42), sym.SymbolType.INTEGER)
self.assertEqual(sym.sym_type(-7.9), sym.SymbolType.FLOAT)
self.assertEqual(sym.sym_type('http://graphbrain.org'), sym.SymbolType.URL)
self.assertEqual(sym.sym_type('https://graphbrain.org'), sym.SymbolType.URL)
