Implemented memcached caching

classes/cache/__init__.py

@@ -0,0 +1,3 @@
+from .holo_cache import HoloCache
+from .holo_cache_memcached import HoloCacheMemcached
+from .holo_cache_redis import HoloCacheRedis

classes/cache/holo_cache.py

@@ -0,0 +1,44 @@
+from abc import ABC, abstractmethod
+from typing import Any, Dict
+
+import pymemcache
+import redis
+
+
+class HoloCache(ABC):
+    client: pymemcache.Client | redis.Redis
+
+    @classmethod
+    @abstractmethod
+    def from_config(cls, engine_config: Dict[str, Any]) -> Any:
+        pass
+
+    @abstractmethod
+    def get_json(self, key: str) -> Any | None:
+        # TODO This method must also carry out ObjectId conversion!
+        pass
+
+    @abstractmethod
+    def get_string(self, key: str) -> str | None:
+        pass
+
+    @abstractmethod
+    def get_object(self, key: str) -> Any | None:
+        pass
+
+    @abstractmethod
+    def set_json(self, key: str, value: Any) -> None:
+        # TODO This method must also carry out ObjectId conversion!
+        pass
+
+    @abstractmethod
+    def set_string(self, key: str, value: str) -> None:
+        pass
+
+    @abstractmethod
+    def set_object(self, key: str, value: Any) -> None:
+        pass
+
+    @abstractmethod
+    def delete(self, key: str) -> None:
+        pass

classes/cache/holo_cache_memcached.py

@@ -0,0 +1,106 @@
+import logging
+from logging import Logger
+from typing import Dict, Any
+
+from bson import ObjectId
+from pymemcache import Client
+from ujson import dumps, loads
+
+from . import HoloCache
+
+logger: Logger = logging.getLogger(__name__)
+
+
+class HoloCacheMemcached(HoloCache):
+    client: Client
+
+    def __init__(self, client: Client):
+        self.client = client
+
+    @classmethod
+    def from_config(cls, engine_config: Dict[str, Any]) -> "HoloCacheMemcached":
+        if "uri" not in engine_config:
+            raise KeyError(
+                "Cache configuration is invalid. Please check if all keys are set (engine: memcached)"
+            )
+
+        return cls(Client(engine_config["uri"], default_noreply=True))
+
+    def get_json(self, key: str) -> Any | None:
+        try:
+            result: Any | None = self.client.get(key, None)
+
+            logger.debug(
+                "Got json cache key '%s'%s",
+                key,
+                "" if result is not None else " (not found)",
+            )
+        except Exception as exc:
+            logger.error("Could not get json cache key '%s' due to: %s", key, exc)
+            return None
+
+        return None if result is None else self._string_to_json(result)
+
+    def get_string(self, key: str) -> str | None:
+        try:
+            result: str | None = self.client.get(key, None)
+
+            logger.debug(
+                "Got string cache key '%s'%s",
+                key,
+                "" if result is not None else " (not found)",
+            )
+
+            return result
+        except Exception as exc:
+            logger.error("Could not get string cache key '%s' due to: %s", key, exc)
+            return None
+
+    def get_object(self, key: str) -> Any | None:
+        # TODO Implement binary deserialization
+        raise NotImplementedError()
+
+    def set_json(self, key: str, value: Any) -> None:
+        try:
+            self.client.set(key, self._json_to_string(value))
+            logger.debug("Set json cache key '%s'", key)
+        except Exception as exc:
+            logger.error("Could not set json cache key '%s' due to: %s", key, exc)
+            return None
+
+    def set_string(self, key: str, value: str) -> None:
+        try:
+            self.client.set(key, value)
+            logger.debug("Set string cache key '%s'", key)
+        except Exception as exc:
+            logger.error("Could not set string cache key '%s' due to: %s", key, exc)
+            return None
+
+    def set_object(self, key: str, value: Any) -> None:
+        # TODO Implement binary serialization
+        raise NotImplementedError()
+
+    def delete(self, key: str) -> None:
+        try:
+            self.client.delete(key)
+            logger.debug("Deleted cache key '%s'", key)
+        except Exception as exc:
+            logger.error("Could not delete cache key '%s' due to: %s", key, exc)
+
+    @staticmethod
+    def _json_to_string(json_object: Any) -> str:
+        if isinstance(json_object, dict) and "_id" in json_object:
+            json_object["_id"] = str(json_object["_id"])
+
+        return dumps(
+            json_object, ensure_ascii=False, indent=0, escape_forward_slashes=False
+        )
+
+    @staticmethod
+    def _string_to_json(json_string: str) -> Any:
+        json_object: Any = loads(json_string)
+
+        if isinstance(json_object, dict) and "_id" in json_object:
+            json_object["_id"] = ObjectId(json_object["_id"])
+
+        return json_object

