AsyncTask(name),

_function(nullptr),

_args(nullptr),

_upon_death(nullptr),

_owner(nullptr),

_registered_to_owner(false),

_exception(nullptr),

_exc_value(nullptr),

_exc_traceback(nullptr),

_generator(nullptr),

_future_done(nullptr),

_ignore_return(false),

_retrieved_exception(false) {

nassertv(func_or_coro != nullptr);

if (func_or_coro == Py_None || PyCallable_Check(func_or_coro)) {

_function = func_or_coro;

Py_INCREF(_function);

} else if (PyCoro_CheckExact(func_or_coro)) {

// We also allow passing in a coroutine, because why not.

_generator = func_or_coro;

Py_INCREF(_generator);

} else if (PyGen_CheckExact(func_or_coro)) {

// Something emulating a coroutine.

_generator = func_or_coro;

Py_INCREF(_generator);

} else {

nassert_raise("Invalid function passed to PythonTask");

}

set_args(Py_None, true);

set_upon_death(Py_None);

set_owner(Py_None);

__dict__ = PyDict_New();

#ifndef SIMPLE_THREADS

// Ensure that the Python threading system is initialized and ready to go.

#ifdef WITH_THREAD // This symbol defined within Python.h

PyEval_InitThreads();

#endif

#endif

Py_XDECREF(_function);

_function = function;

Py_INCREF(_function);

if (_function != Py_None && !PyCallable_Check(_function)) {

nassert_raise("Invalid function passed to PythonTask");

}

Py_XDECREF(_args);

_args = nullptr;

if (args == Py_None) {

// None means no arguments; create an empty tuple.

_args = PyTuple_New(0);

} else {

if (PySequence_Check(args)) {

_args = PySequence_Tuple(args);

}

}

if (_args == nullptr) {

nassert_raise("Invalid args passed to PythonTask");

_args = PyTuple_New(0);

}

_append_task = append_task;

Py_XDECREF(_upon_death);

_upon_death = upon_death;

Py_INCREF(_upon_death);

if (_upon_death != Py_None && !PyCallable_Check(_upon_death)) {

nassert_raise("Invalid upon_death function passed to PythonTask");

}

#ifndef NDEBUG

if (owner != Py_None) {

PyObject *add = PyObject_GetAttrString(owner, "_addTask");

PyObject *clear = PyObject_GetAttrString(owner, "_clearTask");

if (add == nullptr || !PyCallable_Check(add) ||

clear == nullptr || !PyCallable_Check(clear)) {

Dtool_Raise_TypeError("owner object should have _addTask and _clearTask methods");

return;

}

}

#endif

if (_owner != nullptr && _owner != Py_None && _state != S_inactive) {

unregister_from_owner();

}

Py_XDECREF(_owner);

_owner = owner;

Py_INCREF(_owner);

if (_owner != Py_None && _state != S_inactive) {

register_to_owner();

}

if (!PyUnicode_Check(attr)) {

PyErr_Format(PyExc_TypeError,

"attribute name must be string, not '%.200s'",

attr->ob_type->tp_name);

return -1;

}

PyObject *descr = _PyType_Lookup(Py_TYPE(self), attr);

if (descr != nullptr) {

Py_INCREF(descr);

descrsetfunc f = descr->ob_type->tp_descr_set;

if (f != nullptr) {

return f(descr, self, v);

}

}

if (task_cat.is_debug()) {

PyObject *str = PyObject_Repr(v);

task_cat.debug()

<< *this << ": task."

<< PyUnicode_AsUTF8(attr) << " = "

<< PyUnicode_AsUTF8(str) << "\n";

Py_DECREF(str);

}

return PyDict_SetItem(__dict__, attr, v);

if (PyObject_GenericSetAttr(self, attr, nullptr) == 0) {

return 0;

}

if (!PyErr_ExceptionMatches(PyExc_AttributeError)) {

return -1;

}

PyErr_Clear();

if (PyDict_DelItem(__dict__, attr) == -1) {

// PyDict_DelItem does not raise an exception.

PyErr_Format(PyExc_AttributeError,

"'PythonTask' object has no attribute '%U'",

attr);

return -1;

}

return 0;

return 0;

return 0;

AsyncTaskManager *manager = _manager;

if (manager != nullptr) {

nassertr(_chain->_manager == manager, false);

if (task_cat.is_debug()) {

task_cat.debug()

<< "Cancelling " << *this << "\n";

}

MutexHolder holder(manager->_lock);

if (_state == S_awaiting) {

// Reactivate it so that it can receive a CancelledException.

_must_cancel = true;

_state = AsyncTask::S_active;

_chain->_active.push_back(this);

--_chain->_num_awaiting_tasks;

return true;

}

else if (_future_done != nullptr) {

// We are polling, waiting for a non-Panda future to be done.

Py_DECREF(_future_done);

_future_done = nullptr;

_must_cancel = true;

return true;

}

else if (_chain->do_remove(this, true)) {

return true;

}

else {

if (task_cat.is_debug()) {

task_cat.debug()

<< " (unable to cancel " << *this << ")\n";

}

return false;

}

}

return false;

#if defined(HAVE_THREADS) && !defined(SIMPLE_THREADS)

// Use PyGILState to protect this asynchronous call.

PyGILState_STATE gstate;

gstate = PyGILState_Ensure();

#endif

DoneStatus result = do_python_task();

#if defined(HAVE_THREADS) && !defined(SIMPLE_THREADS)

PyGILState_Release(gstate);

#endif

return result;

PyObject *result = nullptr;

// Are we waiting for a future to finish?

if (_future_done != nullptr) {

PyObject *is_done = PyObject_CallObject(_future_done, nullptr);

if (!PyObject_IsTrue(is_done)) {

// Nope, ask again next frame.

Py_DECREF(is_done);

return DS_cont;

}

Py_DECREF(is_done);

Py_DECREF(_future_done);

_future_done = nullptr;

}

if (_generator == nullptr) {

// We are calling the function directly.

nassertr(_function != nullptr, DS_interrupt);

PyObject *args = get_args();

result = PythonThread::call_python_func(_function, args);

Py_DECREF(args);

if (result != nullptr && PyGen_Check(result)) {

// The function has yielded a generator. We will call into that

// henceforth, instead of calling the function from the top again.

if (task_cat.is_debug()) {

PyObject *str = PyObject_ASCII(_function);

task_cat.debug()

<< PyUnicode_AsUTF8(str) << " in " << *this

<< " yielded a generator.\n";

Py_DECREF(str);

}

_generator = result;

result = nullptr;

} else if (result != nullptr && Py_TYPE(result)->tp_as_async != nullptr) {

// The function yielded a coroutine, or something of the sort.

if (task_cat.is_debug()) {

PyObject *str = PyObject_ASCII(_function);

PyObject *str2 = PyObject_ASCII(result);

task_cat.debug()

<< PyUnicode_AsUTF8(str) << " in " << *this

<< " yielded an awaitable: " << PyUnicode_AsUTF8(str2) << "\n";

Py_DECREF(str);

Py_DECREF(str2);

}

if (PyCoro_CheckExact(result)) {

// If a coroutine, am_await is possible but senseless, since we can

// just call send(None) on the coroutine itself.

_generator = result;

} else {

unaryfunc await = Py_TYPE(result)->tp_as_async->am_await;

_generator = await(result);

Py_DECREF(result);

}

result = nullptr;

}

}

if (_generator != nullptr) {

if (!_must_cancel) {

// We are calling a generator. Use "send" rather than PyIter_Next since

// we need to be able to read the value from a StopIteration exception.

PyObject *func = PyObject_GetAttrString(_generator, "send");

nassertr(func != nullptr, DS_interrupt);

result = PyObject_CallFunctionObjArgs(func, Py_None, nullptr);

Py_DECREF(func);

} else {

// Throw a CancelledError into the generator.

_must_cancel = false;

PyObject *exc = _PyObject_CallNoArg(Extension<AsyncFuture>::get_cancelled_error_type());

PyObject *func = PyObject_GetAttrString(_generator, "throw");

result = PyObject_CallFunctionObjArgs(func, exc, nullptr);

Py_DECREF(func);

Py_DECREF(exc);

}

if (result == nullptr) {

// An error happened. If StopIteration, that indicates the task has

// returned. Otherwise, we need to save it so that it can be re-raised

// in the function that awaited this task.

Py_DECREF(_generator);

_generator = nullptr;

if (_PyGen_FetchStopIterationValue(&result) == 0) {

PyErr_Clear();

if (_must_cancel) {

// Task was cancelled right before finishing. Make sure it is not

// getting rerun or marked as successfully completed.

_state = S_servicing_removed;

}

// If we passed a coroutine into the task, eg. something like:

// taskMgr.add(my_async_function())

// then we cannot rerun the task, so the return value is always

// assumed to be DS_done. Instead, we pass the return value to the

// result of the `await` expression.

if (_function == nullptr) {

if (task_cat.is_debug()) {

task_cat.debug()

<< *this << " received StopIteration from coroutine.\n";

}

// Store the result in _exc_value because that's not used anyway.

Py_XDECREF(_exc_value);

_exc_value = result;

return DS_done;

}

} else if (PyErr_ExceptionMatches(Extension<AsyncFuture>::get_cancelled_error_type())) {

// Someone cancelled the coroutine, and it did not bother to handle it,

// so we should consider it cancelled.

if (task_cat.is_debug()) {

task_cat.debug()

<< *this << " was cancelled and did not catch CancelledError.\n";

}

_state = S_servicing_removed;

PyErr_Clear();

return DS_done;

} else if (_function == nullptr) {

// We got an exception. If this is a scheduled coroutine, we will

// keep it and instead throw it into whatever 'awaits' this task.

// Otherwise, fall through and handle it the regular way.

Py_XDECREF(_exception);

Py_XDECREF(_exc_value);

Py_XDECREF(_exc_traceback);

PyErr_Fetch(&_exception, &_exc_value, &_exc_traceback);

_retrieved_exception = false;

if (task_cat.is_debug()) {

if (_exception != nullptr && Py_TYPE(_exception) == &PyType_Type) {

task_cat.debug()

<< *this << " received " << ((PyTypeObject *)_exception)->tp_name << " from coroutine.\n";

} else {

task_cat.debug()

<< *this << " received exception from coroutine.\n";

}

}

// Tell the task chain we want to kill ourselves. We indicate this is

// a "clean exit" because we still want to run the done callbacks on

// exception.

return DS_done;

}

} else if (DtoolInstance_Check(result)) {

// We are waiting for an AsyncFuture (eg. other task) to finish.

AsyncFuture *fut = (AsyncFuture *)DtoolInstance_UPCAST(result, Dtool_AsyncFuture);

if (fut != nullptr) {

// Suspend execution of this task until this other task has completed.

if (fut != (AsyncFuture *)this && !fut->done()) {

if (fut->is_task()) {

// This is actually a task, do we need to schedule it with the

// manager? This allows doing something like

// await Task.pause(1.0)

// directly instead of having to do:

// await taskMgr.add(Task.pause(1.0))

AsyncTask *task = (AsyncTask *)fut;

if (!task->is_alive()) {

_manager->add(task);

}

}

if (fut->add_waiting_task(this)) {

if (task_cat.is_debug()) {

task_cat.debug()

<< *this << " is now awaiting <" << *fut << ">.\n";

}

} else {

// The task is already done. Continue at next opportunity.

if (task_cat.is_debug()) {

task_cat.debug()

<< *this << " would await <" << *fut << ">, were it not already done.\n";

}

Py_DECREF(result);

return DS_cont;

}

} else {

// This is an error. If we wanted to be fancier we could also

// detect deeper circular dependencies.

task_cat.error()

<< *this << " cannot await itself\n";

}

Py_DECREF(result);

return DS_await;

}

} else {

// We are waiting for a non-Panda future to finish. We currently

// implement this by checking every frame whether the future is done.

PyObject *check = PyObject_GetAttrString(result, "_asyncio_future_blocking");

if (check != nullptr && check != Py_None) {

Py_DECREF(check);

// Next frame, check whether this future is done.

_future_done = PyObject_GetAttrString(result, "done");

if (_future_done == nullptr || !PyCallable_Check(_future_done)) {

task_cat.error()

<< "future.done is not callable\n";

return DS_interrupt;

}

if (task_cat.is_debug()) {

PyObject *str = PyObject_ASCII(result);

task_cat.debug()

<< *this << " is now polling " << PyUnicode_AsUTF8(str) << ".done()\n";

Py_DECREF(str);

}

Py_DECREF(result);

return DS_cont;

}

PyErr_Clear();

Py_XDECREF(check);

}

}

if (result == nullptr) {

if (PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_SystemExit)) {

// Don't print an error message for SystemExit. Or rather, make it a

// debug message.

if (task_cat.is_debug()) {

task_cat.debug()

<< "SystemExit occurred in " << *this << "\n";

}

} else {

task_cat.error()

<< "Exception occurred in " << *this << "\n";

}

return DS_interrupt;

}

