Yury Selivanov
10 years ago
9 changed files with 2744 additions and 586 deletions
-
2Lib/asyncio/base_events.py
-
70Lib/asyncio/base_futures.py
-
76Lib/asyncio/base_tasks.py
-
4Lib/asyncio/coroutines.py
-
89Lib/asyncio/futures.py
-
80Lib/asyncio/tasks.py
-
439Lib/test/test_asyncio/test_tasks.py
-
2050Modules/_asynciomodule.c
-
520Modules/clinic/_asynciomodule.c.h
@ -0,0 +1,70 @@ |
|||||
|
__all__ = [] |
||||
|
|
||||
|
import concurrent.futures._base |
||||
|
import reprlib |
||||
|
|
||||
|
from . import events |
||||
|
|
||||
|
Error = concurrent.futures._base.Error |
||||
|
CancelledError = concurrent.futures.CancelledError |
||||
|
TimeoutError = concurrent.futures.TimeoutError |
||||
|
|
||||
|
|
||||
|
class InvalidStateError(Error): |
||||
|
"""The operation is not allowed in this state.""" |
||||
|
|
||||
|
|
||||
|
# States for Future. |
||||
|
_PENDING = 'PENDING' |
||||
|
_CANCELLED = 'CANCELLED' |
||||
|
_FINISHED = 'FINISHED' |
||||
|
|
||||
|
|
||||
|
def isfuture(obj): |
||||
|
"""Check for a Future. |
||||
|
|
||||
|
This returns True when obj is a Future instance or is advertising |
||||
|
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 |
||||
@ -0,0 +1,76 @@ |
|||||
|
import linecache |
||||
|
import traceback |
||||
|
|
||||
|
from . import base_futures |
||||
|
from . import coroutines |
||||
|
|
||||
|
|
||||
|
def _task_repr_info(task): |
||||
|
info = base_futures._future_repr_info(task) |
||||
|
|
||||
|
if task._must_cancel: |
||||
|
# replace status |
||||
|
info[0] = 'cancelling' |
||||
|
|
||||
|
coro = coroutines._format_coroutine(task._coro) |
||||
|
info.insert(1, 'coro=<%s>' % coro) |
||||
|
|
||||
|
if task._fut_waiter is not None: |
||||
|
info.insert(2, 'wait_for=%r' % task._fut_waiter) |
||||
|
return info |
||||
|
|
||||
|
|
||||
|
def _task_get_stack(task, limit): |
||||
|
frames = [] |
||||
|
try: |
||||
|
# 'async def' coroutines |
||||
|
f = task._coro.cr_frame |
||||
|
except AttributeError: |
||||
|
f = task._coro.gi_frame |
||||
|
if f is not None: |
||||
|
while f is not None: |
||||
|
if limit is not None: |
||||
|
if limit <= 0: |
||||
|
break |
||||
|
limit -= 1 |
||||
|
frames.append(f) |
||||
|
f = f.f_back |
||||
|
frames.reverse() |
||||
|
elif task._exception is not None: |
||||
|
tb = task._exception.__traceback__ |
||||
|
while tb is not None: |
||||
|
if limit is not None: |
||||
|
if limit <= 0: |
||||
|
break |
||||
|
limit -= 1 |
||||
|
frames.append(tb.tb_frame) |
||||
|
tb = tb.tb_next |
||||
|
return frames |
||||
|
|
||||
|
|
||||
|
def _task_print_stack(task, limit, file): |
||||
|
extracted_list = [] |
||||
|
checked = set() |
||||
|
for f in task.get_stack(limit=limit): |
||||
|
lineno = f.f_lineno |
||||
|
co = f.f_code |
||||
|
filename = co.co_filename |
||||
|
name = co.co_name |
||||
|
if filename not in checked: |
||||
|
checked.add(filename) |
||||
|
linecache.checkcache(filename) |
||||
|
line = linecache.getline(filename, lineno, f.f_globals) |
||||
|
extracted_list.append((filename, lineno, name, line)) |
||||
|
exc = task._exception |
||||
|
if not extracted_list: |
||||
|
print('No stack for %r' % task, file=file) |
||||
|
elif exc is not None: |
||||
|
print('Traceback for %r (most recent call last):' % task, |
||||
|
file=file) |
||||
|
else: |
||||
|
print('Stack for %r (most recent call last):' % task, |
||||
|
file=file) |
||||
|
traceback.print_list(extracted_list, file=file) |
||||
|
if exc is not None: |
||||
|
for line in traceback.format_exception_only(exc.__class__, exc): |
||||
|
print(line, file=file, end='') |
||||
439
Lib/test/test_asyncio/test_tasks.py
File diff suppressed because it is too large
View File
File diff suppressed because it is too large
View File
2050
Modules/_asynciomodule.c
File diff suppressed because it is too large
View File
File diff suppressed because it is too large
View File
@ -0,0 +1,520 @@ |
|||||
|
/*[clinic input] |
||||
|
preserve |
||||
|
[clinic start generated code]*/ |
||||
|
|
||||
|
PyDoc_STRVAR(_asyncio_Future___init____doc__, |
||||
|
"Future(*, loop=None)\n" |
||||
|
"--\n" |
||||
|
"\n" |
||||
|
"This class is *almost* compatible with concurrent.futures.Future.\n" |
||||
|
"\n" |
||||
|
" Differences:\n" |
||||
|
"\n" |
||||
|
" - result() and exception() do not take a timeout argument and\n" |
||||
|
" raise an exception when the future isn\'t done yet.\n" |
||||
|
"\n" |
||||
|
" - Callbacks registered with add_done_callback() are always called\n" |
||||
|
" via the event loop\'s call_soon_threadsafe().\n" |
||||
|
"\n" |
||||
|
" - This class is not compatible with the wait() and as_completed()\n" |
||||
|
" methods in the concurrent.futures package."); |
||||
|
|
||||
|
static int |
||||
|
_asyncio_Future___init___impl(FutureObj *self, PyObject *loop); |
||||
|
|
||||
|
static int |
||||
|
_asyncio_Future___init__(PyObject *self, PyObject *args, PyObject *kwargs) |
||||
|
{ |
||||
|
int return_value = -1; |
||||
|
static const char * const _keywords[] = {"loop", NULL}; |
||||
|
static _PyArg_Parser _parser = {"|$O:Future", _keywords, 0}; |
||||
|
PyObject *loop = NULL; |
||||
|
|
||||
|
if (!_PyArg_ParseTupleAndKeywordsFast(args, kwargs, &_parser, |
||||
|
&loop)) { |
||||
|
goto exit; |
||||
|
} |
||||
|
return_value = _asyncio_Future___init___impl((FutureObj *)self, loop); |
||||
|
|
||||
|
exit: |
||||
|
return return_value; |
||||
|
} |
||||
|
|
||||
|
PyDoc_STRVAR(_asyncio_Future_result__doc__, |
||||
|
"result($self, /)\n" |
||||
|
"--\n" |
||||
|
"\n" |
||||
|
"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."); |
||||
|
|
||||
|
#define _ASYNCIO_FUTURE_RESULT_METHODDEF \ |
||||
|
{"result", (PyCFunction)_asyncio_Future_result, METH_NOARGS, _asyncio_Future_result__doc__}, |
||||
|
|
||||
|
static PyObject * |
||||
|
_asyncio_Future_result_impl(FutureObj *self); |
||||
|
|
||||
|
static PyObject * |
||||
|
_asyncio_Future_result(FutureObj *self, PyObject *Py_UNUSED(ignored)) |
||||
|
{ |
||||
|
return _asyncio_Future_result_impl(self); |
||||
|
} |
||||
|
|
||||
|
PyDoc_STRVAR(_asyncio_Future_exception__doc__, |
||||
|
"exception($self, /)\n" |
||||
|
"--\n" |
||||
|
"\n" |
||||
|
"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."); |
||||
|
|
||||
|
#define _ASYNCIO_FUTURE_EXCEPTION_METHODDEF \ |
||||
|
{"exception", (PyCFunction)_asyncio_Future_exception, METH_NOARGS, _asyncio_Future_exception__doc__}, |
||||
|
|
||||
|
static PyObject * |
||||
|
_asyncio_Future_exception_impl(FutureObj *self); |
||||
|
|
||||
|
static PyObject * |
||||
|
_asyncio_Future_exception(FutureObj *self, PyObject *Py_UNUSED(ignored)) |
||||
|
{ |
||||
|
return _asyncio_Future_exception_impl(self); |
||||
|
} |
||||
|
|
||||
|
PyDoc_STRVAR(_asyncio_Future_set_result__doc__, |
||||
|
"set_result($self, res, /)\n" |
||||
|
"--\n" |
||||
|
"\n" |
||||
|
"Mark the future done and set its result.\n" |
||||
|
"\n" |
||||
|
"If the future is already done when this method is called, raises\n" |
||||
|
"InvalidStateError."); |
||||
|
|
||||
|
#define _ASYNCIO_FUTURE_SET_RESULT_METHODDEF \ |
||||
|
{"set_result", (PyCFunction)_asyncio_Future_set_result, METH_O, _asyncio_Future_set_result__doc__}, |
||||
|
|
||||
|
PyDoc_STRVAR(_asyncio_Future_set_exception__doc__, |
||||
|
"set_exception($self, exception, /)\n" |
||||
|
"--\n" |
||||
|
"\n" |
||||
|
"Mark the future done and set an exception.\n" |
||||
|
"\n" |
||||
|
"If the future is already done when this method is called, raises\n" |
||||
|
"InvalidStateError."); |
||||
|
|
||||
|
#define _ASYNCIO_FUTURE_SET_EXCEPTION_METHODDEF \ |
||||
|
{"set_exception", (PyCFunction)_asyncio_Future_set_exception, METH_O, _asyncio_Future_set_exception__doc__}, |
||||
|
|
||||
|
PyDoc_STRVAR(_asyncio_Future_add_done_callback__doc__, |
||||
|
"add_done_callback($self, fn, /)\n" |
||||
|
"--\n" |
||||
|
"\n" |
||||
|
"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."); |
||||
|
|
||||
|
#define _ASYNCIO_FUTURE_ADD_DONE_CALLBACK_METHODDEF \ |
||||
|
{"add_done_callback", (PyCFunction)_asyncio_Future_add_done_callback, METH_O, _asyncio_Future_add_done_callback__doc__}, |
||||
|
|
||||
|
PyDoc_STRVAR(_asyncio_Future_remove_done_callback__doc__, |
||||
|
"remove_done_callback($self, fn, /)\n" |
||||
|
"--\n" |
||||
|
"\n" |
||||
|
"Remove all instances of a callback from the \"call when done\" list.\n" |
||||
|
"\n" |
||||
|
"Returns the number of callbacks removed."); |
||||
|
|
||||
|
#define _ASYNCIO_FUTURE_REMOVE_DONE_CALLBACK_METHODDEF \ |
||||
|
{"remove_done_callback", (PyCFunction)_asyncio_Future_remove_done_callback, METH_O, _asyncio_Future_remove_done_callback__doc__}, |
||||
|
|
||||
|
PyDoc_STRVAR(_asyncio_Future_cancel__doc__, |
||||
|
"cancel($self, /)\n" |
||||
|
"--\n" |
||||
|
"\n" |
||||
|
"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."); |
||||
|
|
||||
|
#define _ASYNCIO_FUTURE_CANCEL_METHODDEF \ |
||||
|
{"cancel", (PyCFunction)_asyncio_Future_cancel, METH_NOARGS, _asyncio_Future_cancel__doc__}, |
||||
|
|
||||
|
static PyObject * |
||||
|
_asyncio_Future_cancel_impl(FutureObj *self); |
||||
|
|
||||
|
static PyObject * |
||||
|
_asyncio_Future_cancel(FutureObj *self, PyObject *Py_UNUSED(ignored)) |
||||
|
{ |
||||
|
return _asyncio_Future_cancel_impl(self); |
||||
|
} |
||||
|
|
||||
|
PyDoc_STRVAR(_asyncio_Future_cancelled__doc__, |
||||
|
"cancelled($self, /)\n" |
||||
|
"--\n" |
||||
|
"\n" |
||||
|
"Return True if the future was cancelled."); |
||||
|
|
||||
|
#define _ASYNCIO_FUTURE_CANCELLED_METHODDEF \ |
||||
|
{"cancelled", (PyCFunction)_asyncio_Future_cancelled, METH_NOARGS, _asyncio_Future_cancelled__doc__}, |
||||
|
|
||||
|
static PyObject * |
||||
|
_asyncio_Future_cancelled_impl(FutureObj *self); |
||||
|
|
||||
|
static PyObject * |
||||
|
_asyncio_Future_cancelled(FutureObj *self, PyObject *Py_UNUSED(ignored)) |
||||
|
{ |
||||
|
return _asyncio_Future_cancelled_impl(self); |
||||
|
} |
||||
|
|
||||
|
PyDoc_STRVAR(_asyncio_Future_done__doc__, |
||||
|
"done($self, /)\n" |
||||
|
"--\n" |
||||
|
"\n" |
||||
|
"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."); |
||||
|
|
||||
|
#define _ASYNCIO_FUTURE_DONE_METHODDEF \ |
||||
|
{"done", (PyCFunction)_asyncio_Future_done, METH_NOARGS, _asyncio_Future_done__doc__}, |
||||
|
|
||||
|
static PyObject * |
||||
|
_asyncio_Future_done_impl(FutureObj *self); |
||||
|
|
||||
|
static PyObject * |
||||
|
_asyncio_Future_done(FutureObj *self, PyObject *Py_UNUSED(ignored)) |
||||
|
{ |
||||
|
return _asyncio_Future_done_impl(self); |
||||
|
} |
||||
|
|
||||
|
PyDoc_STRVAR(_asyncio_Future__repr_info__doc__, |
||||
|
"_repr_info($self, /)\n" |
||||
|
"--\n" |
||||
|
"\n"); |
||||
|
|
||||
|
#define _ASYNCIO_FUTURE__REPR_INFO_METHODDEF \ |
||||
|
{"_repr_info", (PyCFunction)_asyncio_Future__repr_info, METH_NOARGS, _asyncio_Future__repr_info__doc__}, |
||||
|
|
||||
|
static PyObject * |
||||
|
_asyncio_Future__repr_info_impl(FutureObj *self); |
||||
|
|
||||
|
static PyObject * |
||||
|
_asyncio_Future__repr_info(FutureObj *self, PyObject *Py_UNUSED(ignored)) |
||||
|
{ |
||||
|
return _asyncio_Future__repr_info_impl(self); |
||||
|
} |
||||
|
|
||||
|
PyDoc_STRVAR(_asyncio_Future__schedule_callbacks__doc__, |
||||
|
"_schedule_callbacks($self, /)\n" |
||||
|
"--\n" |
||||
|
"\n"); |
||||
|
|
||||
|
#define _ASYNCIO_FUTURE__SCHEDULE_CALLBACKS_METHODDEF \ |
||||
|
{"_schedule_callbacks", (PyCFunction)_asyncio_Future__schedule_callbacks, METH_NOARGS, _asyncio_Future__schedule_callbacks__doc__}, |
||||
|
|
||||
|
static PyObject * |
||||
|
_asyncio_Future__schedule_callbacks_impl(FutureObj *self); |
||||
|
|
||||
|
static PyObject * |
||||
|
_asyncio_Future__schedule_callbacks(FutureObj *self, PyObject *Py_UNUSED(ignored)) |
||||
|
{ |
||||
|
return _asyncio_Future__schedule_callbacks_impl(self); |
||||
|
} |
||||
|
|
||||
|
PyDoc_STRVAR(_asyncio_Task___init____doc__, |
||||
|
"Task(coro, *, loop=None)\n" |
||||
|
"--\n" |
||||
|
"\n" |
||||
|
"A coroutine wrapped in a Future."); |
||||
|
|
||||
|
static int |
||||
|
_asyncio_Task___init___impl(TaskObj *self, PyObject *coro, PyObject *loop); |
||||
|
|
||||
|
static int |
||||
|
_asyncio_Task___init__(PyObject *self, PyObject *args, PyObject *kwargs) |
||||
|
{ |
||||
|
int return_value = -1; |
||||
|
static const char * const _keywords[] = {"coro", "loop", NULL}; |
||||
|
static _PyArg_Parser _parser = {"O|$O:Task", _keywords, 0}; |
||||
|
PyObject *coro; |
||||
|
PyObject *loop = NULL; |
||||
|
|
||||
|
if (!_PyArg_ParseTupleAndKeywordsFast(args, kwargs, &_parser, |
||||
|
&coro, &loop)) { |
||||
|
goto exit; |
||||
|
} |
||||
|
return_value = _asyncio_Task___init___impl((TaskObj *)self, coro, loop); |
||||
|
|
||||
|
exit: |
||||
|
return return_value; |
||||
|
} |
||||
|
|
||||
|
PyDoc_STRVAR(_asyncio_Task_current_task__doc__, |
||||
|
"current_task($type, /, loop=None)\n" |
||||
|
"--\n" |
||||
|
"\n" |
||||
|
"Return the currently running task in an event loop or None.\n" |
||||
|
"\n" |
||||
|
"By default the current task for the current event loop is returned.\n" |
||||
|
"\n" |
||||
|
"None is returned when called not in the context of a Task."); |
||||
|
|
||||
|
#define _ASYNCIO_TASK_CURRENT_TASK_METHODDEF \ |
||||
|
{"current_task", (PyCFunction)_asyncio_Task_current_task, METH_FASTCALL|METH_CLASS, _asyncio_Task_current_task__doc__}, |
||||
|
|
||||
|
static PyObject * |
||||
|
_asyncio_Task_current_task_impl(PyTypeObject *type, PyObject *loop); |
||||
|
|
||||
|
static PyObject * |
||||
|
_asyncio_Task_current_task(PyTypeObject *type, PyObject **args, Py_ssize_t nargs, PyObject *kwnames) |
||||
|
{ |
||||
|
PyObject *return_value = NULL; |
||||
|
static const char * const _keywords[] = {"loop", NULL}; |
||||
|
static _PyArg_Parser _parser = {"|O:current_task", _keywords, 0}; |
||||
|
PyObject *loop = NULL; |
||||
|
|
||||
|
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser, |
||||
|
&loop)) { |
||||
|
goto exit; |
||||
|
} |
||||
|
return_value = _asyncio_Task_current_task_impl(type, loop); |
||||
|
|
||||
|
exit: |
||||
|
return return_value; |
||||
|
} |
||||
|
|
||||
|
PyDoc_STRVAR(_asyncio_Task_all_tasks__doc__, |
||||
|
"all_tasks($type, /, loop=None)\n" |
||||
|
"--\n" |
||||
|
"\n" |
||||
|
"Return a set of all tasks for an event loop.\n" |
||||
|
"\n" |
||||
|
"By default all tasks for the current event loop are returned."); |
||||
|
|
||||
|
#define _ASYNCIO_TASK_ALL_TASKS_METHODDEF \ |
||||
|
{"all_tasks", (PyCFunction)_asyncio_Task_all_tasks, METH_FASTCALL|METH_CLASS, _asyncio_Task_all_tasks__doc__}, |
||||
|
|
||||
|
static PyObject * |
||||
|
_asyncio_Task_all_tasks_impl(PyTypeObject *type, PyObject *loop); |
||||
|
|
||||
|
static PyObject * |
||||
|
_asyncio_Task_all_tasks(PyTypeObject *type, PyObject **args, Py_ssize_t nargs, PyObject *kwnames) |
||||
|
{ |
||||
|
PyObject *return_value = NULL; |
||||
|
static const char * const _keywords[] = {"loop", NULL}; |
||||
|
static _PyArg_Parser _parser = {"|O:all_tasks", _keywords, 0}; |
||||
|
PyObject *loop = NULL; |
||||
|
|
||||
|
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser, |
||||
|
&loop)) { |
||||
|
goto exit; |
||||
|
} |
||||
|
return_value = _asyncio_Task_all_tasks_impl(type, loop); |
||||
|
|
||||
|
exit: |
||||
|
return return_value; |
||||
|
} |
||||
|
|
||||
|
PyDoc_STRVAR(_asyncio_Task__repr_info__doc__, |
||||
|
"_repr_info($self, /)\n" |
||||
|
"--\n" |
||||
|
"\n"); |
||||
|
|
||||
|
#define _ASYNCIO_TASK__REPR_INFO_METHODDEF \ |
||||
|
{"_repr_info", (PyCFunction)_asyncio_Task__repr_info, METH_NOARGS, _asyncio_Task__repr_info__doc__}, |
||||
|
|
||||
|
static PyObject * |
||||
|
_asyncio_Task__repr_info_impl(TaskObj *self); |
||||
|
|
||||
|
static PyObject * |
||||
|
_asyncio_Task__repr_info(TaskObj *self, PyObject *Py_UNUSED(ignored)) |
||||
|
{ |
||||
|
return _asyncio_Task__repr_info_impl(self); |
||||
|
} |
||||
|
|
||||
|
PyDoc_STRVAR(_asyncio_Task_cancel__doc__, |
||||
|
"cancel($self, /)\n" |
||||
|
"--\n" |
||||
|
"\n" |
||||
|
"Request that this task cancel itself.\n" |
||||
|
"\n" |
||||
|
"This arranges for a CancelledError to be thrown into the\n" |
||||
|
"wrapped coroutine on the next cycle through the event loop.\n" |
||||
|
"The coroutine then has a chance to clean up or even deny\n" |
||||
|
"the request using try/except/finally.\n" |
||||
|
"\n" |
||||
|
"Unlike Future.cancel, this does not guarantee that the\n" |
||||
|
"task will be cancelled: the exception might be caught and\n" |
||||
|
"acted upon, delaying cancellation of the task or preventing\n" |
||||
|
"cancellation completely. The task may also return a value or\n" |
||||
|
"raise a different exception.\n" |
||||
|
"\n" |
||||
|
"Immediately after this method is called, Task.cancelled() will\n" |
||||
|
"not return True (unless the task was already cancelled). A\n" |
||||
|
"task will be marked as cancelled when the wrapped coroutine\n" |
||||
|
"terminates with a CancelledError exception (even if cancel()\n" |
||||
|
"was not called)."); |
||||
|
|
||||
|
#define _ASYNCIO_TASK_CANCEL_METHODDEF \ |
||||
|
{"cancel", (PyCFunction)_asyncio_Task_cancel, METH_NOARGS, _asyncio_Task_cancel__doc__}, |
||||
|
|
||||
|
static PyObject * |
||||
|
_asyncio_Task_cancel_impl(TaskObj *self); |
||||
|
|
||||
|
static PyObject * |
||||
|
_asyncio_Task_cancel(TaskObj *self, PyObject *Py_UNUSED(ignored)) |
||||
|
{ |
||||
|
return _asyncio_Task_cancel_impl(self); |
||||
|
} |
||||
|
|
||||
|
PyDoc_STRVAR(_asyncio_Task_get_stack__doc__, |
||||
|
"get_stack($self, /, *, limit=None)\n" |
||||
|
"--\n" |
||||
|
"\n" |
||||
|
"Return the list of stack frames for this task\'s coroutine.\n" |
||||
|
"\n" |
||||
|
"If the coroutine is not done, this returns the stack where it is\n" |
||||
|
"suspended. If the coroutine has completed successfully or was\n" |
||||
|
"cancelled, this returns an empty list. If the coroutine was\n" |
||||
|
"terminated by an exception, this returns the list of traceback\n" |
||||
|
"frames.\n" |
||||
|
"\n" |
||||
|
"The frames are always ordered from oldest to newest.\n" |
||||
|
"\n" |
||||
|
"The optional limit gives the maximum number of frames to\n" |
||||
|
"return; by default all available frames are returned. Its\n" |
||||
|
"meaning differs depending on whether a stack or a traceback is\n" |
||||
|
"returned: the newest frames of a stack are returned, but the\n" |
||||
|
"oldest frames of a traceback are returned. (This matches the\n" |
||||
|
"behavior of the traceback module.)\n" |
||||
|
"\n" |
||||
|
"For reasons beyond our control, only one stack frame is\n" |
||||
|
"returned for a suspended coroutine."); |
||||
|
|
||||
|
#define _ASYNCIO_TASK_GET_STACK_METHODDEF \ |
||||
|
{"get_stack", (PyCFunction)_asyncio_Task_get_stack, METH_FASTCALL, _asyncio_Task_get_stack__doc__}, |
||||
|
|
||||
|
static PyObject * |
||||
|
_asyncio_Task_get_stack_impl(TaskObj *self, PyObject *limit); |
||||
|
|
||||
|
static PyObject * |
||||
|
_asyncio_Task_get_stack(TaskObj *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames) |
||||
|
{ |
||||
|
PyObject *return_value = NULL; |
||||
|
static const char * const _keywords[] = {"limit", NULL}; |
||||
|
static _PyArg_Parser _parser = {"|$O:get_stack", _keywords, 0}; |
||||
|
PyObject *limit = Py_None; |
||||
|
|
||||
|
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser, |
||||
|
&limit)) { |
||||
|
goto exit; |
||||
|
} |
||||
|
return_value = _asyncio_Task_get_stack_impl(self, limit); |
||||
|
|
||||
|
exit: |
||||
|
return return_value; |
||||
|
} |
||||
|
|
||||
|
PyDoc_STRVAR(_asyncio_Task_print_stack__doc__, |
||||
|
"print_stack($self, /, *, limit=None, file=None)\n" |
||||
|
"--\n" |
||||
|
"\n" |
||||
|
"Print the stack or traceback for this task\'s coroutine.\n" |
||||
|
"\n" |
||||
|
"This produces output similar to that of the traceback module,\n" |
||||
|
"for the frames retrieved by get_stack(). The limit argument\n" |
||||
|
"is passed to get_stack(). The file argument is an I/O stream\n" |
||||
|
"to which the output is written; by default output is written\n" |
||||
|
"to sys.stderr."); |
||||
|
|
||||
|
#define _ASYNCIO_TASK_PRINT_STACK_METHODDEF \ |
||||
|
{"print_stack", (PyCFunction)_asyncio_Task_print_stack, METH_FASTCALL, _asyncio_Task_print_stack__doc__}, |
||||
|
|
||||
|
static PyObject * |
||||
|
_asyncio_Task_print_stack_impl(TaskObj *self, PyObject *limit, |
||||
|
PyObject *file); |
||||
|
|
||||
|
static PyObject * |
||||
|
_asyncio_Task_print_stack(TaskObj *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames) |
||||
|
{ |
||||
|
PyObject *return_value = NULL; |
||||
|
static const char * const _keywords[] = {"limit", "file", NULL}; |
||||
|
static _PyArg_Parser _parser = {"|$OO:print_stack", _keywords, 0}; |
||||
|
PyObject *limit = Py_None; |
||||
|
PyObject *file = Py_None; |
||||
|
|
||||
|
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser, |
||||
|
&limit, &file)) { |
||||
|
goto exit; |
||||
|
} |
||||
|
return_value = _asyncio_Task_print_stack_impl(self, limit, file); |
||||
|
|
||||
|
exit: |
||||
|
return return_value; |
||||
|
} |
||||
|
|
||||
|
PyDoc_STRVAR(_asyncio_Task__step__doc__, |
||||
|
"_step($self, /, exc=None)\n" |
||||
|
"--\n" |
||||
|
"\n"); |
||||
|
|
||||
|
#define _ASYNCIO_TASK__STEP_METHODDEF \ |
||||
|
{"_step", (PyCFunction)_asyncio_Task__step, METH_FASTCALL, _asyncio_Task__step__doc__}, |
||||
|
|
||||
|
static PyObject * |
||||
|
_asyncio_Task__step_impl(TaskObj *self, PyObject *exc); |
||||
|
|
||||
|
static PyObject * |
||||
|
_asyncio_Task__step(TaskObj *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames) |
||||
|
{ |
||||
|
PyObject *return_value = NULL; |
||||
|
static const char * const _keywords[] = {"exc", NULL}; |
||||
|
static _PyArg_Parser _parser = {"|O:_step", _keywords, 0}; |
||||
|
PyObject *exc = NULL; |
||||
|
|
||||
|
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser, |
||||
|
&exc)) { |
||||
|
goto exit; |
||||
|
} |
||||
|
return_value = _asyncio_Task__step_impl(self, exc); |
||||
|
|
||||
|
exit: |
||||
|
return return_value; |
||||
|
} |
||||
|
|
||||
|
PyDoc_STRVAR(_asyncio_Task__wakeup__doc__, |
||||
|
"_wakeup($self, /, fut)\n" |
||||
|
"--\n" |
||||
|
"\n"); |
||||
|
|
||||
|
#define _ASYNCIO_TASK__WAKEUP_METHODDEF \ |
||||
|
{"_wakeup", (PyCFunction)_asyncio_Task__wakeup, METH_FASTCALL, _asyncio_Task__wakeup__doc__}, |
||||
|
|
||||
|
static PyObject * |
||||
|
_asyncio_Task__wakeup_impl(TaskObj *self, PyObject *fut); |
||||
|
|
||||
|
static PyObject * |
||||
|
_asyncio_Task__wakeup(TaskObj *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames) |
||||
|
{ |
||||
|
PyObject *return_value = NULL; |
||||
|
static const char * const _keywords[] = {"fut", NULL}; |
||||
|
static _PyArg_Parser _parser = {"O:_wakeup", _keywords, 0}; |
||||
|
PyObject *fut; |
||||
|
|
||||
|
if (!_PyArg_ParseStack(args, nargs, kwnames, &_parser, |
||||
|
&fut)) { |
||||
|
goto exit; |
||||
|
} |
||||
|
return_value = _asyncio_Task__wakeup_impl(self, fut); |
||||
|
|
||||
|
exit: |
||||
|
return return_value; |
||||
|
} |
||||
|
/*[clinic end generated code: output=8f036321bb083066 input=a9049054013a1b77]*/ |
||||
Write
Preview
Loading…
Cancel
Save
Reference in new issue