Merge pull request CloudBotIRC#175 from linuxdaemon/gonzobot+fix-deprecations

Fix various DeprecationWarnings in the core and plugins

Author: edwardslabs

cloudbot/__main__.py

@@ -6,6 +6,10 @@
 import signal
 
 # store the original working directory, for use when restarting
+from functools import partial
+
+from cloudbot.util import async_util
+
 original_wd = os.path.realpath(".")
 
 # set up environment - we need to make sure we are in the install directory
@@ -47,9 +51,10 @@ def exit_gracefully(signum, frame):
             stopped_while_restarting = True
         else:
             _bot.loop.call_soon_threadsafe(
-                lambda: asyncio.async(_bot.stop("Killed (Received SIGINT {})".format(signum)), loop=_bot.loop))
+                partial(async_util.wrap_future, _bot.stop("Killed (Received SIGINT {})".format(signum)), loop=_bot.loop)
+            )
 
-        logger.warn("Bot received Signal Interrupt ({})".format(signum))
+        logger.warning("Bot received Signal Interrupt ({})".format(signum))
 
         # restore the original handler so if they do it again it triggers
         signal.signal(signal.SIGINT, original_sigint)

cloudbot/clients/irc.py

@@ -7,6 +7,7 @@
 
 from cloudbot.client import Client
 from cloudbot.event import Event, EventType
+from cloudbot.util import async_util
 
 logger = logging.getLogger("cloudbot")
 
@@ -218,8 +219,7 @@ def _send(self, line):
         :type line: str
         """
         logger.info("[{}] >> {}".format(self.name, line))
-        asyncio.async(self._protocol.send(line), loop=self.loop)
-
+        async_util.wrap_future(self._protocol.send(line), loop=self.loop)
 
     @property
     def connected(self):
@@ -272,14 +272,14 @@ def connection_lost(self, exc):
             # we've been closed intentionally, so don't reconnect
             return
         logger.error("[{}] Connection lost: {}".format(self.conn.name, exc))
-        asyncio.async(self.conn.connect(), loop=self.loop)
+        async_util.wrap_future(self.conn.connect(), loop=self.loop)
 
     def eof_received(self):
         self._connected = False
         # create a new connected_future for when we are connected.
         self._connected_future = asyncio.Future(loop=self.loop)
         logger.info("[{}] EOF received.".format(self.conn.name))
-        asyncio.async(self.conn.connect(), loop=self.loop)
+        async_util.wrap_future(self.conn.connect(), loop=self.loop)
         return True
 
     @asyncio.coroutine
@@ -339,7 +339,7 @@ def data_received(self, data):
             # Reply to pings immediately
 
             if command == "PING":
-                asyncio.async(self.send("PONG " + command_params[-1]), loop=self.loop)
+                async_util.wrap_future(self.send("PONG " + command_params[-1]), loop=self.loop)
 
             # Parse the command and params
 
@@ -406,7 +406,7 @@ def data_received(self, data):
                           irc_prefix=prefix, irc_command=command, irc_paramlist=command_params, irc_ctcp_text=ctcp_text)
 
             # handle the message, async
-            asyncio.async(self.bot.process(event), loop=self.loop)
+            async_util.wrap_future(self.bot.process(event), loop=self.loop)
 
 # Channel Commands
 # NOTICE #chan :Text

cloudbot/event.py

@@ -2,6 +2,10 @@
 import concurrent.futures
 import enum
 import logging
+import warnings
+from functools import partial
+
+import sys
 
 logger = logging.getLogger("cloudbot")
 
@@ -153,7 +157,7 @@ def prepare(self):
             # we're running a coroutine hook with a db, so initialise an executor pool
             self.db_executor = concurrent.futures.ThreadPoolExecutor(1)
             # be sure to initialize the db in the database executor, so it will be accessible in that thread.
-            self.db = yield from self.async(self.bot.db_session)
+            self.db = yield from self.async_call(self.bot.db_session)
 
     def prepare_threaded(self):
         """
