Merge branch 'gonzobot' into gonzobot+fix-debug-mode-coros

Author: linuxdaemon

cloudbot/bot.py

@@ -314,7 +314,7 @@ def add_hook(hook, _event, _run_before=False):
                             add_hook(command_hook, command_event)
                         else:
                             event.notice("Possible matches: {}".format(
-                                formatting.get_text_list([command for command, plugin in potential_matches])))
+                                formatting.get_text_list(sorted([command for command, plugin in potential_matches]))))
 
         if event.type in (EventType.message, EventType.action):
             # Regex hooks

cloudbot/client.py

@@ -79,7 +79,7 @@ def try_connect(self):
             try:
                 yield from self.connect(timeout)
             except Exception:
-                logger.exception("[%s] Error occurred while connecting.")
+                logger.exception("[%s] Error occurred while connecting.", self.name)
             else:
                 break
 

cloudbot/clients/irc.py

@@ -126,11 +126,13 @@ def connect(self, timeout=None):
             return
 
         if self._connected:
+            self._connected = False
             logger.info("[{}] Reconnecting".format(self.name))
-            self._transport.close()
+            if self._transport:
+                self._transport.close()
         else:
-            self._connected = True
             logger.info("[{}] Connecting".format(self.name))
+
         optional_params = {}
         if self.local_bind:
             optional_params["local_addr"] = self.local_bind
@@ -144,6 +146,8 @@ def connect(self, timeout=None):
 
         self._transport, self._protocol = yield from coro
 
+        self._connected = True
+
         tasks = [
             self.bot.plugin_manager.launch(hook, Event(bot=self.bot, conn=self, hook=hook))
             for hook in self.bot.plugin_manager.connect_hooks
@@ -303,14 +307,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))
-        async_util.wrap_future(self.conn.connect(), loop=self.loop)
+        async_util.wrap_future(self.conn.try_connect(), loop=self.loop)
 
     def eof_received(self):
         self._connected = False
         # create a new connected_future for when we are connected.
         self._connected_future = async_util.create_future(self.loop)
         logger.info("[{}] EOF received.".format(self.conn.name))
-        async_util.wrap_future(self.conn.connect(), loop=self.loop)
+        async_util.wrap_future(self.conn.try_connect(), loop=self.loop)
         return True
 
     @asyncio.coroutine

cloudbot/util/formatting.py

@@ -47,6 +47,7 @@
 import copy
 import html.entities
 import re
+import warnings
 from html.parser import HTMLParser
 
 from cloudbot.util.colors import strip_irc