classes/cache/holo_cache_redis.py

@@ -0,0 +1,34 @@
+from typing import Dict, Any
+
+from redis import Redis
+
+from classes.cache import HoloCache
+
+
+class HoloCacheRedis(HoloCache):
+    client: Redis
+
+    @classmethod
+    def from_config(cls, engine_config: Dict[str, Any]) -> Any:
+        raise NotImplementedError()
+
+    def get_json(self, key: str) -> Any | None:
+        raise NotImplementedError()
+
+    def get_string(self, key: str) -> str | None:
+        raise NotImplementedError()
+
+    def get_object(self, key: str) -> Any | None:
+        raise NotImplementedError()
+
+    def set_json(self, key: str, value: Any) -> None:
+        raise NotImplementedError()
+
+    def set_string(self, key: str, value: str) -> None:
+        raise NotImplementedError()
+
+    def set_object(self, key: str, value: Any) -> None:
+        raise NotImplementedError()
+
+    def delete(self, key: str) -> None:
+        raise NotImplementedError()

classes/holo_bot.py

@@ -1,6 +1,21 @@
+import logging
+from logging import Logger
+
 from libbot.pycord.classes import PycordBot
 
+from classes.cache.holo_cache_memcached import HoloCacheMemcached
+from classes.cache.holo_cache_redis import HoloCacheRedis
+from modules.cache_utils import create_cache_client
+
+logger: Logger = logging.getLogger(__name__)
+
 
 class HoloBot(PycordBot):
+    cache: HoloCacheMemcached | HoloCacheRedis | None = None
+
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
+
+    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"])

classes/holo_user.py

@@ -6,7 +6,9 @@ from bson import ObjectId
 from discord import User, Member
 from libbot.utils import config_get
 from pymongo.results import InsertOneResult
+from typing_extensions import deprecated
 
+from classes.cache import HoloCache
 from errors import UserNotFoundError
 from modules.database import col_warnings, col_users
 
@@ -29,33 +31,41 @@ class HoloUser:
 
     @classmethod
     async def from_user(
-        cls, user: User | Member, allow_creation: bool = True
+        cls,
+        user: User | Member,
+        allow_creation: bool = True,
+        cache: HoloCache | None = None,
     ) -> "HoloUser":
         """Get an object that has a proper binding between Discord ID and database
 
         ### Args:
             * `user` (User | Member): Object from which an ID can be extracted
+            * `allow_creation` (bool, optional): Whether to allow creation of a new user record if none found. Defaults to True.
+            * `cache` (HoloCache | None, optional): Cache engine to get the cache from
 
         ### Raises:
             * `UserNotFoundError`: User with such ID does not seem to exist in database
         """
-        db_entry: Dict[str, Any] | None = await col_users.find_one({"user": user.id})
+        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: Dict[str, Any] | None = await col_users.find_one({"id": user.id})
 
         if db_entry is None:
             if not allow_creation:
                 raise UserNotFoundError(user=user, user_id=user.id)
 
-            db_entry = {
-                "user": user.id,
-                "custom_role": None,
-                "custom_channel": None,
-            }
+            db_entry = HoloUser.get_defaults(user.id)
 
             insert_result: InsertOneResult = await col_users.insert_one(db_entry)
 
-            db_entry["_id"] = insert_result.inserted_id()
+            db_entry["_id"] = insert_result.inserted_id
 
-        db_entry["id"] = db_entry.pop("user")
+        if cache is not None:
+            cache.set_json(f"user_{user.id}", db_entry)
 
         return cls(**db_entry)
 
@@ -63,23 +73,28 @@ class HoloUser:
     async def from_id(cls, user_id: int) -> "HoloUser":
         return NotImplemented
 
+    # TODO Deprecate and remove warnings
+    @deprecated("Warnings are deprecated")
     async def get_warnings(self) -> int:
         """Get number of warnings user has
 
         ### Returns:
             * `int`: Number of warnings
         """
-        warns: Dict[str, Any] | None = await col_warnings.find_one({"user": self.id})
+        warns: Dict[str, Any] | None = await col_warnings.find_one({"id": self.id})
 
         return 0 if warns is None else warns["warns"]
 
-    async def warn(self, count: int = 1, reason: str = "Not provided") -> None:
+    # TODO Deprecate and remove warnings
+    @deprecated("Warnings are deprecated")
+    async def warn(self, count: int = 1, reason: str = "Reason not provided") -> None:
         """Warn and add count to warns number
 
         ### Args:
             * `count` (int, optional): Count of warnings to be added. Defaults to 1.
+            * `reason` (int, optional): Count of warnings to be added. Defaults to 1.
         """
