Initial commit with code

classes/__init__.py

@@ -0,0 +1,2 @@
+from .pycord_guild import PycordGuild
+from .pycord_user import PycordUser

classes/errors/__init__.py

@@ -0,0 +1,2 @@
+from .pycord_guild import GuildNotFoundError
+from .pycord_user import UserNotFoundError

classes/errors/pycord_guild.py

@@ -0,0 +1,7 @@
+class GuildNotFoundError(Exception):
+    """PycordGuild could not find guild with such an ID in the database"""
+
+    def __init__(self, guild_id: int) -> None:
+        self.guild_id = guild_id
+
+        super().__init__(f"Guild with id {self.guild_id} was not found")

classes/errors/pycord_user.py

@@ -0,0 +1,7 @@
+class UserNotFoundError(Exception):
+    """PycordUser could not find user with such an ID in the database"""
+
+    def __init__(self, user_id: int) -> None:
+        self.user_id = user_id
+
+        super().__init__(f"User with id {self.user_id} was not found")

classes/pycord_bot.py

@@ -0,0 +1,71 @@
+import logging
+from logging import Logger
+from typing import Any
+
+from aiohttp import ClientSession
+from discord import User
+from libbot.cache.manager import create_cache_client
+from libbot.pycord.classes import PycordBot as LibPycordBot
+
+from classes import PycordUser
+
+logger: Logger = logging.getLogger(__name__)
+
+
+# from modules.tracking.dhl import update_tracks_dhl
+
+
+class PycordBot(LibPycordBot):
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+
+        self._set_cache_engine()
+
+        self.client_session = ClientSession()
+
+        if self.scheduler is None:
+            return
+
+        # This replacement exists because of the different
+        # i18n formats than provided by libbot
+        self._ = self._modified_string_getter
+
+    def _modified_string_getter(self, key: str, *args: str, locale: str | None = None) -> Any:
+        """This method exists because of the different i18n formats than provided by libbot.
+        It splits "-" and takes the first part of the provided locale to make complex language codes
+        compatible with an easy libbot approach to i18n.
+        """
+        return self.bot_locale._(key, *args, locale=None if locale is None else locale.split("-")[0])
+
+    def _set_cache_engine(self) -> None:
+        if "cache" in self.config and self.config["cache"]["type"] is not None:
+            self.cache = create_cache_client(self.config, self.config["cache"]["type"])
+
+    async def find_user(self, user: int | User) -> PycordUser:
+        """Find User by its ID or User object.
+
+        Args:
+            user (int | User): ID or User object to extract ID from
+
+        Returns:
+            PycordUser: User object
+
+        Raises:
+             UserNotFoundException: User was not found and creation was not allowed
+        """
+        return (
+            await PycordUser.from_id(user, cache=self.cache)
+            if isinstance(user, int)
+            else await PycordUser.from_id(user.id, cache=self.cache)
+        )
+
+    async def start(self, *args: Any, **kwargs: Any) -> None:
+        await super().start(*args, **kwargs)
+
+    async def close(self, **kwargs) -> None:
+        await self.client_session.close()
+
+        if self.scheduler is not None:
+            self.scheduler.shutdown()
+
+        await super().close(**kwargs)

classes/pycord_guild.py

@@ -0,0 +1,47 @@
+from dataclasses import dataclass
+from typing import Any, Dict, Optional
+
+from bson import ObjectId
+from libbot.cache.classes import Cache
+
+
+@dataclass
+class PycordGuild:
+    _id: ObjectId
+    id: int
+
+    def __init__(self) -> None:
+        raise NotImplementedError()
+
+    @classmethod
+    async def from_id(
+        cls, guild_id: int, allow_creation: bool = True, cache: Optional[Cache] = None
+    ) -> "PycordGuild":
+        """Find guild in database and create new record if guild does not exist.
+
+        Args:
+            guild_id (int): User's Discord ID
+            allow_creation (:obj:`bool`, optional): Create new guild record if none found in the database
+            cache (:obj:`Cache`, optional): Cache engine to get the cache from
+
+        Returns:
+            PycordGuild: User object
+
+        Raises:
+             GuildNotFoundError: User was not found and creation was not allowed
+        """
+        raise NotImplementedError()
+
+    def to_dict(self, json_compatible: bool = False) -> Dict[str, Any]:
+        """Convert PycordGuild object to a JSON representation.
+
+        Args:
+            json_compatible (bool): Whether the JSON-incompatible objects like ObjectId need to be converted
+
+        Returns:
+            Dict[str, Any]: JSON representation of PycordGuild
+        """
+        return {
+            "_id": self._id if not json_compatible else str(self._id),
+            "id": self.id,
+        }

classes/pycord_user.py

