Add caching to Pincer impl (As it doesnt have it)

antispam/exceptions.py

@@ -87,3 +87,11 @@ class GuildAddonNotFound(GuildNotFound):
 
 class PluginError(BaseASHException):
     """An error occurred that was related to a plugin and not AntiSpamHandler"""
+
+
+class ExistingEntry(BaseASHException):
+    """An entry was already found in the timed cache with this key."""
+
+
+class NonExistentEntry(BaseASHException):
+    """No entry found in the timed cache with this key."""

antispam/libs/pincer.py

@@ -21,6 +21,8 @@
 DEALINGS IN THE SOFTWARE.
 """
 import asyncio
+import datetime
+import functools
 import logging
 from typing import Optional, List, Dict, Union
 from unittest.mock import AsyncMock
@@ -33,23 +35,88 @@
     LogicError,
     PropagateFailure,
     MissingGuildPermissions,
+    NonExistentEntry,
 )
 from antispam.abc import Lib
 from antispam.dataclasses import Member, Guild, Message
 from antispam.dataclasses.propagate_data import PropagateData
 
 from pincer import objects
 
-from antispam.libs.shared import SubstituteArgs, Base
+from antispam.libs.shared import SubstituteArgs, Base, TimedCache
 
 log = logging.getLogger(__name__)
 
 
+def clean_cache(func):
+    """Non-lazy eviction of the cache to keep it small(ish)"""
+
+    @functools.wraps(func)
+    async def wrapped(*args, **kwargs):
+        self: "Pincer" = args[0]
+        self._timed_cache.force_clean()
+
+        if asyncio.iscoroutinefunction(func):
+            return await func(*args, **kwargs)
+
+        return func(*args, **kwargs)
+
+    return wrapped
+
+
 class Pincer(Base, Lib):
     def __init__(self, handler):
         self.handler = handler
         self.bot: pincer.Client = self.handler.bot
 
+        self._timed_cache: TimedCache = TimedCache()
+
+    # Cached methods
+    async def _fetch_member(self, member_id: int, guild_id: int) -> objects.GuildMember:
+        key = f"GuildMember:{member_id}:{guild_id}"
+        try:
+            return self._timed_cache.get_entry(key)
+        except NonExistentEntry:
+            member: objects.GuildMember = await objects.GuildMember.from_id(
+                self.bot, guild_id, member_id
+            )
+            member.permissions = await self._get_perms(member.roles, guild_id)
+            self._timed_cache.add_entry(key, member, ttl=datetime.timedelta(hours=1))
+            return member
+
+    async def _fetch_text_channel(self, channel_id: int) -> objects.Channel:
+        key = f"TextChannel:{channel_id}"
+        try:
+            return self._timed_cache.get_entry(key)
+        except NonExistentEntry:
+            channel: objects.Channel = await objects.TextChannel.from_id(
+                self.bot, channel_id
+            )
+            self._timed_cache.add_entry(key, channel, ttl=datetime.timedelta(hours=1))
+            return channel
+
+    async def _fetch_guild(self, guild_id: int) -> objects.Guild:
+        key = f"Guild:{guild_id}"
+        try:
+            return self._timed_cache.get_entry(key)
+        except NonExistentEntry:
+            guild: objects.Guild = await objects.Guild.from_id(self.bot, guild_id)
+            self._timed_cache.add_entry(key, guild, ttl=datetime.timedelta(hours=1))
+            return guild
+
+    async def _fetch_user_message(
+        self, message_id: int, channel_id: int
+    ) -> UserMessage:
+        key = f"UserMessage:{message_id}:{channel_id}"
+        try:
+            return self._timed_cache.get_entry(key)
+        except NonExistentEntry:
+            message: UserMessage = await UserMessage.from_id(
+                self.bot, message_id, channel_id
+            )
+            self._timed_cache.add_entry(key, message, ttl=datetime.timedelta(days=1))
+            return message
+
     def get_file(self, path: str):
         return objects.File.from_file(path)
 
@@ -75,11 +142,11 @@ async def get_channel_from_message(self, message: UserMessage):
         return await self.get_channel_by_id(message.channel_id)
 
     async def get_channel_by_id(self, channel_id: int):
-        return await objects.TextChannel.from_id(self.bot, channel_id)
+        return await self._fetch_text_channel(channel_id)
 
     async def get_substitute_args(self, message) -> SubstituteArgs:
         client: pincer.Client = self.bot
-        guild: objects.Guild = await objects.Guild.from_id(client, message.guild_id)
+        guild: objects.Guild = await self._fetch_guild(message.guild_id)
 
         return SubstituteArgs(
             bot_id=client.bot.id,
@@ -104,8 +171,8 @@ async def delete_member_messages(self, member: Member) -> None:
             if not message.is_duplicate:
                 continue
 
-            actual_message: UserMessage = await UserMessage.from_id(
-                client, message.id, message.channel_id
+            actual_message: UserMessage = await self._fetch_user_message(
+                message.id, message.channel_id
             )
             await actual_message.delete()
 
@@ -211,9 +278,7 @@ async def send_guild_log(
                 return
 
             channel_id = guild.log_channel_id
-            channel: objects.Channel = await objects.TextChannel.from_id(
-                self.bot, channel_id
-            )
+            channel: objects.Channel = await self._fetch_text_channel(channel_id)
 
             # TODO File's require testing
             # Pincer handles Embed/str behind the scenes
@@ -230,9 +295,8 @@ async def send_guild_log(
                 guild.id,
             )
 
-    async def check_message_can_be_propagated(
-        self, message: UserMessage
-    ) -> PropagateData:
+    @clean_cache
+    async def check_message_can_be_propagated(self, message) -> PropagateData:
         if not isinstance(message, (UserMessage, AsyncMock)):
             raise PropagateFailure(
                 data={"status": "Expected message of type UserMessage"}
@@ -248,15 +312,14 @@ async def check_message_can_be_propagated(
             raise PropagateFailure(data={"status": "Ignoring messages from dm's"})
 
             # The bot is immune to spam
-        if message.author.id == self.handler.bot.client.bot.id:
+        if message.author.id == self.bot.bot.id:
             log.debug("Message(id=%s) was from myself", message.id)
             raise PropagateFailure(
                 data={"status": "Ignoring messages from myself (the bot)"}
             )
 
-        guild: objects.Guild = await objects.Guild.from_id(self.bot, message.guild_id)
-        member: objects.GuildMember = await objects.GuildMember.from_id(
-            self.bot, message.guild_id, message.author.id
+        member: objects.GuildMember = await self._fetch_member(
+            message.author.id, message.guild_id
         )
 
         # Return if ignored bot
@@ -284,9 +347,7 @@ async def check_message_can_be_propagated(
             )
 
         # Return if ignored channel
-        channel: objects.Channel = await objects.TextChannel.from_id(
-            self.bot, message.channel_id
-        )
+        channel: objects.Channel = await self._fetch_text_channel(message.channel_id)
         if (
             message.channel_id in self.handler.options.ignored_channels
             or channel.name in self.handler.options.ignored_channels
@@ -314,7 +375,7 @@ async def check_message_can_be_propagated(
                 message.author.id,
             )
 
-        perms: int = int(member.permissions)
+        perms: int = member.permissions
         kick_members = bool(perms << 1)
         ban_members = bool(perms << 2)
         has_perms = kick_members and ban_members
@@ -326,6 +387,7 @@ async def check_message_can_be_propagated(
             has_perms_to_make_guild=has_perms,
         )
 
+    @clean_cache
     async def punish_member(
         self,
         original_message,
@@ -337,13 +399,13 @@ async def punish_member(
         user_delete_after: int = None,
         channel_delete_after: int = None,
     ):
-        guild = await objects.Guild.from_id(self.bot, member.guild_id)
+        guild: objects.Guild = await self._fetch_guild(member.guild_id)
         author: objects.User = original_message.author
-        channel: objects.Channel = await objects.TextChannel.from_id(
-            self.bot, original_message.channel_id
+        channel: objects.Channel = await self._fetch_text_channel(
+            original_message.channel_id
         )
-        _member: objects.GuildMember = await objects.GuildMember.from_id(
-            self.bot, member.guild_id, member.id
+        _member: objects.GuildMember = await self._fetch_member(
+            original_message.author.id, original_message.guild_id
         )
 
         # Check we have perms to punish
@@ -372,10 +434,8 @@ async def punish_member(
                 f"I cannot punish Member(id={_member.id}, username={_member.username}) "
                 f"because they own this guild. Guild(name={guild.name})"
             )
-
-        sent_message: Optional[objects.UserMessage] = None
         # TODO Add error handling when #421 is merged
-        sent_message = await author.send(user_message)
+        sent_message: objects.UserMessage = await author.send(user_message)
 
         if user_delete_after:
             await asyncio.sleep(user_delete_after)
@@ -441,3 +501,19 @@ async def punish_member(
 
         member._in_guild = True
         await self.handler.cache.set_member(member)
+
+    async def _get_perms(self, member_roles: List[int], guild_id: int) -> int:
+        guild_roles: list = await self.bot.http.get(f"/guilds/{guild_id}/roles")
+        # Gotta guess perms from role perms
+        actual_roles = []
+        for role in guild_roles:
+            if int(role["id"]) in member_roles:
+                actual_roles.append(role)
+
+        initial = 0x0
+        for role in actual_roles:
+            initial |= int(role["permissions"], 16)
+        if initial << 3:
+            # Admin implies all perms
+            initial = 0b111111111111111111111111111111111111111
+        return initial

antispam/libs/shared/__init__.py

@@ -1,7 +1,8 @@
 import logging
 from antispam.libs.shared.substitute_args import SubstituteArgs
 from antispam.libs.shared.base import Base
+from antispam.libs.shared.timed_cache import TimedCache
 
-__all__ = ("SubstituteArgs", "Base")
+__all__ = ("SubstituteArgs", "Base", "TimedCache")
 
 logging.getLogger(__name__).addHandler(logging.NullHandler())

antispam/libs/shared/timed_cache.py

@@ -0,0 +1,80 @@
+"""
+The MIT License (MIT)
+
+Copyright (c) 2020-Current Skelmis
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+"""
+# Taken from https://github.com/Skelmis/DPY-Bot-Base/tree/master/bot_base/caches
+from datetime import timedelta, datetime
+from typing import Any, Dict, Optional
+
+import attr
+
+from antispam.exceptions import NonExistentEntry, ExistingEntry
+
+
+@attr.s(slots=True)
+class Entry:
+    value: Any = attr.ib()
+    expiry_time: Optional[datetime] = attr.ib(default=None)
+
+
+class TimedCache:
+    __slots__ = ("cache",)
+
+    def __init__(self):
+        self.cache: Dict[Any, Entry] = {}
+
+    def __contains__(self, item: Any) -> bool:
+        try:
+            entry = self.cache[item]
+            if entry.expiry_time < datetime.now():
+                self.delete_entry(item)
+                return False
+        except KeyError:
+            return False
+        else:
+            return True
+
+    def add_entry(
+        self, key: Any, value: Any, *, ttl: timedelta = None, override: bool = False
+    ) -> None:
+        ttl = ttl or timedelta()
+        if key in self and not override:
+            raise ExistingEntry
+
+        self.cache[key] = Entry(value=value, expiry_time=(datetime.now() + ttl))
+
+    def delete_entry(self, key: Any) -> None:
+        try:
+            self.cache.pop(key)
+        except KeyError:
+            pass
+
+    def get_entry(self, key: Any) -> Any:
+        if key not in self:
+            raise NonExistentEntry
+
+        return self.cache[key].value
+
+    def force_clean(self) -> None:
+        now = datetime.now()
+        for k, v in self.cache.items():
+            if v.expiry_time < now:
+                self.delete_entry(k)

examples/basic_pincer_example.py

@@ -8,11 +8,6 @@
 from examples.jsonLoader import read_json
 
 file = read_json("token")
-# logging.basicConfig(
-#     format="%(levelname)s | %(asctime)s | %(module)s | %(message)s",
-#     datefmt="%d/%m/%Y %I:%M:%S %p",
-#     level=logging.DEBUG,
-# )
 
 
 class Bot(Client):
@@ -25,7 +20,6 @@ async def on_ready(self):
 
     @Client.event
     async def on_message(self, message: UserMessage):
-        print("on_messages")
         await self.antispam.propagate(message)  # noqa