Branch data Line data Source code
1 : : /*[clinic input]
2 : : preserve
3 : : [clinic start generated code]*/
4 : :
5 : : PyDoc_STRVAR(_asyncio_Future___init____doc__,
6 : : "Future(*, loop=None)\n"
7 : : "--\n"
8 : : "\n"
9 : : "This class is *almost* compatible with concurrent.futures.Future.\n"
10 : : "\n"
11 : : " Differences:\n"
12 : : "\n"
13 : : " - result() and exception() do not take a timeout argument and\n"
14 : : " raise an exception when the future isn\'t done yet.\n"
15 : : "\n"
16 : : " - Callbacks registered with add_done_callback() are always called\n"
17 : : " via the event loop\'s call_soon_threadsafe().\n"
18 : : "\n"
19 : : " - This class is not compatible with the wait() and as_completed()\n"
20 : : " methods in the concurrent.futures package.");
21 : :
22 : : static int
23 : : _asyncio_Future___init___impl(FutureObj *self, PyObject *loop);
24 : :
25 : : static int
26 : 14247 : _asyncio_Future___init__(PyObject *self, PyObject *args, PyObject *kwargs)
27 : : {
28 : 14247 : int return_value = -1;
29 : : static const char * const _keywords[] = {"loop", NULL};
30 : : static _PyArg_Parser _parser = {NULL, _keywords, "Future", 0};
31 : : PyObject *argsbuf[1];
32 : : PyObject * const *fastargs;
33 : 14247 : Py_ssize_t nargs = PyTuple_GET_SIZE(args);
34 [ + + ]: 14247 : Py_ssize_t noptargs = nargs + (kwargs ? PyDict_GET_SIZE(kwargs) : 0) - 0;
35 : 14247 : PyObject *loop = Py_None;
36 : :
37 [ + + + - : 14247 : fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser, 0, 0, 0, argsbuf);
+ - + - ]
38 [ + + ]: 14247 : if (!fastargs) {
39 : 2 : goto exit;
40 : : }
41 [ + + ]: 14245 : if (!noptargs) {
42 : 59 : goto skip_optional_kwonly;
43 : : }
44 : 14186 : loop = fastargs[0];
45 : 14245 : skip_optional_kwonly:
46 : 14245 : return_value = _asyncio_Future___init___impl((FutureObj *)self, loop);
47 : :
48 : 14247 : exit:
49 : 14247 : return return_value;
50 : : }
51 : :
52 : : PyDoc_STRVAR(_asyncio_Future_result__doc__,
53 : : "result($self, /)\n"
54 : : "--\n"
55 : : "\n"
56 : : "Return the result this future represents.\n"
57 : : "\n"
58 : : "If the future has been cancelled, raises CancelledError. If the\n"
59 : : "future\'s result isn\'t yet available, raises InvalidStateError. If\n"
60 : : "the future is done and has an exception set, this exception is raised.");
61 : :
62 : : #define _ASYNCIO_FUTURE_RESULT_METHODDEF \
63 : : {"result", (PyCFunction)_asyncio_Future_result, METH_NOARGS, _asyncio_Future_result__doc__},
64 : :
65 : : static PyObject *
66 : : _asyncio_Future_result_impl(FutureObj *self);
67 : :
68 : : static PyObject *
69 : 7360 : _asyncio_Future_result(FutureObj *self, PyObject *Py_UNUSED(ignored))
70 : : {
71 : 7360 : return _asyncio_Future_result_impl(self);
72 : : }
73 : :
74 : : PyDoc_STRVAR(_asyncio_Future_exception__doc__,
75 : : "exception($self, /)\n"
76 : : "--\n"
77 : : "\n"
78 : : "Return the exception that was set on this future.\n"
79 : : "\n"
80 : : "The exception (or None if no exception was set) is returned only if\n"
81 : : "the future is done. If the future has been cancelled, raises\n"
82 : : "CancelledError. If the future isn\'t done yet, raises\n"
83 : : "InvalidStateError.");
84 : :
85 : : #define _ASYNCIO_FUTURE_EXCEPTION_METHODDEF \
86 : : {"exception", (PyCFunction)_asyncio_Future_exception, METH_NOARGS, _asyncio_Future_exception__doc__},
87 : :
88 : : static PyObject *
89 : : _asyncio_Future_exception_impl(FutureObj *self);
90 : :
91 : : static PyObject *
92 : 8134 : _asyncio_Future_exception(FutureObj *self, PyObject *Py_UNUSED(ignored))
93 : : {
94 : 8134 : return _asyncio_Future_exception_impl(self);
95 : : }
96 : :
97 : : PyDoc_STRVAR(_asyncio_Future_set_result__doc__,
98 : : "set_result($self, result, /)\n"
99 : : "--\n"
100 : : "\n"
101 : : "Mark the future done and set its result.\n"
102 : : "\n"
103 : : "If the future is already done when this method is called, raises\n"
104 : : "InvalidStateError.");
105 : :
106 : : #define _ASYNCIO_FUTURE_SET_RESULT_METHODDEF \
107 : : {"set_result", (PyCFunction)_asyncio_Future_set_result, METH_O, _asyncio_Future_set_result__doc__},
108 : :
109 : : PyDoc_STRVAR(_asyncio_Future_set_exception__doc__,
110 : : "set_exception($self, exception, /)\n"
111 : : "--\n"
112 : : "\n"
113 : : "Mark the future done and set an exception.\n"
114 : : "\n"
115 : : "If the future is already done when this method is called, raises\n"
116 : : "InvalidStateError.");
117 : :
118 : : #define _ASYNCIO_FUTURE_SET_EXCEPTION_METHODDEF \
119 : : {"set_exception", (PyCFunction)_asyncio_Future_set_exception, METH_O, _asyncio_Future_set_exception__doc__},
120 : :
121 : : PyDoc_STRVAR(_asyncio_Future_add_done_callback__doc__,
122 : : "add_done_callback($self, fn, /, *, context=<unrepresentable>)\n"
123 : : "--\n"
124 : : "\n"
125 : : "Add a callback to be run when the future becomes done.\n"
126 : : "\n"
127 : : "The callback is called with a single argument - the future object. If\n"
128 : : "the future is already done when this is called, the callback is\n"
129 : : "scheduled with call_soon.");
130 : :
131 : : #define _ASYNCIO_FUTURE_ADD_DONE_CALLBACK_METHODDEF \
132 : : {"add_done_callback", _PyCFunction_CAST(_asyncio_Future_add_done_callback), METH_FASTCALL|METH_KEYWORDS, _asyncio_Future_add_done_callback__doc__},
133 : :
134 : : static PyObject *
135 : : _asyncio_Future_add_done_callback_impl(FutureObj *self, PyObject *fn,
136 : : PyObject *context);
137 : :
138 : : static PyObject *
139 : 8931 : _asyncio_Future_add_done_callback(FutureObj *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
140 : : {
141 : 8931 : PyObject *return_value = NULL;
142 : : static const char * const _keywords[] = {"", "context", NULL};
143 : : static _PyArg_Parser _parser = {NULL, _keywords, "add_done_callback", 0};
144 : : PyObject *argsbuf[2];
145 [ + + ]: 8931 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
146 : : PyObject *fn;
147 : 8931 : PyObject *context = NULL;
148 : :
149 [ + + + - : 8931 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
+ - - + ]
150 [ - + ]: 8931 : if (!args) {
151 : 0 : goto exit;
152 : : }
153 : 8931 : fn = args[0];
154 [ + + ]: 8931 : if (!noptargs) {
155 : 8275 : goto skip_optional_kwonly;
156 : : }
157 : 656 : context = args[1];
158 : 8931 : skip_optional_kwonly:
159 : 8931 : return_value = _asyncio_Future_add_done_callback_impl(self, fn, context);
160 : :
161 : 8931 : exit:
162 : 8931 : return return_value;
163 : : }
164 : :
165 : : PyDoc_STRVAR(_asyncio_Future_remove_done_callback__doc__,
166 : : "remove_done_callback($self, fn, /)\n"
167 : : "--\n"
168 : : "\n"
169 : : "Remove all instances of a callback from the \"call when done\" list.\n"
170 : : "\n"
171 : : "Returns the number of callbacks removed.");
172 : :
173 : : #define _ASYNCIO_FUTURE_REMOVE_DONE_CALLBACK_METHODDEF \
174 : : {"remove_done_callback", (PyCFunction)_asyncio_Future_remove_done_callback, METH_O, _asyncio_Future_remove_done_callback__doc__},
175 : :
176 : : PyDoc_STRVAR(_asyncio_Future_cancel__doc__,
177 : : "cancel($self, /, msg=None)\n"
178 : : "--\n"
179 : : "\n"
180 : : "Cancel the future and schedule callbacks.\n"
181 : : "\n"
182 : : "If the future is already done or cancelled, return False. Otherwise,\n"
183 : : "change the future\'s state to cancelled, schedule the callbacks and\n"
184 : : "return True.");
185 : :
186 : : #define _ASYNCIO_FUTURE_CANCEL_METHODDEF \
187 : : {"cancel", _PyCFunction_CAST(_asyncio_Future_cancel), METH_FASTCALL|METH_KEYWORDS, _asyncio_Future_cancel__doc__},
188 : :
189 : : static PyObject *
190 : : _asyncio_Future_cancel_impl(FutureObj *self, PyObject *msg);
191 : :
192 : : static PyObject *
193 : 494 : _asyncio_Future_cancel(FutureObj *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
194 : : {
195 : 494 : PyObject *return_value = NULL;
196 : : static const char * const _keywords[] = {"msg", NULL};
197 : : static _PyArg_Parser _parser = {NULL, _keywords, "cancel", 0};
198 : : PyObject *argsbuf[1];
199 [ + + ]: 494 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
200 : 494 : PyObject *msg = Py_None;
201 : :
202 [ + + + - : 494 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
+ - - + ]
203 [ - + ]: 494 : if (!args) {
204 : 0 : goto exit;
205 : : }
206 [ + + ]: 494 : if (!noptargs) {
207 : 90 : goto skip_optional_pos;
208 : : }
209 : 404 : msg = args[0];
210 : 494 : skip_optional_pos:
211 : 494 : return_value = _asyncio_Future_cancel_impl(self, msg);
212 : :
213 : 494 : exit:
214 : 494 : return return_value;
215 : : }
216 : :
217 : : PyDoc_STRVAR(_asyncio_Future_cancelled__doc__,
218 : : "cancelled($self, /)\n"
219 : : "--\n"
220 : : "\n"
221 : : "Return True if the future was cancelled.");
222 : :
223 : : #define _ASYNCIO_FUTURE_CANCELLED_METHODDEF \
224 : : {"cancelled", (PyCFunction)_asyncio_Future_cancelled, METH_NOARGS, _asyncio_Future_cancelled__doc__},
225 : :
226 : : static PyObject *
227 : : _asyncio_Future_cancelled_impl(FutureObj *self);
228 : :
229 : : static PyObject *
230 : 20764 : _asyncio_Future_cancelled(FutureObj *self, PyObject *Py_UNUSED(ignored))
231 : : {
232 : 20764 : return _asyncio_Future_cancelled_impl(self);
233 : : }
234 : :
235 : : PyDoc_STRVAR(_asyncio_Future_done__doc__,
236 : : "done($self, /)\n"
237 : : "--\n"
238 : : "\n"
239 : : "Return True if the future is done.\n"
240 : : "\n"
241 : : "Done means either that a result / exception are available, or that the\n"
242 : : "future was cancelled.");
243 : :
244 : : #define _ASYNCIO_FUTURE_DONE_METHODDEF \
245 : : {"done", (PyCFunction)_asyncio_Future_done, METH_NOARGS, _asyncio_Future_done__doc__},
246 : :
247 : : static PyObject *
248 : : _asyncio_Future_done_impl(FutureObj *self);
249 : :
250 : : static PyObject *
251 : 9234 : _asyncio_Future_done(FutureObj *self, PyObject *Py_UNUSED(ignored))
252 : : {
253 : 9234 : return _asyncio_Future_done_impl(self);
254 : : }
255 : :
256 : : PyDoc_STRVAR(_asyncio_Future_get_loop__doc__,
257 : : "get_loop($self, /)\n"
258 : : "--\n"
259 : : "\n"
260 : : "Return the event loop the Future is bound to.");
261 : :
262 : : #define _ASYNCIO_FUTURE_GET_LOOP_METHODDEF \
263 : : {"get_loop", (PyCFunction)_asyncio_Future_get_loop, METH_NOARGS, _asyncio_Future_get_loop__doc__},
264 : :
265 : : static PyObject *
266 : : _asyncio_Future_get_loop_impl(FutureObj *self);
267 : :
268 : : static PyObject *
269 : 9745 : _asyncio_Future_get_loop(FutureObj *self, PyObject *Py_UNUSED(ignored))
270 : : {
271 : 9745 : return _asyncio_Future_get_loop_impl(self);
272 : : }
273 : :
274 : : PyDoc_STRVAR(_asyncio_Future__make_cancelled_error__doc__,
275 : : "_make_cancelled_error($self, /)\n"
276 : : "--\n"
277 : : "\n"
278 : : "Create the CancelledError to raise if the Future is cancelled.\n"
279 : : "\n"
280 : : "This should only be called once when handling a cancellation since\n"
281 : : "it erases the context exception value.");
282 : :
283 : : #define _ASYNCIO_FUTURE__MAKE_CANCELLED_ERROR_METHODDEF \
284 : : {"_make_cancelled_error", (PyCFunction)_asyncio_Future__make_cancelled_error, METH_NOARGS, _asyncio_Future__make_cancelled_error__doc__},
285 : :
286 : : static PyObject *
287 : : _asyncio_Future__make_cancelled_error_impl(FutureObj *self);
288 : :
289 : : static PyObject *
290 : 5 : _asyncio_Future__make_cancelled_error(FutureObj *self, PyObject *Py_UNUSED(ignored))
291 : : {
292 : 5 : return _asyncio_Future__make_cancelled_error_impl(self);
293 : : }
294 : :
295 : : PyDoc_STRVAR(_asyncio_Task___init____doc__,
296 : : "Task(coro, *, loop=None, name=None, context=None)\n"
297 : : "--\n"
298 : : "\n"
299 : : "A coroutine wrapped in a Future.");
300 : :
301 : : static int
302 : : _asyncio_Task___init___impl(TaskObj *self, PyObject *coro, PyObject *loop,
303 : : PyObject *name, PyObject *context);
304 : :
305 : : static int
306 : 7208 : _asyncio_Task___init__(PyObject *self, PyObject *args, PyObject *kwargs)
307 : : {
308 : 7208 : int return_value = -1;
309 : : static const char * const _keywords[] = {"coro", "loop", "name", "context", NULL};
310 : : static _PyArg_Parser _parser = {NULL, _keywords, "Task", 0};
311 : : PyObject *argsbuf[4];
312 : : PyObject * const *fastargs;
313 : 7208 : Py_ssize_t nargs = PyTuple_GET_SIZE(args);
314 [ + + ]: 7208 : Py_ssize_t noptargs = nargs + (kwargs ? PyDict_GET_SIZE(kwargs) : 0) - 1;
315 : : PyObject *coro;
316 : 7208 : PyObject *loop = Py_None;
317 : 7208 : PyObject *name = Py_None;
318 : 7208 : PyObject *context = Py_None;
319 : :
320 [ + + + - : 7208 : fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser, 1, 1, 0, argsbuf);
+ - + - ]
321 [ - + ]: 7208 : if (!fastargs) {
322 : 0 : goto exit;
323 : : }
324 : 7208 : coro = fastargs[0];
325 [ + + ]: 7208 : if (!noptargs) {
326 : 1 : goto skip_optional_kwonly;
327 : : }
328 [ + - ]: 7207 : if (fastargs[1]) {
329 : 7207 : loop = fastargs[1];
330 [ + + ]: 7207 : if (!--noptargs) {
331 : 6 : goto skip_optional_kwonly;
332 : : }
333 : : }
334 [ + - ]: 7201 : if (fastargs[2]) {
335 : 7201 : name = fastargs[2];
336 [ - + ]: 7201 : if (!--noptargs) {
337 : 0 : goto skip_optional_kwonly;
338 : : }
339 : : }
340 : 7201 : context = fastargs[3];
341 : 7208 : skip_optional_kwonly:
342 : 7208 : return_value = _asyncio_Task___init___impl((TaskObj *)self, coro, loop, name, context);
343 : :
344 : 7208 : exit:
345 : 7208 : return return_value;
346 : : }
347 : :
348 : : PyDoc_STRVAR(_asyncio_Task__make_cancelled_error__doc__,
349 : : "_make_cancelled_error($self, /)\n"
350 : : "--\n"
351 : : "\n"
352 : : "Create the CancelledError to raise if the Task is cancelled.\n"
353 : : "\n"
354 : : "This should only be called once when handling a cancellation since\n"
355 : : "it erases the context exception value.");
356 : :
357 : : #define _ASYNCIO_TASK__MAKE_CANCELLED_ERROR_METHODDEF \
358 : : {"_make_cancelled_error", (PyCFunction)_asyncio_Task__make_cancelled_error, METH_NOARGS, _asyncio_Task__make_cancelled_error__doc__},
359 : :
360 : : static PyObject *
361 : : _asyncio_Task__make_cancelled_error_impl(TaskObj *self);
362 : :
363 : : static PyObject *
364 : 33 : _asyncio_Task__make_cancelled_error(TaskObj *self, PyObject *Py_UNUSED(ignored))
365 : : {
366 : 33 : return _asyncio_Task__make_cancelled_error_impl(self);
367 : : }
368 : :
369 : : PyDoc_STRVAR(_asyncio_Task_cancel__doc__,
370 : : "cancel($self, /, msg=None)\n"
371 : : "--\n"
372 : : "\n"
373 : : "Request that this task cancel itself.\n"
374 : : "\n"
375 : : "This arranges for a CancelledError to be thrown into the\n"
376 : : "wrapped coroutine on the next cycle through the event loop.\n"
377 : : "The coroutine then has a chance to clean up or even deny\n"
378 : : "the request using try/except/finally.\n"
379 : : "\n"
380 : : "Unlike Future.cancel, this does not guarantee that the\n"
381 : : "task will be cancelled: the exception might be caught and\n"
382 : : "acted upon, delaying cancellation of the task or preventing\n"
383 : : "cancellation completely. The task may also return a value or\n"
384 : : "raise a different exception.\n"
385 : : "\n"
386 : : "Immediately after this method is called, Task.cancelled() will\n"
387 : : "not return True (unless the task was already cancelled). A\n"
388 : : "task will be marked as cancelled when the wrapped coroutine\n"
389 : : "terminates with a CancelledError exception (even if cancel()\n"
390 : : "was not called).\n"
391 : : "\n"
392 : : "This also increases the task\'s count of cancellation requests.");
393 : :
394 : : #define _ASYNCIO_TASK_CANCEL_METHODDEF \
395 : : {"cancel", _PyCFunction_CAST(_asyncio_Task_cancel), METH_FASTCALL|METH_KEYWORDS, _asyncio_Task_cancel__doc__},
396 : :
397 : : static PyObject *
398 : : _asyncio_Task_cancel_impl(TaskObj *self, PyObject *msg);
399 : :
400 : : static PyObject *
401 : 417 : _asyncio_Task_cancel(TaskObj *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
402 : : {
403 : 417 : PyObject *return_value = NULL;
404 : : static const char * const _keywords[] = {"msg", NULL};
405 : : static _PyArg_Parser _parser = {NULL, _keywords, "cancel", 0};
406 : : PyObject *argsbuf[1];
407 [ + + ]: 417 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
408 : 417 : PyObject *msg = Py_None;
409 : :
410 [ + + + - : 417 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
+ - - + ]
411 [ - + ]: 417 : if (!args) {
412 : 0 : goto exit;
413 : : }
414 [ + + ]: 417 : if (!noptargs) {
415 : 317 : goto skip_optional_pos;
416 : : }
417 : 100 : msg = args[0];
418 : 417 : skip_optional_pos:
419 : 417 : return_value = _asyncio_Task_cancel_impl(self, msg);
420 : :
421 : 417 : exit:
422 : 417 : return return_value;
423 : : }
424 : :
425 : : PyDoc_STRVAR(_asyncio_Task_cancelling__doc__,
426 : : "cancelling($self, /)\n"
427 : : "--\n"
428 : : "\n"
429 : : "Return the count of the task\'s cancellation requests.\n"
430 : : "\n"
431 : : "This count is incremented when .cancel() is called\n"
432 : : "and may be decremented using .uncancel().");
433 : :
434 : : #define _ASYNCIO_TASK_CANCELLING_METHODDEF \
435 : : {"cancelling", (PyCFunction)_asyncio_Task_cancelling, METH_NOARGS, _asyncio_Task_cancelling__doc__},
436 : :
437 : : static PyObject *
438 : : _asyncio_Task_cancelling_impl(TaskObj *self);
439 : :
440 : : static PyObject *
441 : 1767 : _asyncio_Task_cancelling(TaskObj *self, PyObject *Py_UNUSED(ignored))
442 : : {
443 : 1767 : return _asyncio_Task_cancelling_impl(self);
444 : : }
445 : :
446 : : PyDoc_STRVAR(_asyncio_Task_uncancel__doc__,
447 : : "uncancel($self, /)\n"
448 : : "--\n"
449 : : "\n"
450 : : "Decrement the task\'s count of cancellation requests.\n"
451 : : "\n"
452 : : "This should be used by tasks that catch CancelledError\n"
453 : : "and wish to continue indefinitely until they are cancelled again.\n"
454 : : "\n"
455 : : "Returns the remaining number of cancellation requests.");
456 : :
457 : : #define _ASYNCIO_TASK_UNCANCEL_METHODDEF \
458 : : {"uncancel", (PyCFunction)_asyncio_Task_uncancel, METH_NOARGS, _asyncio_Task_uncancel__doc__},
459 : :
460 : : static PyObject *
461 : : _asyncio_Task_uncancel_impl(TaskObj *self);
462 : :
463 : : static PyObject *
464 : 25 : _asyncio_Task_uncancel(TaskObj *self, PyObject *Py_UNUSED(ignored))
465 : : {
466 : 25 : return _asyncio_Task_uncancel_impl(self);
467 : : }
468 : :
469 : : PyDoc_STRVAR(_asyncio_Task__check_future__doc__,
470 : : "_check_future($self, /, future)\n"
471 : : "--\n"
472 : : "\n"
473 : : "Return False if task and future loops are not compatible.");
474 : :
475 : : #define _ASYNCIO_TASK__CHECK_FUTURE_METHODDEF \
476 : : {"_check_future", _PyCFunction_CAST(_asyncio_Task__check_future), METH_FASTCALL|METH_KEYWORDS, _asyncio_Task__check_future__doc__},
477 : :
478 : : static int
479 : : _asyncio_Task__check_future_impl(TaskObj *self, PyObject *future);
480 : :
481 : : static PyObject *
482 : 250 : _asyncio_Task__check_future(TaskObj *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
483 : : {
484 : 250 : PyObject *return_value = NULL;
485 : : static const char * const _keywords[] = {"future", NULL};
486 : : static _PyArg_Parser _parser = {NULL, _keywords, "_check_future", 0};
487 : : PyObject *argsbuf[1];
488 : : PyObject *future;
489 : : int _return_value;
490 : :
491 [ + - + - : 250 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
+ - - + ]
492 [ - + ]: 250 : if (!args) {
493 : 0 : goto exit;
494 : : }
495 : 250 : future = args[0];
496 : 250 : _return_value = _asyncio_Task__check_future_impl(self, future);
497 [ - + - - ]: 250 : if ((_return_value == -1) && PyErr_Occurred()) {
498 : 0 : goto exit;
499 : : }
500 : 250 : return_value = PyBool_FromLong((long)_return_value);
501 : :
502 : 250 : exit:
503 : 250 : return return_value;
504 : : }
505 : :
506 : : PyDoc_STRVAR(_asyncio_Task_get_stack__doc__,
507 : : "get_stack($self, /, *, limit=None)\n"
508 : : "--\n"
509 : : "\n"
510 : : "Return the list of stack frames for this task\'s coroutine.\n"
511 : : "\n"
512 : : "If the coroutine is not done, this returns the stack where it is\n"
513 : : "suspended. If the coroutine has completed successfully or was\n"
514 : : "cancelled, this returns an empty list. If the coroutine was\n"
515 : : "terminated by an exception, this returns the list of traceback\n"
516 : : "frames.\n"
517 : : "\n"
518 : : "The frames are always ordered from oldest to newest.\n"
519 : : "\n"
520 : : "The optional limit gives the maximum number of frames to\n"
521 : : "return; by default all available frames are returned. Its\n"
522 : : "meaning differs depending on whether a stack or a traceback is\n"
523 : : "returned: the newest frames of a stack are returned, but the\n"
524 : : "oldest frames of a traceback are returned. (This matches the\n"
525 : : "behavior of the traceback module.)\n"
526 : : "\n"
527 : : "For reasons beyond our control, only one stack frame is\n"
528 : : "returned for a suspended coroutine.");
529 : :
530 : : #define _ASYNCIO_TASK_GET_STACK_METHODDEF \
531 : : {"get_stack", _PyCFunction_CAST(_asyncio_Task_get_stack), METH_FASTCALL|METH_KEYWORDS, _asyncio_Task_get_stack__doc__},
532 : :
533 : : static PyObject *
534 : : _asyncio_Task_get_stack_impl(TaskObj *self, PyObject *limit);
535 : :
536 : : static PyObject *
537 : 11 : _asyncio_Task_get_stack(TaskObj *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
538 : : {
539 : 11 : PyObject *return_value = NULL;
540 : : static const char * const _keywords[] = {"limit", NULL};
541 : : static _PyArg_Parser _parser = {NULL, _keywords, "get_stack", 0};
542 : : PyObject *argsbuf[1];
543 [ + + ]: 11 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
544 : 11 : PyObject *limit = Py_None;
545 : :
546 [ + + + - : 11 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 0, 0, argsbuf);
+ - - + ]
547 [ - + ]: 11 : if (!args) {
548 : 0 : goto exit;
549 : : }
550 [ + + ]: 11 : if (!noptargs) {
551 : 2 : goto skip_optional_kwonly;
552 : : }
553 : 9 : limit = args[0];
554 : 11 : skip_optional_kwonly:
555 : 11 : return_value = _asyncio_Task_get_stack_impl(self, limit);
556 : :
557 : 11 : exit:
558 : 11 : return return_value;
559 : : }
560 : :
561 : : PyDoc_STRVAR(_asyncio_Task_print_stack__doc__,
562 : : "print_stack($self, /, *, limit=None, file=None)\n"
563 : : "--\n"
564 : : "\n"
565 : : "Print the stack or traceback for this task\'s coroutine.\n"
566 : : "\n"
567 : : "This produces output similar to that of the traceback module,\n"
568 : : "for the frames retrieved by get_stack(). The limit argument\n"
569 : : "is passed to get_stack(). The file argument is an I/O stream\n"
570 : : "to which the output is written; by default output is written\n"
571 : : "to sys.stderr.");
572 : :
573 : : #define _ASYNCIO_TASK_PRINT_STACK_METHODDEF \
574 : : {"print_stack", _PyCFunction_CAST(_asyncio_Task_print_stack), METH_FASTCALL|METH_KEYWORDS, _asyncio_Task_print_stack__doc__},
575 : :
576 : : static PyObject *
577 : : _asyncio_Task_print_stack_impl(TaskObj *self, PyObject *limit,
578 : : PyObject *file);
579 : :
580 : : static PyObject *
581 : 4 : _asyncio_Task_print_stack(TaskObj *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
582 : : {
583 : 4 : PyObject *return_value = NULL;
584 : : static const char * const _keywords[] = {"limit", "file", NULL};
585 : : static _PyArg_Parser _parser = {NULL, _keywords, "print_stack", 0};
586 : : PyObject *argsbuf[2];
587 [ + - ]: 4 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
588 : 4 : PyObject *limit = Py_None;
589 : 4 : PyObject *file = Py_None;
590 : :
591 [ - + - - : 4 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 0, 0, argsbuf);
- - - - ]
592 [ - + ]: 4 : if (!args) {
593 : 0 : goto exit;
594 : : }
595 [ - + ]: 4 : if (!noptargs) {
596 : 0 : goto skip_optional_kwonly;
597 : : }
598 [ + - ]: 4 : if (args[0]) {
599 : 4 : limit = args[0];
600 [ - + ]: 4 : if (!--noptargs) {
601 : 0 : goto skip_optional_kwonly;
602 : : }
603 : : }
604 : 4 : file = args[1];
605 : 4 : skip_optional_kwonly:
606 : 4 : return_value = _asyncio_Task_print_stack_impl(self, limit, file);
607 : :
608 : 4 : exit:
609 : 4 : return return_value;
610 : : }
611 : :
612 : : PyDoc_STRVAR(_asyncio_Task_set_result__doc__,
613 : : "set_result($self, result, /)\n"
614 : : "--\n"
615 : : "\n");
616 : :
617 : : #define _ASYNCIO_TASK_SET_RESULT_METHODDEF \
618 : : {"set_result", (PyCFunction)_asyncio_Task_set_result, METH_O, _asyncio_Task_set_result__doc__},
619 : :
620 : : PyDoc_STRVAR(_asyncio_Task_set_exception__doc__,
621 : : "set_exception($self, exception, /)\n"
622 : : "--\n"
623 : : "\n");
624 : :
625 : : #define _ASYNCIO_TASK_SET_EXCEPTION_METHODDEF \
626 : : {"set_exception", (PyCFunction)_asyncio_Task_set_exception, METH_O, _asyncio_Task_set_exception__doc__},
627 : :
628 : : PyDoc_STRVAR(_asyncio_Task_get_coro__doc__,
629 : : "get_coro($self, /)\n"
630 : : "--\n"
631 : : "\n");
632 : :
633 : : #define _ASYNCIO_TASK_GET_CORO_METHODDEF \
634 : : {"get_coro", (PyCFunction)_asyncio_Task_get_coro, METH_NOARGS, _asyncio_Task_get_coro__doc__},
635 : :
636 : : static PyObject *
637 : : _asyncio_Task_get_coro_impl(TaskObj *self);
638 : :
639 : : static PyObject *
640 : 4 : _asyncio_Task_get_coro(TaskObj *self, PyObject *Py_UNUSED(ignored))
641 : : {
642 : 4 : return _asyncio_Task_get_coro_impl(self);
643 : : }
644 : :
645 : : PyDoc_STRVAR(_asyncio_Task_get_name__doc__,
646 : : "get_name($self, /)\n"
647 : : "--\n"
648 : : "\n");
649 : :
650 : : #define _ASYNCIO_TASK_GET_NAME_METHODDEF \
651 : : {"get_name", (PyCFunction)_asyncio_Task_get_name, METH_NOARGS, _asyncio_Task_get_name__doc__},
652 : :
653 : : static PyObject *
654 : : _asyncio_Task_get_name_impl(TaskObj *self);
655 : :
656 : : static PyObject *
657 : 1772 : _asyncio_Task_get_name(TaskObj *self, PyObject *Py_UNUSED(ignored))
658 : : {
659 : 1772 : return _asyncio_Task_get_name_impl(self);
660 : : }
661 : :
662 : : PyDoc_STRVAR(_asyncio_Task_set_name__doc__,
663 : : "set_name($self, value, /)\n"
664 : : "--\n"
665 : : "\n");
666 : :
667 : : #define _ASYNCIO_TASK_SET_NAME_METHODDEF \
668 : : {"set_name", (PyCFunction)_asyncio_Task_set_name, METH_O, _asyncio_Task_set_name__doc__},
669 : :
670 : : PyDoc_STRVAR(_asyncio__get_running_loop__doc__,
671 : : "_get_running_loop($module, /)\n"
672 : : "--\n"
673 : : "\n"
674 : : "Return the running event loop or None.\n"
675 : : "\n"
676 : : "This is a low-level function intended to be used by event loops.\n"
677 : : "This function is thread-specific.");
678 : :
679 : : #define _ASYNCIO__GET_RUNNING_LOOP_METHODDEF \
680 : : {"_get_running_loop", (PyCFunction)_asyncio__get_running_loop, METH_NOARGS, _asyncio__get_running_loop__doc__},
681 : :
682 : : static PyObject *
683 : : _asyncio__get_running_loop_impl(PyObject *module);
684 : :
685 : : static PyObject *
686 : 11586 : _asyncio__get_running_loop(PyObject *module, PyObject *Py_UNUSED(ignored))
687 : : {
688 : 11586 : return _asyncio__get_running_loop_impl(module);
689 : : }
690 : :
691 : : PyDoc_STRVAR(_asyncio__set_running_loop__doc__,
692 : : "_set_running_loop($module, loop, /)\n"
693 : : "--\n"
694 : : "\n"
695 : : "Set the running event loop.\n"
696 : : "\n"
697 : : "This is a low-level function intended to be used by event loops.\n"
698 : : "This function is thread-specific.");
699 : :
700 : : #define _ASYNCIO__SET_RUNNING_LOOP_METHODDEF \
701 : : {"_set_running_loop", (PyCFunction)_asyncio__set_running_loop, METH_O, _asyncio__set_running_loop__doc__},
702 : :
703 : : PyDoc_STRVAR(_asyncio_get_event_loop__doc__,
704 : : "get_event_loop($module, /)\n"
705 : : "--\n"
706 : : "\n"
707 : : "Return an asyncio event loop.\n"
708 : : "\n"
709 : : "When called from a coroutine or a callback (e.g. scheduled with\n"
710 : : "call_soon or similar API), this function will always return the\n"
711 : : "running event loop.\n"
712 : : "\n"
713 : : "If there is no running event loop set, the function will return\n"
714 : : "the result of `get_event_loop_policy().get_event_loop()` call.");
715 : :
716 : : #define _ASYNCIO_GET_EVENT_LOOP_METHODDEF \
717 : : {"get_event_loop", (PyCFunction)_asyncio_get_event_loop, METH_NOARGS, _asyncio_get_event_loop__doc__},
718 : :
719 : : static PyObject *
720 : : _asyncio_get_event_loop_impl(PyObject *module);
721 : :
722 : : static PyObject *
723 : 19 : _asyncio_get_event_loop(PyObject *module, PyObject *Py_UNUSED(ignored))
724 : : {
725 : 19 : return _asyncio_get_event_loop_impl(module);
726 : : }
727 : :
728 : : PyDoc_STRVAR(_asyncio__get_event_loop__doc__,
729 : : "_get_event_loop($module, /, stacklevel=3)\n"
730 : : "--\n"
731 : : "\n");
732 : :
733 : : #define _ASYNCIO__GET_EVENT_LOOP_METHODDEF \
734 : : {"_get_event_loop", _PyCFunction_CAST(_asyncio__get_event_loop), METH_FASTCALL|METH_KEYWORDS, _asyncio__get_event_loop__doc__},
735 : :
736 : : static PyObject *
737 : : _asyncio__get_event_loop_impl(PyObject *module, int stacklevel);
738 : :
739 : : static PyObject *
740 : 461 : _asyncio__get_event_loop(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
741 : : {
742 : 461 : PyObject *return_value = NULL;
743 : : static const char * const _keywords[] = {"stacklevel", NULL};
744 : : static _PyArg_Parser _parser = {NULL, _keywords, "_get_event_loop", 0};
745 : : PyObject *argsbuf[1];
746 [ + + ]: 461 : Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
747 : 461 : int stacklevel = 3;
748 : :
749 [ + + + - : 461 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
+ - - + ]
750 [ - + ]: 461 : if (!args) {
751 : 0 : goto exit;
752 : : }
753 [ + + ]: 461 : if (!noptargs) {
754 : 108 : goto skip_optional_pos;
755 : : }
756 : 353 : stacklevel = _PyLong_AsInt(args[0]);
757 [ - + - - ]: 353 : if (stacklevel == -1 && PyErr_Occurred()) {
758 : 0 : goto exit;
759 : : }
760 : 353 : skip_optional_pos:
761 : 461 : return_value = _asyncio__get_event_loop_impl(module, stacklevel);
762 : :
763 : 461 : exit:
764 : 461 : return return_value;
765 : : }
766 : :
767 : : PyDoc_STRVAR(_asyncio_get_running_loop__doc__,
768 : : "get_running_loop($module, /)\n"
769 : : "--\n"
770 : : "\n"
771 : : "Return the running event loop. Raise a RuntimeError if there is none.\n"
772 : : "\n"
773 : : "This function is thread-specific.");
774 : :
775 : : #define _ASYNCIO_GET_RUNNING_LOOP_METHODDEF \
776 : : {"get_running_loop", (PyCFunction)_asyncio_get_running_loop, METH_NOARGS, _asyncio_get_running_loop__doc__},
777 : :
778 : : static PyObject *
779 : : _asyncio_get_running_loop_impl(PyObject *module);
780 : :
781 : : static PyObject *
782 : 11422 : _asyncio_get_running_loop(PyObject *module, PyObject *Py_UNUSED(ignored))
783 : : {
784 : 11422 : return _asyncio_get_running_loop_impl(module);
785 : : }
786 : :
787 : : PyDoc_STRVAR(_asyncio__register_task__doc__,
788 : : "_register_task($module, /, task)\n"
789 : : "--\n"
790 : : "\n"
791 : : "Register a new task in asyncio as executed by loop.\n"
792 : : "\n"
793 : : "Returns None.");
794 : :
795 : : #define _ASYNCIO__REGISTER_TASK_METHODDEF \
796 : : {"_register_task", _PyCFunction_CAST(_asyncio__register_task), METH_FASTCALL|METH_KEYWORDS, _asyncio__register_task__doc__},
797 : :
798 : : static PyObject *
799 : : _asyncio__register_task_impl(PyObject *module, PyObject *task);
800 : :
801 : : static PyObject *
802 : 1136 : _asyncio__register_task(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
803 : : {
804 : 1136 : PyObject *return_value = NULL;
805 : : static const char * const _keywords[] = {"task", NULL};
806 : : static _PyArg_Parser _parser = {NULL, _keywords, "_register_task", 0};
807 : : PyObject *argsbuf[1];
808 : : PyObject *task;
809 : :
810 [ + - + - : 1136 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
+ - - + ]
811 [ - + ]: 1136 : if (!args) {
812 : 0 : goto exit;
813 : : }
814 : 1136 : task = args[0];
815 : 1136 : return_value = _asyncio__register_task_impl(module, task);
816 : :
817 : 1136 : exit:
818 : 1136 : return return_value;
819 : : }
820 : :
821 : : PyDoc_STRVAR(_asyncio__unregister_task__doc__,
822 : : "_unregister_task($module, /, task)\n"
823 : : "--\n"
824 : : "\n"
825 : : "Unregister a task.\n"
826 : : "\n"
827 : : "Returns None.");
828 : :
829 : : #define _ASYNCIO__UNREGISTER_TASK_METHODDEF \
830 : : {"_unregister_task", _PyCFunction_CAST(_asyncio__unregister_task), METH_FASTCALL|METH_KEYWORDS, _asyncio__unregister_task__doc__},
831 : :
832 : : static PyObject *
833 : : _asyncio__unregister_task_impl(PyObject *module, PyObject *task);
834 : :
835 : : static PyObject *
836 : 5 : _asyncio__unregister_task(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
837 : : {
838 : 5 : PyObject *return_value = NULL;
839 : : static const char * const _keywords[] = {"task", NULL};
840 : : static _PyArg_Parser _parser = {NULL, _keywords, "_unregister_task", 0};
841 : : PyObject *argsbuf[1];
842 : : PyObject *task;
843 : :
844 [ + - + - : 5 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
+ - - + ]
845 [ - + ]: 5 : if (!args) {
846 : 0 : goto exit;
847 : : }
848 : 5 : task = args[0];
849 : 5 : return_value = _asyncio__unregister_task_impl(module, task);
850 : :
851 : 5 : exit:
852 : 5 : return return_value;
853 : : }
854 : :
855 : : PyDoc_STRVAR(_asyncio__enter_task__doc__,
856 : : "_enter_task($module, /, loop, task)\n"
857 : : "--\n"
858 : : "\n"
859 : : "Enter into task execution or resume suspended task.\n"
860 : : "\n"
861 : : "Task belongs to loop.\n"
862 : : "\n"
863 : : "Returns None.");
864 : :
865 : : #define _ASYNCIO__ENTER_TASK_METHODDEF \
866 : : {"_enter_task", _PyCFunction_CAST(_asyncio__enter_task), METH_FASTCALL|METH_KEYWORDS, _asyncio__enter_task__doc__},
867 : :
868 : : static PyObject *
869 : : _asyncio__enter_task_impl(PyObject *module, PyObject *loop, PyObject *task);
870 : :
871 : : static PyObject *
872 : 1709 : _asyncio__enter_task(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
873 : : {
874 : 1709 : PyObject *return_value = NULL;
875 : : static const char * const _keywords[] = {"loop", "task", NULL};
876 : : static _PyArg_Parser _parser = {NULL, _keywords, "_enter_task", 0};
877 : : PyObject *argsbuf[2];
878 : : PyObject *loop;
879 : : PyObject *task;
880 : :
881 [ + - + - : 1709 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 2, 0, argsbuf);
+ - - + ]
882 [ - + ]: 1709 : if (!args) {
883 : 0 : goto exit;
884 : : }
885 : 1709 : loop = args[0];
886 : 1709 : task = args[1];
887 : 1709 : return_value = _asyncio__enter_task_impl(module, loop, task);
888 : :
889 : 1709 : exit:
890 : 1709 : return return_value;
891 : : }
892 : :
893 : : PyDoc_STRVAR(_asyncio__leave_task__doc__,
894 : : "_leave_task($module, /, loop, task)\n"
895 : : "--\n"
896 : : "\n"
897 : : "Leave task execution or suspend a task.\n"
898 : : "\n"
899 : : "Task belongs to loop.\n"
900 : : "\n"
901 : : "Returns None.");
902 : :
903 : : #define _ASYNCIO__LEAVE_TASK_METHODDEF \
904 : : {"_leave_task", _PyCFunction_CAST(_asyncio__leave_task), METH_FASTCALL|METH_KEYWORDS, _asyncio__leave_task__doc__},
905 : :
906 : : static PyObject *
907 : : _asyncio__leave_task_impl(PyObject *module, PyObject *loop, PyObject *task);
908 : :
909 : : static PyObject *
910 : 1710 : _asyncio__leave_task(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
911 : : {
912 : 1710 : PyObject *return_value = NULL;
913 : : static const char * const _keywords[] = {"loop", "task", NULL};
914 : : static _PyArg_Parser _parser = {NULL, _keywords, "_leave_task", 0};
915 : : PyObject *argsbuf[2];
916 : : PyObject *loop;
917 : : PyObject *task;
918 : :
919 [ + - + - : 1710 : args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 2, 0, argsbuf);
+ - - + ]
920 [ - + ]: 1710 : if (!args) {
921 : 0 : goto exit;
922 : : }
923 : 1710 : loop = args[0];
924 : 1710 : task = args[1];
925 : 1710 : return_value = _asyncio__leave_task_impl(module, loop, task);
926 : :
927 : 1710 : exit:
928 : 1710 : return return_value;
929 : : }
930 : : /*[clinic end generated code: output=eccf150c9c30efd5 input=a9049054013a1b77]*/
|
