Guido van Rossum | 27b7c7e | 2013-10-17 13:40:50 -0700 | [diff] [blame] | 1 | """A Future class similar to the one in PEP 3148.""" |
| 2 | |
Yury Selivanov | 6370f34 | 2017-12-10 18:36:12 -0500 | [diff] [blame] | 3 | __all__ = ( |
Yury Selivanov | 6370f34 | 2017-12-10 18:36:12 -0500 | [diff] [blame] | 4 | 'Future', 'wrap_future', 'isfuture', |
| 5 | ) |
Guido van Rossum | 27b7c7e | 2013-10-17 13:40:50 -0700 | [diff] [blame] | 6 | |
Yury Selivanov | a0c1ba6 | 2016-10-28 12:52:37 -0400 | [diff] [blame] | 7 | import concurrent.futures |
Yury Selivanov | f23746a | 2018-01-22 19:11:18 -0500 | [diff] [blame] | 8 | import contextvars |
Guido van Rossum | 27b7c7e | 2013-10-17 13:40:50 -0700 | [diff] [blame] | 9 | import logging |
Victor Stinner | 4c3c699 | 2013-12-19 22:42:40 +0100 | [diff] [blame] | 10 | import sys |
Guido van Rossum | 27b7c7e | 2013-10-17 13:40:50 -0700 | [diff] [blame] | 11 | |
Yury Selivanov | a0c1ba6 | 2016-10-28 12:52:37 -0400 | [diff] [blame] | 12 | from . import base_futures |
Guido van Rossum | 27b7c7e | 2013-10-17 13:40:50 -0700 | [diff] [blame] | 13 | from . import events |
Andrew Svetlov | 0baa72f | 2018-09-11 10:13:04 -0700 | [diff] [blame] | 14 | from . import exceptions |
Andrew Svetlov | f74ef45 | 2017-12-15 07:04:38 +0200 | [diff] [blame] | 15 | from . import format_helpers |
Guido van Rossum | 27b7c7e | 2013-10-17 13:40:50 -0700 | [diff] [blame] | 16 | |
Guido van Rossum | 27b7c7e | 2013-10-17 13:40:50 -0700 | [diff] [blame] | 17 | |
Yury Selivanov | a0c1ba6 | 2016-10-28 12:52:37 -0400 | [diff] [blame] | 18 | isfuture = base_futures.isfuture |
| 19 | |
| 20 | |
| 21 | _PENDING = base_futures._PENDING |
| 22 | _CANCELLED = base_futures._CANCELLED |
| 23 | _FINISHED = base_futures._FINISHED |
| 24 | |
Guido van Rossum | 27b7c7e | 2013-10-17 13:40:50 -0700 | [diff] [blame] | 25 | |
| 26 | STACK_DEBUG = logging.DEBUG - 1 # heavy-duty debugging |
| 27 | |
| 28 | |
Guido van Rossum | 27b7c7e | 2013-10-17 13:40:50 -0700 | [diff] [blame] | 29 | class Future: |
| 30 | """This class is *almost* compatible with concurrent.futures.Future. |
| 31 | |
| 32 | Differences: |
| 33 | |
Antoine Pitrou | 22b1128 | 2017-11-07 17:03:28 +0100 | [diff] [blame] | 34 | - This class is not thread-safe. |
| 35 | |
Guido van Rossum | 27b7c7e | 2013-10-17 13:40:50 -0700 | [diff] [blame] | 36 | - result() and exception() do not take a timeout argument and |
| 37 | raise an exception when the future isn't done yet. |
| 38 | |
| 39 | - Callbacks registered with add_done_callback() are always called |
Antoine Pitrou | 22b1128 | 2017-11-07 17:03:28 +0100 | [diff] [blame] | 40 | via the event loop's call_soon(). |
Guido van Rossum | 27b7c7e | 2013-10-17 13:40:50 -0700 | [diff] [blame] | 41 | |
| 42 | - This class is not compatible with the wait() and as_completed() |
| 43 | methods in the concurrent.futures package. |
| 44 | |
| 45 | (In Python 3.4 or later we may be able to unify the implementations.) |
| 46 | """ |
| 47 | |
| 48 | # Class variables serving as defaults for instance variables. |
| 49 | _state = _PENDING |
| 50 | _result = None |
| 51 | _exception = None |
| 52 | _loop = None |
Victor Stinner | fe22e09 | 2014-12-04 23:00:13 +0100 | [diff] [blame] | 53 | _source_traceback = None |
Guido van Rossum | 27b7c7e | 2013-10-17 13:40:50 -0700 | [diff] [blame] | 54 | |
Guido van Rossum | 1140a03 | 2016-09-09 12:54:54 -0700 | [diff] [blame] | 55 | # This field is used for a dual purpose: |
| 56 | # - Its presence is a marker to declare that a class implements |
| 57 | # the Future protocol (i.e. is intended to be duck-type compatible). |
| 58 | # The value must also be not-None, to enable a subclass to declare |
| 59 | # that it is not compatible by setting this to None. |
| 60 | # - It is set by __iter__() below so that Task._step() can tell |
Andrew Svetlov | 8874342 | 2017-12-11 17:35:49 +0200 | [diff] [blame] | 61 | # the difference between |
| 62 | # `await Future()` or`yield from Future()` (correct) vs. |
Guido van Rossum | 1140a03 | 2016-09-09 12:54:54 -0700 | [diff] [blame] | 63 | # `yield Future()` (incorrect). |
| 64 | _asyncio_future_blocking = False |
Guido van Rossum | 27b7c7e | 2013-10-17 13:40:50 -0700 | [diff] [blame] | 65 | |
Yury Selivanov | e0aef4f | 2017-12-25 16:16:10 -0500 | [diff] [blame] | 66 | __log_traceback = False |
Guido van Rossum | 27b7c7e | 2013-10-17 13:40:50 -0700 | [diff] [blame] | 67 | |
| 68 | def __init__(self, *, loop=None): |
| 69 | """Initialize the future. |
| 70 | |
Martin Panter | c04fb56 | 2016-02-10 05:44:01 +0000 | [diff] [blame] | 71 | The optional event_loop argument allows explicitly setting the event |
Guido van Rossum | 27b7c7e | 2013-10-17 13:40:50 -0700 | [diff] [blame] | 72 | loop object used by the future. If it's not provided, the future uses |
| 73 | the default event loop. |
| 74 | """ |
| 75 | if loop is None: |
| 76 | self._loop = events.get_event_loop() |
| 77 | else: |
| 78 | self._loop = loop |
| 79 | self._callbacks = [] |
Victor Stinner | 80f53aa | 2014-06-27 13:52:20 +0200 | [diff] [blame] | 80 | if self._loop.get_debug(): |
Andrew Svetlov | f74ef45 | 2017-12-15 07:04:38 +0200 | [diff] [blame] | 81 | self._source_traceback = format_helpers.extract_stack( |
| 82 | sys._getframe(1)) |
Guido van Rossum | 27b7c7e | 2013-10-17 13:40:50 -0700 | [diff] [blame] | 83 | |
Yury Selivanov | a0c1ba6 | 2016-10-28 12:52:37 -0400 | [diff] [blame] | 84 | _repr_info = base_futures._future_repr_info |
Victor Stinner | 313a980 | 2014-07-29 12:58:23 +0200 | [diff] [blame] | 85 | |
| 86 | def __repr__(self): |
Yury Selivanov | 6370f34 | 2017-12-10 18:36:12 -0500 | [diff] [blame] | 87 | return '<{} {}>'.format(self.__class__.__name__, |
| 88 | ' '.join(self._repr_info())) |
Guido van Rossum | 27b7c7e | 2013-10-17 13:40:50 -0700 | [diff] [blame] | 89 | |
INADA Naoki | 3e2ad8e | 2017-04-25 10:57:18 +0900 | [diff] [blame] | 90 | def __del__(self): |
Yury Selivanov | e0aef4f | 2017-12-25 16:16:10 -0500 | [diff] [blame] | 91 | if not self.__log_traceback: |
INADA Naoki | 3e2ad8e | 2017-04-25 10:57:18 +0900 | [diff] [blame] | 92 | # set_exception() was not called, or result() or exception() |
| 93 | # has consumed the exception |
| 94 | return |
| 95 | exc = self._exception |
| 96 | context = { |
Yury Selivanov | 6370f34 | 2017-12-10 18:36:12 -0500 | [diff] [blame] | 97 | 'message': |
| 98 | f'{self.__class__.__name__} exception was never retrieved', |
INADA Naoki | 3e2ad8e | 2017-04-25 10:57:18 +0900 | [diff] [blame] | 99 | 'exception': exc, |
| 100 | 'future': self, |
| 101 | } |
| 102 | if self._source_traceback: |
| 103 | context['source_traceback'] = self._source_traceback |
| 104 | self._loop.call_exception_handler(context) |
Victor Stinner | 4c3c699 | 2013-12-19 22:42:40 +0100 | [diff] [blame] | 105 | |
Yury Selivanov | e0aef4f | 2017-12-25 16:16:10 -0500 | [diff] [blame] | 106 | @property |
| 107 | def _log_traceback(self): |
| 108 | return self.__log_traceback |
| 109 | |
| 110 | @_log_traceback.setter |
| 111 | def _log_traceback(self, val): |
| 112 | if bool(val): |
| 113 | raise ValueError('_log_traceback can only be set to False') |
| 114 | self.__log_traceback = False |
| 115 | |
Yury Selivanov | ca9b36c | 2017-12-23 15:04:15 -0500 | [diff] [blame] | 116 | def get_loop(self): |
| 117 | """Return the event loop the Future is bound to.""" |
| 118 | return self._loop |
| 119 | |
Guido van Rossum | 27b7c7e | 2013-10-17 13:40:50 -0700 | [diff] [blame] | 120 | def cancel(self): |
| 121 | """Cancel the future and schedule callbacks. |
| 122 | |
| 123 | If the future is already done or cancelled, return False. Otherwise, |
| 124 | change the future's state to cancelled, schedule the callbacks and |
| 125 | return True. |
| 126 | """ |
Yury Selivanov | e0aef4f | 2017-12-25 16:16:10 -0500 | [diff] [blame] | 127 | self.__log_traceback = False |
Guido van Rossum | 27b7c7e | 2013-10-17 13:40:50 -0700 | [diff] [blame] | 128 | if self._state != _PENDING: |
| 129 | return False |
| 130 | self._state = _CANCELLED |
Yury Selivanov | 22feeb8 | 2018-01-24 11:31:01 -0500 | [diff] [blame] | 131 | self.__schedule_callbacks() |
Guido van Rossum | 27b7c7e | 2013-10-17 13:40:50 -0700 | [diff] [blame] | 132 | return True |
| 133 | |
Yury Selivanov | 22feeb8 | 2018-01-24 11:31:01 -0500 | [diff] [blame] | 134 | def __schedule_callbacks(self): |
Guido van Rossum | 27b7c7e | 2013-10-17 13:40:50 -0700 | [diff] [blame] | 135 | """Internal: Ask the event loop to call all callbacks. |
| 136 | |
| 137 | The callbacks are scheduled to be called as soon as possible. Also |
| 138 | clears the callback list. |
| 139 | """ |
| 140 | callbacks = self._callbacks[:] |
| 141 | if not callbacks: |
| 142 | return |
| 143 | |
| 144 | self._callbacks[:] = [] |
Yury Selivanov | f23746a | 2018-01-22 19:11:18 -0500 | [diff] [blame] | 145 | for callback, ctx in callbacks: |
| 146 | self._loop.call_soon(callback, self, context=ctx) |
Guido van Rossum | 27b7c7e | 2013-10-17 13:40:50 -0700 | [diff] [blame] | 147 | |
| 148 | def cancelled(self): |
| 149 | """Return True if the future was cancelled.""" |
| 150 | return self._state == _CANCELLED |
| 151 | |
| 152 | # Don't implement running(); see http://bugs.python.org/issue18699 |
| 153 | |
| 154 | def done(self): |
| 155 | """Return True if the future is done. |
| 156 | |
| 157 | Done means either that a result / exception are available, or that the |
| 158 | future was cancelled. |
| 159 | """ |
| 160 | return self._state != _PENDING |
| 161 | |
| 162 | def result(self): |
| 163 | """Return the result this future represents. |
| 164 | |
| 165 | If the future has been cancelled, raises CancelledError. If the |
| 166 | future's result isn't yet available, raises InvalidStateError. If |
| 167 | the future is done and has an exception set, this exception is raised. |
| 168 | """ |
| 169 | if self._state == _CANCELLED: |
Andrew Svetlov | 0baa72f | 2018-09-11 10:13:04 -0700 | [diff] [blame] | 170 | raise exceptions.CancelledError |
Guido van Rossum | 27b7c7e | 2013-10-17 13:40:50 -0700 | [diff] [blame] | 171 | if self._state != _FINISHED: |
Andrew Svetlov | 0baa72f | 2018-09-11 10:13:04 -0700 | [diff] [blame] | 172 | raise exceptions.InvalidStateError('Result is not ready.') |
Yury Selivanov | e0aef4f | 2017-12-25 16:16:10 -0500 | [diff] [blame] | 173 | self.__log_traceback = False |
Guido van Rossum | 27b7c7e | 2013-10-17 13:40:50 -0700 | [diff] [blame] | 174 | if self._exception is not None: |
| 175 | raise self._exception |
| 176 | return self._result |
| 177 | |
| 178 | def exception(self): |
| 179 | """Return the exception that was set on this future. |
| 180 | |
| 181 | The exception (or None if no exception was set) is returned only if |
| 182 | the future is done. If the future has been cancelled, raises |
| 183 | CancelledError. If the future isn't done yet, raises |
| 184 | InvalidStateError. |
| 185 | """ |
| 186 | if self._state == _CANCELLED: |
Andrew Svetlov | 0baa72f | 2018-09-11 10:13:04 -0700 | [diff] [blame] | 187 | raise exceptions.CancelledError |
Guido van Rossum | 27b7c7e | 2013-10-17 13:40:50 -0700 | [diff] [blame] | 188 | if self._state != _FINISHED: |
Andrew Svetlov | 0baa72f | 2018-09-11 10:13:04 -0700 | [diff] [blame] | 189 | raise exceptions.InvalidStateError('Exception is not set.') |
Yury Selivanov | e0aef4f | 2017-12-25 16:16:10 -0500 | [diff] [blame] | 190 | self.__log_traceback = False |
Guido van Rossum | 27b7c7e | 2013-10-17 13:40:50 -0700 | [diff] [blame] | 191 | return self._exception |
| 192 | |
Yury Selivanov | f23746a | 2018-01-22 19:11:18 -0500 | [diff] [blame] | 193 | def add_done_callback(self, fn, *, context=None): |
Guido van Rossum | 27b7c7e | 2013-10-17 13:40:50 -0700 | [diff] [blame] | 194 | """Add a callback to be run when the future becomes done. |
| 195 | |
| 196 | The callback is called with a single argument - the future object. If |
| 197 | the future is already done when this is called, the callback is |
| 198 | scheduled with call_soon. |
| 199 | """ |
| 200 | if self._state != _PENDING: |
Yury Selivanov | f23746a | 2018-01-22 19:11:18 -0500 | [diff] [blame] | 201 | self._loop.call_soon(fn, self, context=context) |
Guido van Rossum | 27b7c7e | 2013-10-17 13:40:50 -0700 | [diff] [blame] | 202 | else: |
Yury Selivanov | f23746a | 2018-01-22 19:11:18 -0500 | [diff] [blame] | 203 | if context is None: |
| 204 | context = contextvars.copy_context() |
| 205 | self._callbacks.append((fn, context)) |
Guido van Rossum | 27b7c7e | 2013-10-17 13:40:50 -0700 | [diff] [blame] | 206 | |
| 207 | # New method not in PEP 3148. |
| 208 | |
| 209 | def remove_done_callback(self, fn): |
| 210 | """Remove all instances of a callback from the "call when done" list. |
| 211 | |
| 212 | Returns the number of callbacks removed. |
| 213 | """ |
Yury Selivanov | f23746a | 2018-01-22 19:11:18 -0500 | [diff] [blame] | 214 | filtered_callbacks = [(f, ctx) |
| 215 | for (f, ctx) in self._callbacks |
| 216 | if f != fn] |
Guido van Rossum | 27b7c7e | 2013-10-17 13:40:50 -0700 | [diff] [blame] | 217 | removed_count = len(self._callbacks) - len(filtered_callbacks) |
| 218 | if removed_count: |
| 219 | self._callbacks[:] = filtered_callbacks |
| 220 | return removed_count |
| 221 | |
| 222 | # So-called internal methods (note: no set_running_or_notify_cancel()). |
| 223 | |
| 224 | def set_result(self, result): |
| 225 | """Mark the future done and set its result. |
| 226 | |
| 227 | If the future is already done when this method is called, raises |
| 228 | InvalidStateError. |
| 229 | """ |
| 230 | if self._state != _PENDING: |
Andrew Svetlov | 0baa72f | 2018-09-11 10:13:04 -0700 | [diff] [blame] | 231 | raise exceptions.InvalidStateError(f'{self._state}: {self!r}') |
Guido van Rossum | 27b7c7e | 2013-10-17 13:40:50 -0700 | [diff] [blame] | 232 | self._result = result |
| 233 | self._state = _FINISHED |
Yury Selivanov | 22feeb8 | 2018-01-24 11:31:01 -0500 | [diff] [blame] | 234 | self.__schedule_callbacks() |
Guido van Rossum | 27b7c7e | 2013-10-17 13:40:50 -0700 | [diff] [blame] | 235 | |
| 236 | def set_exception(self, exception): |
| 237 | """Mark the future done and set an exception. |
| 238 | |
| 239 | If the future is already done when this method is called, raises |
| 240 | InvalidStateError. |
| 241 | """ |
| 242 | if self._state != _PENDING: |
Andrew Svetlov | 0baa72f | 2018-09-11 10:13:04 -0700 | [diff] [blame] | 243 | raise exceptions.InvalidStateError(f'{self._state}: {self!r}') |
Victor Stinner | 9572898 | 2014-01-30 16:01:54 -0800 | [diff] [blame] | 244 | if isinstance(exception, type): |
| 245 | exception = exception() |
Yury Selivanov | 1bd0307 | 2016-03-02 11:03:28 -0500 | [diff] [blame] | 246 | if type(exception) is StopIteration: |
| 247 | raise TypeError("StopIteration interacts badly with generators " |
| 248 | "and cannot be raised into a Future") |
Guido van Rossum | 27b7c7e | 2013-10-17 13:40:50 -0700 | [diff] [blame] | 249 | self._exception = exception |
Guido van Rossum | 27b7c7e | 2013-10-17 13:40:50 -0700 | [diff] [blame] | 250 | self._state = _FINISHED |
Yury Selivanov | 22feeb8 | 2018-01-24 11:31:01 -0500 | [diff] [blame] | 251 | self.__schedule_callbacks() |
Yury Selivanov | e0aef4f | 2017-12-25 16:16:10 -0500 | [diff] [blame] | 252 | self.__log_traceback = True |
Guido van Rossum | 27b7c7e | 2013-10-17 13:40:50 -0700 | [diff] [blame] | 253 | |
Yury Selivanov | 0cf16f9 | 2017-12-25 10:48:15 -0500 | [diff] [blame] | 254 | def __await__(self): |
Guido van Rossum | 27b7c7e | 2013-10-17 13:40:50 -0700 | [diff] [blame] | 255 | if not self.done(): |
Guido van Rossum | 1140a03 | 2016-09-09 12:54:54 -0700 | [diff] [blame] | 256 | self._asyncio_future_blocking = True |
Guido van Rossum | 27b7c7e | 2013-10-17 13:40:50 -0700 | [diff] [blame] | 257 | yield self # This tells Task to wait for completion. |
Yury Selivanov | 0cf16f9 | 2017-12-25 10:48:15 -0500 | [diff] [blame] | 258 | if not self.done(): |
| 259 | raise RuntimeError("await wasn't used with future") |
Guido van Rossum | 27b7c7e | 2013-10-17 13:40:50 -0700 | [diff] [blame] | 260 | return self.result() # May raise too. |
| 261 | |
Yury Selivanov | 0cf16f9 | 2017-12-25 10:48:15 -0500 | [diff] [blame] | 262 | __iter__ = __await__ # make compatible with 'yield from'. |
Yury Selivanov | 1af2bf7 | 2015-05-11 22:27:25 -0400 | [diff] [blame] | 263 | |
Guido van Rossum | 27b7c7e | 2013-10-17 13:40:50 -0700 | [diff] [blame] | 264 | |
Yury Selivanov | 01c521b | 2016-10-23 22:34:35 -0400 | [diff] [blame] | 265 | # Needed for testing purposes. |
| 266 | _PyFuture = Future |
| 267 | |
| 268 | |
Yury Selivanov | ca9b36c | 2017-12-23 15:04:15 -0500 | [diff] [blame] | 269 | def _get_loop(fut): |
| 270 | # Tries to call Future.get_loop() if it's available. |
| 271 | # Otherwise fallbacks to using the old '_loop' property. |
| 272 | try: |
| 273 | get_loop = fut.get_loop |
| 274 | except AttributeError: |
| 275 | pass |
| 276 | else: |
| 277 | return get_loop() |
| 278 | return fut._loop |
| 279 | |
| 280 | |
Yury Selivanov | 5d7e3b6 | 2015-11-17 12:19:41 -0500 | [diff] [blame] | 281 | def _set_result_unless_cancelled(fut, result): |
| 282 | """Helper setting the result only if the future was not cancelled.""" |
| 283 | if fut.cancelled(): |
| 284 | return |
| 285 | fut.set_result(result) |
| 286 | |
| 287 | |
Andrew Svetlov | 0baa72f | 2018-09-11 10:13:04 -0700 | [diff] [blame] | 288 | def _convert_future_exc(exc): |
| 289 | exc_class = type(exc) |
| 290 | if exc_class is concurrent.futures.CancelledError: |
| 291 | return exceptions.CancelledError(*exc.args) |
| 292 | elif exc_class is concurrent.futures.TimeoutError: |
| 293 | return exceptions.TimeoutError(*exc.args) |
| 294 | elif exc_class is concurrent.futures.InvalidStateError: |
| 295 | return exceptions.InvalidStateError(*exc.args) |
| 296 | else: |
| 297 | return exc |
| 298 | |
| 299 | |
Guido van Rossum | 841d9ee | 2015-10-03 08:31:42 -0700 | [diff] [blame] | 300 | def _set_concurrent_future_state(concurrent, source): |
| 301 | """Copy state from a future to a concurrent.futures.Future.""" |
| 302 | assert source.done() |
| 303 | if source.cancelled(): |
| 304 | concurrent.cancel() |
| 305 | if not concurrent.set_running_or_notify_cancel(): |
| 306 | return |
| 307 | exception = source.exception() |
| 308 | if exception is not None: |
Andrew Svetlov | 0baa72f | 2018-09-11 10:13:04 -0700 | [diff] [blame] | 309 | concurrent.set_exception(_convert_future_exc(exception)) |
Guido van Rossum | 841d9ee | 2015-10-03 08:31:42 -0700 | [diff] [blame] | 310 | else: |
| 311 | result = source.result() |
| 312 | concurrent.set_result(result) |
| 313 | |
| 314 | |
Yury Selivanov | 5d7e3b6 | 2015-11-17 12:19:41 -0500 | [diff] [blame] | 315 | def _copy_future_state(source, dest): |
| 316 | """Internal helper to copy state from another Future. |
| 317 | |
| 318 | The other Future may be a concurrent.futures.Future. |
| 319 | """ |
| 320 | assert source.done() |
| 321 | if dest.cancelled(): |
| 322 | return |
| 323 | assert not dest.done() |
| 324 | if source.cancelled(): |
| 325 | dest.cancel() |
| 326 | else: |
| 327 | exception = source.exception() |
| 328 | if exception is not None: |
Andrew Svetlov | 0baa72f | 2018-09-11 10:13:04 -0700 | [diff] [blame] | 329 | dest.set_exception(_convert_future_exc(exception)) |
Yury Selivanov | 5d7e3b6 | 2015-11-17 12:19:41 -0500 | [diff] [blame] | 330 | else: |
| 331 | result = source.result() |
| 332 | dest.set_result(result) |
| 333 | |
| 334 | |
Guido van Rossum | 841d9ee | 2015-10-03 08:31:42 -0700 | [diff] [blame] | 335 | def _chain_future(source, destination): |
| 336 | """Chain two futures so that when one completes, so does the other. |
| 337 | |
| 338 | The result (or exception) of source will be copied to destination. |
| 339 | If destination is cancelled, source gets cancelled too. |
| 340 | Compatible with both asyncio.Future and concurrent.futures.Future. |
| 341 | """ |
Guido van Rossum | 7b3b3dc | 2016-09-09 14:26:31 -0700 | [diff] [blame] | 342 | if not isfuture(source) and not isinstance(source, |
| 343 | concurrent.futures.Future): |
Guido van Rossum | 841d9ee | 2015-10-03 08:31:42 -0700 | [diff] [blame] | 344 | raise TypeError('A future is required for source argument') |
Guido van Rossum | 7b3b3dc | 2016-09-09 14:26:31 -0700 | [diff] [blame] | 345 | if not isfuture(destination) and not isinstance(destination, |
| 346 | concurrent.futures.Future): |
Guido van Rossum | 841d9ee | 2015-10-03 08:31:42 -0700 | [diff] [blame] | 347 | raise TypeError('A future is required for destination argument') |
Yury Selivanov | ca9b36c | 2017-12-23 15:04:15 -0500 | [diff] [blame] | 348 | source_loop = _get_loop(source) if isfuture(source) else None |
| 349 | dest_loop = _get_loop(destination) if isfuture(destination) else None |
Guido van Rossum | 841d9ee | 2015-10-03 08:31:42 -0700 | [diff] [blame] | 350 | |
| 351 | def _set_state(future, other): |
Guido van Rossum | 7b3b3dc | 2016-09-09 14:26:31 -0700 | [diff] [blame] | 352 | if isfuture(future): |
Yury Selivanov | 5d7e3b6 | 2015-11-17 12:19:41 -0500 | [diff] [blame] | 353 | _copy_future_state(other, future) |
Guido van Rossum | 841d9ee | 2015-10-03 08:31:42 -0700 | [diff] [blame] | 354 | else: |
| 355 | _set_concurrent_future_state(future, other) |
| 356 | |
| 357 | def _call_check_cancel(destination): |
| 358 | if destination.cancelled(): |
| 359 | if source_loop is None or source_loop is dest_loop: |
| 360 | source.cancel() |
| 361 | else: |
| 362 | source_loop.call_soon_threadsafe(source.cancel) |
| 363 | |
| 364 | def _call_set_state(source): |
Yury Selivanov | fdccfe0 | 2018-05-28 17:10:20 -0400 | [diff] [blame] | 365 | if (destination.cancelled() and |
| 366 | dest_loop is not None and dest_loop.is_closed()): |
| 367 | return |
Guido van Rossum | 841d9ee | 2015-10-03 08:31:42 -0700 | [diff] [blame] | 368 | if dest_loop is None or dest_loop is source_loop: |
| 369 | _set_state(destination, source) |
| 370 | else: |
| 371 | dest_loop.call_soon_threadsafe(_set_state, destination, source) |
| 372 | |
| 373 | destination.add_done_callback(_call_check_cancel) |
| 374 | source.add_done_callback(_call_set_state) |
| 375 | |
| 376 | |
| 377 | def wrap_future(future, *, loop=None): |
Guido van Rossum | 27b7c7e | 2013-10-17 13:40:50 -0700 | [diff] [blame] | 378 | """Wrap concurrent.futures.Future object.""" |
Guido van Rossum | 7b3b3dc | 2016-09-09 14:26:31 -0700 | [diff] [blame] | 379 | if isfuture(future): |
Guido van Rossum | 841d9ee | 2015-10-03 08:31:42 -0700 | [diff] [blame] | 380 | return future |
| 381 | assert isinstance(future, concurrent.futures.Future), \ |
Yury Selivanov | 6370f34 | 2017-12-10 18:36:12 -0500 | [diff] [blame] | 382 | f'concurrent.futures.Future is expected, got {future!r}' |
Yury Selivanov | 7661db6 | 2016-05-16 15:38:39 -0400 | [diff] [blame] | 383 | if loop is None: |
| 384 | loop = events.get_event_loop() |
| 385 | new_future = loop.create_future() |
Guido van Rossum | 841d9ee | 2015-10-03 08:31:42 -0700 | [diff] [blame] | 386 | _chain_future(future, new_future) |
Guido van Rossum | 27b7c7e | 2013-10-17 13:40:50 -0700 | [diff] [blame] | 387 | return new_future |
INADA Naoki | c411a7d | 2016-10-18 11:48:14 +0900 | [diff] [blame] | 388 | |
| 389 | |
| 390 | try: |
| 391 | import _asyncio |
| 392 | except ImportError: |
| 393 | pass |
| 394 | else: |
Yury Selivanov | 01c521b | 2016-10-23 22:34:35 -0400 | [diff] [blame] | 395 | # _CFuture is needed for tests. |
| 396 | Future = _CFuture = _asyncio.Future |