@@ -247,11 +248,65 @@ def pluralize(num=0, text=''):
     Takes a number and a string, and pluralizes that string using the number and combines the results.
     :rtype: str
     """
-    return "{:,} {}{}".format(num, text, "s"[num == 1:])
+    warnings.warn(
+        "formatting.pluralize() is deprecated, please use one of the other formatting.pluralize_*() functions",
+        DeprecationWarning
+    )
+    return pluralize_suffix(num, text)
 
 
-# alternate form
-pluralise = pluralize
+def pluralise(num=0, text=''):
+    """
+    Takes a number and a string, and pluralizes that string using the number and combines the results.
+    :rtype: str
+    """
+    warnings.warn(
+        "formatting.pluralise() is deprecated, please use one of the other formatting.pluralise_*() functions",
+        DeprecationWarning
+    )
+    return pluralise_suffix(num, text)
+
+
+def pluralize_suffix(num=0, text='', suffix='s'):
+    """
+    Takes a number and a string, and pluralizes that string using the number and combines the results.
+    :rtype: str
+    """
+    return pluralize_select(num, text, text + suffix)
+
+
+pluralise_suffix = pluralize_suffix
+
+
+def pluralize_select(count, single, plural):
+    return "{:,} {}".format(count, single if count == 1 else plural)
+
+
+pluralise_select = pluralize_select
+
+
+def pluralize_auto(count, thing):
+    if thing.endswith(('s', 'ss', 'sh', 'ch', 'x', 'z')):
+        return pluralize_suffix(count, thing, 'es')
+    elif thing.endswith(('f', 'fe')):
+        return pluralize_select(count, thing, thing.rsplit('f', 1)[0] + 'ves')
+    elif thing.endswith('y') and thing[-2:-1].lower() not in "aeiou":
+        return pluralize_select(count, thing, thing[:-1] + 'ies')
+    elif thing.endswith('y') and thing[-2:-1].lower() in "aeiou":
+        return pluralize_suffix(count, thing)
+    elif thing.endswith('o'):
+        return pluralize_suffix(count, thing, 'es')
+    elif thing.endswith('us'):
+        return pluralize_select(count, thing, thing[:-2] + 'i')
+    elif thing.endswith('is'):
+        return pluralize_select(count, thing, thing[:-2] + 'es')
+    elif thing.endswith('on'):
+        return pluralize_select(count, thing, thing[:-2] + 'a')
+    else:
+        return pluralize_suffix(count, thing)
+
+
+pluralise_auto = pluralize_auto
 
 
 def dict_format(args, formats):

cloudbot/util/test/test_formatting.py

@@ -1,5 +1,6 @@
-from cloudbot.util.formatting import munge, dict_format, pluralize, strip_colors, truncate, truncate_str, \
-    strip_html, multi_replace, multiword_replace, truncate_words, smart_split, get_text_list, ireplace, chunk_str
+from cloudbot.util.formatting import munge, dict_format, strip_colors, truncate, truncate_str, \
+    strip_html, multi_replace, multiword_replace, truncate_words, smart_split, get_text_list, ireplace, chunk_str, \
+    pluralize_suffix
 
 test_munge_input = "The quick brown fox jumps over the lazy dog"
 test_munge_count = 3
@@ -55,8 +56,8 @@ def test_dict_format():
 
 
 def test_pluralize():
-    assert pluralize(test_pluralize_num_a, test_pluralize_text) == test_pluralize_result_a
-    assert pluralize(test_pluralize_num_b, test_pluralize_text) == test_pluralize_result_b
+    assert pluralize_suffix(test_pluralize_num_a, test_pluralize_text) == test_pluralize_result_a
+    assert pluralize_suffix(test_pluralize_num_b, test_pluralize_text) == test_pluralize_result_b
 
 
 def test_strip_colors():

cloudbot/util/web.py

@@ -207,7 +207,7 @@ def paste(self, data, ext):
             'expire': '1d'
         }
         try:
-            r = requests.post(SNOONET_PASTE + '/paste/new', params=params)
+            r = requests.post(SNOONET_PASTE + '/paste/new', data=params)
             r.raise_for_status()
         except RequestException as e:
             r = e.response

data/food/coffee.json

@@ -1,6 +1,6 @@
 {
     "templates": [
-        "hands {user} a {size} {temperature} {flavor} {coffee} with {shots} shots of espresso!"
+        "hands {user} a {size} {temperature} {flavor} {coffee} with {shots} of espresso!"
     ],
     "parts": {
         "temperature": [
@@ -35,9 +35,9 @@
             "breve"
         ],
         "shots": [
-            "one",
-            "two",
-            "three"
+            "one shot",
+            "two shots",
+            "three shots"
         ]
     }
 }

plugins/autojoin.py

@@ -1,7 +1,8 @@
 import asyncio
+from collections import defaultdict
+from threading import RLock
 
 from sqlalchemy import PrimaryKeyConstraint, Column, String, Table, and_
-from sqlalchemy.exc import IntegrityError
 
 from cloudbot import hook
 from cloudbot.util import database
@@ -14,40 +15,54 @@
     PrimaryKeyConstraint('conn', 'chan')
 )
 
+chan_cache = defaultdict(set)
+db_lock = RLock()
+
 
 def get_channels(db, conn):
     return db.execute(table.select().where(table.c.conn == conn.name.casefold())).fetchall()
 
 
+@hook.on_start
+def load_cache(db):
+    with db_lock:
+        chan_cache.clear()
+        for row in db.execute(table.select()):
+            chan_cache[row['conn']].add(row['chan'])
+
+
 @hook.irc_raw('376')
 @asyncio.coroutine
-def do_joins(db, conn, async_call):
-    chans = yield from async_call(get_channels, db, conn)
+def do_joins(conn):
     join_throttle = conn.config.get("join_throttle", 0.4)
-    for chan in chans:
-        conn.join(chan[1])
+    for chan in chan_cache[conn.name]:
+        conn.join(chan)
         yield from asyncio.sleep(join_throttle)
 
 
 @hook.irc_raw('JOIN', singlethread=True)
 def add_chan(db, conn, chan, nick):
-    if nick.casefold() == conn.nick.casefold():
-        try:
+    chans = chan_cache[conn.name]
+    chan = chan.casefold()
+    if nick.casefold() == conn.nick.casefold() and chan not in chans:
+        with db_lock:
             db.execute(table.insert().values(conn=conn.name.casefold(), chan=chan.casefold()))
             db.commit()
-        except IntegrityError:
-            pass
+
+        load_cache(db)
 
 
 @hook.irc_raw('PART', singlethread=True)
 def on_part(db, conn, chan, nick):
     if nick.casefold() == conn.nick.casefold():
-        db.execute(table.delete().where(and_(table.c.conn == conn.name.casefold(), table.c.chan == chan.casefold())))
-        db.commit()
+        with db_lock:
+            db.execute(
+                table.delete().where(and_(table.c.conn == conn.name.casefold(), table.c.chan == chan.casefold())))
+            db.commit()
+
+        load_cache(db)
 
 
 @hook.irc_raw('KICK', singlethread=True)
 def on_kick(db, conn, chan, target):
-    if target.casefold() == conn.nick.casefold():
-        db.execute(table.delete().where(and_(table.c.conn == conn.name.casefold(), table.c.chan == chan.casefold())))
-        db.commit()
+    on_part(db, conn, chan, target)

plugins/chain.py

@@ -7,7 +7,7 @@
 from cloudbot import hook
 from cloudbot.event import CommandEvent
 from cloudbot.util import database
-from cloudbot.util.formatting import chunk_str, pluralize
+from cloudbot.util.formatting import chunk_str, pluralize_auto
 
 commands = Table(
     'chain_commands',
@@ -103,7 +103,7 @@ def chainallow(text, db, notice_doc, bot):
         res = db.execute(commands.delete().where(commands.c.hook == hook_name))
         db.commit()
         load_cache(db)
-        return "Deleted {}.".format(pluralize(res.rowcount, "row"))
+        return "Deleted {}.".format(pluralize_auto(res.rowcount, "row"))
     else:
         return notice_doc()
 

plugins/core/chan_log.py

@@ -16,35 +16,48 @@ def _dump_attrs(obj):
 def on_hook_end(error, launched_hook, launched_event, admin_log):
     should_broadcast = True
     if error is not None:
-        admin_log(
-            "Error occurred in {}.{}".format(launched_hook.plugin.title, launched_hook.function_name), should_broadcast
-        )
-
-        lines = traceback.format_exception(*error)
-        last_line = lines[-1]
-        admin_log(last_line, should_broadcast)
-        url = web.paste('\n'.join(lines))
-        admin_log("Traceback: " + url, should_broadcast)
-
-        lines = ["{} = {}".format(k, v) for k, v in _dump_attrs(launched_event)]
-        exc_type, exc, exc_tb = error
-
-        lines.append("")
-        lines.append("Error data:")
-        lines.extend("{} = {}".format(k, v) for k, v in _dump_attrs(exc))
-
-        if isinstance(exc, RequestException):
-            if exc.request is not None:
-                req = exc.request
-                lines.append("")
-                lines.append("Request Info:")
-                lines.extend("{} = {}".format(k, v) for k, v in _dump_attrs(req))
-
-            if exc.response is not None:
-                response = exc.response
-                lines.append("")
-                lines.append("Response Info:")
-                lines.extend("{} = {}".format(k, v) for k, v in _dump_attrs(response))
-
-        url = web.paste('\n'.join(lines))
-        admin_log("Event: " + url, should_broadcast)
+        messages = [
+            "Error occurred in {}.{}".format(launched_hook.plugin.title, launched_hook.function_name)
+        ]
+
+        try:
+            lines = traceback.format_exception(*error)
+            last_line = lines[-1]
+            messages.append(last_line.strip())
+        except Exception as e:
+            messages.append("Error occurred while formatting error {}: {}".format(type(e), e))
+        else:
+            try:
+                url = web.paste('\n'.join(lines))
+                messages.append("Traceback: " + url)
+            except Exception as e:
+                messages.append("Error occurred while gathering traceback {}: {}".format(type(e), e))
+
+        try:
+            lines = ["{} = {}".format(k, v) for k, v in _dump_attrs(launched_event)]
+            exc_type, exc, exc_tb = error
+
+            lines.append("")
+            lines.append("Error data:")
+            lines.extend("{} = {}".format(k, v) for k, v in _dump_attrs(exc))
+
+            if isinstance(exc, RequestException):
+                if exc.request is not None:
+                    req = exc.request
+                    lines.append("")
+                    lines.append("Request Info:")
+                    lines.extend("{} = {}".format(k, v) for k, v in _dump_attrs(req))
+
+                if exc.response is not None:
+                    response = exc.response
+                    lines.append("")
+                    lines.append("Response Info:")
+                    lines.extend("{} = {}".format(k, v) for k, v in _dump_attrs(response))
+
+            url = web.paste('\n'.join(lines))
+            messages.append("Event: " + url)
+        except Exception as e:
+            messages.append("Error occurred while gathering error data {}: {}".format(type(e), e))
+
+        for message in messages:
+            admin_log(message, should_broadcast)