def test_done_callback_already_cancelled(self): self.was_cancelled = None def fn(callback_future): self.was_cancelled = callback_future.cancelled() f = Future() self.assertTrue(f.cancel()) f.add_done_callback(fn) self.assertTrue(self.was_cancelled)
def test_done_callback_already_failed(self): self.callback_exception = None def fn(callback_future): self.callback_exception = callback_future.exception() f = Future() f.set_exception(Exception('test')) f.add_done_callback(fn) self.assertEquals(('test',), self.callback_exception.args)
def test_done_callback_with_result(self): callback_result = [None] def fn(callback_future): callback_result[0] = callback_future.result() f = Future() f.add_done_callback(fn) f.set_result(5) self.assertEqual(5, callback_result[0])
def test_done_callback_with_result(self): self.callback_result = None def fn(callback_future): self.callback_result = callback_future.result() f = Future() f.add_done_callback(fn) f.set_result(5) self.assertEquals(5, self.callback_result)
def test_done_callback_already_successful(self): callback_result = [None] def fn(callback_future): callback_result[0] = callback_future.result() f = Future() f.set_result(5) f.add_done_callback(fn) self.assertEqual(5, callback_result[0])
def test_done_callback_already_failed(self): callback_exception = [None] def fn(callback_future): callback_exception[0] = callback_future.exception() f = Future() f.set_exception(Exception('test')) f.add_done_callback(fn) self.assertEqual(('test',), callback_exception[0].args)
def test_done_callback_already_cancelled(self): was_cancelled = [None] def fn(callback_future): was_cancelled[0] = callback_future.cancelled() f = Future() self.assertTrue(f.cancel()) f.add_done_callback(fn) self.assertTrue(was_cancelled[0])
def test_done_callback_already_successful(self): self.callback_result = None def fn(callback_future): self.callback_result = callback_future.result() f = Future() f.set_result(5) f.add_done_callback(fn) self.assertEquals(5, self.callback_result)
def test_done_callback_with_exception(self): callback_exception = [None] def fn(callback_future): callback_exception[0] = callback_future.exception() f = Future() f.add_done_callback(fn) f.set_exception(Exception("test")) self.assertEqual(("test",), callback_exception[0].args)
def test_done_callback_with_exception(self): callback_exception = None def fn(callback_future): nonlocal callback_exception callback_exception = callback_future.exception() f = Future() f.add_done_callback(fn) f.set_exception(Exception('test')) self.assertEqual(('test',), callback_exception.args)
def test_done_callback_with_cancel(self): was_cancelled = None def fn(callback_future): nonlocal was_cancelled was_cancelled = callback_future.cancelled() f = Future() f.add_done_callback(fn) self.assertTrue(f.cancel()) self.assertTrue(was_cancelled)
def test_done_callback_raises(self): with captured_stderr() as stderr: raising_was_called = [False] raising_old_style_was_called = [False] fn_was_called = [False] def raising_fn(callback_future): raising_was_called[0] = True raise Exception('doh!') def raising_old_style_fn(callback_future): raising_old_style_was_called[0] = True class OldStyle: # Does not inherit from object def __str__(self): return 'doh!' raise OldStyle() def fn(callback_future): fn_was_called[0] = True f = Future() f.add_done_callback(raising_fn) f.add_done_callback(raising_old_style_fn) f.add_done_callback(fn) f.set_result(5) self.assertTrue(raising_was_called) self.assertTrue(raising_old_style_was_called) self.assertTrue(fn_was_called) self.assertIn('Exception: doh!', stderr.getvalue()) self.assertIn('OldStyle: doh!', stderr.getvalue())
def test_done_callback_already_failed(self): callback_exception = None def fn(callback_future): nonlocal callback_exception callback_exception = callback_future.exception() f = Future() f.set_exception(Exception("test")) f.add_done_callback(fn) self.assertEqual(("test",), callback_exception.args)
class Search(object): def __init__(self, key, routing_tables, network_node, nb_parallel=3, nb_pool=10): self.key = key self.routing_tables = routing_tables self.network_node = network_node self.key = key self.request_in_progress = {} self.nb_parallel = nb_parallel self.completed = Future() self.canditate_peers = set() self.requested_peers = set() self.nb_pool = nb_pool def start(self): self.fillpeers() self.process_search() return self.completed def fillpeers(self): closest = self.routing_tables.find_closest(self.key, self.nb_pool, excluding=self.requested_peers | self.canditate_peers) self.canditate_peers |= set(closest) def process_search(self): if not self.completed.done() and len(self.canditate_peers) == 0 and len(self.request_in_progress) == 0: self.completed.set_exception(ValueNotFound("unable to find value")) return while self.canditate_peers and len(self.request_in_progress) <= self.nb_parallel: p = self.canditate_peers.pop() self.requested_peers.add(p) future = self.network_node.request(p.addr, {"method" : "find_node", "params": str(self.key)}) self.request_in_progress[future] = p #then(future, self.on_reply) future.add_done_callback(self.on_reply) def on_reply(self, future): del self.request_in_progress[future] exception = future.exception() if exception is None: result = future.result() if 'value' in result: self.completed.set_result(result['value']) elif 'peers' in result: for id, addr in result["peers"]: peer = Peer(Id(id), addr) if peer not in self.requested_peers: self.canditate_peers.add(Peer(Id(id), addr)) self.process_search() def __eq__(self, other): return self.key == other.key
def test_old_style_exception(self): class OldStyle: # Does not inherit from object def __str__(self): return 'doh!' callback_exc_info = [None] def fn(callback_future): callback_exc_info[0] = callback_future.exception_info() f = Future() f.add_done_callback(fn) try: raise OldStyle() except OldStyle: want_exc_info = sys.exc_info() f.set_exception_info(*want_exc_info[1:]) self.assertEqual(f.exception_info(), want_exc_info[1:]) self.assertEqual(callback_exc_info[0], want_exc_info[1:]) try: f.result() except OldStyle: got_exc_info = sys.exc_info() else: self.fail('OldStyle exception not raised') self.assertEqual(got_exc_info[:2], want_exc_info[:2]) got_tb = traceback.extract_tb(got_exc_info[2]) want_tb = traceback.extract_tb(want_exc_info[2]) self.assertEqual(got_tb[-len(want_tb):], want_tb)
class Runner(object): """ This class waits for dependencies to finish and submits itself to the job scheduler """ def __init__(self, task): self.future = Future() # a list of Runners to wait for self.waiting_for = [] # the callable to run self.task = task super(Runner, self).__init__() def schedule(self, executor, _reschedule=False): """ Try to schedule this Runner with the executor or wait for dependencies """ if self.future.done(): return if False not in [r.future.done() for r in self.waiting_for]: if any(r.future.exception() for r in self.waiting_for): # a dependency failed. done() is True but an exception is set return executor.submit(self) return def dep_finished_callback(future): self.schedule(executor, _reschedule=True) if not _reschedule: for runner in self.waiting_for: runner.future.add_done_callback(dep_finished_callback)
def test_done_callback_raises(self): LOGGER.removeHandler(STDERR_HANDLER) logging_stream = io.StringIO() handler = logging.StreamHandler(logging_stream) LOGGER.addHandler(handler) try: raising_was_called = False fn_was_called = False def raising_fn(callback_future): nonlocal raising_was_called raising_was_called = True raise Exception('doh!') def fn(callback_future): nonlocal fn_was_called fn_was_called = True f = Future() f.add_done_callback(raising_fn) f.add_done_callback(fn) f.set_result(5) self.assertTrue(raising_was_called) self.assertTrue(fn_was_called) self.assertIn('Exception: doh!', logging_stream.getvalue()) finally: LOGGER.removeHandler(handler) LOGGER.addHandler(STDERR_HANDLER)
def __init__(self, task): self.future = Future() # a list of Runners to wait for self.waiting_for = [] # the callable to run self.task = task super(Runner, self).__init__()
def __init__(self, key, routing_tables, network_node, nb_parallel=3, nb_pool=10): self.key = key self.routing_tables = routing_tables self.network_node = network_node self.key = key self.request_in_progress = {} self.nb_parallel = nb_parallel self.completed = Future() self.canditate_peers = set() self.requested_peers = set() self.nb_pool = nb_pool
def test_done_callback_raises(self): with captured_stderr() as stderr: raising_was_called = [False] fn_was_called = [False] def raising_fn(callback_future): raising_was_called[0] = True raise Exception("doh!") def fn(callback_future): fn_was_called[0] = True f = Future() f.add_done_callback(raising_fn) f.add_done_callback(fn) f.set_result(5) self.assertTrue(raising_was_called) self.assertTrue(fn_was_called) self.assertIn("Exception: doh!", stderr.getvalue())
def test_free_reference_yielded_future(self): # Issue #14406: Generator should not keep references # to finished futures. futures_list = [Future() for _ in range(8)] futures_list.append(create_future(state=CANCELLED_AND_NOTIFIED)) futures_list.append(create_future(state=FINISHED, result=42)) with self.assertRaises(futures.TimeoutError): for future in futures.as_completed(futures_list, timeout=0): futures_list.remove(future) wr = weakref.ref(future) del future self.assertIsNone(wr()) futures_list[0].set_result("test") for future in futures.as_completed(futures_list): futures_list.remove(future) wr = weakref.ref(future) del future self.assertIsNone(wr()) if futures_list: futures_list[0].set_result("test")
def test_done_callback_raises(self): with test.support.captured_stderr() as stderr: raising_was_called = False fn_was_called = False def raising_fn(callback_future): nonlocal raising_was_called raising_was_called = True raise Exception('doh!') def fn(callback_future): nonlocal fn_was_called fn_was_called = True f = Future() f.add_done_callback(raising_fn) f.add_done_callback(fn) f.set_result(5) self.assertTrue(raising_was_called) self.assertTrue(fn_was_called) self.assertIn('Exception: doh!', stderr.getvalue())
def __init__(self, level: int = logging.NOTSET, maxlen: Optional[int] = None) -> None: super().__init__(level=level) self.cached_records = deque([], maxlen) self._emit_future = Future()
def submit(self, fn, *args, **kwargs): future = Future() future.set_result(fn(*args, **kwargs)) return future
def create_future(state=PENDING, exception=None, result=None): f = Future() f._state = state f._exception = exception f._result = result return f
def append_stage(stage_future: Future): stage = stage_future.result() container = self._build_container(name, stage, concurrency, parallel) self._wait_for_previous(container, last_stage_name) self._containers[name] = container
def __init__(self) -> None: super().__init__() self.completable_feature = Future() self.test_count = 0 self.test_method = self.test self.test_method_with_sleep = self.test_with_sleep
def submit(self, fn): result = fn() future = Future() future.set_result(result) return future
class CachedHandler(logging.Handler): """Handler which stores past records This is used to populate Maestral's status and error interfaces. The method :meth:`wait_for_emit` can be used from another thread to block until a new record is emitted, for instance to react to state changes. :param level: Initial log level. Defaults to NOTSET. :param maxlen: Maximum number of records to store. If ``None``, all records will be stored. Defaults to ``None``. """ cached_records: Deque[logging.LogRecord] _emit_future: Future def __init__(self, level: int = logging.NOTSET, maxlen: Optional[int] = None) -> None: super().__init__(level=level) self.cached_records = deque([], maxlen) self._emit_future = Future() def emit(self, record: logging.LogRecord) -> None: """ Logs the specified log record and saves it to the cache. :param record: Log record. """ self.cached_records.append(record) # notify any waiting coroutines that we have a status change try: self._emit_future.set_result(True) except InvalidStateError: pass def wait_for_emit(self, timeout: Optional[float]) -> bool: """ Blocks until a new record is emitted. :param timeout: Maximum time to block before returning. :returns: ``True`` if there was a status change, ``False`` in case of a timeout. """ done, not_done = wait([self._emit_future], timeout=timeout) self._emit_future = Future() # reset future return len(done) == 1 def getLastMessage(self) -> str: """ :returns: The log message of the last record or an empty string. """ try: last_record = self.cached_records[-1] return last_record.getMessage() except IndexError: return "" def getAllMessages(self) -> List[str]: """ :returns: A list of all record messages. """ return [r.getMessage() for r in self.cached_records] def clear(self) -> None: """ Clears all cached records. """ self.cached_records.clear()