diff -r 40c0c2eedf17 Lib/asyncio/futures.py
--- a/Lib/asyncio/futures.py Fri Oct 07 12:40:22 2016 -0400
+++ b/Lib/asyncio/futures.py Sat Oct 08 20:37:37 2016 +0900
@@ -117,12 +117,52 @@
itself as duck-type compatible by setting _asyncio_future_blocking.
See comment in Future for more details.
"""
return getattr(obj, '_asyncio_future_blocking', None) is not None
+def _format_callbacks(cb):
+ """helper function for Future.__repr__"""
+ size = len(cb)
+ if not size:
+ cb = ''
+
+ def format_cb(callback):
+ return events._format_callback_source(callback, ())
+
+ if size == 1:
+ cb = format_cb(cb[0])
+ elif size == 2:
+ cb = '{}, {}'.format(format_cb(cb[0]), format_cb(cb[1]))
+ elif size > 2:
+ cb = '{}, <{} more>, {}'.format(format_cb(cb[0]),
+ size-2,
+ format_cb(cb[-1]))
+ return 'cb=[%s]' % cb
+
+
+def _future_repr_info(future):
+ # (Future) -> str
+ """helper function for Future.__repr__"""
+ info = [future._state.lower()]
+ if future._state == _FINISHED:
+ if future._exception is not None:
+ info.append('exception={!r}'.format(future._exception))
+ else:
+ # use reprlib to limit the length of the output, especially
+ # for very long strings
+ result = reprlib.repr(future._result)
+ info.append('result={}'.format(result))
+ if future._callbacks:
+ info.append(_format_callbacks(future._callbacks))
+ if future._source_traceback:
+ frame = future._source_traceback[-1]
+ info.append('created at %s:%s' % (frame[0], frame[1]))
+ return info
+
+
class Future:
"""This class is *almost* compatible with concurrent.futures.Future.
Differences:
- result() and exception() do not take a timeout argument and
@@ -169,51 +209,16 @@
else:
self._loop = loop
self._callbacks = []
if self._loop.get_debug():
self._source_traceback = traceback.extract_stack(sys._getframe(1))
- def __format_callbacks(self):
- cb = self._callbacks
- size = len(cb)
- if not size:
- cb = ''
-
- def format_cb(callback):
- return events._format_callback_source(callback, ())
-
- if size == 1:
- cb = format_cb(cb[0])
- elif size == 2:
- cb = '{}, {}'.format(format_cb(cb[0]), format_cb(cb[1]))
- elif size > 2:
- cb = '{}, <{} more>, {}'.format(format_cb(cb[0]),
- size-2,
- format_cb(cb[-1]))
- return 'cb=[%s]' % cb
-
- def _repr_info(self):
- info = [self._state.lower()]
- if self._state == _FINISHED:
- if self._exception is not None:
- info.append('exception={!r}'.format(self._exception))
- else:
- # use reprlib to limit the length of the output, especially
- # for very long strings
- result = reprlib.repr(self._result)
- info.append('result={}'.format(result))
- if self._callbacks:
- info.append(self.__format_callbacks())
- if self._source_traceback:
- frame = self._source_traceback[-1]
- info.append('created at %s:%s' % (frame[0], frame[1]))
- return info
+ _repr_info = _future_repr_info
def __repr__(self):
- info = self._repr_info()
- return '<%s %s>' % (self.__class__.__name__, ' '.join(info))
+ return '<%s %s>' % (self.__class__.__name__, ' '.join(self._repr_info()))
# On Python 3.3 and older, objects with a destructor part of a reference
# cycle are never destroyed. It's not more the case on Python 3.4 thanks
# to the PEP 442.
if compat.PY34:
def __del__(self):
@@ -423,12 +428,27 @@
dest.set_exception(exception)
else:
result = source.result()
dest.set_result(result)
+try:
+ import _futures
+except ImportError:
+ pass
+else:
+ _futures._init_module(
+ traceback.extract_stack,
+ events.get_event_loop,
+ _future_repr_info,
+ InvalidStateError,
+ CancelledError)
+
+ Future = _futures.Future
+
+
def _chain_future(source, destination):
"""Chain two futures so that when one completes, so does the other.
The result (or exception) of source will be copied to destination.
If destination is cancelled, source gets cancelled too.
Compatible with both asyncio.Future and concurrent.futures.Future.
diff -r 40c0c2eedf17 Modules/Setup.dist
--- a/Modules/Setup.dist Fri Oct 07 12:40:22 2016 -0400
+++ b/Modules/Setup.dist Sat Oct 08 20:37:37 2016 +0900
@@ -178,12 +178,13 @@
#_random _randommodule.c # Random number generator
#_elementtree -I$(srcdir)/Modules/expat -DHAVE_EXPAT_CONFIG_H -DUSE_PYEXPAT_CAPI _elementtree.c # elementtree accelerator
#_pickle _pickle.c # pickle accelerator
#_datetime _datetimemodule.c # datetime accelerator
#_bisect _bisectmodule.c # Bisection algorithms
#_heapq _heapqmodule.c # Heap queue algorithm
+#_futures _futuresmodule.c # Fast asyncio Future
#unicodedata unicodedata.c # static Unicode character database
# Modules with some UNIX dependencies -- on by default:
# (If you have a really backward UNIX, select and socket may not be
diff -r 40c0c2eedf17 Modules/_futuresmodule.c
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/Modules/_futuresmodule.c Sat Oct 08 20:37:37 2016 +0900
@@ -0,0 +1,978 @@
+#include "Python.h"
+#include "structmember.h"
+
+
+/* identifiers used from some functions */
+_Py_IDENTIFIER(call_soon);
+
+
+/* State of the _futures module */
+static int _futuremod_ready;
+static PyObject *traceback_extract_stack;
+static PyObject *asyncio_get_event_loop;
+static PyObject *asyncio_repr_info_func;
+static PyObject *asyncio_InvalidStateError;
+static PyObject *asyncio_CancelledError;
+
+
+/* Get FutureIter from Future */
+static PyObject* new_future_iter(PyObject *fut);
+
+
+/* make sure module state is initialized and ready to be used. */
+static int
+_FuturesMod_EnsureState(void)
+{
+ if (!_futuremod_ready) {
+ PyErr_SetString(PyExc_RuntimeError,
+ "_futures module wasn't properly initialized");
+ return -1;
+ }
+ return 0;
+}
+
+
+typedef enum {
+ STATE_PENDING,
+ STATE_CANCELLED,
+ STATE_FINISHED
+} fut_state;
+
+
+typedef struct {
+ PyObject_HEAD
+ PyObject *fut_loop;
+ PyObject *fut_callbacks;
+ PyObject *fut_exception;
+ PyObject *fut_result;
+ PyObject *fut_source_tb;
+ fut_state fut_state;
+ int fut_log_tb;
+ int fut_blocking;
+ PyObject *dict;
+ PyObject *fut_weakreflist;
+} FutureObj;
+
+
+static int
+_schedule_callbacks(FutureObj *fut)
+{
+ Py_ssize_t len;
+ PyObject* iters;
+ int i;
+
+ if (fut->fut_callbacks == NULL) {
+ PyErr_SetString(PyExc_RuntimeError, "NULL callbacks");
+ return -1;
+ }
+
+ len = PyList_GET_SIZE(fut->fut_callbacks);
+ if (len == 0)
+ return 0;
+
+ iters = PyList_GetSlice(fut->fut_callbacks, 0, len);
+ if (iters == NULL)
+ return -1;
+ if (PyList_SetSlice(fut->fut_callbacks, 0, len, NULL) < 0) {
+ Py_DECREF(iters);
+ return -1;
+ }
+
+ for (i = 0; i < len; i++) {
+ PyObject *handle = NULL;
+ PyObject *cb = PyList_GET_ITEM(iters, i);
+
+ handle = _PyObject_CallMethodId(
+ fut->fut_loop, &PyId_call_soon, "OO", cb, fut, NULL);
+
+ if (handle == NULL) {
+ Py_DECREF(iters);
+ return -1;
+ } else {
+ Py_DECREF(handle);
+ }
+ }
+
+ Py_DECREF(iters);
+ return 0;
+}
+
+static int
+FutureObj_init(FutureObj *fut, PyObject *args, PyObject *kwds)
+{
+ static char *kwlist[] = {"loop", NULL};
+ PyObject *loop = NULL;
+ PyObject *res = NULL;
+ _Py_IDENTIFIER(get_debug);
+
+ if (_FuturesMod_EnsureState()) {
+ return -1;
+ }
+
+ if (!PyArg_ParseTupleAndKeywords(args, kwds, "|$O", kwlist, &loop))
+ return -1;
+ if (loop == NULL || loop == Py_None) {
+ loop = PyObject_CallObject(asyncio_get_event_loop, NULL);
+ if (loop == NULL)
+ return -1;
+ } else {
+ Py_INCREF(loop);
+ }
+ Py_CLEAR(fut->fut_loop);
+ fut->fut_loop = loop;
+
+ res = _PyObject_CallMethodId(fut->fut_loop, &PyId_get_debug, "()", NULL);
+ if (res == NULL)
+ return -1;
+ if (PyObject_IsTrue(res)) {
+ Py_CLEAR(res);
+ fut->fut_source_tb = PyObject_CallObject(traceback_extract_stack, NULL);
+ if (fut->fut_source_tb == NULL)
+ return -1;
+ } else {
+ Py_CLEAR(res);
+ }
+
+ fut->fut_callbacks = PyList_New(0);
+ if (fut->fut_callbacks == NULL)
+ return -1;
+
+ return 0;
+}
+
+static int
+FutureObj_clear(FutureObj *fut)
+{
+ Py_CLEAR(fut->fut_loop);
+ Py_CLEAR(fut->fut_callbacks);
+ Py_CLEAR(fut->fut_result);
+ Py_CLEAR(fut->fut_exception);
+ Py_CLEAR(fut->fut_source_tb);
+ Py_CLEAR(fut->dict);
+ return 0;
+}
+
+static void
+FutureObj_dealloc(FutureObj *fut)
+{
+ FutureObj_clear(fut);
+
+ if (fut->fut_weakreflist != NULL)
+ PyObject_ClearWeakRefs((PyObject *)fut);
+
+ Py_TYPE(fut)->tp_free(fut);
+}
+
+static int
+FutureObj_traverse(FutureObj *fut, visitproc visit, void *arg)
+{
+ Py_VISIT(fut->fut_loop);
+ Py_VISIT(fut->fut_callbacks);
+ Py_VISIT(fut->fut_result);
+ Py_VISIT(fut->fut_exception);
+ Py_VISIT(fut->fut_source_tb);
+ Py_VISIT(fut->dict);
+ return 0;
+}
+
+PyDoc_STRVAR(pydoc_result,
+ "Return the result this future represents.\n"
+ "\n"
+ "If the future has been cancelled, raises CancelledError. If the\n"
+ "future's result isn't yet available, raises InvalidStateError. If\n"
+ "the future is done and has an exception set, this exception is raised."
+);
+
+static PyObject *
+FutureObj_result(FutureObj *fut, PyObject *arg)
+{
+ if (fut->fut_state == STATE_CANCELLED) {
+ PyErr_SetString(asyncio_CancelledError, "");
+ return NULL;
+ }
+
+ if (fut->fut_state != STATE_FINISHED) {
+ PyErr_SetString(asyncio_InvalidStateError, "Result is not ready.");
+ return NULL;
+ }
+
+ fut->fut_log_tb = 0;
+ if (fut->fut_exception != NULL) {
+ PyObject *type = NULL;
+ type = PyExceptionInstance_Class(fut->fut_exception);
+ PyErr_SetObject(type, fut->fut_exception);
+ return NULL;
+ }
+
+ Py_INCREF(fut->fut_result);
+ return fut->fut_result;
+}
+
+PyDoc_STRVAR(pydoc_exception,
+ "Return the exception that was set on this future.\n"
+ "\n"
+ "The exception (or None if no exception was set) is returned only if\n"
+ "the future is done. If the future has been cancelled, raises\n"
+ "CancelledError. If the future isn't done yet, raises\n"
+ "InvalidStateError."
+);
+
+static PyObject *
+FutureObj_exception(FutureObj *fut, PyObject *arg)
+{
+ if (_FuturesMod_EnsureState()) {
+ return NULL;
+ }
+
+ if (fut->fut_state == STATE_CANCELLED) {
+ PyErr_SetString(asyncio_CancelledError, "");
+ return NULL;
+ }
+
+ if (fut->fut_state != STATE_FINISHED) {
+ PyErr_SetString(asyncio_InvalidStateError, "Result is not ready.");
+ return NULL;
+ }
+
+ if (fut->fut_exception != NULL) {
+ fut->fut_log_tb = 0;
+ Py_INCREF(fut->fut_exception);
+ return fut->fut_exception;
+ }
+
+ Py_RETURN_NONE;
+}
+
+PyDoc_STRVAR(pydoc_set_result,
+ "Mark the future done and set its result.\n"
+ "\n"
+ "If the future is already done when this method is called, raises\n"
+ "InvalidStateError."
+);
+
+static PyObject *
+FutureObj_set_result(FutureObj *fut, PyObject *res)
+{
+ if (_FuturesMod_EnsureState()) {
+ return NULL;
+ }
+
+ if (fut->fut_state != STATE_PENDING) {
+ PyErr_SetString(asyncio_InvalidStateError, "invalid state");
+ return NULL;
+ }
+
+ Py_INCREF(res);
+ fut->fut_result = res;
+ fut->fut_state = STATE_FINISHED;
+
+ if (_schedule_callbacks(fut) == -1)
+ return NULL;
+
+ Py_RETURN_NONE;
+}
+
+PyDoc_STRVAR(pydoc_set_exception,
+ "Mark the future done and set an exception.\n"
+ "\n"
+ "If the future is already done when this method is called, raises\n"
+ "InvalidStateError."
+);
+
+static PyObject *
+FutureObj_set_exception(FutureObj *fut, PyObject *exc)
+{
+ PyObject *exc_val = NULL;
+
+ if (_FuturesMod_EnsureState()) {
+ return NULL;
+ }
+
+ if (fut->fut_state != STATE_PENDING) {
+ PyErr_SetString(asyncio_InvalidStateError, "invalid state");
+ return NULL;
+ }
+
+ if (PyExceptionClass_Check(exc)) {
+ exc_val = PyObject_CallObject(exc, NULL);
+ if (exc_val == NULL)
+ return NULL;
+ }
+ else {
+ exc_val = exc;
+ Py_INCREF(exc_val);
+ }
+ if (!PyExceptionInstance_Check(exc_val)) {
+ Py_DECREF(exc_val);
+ PyErr_SetString(PyExc_TypeError, "invalid exception object");
+ return NULL;
+ }
+ if ((PyObject*)Py_TYPE(exc_val) == PyExc_StopIteration) {
+ Py_DECREF(exc_val);
+ PyErr_SetString(PyExc_TypeError,
+ "StopIteration interacts badly with generators "
+ "and cannot be raised into a Future");
+ return NULL;
+ }
+
+ fut->fut_exception = exc_val;
+ fut->fut_state = STATE_FINISHED;
+
+ if (_schedule_callbacks(fut) == -1)
+ return NULL;
+
+ fut->fut_log_tb = 1;
+ Py_RETURN_NONE;
+}
+
+PyDoc_STRVAR(pydoc_add_done_callback,
+ "Add a callback to be run when the future becomes done.\n"
+ "\n"
+ "The callback is called with a single argument - the future object. If\n"
+ "the future is already done when this is called, the callback is\n"
+ "scheduled with call_soon.";
+);
+
+static PyObject *
+FutureObj_add_done_callback(FutureObj *fut, PyObject *arg)
+{
+ if (fut->fut_state != STATE_PENDING) {
+ PyObject *handle = _PyObject_CallMethodId(
+ fut->fut_loop, &PyId_call_soon, "OO", arg, fut, NULL);
+
+ if (handle == NULL)
+ return NULL;
+ else
+ Py_DECREF(handle);
+ } else {
+ int err = PyList_Append(fut->fut_callbacks, arg);
+ if (err != 0) {
+ return NULL;
+ }
+ }
+ Py_RETURN_NONE;
+}
+
+PyDoc_STRVAR(pydoc_remove_done_callback,
+ "Remove all instances of a callback from the \"call when done\" list.\n"
+ "\n"
+ "Returns the number of callbacks removed."
+);
+
+static PyObject *
+FutureObj_remove_done_callback(FutureObj *fut, PyObject *arg)
+{
+ PyObject *newlist;
+ Py_ssize_t len, i, j=0;
+
+ len = PyList_GET_SIZE(fut->fut_callbacks);
+ if (len == 0) {
+ return PyLong_FromSsize_t(0);
+ }
+
+ newlist = PyList_New(len);
+ if (newlist == NULL) {
+ return NULL;
+ }
+
+ for (i = 0; i < len; i++) {
+ int ret;
+ PyObject *item = PyList_GET_ITEM(fut->fut_callbacks, i);
+
+ if ((ret = PyObject_RichCompareBool(arg, item, Py_EQ)) < 0) {
+ goto fail;
+ }
+ if (ret == 0) {
+ Py_INCREF(item);
+ PyList_SET_ITEM(newlist, j, item);
+ j++;
+ }
+ }
+
+ if (PyList_SetSlice(newlist, j, len, NULL) < 0) {
+ goto fail;
+ }
+ if (PyList_SetSlice(fut->fut_callbacks, 0, len, newlist) < 0) {
+ goto fail;
+ }
+ Py_DECREF(newlist);
+ return PyLong_FromSsize_t(len - j);
+
+fail:
+ Py_DECREF(newlist);
+ return NULL;
+}
+
+PyDoc_STRVAR(pydoc_cancel,
+ "Cancel the future and schedule callbacks.\n"
+ "\n"
+ "If the future is already done or cancelled, return False. Otherwise,\n"
+ "change the future's state to cancelled, schedule the callbacks and\n"
+ "return True."
+);
+
+static PyObject *
+FutureObj_cancel(FutureObj *fut, PyObject *arg)
+{
+ if (fut->fut_state != STATE_PENDING) {
+ Py_RETURN_FALSE;
+ }
+ fut->fut_state = STATE_CANCELLED;
+
+ if (_schedule_callbacks(fut) == -1) {
+ return NULL;
+ }
+
+ Py_RETURN_TRUE;
+}
+
+PyDoc_STRVAR(pydoc_cancelled, "Return True if the future was cancelled.");
+
+static PyObject *
+FutureObj_cancelled(FutureObj *fut, PyObject *arg)
+{
+ if (fut->fut_state == STATE_CANCELLED) {
+ Py_RETURN_TRUE;
+ } else {
+ Py_RETURN_FALSE;
+ }
+}
+
+PyDoc_STRVAR(pydoc_done,
+ "Return True if the future is done.\n"
+ "\n"
+ "Done means either that a result / exception are available, or that the\n"
+ "future was cancelled."
+);
+
+static PyObject *
+FutureObj_done(FutureObj *fut, PyObject *arg)
+{
+ if (fut->fut_state == STATE_PENDING) {
+ Py_RETURN_FALSE;
+ } else {
+ Py_RETURN_TRUE;
+ }
+}
+
+static PyObject *
+FutureObj_get_blocking(FutureObj *fut)
+{
+ if (fut->fut_blocking) {
+ Py_RETURN_TRUE;
+ } else {
+ Py_RETURN_FALSE;
+ }
+}
+
+static int
+FutureObj_set_blocking(FutureObj *fut, PyObject *val)
+{
+ int is_true = PyObject_IsTrue(val);
+ if (is_true < 0)
+ return -1;
+
+ fut->fut_blocking = is_true;
+ return 0;
+}
+
+static PyObject *
+FutureObj_get_log_traceback(FutureObj *fut)
+{
+ if (fut->fut_log_tb) {
+ Py_RETURN_TRUE;
+ }
+ else {
+ Py_RETURN_FALSE;
+ }
+}
+
+static PyObject *
+FutureObj_get_loop(FutureObj *fut)
+{
+ if (fut->fut_loop == NULL)
+ Py_RETURN_NONE;
+
+ Py_INCREF(fut->fut_loop);
+ return fut->fut_loop;
+}
+
+static PyObject *
+FutureObj_get_callbacks(FutureObj *fut)
+{
+ if (fut->fut_callbacks == NULL)
+ Py_RETURN_NONE;
+
+ Py_INCREF(fut->fut_callbacks);
+ return fut->fut_callbacks;
+}
+
+static PyObject *
+FutureObj_get_result(FutureObj *fut)
+{
+ if (fut->fut_result == NULL)
+ Py_RETURN_NONE;
+
+ Py_INCREF(fut->fut_result);
+ return fut->fut_result;
+}
+
+static PyObject *
+FutureObj_get_exception(FutureObj *fut)
+{
+ if (fut->fut_exception == NULL)
+ Py_RETURN_NONE;
+
+ Py_INCREF(fut->fut_exception);
+ return fut->fut_exception;
+}
+
+static PyObject *
+FutureObj_get_source_traceback(FutureObj *fut)
+{
+ if (fut->fut_source_tb == NULL)
+ Py_RETURN_NONE;
+
+ Py_INCREF(fut->fut_source_tb);
+ return fut->fut_source_tb;
+}
+
+static PyObject *
+FutureObj_get_state(FutureObj *fut)
+{
+ _Py_IDENTIFIER(PENDING);
+ _Py_IDENTIFIER(CANCELLED);
+ _Py_IDENTIFIER(FINISHED);
+ PyObject *ret = NULL;
+
+ switch (fut->fut_state) {
+ case STATE_PENDING:
+ ret = _PyUnicode_FromId(&PyId_PENDING);
+ break;
+ case STATE_CANCELLED:
+ ret = _PyUnicode_FromId(&PyId_CANCELLED);
+ break;
+ case STATE_FINISHED:
+ ret = _PyUnicode_FromId(&PyId_FINISHED);
+ break;
+ default:
+ assert (0);
+ }
+ Py_INCREF(ret);
+ return ret;
+}
+
+static PyObject*
+FutureObj__repr_info(FutureObj *fut)
+{
+ if (asyncio_repr_info_func == NULL) {
+ return PyList_New(0);
+ }
+ return PyObject_CallFunctionObjArgs(asyncio_repr_info_func, fut, NULL);
+}
+
+static PyObject *
+FutureObj_repr(FutureObj *fut)
+{
+ _Py_IDENTIFIER(_repr_info);
+
+ PyObject *_repr_info = _PyUnicode_FromId(&PyId__repr_info); // borrowed
+ if (_repr_info == NULL) {
+ return NULL;
+ }
+
+ PyObject *rinfo = PyObject_CallMethodObjArgs((PyObject*)fut, _repr_info,
+ NULL);
+ if (rinfo == NULL) {
+ return NULL;
+ }
+
+ PyObject *sp = PyUnicode_FromString(" ");
+ if (sp == NULL) {
+ Py_DECREF(rinfo);
+ return NULL;
+ }
+
+ PyObject *rinfo_s = PyUnicode_Join(sp, rinfo);
+ Py_DECREF(sp);
+ Py_DECREF(rinfo);
+ if (rinfo_s == NULL) {
+ return NULL;
+ }
+
+ PyObject *rstr = NULL;
+ PyObject *type_name = PyObject_GetAttrString((PyObject*)Py_TYPE(fut),
+ "__name__");
+ if (type_name != NULL) {
+ rstr = PyUnicode_FromFormat("<%S %S>", type_name, rinfo_s);
+ Py_DECREF(type_name);
+ }
+ Py_DECREF(rinfo_s);
+ return rstr;
+}
+
+static PyObject*
+FutureObj__del__(FutureObj *fut)
+{
+ _Py_IDENTIFIER(call_exception_handler);
+ _Py_IDENTIFIER(message);
+ _Py_IDENTIFIER(exception);
+ _Py_IDENTIFIER(future);
+ _Py_IDENTIFIER(source_traceback);
+
+ if (!fut->fut_log_tb) {
+ Py_RETURN_NONE;
+ }
+
+ PyObject *context = NULL;
+ PyObject *message = NULL;
+
+ message = PyUnicode_FromFormat(
+ "%s exception was never retrieved", Py_TYPE(fut)->tp_name);
+ if (message == NULL) {
+ goto error;
+ }
+
+ context = PyDict_New();
+ if (context == NULL) {
+ goto error;
+ }
+ if (_PyDict_SetItemId(context, &PyId_message, message) < 0 ||
+ _PyDict_SetItemId(context, &PyId_exception, fut->fut_exception) < 0 ||
+ _PyDict_SetItemId(context, &PyId_future, (PyObject*)fut) < 0) {
+ goto error;
+ }
+ if (fut->fut_source_tb != NULL) {
+ if (_PyDict_SetItemId(context, &PyId_source_traceback,
+ fut->fut_source_tb) < 0) {
+ goto error;
+ }
+ }
+
+ PyObject *ret = _PyObject_CallMethodId(fut->fut_loop,
+ &PyId_call_exception_handler,
+ "O", context);
+ if (ret == NULL) {
+ goto error;
+ }
+ Py_DECREF(ret);
+ Py_DECREF(context);
+ Py_DECREF(message);
+ Py_RETURN_NONE;
+
+error:
+ Py_CLEAR(context);
+ Py_CLEAR(message);
+ return NULL;
+}
+
+static PyAsyncMethods FutureType_as_async = {
+ (unaryfunc)new_future_iter, /* am_await */
+ 0, /* am_aiter */
+ 0 /* am_anext */
+};
+
+static PyMethodDef FutureType_methods[] = {
+ {"_repr_info", (PyCFunction)FutureObj__repr_info, METH_NOARGS, NULL},
+ {"add_done_callback",
+ (PyCFunction)FutureObj_add_done_callback,
+ METH_O, pydoc_add_done_callback},
+ {"remove_done_callback",
+ (PyCFunction)FutureObj_remove_done_callback,
+ METH_O, pydoc_remove_done_callback},
+ {"set_result",
+ (PyCFunction)FutureObj_set_result, METH_O, pydoc_set_result},
+ {"set_exception",
+ (PyCFunction)FutureObj_set_exception, METH_O, pydoc_set_exception},
+ {"cancel", (PyCFunction)FutureObj_cancel, METH_NOARGS, pydoc_cancel},
+ {"cancelled",
+ (PyCFunction)FutureObj_cancelled, METH_NOARGS, pydoc_cancelled},
+ {"done", (PyCFunction)FutureObj_done, METH_NOARGS, pydoc_done},
+ {"result", (PyCFunction)FutureObj_result, METH_NOARGS, pydoc_result},
+ {"exception",
+ (PyCFunction)FutureObj_exception, METH_NOARGS, pydoc_exception},
+ {"__del__", (PyCFunction)FutureObj__del__, METH_NOARGS, NULL},
+ {NULL, NULL} /* Sentinel */
+};
+
+static PyGetSetDef FutureType_getsetlist[] = {
+ {"_state", (getter)FutureObj_get_state, NULL, NULL},
+ {"_asyncio_future_blocking", (getter)FutureObj_get_blocking,
+ (setter)FutureObj_set_blocking, NULL},
+ {"_loop", (getter)FutureObj_get_loop, NULL, NULL},
+ {"_callbacks", (getter)FutureObj_get_callbacks, NULL, NULL},
+ {"_result", (getter)FutureObj_get_result, NULL, NULL},
+ {"_exception", (getter)FutureObj_get_exception, NULL, NULL},
+ {"_log_traceback", (getter)FutureObj_get_log_traceback, NULL, NULL},
+ {"_source_traceback", (getter)FutureObj_get_source_traceback, NULL, NULL},
+ {NULL} /* Sentinel */
+};
+
+static PyTypeObject FutureType = {
+ PyVarObject_HEAD_INIT(0, 0)
+ "_futures.Future",
+ sizeof(FutureObj), /* tp_basicsize */
+ .tp_dealloc = (destructor)FutureObj_dealloc,
+ .tp_as_async = &FutureType_as_async,
+ .tp_repr = (reprfunc)FutureObj_repr,
+ .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE,
+ .tp_doc = "Fast asyncio.Future implementation.",
+ .tp_traverse = (traverseproc)FutureObj_traverse,
+ .tp_clear = (inquiry)FutureObj_clear,
+ .tp_weaklistoffset = offsetof(FutureObj, fut_weakreflist),
+ .tp_iter = (getiterfunc)new_future_iter,
+ .tp_methods = FutureType_methods,
+ .tp_getset = FutureType_getsetlist,
+ .tp_dictoffset = offsetof(FutureObj, dict),
+ .tp_init = (initproc)FutureObj_init,
+ .tp_new = PyType_GenericNew,
+};
+
+/*********************** Future Iterator **************************/
+
+typedef struct {
+ PyObject_HEAD
+ FutureObj *future;
+} futureiterobject;
+
+static void
+FutureIter_dealloc(futureiterobject *it)
+{
+ _PyObject_GC_UNTRACK(it);
+ Py_XDECREF(it->future);
+ PyObject_GC_Del(it);
+}
+
+static PyObject *
+FutureIter_iternext(futureiterobject *it)
+{
+ PyObject *res;
+ FutureObj *fut = it->future;
+
+ if (fut == NULL)
+ return NULL;
+
+ if (fut->fut_state == STATE_PENDING) {
+ if (!fut->fut_blocking) {
+ fut->fut_blocking = 1;
+ Py_INCREF(fut);
+ return (PyObject *)fut;
+ }
+ PyErr_Format(PyExc_AssertionError,
+ "yield from wasn't used with future");
+ return NULL;
+ }
+
+ res = FutureObj_result(fut, NULL);
+ if (res != NULL) {
+ // normal result
+ PyErr_SetObject(PyExc_StopIteration, res);
+ Py_DECREF(res);
+ }
+
+ it->future = NULL;
+ Py_DECREF(fut);
+ return NULL;
+}
+
+static PyObject *
+FutureIter_send(futureiterobject *self, PyObject *arg)
+{
+ if (arg != Py_None) {
+ PyErr_Format(PyExc_TypeError,
+ "can't send non-None value to a FutureIter");
+ return NULL;
+ }
+ return FutureIter_iternext(self);
+}
+
+static PyObject *
+FutureIter_throw(futureiterobject *self, PyObject *args)
+{
+ PyObject *type=NULL, *val=NULL, *tb=NULL;
+ if (!PyArg_ParseTuple(args, "O|OO", &type, &val, &tb))
+ return NULL;
+
+ if (val == Py_None) {
+ val = NULL;
+ }
+ if (tb == Py_None) {
+ tb = NULL;
+ }
+
+ Py_CLEAR(self->future);
+
+ if (tb != NULL) {
+ PyErr_Restore(type, val, tb);
+ }
+ else if (val != NULL) {
+ PyErr_SetObject(type, val);
+ }
+ else {
+ if (PyExceptionClass_Check(type)) {
+ val = PyObject_CallObject(type, NULL);
+ }
+ else {
+ val = type;
+ assert (PyExceptionInstance_Check(val));
+ type = (PyObject*)Py_TYPE(val);
+ assert (PyExceptionClass_Check(type));
+ }
+ PyErr_SetObject(type, val);
+ }
+ return FutureIter_iternext(self);
+}
+
+static PyObject *
+FutureIter_close(futureiterobject *self, PyObject *arg)
+{
+ Py_CLEAR(self->future);
+ Py_RETURN_NONE;
+}
+
+static int
+FutureIter_traverse(futureiterobject *it, visitproc visit, void *arg)
+{
+ Py_VISIT(it->future);
+ return 0;
+}
+
+static PyMethodDef FutureIter_methods[] = {
+ {"send", (PyCFunction)FutureIter_send, METH_O, NULL},
+ {"throw", (PyCFunction)FutureIter_throw, METH_VARARGS, NULL},
+ {"close", (PyCFunction)FutureIter_close, METH_NOARGS, NULL},
+ {NULL, NULL} /* Sentinel */
+};
+
+static PyTypeObject FutureIterType = {
+ PyVarObject_HEAD_INIT(0, 0)
+ "_futures.FutureIter",
+ sizeof(futureiterobject), /* tp_basicsize */
+ 0, /* tp_itemsize */
+ (destructor)FutureIter_dealloc, /* tp_dealloc */
+ 0, /* tp_print */
+ 0, /* tp_getattr */
+ 0, /* tp_setattr */
+ 0, /* tp_as_async */
+ 0, /* tp_repr */
+ 0, /* tp_as_number */
+ 0, /* tp_as_sequence */
+ 0, /* tp_as_mapping */
+ 0, /* tp_hash */
+ 0, /* tp_call */
+ 0, /* tp_str */
+ PyObject_GenericGetAttr, /* tp_getattro */
+ 0, /* tp_setattro */
+ 0, /* tp_as_buffer */
+ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /* tp_flags */
+ 0, /* tp_doc */
+ (traverseproc)FutureIter_traverse, /* tp_traverse */
+ 0, /* tp_clear */
+ 0, /* tp_richcompare */
+ 0, /* tp_weaklistoffset */
+ PyObject_SelfIter, /* tp_iter */
+ (iternextfunc)FutureIter_iternext, /* tp_iternext */
+ FutureIter_methods, /* tp_methods */
+ 0, /* tp_members */
+};
+
+static PyObject *
+new_future_iter(PyObject *fut)
+{
+ futureiterobject *it;
+
+ if (!PyObject_TypeCheck(fut, &FutureType)) {
+ PyErr_BadInternalCall();
+ return NULL;
+ }
+ it = PyObject_GC_New(futureiterobject, &FutureIterType);
+ if (it == NULL)
+ return NULL;
+ Py_INCREF(fut);
+ it->future = (FutureObj*)fut;
+ _PyObject_GC_TRACK(it);
+ return (PyObject*)it;
+}
+
+/*********************** Module **************************/
+
+PyDoc_STRVAR(module_doc, "Fast asyncio.Future implementation.\n");
+
+PyObject *
+_init_module(PyObject *self, PyObject *args)
+{
+ PyObject *extract_stack;
+ PyObject *get_event_loop;
+ PyObject *repr_info_func;
+ PyObject *invalidStateError;
+ PyObject *cancelledError;
+
+ if (!PyArg_UnpackTuple(args, "_init_module", 5, 5,
+ &extract_stack,
+ &get_event_loop,
+ &repr_info_func,
+ &invalidStateError,
+ &cancelledError)) {
+ return NULL;
+ }
+
+ Py_INCREF(extract_stack);
+ Py_XSETREF(traceback_extract_stack, extract_stack);
+
+ Py_INCREF(get_event_loop);
+ Py_XSETREF(asyncio_get_event_loop, get_event_loop);
+
+ Py_INCREF(repr_info_func);
+ Py_XSETREF(asyncio_repr_info_func, repr_info_func);
+
+ Py_INCREF(invalidStateError);
+ Py_XSETREF(asyncio_InvalidStateError, invalidStateError);
+
+ Py_INCREF(cancelledError);
+ Py_XSETREF(asyncio_CancelledError, cancelledError);
+
+ _futuremod_ready = 1;
+
+ Py_RETURN_NONE;
+}
+
+
+static struct PyMethodDef futuresmod_methods[] = {
+ {"_init_module", _init_module, METH_VARARGS, NULL},
+ {NULL, NULL}
+};
+
+
+static struct PyModuleDef _futuresmodule = {
+ PyModuleDef_HEAD_INIT, /* m_base */
+ "_futures", /* m_name */
+ module_doc, /* m_doc */
+ -1, /* m_size */
+ futuresmod_methods, /* m_methods */
+ NULL, /* m_slots */
+ NULL, /* m_traverse */
+ NULL, /* m_clear */
+ NULL, /* m_free */
+};
+
+
+PyMODINIT_FUNC
+PyInit__futures(void)
+{
+ if (PyType_Ready(&FutureType) < 0)
+ return NULL;
+ if (PyType_Ready(&FutureIterType) < 0)
+ return NULL;
+
+ PyObject *m = PyModule_Create(&_futuresmodule);
+ if (m == NULL)
+ return NULL;
+
+ Py_INCREF(&FutureType);
+ if (PyModule_AddObject(m, "Future", (PyObject *)&FutureType) < 0) {
+ Py_DECREF(&FutureType);
+ return NULL;
+ }
+
+ return m;
+}
diff -r 40c0c2eedf17 PCbuild/pythoncore.vcxproj
--- a/PCbuild/pythoncore.vcxproj Fri Oct 07 12:40:22 2016 -0400
+++ b/PCbuild/pythoncore.vcxproj Sat Oct 08 20:37:37 2016 +0900
@@ -218,12 +218,13 @@
+
diff -r 40c0c2eedf17 PCbuild/pythoncore.vcxproj.filters
--- a/PCbuild/pythoncore.vcxproj.filters Fri Oct 07 12:40:22 2016 -0400
+++ b/PCbuild/pythoncore.vcxproj.filters Sat Oct 08 20:37:37 2016 +0900
@@ -467,12 +467,15 @@
Modules
Modules
+
+ Modules
+
Modules
Modules
diff -r 40c0c2eedf17 setup.py
--- a/setup.py Fri Oct 07 12:40:22 2016 -0400
+++ b/setup.py Sat Oct 08 20:37:37 2016 +0900
@@ -653,12 +653,14 @@
exts.append( Extension('_lsprof', ['_lsprof.c', 'rotatingtree.c']) )
# static Unicode character database
exts.append( Extension('unicodedata', ['unicodedata.c'],
depends=['unicodedata_db.h', 'unicodename_db.h']) )
# _opcode module
exts.append( Extension('_opcode', ['_opcode.c']) )
+ # Fast asyncio Future implementation
+ exts.append( Extension("_futures", ["_futuresmodule.c"]) )
# Modules with some UNIX dependencies -- on by default:
# (If you have a really backward UNIX, select and socket may not be
# supported...)
# fcntl(2) and ioctl(2)