def reconcile_query(dataset: Dataset, query: Dict[str, Any]):
"""Reconcile operation for a single query."""
# log.info("Reconcile: %r", query)
limit = int(query.get("limit", 5))
type = query.get("type", settings.BASE_SCHEMA)
proxy = Entity(type)
proxy.add("name", query.get("query"))
proxy.add("notes", query.get("query"))
for p in query.get("properties", []):
prop = model.get_qname(p.get("pid"))
if prop is None:
continue
try:
proxy.add_cast(prop.schema, prop.name, p.get("v"), fuzzy=True)
except InvalidData:
log.exception("Invalid property is set.")
results = []
# log.info("QUERY %r %s", proxy.to_dict(), limit)
for result, score in match_entities(dataset,
proxy,
limit=limit,
fuzzy=True):
results.append(get_freebase_entity(result, score))
return {"result": results}
def test_invert(self):
prop = model.get_qname('Thing:name')
node = Node(registry.entity, 'banana')
stmt = Statement(node, prop, "Theodore")
assert not stmt.inverted
inv = stmt.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')
stmt = Statement(banana, prop, peach.value)
inv = stmt.invert()
assert inv.subject == peach
assert inv.value_node == banana
assert inv.prop == stmt.prop
def test_base_functions(self):
data = dict(ENTITY)
data["properties"]["banana"] = ["foo"]
proxy = EntityProxy.from_dict(model, data)
assert "test" in repr(proxy), repr(proxy)
assert hash(proxy) == hash(proxy.id)
assert proxy.get("name") == ["Ralph Tester"]
assert proxy.first("name") == "Ralph Tester"
prop = model.get_qname("Thing:name")
assert proxy.get(prop) == ["Ralph Tester"]
assert proxy.caption == "Ralph Tester"
assert str(proxy) == "Ralph Tester"
name = "Ralph the Great"
proxy.add("name", name)
assert len(proxy.get("name")) == 2
proxy.add("name", None)
assert len(proxy.get("name")) == 2
proxy.add("name", "")
assert len(proxy.get("name")) == 2
proxy.add("name", [""])
assert len(proxy.get("name")) == 2
proxy.add("name", {"name": "banana"})
assert len(proxy.get("name")) == 3, proxy.get("name")
assert name in proxy.get("name")
assert name in proxy.names, proxy.names
with raises(InvalidData):
proxy.add("banana", "yellow")
proxy.add("banana", "yellow", quiet=True)
mem = model.make_entity("Membership")
mem.id = "foo"
with raises(InvalidData):
proxy.add("directorshipDirector", mem)
with raises(InvalidData):
proxy.add("sameAs", proxy)
with raises(InvalidData):
proxy.get("banana")
assert [] == proxy.get("banana", quiet=True)
with raises(InvalidData):
proxy.first("banana")
assert proxy.first("banana", quiet=True) is None
assert len(proxy.get("nationality")) == 0
double = model.get_proxy(proxy)
assert double == proxy
proxy.add("banana", name, quiet=True)
with raises(InvalidData):
proxy.add("banana", name)
with raises(InvalidData):
EntityProxy.from_dict(model, {})
def test_base_functions(self):
proxy = EntityProxy.from_dict(model, ENTITY)
assert 'test' in repr(proxy), repr(proxy)
assert hash(proxy) == hash(proxy.id)
assert proxy.get('name') == ['Ralph Tester']
assert proxy.first('name') == 'Ralph Tester'
prop = model.get_qname('Thing:name')
assert proxy.get(prop) == ['Ralph Tester']
assert proxy.caption == 'Ralph Tester'
assert str(proxy) == 'Ralph Tester'
name = 'Ralph the Great'
proxy.add('name', name)
assert len(proxy.get('name')) == 2
proxy.add('name', None)
assert len(proxy.get('name')) == 2
proxy.add('name', '')
assert len(proxy.get('name')) == 2
proxy.add('name', [''])
assert len(proxy.get('name')) == 2
proxy.add('name', {'name': 'banana'}, cleaned=True)
assert len(proxy.get('name')) == 2
assert name in proxy.get('name')
assert name in proxy.names, proxy.names
with assert_raises(InvalidData):
proxy.add('banana', 'yellow')
proxy.add('banana', 'yellow', quiet=True)
mem = model.make_entity('Membership')
mem.id = 'foo'
with assert_raises(InvalidData):
proxy.add('directorshipDirector', mem)
with assert_raises(InvalidData):
proxy.add('sameAs', proxy)
with assert_raises(InvalidData):
proxy.get('banana')
assert [] == proxy.get('banana', quiet=True)
with assert_raises(InvalidData):
proxy.first('banana')
assert proxy.first('banana', quiet=True) is None
assert len(proxy.get('nationality')) == 0
double = EntityProxy.from_dict(model, proxy)
assert double == proxy
proxy.add('banana', name, quiet=True)
with assert_raises(InvalidData):
proxy.add('banana', name)
with assert_raises(InvalidData):
EntityProxy.from_dict(model, {})
def test_base(self):
prop = model.get_qname('Thing:name')
node = Node(registry.entity, 'banana')
stmt = Statement(node, prop, "Theodore Böln")
assert stmt.subject == node
value = stmt.to_tuple()
other = stmt.from_tuple(model, value)
assert other == stmt, (stmt, other)
assert hash(other) == hash(stmt)
assert repr(other) == repr(stmt)
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 test_adjacent(self):
graph = Graph(edge_types=registry.pivots)
graph.add(model.get_proxy(ENTITY))
graph.add(model.get_proxy(ENTITY2))
graph.add(model.get_proxy(REL))
graph.add(model.get_proxy(PASS))
node = Node(registry.entity, 'jodie')
adj = list(graph.get_adjacent(node))
assert len(adj) == 3, adj
node = Node(registry.entity, 'ralph')
adj = list(graph.get_adjacent(node))
assert len(adj) == 7, adj
node = Node(registry.entity, 'passpoat')
adj = list(graph.get_adjacent(node))
assert len(adj) == 2, adj
node = Node(registry.entity, 'passpoat')
prop = model.get_qname('Passport:holder')
adj = list(graph.get_adjacent(node, prop))
assert len(adj) == 1, adj
assert adj[0].source_prop == prop, adj[0].source_prop
assert adj[0].target_prop == prop.reverse, adj[0].target_prop
node = Node(registry.entity, 'jodie')
prop = model.get_qname('Person:familyPerson')
adj = list(graph.get_adjacent(node, prop))
assert len(adj) == 1, adj
assert adj[0].source_prop == prop, adj[0].source_prop
node = Node(registry.entity, 'ralph')
prop = model.get_qname('Person:familyRelative')
adj2 = list(graph.get_adjacent(node, prop))
assert len(adj2) == 1, adj2
assert adj2[0].target_prop == prop, adj2[0].target_prop
assert adj[0] == adj2[0], (adj[0], adj2[0])
assert adj[0].id in repr(adj[0]), repr(adj[0])
def test_adjacent(self):
graph = Graph(edge_types=registry.pivots)
graph.add(model.get_proxy(ENTITY, cleaned=False))
graph.add(model.get_proxy(ENTITY2, cleaned=False))
graph.add(model.get_proxy(REL, cleaned=False))
graph.add(model.get_proxy(PASS, cleaned=False))
node = Node(registry.entity, "jodie")
adj = list(graph.get_adjacent(node))
assert len(adj) == 3, adj
node = Node(registry.entity, "ralph")
adj = list(graph.get_adjacent(node))
assert len(adj) == 7, adj
node = Node(registry.entity, "passpoat")
adj = list(graph.get_adjacent(node))
assert len(adj) == 2, adj
node = Node(registry.entity, "passpoat")
prop = model.get_qname("Identification:holder")
adj = list(graph.get_adjacent(node, prop))
assert len(adj) == 1, adj
assert adj[0].source_prop == prop, adj[0].source_prop
assert adj[0].target_prop == prop.reverse, adj[0].target_prop
node = Node(registry.entity, "jodie")
prop = model.get_qname("Person:familyPerson")
adj = list(graph.get_adjacent(node, prop))
assert len(adj) == 1, adj
assert adj[0].source_prop == prop, adj[0].source_prop
node = Node(registry.entity, "ralph")
prop = model.get_qname("Person:familyRelative")
adj2 = list(graph.get_adjacent(node, prop))
assert len(adj2) == 1, adj2
assert adj2[0].target_prop == prop, adj2[0].target_prop
assert adj[0] == adj2[0], (adj[0], adj2[0])
assert adj[0].id in repr(adj[0]), repr(adj[0])
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)
def test_model_basics(self):
assert model.schemata['Thing'], model.schemata
thing = model.schemata['Thing']
assert thing == model.get(thing)
assert thing in list(model), list(model)
assert 'Person' in model.to_dict(), model.to_dict()
assert 'Thing' in model.to_dict(), model.to_dict()
with assert_raises(KeyError):
model['Banana']
assert model.get_qname('Thing:name') == thing.get('name')
props = list(model.properties)
assert len(props), props
assert thing.get('name') in props, props
def entity_references(entity, authz=None):
"""Given a particular entity, find all the references to it from other
entities, grouped by the property where they are used."""
schema = model.get(entity.get('schema'))
facets = []
for prop in model.properties:
if prop.type != registry.entity:
continue
if not schema.is_a(prop.range):
continue
index = entities_read_index(prop.schema)
field = 'properties.%s' % prop.name
value = entity.get('id')
facets.append((index, prop.qname, registry.entity.group, field, value))
res = _filters_faceted_query(facets, authz=authz)
for (qname, total) in res.items():
if total > 0:
yield (model.get_qname(qname), total)
def entity_references(entity, authz):
"""Given a particular entity, find all the references to it from other
entities, grouped by the property where they are used."""
schema = model.get(entity.get('schema'))
group = registry.entity.group
facets = []
for prop in model.properties:
if prop.type != registry.entity:
continue
if not schema.is_a(prop.range):
continue
index = entities_read_index(prop.schema)
field = 'properties.%s' % prop.name
value = entity.get('id')
facets.append((index, prop.qname, group, field, value))
res = _filters_faceted_query(authz, facets)
for (qname, total) in res.items():
if total > 0:
yield (model.get_qname(qname), total)
def test_model_basics(self):
assert model.schemata['Thing'], model.schemata
thing = model.schemata['Thing']
assert thing == model.get(thing)
assert thing in list(model), list(model)
data = model.to_dict()
assert 'schemata' in data, data
assert len(data['schemata']) == len(model.schemata)
assert 'Thing' in data['schemata']
assert 'types' in data, data
assert len(data['types']) == len(list(registry.types))
assert 'name' in data['types']
assert 'entity' in data['types']
with assert_raises(KeyError):
model['Banana']
assert model.get_qname('Thing:name') == thing.get('name')
props = list(model.properties)
assert len(props), props
assert thing.get('name') in props, props
def test_model_basics(self):
assert model.schemata["Thing"], model.schemata
thing = model.schemata["Thing"]
assert thing == model.get(thing)
assert thing in list(model), list(model)
data = model.to_dict()
assert "schemata" in data, data
assert len(data["schemata"]) == len(model.schemata)
assert "Thing" in data["schemata"]
assert "types" in data, data
assert len(data["types"]) == len(list(registry.types))
assert "name" in data["types"]
assert "entity" in data["types"]
with assert_raises(KeyError):
model["Banana"]
assert model.get_qname("Thing:name") == thing.get("name")
props = list(model.properties)
assert len(props), props
assert thing.get("name") in props, props
def iter_value_entities(type_, value):
value = stringify(value)
if type_.group is None or value is None:
return
key = cache.object_key(type(type_), value)
degree_key = cache.object_key(type(type_), value, 'deg1')
degree = cache.get(degree_key)
if degree is not None:
for item in cache.kv.sscan_iter(key):
qname, entity_id = item.decode('utf-8').split('@', 1)
prop = model.get_qname(qname)
yield entity_id, prop
else:
degree = 0
pipe = cache.kv.pipeline()
for entity_id, prop in _iter_value_entities(type_, value):
yield entity_id, prop
item = '@'.join((prop.qname, entity_id))
pipe.sadd(key, item)
degree += 1
pipe.set(degree_key, degree, ex=cache.EXPIRE)
pipe.execute()
def test_base_functions(self):
proxy = EntityProxy.from_dict(model, ENTITY)
assert 'test' in repr(proxy), repr(proxy)
assert hash(proxy) == hash(proxy.id)
assert proxy.get('name') == ['Ralph Tester']
prop = model.get_qname('Thing:name')
assert proxy.get(prop) == ['Ralph Tester']
assert proxy.caption == 'Ralph Tester'
assert str(proxy) == 'Ralph Tester'
name = 'Ralph the Great'
proxy.add('name', name)
assert len(proxy.get('name')) == 2
proxy.add('name', None)
assert len(proxy.get('name')) == 2
proxy.add('name', '')
assert len(proxy.get('name')) == 2
proxy.add('name', [''])
assert len(proxy.get('name')) == 2
assert name in proxy.get('name')
assert name in proxy.names, proxy.names
with assert_raises(InvalidData):
proxy.get('banana')
assert [] == proxy.get('banana', quiet=True)
assert len(proxy.get('nationality')) == 0
double = EntityProxy.from_dict(model, proxy)
assert double == proxy
proxy.add('banana', name, quiet=True)
with assert_raises(InvalidData):
proxy.add('banana', name)
with assert_raises(InvalidData):
EntityProxy.from_dict(model, {})
