Created an uptime cog. Testing Azure CI deployment.

6 files changed, 654 insertions, 0 deletions

diff --git a/bot/cogs/hacktober/__init__.py b/bot/cogs/hacktober/__init__.py
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/bot/cogs/hacktober/__init__.py
diff --git a/bot/cogs/hacktober/hacktoberstats.py b/bot/cogs/hacktober/hacktoberstats.py
new file mode 100644
index 00000000..0ccb41c1
--- /dev/null
+++ b/bot/cogs/hacktober/hacktoberstats.py
@@ -0,0 +1,326 @@
+import json
+import logging
+import re
+import typing
+from collections import Counter
+from datetime import datetime
+from pathlib import Path
+
+import aiohttp
+import discord
+from discord.ext import commands
+
+
+class Stats:
+    def __init__(self, bot):
+        self.bot = bot
+        self.link_json = Path('./bot/resources', 'github_links.json')
+        self.linked_accounts = self.load_linked_users()
+
+    @commands.group(
+        name='stats',
+        aliases=('hacktoberstats', 'getstats', 'userstats'),
+        invoke_without_command=True
+    )
+    async def hacktoberstats_group(self, ctx: commands.Context, github_username: str = None):
+        """
+        If invoked without a subcommand or github_username, get the invoking user's stats if
+        they've linked their Discord name to GitHub using .stats link
+
+        If invoked with a github_username, get that user's contributions
+        """
+        if not github_username:
+            author_id, author_mention = Stats._author_mention_from_context(ctx)
+
+            if str(author_id) in self.linked_accounts.keys():
+                github_username = self.linked_accounts[author_id]["github_username"]
+                logging.info(f"Getting stats for {author_id} linked GitHub account '{github_username}'")
+            else:
+                msg = (
+                    f"{author_mention}, you have not linked a GitHub account\n\n"
+                    f"You can link your GitHub account using:\n```{ctx.prefix}stats link github_username```\n"
+                    f"Or query GitHub stats directly using:\n```{ctx.prefix}stats github_username```"
+                )
+                await ctx.send(msg)
+                return
+
+        await self.get_stats(ctx, github_username)
+
+    @hacktoberstats_group.command(name="link")
+    async def link_user(self, ctx: commands.Context, github_username: str = None):
+        """
+        Link the invoking user's Github github_username to their Discord ID
+
+        Linked users are stored as a nested dict:
+            {
+                Discord_ID: {
+                    "github_username": str
+                    "date_added": datetime
+                }
+            }
+        """
+        author_id, author_mention = Stats._author_mention_from_context(ctx)
+        if github_username:
+            if str(author_id) in self.linked_accounts.keys():
+                old_username = self.linked_accounts[author_id]["github_username"]
+                logging.info(f"{author_id} has changed their github link from '{old_username}' to '{github_username}'")
+                await ctx.send(f"{author_mention}, your GitHub username has been updated to: '{github_username}'")
+            else:
+                logging.info(f"{author_id} has added a github link to '{github_username}'")
+                await ctx.send(f"{author_mention}, your GitHub username has been added")
+
+            self.linked_accounts[author_id] = {
+                "github_username": github_username,
+                "date_added": datetime.now()
+            }
+
+            self.save_linked_users()
+        else:
+            logging.info(f"{author_id} tried to link a GitHub account but didn't provide a username")
+            await ctx.send(f"{author_mention}, a GitHub username is required to link your account")
+
+    @hacktoberstats_group.command(name="unlink")
+    async def unlink_user(self, ctx: commands.Context):
+        """
+        Remove the invoking user's account link from the log
+        """
+        author_id, author_mention = Stats._author_mention_from_context(ctx)
+
+        stored_user = self.linked_accounts.pop(author_id, None)
+        if stored_user:
+            await ctx.send(f"{author_mention}, your GitHub profile has been unlinked")
+            logging.info(f"{author_id} has unlinked their GitHub account")
+        else:
+            await ctx.send(f"{author_mention}, you do not currently have a linked GitHub account")
+            logging.info(f"{author_id} tried to unlink their GitHub account but no account was linked")
+
+        self.save_linked_users()
+
+    def load_linked_users(self) -> typing.Dict:
+        """
+        Load list of linked users from local JSON file
+
+        Linked users are stored as a nested dict:
+            {
+                Discord_ID: {
+                    "github_username": str
+                    "date_added": datetime
+                }
+            }
+        """
+        if self.link_json.exists():
+            logging.info(f"Loading linked GitHub accounts from '{self.link_json}'")
+            with open(self.link_json, 'r') as fID:
+                linked_accounts = json.load(fID)
+
+            logging.info(f"Loaded {len(linked_accounts)} linked GitHub accounts from '{self.link_json}'")
+            return linked_accounts
+        else:
+            logging.info(f"Linked account log: '{self.link_json}' does not exist")
+            return {}
+
+    def save_linked_users(self):
+        """
+        Save list of linked users to local JSON file
+
+        Linked users are stored as a nested dict:
+            {
+                Discord_ID: {
+                    "github_username": str
+                    "date_added": datetime
+                }
+            }
+        """
+        logging.info(f"Saving linked_accounts to '{self.link_json}'")
+        with open(self.link_json, 'w') as fID:
+            json.dump(self.linked_accounts, fID, default=str)
+        logging.info(f"linked_accounts saved to '{self.link_json}'")
+
+    async def get_stats(self, ctx: commands.Context, github_username: str):
+        """
+        Query GitHub's API for PRs created by a GitHub user during the month of October that
+        do not have an 'invalid' tag
+
+        For example:
+            !getstats heavysaturn
+
+        If a valid github_username is provided, an embed is generated and posted to the channel
+
+        Otherwise, post a helpful error message
+        """
+        prs = await self.get_october_prs(github_username)
+
+        if prs:
+            stats_embed = self.build_embed(github_username, prs)
+            await ctx.send('Here are some stats!', embed=stats_embed)
+        else:
+            await ctx.send(f"No October GitHub contributions found for '{github_username}'")
+
+    def build_embed(self, github_username: str, prs: typing.List[dict]) -> discord.Embed:
+        """
+        Return a stats embed built from github_username's PRs
+        """
+        logging.info(f"Building Hacktoberfest embed for GitHub user: '{github_username}'")
+        pr_stats = self._summarize_prs(prs)
+
+        n = pr_stats['n_prs']
+        if n >= 5:
+            shirtstr = f"**{github_username} has earned a tshirt!**"
+        elif n == 4:
+            shirtstr = f"**{github_username} is 1 PR away from a tshirt!**"
+        else:
+            shirtstr = f"**{github_username} is {5 - n} PRs away from a tshirt!**"
+
+        stats_embed = discord.Embed(
+            title=f"{github_username}'s Hacktoberfest",
+            color=discord.Color(0x9c4af7),
+            description=f"{github_username} has made {n} {Stats._contributionator(n)} in October\n\n{shirtstr}\n\n"
+        )
+
+        stats_embed.set_thumbnail(url=f"https://www.github.com/{github_username}.png")
+        stats_embed.set_author(
+            name="Hacktoberfest",
+            url="https://hacktoberfest.digitalocean.com",
+            icon_url="https://hacktoberfest.digitalocean.com/assets/logo-hacktoberfest.png"
+        )
+        stats_embed.add_field(
+            name="Top 5 Repositories:",
+            value=self._build_top5str(pr_stats)
+        )
+
+        logging.info(f"Hacktoberfest PR built for GitHub user '{github_username}'")
+        return stats_embed
+
+    @staticmethod
+    async def get_october_prs(github_username: str) -> typing.List[dict]:
+        """
+        Query GitHub's API for PRs created during the month of October by github_username
+        that do not have an 'invalid' tag
+
+        If PRs are found, return a list of dicts with basic PR information
+
+        For each PR:
+            {
+            "repo_url": str
+            "repo_shortname": str (e.g. "discord-python/hacktoberbot")
+            "created_at": datetime.datetime
+            }
+
+        Otherwise, return None
+        """
+        logging.info(f"Generating Hacktoberfest PR query for GitHub user: '{github_username}'")
+        base_url = "https://api.github.com/search/issues?q="
+        not_label = "invalid"
+        action_type = "pr"
+        is_query = f"public+author:{github_username}"
+        date_range = "2018-10-01..2018-10-31"
+        per_page = "300"
+        query_url = (
+            f"{base_url}"
+            f"-label:{not_label}"
+            f"+type:{action_type}"
+            f"+is:{is_query}"
+            f"+created:{date_range}"
+            f"&per_page={per_page}"
+        )
+
+        headers = {"user-agent": "Discord Python Hactoberbot"}
+        async with aiohttp.ClientSession() as session:
+            async with session.get(query_url, headers=headers) as resp:
+                jsonresp = await resp.json()
+
+        if "message" in jsonresp.keys():
+            # One of the parameters is invalid, short circuit for now
+            api_message = jsonresp["errors"][0]["message"]
+            logging.error(f"GitHub API request for '{github_username}' failed with message: {api_message}")
+            return
+        else:
+            if jsonresp["total_count"] == 0:
+                # Short circuit if there aren't any PRs
+                logging.info(f"No Hacktoberfest PRs found for GitHub user: '{github_username}'")
+                return
+            else:
+                logging.info(f"Found {len(jsonresp['items'])} Hacktoberfest PRs for GitHub user: '{github_username}'")
+                outlist = []
+                for item in jsonresp["items"]:
+                    shortname = Stats._get_shortname(item["repository_url"])
+                    itemdict = {
+                        "repo_url": f"https://www.github.com/{shortname}",
+                        "repo_shortname": shortname,
+                        "created_at": datetime.strptime(
+                            item["created_at"], r"%Y-%m-%dT%H:%M:%SZ"
+                        ),
+                    }
+                    outlist.append(itemdict)
+                return outlist
+
+    @staticmethod
+    def _get_shortname(in_url: str) -> str:
+        """
+        Extract shortname from https://api.github.com/repos/* URL
+
+        e.g. "https://api.github.com/repos/discord-python/hacktoberbot"
+             |
+             V
+             "discord-python/hacktoberbot"
+        """
+        exp = r"https?:\/\/api.github.com\/repos\/([/\-\_\.\w]+)"
+        return re.findall(exp, in_url)[0]
+
+    @staticmethod
+    def _summarize_prs(prs: typing.List[dict]) -> typing.Dict:
+        """
+        Generate statistics from an input list of PR dictionaries, as output by get_october_prs
+
+        Return a dictionary containing:
+            {
+            "n_prs": int
+            "top5": [(repo_shortname, ncontributions), ...]
+            }
+        """
+        contributed_repos = [pr["repo_shortname"] for pr in prs]
+        return {"n_prs": len(prs), "top5": Counter(contributed_repos).most_common(5)}
+
+    @staticmethod
+    def _build_top5str(stats: typing.List[tuple]) -> str:
+        """
+        Build a string from the Top 5 contributions that is compatible with a discord.Embed field
+
+        Top 5 contributions should be a list of tuples, as output in the stats dictionary by
+        _summarize_prs
+
+        String is of the form:
+           n contribution(s) to [shortname](url)
+           ...
+        """
+        baseURL = "https://www.github.com/"
+        contributionstrs = []
+        for repo in stats['top5']:
+            n = repo[1]
+            contributionstrs.append(f"{n} {Stats._contributionator(n)} to [{repo[0]}]({baseURL}{repo[0]})")
+
+        return "\n".join(contributionstrs)
+
+    @staticmethod
+    def _contributionator(n: int) -> str:
+        """
+        Return "contribution" or "contributions" based on the value of n
+        """
+        if n == 1:
+            return "contribution"
+        else:
+            return "contributions"
+
+    @staticmethod
+    def _author_mention_from_context(ctx: commands.Context) -> typing.Tuple:
+        """
+        Return stringified Message author ID and mentionable string from commands.Context
+        """
+        author_id = str(ctx.message.author.id)
+        author_mention = ctx.message.author.mention
+
+        return author_id, author_mention
+
+
+def setup(bot):
+    bot.add_cog(Stats(bot))
diff --git a/bot/cogs/hacktober/halloween_facts.py b/bot/cogs/hacktober/halloween_facts.py
new file mode 100644
index 00000000..e97c80d2
--- /dev/null
+++ b/bot/cogs/hacktober/halloween_facts.py
@@ -0,0 +1,75 @@
+import asyncio
+import json
+import random
+from datetime import timedelta
+from pathlib import Path
+
+import discord
+from discord.ext import commands
+
+SPOOKY_EMOJIS = [
+    "\N{BAT}",
+    "\N{DERELICT HOUSE BUILDING}",
+    "\N{EXTRATERRESTRIAL ALIEN}",
+    "\N{GHOST}",
+    "\N{JACK-O-LANTERN}",
+    "\N{SKULL}",
+    "\N{SKULL AND CROSSBONES}",
+    "\N{SPIDER WEB}",
+]
+PUMPKIN_ORANGE = discord.Color(0xFF7518)
+HACKTOBERBOT_CHANNEL_ID = 498804484324196362
+INTERVAL = timedelta(hours=6).total_seconds()
+
+
+class HalloweenFacts:
+
+    def __init__(self, bot):
+        self.bot = bot
+        with open(Path("./bot/resources", "halloween_facts.json"), "r") as file:
+            self.halloween_facts = json.load(file)
+        self.channel = None
+        self.last_fact = None
+
+    async def on_ready(self):
+        self.channel = self.bot.get_channel(HACKTOBERBOT_CHANNEL_ID)
+        self.bot.loop.create_task(self._fact_publisher_task())
+
+    async def _fact_publisher_task(self):
+        """
+        A background task that runs forever, sending Halloween facts at random to the Discord channel with id equal to
+        HACKTOBERFEST_CHANNEL_ID every INTERVAL seconds.
+        """
+        facts = list(enumerate(self.halloween_facts))
+        while True:
+            # Avoid choosing each fact at random to reduce chances of facts being reposted soon.
+            random.shuffle(facts)
+            for index, fact in facts:
+                embed = self._build_embed(index, fact)
+                await self.channel.send("Your regular serving of random Halloween facts", embed=embed)
+                self.last_fact = (index, fact)
+                await asyncio.sleep(INTERVAL)
+
+    @commands.command(name="hallofact", aliases=["hallofacts"], brief="Get the most recent Halloween fact")
+    async def get_last_fact(self, ctx):
+        """
+        Reply with the most recent Halloween fact.
+        """
+        if ctx.channel != self.channel:
+            return
+        index, fact = self.last_fact
+        embed = self._build_embed(index, fact)
+        await ctx.send("Halloween fact recap", embed=embed)
+
+    @staticmethod
+    def _build_embed(index, fact):
+        """
+        Builds a Discord embed from the given fact and its index.
+        """
+        emoji = random.choice(SPOOKY_EMOJIS)
+        title = f"{emoji} Halloween Fact #{index + 1}"
+        return discord.Embed(title=title, description=fact, color=PUMPKIN_ORANGE)
+
+
+def setup(bot):
+    bot.add_cog(HalloweenFacts(bot))
diff --git a/bot/cogs/hacktober/halloweenify.py b/bot/cogs/hacktober/halloweenify.py
new file mode 100644
index 00000000..a5fe45ef
--- /dev/null
+++ b/bot/cogs/hacktober/halloweenify.py
@@ -0,0 +1,48 @@
+from json import load
+from pathlib import Path
+from random import choice
+
+import discord
+from discord.ext import commands
+from discord.ext.commands.cooldowns import BucketType
+
+
+class Halloweenify:
+    """
+    A cog to change a invokers nickname to a spooky one!
+    """
+
+    def __init__(self, bot):
+        self.bot = bot
+
+    @commands.cooldown(1, 300, BucketType.user)
+    @commands.command()
+    async def halloweenify(self, ctx):
+        """
+        Change your nickname into a much spookier one!
+        """
+        with open(Path('./bot/resources', 'halloweenify.json'), 'r') as f:
+            data = load(f)
+
+        # Choose a random character from our list we loaded above and set apart the nickname and image url.
+        character = choice(data['characters'])
+        nickname = ''.join([nickname for nickname in character])
+        image = ''.join([character[nickname] for nickname in character])
+
+        # Build up a Embed
+        embed = discord.Embed()
+        embed.colour = discord.Colour.dark_orange()
+        embed.title = 'Not spooky enough?'
+        embed.description = (
+            f'**{ctx.author.display_name}** wasn\'t spooky enough for you? That\'s understandable, '
+            f'{ctx.author.display_name} isn\'t scary at all! Let me think of something better. Hmm... I got it!\n\n '
+            f'Your new nickname will be: \n :ghost: **{nickname}** :jack_o_lantern:'
+        )
+        embed.set_image(url=image)
+
+        await ctx.author.edit(nick=nickname)
+        await ctx.send(embed=embed)
+
+
+def setup(bot):
+    bot.add_cog(Halloweenify(bot))
diff --git a/bot/cogs/hacktober/movie.py b/bot/cogs/hacktober/movie.py
new file mode 100644
index 00000000..925f813f
--- /dev/null
+++ b/bot/cogs/hacktober/movie.py
@@ -0,0 +1,136 @@
+import random
+from os import environ
+
+import aiohttp
+from discord import Embed
+from discord.ext import commands
+
+
+TMDB_API_KEY = environ.get('TMDB_API_KEY')
+TMDB_TOKEN = environ.get('TMDB_TOKEN')
+
+
+class Movie:
+    """
+    Selects a random scary movie and embeds info into discord chat
+    """
+
+    def __init__(self, bot):
+        self.bot = bot
+
+    @commands.command(name='movie', alias=['tmdb'])
+    async def random_movie(self, ctx):
+        """
+        Randomly select a scary movie and display information about it.
+        """
+        selection = await self.select_movie()
+        movie_details = await self.format_metadata(selection)
+
+        await ctx.send(embed=movie_details)
+
+    @staticmethod
+    async def select_movie():
+        """
+        Selects a random movie and returns a json of movie details from TMDb
+        """
+
+        url = 'https://api.themoviedb.org/4/discover/movie'
+        params = {
+            'with_genres': '27',
+            'vote_count.gte': '5'
+        }
+        headers = {
+            'Authorization': 'Bearer ' + TMDB_TOKEN,
+            'Content-Type': 'application/json;charset=utf-8'
+        }
+
+        # Get total page count of horror movies
+        async with aiohttp.ClientSession() as session:
+            response = await session.get(url=url, params=params, headers=headers)
+            total_pages = await response.json()
+            total_pages = total_pages.get('total_pages')
+
+            # Get movie details from one random result on a random page
+            params['page'] = random.randint(1, total_pages)
+            response = await session.get(url=url, params=params, headers=headers)
+            response = await response.json()
+            selection_id = random.choice(response.get('results')).get('id')
+
+            # Get full details and credits
+            selection = await session.get(
+                url='https://api.themoviedb.org/3/movie/' + str(selection_id),
+                params={'api_key': TMDB_API_KEY, 'append_to_response': 'credits'}
+            )
+
+            return await selection.json()
+
+    @staticmethod
+    async def format_metadata(movie):
+        """
+        Formats raw TMDb data to be embedded in discord chat
+        """
+
+        # Build the relevant URLs.
+        movie_id = movie.get("id")
+        poster_path = movie.get("poster_path")
+        tmdb_url = f'https://www.themoviedb.org/movie/{movie_id}' if movie_id else None
+        poster = f'https://image.tmdb.org/t/p/original{poster_path}' if poster_path else None
+
+        # Get cast names
+        cast = []
+        for actor in movie.get('credits', {}).get('cast', [])[:3]:
+            cast.append(actor.get('name'))
+
+        # Get director name
+        director = movie.get('credits', {}).get('crew', [])
+        if director:
+            director = director[0].get('name')
+
+        # Determine the spookiness rating
+        rating = ''
+        rating_count = movie.get('vote_average', 0)
+
+        if rating_count:
+            rating_count /= 2
+
+        for _ in range(int(rating_count)):
+            rating += ':skull:'
+        if (rating_count % 1) >= .5:
+            rating += ':bat:'
+
+        # Try to get year of release and runtime
+        year = movie.get('release_date', [])[:4]
+        runtime = movie.get('runtime')
+        runtime = f"{runtime} minutes" if runtime else None
+
+        # Not all these attributes will always be present
+        movie_attributes = {
+            "Directed by": director,
+            "Starring": ', '.join(cast),
+            "Running time": runtime,
+            "Release year": year,
+            "Spookiness rating": rating,
+        }
+
+        embed = Embed(
+            colour=0x01d277,
+            title='**' + movie.get('title') + '**',
+            url=tmdb_url,
+            description=movie.get('overview')
+        )
+
+        if poster:
+            embed.set_image(url=poster)
+
+        # Add the attributes that we actually have data for, but not the others.
+        for name, value in movie_attributes.items():
+            if value:
+                embed.add_field(name=name, value=value)
+
+        embed.set_footer(text='powered by themoviedb.org')
+
+        return embed
+
+
+def setup(bot):
+    bot.add_cog(Movie(bot))
diff --git a/bot/cogs/hacktober/spookyreact.py b/bot/cogs/hacktober/spookyreact.py
new file mode 100644
index 00000000..9146b797
--- /dev/null
+++ b/bot/cogs/hacktober/spookyreact.py
@@ -0,0 +1,69 @@
+import logging
+import re
+
+import discord
+
+SPOOKY_TRIGGERS = {
+    'spooky': (r"\bspo{2,}ky\b", "\U0001F47B"),
+    'skeleton': (r"\bskeleton\b", "\U0001F480"),
+    'doot': (r"\bdo{2,}t\b", "\U0001F480"),
+    'pumpkin': (r"\bpumpkin\b", "\U0001F383"),
+    'halloween': (r"\bhalloween\b", "\U0001F383"),
+    'jack-o-lantern': (r"\bjack-o-lantern\b", "\U0001F383"),
+    'danger': (r"\bdanger\b", "\U00002620")
+}
+
+
+class SpookyReact:
+
+    """
+    A cog that makes the bot react to message triggers.
+    """
+
+    def __init__(self, bot):
+        self.bot = bot
+
+    async def on_message(self, ctx: discord.Message):
+        """
+        A command to send the hacktoberbot github project
+
+        Lines that begin with the bot's command prefix are ignored
+
+        Hacktoberbot's own messages are ignored
+        """
+        for trigger in SPOOKY_TRIGGERS.keys():
+            trigger_test = re.search(SPOOKY_TRIGGERS[trigger][0], ctx.content.lower())
+            if trigger_test:
+                # Check message for bot replies and/or command invocations
+                # Short circuit if they're found, logging is handled in _short_circuit_check
+                if await self._short_circuit_check(ctx):
+                    return
+                else:
+                    await ctx.add_reaction(SPOOKY_TRIGGERS[trigger][1])
+                    logging.info(f"Added '{trigger}' reaction to message ID: {ctx.id}")
+
+    async def _short_circuit_check(self, ctx: discord.Message) -> bool:
+        """
+        Short-circuit helper check.
+
+        Return True if:
+          * author is the bot
+          * prefix is not None
+        """
+        # Check for self reaction
+        if ctx.author == self.bot.user:
+            logging.info(f"Ignoring reactions on self message. Message ID: {ctx.id}")
+            return True
+
+        # Check for command invocation
+        # Because on_message doesn't give a full Context object, generate one first
+        tmp_ctx = await self.bot.get_context(ctx)
+        if tmp_ctx.prefix:
+            logging.info(f"Ignoring reactions on command invocation. Message ID: {ctx.id}")
+            return True
+
+        return False
+
+
+def setup(bot):
+    bot.add_cog(SpookyReact(bot))