Mix asyncio with twisted

asyncio_ex.py

import asyncio
import logging


async def start():
    logging.warning('started')
    await asyncio.sleep(2)
    logging.warning('finished')


async def main():
    logging.basicConfig(
        level=logging.INFO,
        format=(
            '%(asctime)s [%(levelname)s] PID:%(process)s '
            '%(pathname)s:%(lineno)d %(message)s'
        )
    )

    await asyncio.gather(start(),
                         start())

if __name__ == "__main__":
    loop = asyncio.get_event_loop()
    loop.run_until_complete(main())
    loop.close()

twisted_await.py

import logging

from twisted.internet import reactor, defer


def sleep(_):
    d = defer.Deferred()
    reactor.callLater(2, d.callback, None)
    return d


def end(_):
    logging.warning('finished')


async def start(_):
    logging.warning('started')
    await sleep(None)
    return _


def main():
    logging.basicConfig(
        level=logging.INFO,
        format=(
            '%(asctime)s [%(levelname)s] PID:%(process)s '
            '%(pathname)s:%(lineno)d %(message)s'
        )
    )

    for _ in range(2):
        d = defer.ensureDeferred(start(None))
        d.pause()
        d.addCallback(end)
        d.unpause()

    reactor.run()


if __name__ == "__main__":
    main()

twisted_await_asyncio.py

import asyncio
import logging


from twisted.internet import asyncioreactor
asyncioreactor.install(asyncio.get_event_loop())
from twisted.internet import defer, reactor


def end(_):
    logging.warning('finished')


async def start(_):
    logging.warning('started')
    await defer.ensureDeferred(asyncio.sleep(2))
    return _


def main():
    logging.basicConfig(
        level=logging.INFO,
        format=(
            '%(asctime)s [%(levelname)s] PID:%(process)s '
            '%(pathname)s:%(lineno)d %(message)s'
        )
    )

    for _ in range(2):
        d = defer.Deferred(defer.ensureDeferred(start(None)))
        d.pause()
        d.addCallback(end)
        d.unpause()
        d.callback(None)

    reactor.run()


if __name__ == "__main__":
    main()

twisted_ex.py

import logging

from twisted.internet import reactor, defer


defer.setDebugging(True)


def sleep(_):
    d = defer.Deferred()
    reactor.callLater(2, d.callback, None)
    return d


def end(_):
    logging.warning('finished')


def start(_):
    logging.warning('started')
    return _


def main():
    logging.basicConfig(
        level=logging.INFO,
        format=(
            '%(asctime)s [%(levelname)s] PID:%(process)s '
            '%(pathname)s:%(lineno)d %(message)s'
        )
    )

    for _ in range(2):
        d = defer.Deferred()
        d.pause()
        d.addCallback(start)
        d.addCallback(sleep)
        d.addCallback(end)
        d.unpause()
        d.callback(None)

    reactor.run()


if __name__ == "__main__":
    main()