give better output to discord of dice rolls, handle errors

written for expecting a JSON with detail in an error response, but might
also decently handle the other cases

hitomi/backends.py

@@ -9,13 +9,36 @@ import hitomi.config as config
 logger = logging.getLogger(__name__)
 
 
+class DrBotzoError(requests.HTTPError):
+    """Wrap HTTPError with the error detail from the dr.botzo API, if available."""
+
+    def __init__(self, *args, **kwargs):
+        """Initialize DrBotzoError."""
+        detail = kwargs.pop('detail', None)
+        self.detail = detail
+        super(DrBotzoError, self).__init__(*args, **kwargs)
+
+
 class DrBotzoBackend(object):
     """Basic HTTP requests API, wrapped with some authentication and config stuff."""
 
     def post(self, url, **kwargs):
         """Wrap requests.post with authentication and hostname settings."""
-        return requests.post(urljoin(config.DR_BOTZO_BACKEND_HOST, url),
+        try:
+            response = requests.post(urljoin(config.DR_BOTZO_BACKEND_HOST, url),
                                      auth=(config.DR_BOTZO_BACKEND_USER, config.DR_BOTZO_BACKEND_PASS), **kwargs)
+            response.raise_for_status()
+            return response
+        except requests.ConnectionError as cex:
+            logger.exception("received a connection error during POST %s", url)
+            raise DrBotzoError(cex, detail="A connection error occurred.")
+        except requests.HTTPError as httpex:
+            logger.exception("received an HTTP error during POST %s", url)
+            try:
+                detail = httpex.response.json()['detail']
+                raise DrBotzoError(httpex, detail=detail)
+            except (ValueError, KeyError):
+                raise DrBotzoError(httpex, detail="An unexpected error occurred.")
 
 
 dr_botzo = DrBotzoBackend()

hitomi/dice.py

@@ -1,10 +1,11 @@
 """Commands for dice rolling type behavior."""
 import logging
+import re
 
 from discord.ext import commands
 
 from hitomi import bot
-from hitomi.backends import dr_botzo
+from hitomi.backends import dr_botzo, DrBotzoError
 
 logger = logging.getLogger(__name__)
 
@@ -13,15 +14,23 @@ class Dice(commands.Cog):
     """Commands for rolling dice and whatnot."""
 
     @commands.command()
-    async def roll(self, ctx, dice):
+    async def roll(self, ctx, *, dice):
         """Roll a provided dice string.
 
         Format: T#K/NdS+M; T = times, K = keep, N = number, S = sides, M = modifier
         """
+        await ctx.trigger_typing()
         logger.info("rolling dice: %s", dice)
-        result = dr_botzo.post('/dice/rpc/roll/', json={'dice': dice})
+        try:
-        logger.debug(result)
+            response = dr_botzo.post('/dice/rpc/roll/', json={'dice': dice})
-        await ctx.send(result.json())
+            response.raise_for_status()
+            logger.debug("result of rolling dice: HTTP %s, %s", response.status_code, response.text)
+            output = re.sub(r'(\d+)(.*?\s+)(\(.*?\))', r'**\1**\2\3', response.json()['result'])
+            output = '\n'.join(output.split('; '))
+            await ctx.send(output)
+        except DrBotzoError as drex:
+            logger.exception("received an error from dr.botzo attempting to roll %s: %s", dice, drex)
+            await ctx.send(f"*{drex.detail}*")
 
 
 bot.add_cog(Dice(bot))