def execute_entities(self, graph, query, ctx):
entities_link = query.fields_map['_entities']
query = entities_link.node
representations = entities_link.options['representations']
queue = Queue(self.executor)
task_set = queue.fork(None)
query_workflow = Query(queue, task_set, graph, query, Context(ctx))
type_ids_map = defaultdict(list)
for rep in representations:
typename = rep['__typename']
for key in get_keys(graph, typename):
if key not in rep:
continue
ident = rep[key]
type_ids_map[typename].append(ident)
for typename in type_ids_map:
ids = type_ids_map[typename]
node = graph.nodes_map[typename]
query_workflow.process_node(node, query, ids)
return self.executor.process(queue, query_workflow)
def execute_query(self, graph, query, ctx):
query = InitOptions(graph).visit(query)
queue = Queue(self.executor)
task_set = queue.fork(None)
query_workflow = Query(queue, task_set, graph, query, Context(ctx))
query_workflow.start()
return self.executor.process(queue, query_workflow)
class TestQueue(TestCase):
SCRIPT = [
'-> level1_init',
'<- level1_init',
'.. level1_task1',
'-> level1_task1_callback',
'-> level2_init',
'<- level2_init',
'<- level1_task1_callback',
'.. level2_task1',
'-> level2_task1_callback',
'-> level3_init',
'<- level3_init',
'<- level2_task1_callback',
'.. level3_task1',
'-> level3_task1_callback',
'<- level3_task1_callback',
'.. level3_task2',
'-> level3_task2_callback',
'<- level3_task2_callback',
'-> level2_task_set3_callback',
'<- level2_task_set3_callback',
'.. level2_task2',
'-> level2_task2_callback',
'<- level2_task2_callback',
'-> level1_task_set2_callback',
'<- level1_task_set2_callback',
'.. level1_task2',
'-> level1_task2_callback',
'<- level1_task2_callback',
'-> level0_task_set1_callback',
'<- level0_task_set1_callback',
]
def func(self, arg):
self.results.append('.. {}'.format(arg))
@log_call
def level1_init(self):
self.task_set1 = self.queue.fork(None)
level1_task1 = self.task_set1.submit(self.func, 'level1_task1')
self.queue.add_callback(level1_task1, self.level1_task1_callback)
self.queue.add_callback(self.task_set1, self.level0_task_set1_callback)
@log_call
def level1_task1_callback(self):
self.level2_init()
@log_call
def level2_init(self):
self.task_set2 = self.queue.fork(self.task_set1)
level2_task1 = self.task_set2.submit(self.func, 'level2_task1')
self.queue.add_callback(level2_task1, self.level2_task1_callback)
self.queue.add_callback(self.task_set2, self.level1_task_set2_callback)
@log_call
def level2_task1_callback(self):
self.level3_init()
@log_call
def level3_init(self):
self.task_set3 = self.queue.fork(self.task_set2)
level3_task1 = self.task_set3.submit(self.func, 'level3_task1')
self.queue.add_callback(level3_task1, self.level3_task1_callback)
self.queue.add_callback(self.task_set3, self.level2_task_set3_callback)
@log_call
def level3_task1_callback(self):
level3_task2 = self.task_set3.submit(self.func, 'level3_task2')
self.queue.add_callback(level3_task2, self.level3_task2_callback)
@log_call
def level3_task2_callback(self):
pass
@log_call
def level2_task_set3_callback(self):
level2_task2 = self.task_set2.submit(self.func, 'level2_task2')
self.queue.add_callback(level2_task2, self.level2_task2_callback)
@log_call
def level2_task2_callback(self):
pass
@log_call
def level1_task_set2_callback(self):
level1_task2 = self.task_set1.submit(self.func, 'level1_task2')
self.queue.add_callback(level1_task2, self.level1_task2_callback)
@log_call
def level1_task2_callback(self):
pass
@log_call
def level0_task_set1_callback(self):
pass
def setUp(self):
self.executor = DummyExecutor()
self.queue = Queue(self.executor)
self.results = []
self.maxDiff = None
def _test(self, idx):
self.level1_init()
# just to be sure that it is possible to pass empty list
self.queue.progress([])
while self.queue.__futures__:
task = self.queue.__futures__[idx]
task.run()
self.queue.progress([task])
self.assertEqual(self.results, self.SCRIPT)
self.assertFalse(self.queue._futures)
self.assertFalse(self.queue._forks)
self.assertFalse(self.queue._callbacks)
def testForward(self):
self._test(0)
def testBackward(self):
self._test(-1)
def setUp(self):
self.executor = DummyExecutor()
self.queue = Queue(self.executor)
self.results = []
self.maxDiff = None
