Merge branch 'gonzobot' into gonzobot+outgoing-sieves

Author: linuxdaemon

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,7 +7,7 @@
 
 from cloudbot.client import Client
 from cloudbot.event import Event, EventType, IrcOutEvent
-from cloudbot.util.parsers.irc import Message
+from cloudbot.util import async_util
 
 logger = logging.getLogger("cloudbot")
 
@@ -19,8 +19,10 @@
 irc_bad_chars = ''.join([chr(x) for x in list(range(0, 1)) + list(range(4, 32)) + list(range(127, 160))])
 irc_clean_re = re.compile('[{}]'.format(re.escape(irc_bad_chars)))
 
+
 def irc_clean(dirty):
-    return irc_clean_re.sub('',dirty)
+    return irc_clean_re.sub('', dirty)
+
 
 irc_command_to_event_type = {
     "PRIVMSG": EventType.message,
@@ -219,8 +221,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):
@@ -273,14 +274,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
@@ -370,7 +371,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
 
@@ -437,13 +438,4 @@ 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)
-
-# Channel Commands
-# NOTICE #chan :Text
-# PRIVMSG #chan :Text
-# KICK #chan nick :reason
-# JOIN #chan
-# PART #chan :reason
-# MODE #chan +<modes>
-# INVITE nick :#chan
+            async_util.wrap_future(self.bot.process(event), loop=self.loop)

cloudbot/event.py

@@ -2,6 +2,10 @@
 import concurrent.futures
 import enum
 import logging
+import warnings
+from functools import partial
+
+import sys
 
 from cloudbot.util.parsers.irc import Message
 
@@ -155,7 +159,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):
         """
@@ -191,7 +195,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):
@@ -312,17 +316,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 itertools import chain
 from operator import attrgetter
 
 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")
 
@@ -202,7 +206,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)
 
@@ -654,12 +658,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)

data/kero.txt

@@ -0,0 +1,43 @@
+PRIUS JIMMY BUFFET!!!
+DISNEY APPLE BEARDS, FUCK COFFEE!
+FUCK THINGS THAT ARE GOOD AND NICE!
+RED ZONE SCHMED ZONE!
+i DONT USE APPLE CPMPUTERS!!!!
+???!??!?  YOU CLEARLY DONT LISTEN!
+WHY ARE PEOPLE CALLING ME A NERD I WAS ON THE iPHONE AND DONT GET IT!!!!
+OH MAN FUCK BEARDS!
+I AM GOING DOWN THE HALL TO A MEETING UNDER MY OWN POWER RIGHT NOW!!!
+NOT A VEGETABLE!!!!!!!
+i think thats a vulva euphemism, PW.
+THEY START SHOVING CAKES IN EACH OTHERS FACES LIKE ITS A MANATEE WEDDING HOLY SHIT!
+I DONT MAKE THE NEWS I JUST REPORT IT!
+HURR DURR YOU ARE OLD WITH PRINTED PAGES
+pants on head mouthbreather.
+HELLO I AM BACK WHAT IS NEW?
+YOU ARE A HORRIBLE DEAD FAN!
+i try not to be racist, but seriously.  there's a mexican guy in our neighborhood.  on the 4th like 40 people in his family came over and shot off fireworks and they sat in lawn chairs in the front yard.
+there's an old asian woman in our neighborhood who hides in her house and walks 10 feet  behind her husband and is a bad driver.
+HOW AM I NOT SUPPOSED TO BE RACIST WITH THAT OVERWHELMING EVIDENCE EXACTLY!?!?
+???? WTF IS
+NO I NEVER THINK THAT I AM VERY HAPPY
+HORSES CANT TALK IDIOTS
+I WENT TO ZERO STRIP CLUBS AND HAD ZERO STREET BEER
+I FUCKING WRITE CURRICULUM ON HOW TO SELL AND NETWORK AND RUN A BUSINESS ALL FUCKING DAY LONG
+you gentlemen are hilarious.  theres certainly nothing in what you're doing that could be considered "ball busting" or "trolling."
+YOU CAN EMAIL FROM YOUR PHONE? MAGIC MAN FROM THE FUTURE, DO THEY HAVE RUBBER VAGINAS MEN CAN PUT THEIR DICKS INTO AS WELL?
+really who the fuck cares who the third president was?
+why dont you just bore your candidat to tears with talk about subarus and guns and talk about the recruiters that have been calling *you*? Itll be just like irc.
+DONT TAKE AWAY MY FUN.
+I may beat off on the notes afterward because that turns me on, DONT JUDGE ME ITS NORMAL.
+wtf is a homeless guyy gonna do with a speaker SURE WOULD LIKE TO EAT BUT AT LEAST I HAVE MY KOOL JAMZ
+thanks for overexplaining that one
+Really.  I say ejaculating on pictures is weird and somehow that translates to OMG WAT A PRUDE
+Had someone ejaculate on a picture of me.  Gotta try it once.
+apparently theres a thing where people ejaculate on pictures i bet you could monetize that.
+'Hey you can talk to this chick and maybe get laid or cum on a picture,' only complete social retards pick the latter.
+Hahaha those weirdos with tentacle porn excuse me I need to whack it on a picture and put it on the Internet.
+enjoy your penis salad sandwich
+im pretty sure ive never said 'OH MY GOODNESS LOOK AT HIS PENIS I WISH I HAD THAT PENIS' then went searching for it to show someone else 24 hours later because i couldn't stop thinking about teddy bridgewater's beautiful penis <3
+i don't think "we" have ever "talked a lot of dick."
+OMG DID YOU SEE THE BALLS TOO?
+be as weird as you want. i dont understand why its so cool now to go "OOOO THATS JUST WHO HE IS DONT JUDGE." if you like to have your balls hit with a hammer while you ejaculate onto pictures of horses i think you should be called fucking weird.

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