First commit

core/utils/helpers.py

@@ -0,0 +1,200 @@
+import os
+import discord
+from collections import defaultdict
+from core.json_io import JsonIO
+from core import json_flusher
+
+
+GLOBAL_KEY = '__global__'
+SENTINEL = object()
+
+
+class JsonDB(JsonIO):
+    """
+    A DB-like helper class to streamline the saving of json files
+
+    Parameters:
+
+    file_path: str
+      The path of the json file you want to create / access
+    create_dirs: bool=False
+      If True, it will create any missing directory leading to
+      the file you want to create
+    autosave: bool=False
+      If True, any change to the "database" will be queued to the
+      flusher and scheduled for a later write
+    default_value: Optional=None
+      Same behaviour as a defaultdict
+    """
+    def __init__(self, file_path, **kwargs):
+        create_dirs = kwargs.pop("create_dirs", False)
+        default_value = kwargs.pop("default_value", SENTINEL)
+        self.autosave = kwargs.pop("autosave", False)
+        self.path = file_path
+        self._flusher = json_flusher.get_flusher()
+
+        file_exists = os.path.isfile(file_path)
+
+        if create_dirs and not file_exists:
+            path, _ = os.path.split(file_path)
+            if path:
+                try:
+                    os.makedirs(path)
+                except FileExistsError:
+                    pass
+
+        if file_exists:
+            # Might be worth looking into threadsafe ways for very large files
+            self._data = self._load_json(file_path)
+        else:
+            self._data = {}
+            self._save()
+
+        if default_value is not SENTINEL:
+            def _get_default():
+                return default_value
+            self._data = defaultdict(_get_default, self._data)
+
+    def set(self, key, value):
+        """Sets a DB's entry"""
+        self._data[key] = value
+        if self.autosave:
+            self._flusher.add_to_queue(self.path, self._data)
+
+    def get(self, key, default=None):
+        """Returns a DB's entry"""
+        return self._data.get(key, default)
+
+    def remove(self, key):
+        """Removes a DB's entry"""
+        del self._data[key]
+        if self.autosave:
+            self._flusher.add_to_queue(self.path, self._data)
+
+    def pop(self, key, default=None):
+        """Removes and returns a DB's entry"""
+        return self._data.pop(key, default)
+
+    def wipe(self):
+        """Wipes DB"""
+        self._data = {}
+        if self.autosave:
+            self._flusher.add_to_queue(self.path, self._data)
+
+    def all(self):
+        """Returns all DB's data"""
+        return self._data
+
+    def _save(self):
+        """Using this should be avoided. Let's stick to threadsafe saves"""
+        self._save_json(self.path, self._data)
+
+    async def save(self):
+        self._flusher.remove_from_queue(self.path)
+        await self._threadsafe_save_json(self.path, self._data)
+
+    def __contains__(self, key):
+        return key in self._data
+
+    def __getitem__(self, key):
+        return self._data[key]
+
+    def __len__(self):
+        return len(self._data)
+
+    def __repr__(self):
+        return "<{} {}>".format(self.__class__.__name__, self._data)
+
+
+class JsonGuildDB(JsonDB):
+    """
+    A DB-like helper class to streamline the saving of json files
+    This is a variant of JsonDB that allows for guild specific data
+    Global data is still allowed with dedicated methods
+
+    Same parameters as JsonDB
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def set(self, guild, key, value):
+        """Sets a guild's entry"""
+        if not isinstance(guild, discord.Guild):
+            raise TypeError('Can only set guild data')
+        if str(guild.id) not in self._data:
+            self._data[str(guild.id)] = {}
+        self._data[str(guild.id)][key] = value
+        if self.autosave:
+            self._flusher.add_to_queue(self.path, self._data)
+
+    def get(self, guild, key, default=None):
+        """Returns a guild's entry"""
+        if not isinstance(guild, discord.Guild):
+            raise TypeError('Can only get guild data')
+        if str(guild.id) not in self._data:
+            return default
+        return self._data[str(guild.id)].get(key, default)
+
+    def remove(self, guild, key):
+        """Removes a guild's entry"""
+        if not isinstance(guild, discord.Guild):
+            raise TypeError('Can only remove guild data')
+        if str(guild.id) not in self._data:
+            raise KeyError('Guild data is not present')
+        del self._data[str(guild.id)][key]
+        if self.autosave:
+            self._flusher.add_to_queue(self.path, self._data)
+
+    def pop(self, guild, key, default=None):
+        """Removes and returns a guild's entry"""
+        if not isinstance(guild, discord.Guild):
+            raise TypeError('Can only remove guild data')
+        return self._data.get(str(guild.id), {}).pop(key, default)
+        if self.autosave:
+            self._flusher.add_to_queue(self.path, self._data)
+
+    def get_all(self, guild, default):
+        """Returns all entries of a guild"""
+        if not isinstance(guild, discord.Guild):
+            raise TypeError('Can only get guild data')
+        return self._data.get(str(guild.id), default)
+
+    def remove_all(self, guild):
+        """Removes all entries of a guild"""
+        if not isinstance(guild, discord.Guild):
+            raise TypeError('Can only remove guilds')
+        super().remove(str(guild.id))
+        if self.autosave:
+            self._flusher.add_to_queue(self.path, self._data)
+
+    def set_global(self, key, value):
+        """Sets a global value"""
+        if GLOBAL_KEY not in self._data:
+            self._data[GLOBAL_KEY] = {}
+        self._data[GLOBAL_KEY][key] = value
+        if self.autosave:
+            self._flusher.add_to_queue(self.path, self._data)
+
+    def get_global(self, key, default=None):
+        """Gets a global value"""
+        if GLOBAL_KEY not in self._data:
+            self._data[GLOBAL_KEY] = {}
+
+        return self._data[GLOBAL_KEY].get(key, default)
+
+    def remove_global(self, key):
+        """Removes a global value"""
+        if GLOBAL_KEY not in self._data:
+            self._data[GLOBAL_KEY] = {}
+        del self._data[key]
+        if self.autosave:
+            self._flusher.add_to_queue(self.path, self._data)
+
+    def pop_global(self, key, default=None):
+        """Removes and returns a global value"""
+        if GLOBAL_KEY not in self._data:
+            self._data[GLOBAL_KEY] = {}
+        return self._data.pop(key, default)
+        if self.autosave:
+            self._flusher.add_to_queue(self.path, self._data)