@@ -189,7 +193,7 @@ def close(self):
         if self.db is not None:
             #logger.debug("Closing database session for {}:threaded=False".format(self.hook.description))
             # be sure the close the database in the database executor, as it is only accessable in that one thread
-            yield from self.async(self.db.close)
+            yield from self.async_call(self.db.close)
             self.db = None
 
     def close_threaded(self):
@@ -310,17 +314,34 @@ def has_permission(self, permission, notice=True):
         return self.conn.permissions.has_perm_mask(self.mask, permission, notice=notice)
 
     @asyncio.coroutine
-    def async(self, function, *args, **kwargs):
+    def async_call(self, func, *args, **kwargs):
         if self.db_executor is not None:
             executor = self.db_executor
         else:
             executor = None
-        if kwargs:
-            result = yield from self.loop.run_in_executor(executor, function, *args)
-        else:
-            result = yield from self.loop.run_in_executor(executor, lambda: function(*args, **kwargs))
+
+        part = partial(func, *args, **kwargs)
+        result = yield from self.loop.run_in_executor(executor, part)
         return result
 
+    if sys.version_info < (3, 7, 0):
+        # noinspection PyCompatibility
+        @asyncio.coroutine
+        def async_(self, function, *args, **kwargs):
+            warnings.warn(
+                "event.async() is deprecated, use event.async_call() instead.",
+                DeprecationWarning, stacklevel=2
+            )
+            result = yield from self.async_call(function, *args, **kwargs)
+            return result
+
+
+# Silence deprecation warnings about use of the 'async' name as a function
+try:
+    setattr(Event, 'async', getattr(Event, 'async_'))
+except AttributeError:
+    pass
+
 
 class CommandEvent(Event):
     """

cloudbot/hook.py

@@ -309,7 +309,7 @@ def sieve(param=None, **kwargs):
     """
 
     def _sieve_hook(func):
-        assert len(inspect.getargspec(func).args) == 3, \
+        assert len(inspect.getfullargspec(func).args) == 3, \
             "Sieve plugin has incorrect argument count. Needs params: bot, input, plugin"
 
         hook = _get_hook(func, "sieve")

cloudbot/plugin.py

@@ -5,15 +5,19 @@
 import logging
 import os
 import re
+import warnings
 from collections import defaultdict
 from operator import attrgetter
 from itertools import chain
 
 import sqlalchemy
+import sys
+
+import time
 
 from cloudbot.event import Event
 from cloudbot.hook import Priority, Action
-from cloudbot.util import database
+from cloudbot.util import database, async_util
 
 logger = logging.getLogger("cloudbot")
 
@@ -200,7 +204,7 @@ def load_plugin(self, path):
             self._log_hook(on_cap_ack_hook)
 
         for periodic_hook in plugin.periodic:
-            task = asyncio.async(self._start_periodic(periodic_hook))
+            task = async_util.wrap_future(self._start_periodic(periodic_hook))
             plugin.tasks.append(task)
             self._log_hook(periodic_hook)
 
@@ -640,12 +644,18 @@ def __init__(self, _type, plugin, func_hook):
         self.function = func_hook.function
         self.function_name = self.function.__name__
 
-        self.required_args = inspect.getargspec(self.function)[0]
-        if self.required_args is None:
-            self.required_args = []
+        sig = inspect.signature(self.function)
 
         # don't process args starting with "_"
-        self.required_args = [arg for arg in self.required_args if not arg.startswith("_")]
+        self.required_args = [arg for arg in sig.parameters.keys() if not arg.startswith('_')]
+        if sys.version_info < (3, 7, 0):
+            if "async" in self.required_args:
+                logger.warning("Use of deprecated function 'async' in %s", self.description)
+                time.sleep(1)
+                warnings.warn(
+                    "event.async() is deprecated, use event.async_call() instead.",
+                    DeprecationWarning, stacklevel=2
+                )
 
         if asyncio.iscoroutine(self.function) or asyncio.iscoroutinefunction(self.function):
             self.threaded = False

cloudbot/reloader.py