if (result == Py_None || _ignore_return) {

Py_DECREF(result);

return DS_done;

}

if (PyLong_Check(result)) {

long retval = PyLong_AS_LONG(result);

switch (retval) {

case DS_again:

Py_XDECREF(_generator);

_generator = nullptr;

// Fall through.

case DS_done:

case DS_cont:

case DS_pickup:

case DS_exit:

case DS_pause:

// Legitimate value.

Py_DECREF(result);

return (DoneStatus) retval;

case -1:

// Legacy value.

Py_DECREF(result);

return DS_done;

default:

// Unexpected value.

break;

}

}

// This is unfortunate, but some are returning task.done, which nowadays

// conflicts with the AsyncFuture method. Check if that is being returned.

PyMethodDef *meth = nullptr;

if (PyCFunction_Check(result)) {

meth = ((PyCFunctionObject *)result)->m_ml;

} else if (Py_TYPE(result) == &PyMethodDescr_Type) {

meth = ((PyMethodDescrObject *)result)->d_method;

}

if (meth != nullptr && strcmp(meth->ml_name, "done") == 0) {

Py_DECREF(result);

return DS_done;

}

std::ostringstream strm;

PyObject *str = PyObject_ASCII(result);

if (str == nullptr) {

str = PyUnicode_FromString("<repr error>");

}

