def _search_cache(tx, alist_to_instantiate: Alist, attribute_to_instantiate,
search_attributes) -> (bool, list):
alists = []
conditions = ""
resultStatus = False
if not attribute_to_instantiate:
return (resultStatus, [alist_to_instantiate])
conditions = " AND ".join([
f"n.{x}='{alist_to_instantiate.instantiation_value(x)}'"
for x in search_attributes
])
results = tx.run("MATCH (n:Alist)" f"WHERE {conditions}" "RETURN n")
for node in results:
if node[0]:
try:
alist = Alist(**node[0]._properties)
if alist.is_instantiated(attribute_to_instantiate):
alist.set(
attribute_to_instantiate,
alist.instantiation_value(attribute_to_instantiate))
alist.attributes.pop('sessionId', None)
alist.attributes.pop('parentId', None)
alist.attributes.pop('src', None)
alists.append(alist)
resultStatus = True
except:
print("Error during alist creation from search result")
return (resultStatus, alists)
def test_isInstantiated2(self):
alist = Alist(
**{
tt.ID: '1',
tt.SUBJECT: 'Africa',
tt.PROPERTY: 'P1082',
tt.OBJECT: '?x',
tt.TIME: '2010',
tt.OPVAR: '?x',
tt.COST: 1
})
alist.set('#d', 34)
results = [
alist.is_instantiated(tt.SUBJECT),
alist.is_instantiated(tt.OBJECT),
alist.is_instantiated('#d')
]
self.assertEqual(results, [True, False, True],
"should result in list [True, False, True].")
def test_isInstantiated(self):
alist = Alist(
**{
tt.ID: '1',
tt.SUBJECT: '$y',
tt.PROPERTY: 'P1082',
tt.OBJECT: '?x',
tt.TIME: '2010',
tt.OPVAR: '?x',
tt.COST: 1,
'$y': 'Ghana'
})
result = alist.is_instantiated(tt.SUBJECT)
self.assertTrue(result)
def run_frank(self, alist: Alist):
""" Run the FRANK algorithm for an alist
Args
----
alist : Alist
Return
------
Return True if the instantiation of the project variable of an alist
is propagated to the root node.
Notes
-----
For the given alist, attempt to instantiate projection
variable. If instantiation is successful, attempt to reduce
Else decompose and add new children to queue
"""
self.last_heartbeat = time.time()
curr_propagated_alists = []
self.max_depth = alist.depth
if alist.state is states.PRUNED:
self.write_trace(
f"{pcol.RED}ignore pruned {alist.id}{pcol.RESET}-{alist}{pcol.RESETALL}"
)
return propagated_alists
bool_result = False
proj_vars = alist.projection_variables()
proj_instantiated = True
if proj_vars:
for p, _ in proj_vars.items():
proj_instantiated = proj_instantiated and alist.is_instantiated(
p)
agg_vars = alist.get(tt.OPVAR).split(' ')
agg_instantiated = True
if agg_vars:
for v in agg_vars:
agg_instantiated = agg_instantiated and alist.is_instantiated(
v)
if agg_instantiated:
bool_result = True
if bool_result:
alist.state = states.REDUCIBLE
self.G.add_alist(alist)
# if OPVAR not instantiated, search KB
elif not bool_result:
bool_result = self.search_kb(alist)
# search kb for the variable instantiation
if bool_result:
is_propagated = False
if alist.state != states.REDUCIBLE: # if in reducible state, don't change
alist.state = states.EXPLORED
self.G.add_alist(alist)
if agg_instantiated and proj_instantiated:
alist.state = states.REDUCIBLE
self.G.add_alist(alist)
if self.G.child_ids(alist.id):
is_propagated = self.propagate(self.G.child_ids(alist.id)[0])
else:
is_propagated = self.propagate(
self.G.child_ids(self.G.parent_ids(alist.id)[0])[0])
if is_propagated:
prop_alist = self.G.alist(self.root.id)
self.write_trace(
f"{pcol.CYAN}intermediate ans: "
f"{pcol.RESET}-{prop_alist}{pcol.RESETALL}",
loglevel=processLog.LogLevel.ANSWER)
curr_propagated_alists.append(prop_alist.copy())
self.propagated_alists.append(prop_alist.copy())
else:
alist.state = states.EXPLORED
self.G.add_alist(alist)
for mapOp in self.get_map_strategy(alist):
self.decompose(alist, mapOp)
return curr_propagated_alists
