def expand_group(node):
if node.type.group is None or node.value is None:
return
value = str(node.value)
query = {
'query': {
'term': {
node.type.group: value
}
},
'_source': {
'includes': ['schema', 'properties']
}
}
for res in scan(es, index=entities_index(), query=query):
entity_id = res.get('_id')
source = res.get('_source')
properties = source.get('properties')
schema = model.get(source.get('schema'))
for prop in schema.properties.values():
if prop.type != node.type:
continue
values = properties.get(prop.name)
values = node.type.normalize_set(values)
if value not in values:
continue
if prop.reverse:
yield Link(node, prop.reverse, entity_id)
else:
yield Link(node, prop, entity_id, inverted=True)
def expand_node(node):
if node.type == registry.entity:
yield from expand_entity(node.value)
for entity_id, prop in iter_value_entities(node.type, node.value):
if prop.reverse:
yield Link(node, prop.reverse, entity_id)
else:
yield Link(node, prop, entity_id, inverted=True)
def test_base(self):
prop = model.get_qname('Thing:name')
node = Node(registry.entity, 'banana')
link = Link(node, prop, "Theodore Böln")
assert link.subject == node
value = link.to_tuple()
other = link.from_tuple(model, value)
assert other == link, (link, other)
assert hash(other) == hash(link)
assert repr(other) == repr(link)
def load_links(node):
degree_key = typed_key(node, DEGREE)
if cache.kv.get(degree_key) is None:
raise CacheMiss()
key = typed_key(node)
for packed in cache.kv.lrange(key, 0, -1):
data = msgpack.unpackb(packed, raw=False)
data = tuple((node, *data))
link = Link.from_tuple(model, data)
if link is not None:
yield link
def expand_entity(entity):
"""Transform an entity into a set of statements. This can
accept either an entity object or an entity ID."""
if not is_mapping(entity):
entity = get_entity(entity)
if entity is None:
return
proxy = model.get_proxy(entity)
yield from proxy.links
# TODO: factor out inference
thing = model.get(Entity.THING)
if proxy.schema.is_a(thing):
sameAs = thing.get("sameAs")
for (score, _, other) in xref_item(proxy):
yield Link(proxy.node,
sameAs,
other.id,
weight=score,
inferred=True)
def test_invert(self):
prop = model.get_qname('Thing:name')
node = Node(registry.entity, 'banana')
link = Link(node, prop, "Theodore")
assert not link.inverted
inv = link.invert()
assert inv.inverted
assert inv.rdf() is None
banana = Node(registry.entity, 'banana')
peach = Node(registry.entity, 'peach')
prop = model.get_qname('Thing:sameAs')
link = Link(banana, prop, peach.value)
inv = link.invert()
assert inv.subject == peach
assert inv.value_node == banana
assert inv.prop == link.prop
def links(self):
node = self.node
if node is None:
return
for prop, value in self.itervalues():
yield Link(node, prop, value)
def test_graph(self):
g = DiGraph()
proxy = model.get_proxy(ENTITY)
node = proxy.node
self.assertEqual(str(node), node.id)
for link in proxy.links:
link.to_digraph(g)
self.assertEqual(g.number_of_edges(), 8)
self.assertEqual(g.number_of_nodes(), 9)
self.assertIn(node.id, g.nodes)
prop = model.get_qname('Thing:name')
link = Link(Node(registry.name, 'Bob'), prop, proxy.id, inverted=True)
link.to_digraph(g)
self.assertEqual(g.number_of_edges(), 9)
link = Link(node, prop, 'Blub', weight=0)
link.to_digraph(g)
self.assertEqual(g.number_of_edges(), 9)
prop = model.get_qname('Thing:summary')
link = Link(node, prop, 'This is a text')
link.to_digraph(g)
self.assertEqual(g.number_of_edges(), 9)