Twisted Python IRC机器人-如何异步执行函数以使其不会阻塞机器人？

Question

I'm trying to write an IRC bot that continues to work normally while it executes a long (10+ seconds) function.

I started by writing the bot using socket. When I called a 'blocking' function (computation that takes few seconds to execute), the bot naturally stopped responding and did not record any messages sent in chat while the function was computing.

I did some googling and saw a lot of people recommend using Twisted.

I implemented basic IRC bot, heavily based on some examples:

# twisted imports
from twisted.words.protocols import irc
from twisted.internet import reactor, protocol
from twisted.python import log

# system imports
import time, sys, datetime

def a_long_function():
    time.sleep(180)
    print("finished")

class BotMain(irc.IRCClient):

    nickname = "testIRC_bot"

    def connectionMade(self):
        irc.IRCClient.connectionMade(self)

    def connectionLost(self, reason):
        irc.IRCClient.connectionLost(self, reason)

    # callbacks for events

    def signedOn(self):
        """Signed to server"""
        self.join(self.factory.channel)

    def joined(self, channel):
        """Joined channel"""

    def privmsg(self, user, channel, msg):
        """Received message"""
        user = user.split('!', 1)[0]

        if 'test' in msg.lower():
            print("timeout started")

            a_long_function()

            msg = "test finished"
            self.msg(channel, msg)

        if 'ping' in msg.lower():
            self.msg(channel, "pong")
            print("pong")

class BotMainFactory(protocol.ClientFactory):
    """A factory for BotMains """

    protocol = BotMain

    def __init__(self, channel, filename):
        self.channel = channel
        self.filename = filename

    def clientConnectionLost(self, connector, reason):
        """Try to reconnect on connection lost"""
        connector.connect()

    def clientConnectionFailed(self, connector, reason):
        print ("connection failed:", reason)
        reactor.stop()

if __name__ == '__main__':

    log.startLogging(sys.stdout)
    f = BotMainFactory("#test", "log.txt")
    reactor.connectTCP("irc.freenode.net", 6667, f)
    reactor.run()

This approach is definitely better than my earlier socket implementation, because now the bot still receives the messages sent while it executes a_long_function() .

However, it only 'sees' these messages after the function is complete. This means that when I was logging the messages to txt file, all messages received when a_long_function() was executing receive the same timestamp of when the function has finished - and not when they were actually sent in the chatroom.

Also, the bot still isn't able to send any messages while its executing the long function.

Could someone point me in the right direction of how I should go about changing the code so that this long function can be executed asynchronously, so that the bot can still log and reply to messages as it's executing?

Thanks in advance.

Edit: I came across this answer, which gave me an idea that I could add deferLater calls into my a_long_function to split it into smaller chunks (that say take 1s to execute), and have the bot resume normal operation in between to reply to and log any messages that were sent to the IRC channel in mean time. Or perhaps add a timer that counts how long a_long_function has been running for, and if its longer than a threshold, it would call a deferLater to let the bot catch up on the buffered messages.

This does seem like a bit of hack thought - is there a more elegant solution?

Answer 1

No, there is not really a more elegant solution. Unless you want to use threading, which might look more elegant but could easily lead to an unstable program. If you can avoid it, go with the deferral solution.

Answer 2

To asynchronously call a function, you should use the asyncio package along with async/await, or coroutines. Keep in mind that calling async/await is a v3 implementation, not v2.

Using async/await:

#!/usr/bin/env python3
# countasync.py

import asyncio

async def count():
    print("One")
    await asyncio.sleep(1)
    print("Two")

async def main():
    await asyncio.gather(count(), count(), count())

if __name__ == "__main__":
    import time
    s = time.perf_counter()
    asyncio.run(main())
    elapsed = time.perf_counter() - s
    print(f"{__file__} executed in {elapsed:0.2f} seconds.")

There is a really good tutorial you can read here that goes over using asyncio, in depth.

Hope of help!