@@ -0,0 +1,158 @@
+import logging
+from dataclasses import dataclass
+from logging import Logger
+from typing import Any, Dict, Optional
+
+from bson import ObjectId
+from libbot.cache.classes import Cache
+from pymongo.results import InsertOneResult
+
+from classes.errors.pycord_user import UserNotFoundError
+from modules.database import col_users
+
+logger: Logger = logging.getLogger(__name__)
+
+
+@dataclass
+class PycordUser:
+    """Dataclass of DB entry of a user"""
+
+    __slots__ = ("_id", "id")
+
+    _id: ObjectId
+    id: int
+
+    @classmethod
+    async def from_id(
+        cls, user_id: int, allow_creation: bool = True, cache: Optional[Cache] = None
+    ) -> "PycordUser":
+        """Find user in database and create new record if user does not exist.
+
+        Args:
+            user_id (int): User's Discord ID
+            allow_creation (:obj:`bool`, optional): Create new user record if none found in the database
+            cache (:obj:`Cache`, optional): Cache engine to get the cache from
+
+        Returns:
+            PycordUser: User object
+
+        Raises:
+             UserNotFoundError: User was not found and creation was not allowed
+        """
+        if cache is not None:
+            cached_entry: Dict[str, Any] | None = cache.get_json(f"user_{user_id}")
+
+            if cached_entry is not None:
+                return cls(**cached_entry)
+
+        db_entry = await col_users.find_one({"id": user_id})
+
+        if db_entry is None:
+            if not allow_creation:
+                raise UserNotFoundError(user_id)
+
+            db_entry = PycordUser.get_defaults(user_id)
+
+            insert_result: InsertOneResult = await col_users.insert_one(db_entry)
+
+            db_entry["_id"] = insert_result.inserted_id
+
+        if cache is not None:
+            cache.set_json(f"user_{user_id}", db_entry)
+
+        return cls(**db_entry)
+
+    def to_dict(self, json_compatible: bool = False) -> Dict[str, Any]:
+        """Convert PycordUser object to a JSON representation.
+
+        Args:
+            json_compatible (bool): Whether the JSON-incompatible objects like ObjectId need to be converted
+
+        Returns:
+            Dict[str, Any]: JSON representation of PycordUser
+        """
+        return {
+            "_id": self._id if not json_compatible else str(self._id),
+            "id": self.id,
+        }
+
+    async def _set(self, key: str, value: Any, cache: Optional[Cache] = None) -> None:
+        """Set attribute data and save it into the database.
+
+        Args:
+            key (str): Attribute to change
+            value (Any): Value to set
+            cache (:obj:`Cache`, optional): Cache engine to write the update into
+        """
+        if not hasattr(self, key):
+            raise AttributeError()
+
+        setattr(self, key, value)
+
+        await col_users.update_one({"_id": self._id}, {"$set": {key: value}}, upsert=True)
+
+        self._update_cache(cache)
+
+        logger.info("Set attribute '%s' of user %s to '%s'", key, self.id, value)
+
+    async def _remove(self, key: str, cache: Optional[Cache] = None) -> None:
+        """Remove attribute data and save it into the database.
+
+        Args:
+            key (str): Attribute to remove
+            cache (:obj:`Cache`, optional): Cache engine to write the update into
+        """
+        if not hasattr(self, key):
+            raise AttributeError()
+
+        default_value: Any = PycordUser.get_default_value(key)
+
+        setattr(self, key, default_value)
+
+        await col_users.update_one({"_id": self._id}, {"$set": {key: default_value}}, upsert=True)
+
+        self._update_cache(cache)
+
+        logger.info("Removed attribute '%s' of user %s", key, self.id)
+
+    def _get_cache_key(self) -> str:
+        return f"user_{self.id}"
+
+    def _update_cache(self, cache: Optional[Cache] = None) -> None:
+        if cache is None:
+            return
+
+        user_dict: Dict[str, Any] = self.to_dict()
+
+        if user_dict is not None:
+            cache.set_json(self._get_cache_key(), user_dict)
+        else:
+            self._delete_cache(cache)
+
+    def _delete_cache(self, cache: Optional[Cache] = None) -> None:
+        if cache is None:
+            return
+
+        cache.delete(self._get_cache_key())
+
+    @staticmethod
+    def get_defaults(user_id: Optional[int] = None) -> Dict[str, Any]:
+        return {
+            "id": user_id,
+        }
+
+    @staticmethod
+    def get_default_value(key: str) -> Any:
+        if key not in PycordUser.get_defaults():
+            raise KeyError(f"There's no default value for key '{key}' in PycordUser")
+
+        return PycordUser.get_defaults()[key]
+
+    async def purge(self, cache: Optional[Cache] = None) -> None:
+        """Completely remove user data from database. Currently only removes the user record from users collection.
+
+        Args:
+            cache (:obj:`Cache`, optional): Cache engine to write the update into
+        """
+        await col_users.delete_one({"_id": self._id})
+        self._delete_cache(cache)