traverseda
/
cpython
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

bpo-40967: Remove deprecated asyncio.Task.current_task() and asyncio.Task.all_tasks() (GH-20874)

This commit is contained in:
Rémi Lapeyre 2020-07-02 05:41:21 +02:00 committed by GitHub
parent 666ecfb095
commit 004e64e805
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
7 changed files with 9 additions and 270 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
Doc/library/asyncio-task.rst
View File

@ -962,31 +962,6 @@ Task Object
.. versionadded:: 3.8
.. classmethod:: all_tasks(loop=None)
Return a set of all tasks for an event loop.
By default all tasks for the current event loop are returned.
If *loop* is ``None``, the :func:`get_event_loop` function
is used to get the current loop.
.. deprecated-removed:: 3.7 3.9
Do not call this as a task method. Use the :func:`asyncio.all_tasks`
function instead.
.. classmethod:: current_task(loop=None)
Return the currently running task or ``None``.
If *loop* is ``None``, the :func:`get_event_loop` function
is used to get the current loop.
.. deprecated-removed:: 3.7 3.9
Do not call this as a task method. Use the
:func:`asyncio.current_task` function instead.
.. _asyncio_generator_based_coro:

5
Doc/whatsnew/3.9.rst
View File

@ -878,6 +878,11 @@ Removed
deprecated since 2006, and only returning ``False`` when it's called.
(Contributed by Batuhan Taskaya in :issue:`40208`)
* The :meth:`asyncio.Task.current_task` and :meth:`asyncio.Task.all_tasks` have
have been removed. They were deprecated since Python 3.7 and you can use
:func:`asyncio.current_task` and :func:`asyncio.all_tasks` instead.
(Contributed by Rémi Lapeyre in :issue:`40967`)
Porting to Python 3.9
=====================

28
Lib/asyncio/tasks.py
View File

@ -113,34 +113,6 @@ class Task(futures._PyFuture): # Inherit Python Task implementation
# status is still pending
_log_destroy_pending = True
@classmethod
def current_task(cls, loop=None):
"""Return the currently running task in an event loop or None.
By default the current task for the current event loop is returned.
None is returned when called not in the context of a Task.
"""
warnings.warn("Task.current_task() is deprecated since Python 3.7, "
"use asyncio.current_task() instead",
DeprecationWarning,
stacklevel=2)
if loop is None:
loop = events.get_event_loop()
return current_task(loop)
@classmethod
def all_tasks(cls, loop=None):
"""Return a set of all tasks for an event loop.
By default all tasks for the current event loop are returned.
"""
warnings.warn("Task.all_tasks() is deprecated since Python 3.7, "
"use asyncio.all_tasks() instead",
DeprecationWarning,
stacklevel=2)
return _all_tasks_compat(loop)
def __init__(self, coro, *, loop=None, name=None):
super().__init__(loop=loop)
if self._source_traceback:

46
Lib/test/test_asyncio/test_tasks.py
View File

@ -1943,32 +1943,6 @@ class BaseTaskTests:
self.assertEqual(res, 'test')
self.assertIsNone(t2.result())
def test_current_task_deprecated(self):
Task = self.__class__.Task
with self.assertWarns(DeprecationWarning):
self.assertIsNone(Task.current_task(loop=self.loop))
async def coro(loop):
with self.assertWarns(DeprecationWarning):
self.assertIs(Task.current_task(loop=loop), task)
# See http://bugs.python.org/issue29271 for details:
asyncio.set_event_loop(loop)
try:
with self.assertWarns(DeprecationWarning):
self.assertIs(Task.current_task(None), task)
with self.assertWarns(DeprecationWarning):
self.assertIs(Task.current_task(), task)
finally:
asyncio.set_event_loop(None)
task = self.new_task(self.loop, coro(self.loop))
self.loop.run_until_complete(task)
with self.assertWarns(DeprecationWarning):
self.assertIsNone(Task.current_task(loop=self.loop))
def test_current_task(self):
self.assertIsNone(asyncio.current_task(loop=self.loop))
@ -2305,16 +2279,6 @@ class BaseTaskTests:
self.assertIsInstance(exception, Exception)
self.assertEqual(exception.args, ("foo", ))
def test_all_tasks_deprecated(self):
Task = self.__class__.Task
async def coro():
with self.assertWarns(DeprecationWarning):
assert Task.all_tasks(self.loop) == {t}
t = self.new_task(self.loop, coro())
self.loop.run_until_complete(t)
def test_log_destroyed_pending_task(self):
Task = self.__class__.Task
@ -2337,14 +2301,6 @@ class BaseTaskTests:
self.assertEqual(asyncio.all_tasks(loop=self.loop), {task})
# See http://bugs.python.org/issue29271 for details:
asyncio.set_event_loop(self.loop)
try:
with self.assertWarns(DeprecationWarning):
self.assertEqual(Task.all_tasks(), {task})
with self.assertWarns(DeprecationWarning):
self.assertEqual(Task.all_tasks(None), {task})
finally:
asyncio.set_event_loop(None)
# execute the task so it waits for future
@ -3043,8 +2999,6 @@ class BaseTaskIntrospectionTests:
self.assertEqual(asyncio.all_tasks(loop), set())
self._register_task(task)
self.assertEqual(asyncio.all_tasks(loop), set())
with self.assertWarns(DeprecationWarning):
self.assertEqual(asyncio.Task.all_tasks(loop), {task})
self._unregister_task(task)
def test__enter_task(self):

2
Misc/NEWS.d/next/Library/2020-06-15-00-13-57.bpo-40967._dx3OO.rst Normal file
View File

@ -0,0 +1,2 @@
Removed :meth:`asyncio.Task.current_task` and
:meth:`asyncio.Task.all_tasks`. Patch contributed by Rémi Lapeyre.

89
Modules/_asynciomodule.c
View File

@ -13,10 +13,8 @@ module _asyncio
_Py_IDENTIFIER(__asyncio_running_event_loop__);
_Py_IDENTIFIER(_asyncio_future_blocking);
_Py_IDENTIFIER(add_done_callback);
_Py_IDENTIFIER(_all_tasks_compat);
_Py_IDENTIFIER(call_soon);
_Py_IDENTIFIER(cancel);
_Py_IDENTIFIER(current_task);
_Py_IDENTIFIER(get_event_loop);
_Py_IDENTIFIER(send);
_Py_IDENTIFIER(throw);
@ -2182,91 +2180,6 @@ TaskObj_get_fut_waiter(TaskObj *task, void *Py_UNUSED(ignored))
Py_RETURN_NONE;
}
/*[clinic input]
@classmethod
_asyncio.Task.current_task
loop: object = None
Return the currently running task in an event loop or None.
By default the current task for the current event loop is returned.
None is returned when called not in the context of a Task.
[clinic start generated code]*/
static PyObject *
_asyncio_Task_current_task_impl(PyTypeObject *type, PyObject *loop)
/*[clinic end generated code: output=99fbe7332c516e03 input=cd14770c5b79c7eb]*/
{
PyObject *ret;
PyObject *current_task_func;
if (PyErr_WarnEx(PyExc_DeprecationWarning,
"Task.current_task() is deprecated, " \
"use asyncio.current_task() instead",
1) < 0) {
return NULL;
}
current_task_func = _PyObject_GetAttrId(asyncio_mod, &PyId_current_task);
if (current_task_func == NULL) {
return NULL;
}
if (loop == Py_None) {
loop = get_event_loop();
if (loop == NULL) {
Py_DECREF(current_task_func);
return NULL;
}
ret = PyObject_CallOneArg(current_task_func, loop);
Py_DECREF(current_task_func);
Py_DECREF(loop);
return ret;
}
else {
ret = PyObject_CallOneArg(current_task_func, loop);
Py_DECREF(current_task_func);
return ret;
}
}
/*[clinic input]
@classmethod
_asyncio.Task.all_tasks
loop: object = None
Return a set of all tasks for an event loop.
By default all tasks for the current event loop are returned.
[clinic start generated code]*/
static PyObject *
_asyncio_Task_all_tasks_impl(PyTypeObject *type, PyObject *loop)
/*[clinic end generated code: output=11f9b20749ccca5d input=497f80bc9ce726b5]*/
{
PyObject *res;
PyObject *all_tasks_func;
if (PyErr_WarnEx(PyExc_DeprecationWarning,
"Task.all_tasks() is deprecated, " \
"use asyncio.all_tasks() instead",
1) < 0) {
return NULL;
}
all_tasks_func = _PyObject_GetAttrId(asyncio_mod, &PyId__all_tasks_compat);
if (all_tasks_func == NULL) {
return NULL;
}
res = PyObject_CallOneArg(all_tasks_func, loop);
Py_DECREF(all_tasks_func);
return res;
}
/*[clinic input]
_asyncio.Task._make_cancelled_error
@ -2587,8 +2500,6 @@ static PyMethodDef TaskType_methods[] = {
_ASYNCIO_FUTURE_DONE_METHODDEF
_ASYNCIO_TASK_SET_RESULT_METHODDEF
_ASYNCIO_TASK_SET_EXCEPTION_METHODDEF
_ASYNCIO_TASK_CURRENT_TASK_METHODDEF
_ASYNCIO_TASK_ALL_TASKS_METHODDEF
_ASYNCIO_TASK_CANCEL_METHODDEF
_ASYNCIO_TASK_GET_STACK_METHODDEF
_ASYNCIO_TASK_PRINT_STACK_METHODDEF

82
Modules/clinic/_asynciomodule.c.h generated
View File

@ -355,86 +355,6 @@ 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)(void(*)(void))_asyncio_Task_current_task, METH_FASTCALL|METH_KEYWORDS|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 *const *args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
static const char * const _keywords[] = {"loop", NULL};
static _PyArg_Parser _parser = {NULL, _keywords, "current_task", 0};
PyObject *argsbuf[1];
Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
PyObject *loop = Py_None;
args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
if (!args) {
goto exit;
}
if (!noptargs) {
goto skip_optional_pos;
}
loop = args[0];
skip_optional_pos:
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)(void(*)(void))_asyncio_Task_all_tasks, METH_FASTCALL|METH_KEYWORDS|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 *const *args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
static const char * const _keywords[] = {"loop", NULL};
static _PyArg_Parser _parser = {NULL, _keywords, "all_tasks", 0};
PyObject *argsbuf[1];
Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
PyObject *loop = Py_None;
args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
if (!args) {
goto exit;
}
if (!noptargs) {
goto skip_optional_pos;
}
loop = args[0];
skip_optional_pos:
return_value = _asyncio_Task_all_tasks_impl(type, loop);
exit:
return return_value;
}
PyDoc_STRVAR(_asyncio_Task__make_cancelled_error__doc__,
"_make_cancelled_error($self, /)\n"
"--\n"
@ -912,4 +832,4 @@ _asyncio__leave_task(PyObject *module, PyObject *const *args, Py_ssize_t nargs,
exit:
return return_value;
}
/*[clinic end generated code: output=0e5c1eb8b692977b input=a9049054013a1b77]*/
/*[clinic end generated code: output=d0fc522bcbff9d61 input=a9049054013a1b77]*/