-        warns: Dict[str, Any] | None = await col_warnings.find_one({"user": self.id})
+        warns: Dict[str, Any] | None = await col_warnings.find_one({"id": self.id})
 
         if warns is not None:
             await col_warnings.update_one(
@@ -87,16 +102,17 @@ class HoloUser:
                 {"$set": {"warns": warns["warns"] + count}},
             )
         else:
-            await col_warnings.insert_one(document={"user": self.id, "warns": count})
+            await col_warnings.insert_one(document={"id": self.id, "warns": count})
 
         logger.info("User %s was warned %s times due to: %s", self.id, count, reason)
 
-    async def _set(self, key: str, value: Any) -> None:
+    async def _set(self, key: str, value: Any, cache: HoloCache | None = None) -> None:
         """Set attribute data and save it into the database
 
         ### Args:
             * `key` (str): Attribute to be changed
             * `value` (Any): Value to set
+            * `cache` (HoloCache | None, optional): Cache engine to write the update into
         """
         if not hasattr(self, key):
             raise AttributeError()
@@ -107,40 +123,99 @@ class HoloUser:
             {"_id": self._id}, {"$set": {key: value}}, upsert=True
         )
 
-        logger.info("Set attribute %s of user %s to %s", key, self.id, value)
+        self._update_cache(cache)
 
-    async def _remove(self, key: str) -> None:
+        logger.info("Set attribute '%s' of user %s to '%s'", key, self.id, value)
+
+    async def _remove(self, key: str, cache: HoloCache | None = None) -> None:
         """Remove attribute data and save it into the database
 
         ### Args:
             * `key` (str): Attribute to be removed
+            * `cache` (HoloCache | None, optional): Cache engine to write the update into
         """
         if not hasattr(self, key):
             raise AttributeError()
 
-        setattr(self, key, None)
+        default_value: Any = HoloUser.get_default_value(key)
+
+        setattr(self, key, default_value)
 
         await col_users.update_one(
-            {"_id": self._id}, {"$unset": {key: None}}, upsert=True
+            {"_id": self._id}, {"$set": {key: default_value}}, upsert=True
         )
 
-        logger.info("Removed attribute %s of user %s", key, self.id)
+        self._update_cache(cache)
 
-    async def set_custom_channel(self, channel_id: int) -> None:
-        await self._set("custom_channel", channel_id)
+        logger.info("Removed attribute '%s' of user %s", key, self.id)
 
-    async def set_custom_role(self, role_id: int) -> None:
-        await self._set("custom_role", role_id)
+    def _get_cache_key(self) -> str:
+        return f"user_{self.id}"
 
-    async def remove_custom_channel(self) -> None:
-        await self._remove("custom_channel")
+    def _update_cache(self, cache: HoloCache | None = None) -> None:
+        if cache is None:
+            return
 
-    async def remove_custom_role(self) -> None:
-        await self._remove("custom_role")
+        user_dict: Dict[str, Any] = self._to_dict()
 
-    async def purge(self) -> None:
-        """Completely remove user data from database. Will not remove transactions logs and warnings."""
+        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: HoloCache | None = None) -> None:
+        if cache is None:
+            return
+
+        cache.delete(self._get_cache_key())
+
+    @staticmethod
+    def get_defaults(user_id: int | None = None) -> Dict[str, Any]:
+        return {
+            "id": user_id,
+            "custom_role": None,
+            "custom_channel": None,
+        }
+
+    @staticmethod
+    def get_default_value(key: str) -> Any:
+        if key not in HoloUser.get_defaults():
+            raise KeyError(f"There's no default value for key '{key}' in HoloUser")
+
+        return HoloUser.get_defaults()[key]
+
+    def _to_dict(self) -> Dict[str, Any]:
+        return {
+            "_id": self._id,
+            "id": self.id,
+            "custom_role": self.custom_role,
+            "custom_channel": self.custom_channel,
+        }
+
+    async def set_custom_channel(
+        self, channel_id: int, cache: HoloCache | None = None
+    ) -> None:
+        await self._set("custom_channel", channel_id, cache=cache)
+
+    async def set_custom_role(
+        self, role_id: int, cache: HoloCache | None = None
+    ) -> None:
+        await self._set("custom_role", role_id, cache=cache)
+
+    async def remove_custom_channel(self, cache: HoloCache | None = None) -> None:
+        await self._remove("custom_channel", cache=cache)
+
+    async def remove_custom_role(self, cache: HoloCache | None = None) -> None:
+        await self._remove("custom_role", cache=cache)
+
+    async def purge(self, cache: HoloCache | None = None) -> None:
+        """Completely remove user data from database. Will not remove transactions logs and warnings.
+
+        ### Args:
+            * `cache` (HoloCache | None, optional): Cache engine to write the update into
+        """
         await col_users.delete_one({"_id": self._id})
+        self._delete_cache(cache)
 
     @staticmethod
     async def is_moderator(member: User | Member) -> bool: