LCOV - code coverage report
Current view: top level - Modules/clinic - _asynciomodule.c.h (source / functions) Hit Total Coverage
Test: CPython 3.12 LCOV report [commit 5e6661bce9] Lines: 0 232 0.0 %
Date: 2023-03-20 08:15:36 Functions: 0 30 0.0 %
Branches: 0 198 0.0 %

           Branch data     Line data    Source code
       1                 :            : /*[clinic input]
       2                 :            : preserve
       3                 :            : [clinic start generated code]*/
       4                 :            : 
       5                 :            : #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
       6                 :            : #  include "pycore_gc.h"            // PyGC_Head
       7                 :            : #  include "pycore_runtime.h"       // _Py_ID()
       8                 :            : #endif
       9                 :            : 
      10                 :            : 
      11                 :            : PyDoc_STRVAR(_asyncio_Future___init____doc__,
      12                 :            : "Future(*, loop=None)\n"
      13                 :            : "--\n"
      14                 :            : "\n"
      15                 :            : "This class is *almost* compatible with concurrent.futures.Future.\n"
      16                 :            : "\n"
      17                 :            : "    Differences:\n"
      18                 :            : "\n"
      19                 :            : "    - result() and exception() do not take a timeout argument and\n"
      20                 :            : "      raise an exception when the future isn\'t done yet.\n"
      21                 :            : "\n"
      22                 :            : "    - Callbacks registered with add_done_callback() are always called\n"
      23                 :            : "      via the event loop\'s call_soon_threadsafe().\n"
      24                 :            : "\n"
      25                 :            : "    - This class is not compatible with the wait() and as_completed()\n"
      26                 :            : "      methods in the concurrent.futures package.");
      27                 :            : 
      28                 :            : static int
      29                 :            : _asyncio_Future___init___impl(FutureObj *self, PyObject *loop);
      30                 :            : 
      31                 :            : static int
      32                 :          0 : _asyncio_Future___init__(PyObject *self, PyObject *args, PyObject *kwargs)
      33                 :            : {
      34                 :          0 :     int return_value = -1;
      35                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
      36                 :            : 
      37                 :            :     #define NUM_KEYWORDS 1
      38                 :            :     static struct {
      39                 :            :         PyGC_Head _this_is_not_used;
      40                 :            :         PyObject_VAR_HEAD
      41                 :            :         PyObject *ob_item[NUM_KEYWORDS];
      42                 :            :     } _kwtuple = {
      43                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
      44                 :            :         .ob_item = { &_Py_ID(loop), },
      45                 :            :     };
      46                 :            :     #undef NUM_KEYWORDS
      47                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
      48                 :            : 
      49                 :            :     #else  // !Py_BUILD_CORE
      50                 :            :     #  define KWTUPLE NULL
      51                 :            :     #endif  // !Py_BUILD_CORE
      52                 :            : 
      53                 :            :     static const char * const _keywords[] = {"loop", NULL};
      54                 :            :     static _PyArg_Parser _parser = {
      55                 :            :         .keywords = _keywords,
      56                 :            :         .fname = "Future",
      57                 :            :         .kwtuple = KWTUPLE,
      58                 :            :     };
      59                 :            :     #undef KWTUPLE
      60                 :            :     PyObject *argsbuf[1];
      61                 :            :     PyObject * const *fastargs;
      62                 :          0 :     Py_ssize_t nargs = PyTuple_GET_SIZE(args);
      63         [ #  # ]:          0 :     Py_ssize_t noptargs = nargs + (kwargs ? PyDict_GET_SIZE(kwargs) : 0) - 0;
      64                 :          0 :     PyObject *loop = Py_None;
      65                 :            : 
      66   [ #  #  #  #  :          0 :     fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser, 0, 0, 0, argsbuf);
             #  #  #  # ]
      67         [ #  # ]:          0 :     if (!fastargs) {
      68                 :          0 :         goto exit;
      69                 :            :     }
      70         [ #  # ]:          0 :     if (!noptargs) {
      71                 :          0 :         goto skip_optional_kwonly;
      72                 :            :     }
      73                 :          0 :     loop = fastargs[0];
      74                 :          0 : skip_optional_kwonly:
      75                 :          0 :     return_value = _asyncio_Future___init___impl((FutureObj *)self, loop);
      76                 :            : 
      77                 :          0 : exit:
      78                 :          0 :     return return_value;
      79                 :            : }
      80                 :            : 
      81                 :            : PyDoc_STRVAR(_asyncio_Future_result__doc__,
      82                 :            : "result($self, /)\n"
      83                 :            : "--\n"
      84                 :            : "\n"
      85                 :            : "Return the result this future represents.\n"
      86                 :            : "\n"
      87                 :            : "If the future has been cancelled, raises CancelledError.  If the\n"
      88                 :            : "future\'s result isn\'t yet available, raises InvalidStateError.  If\n"
      89                 :            : "the future is done and has an exception set, this exception is raised.");
      90                 :            : 
      91                 :            : #define _ASYNCIO_FUTURE_RESULT_METHODDEF    \
      92                 :            :     {"result", (PyCFunction)_asyncio_Future_result, METH_NOARGS, _asyncio_Future_result__doc__},
      93                 :            : 
      94                 :            : static PyObject *
      95                 :            : _asyncio_Future_result_impl(FutureObj *self);
      96                 :            : 
      97                 :            : static PyObject *
      98                 :          0 : _asyncio_Future_result(FutureObj *self, PyObject *Py_UNUSED(ignored))
      99                 :            : {
     100                 :          0 :     return _asyncio_Future_result_impl(self);
     101                 :            : }
     102                 :            : 
     103                 :            : PyDoc_STRVAR(_asyncio_Future_exception__doc__,
     104                 :            : "exception($self, /)\n"
     105                 :            : "--\n"
     106                 :            : "\n"
     107                 :            : "Return the exception that was set on this future.\n"
     108                 :            : "\n"
     109                 :            : "The exception (or None if no exception was set) is returned only if\n"
     110                 :            : "the future is done.  If the future has been cancelled, raises\n"
     111                 :            : "CancelledError.  If the future isn\'t done yet, raises\n"
     112                 :            : "InvalidStateError.");
     113                 :            : 
     114                 :            : #define _ASYNCIO_FUTURE_EXCEPTION_METHODDEF    \
     115                 :            :     {"exception", _PyCFunction_CAST(_asyncio_Future_exception), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _asyncio_Future_exception__doc__},
     116                 :            : 
     117                 :            : static PyObject *
     118                 :            : _asyncio_Future_exception_impl(FutureObj *self, PyTypeObject *cls);
     119                 :            : 
     120                 :            : static PyObject *
     121                 :          0 : _asyncio_Future_exception(FutureObj *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
     122                 :            : {
     123         [ #  # ]:          0 :     if (nargs) {
     124                 :          0 :         PyErr_SetString(PyExc_TypeError, "exception() takes no arguments");
     125                 :          0 :         return NULL;
     126                 :            :     }
     127                 :          0 :     return _asyncio_Future_exception_impl(self, cls);
     128                 :            : }
     129                 :            : 
     130                 :            : PyDoc_STRVAR(_asyncio_Future_set_result__doc__,
     131                 :            : "set_result($self, result, /)\n"
     132                 :            : "--\n"
     133                 :            : "\n"
     134                 :            : "Mark the future done and set its result.\n"
     135                 :            : "\n"
     136                 :            : "If the future is already done when this method is called, raises\n"
     137                 :            : "InvalidStateError.");
     138                 :            : 
     139                 :            : #define _ASYNCIO_FUTURE_SET_RESULT_METHODDEF    \
     140                 :            :     {"set_result", _PyCFunction_CAST(_asyncio_Future_set_result), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _asyncio_Future_set_result__doc__},
     141                 :            : 
     142                 :            : static PyObject *
     143                 :            : _asyncio_Future_set_result_impl(FutureObj *self, PyTypeObject *cls,
     144                 :            :                                 PyObject *result);
     145                 :            : 
     146                 :            : static PyObject *
     147                 :          0 : _asyncio_Future_set_result(FutureObj *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
     148                 :            : {
     149                 :          0 :     PyObject *return_value = NULL;
     150                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
     151                 :            :     #  define KWTUPLE (PyObject *)&_Py_SINGLETON(tuple_empty)
     152                 :            :     #else
     153                 :            :     #  define KWTUPLE NULL
     154                 :            :     #endif
     155                 :            : 
     156                 :            :     static const char * const _keywords[] = {"", NULL};
     157                 :            :     static _PyArg_Parser _parser = {
     158                 :            :         .keywords = _keywords,
     159                 :            :         .fname = "set_result",
     160                 :            :         .kwtuple = KWTUPLE,
     161                 :            :     };
     162                 :            :     #undef KWTUPLE
     163                 :            :     PyObject *argsbuf[1];
     164                 :            :     PyObject *result;
     165                 :            : 
     166   [ #  #  #  #  :          0 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
             #  #  #  # ]
     167         [ #  # ]:          0 :     if (!args) {
     168                 :          0 :         goto exit;
     169                 :            :     }
     170                 :          0 :     result = args[0];
     171                 :          0 :     return_value = _asyncio_Future_set_result_impl(self, cls, result);
     172                 :            : 
     173                 :          0 : exit:
     174                 :          0 :     return return_value;
     175                 :            : }
     176                 :            : 
     177                 :            : PyDoc_STRVAR(_asyncio_Future_set_exception__doc__,
     178                 :            : "set_exception($self, exception, /)\n"
     179                 :            : "--\n"
     180                 :            : "\n"
     181                 :            : "Mark the future done and set an exception.\n"
     182                 :            : "\n"
     183                 :            : "If the future is already done when this method is called, raises\n"
     184                 :            : "InvalidStateError.");
     185                 :            : 
     186                 :            : #define _ASYNCIO_FUTURE_SET_EXCEPTION_METHODDEF    \
     187                 :            :     {"set_exception", _PyCFunction_CAST(_asyncio_Future_set_exception), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _asyncio_Future_set_exception__doc__},
     188                 :            : 
     189                 :            : static PyObject *
     190                 :            : _asyncio_Future_set_exception_impl(FutureObj *self, PyTypeObject *cls,
     191                 :            :                                    PyObject *exception);
     192                 :            : 
     193                 :            : static PyObject *
     194                 :          0 : _asyncio_Future_set_exception(FutureObj *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
     195                 :            : {
     196                 :          0 :     PyObject *return_value = NULL;
     197                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
     198                 :            :     #  define KWTUPLE (PyObject *)&_Py_SINGLETON(tuple_empty)
     199                 :            :     #else
     200                 :            :     #  define KWTUPLE NULL
     201                 :            :     #endif
     202                 :            : 
     203                 :            :     static const char * const _keywords[] = {"", NULL};
     204                 :            :     static _PyArg_Parser _parser = {
     205                 :            :         .keywords = _keywords,
     206                 :            :         .fname = "set_exception",
     207                 :            :         .kwtuple = KWTUPLE,
     208                 :            :     };
     209                 :            :     #undef KWTUPLE
     210                 :            :     PyObject *argsbuf[1];
     211                 :            :     PyObject *exception;
     212                 :            : 
     213   [ #  #  #  #  :          0 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
             #  #  #  # ]
     214         [ #  # ]:          0 :     if (!args) {
     215                 :          0 :         goto exit;
     216                 :            :     }
     217                 :          0 :     exception = args[0];
     218                 :          0 :     return_value = _asyncio_Future_set_exception_impl(self, cls, exception);
     219                 :            : 
     220                 :          0 : exit:
     221                 :          0 :     return return_value;
     222                 :            : }
     223                 :            : 
     224                 :            : PyDoc_STRVAR(_asyncio_Future_add_done_callback__doc__,
     225                 :            : "add_done_callback($self, fn, /, *, context=<unrepresentable>)\n"
     226                 :            : "--\n"
     227                 :            : "\n"
     228                 :            : "Add a callback to be run when the future becomes done.\n"
     229                 :            : "\n"
     230                 :            : "The callback is called with a single argument - the future object. If\n"
     231                 :            : "the future is already done when this is called, the callback is\n"
     232                 :            : "scheduled with call_soon.");
     233                 :            : 
     234                 :            : #define _ASYNCIO_FUTURE_ADD_DONE_CALLBACK_METHODDEF    \
     235                 :            :     {"add_done_callback", _PyCFunction_CAST(_asyncio_Future_add_done_callback), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _asyncio_Future_add_done_callback__doc__},
     236                 :            : 
     237                 :            : static PyObject *
     238                 :            : _asyncio_Future_add_done_callback_impl(FutureObj *self, PyTypeObject *cls,
     239                 :            :                                        PyObject *fn, PyObject *context);
     240                 :            : 
     241                 :            : static PyObject *
     242                 :          0 : _asyncio_Future_add_done_callback(FutureObj *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
     243                 :            : {
     244                 :          0 :     PyObject *return_value = NULL;
     245                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
     246                 :            : 
     247                 :            :     #define NUM_KEYWORDS 1
     248                 :            :     static struct {
     249                 :            :         PyGC_Head _this_is_not_used;
     250                 :            :         PyObject_VAR_HEAD
     251                 :            :         PyObject *ob_item[NUM_KEYWORDS];
     252                 :            :     } _kwtuple = {
     253                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
     254                 :            :         .ob_item = { &_Py_ID(context), },
     255                 :            :     };
     256                 :            :     #undef NUM_KEYWORDS
     257                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
     258                 :            : 
     259                 :            :     #else  // !Py_BUILD_CORE
     260                 :            :     #  define KWTUPLE NULL
     261                 :            :     #endif  // !Py_BUILD_CORE
     262                 :            : 
     263                 :            :     static const char * const _keywords[] = {"", "context", NULL};
     264                 :            :     static _PyArg_Parser _parser = {
     265                 :            :         .keywords = _keywords,
     266                 :            :         .fname = "add_done_callback",
     267                 :            :         .kwtuple = KWTUPLE,
     268                 :            :     };
     269                 :            :     #undef KWTUPLE
     270                 :            :     PyObject *argsbuf[2];
     271         [ #  # ]:          0 :     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
     272                 :            :     PyObject *fn;
     273                 :          0 :     PyObject *context = NULL;
     274                 :            : 
     275   [ #  #  #  #  :          0 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
             #  #  #  # ]
     276         [ #  # ]:          0 :     if (!args) {
     277                 :          0 :         goto exit;
     278                 :            :     }
     279                 :          0 :     fn = args[0];
     280         [ #  # ]:          0 :     if (!noptargs) {
     281                 :          0 :         goto skip_optional_kwonly;
     282                 :            :     }
     283                 :          0 :     context = args[1];
     284                 :          0 : skip_optional_kwonly:
     285                 :          0 :     return_value = _asyncio_Future_add_done_callback_impl(self, cls, fn, context);
     286                 :            : 
     287                 :          0 : exit:
     288                 :          0 :     return return_value;
     289                 :            : }
     290                 :            : 
     291                 :            : PyDoc_STRVAR(_asyncio_Future_remove_done_callback__doc__,
     292                 :            : "remove_done_callback($self, fn, /)\n"
     293                 :            : "--\n"
     294                 :            : "\n"
     295                 :            : "Remove all instances of a callback from the \"call when done\" list.\n"
     296                 :            : "\n"
     297                 :            : "Returns the number of callbacks removed.");
     298                 :            : 
     299                 :            : #define _ASYNCIO_FUTURE_REMOVE_DONE_CALLBACK_METHODDEF    \
     300                 :            :     {"remove_done_callback", _PyCFunction_CAST(_asyncio_Future_remove_done_callback), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _asyncio_Future_remove_done_callback__doc__},
     301                 :            : 
     302                 :            : static PyObject *
     303                 :            : _asyncio_Future_remove_done_callback_impl(FutureObj *self, PyTypeObject *cls,
     304                 :            :                                           PyObject *fn);
     305                 :            : 
     306                 :            : static PyObject *
     307                 :          0 : _asyncio_Future_remove_done_callback(FutureObj *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
     308                 :            : {
     309                 :          0 :     PyObject *return_value = NULL;
     310                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
     311                 :            :     #  define KWTUPLE (PyObject *)&_Py_SINGLETON(tuple_empty)
     312                 :            :     #else
     313                 :            :     #  define KWTUPLE NULL
     314                 :            :     #endif
     315                 :            : 
     316                 :            :     static const char * const _keywords[] = {"", NULL};
     317                 :            :     static _PyArg_Parser _parser = {
     318                 :            :         .keywords = _keywords,
     319                 :            :         .fname = "remove_done_callback",
     320                 :            :         .kwtuple = KWTUPLE,
     321                 :            :     };
     322                 :            :     #undef KWTUPLE
     323                 :            :     PyObject *argsbuf[1];
     324                 :            :     PyObject *fn;
     325                 :            : 
     326   [ #  #  #  #  :          0 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
             #  #  #  # ]
     327         [ #  # ]:          0 :     if (!args) {
     328                 :          0 :         goto exit;
     329                 :            :     }
     330                 :          0 :     fn = args[0];
     331                 :          0 :     return_value = _asyncio_Future_remove_done_callback_impl(self, cls, fn);
     332                 :            : 
     333                 :          0 : exit:
     334                 :          0 :     return return_value;
     335                 :            : }
     336                 :            : 
     337                 :            : PyDoc_STRVAR(_asyncio_Future_cancel__doc__,
     338                 :            : "cancel($self, /, msg=None)\n"
     339                 :            : "--\n"
     340                 :            : "\n"
     341                 :            : "Cancel the future and schedule callbacks.\n"
     342                 :            : "\n"
     343                 :            : "If the future is already done or cancelled, return False.  Otherwise,\n"
     344                 :            : "change the future\'s state to cancelled, schedule the callbacks and\n"
     345                 :            : "return True.");
     346                 :            : 
     347                 :            : #define _ASYNCIO_FUTURE_CANCEL_METHODDEF    \
     348                 :            :     {"cancel", _PyCFunction_CAST(_asyncio_Future_cancel), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _asyncio_Future_cancel__doc__},
     349                 :            : 
     350                 :            : static PyObject *
     351                 :            : _asyncio_Future_cancel_impl(FutureObj *self, PyTypeObject *cls,
     352                 :            :                             PyObject *msg);
     353                 :            : 
     354                 :            : static PyObject *
     355                 :          0 : _asyncio_Future_cancel(FutureObj *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
     356                 :            : {
     357                 :          0 :     PyObject *return_value = NULL;
     358                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
     359                 :            : 
     360                 :            :     #define NUM_KEYWORDS 1
     361                 :            :     static struct {
     362                 :            :         PyGC_Head _this_is_not_used;
     363                 :            :         PyObject_VAR_HEAD
     364                 :            :         PyObject *ob_item[NUM_KEYWORDS];
     365                 :            :     } _kwtuple = {
     366                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
     367                 :            :         .ob_item = { &_Py_ID(msg), },
     368                 :            :     };
     369                 :            :     #undef NUM_KEYWORDS
     370                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
     371                 :            : 
     372                 :            :     #else  // !Py_BUILD_CORE
     373                 :            :     #  define KWTUPLE NULL
     374                 :            :     #endif  // !Py_BUILD_CORE
     375                 :            : 
     376                 :            :     static const char * const _keywords[] = {"msg", NULL};
     377                 :            :     static _PyArg_Parser _parser = {
     378                 :            :         .keywords = _keywords,
     379                 :            :         .fname = "cancel",
     380                 :            :         .kwtuple = KWTUPLE,
     381                 :            :     };
     382                 :            :     #undef KWTUPLE
     383                 :            :     PyObject *argsbuf[1];
     384         [ #  # ]:          0 :     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
     385                 :          0 :     PyObject *msg = Py_None;
     386                 :            : 
     387   [ #  #  #  #  :          0 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
             #  #  #  # ]
     388         [ #  # ]:          0 :     if (!args) {
     389                 :          0 :         goto exit;
     390                 :            :     }
     391         [ #  # ]:          0 :     if (!noptargs) {
     392                 :          0 :         goto skip_optional_pos;
     393                 :            :     }
     394                 :          0 :     msg = args[0];
     395                 :          0 : skip_optional_pos:
     396                 :          0 :     return_value = _asyncio_Future_cancel_impl(self, cls, msg);
     397                 :            : 
     398                 :          0 : exit:
     399                 :          0 :     return return_value;
     400                 :            : }
     401                 :            : 
     402                 :            : PyDoc_STRVAR(_asyncio_Future_cancelled__doc__,
     403                 :            : "cancelled($self, /)\n"
     404                 :            : "--\n"
     405                 :            : "\n"
     406                 :            : "Return True if the future was cancelled.");
     407                 :            : 
     408                 :            : #define _ASYNCIO_FUTURE_CANCELLED_METHODDEF    \
     409                 :            :     {"cancelled", (PyCFunction)_asyncio_Future_cancelled, METH_NOARGS, _asyncio_Future_cancelled__doc__},
     410                 :            : 
     411                 :            : static PyObject *
     412                 :            : _asyncio_Future_cancelled_impl(FutureObj *self);
     413                 :            : 
     414                 :            : static PyObject *
     415                 :          0 : _asyncio_Future_cancelled(FutureObj *self, PyObject *Py_UNUSED(ignored))
     416                 :            : {
     417                 :          0 :     return _asyncio_Future_cancelled_impl(self);
     418                 :            : }
     419                 :            : 
     420                 :            : PyDoc_STRVAR(_asyncio_Future_done__doc__,
     421                 :            : "done($self, /)\n"
     422                 :            : "--\n"
     423                 :            : "\n"
     424                 :            : "Return True if the future is done.\n"
     425                 :            : "\n"
     426                 :            : "Done means either that a result / exception are available, or that the\n"
     427                 :            : "future was cancelled.");
     428                 :            : 
     429                 :            : #define _ASYNCIO_FUTURE_DONE_METHODDEF    \
     430                 :            :     {"done", (PyCFunction)_asyncio_Future_done, METH_NOARGS, _asyncio_Future_done__doc__},
     431                 :            : 
     432                 :            : static PyObject *
     433                 :            : _asyncio_Future_done_impl(FutureObj *self);
     434                 :            : 
     435                 :            : static PyObject *
     436                 :          0 : _asyncio_Future_done(FutureObj *self, PyObject *Py_UNUSED(ignored))
     437                 :            : {
     438                 :          0 :     return _asyncio_Future_done_impl(self);
     439                 :            : }
     440                 :            : 
     441                 :            : PyDoc_STRVAR(_asyncio_Future_get_loop__doc__,
     442                 :            : "get_loop($self, /)\n"
     443                 :            : "--\n"
     444                 :            : "\n"
     445                 :            : "Return the event loop the Future is bound to.");
     446                 :            : 
     447                 :            : #define _ASYNCIO_FUTURE_GET_LOOP_METHODDEF    \
     448                 :            :     {"get_loop", _PyCFunction_CAST(_asyncio_Future_get_loop), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _asyncio_Future_get_loop__doc__},
     449                 :            : 
     450                 :            : static PyObject *
     451                 :            : _asyncio_Future_get_loop_impl(FutureObj *self, PyTypeObject *cls);
     452                 :            : 
     453                 :            : static PyObject *
     454                 :          0 : _asyncio_Future_get_loop(FutureObj *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
     455                 :            : {
     456         [ #  # ]:          0 :     if (nargs) {
     457                 :          0 :         PyErr_SetString(PyExc_TypeError, "get_loop() takes no arguments");
     458                 :          0 :         return NULL;
     459                 :            :     }
     460                 :          0 :     return _asyncio_Future_get_loop_impl(self, cls);
     461                 :            : }
     462                 :            : 
     463                 :            : PyDoc_STRVAR(_asyncio_Future__make_cancelled_error__doc__,
     464                 :            : "_make_cancelled_error($self, /)\n"
     465                 :            : "--\n"
     466                 :            : "\n"
     467                 :            : "Create the CancelledError to raise if the Future is cancelled.\n"
     468                 :            : "\n"
     469                 :            : "This should only be called once when handling a cancellation since\n"
     470                 :            : "it erases the context exception value.");
     471                 :            : 
     472                 :            : #define _ASYNCIO_FUTURE__MAKE_CANCELLED_ERROR_METHODDEF    \
     473                 :            :     {"_make_cancelled_error", (PyCFunction)_asyncio_Future__make_cancelled_error, METH_NOARGS, _asyncio_Future__make_cancelled_error__doc__},
     474                 :            : 
     475                 :            : static PyObject *
     476                 :            : _asyncio_Future__make_cancelled_error_impl(FutureObj *self);
     477                 :            : 
     478                 :            : static PyObject *
     479                 :          0 : _asyncio_Future__make_cancelled_error(FutureObj *self, PyObject *Py_UNUSED(ignored))
     480                 :            : {
     481                 :          0 :     return _asyncio_Future__make_cancelled_error_impl(self);
     482                 :            : }
     483                 :            : 
     484                 :            : PyDoc_STRVAR(_asyncio_Task___init____doc__,
     485                 :            : "Task(coro, *, loop=None, name=None, context=None)\n"
     486                 :            : "--\n"
     487                 :            : "\n"
     488                 :            : "A coroutine wrapped in a Future.");
     489                 :            : 
     490                 :            : static int
     491                 :            : _asyncio_Task___init___impl(TaskObj *self, PyObject *coro, PyObject *loop,
     492                 :            :                             PyObject *name, PyObject *context);
     493                 :            : 
     494                 :            : static int
     495                 :          0 : _asyncio_Task___init__(PyObject *self, PyObject *args, PyObject *kwargs)
     496                 :            : {
     497                 :          0 :     int return_value = -1;
     498                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
     499                 :            : 
     500                 :            :     #define NUM_KEYWORDS 4
     501                 :            :     static struct {
     502                 :            :         PyGC_Head _this_is_not_used;
     503                 :            :         PyObject_VAR_HEAD
     504                 :            :         PyObject *ob_item[NUM_KEYWORDS];
     505                 :            :     } _kwtuple = {
     506                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
     507                 :            :         .ob_item = { &_Py_ID(coro), &_Py_ID(loop), &_Py_ID(name), &_Py_ID(context), },
     508                 :            :     };
     509                 :            :     #undef NUM_KEYWORDS
     510                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
     511                 :            : 
     512                 :            :     #else  // !Py_BUILD_CORE
     513                 :            :     #  define KWTUPLE NULL
     514                 :            :     #endif  // !Py_BUILD_CORE
     515                 :            : 
     516                 :            :     static const char * const _keywords[] = {"coro", "loop", "name", "context", NULL};
     517                 :            :     static _PyArg_Parser _parser = {
     518                 :            :         .keywords = _keywords,
     519                 :            :         .fname = "Task",
     520                 :            :         .kwtuple = KWTUPLE,
     521                 :            :     };
     522                 :            :     #undef KWTUPLE
     523                 :            :     PyObject *argsbuf[4];
     524                 :            :     PyObject * const *fastargs;
     525                 :          0 :     Py_ssize_t nargs = PyTuple_GET_SIZE(args);
     526         [ #  # ]:          0 :     Py_ssize_t noptargs = nargs + (kwargs ? PyDict_GET_SIZE(kwargs) : 0) - 1;
     527                 :            :     PyObject *coro;
     528                 :          0 :     PyObject *loop = Py_None;
     529                 :          0 :     PyObject *name = Py_None;
     530                 :          0 :     PyObject *context = Py_None;
     531                 :            : 
     532   [ #  #  #  #  :          0 :     fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser, 1, 1, 0, argsbuf);
             #  #  #  # ]
     533         [ #  # ]:          0 :     if (!fastargs) {
     534                 :          0 :         goto exit;
     535                 :            :     }
     536                 :          0 :     coro = fastargs[0];
     537         [ #  # ]:          0 :     if (!noptargs) {
     538                 :          0 :         goto skip_optional_kwonly;
     539                 :            :     }
     540         [ #  # ]:          0 :     if (fastargs[1]) {
     541                 :          0 :         loop = fastargs[1];
     542         [ #  # ]:          0 :         if (!--noptargs) {
     543                 :          0 :             goto skip_optional_kwonly;
     544                 :            :         }
     545                 :            :     }
     546         [ #  # ]:          0 :     if (fastargs[2]) {
     547                 :          0 :         name = fastargs[2];
     548         [ #  # ]:          0 :         if (!--noptargs) {
     549                 :          0 :             goto skip_optional_kwonly;
     550                 :            :         }
     551                 :            :     }
     552                 :          0 :     context = fastargs[3];
     553                 :          0 : skip_optional_kwonly:
     554                 :          0 :     return_value = _asyncio_Task___init___impl((TaskObj *)self, coro, loop, name, context);
     555                 :            : 
     556                 :          0 : exit:
     557                 :          0 :     return return_value;
     558                 :            : }
     559                 :            : 
     560                 :            : PyDoc_STRVAR(_asyncio_Task__make_cancelled_error__doc__,
     561                 :            : "_make_cancelled_error($self, /)\n"
     562                 :            : "--\n"
     563                 :            : "\n"
     564                 :            : "Create the CancelledError to raise if the Task is cancelled.\n"
     565                 :            : "\n"
     566                 :            : "This should only be called once when handling a cancellation since\n"
     567                 :            : "it erases the context exception value.");
     568                 :            : 
     569                 :            : #define _ASYNCIO_TASK__MAKE_CANCELLED_ERROR_METHODDEF    \
     570                 :            :     {"_make_cancelled_error", (PyCFunction)_asyncio_Task__make_cancelled_error, METH_NOARGS, _asyncio_Task__make_cancelled_error__doc__},
     571                 :            : 
     572                 :            : static PyObject *
     573                 :            : _asyncio_Task__make_cancelled_error_impl(TaskObj *self);
     574                 :            : 
     575                 :            : static PyObject *
     576                 :          0 : _asyncio_Task__make_cancelled_error(TaskObj *self, PyObject *Py_UNUSED(ignored))
     577                 :            : {
     578                 :          0 :     return _asyncio_Task__make_cancelled_error_impl(self);
     579                 :            : }
     580                 :            : 
     581                 :            : PyDoc_STRVAR(_asyncio_Task_cancel__doc__,
     582                 :            : "cancel($self, /, msg=None)\n"
     583                 :            : "--\n"
     584                 :            : "\n"
     585                 :            : "Request that this task cancel itself.\n"
     586                 :            : "\n"
     587                 :            : "This arranges for a CancelledError to be thrown into the\n"
     588                 :            : "wrapped coroutine on the next cycle through the event loop.\n"
     589                 :            : "The coroutine then has a chance to clean up or even deny\n"
     590                 :            : "the request using try/except/finally.\n"
     591                 :            : "\n"
     592                 :            : "Unlike Future.cancel, this does not guarantee that the\n"
     593                 :            : "task will be cancelled: the exception might be caught and\n"
     594                 :            : "acted upon, delaying cancellation of the task or preventing\n"
     595                 :            : "cancellation completely.  The task may also return a value or\n"
     596                 :            : "raise a different exception.\n"
     597                 :            : "\n"
     598                 :            : "Immediately after this method is called, Task.cancelled() will\n"
     599                 :            : "not return True (unless the task was already cancelled).  A\n"
     600                 :            : "task will be marked as cancelled when the wrapped coroutine\n"
     601                 :            : "terminates with a CancelledError exception (even if cancel()\n"
     602                 :            : "was not called).\n"
     603                 :            : "\n"
     604                 :            : "This also increases the task\'s count of cancellation requests.");
     605                 :            : 
     606                 :            : #define _ASYNCIO_TASK_CANCEL_METHODDEF    \
     607                 :            :     {"cancel", _PyCFunction_CAST(_asyncio_Task_cancel), METH_FASTCALL|METH_KEYWORDS, _asyncio_Task_cancel__doc__},
     608                 :            : 
     609                 :            : static PyObject *
     610                 :            : _asyncio_Task_cancel_impl(TaskObj *self, PyObject *msg);
     611                 :            : 
     612                 :            : static PyObject *
     613                 :          0 : _asyncio_Task_cancel(TaskObj *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
     614                 :            : {
     615                 :          0 :     PyObject *return_value = NULL;
     616                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
     617                 :            : 
     618                 :            :     #define NUM_KEYWORDS 1
     619                 :            :     static struct {
     620                 :            :         PyGC_Head _this_is_not_used;
     621                 :            :         PyObject_VAR_HEAD
     622                 :            :         PyObject *ob_item[NUM_KEYWORDS];
     623                 :            :     } _kwtuple = {
     624                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
     625                 :            :         .ob_item = { &_Py_ID(msg), },
     626                 :            :     };
     627                 :            :     #undef NUM_KEYWORDS
     628                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
     629                 :            : 
     630                 :            :     #else  // !Py_BUILD_CORE
     631                 :            :     #  define KWTUPLE NULL
     632                 :            :     #endif  // !Py_BUILD_CORE
     633                 :            : 
     634                 :            :     static const char * const _keywords[] = {"msg", NULL};
     635                 :            :     static _PyArg_Parser _parser = {
     636                 :            :         .keywords = _keywords,
     637                 :            :         .fname = "cancel",
     638                 :            :         .kwtuple = KWTUPLE,
     639                 :            :     };
     640                 :            :     #undef KWTUPLE
     641                 :            :     PyObject *argsbuf[1];
     642         [ #  # ]:          0 :     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
     643                 :          0 :     PyObject *msg = Py_None;
     644                 :            : 
     645   [ #  #  #  #  :          0 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
             #  #  #  # ]
     646         [ #  # ]:          0 :     if (!args) {
     647                 :          0 :         goto exit;
     648                 :            :     }
     649         [ #  # ]:          0 :     if (!noptargs) {
     650                 :          0 :         goto skip_optional_pos;
     651                 :            :     }
     652                 :          0 :     msg = args[0];
     653                 :          0 : skip_optional_pos:
     654                 :          0 :     return_value = _asyncio_Task_cancel_impl(self, msg);
     655                 :            : 
     656                 :          0 : exit:
     657                 :          0 :     return return_value;
     658                 :            : }
     659                 :            : 
     660                 :            : PyDoc_STRVAR(_asyncio_Task_cancelling__doc__,
     661                 :            : "cancelling($self, /)\n"
     662                 :            : "--\n"
     663                 :            : "\n"
     664                 :            : "Return the count of the task\'s cancellation requests.\n"
     665                 :            : "\n"
     666                 :            : "This count is incremented when .cancel() is called\n"
     667                 :            : "and may be decremented using .uncancel().");
     668                 :            : 
     669                 :            : #define _ASYNCIO_TASK_CANCELLING_METHODDEF    \
     670                 :            :     {"cancelling", (PyCFunction)_asyncio_Task_cancelling, METH_NOARGS, _asyncio_Task_cancelling__doc__},
     671                 :            : 
     672                 :            : static PyObject *
     673                 :            : _asyncio_Task_cancelling_impl(TaskObj *self);
     674                 :            : 
     675                 :            : static PyObject *
     676                 :          0 : _asyncio_Task_cancelling(TaskObj *self, PyObject *Py_UNUSED(ignored))
     677                 :            : {
     678                 :          0 :     return _asyncio_Task_cancelling_impl(self);
     679                 :            : }
     680                 :            : 
     681                 :            : PyDoc_STRVAR(_asyncio_Task_uncancel__doc__,
     682                 :            : "uncancel($self, /)\n"
     683                 :            : "--\n"
     684                 :            : "\n"
     685                 :            : "Decrement the task\'s count of cancellation requests.\n"
     686                 :            : "\n"
     687                 :            : "This should be used by tasks that catch CancelledError\n"
     688                 :            : "and wish to continue indefinitely until they are cancelled again.\n"
     689                 :            : "\n"
     690                 :            : "Returns the remaining number of cancellation requests.");
     691                 :            : 
     692                 :            : #define _ASYNCIO_TASK_UNCANCEL_METHODDEF    \
     693                 :            :     {"uncancel", (PyCFunction)_asyncio_Task_uncancel, METH_NOARGS, _asyncio_Task_uncancel__doc__},
     694                 :            : 
     695                 :            : static PyObject *
     696                 :            : _asyncio_Task_uncancel_impl(TaskObj *self);
     697                 :            : 
     698                 :            : static PyObject *
     699                 :          0 : _asyncio_Task_uncancel(TaskObj *self, PyObject *Py_UNUSED(ignored))
     700                 :            : {
     701                 :          0 :     return _asyncio_Task_uncancel_impl(self);
     702                 :            : }
     703                 :            : 
     704                 :            : PyDoc_STRVAR(_asyncio_Task_get_stack__doc__,
     705                 :            : "get_stack($self, /, *, limit=None)\n"
     706                 :            : "--\n"
     707                 :            : "\n"
     708                 :            : "Return the list of stack frames for this task\'s coroutine.\n"
     709                 :            : "\n"
     710                 :            : "If the coroutine is not done, this returns the stack where it is\n"
     711                 :            : "suspended.  If the coroutine has completed successfully or was\n"
     712                 :            : "cancelled, this returns an empty list.  If the coroutine was\n"
     713                 :            : "terminated by an exception, this returns the list of traceback\n"
     714                 :            : "frames.\n"
     715                 :            : "\n"
     716                 :            : "The frames are always ordered from oldest to newest.\n"
     717                 :            : "\n"
     718                 :            : "The optional limit gives the maximum number of frames to\n"
     719                 :            : "return; by default all available frames are returned.  Its\n"
     720                 :            : "meaning differs depending on whether a stack or a traceback is\n"
     721                 :            : "returned: the newest frames of a stack are returned, but the\n"
     722                 :            : "oldest frames of a traceback are returned.  (This matches the\n"
     723                 :            : "behavior of the traceback module.)\n"
     724                 :            : "\n"
     725                 :            : "For reasons beyond our control, only one stack frame is\n"
     726                 :            : "returned for a suspended coroutine.");
     727                 :            : 
     728                 :            : #define _ASYNCIO_TASK_GET_STACK_METHODDEF    \
     729                 :            :     {"get_stack", _PyCFunction_CAST(_asyncio_Task_get_stack), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _asyncio_Task_get_stack__doc__},
     730                 :            : 
     731                 :            : static PyObject *
     732                 :            : _asyncio_Task_get_stack_impl(TaskObj *self, PyTypeObject *cls,
     733                 :            :                              PyObject *limit);
     734                 :            : 
     735                 :            : static PyObject *
     736                 :          0 : _asyncio_Task_get_stack(TaskObj *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
     737                 :            : {
     738                 :          0 :     PyObject *return_value = NULL;
     739                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
     740                 :            : 
     741                 :            :     #define NUM_KEYWORDS 1
     742                 :            :     static struct {
     743                 :            :         PyGC_Head _this_is_not_used;
     744                 :            :         PyObject_VAR_HEAD
     745                 :            :         PyObject *ob_item[NUM_KEYWORDS];
     746                 :            :     } _kwtuple = {
     747                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
     748                 :            :         .ob_item = { &_Py_ID(limit), },
     749                 :            :     };
     750                 :            :     #undef NUM_KEYWORDS
     751                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
     752                 :            : 
     753                 :            :     #else  // !Py_BUILD_CORE
     754                 :            :     #  define KWTUPLE NULL
     755                 :            :     #endif  // !Py_BUILD_CORE
     756                 :            : 
     757                 :            :     static const char * const _keywords[] = {"limit", NULL};
     758                 :            :     static _PyArg_Parser _parser = {
     759                 :            :         .keywords = _keywords,
     760                 :            :         .fname = "get_stack",
     761                 :            :         .kwtuple = KWTUPLE,
     762                 :            :     };
     763                 :            :     #undef KWTUPLE
     764                 :            :     PyObject *argsbuf[1];
     765         [ #  # ]:          0 :     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
     766                 :          0 :     PyObject *limit = Py_None;
     767                 :            : 
     768   [ #  #  #  #  :          0 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 0, 0, argsbuf);
             #  #  #  # ]
     769         [ #  # ]:          0 :     if (!args) {
     770                 :          0 :         goto exit;
     771                 :            :     }
     772         [ #  # ]:          0 :     if (!noptargs) {
     773                 :          0 :         goto skip_optional_kwonly;
     774                 :            :     }
     775                 :          0 :     limit = args[0];
     776                 :          0 : skip_optional_kwonly:
     777                 :          0 :     return_value = _asyncio_Task_get_stack_impl(self, cls, limit);
     778                 :            : 
     779                 :          0 : exit:
     780                 :          0 :     return return_value;
     781                 :            : }
     782                 :            : 
     783                 :            : PyDoc_STRVAR(_asyncio_Task_print_stack__doc__,
     784                 :            : "print_stack($self, /, *, limit=None, file=None)\n"
     785                 :            : "--\n"
     786                 :            : "\n"
     787                 :            : "Print the stack or traceback for this task\'s coroutine.\n"
     788                 :            : "\n"
     789                 :            : "This produces output similar to that of the traceback module,\n"
     790                 :            : "for the frames retrieved by get_stack().  The limit argument\n"
     791                 :            : "is passed to get_stack().  The file argument is an I/O stream\n"
     792                 :            : "to which the output is written; by default output is written\n"
     793                 :            : "to sys.stderr.");
     794                 :            : 
     795                 :            : #define _ASYNCIO_TASK_PRINT_STACK_METHODDEF    \
     796                 :            :     {"print_stack", _PyCFunction_CAST(_asyncio_Task_print_stack), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _asyncio_Task_print_stack__doc__},
     797                 :            : 
     798                 :            : static PyObject *
     799                 :            : _asyncio_Task_print_stack_impl(TaskObj *self, PyTypeObject *cls,
     800                 :            :                                PyObject *limit, PyObject *file);
     801                 :            : 
     802                 :            : static PyObject *
     803                 :          0 : _asyncio_Task_print_stack(TaskObj *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
     804                 :            : {
     805                 :          0 :     PyObject *return_value = NULL;
     806                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
     807                 :            : 
     808                 :            :     #define NUM_KEYWORDS 2
     809                 :            :     static struct {
     810                 :            :         PyGC_Head _this_is_not_used;
     811                 :            :         PyObject_VAR_HEAD
     812                 :            :         PyObject *ob_item[NUM_KEYWORDS];
     813                 :            :     } _kwtuple = {
     814                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
     815                 :            :         .ob_item = { &_Py_ID(limit), &_Py_ID(file), },
     816                 :            :     };
     817                 :            :     #undef NUM_KEYWORDS
     818                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
     819                 :            : 
     820                 :            :     #else  // !Py_BUILD_CORE
     821                 :            :     #  define KWTUPLE NULL
     822                 :            :     #endif  // !Py_BUILD_CORE
     823                 :            : 
     824                 :            :     static const char * const _keywords[] = {"limit", "file", NULL};
     825                 :            :     static _PyArg_Parser _parser = {
     826                 :            :         .keywords = _keywords,
     827                 :            :         .fname = "print_stack",
     828                 :            :         .kwtuple = KWTUPLE,
     829                 :            :     };
     830                 :            :     #undef KWTUPLE
     831                 :            :     PyObject *argsbuf[2];
     832         [ #  # ]:          0 :     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
     833                 :          0 :     PyObject *limit = Py_None;
     834                 :          0 :     PyObject *file = Py_None;
     835                 :            : 
     836   [ #  #  #  #  :          0 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 0, 0, argsbuf);
             #  #  #  # ]
     837         [ #  # ]:          0 :     if (!args) {
     838                 :          0 :         goto exit;
     839                 :            :     }
     840         [ #  # ]:          0 :     if (!noptargs) {
     841                 :          0 :         goto skip_optional_kwonly;
     842                 :            :     }
     843         [ #  # ]:          0 :     if (args[0]) {
     844                 :          0 :         limit = args[0];
     845         [ #  # ]:          0 :         if (!--noptargs) {
     846                 :          0 :             goto skip_optional_kwonly;
     847                 :            :         }
     848                 :            :     }
     849                 :          0 :     file = args[1];
     850                 :          0 : skip_optional_kwonly:
     851                 :          0 :     return_value = _asyncio_Task_print_stack_impl(self, cls, limit, file);
     852                 :            : 
     853                 :          0 : exit:
     854                 :          0 :     return return_value;
     855                 :            : }
     856                 :            : 
     857                 :            : PyDoc_STRVAR(_asyncio_Task_set_result__doc__,
     858                 :            : "set_result($self, result, /)\n"
     859                 :            : "--\n"
     860                 :            : "\n");
     861                 :            : 
     862                 :            : #define _ASYNCIO_TASK_SET_RESULT_METHODDEF    \
     863                 :            :     {"set_result", (PyCFunction)_asyncio_Task_set_result, METH_O, _asyncio_Task_set_result__doc__},
     864                 :            : 
     865                 :            : PyDoc_STRVAR(_asyncio_Task_set_exception__doc__,
     866                 :            : "set_exception($self, exception, /)\n"
     867                 :            : "--\n"
     868                 :            : "\n");
     869                 :            : 
     870                 :            : #define _ASYNCIO_TASK_SET_EXCEPTION_METHODDEF    \
     871                 :            :     {"set_exception", (PyCFunction)_asyncio_Task_set_exception, METH_O, _asyncio_Task_set_exception__doc__},
     872                 :            : 
     873                 :            : PyDoc_STRVAR(_asyncio_Task_get_coro__doc__,
     874                 :            : "get_coro($self, /)\n"
     875                 :            : "--\n"
     876                 :            : "\n");
     877                 :            : 
     878                 :            : #define _ASYNCIO_TASK_GET_CORO_METHODDEF    \
     879                 :            :     {"get_coro", (PyCFunction)_asyncio_Task_get_coro, METH_NOARGS, _asyncio_Task_get_coro__doc__},
     880                 :            : 
     881                 :            : static PyObject *
     882                 :            : _asyncio_Task_get_coro_impl(TaskObj *self);
     883                 :            : 
     884                 :            : static PyObject *
     885                 :          0 : _asyncio_Task_get_coro(TaskObj *self, PyObject *Py_UNUSED(ignored))
     886                 :            : {
     887                 :          0 :     return _asyncio_Task_get_coro_impl(self);
     888                 :            : }
     889                 :            : 
     890                 :            : PyDoc_STRVAR(_asyncio_Task_get_context__doc__,
     891                 :            : "get_context($self, /)\n"
     892                 :            : "--\n"
     893                 :            : "\n");
     894                 :            : 
     895                 :            : #define _ASYNCIO_TASK_GET_CONTEXT_METHODDEF    \
     896                 :            :     {"get_context", (PyCFunction)_asyncio_Task_get_context, METH_NOARGS, _asyncio_Task_get_context__doc__},
     897                 :            : 
     898                 :            : static PyObject *
     899                 :            : _asyncio_Task_get_context_impl(TaskObj *self);
     900                 :            : 
     901                 :            : static PyObject *
     902                 :          0 : _asyncio_Task_get_context(TaskObj *self, PyObject *Py_UNUSED(ignored))
     903                 :            : {
     904                 :          0 :     return _asyncio_Task_get_context_impl(self);
     905                 :            : }
     906                 :            : 
     907                 :            : PyDoc_STRVAR(_asyncio_Task_get_name__doc__,
     908                 :            : "get_name($self, /)\n"
     909                 :            : "--\n"
     910                 :            : "\n");
     911                 :            : 
     912                 :            : #define _ASYNCIO_TASK_GET_NAME_METHODDEF    \
     913                 :            :     {"get_name", (PyCFunction)_asyncio_Task_get_name, METH_NOARGS, _asyncio_Task_get_name__doc__},
     914                 :            : 
     915                 :            : static PyObject *
     916                 :            : _asyncio_Task_get_name_impl(TaskObj *self);
     917                 :            : 
     918                 :            : static PyObject *
     919                 :          0 : _asyncio_Task_get_name(TaskObj *self, PyObject *Py_UNUSED(ignored))
     920                 :            : {
     921                 :          0 :     return _asyncio_Task_get_name_impl(self);
     922                 :            : }
     923                 :            : 
     924                 :            : PyDoc_STRVAR(_asyncio_Task_set_name__doc__,
     925                 :            : "set_name($self, value, /)\n"
     926                 :            : "--\n"
     927                 :            : "\n");
     928                 :            : 
     929                 :            : #define _ASYNCIO_TASK_SET_NAME_METHODDEF    \
     930                 :            :     {"set_name", (PyCFunction)_asyncio_Task_set_name, METH_O, _asyncio_Task_set_name__doc__},
     931                 :            : 
     932                 :            : PyDoc_STRVAR(_asyncio__get_running_loop__doc__,
     933                 :            : "_get_running_loop($module, /)\n"
     934                 :            : "--\n"
     935                 :            : "\n"
     936                 :            : "Return the running event loop or None.\n"
     937                 :            : "\n"
     938                 :            : "This is a low-level function intended to be used by event loops.\n"
     939                 :            : "This function is thread-specific.");
     940                 :            : 
     941                 :            : #define _ASYNCIO__GET_RUNNING_LOOP_METHODDEF    \
     942                 :            :     {"_get_running_loop", (PyCFunction)_asyncio__get_running_loop, METH_NOARGS, _asyncio__get_running_loop__doc__},
     943                 :            : 
     944                 :            : static PyObject *
     945                 :            : _asyncio__get_running_loop_impl(PyObject *module);
     946                 :            : 
     947                 :            : static PyObject *
     948                 :          0 : _asyncio__get_running_loop(PyObject *module, PyObject *Py_UNUSED(ignored))
     949                 :            : {
     950                 :          0 :     return _asyncio__get_running_loop_impl(module);
     951                 :            : }
     952                 :            : 
     953                 :            : PyDoc_STRVAR(_asyncio__set_running_loop__doc__,
     954                 :            : "_set_running_loop($module, loop, /)\n"
     955                 :            : "--\n"
     956                 :            : "\n"
     957                 :            : "Set the running event loop.\n"
     958                 :            : "\n"
     959                 :            : "This is a low-level function intended to be used by event loops.\n"
     960                 :            : "This function is thread-specific.");
     961                 :            : 
     962                 :            : #define _ASYNCIO__SET_RUNNING_LOOP_METHODDEF    \
     963                 :            :     {"_set_running_loop", (PyCFunction)_asyncio__set_running_loop, METH_O, _asyncio__set_running_loop__doc__},
     964                 :            : 
     965                 :            : PyDoc_STRVAR(_asyncio_get_event_loop__doc__,
     966                 :            : "get_event_loop($module, /)\n"
     967                 :            : "--\n"
     968                 :            : "\n"
     969                 :            : "Return an asyncio event loop.\n"
     970                 :            : "\n"
     971                 :            : "When called from a coroutine or a callback (e.g. scheduled with\n"
     972                 :            : "call_soon or similar API), this function will always return the\n"
     973                 :            : "running event loop.\n"
     974                 :            : "\n"
     975                 :            : "If there is no running event loop set, the function will return\n"
     976                 :            : "the result of `get_event_loop_policy().get_event_loop()` call.");
     977                 :            : 
     978                 :            : #define _ASYNCIO_GET_EVENT_LOOP_METHODDEF    \
     979                 :            :     {"get_event_loop", (PyCFunction)_asyncio_get_event_loop, METH_NOARGS, _asyncio_get_event_loop__doc__},
     980                 :            : 
     981                 :            : static PyObject *
     982                 :            : _asyncio_get_event_loop_impl(PyObject *module);
     983                 :            : 
     984                 :            : static PyObject *
     985                 :          0 : _asyncio_get_event_loop(PyObject *module, PyObject *Py_UNUSED(ignored))
     986                 :            : {
     987                 :          0 :     return _asyncio_get_event_loop_impl(module);
     988                 :            : }
     989                 :            : 
     990                 :            : PyDoc_STRVAR(_asyncio_get_running_loop__doc__,
     991                 :            : "get_running_loop($module, /)\n"
     992                 :            : "--\n"
     993                 :            : "\n"
     994                 :            : "Return the running event loop.  Raise a RuntimeError if there is none.\n"
     995                 :            : "\n"
     996                 :            : "This function is thread-specific.");
     997                 :            : 
     998                 :            : #define _ASYNCIO_GET_RUNNING_LOOP_METHODDEF    \
     999                 :            :     {"get_running_loop", (PyCFunction)_asyncio_get_running_loop, METH_NOARGS, _asyncio_get_running_loop__doc__},
    1000                 :            : 
    1001                 :            : static PyObject *
    1002                 :            : _asyncio_get_running_loop_impl(PyObject *module);
    1003                 :            : 
    1004                 :            : static PyObject *
    1005                 :          0 : _asyncio_get_running_loop(PyObject *module, PyObject *Py_UNUSED(ignored))
    1006                 :            : {
    1007                 :          0 :     return _asyncio_get_running_loop_impl(module);
    1008                 :            : }
    1009                 :            : 
    1010                 :            : PyDoc_STRVAR(_asyncio__register_task__doc__,
    1011                 :            : "_register_task($module, /, task)\n"
    1012                 :            : "--\n"
    1013                 :            : "\n"
    1014                 :            : "Register a new task in asyncio as executed by loop.\n"
    1015                 :            : "\n"
    1016                 :            : "Returns None.");
    1017                 :            : 
    1018                 :            : #define _ASYNCIO__REGISTER_TASK_METHODDEF    \
    1019                 :            :     {"_register_task", _PyCFunction_CAST(_asyncio__register_task), METH_FASTCALL|METH_KEYWORDS, _asyncio__register_task__doc__},
    1020                 :            : 
    1021                 :            : static PyObject *
    1022                 :            : _asyncio__register_task_impl(PyObject *module, PyObject *task);
    1023                 :            : 
    1024                 :            : static PyObject *
    1025                 :          0 : _asyncio__register_task(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
    1026                 :            : {
    1027                 :          0 :     PyObject *return_value = NULL;
    1028                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
    1029                 :            : 
    1030                 :            :     #define NUM_KEYWORDS 1
    1031                 :            :     static struct {
    1032                 :            :         PyGC_Head _this_is_not_used;
    1033                 :            :         PyObject_VAR_HEAD
    1034                 :            :         PyObject *ob_item[NUM_KEYWORDS];
    1035                 :            :     } _kwtuple = {
    1036                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
    1037                 :            :         .ob_item = { &_Py_ID(task), },
    1038                 :            :     };
    1039                 :            :     #undef NUM_KEYWORDS
    1040                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
    1041                 :            : 
    1042                 :            :     #else  // !Py_BUILD_CORE
    1043                 :            :     #  define KWTUPLE NULL
    1044                 :            :     #endif  // !Py_BUILD_CORE
    1045                 :            : 
    1046                 :            :     static const char * const _keywords[] = {"task", NULL};
    1047                 :            :     static _PyArg_Parser _parser = {
    1048                 :            :         .keywords = _keywords,
    1049                 :            :         .fname = "_register_task",
    1050                 :            :         .kwtuple = KWTUPLE,
    1051                 :            :     };
    1052                 :            :     #undef KWTUPLE
    1053                 :            :     PyObject *argsbuf[1];
    1054                 :            :     PyObject *task;
    1055                 :            : 
    1056   [ #  #  #  #  :          0 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
             #  #  #  # ]
    1057         [ #  # ]:          0 :     if (!args) {
    1058                 :          0 :         goto exit;
    1059                 :            :     }
    1060                 :          0 :     task = args[0];
    1061                 :          0 :     return_value = _asyncio__register_task_impl(module, task);
    1062                 :            : 
    1063                 :          0 : exit:
    1064                 :          0 :     return return_value;
    1065                 :            : }
    1066                 :            : 
    1067                 :            : PyDoc_STRVAR(_asyncio__unregister_task__doc__,
    1068                 :            : "_unregister_task($module, /, task)\n"
    1069                 :            : "--\n"
    1070                 :            : "\n"
    1071                 :            : "Unregister a task.\n"
    1072                 :            : "\n"
    1073                 :            : "Returns None.");
    1074                 :            : 
    1075                 :            : #define _ASYNCIO__UNREGISTER_TASK_METHODDEF    \
    1076                 :            :     {"_unregister_task", _PyCFunction_CAST(_asyncio__unregister_task), METH_FASTCALL|METH_KEYWORDS, _asyncio__unregister_task__doc__},
    1077                 :            : 
    1078                 :            : static PyObject *
    1079                 :            : _asyncio__unregister_task_impl(PyObject *module, PyObject *task);
    1080                 :            : 
    1081                 :            : static PyObject *
    1082                 :          0 : _asyncio__unregister_task(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
    1083                 :            : {
    1084                 :          0 :     PyObject *return_value = NULL;
    1085                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
    1086                 :            : 
    1087                 :            :     #define NUM_KEYWORDS 1
    1088                 :            :     static struct {
    1089                 :            :         PyGC_Head _this_is_not_used;
    1090                 :            :         PyObject_VAR_HEAD
    1091                 :            :         PyObject *ob_item[NUM_KEYWORDS];
    1092                 :            :     } _kwtuple = {
    1093                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
    1094                 :            :         .ob_item = { &_Py_ID(task), },
    1095                 :            :     };
    1096                 :            :     #undef NUM_KEYWORDS
    1097                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
    1098                 :            : 
    1099                 :            :     #else  // !Py_BUILD_CORE
    1100                 :            :     #  define KWTUPLE NULL
    1101                 :            :     #endif  // !Py_BUILD_CORE
    1102                 :            : 
    1103                 :            :     static const char * const _keywords[] = {"task", NULL};
    1104                 :            :     static _PyArg_Parser _parser = {
    1105                 :            :         .keywords = _keywords,
    1106                 :            :         .fname = "_unregister_task",
    1107                 :            :         .kwtuple = KWTUPLE,
    1108                 :            :     };
    1109                 :            :     #undef KWTUPLE
    1110                 :            :     PyObject *argsbuf[1];
    1111                 :            :     PyObject *task;
    1112                 :            : 
    1113   [ #  #  #  #  :          0 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
             #  #  #  # ]
    1114         [ #  # ]:          0 :     if (!args) {
    1115                 :          0 :         goto exit;
    1116                 :            :     }
    1117                 :          0 :     task = args[0];
    1118                 :          0 :     return_value = _asyncio__unregister_task_impl(module, task);
    1119                 :            : 
    1120                 :          0 : exit:
    1121                 :          0 :     return return_value;
    1122                 :            : }
    1123                 :            : 
    1124                 :            : PyDoc_STRVAR(_asyncio__enter_task__doc__,
    1125                 :            : "_enter_task($module, /, loop, task)\n"
    1126                 :            : "--\n"
    1127                 :            : "\n"
    1128                 :            : "Enter into task execution or resume suspended task.\n"
    1129                 :            : "\n"
    1130                 :            : "Task belongs to loop.\n"
    1131                 :            : "\n"
    1132                 :            : "Returns None.");
    1133                 :            : 
    1134                 :            : #define _ASYNCIO__ENTER_TASK_METHODDEF    \
    1135                 :            :     {"_enter_task", _PyCFunction_CAST(_asyncio__enter_task), METH_FASTCALL|METH_KEYWORDS, _asyncio__enter_task__doc__},
    1136                 :            : 
    1137                 :            : static PyObject *
    1138                 :            : _asyncio__enter_task_impl(PyObject *module, PyObject *loop, PyObject *task);
    1139                 :            : 
    1140                 :            : static PyObject *
    1141                 :          0 : _asyncio__enter_task(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
    1142                 :            : {
    1143                 :          0 :     PyObject *return_value = NULL;
    1144                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
    1145                 :            : 
    1146                 :            :     #define NUM_KEYWORDS 2
    1147                 :            :     static struct {
    1148                 :            :         PyGC_Head _this_is_not_used;
    1149                 :            :         PyObject_VAR_HEAD
    1150                 :            :         PyObject *ob_item[NUM_KEYWORDS];
    1151                 :            :     } _kwtuple = {
    1152                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
    1153                 :            :         .ob_item = { &_Py_ID(loop), &_Py_ID(task), },
    1154                 :            :     };
    1155                 :            :     #undef NUM_KEYWORDS
    1156                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
    1157                 :            : 
    1158                 :            :     #else  // !Py_BUILD_CORE
    1159                 :            :     #  define KWTUPLE NULL
    1160                 :            :     #endif  // !Py_BUILD_CORE
    1161                 :            : 
    1162                 :            :     static const char * const _keywords[] = {"loop", "task", NULL};
    1163                 :            :     static _PyArg_Parser _parser = {
    1164                 :            :         .keywords = _keywords,
    1165                 :            :         .fname = "_enter_task",
    1166                 :            :         .kwtuple = KWTUPLE,
    1167                 :            :     };
    1168                 :            :     #undef KWTUPLE
    1169                 :            :     PyObject *argsbuf[2];
    1170                 :            :     PyObject *loop;
    1171                 :            :     PyObject *task;
    1172                 :            : 
    1173   [ #  #  #  #  :          0 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 2, 0, argsbuf);
             #  #  #  # ]
    1174         [ #  # ]:          0 :     if (!args) {
    1175                 :          0 :         goto exit;
    1176                 :            :     }
    1177                 :          0 :     loop = args[0];
    1178                 :          0 :     task = args[1];
    1179                 :          0 :     return_value = _asyncio__enter_task_impl(module, loop, task);
    1180                 :            : 
    1181                 :          0 : exit:
    1182                 :          0 :     return return_value;
    1183                 :            : }
    1184                 :            : 
    1185                 :            : PyDoc_STRVAR(_asyncio__leave_task__doc__,
    1186                 :            : "_leave_task($module, /, loop, task)\n"
    1187                 :            : "--\n"
    1188                 :            : "\n"
    1189                 :            : "Leave task execution or suspend a task.\n"
    1190                 :            : "\n"
    1191                 :            : "Task belongs to loop.\n"
    1192                 :            : "\n"
    1193                 :            : "Returns None.");
    1194                 :            : 
    1195                 :            : #define _ASYNCIO__LEAVE_TASK_METHODDEF    \
    1196                 :            :     {"_leave_task", _PyCFunction_CAST(_asyncio__leave_task), METH_FASTCALL|METH_KEYWORDS, _asyncio__leave_task__doc__},
    1197                 :            : 
    1198                 :            : static PyObject *
    1199                 :            : _asyncio__leave_task_impl(PyObject *module, PyObject *loop, PyObject *task);
    1200                 :            : 
    1201                 :            : static PyObject *
    1202                 :          0 : _asyncio__leave_task(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
    1203                 :            : {
    1204                 :          0 :     PyObject *return_value = NULL;
    1205                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
    1206                 :            : 
    1207                 :            :     #define NUM_KEYWORDS 2
    1208                 :            :     static struct {
    1209                 :            :         PyGC_Head _this_is_not_used;
    1210                 :            :         PyObject_VAR_HEAD
    1211                 :            :         PyObject *ob_item[NUM_KEYWORDS];
    1212                 :            :     } _kwtuple = {
    1213                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
    1214                 :            :         .ob_item = { &_Py_ID(loop), &_Py_ID(task), },
    1215                 :            :     };
    1216                 :            :     #undef NUM_KEYWORDS
    1217                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
    1218                 :            : 
    1219                 :            :     #else  // !Py_BUILD_CORE
    1220                 :            :     #  define KWTUPLE NULL
    1221                 :            :     #endif  // !Py_BUILD_CORE
    1222                 :            : 
    1223                 :            :     static const char * const _keywords[] = {"loop", "task", NULL};
    1224                 :            :     static _PyArg_Parser _parser = {
    1225                 :            :         .keywords = _keywords,
    1226                 :            :         .fname = "_leave_task",
    1227                 :            :         .kwtuple = KWTUPLE,
    1228                 :            :     };
    1229                 :            :     #undef KWTUPLE
    1230                 :            :     PyObject *argsbuf[2];
    1231                 :            :     PyObject *loop;
    1232                 :            :     PyObject *task;
    1233                 :            : 
    1234   [ #  #  #  #  :          0 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 2, 0, argsbuf);
             #  #  #  # ]
    1235         [ #  # ]:          0 :     if (!args) {
    1236                 :          0 :         goto exit;
    1237                 :            :     }
    1238                 :          0 :     loop = args[0];
    1239                 :          0 :     task = args[1];
    1240                 :          0 :     return_value = _asyncio__leave_task_impl(module, loop, task);
    1241                 :            : 
    1242                 :          0 : exit:
    1243                 :          0 :     return return_value;
    1244                 :            : }
    1245                 :            : 
    1246                 :            : PyDoc_STRVAR(_asyncio_current_task__doc__,
    1247                 :            : "current_task($module, /, loop=None)\n"
    1248                 :            : "--\n"
    1249                 :            : "\n"
    1250                 :            : "Return a currently executed task.");
    1251                 :            : 
    1252                 :            : #define _ASYNCIO_CURRENT_TASK_METHODDEF    \
    1253                 :            :     {"current_task", _PyCFunction_CAST(_asyncio_current_task), METH_FASTCALL|METH_KEYWORDS, _asyncio_current_task__doc__},
    1254                 :            : 
    1255                 :            : static PyObject *
    1256                 :            : _asyncio_current_task_impl(PyObject *module, PyObject *loop);
    1257                 :            : 
    1258                 :            : static PyObject *
    1259                 :          0 : _asyncio_current_task(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
    1260                 :            : {
    1261                 :          0 :     PyObject *return_value = NULL;
    1262                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
    1263                 :            : 
    1264                 :            :     #define NUM_KEYWORDS 1
    1265                 :            :     static struct {
    1266                 :            :         PyGC_Head _this_is_not_used;
    1267                 :            :         PyObject_VAR_HEAD
    1268                 :            :         PyObject *ob_item[NUM_KEYWORDS];
    1269                 :            :     } _kwtuple = {
    1270                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
    1271                 :            :         .ob_item = { &_Py_ID(loop), },
    1272                 :            :     };
    1273                 :            :     #undef NUM_KEYWORDS
    1274                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
    1275                 :            : 
    1276                 :            :     #else  // !Py_BUILD_CORE
    1277                 :            :     #  define KWTUPLE NULL
    1278                 :            :     #endif  // !Py_BUILD_CORE
    1279                 :            : 
    1280                 :            :     static const char * const _keywords[] = {"loop", NULL};
    1281                 :            :     static _PyArg_Parser _parser = {
    1282                 :            :         .keywords = _keywords,
    1283                 :            :         .fname = "current_task",
    1284                 :            :         .kwtuple = KWTUPLE,
    1285                 :            :     };
    1286                 :            :     #undef KWTUPLE
    1287                 :            :     PyObject *argsbuf[1];
    1288         [ #  # ]:          0 :     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
    1289                 :          0 :     PyObject *loop = Py_None;
    1290                 :            : 
    1291   [ #  #  #  #  :          0 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
             #  #  #  # ]
    1292         [ #  # ]:          0 :     if (!args) {
    1293                 :          0 :         goto exit;
    1294                 :            :     }
    1295         [ #  # ]:          0 :     if (!noptargs) {
    1296                 :          0 :         goto skip_optional_pos;
    1297                 :            :     }
    1298                 :          0 :     loop = args[0];
    1299                 :          0 : skip_optional_pos:
    1300                 :          0 :     return_value = _asyncio_current_task_impl(module, loop);
    1301                 :            : 
    1302                 :          0 : exit:
    1303                 :          0 :     return return_value;
    1304                 :            : }
    1305                 :            : /*[clinic end generated code: output=00f494214f2fd008 input=a9049054013a1b77]*/

Generated by: LCOV version 1.14