strm

<< *this << " returned " << PyUnicode_AsUTF8(str);

Py_DECREF(str);

Py_DECREF(result);

std::string message = strm.str();

nassert_raise(message);

return DS_interrupt;

AsyncTask::upon_death(manager, clean_exit);

// If we were polling something when we were removed, get rid of it.

if (_future_done != nullptr) {

Py_DECREF(_future_done);

_future_done = nullptr;

}

if (_upon_death != Py_None) {

#if defined(HAVE_THREADS) && !defined(SIMPLE_THREADS)

// Use PyGILState to protect this asynchronous call.

PyGILState_STATE gstate;

gstate = PyGILState_Ensure();

#endif

call_function(_upon_death);

#if defined(HAVE_THREADS) && !defined(SIMPLE_THREADS)

PyGILState_Release(gstate);

#endif

}

unregister_from_owner();

if (_owner != Py_None && !_registered_to_owner) {

#if defined(HAVE_THREADS) && !defined(SIMPLE_THREADS)

// Use PyGILState to protect this asynchronous call.

PyGILState_STATE gstate;

gstate = PyGILState_Ensure();

#endif

_registered_to_owner = true;

call_owner_method("_addTask");

#if defined(HAVE_THREADS) && !defined(SIMPLE_THREADS)

PyGILState_Release(gstate);

#endif

}

// make sure every call to _clearTask corresponds to a call to _addTask

if (_owner != Py_None && _registered_to_owner) {

#if defined(HAVE_THREADS) && !defined(SIMPLE_THREADS)

// Use PyGILState to protect this asynchronous call.

PyGILState_STATE gstate;

gstate = PyGILState_Ensure();

#endif

_registered_to_owner = false;

call_owner_method("_clearTask");

#if defined(HAVE_THREADS) && !defined(SIMPLE_THREADS)

PyGILState_Release(gstate);

#endif

}

if (_owner != Py_None) {

PyObject *func = PyObject_GetAttrString(_owner, (char *)method_name);

if (func == nullptr) {

task_cat.error()

<< "Owner object added to " << *this << " has no method "

<< method_name << "().\n";

} else {

call_function(func);

Py_DECREF(func);

}

}

if (function != Py_None) {

this->ref();

PyObject *self = DTool_CreatePyInstance(this, Dtool_PythonTask, true, false);

PyObject *result = PyObject_CallFunctionObjArgs(function, self, nullptr);

Py_XDECREF(result);

Py_DECREF(self);

}