@@ -1,9 +1,12 @@
 import asyncio
 import os.path
+from functools import partial
 
 from watchdog.observers import Observer
 from watchdog.events import PatternMatchingEventHandler
 
+from cloudbot.util import async_util
+
 
 class PluginReloader(object):
     def __init__(self, bot):
@@ -38,7 +41,8 @@ def reload(self, path):
 
         if isinstance(path, bytes):
             path = path.decode()
-        self.bot.loop.call_soon_threadsafe(lambda: asyncio.async(self._reload(path), loop=self.bot.loop))
+
+        self.bot.loop.call_soon_threadsafe(partial(async_util.wrap_future, self._reload(path), loop=self.bot.loop))
 
     def unload(self, path):
         """
@@ -48,7 +52,8 @@ def unload(self, path):
         """
         if isinstance(path, bytes):
             path = path.decode()
-        self.bot.loop.call_soon_threadsafe(lambda: asyncio.async(self._unload(path), loop=self.bot.loop))
+
+        self.bot.loop.call_soon_threadsafe(partial(async_util.wrap_future, self._unload(path), loop=self.bot.loop))
 
     @asyncio.coroutine
     def _reload(self, path):

cloudbot/util/async_util.py

@@ -0,0 +1,20 @@
+"""
+Wraps various asyncio functions
+"""
+
+import asyncio
+
+import sys
+
+
+def wrap_future(fut, *, loop=None):
+    """
+    Wraps asyncio.async()/asyncio.ensure_future() depending on the python version
+    :param fut: The awaitable, future, or coroutine to wrap
+    :param loop: The loop to run in
+    :return: The wrapped future
+    """
+    if sys.version_info < (3, 4, 4):
+        return asyncio.async(fut, loop=loop)
+
+    return asyncio.ensure_future(fut, loop=loop)

plugins/autojoin.py

@@ -21,8 +21,8 @@ def get_channels(db, conn):
 
 @asyncio.coroutine
 @hook.irc_raw('004')
-def do_joins(db, conn, async):
-    chans = yield from async(get_channels, db, conn)
+def do_joins(db, conn, async_call):
+    chans = yield from async_call(get_channels, db, conn)
     join_throttle = conn.config.get("join_throttle", 0.4)
     for chan in chans:
         conn.join(chan[1])

plugins/geoip.py

@@ -10,6 +10,7 @@
 import geoip2.errors
 
 from cloudbot import hook
+from cloudbot.util import async_util
 
 logger = logging.getLogger("cloudbot")
 
@@ -52,6 +53,7 @@ def update_db():
         return geoip2.database.Reader(PATH)
 
 
+@asyncio.coroutine
 def check_db(loop):
     """
     runs update_db in an executor thread and sets geoip_reader to the result
@@ -68,7 +70,7 @@ def check_db(loop):
 @asyncio.coroutine
 @hook.on_start
 def load_geoip(loop):
-    asyncio.async(check_db(loop), loop=loop)
+    async_util.wrap_future(check_db(loop), loop=loop)
 
 
 @asyncio.coroutine

plugins/log.py

@@ -1,16 +1,15 @@
 import asyncio
-import os
 import codecs
+import os
 import time
 
 import cloudbot
 from cloudbot import hook
 from cloudbot.event import EventType
-
-
 # +---------+
 # | Formats |
 # +---------+
+from cloudbot.hook import Priority
 from cloudbot.util.formatting import strip_colors
 
 base_formats = {
@@ -246,10 +245,20 @@ def console_log(bot, event):
         bot.logger.info(text)
 
 
-@hook.on_stop
 @hook.command("flushlog", permissions=["botcontrol"])
 def flush_log():
     for name, stream in stream_cache.values():
         stream.flush()
     for name, stream in raw_cache.values():
         stream.flush()
+
+
+@hook.on_stop
+def close_logs():
+    for name, stream in stream_cache.values():
+        stream.flush()
+        stream.close()
+
+    for name, stream in raw_cache.values():
+        stream.flush()
+        stream.close()