CustomModules 1.0.1__tar.gz → 2.0.3__tar.gz

{custommodules-1.0.1 → custommodules-2.0.3}/CustomModules/__init__.py

@@ -20,9 +20,9 @@ Available modules:
 - twitch: Twitch API integration
 """
 
-__version__ = '1.0.1'
-__author__ = 'Serpensin'
-__license__ = 'AGPL-3.0'
+__version__ = "2.0.3"
+__author__ = "Serpensin"
+__license__ = "AGPL-3.0"
 
 # Conditional imports based on available dependencies
 try:
@@ -106,20 +106,20 @@ except ImportError:
     pass
 
 __all__ = [
-    'app_translation',
-    'bitmap_handler',
-    'bot_directory',
-    'database_handler',
-    'googletrans',
-    'invite_tracker',
-    'killswitch',
-    'libretrans',
-    'log_handler',
-    'patchnotes',
-    'private_voice',
-    'random_usernames',
-    'stat_dock',
-    'steam',
-    'steam_charts',
-    'twitch',
+    "app_translation",
+    "bitmap_handler",
+    "bot_directory",
+    "database_handler",
+    "googletrans",
+    "invite_tracker",
+    "killswitch",
+    "libretrans",
+    "log_handler",
+    "patchnotes",
+    "private_voice",
+    "random_usernames",
+    "stat_dock",
+    "steam",
+    "steam_charts",
+    "twitch",
 ]

custommodules-2.0.3/CustomModules/app_translation.py

@@ -0,0 +1,80 @@
+import logging
+from typing import Optional
+
+import discord
+
+
+class Translator(discord.app_commands.Translator):
+    def __init__(self, logger: Optional[logging.Logger] = None):
+        """
+        Initializes the Translator class with predefined translations for German and Japanese locales.
+
+        Args:
+            logger (Optional[logging.Logger]): Parent logger. If provided, creates a child logger
+            under CustomModules.AppTranslation. Defaults to None.
+        """
+        # Setup logger with child hierarchy: parent -> CustomModules -> AppTranslation
+        if logger:
+            self.logger = logger.getChild("CustomModules").getChild("AppTranslation")
+        else:
+            self.logger = logging.getLogger("CustomModules.AppTranslation")
+
+        self.logger.debug("Initializing AppTranslation Translator")
+
+        self.translations = {
+            discord.Locale.german: {
+                "Test, if the bot is responding.": "Teste, ob der Bot antwortet.",
+                "Get information about the bot.": "Erhalte Informationen über den Bot.",
+                "change_nickname": "nickname_ändern",
+            },
+            discord.Locale.japanese: {
+                "ping": "ピング",
+                "Test, if the bot is responding.": "ボットが応答しているかテストします。",
+                "botinfo": "ボット情報",
+                "Get information about the bot.": "ボットに関する情報を取得します。",
+                "change_nickname": "ニックネームを変更する",
+            },
+        }
+
+        total_translations = sum(len(trans) for trans in self.translations.values())
+        self.logger.info(
+            f"Translator initialized with {len(self.translations)} locales and {total_translations} total translations"
+        )
+
+    async def load(self) -> None:
+        """
+        Placeholder method for loading translations.
+        Currently does nothing.
+        """
+        self.logger.debug("Load method called (currently no-op)")
+
+    async def translate(
+        self,
+        string: discord.app_commands.locale_str,
+        locale: discord.Locale,
+        context: discord.app_commands.TranslationContext,
+    ) -> Optional[str]:
+        """
+        Translates a given string to the specified locale.
+
+        Parameters:
+        string (discord.app_commands.locale_str): The string that is requesting to be translated.
+        locale (discord.Locale): The target language to translate to.
+        context (discord.app_commands.TranslationContext): The origin of this string, e.g., TranslationContext.command_name, etc.
+
+        Returns:
+        Optional[str]: The translated string if available, otherwise the original string.
+        """
+        original = string.message
+        translated = self.translations.get(locale, {}).get(original, original)
+
+        if translated != original:
+            self.logger.debug(
+                f"Translated '{original}' to '{translated}' for locale {locale.value}"
+            )
+        else:
+            self.logger.debug(
+                f"No translation found for '{original}' in locale {locale.value}, using original"
+            )
+
+        return translated

custommodules-2.0.3/CustomModules/bitmap_handler.py

@@ -0,0 +1,298 @@
+import logging
+from typing import Dict, List, Optional, Union
+
+
+class BitmapHandler:
+    def __init__(self, keys: List[str], logger: Optional[logging.Logger] = None):
+        """
+        Initialize the BitmapHandler with a list of keys.
+
+        Args:
+            keys (List[str]): A list of keys to initialize the bitmap.
+            A maximum of 64 keys can be provided.
+            logger (Optional[logging.Logger]): Parent logger. If provided, creates a child logger
+            under CustomModules.BitmapHandler. Defaults to None.
+
+        Raises:
+            ValueError: If more than 64 keys are provided.
+        """
+        # Setup logger with child hierarchy: parent -> CustomModules -> BitmapHandler
+        if logger:
+            self.logger = logger.getChild("CustomModules").getChild("BitmapHandler")
+        else:
+            self.logger = logging.getLogger("CustomModules.BitmapHandler")
+
+        self.logger.debug(f"Initializing BitmapHandler with {len(keys)} keys")
+
+        if len(keys) > 64:
+            self.logger.error(f"Too many keys provided: {len(keys)} > 64")
+            raise ValueError(
+                "Warning: You are trying to initialize with more than 64 keys. This may exceed the limit for bit manipulation."
+            )
+
+        # Generate the bitmap dictionary dynamically
+        self.bitmap: Dict[str, int] = {key: index for index, key in enumerate(keys)}
+        self.key_list: List[str] = keys.copy()  # Store keys in a list for ordering
+
+        self.logger.info(
+            f"BitmapHandler initialized successfully with keys: {', '.join(keys)}"
+        )
+
+    def get_bitkey(self, *args: str) -> int:
+        """
+        Converts a list of keys into a single bitkey.
+
+        Args:
+            *args (str): A variable number of keys to be converted to a bitkey.
+
+        Returns:
+            int: The bitkey representing the provided keys.
+
+        Raises:
+            KeyError: If any key is invalid (not in the bitmap).
+        """
+        self.logger.debug(f"Converting keys to bitkey: {args}")
+        bitkey = 0
+        for key in args:
+            if key in self.bitmap:
+                bitkey |= 1 << self.bitmap[key]
+                self.logger.debug(
+                    f"Added key '{key}' at position {self.bitmap[key]} to bitkey"
+                )
+            elif key:
+                self.logger.error(f"Invalid key provided: {key}")
+                raise KeyError(f"Invalid key: {key}")
+
+        self.logger.debug(f"Generated bitkey: {bitkey} (binary: {bin(bitkey)})")
+        return bitkey
+
+    def check_key_in_bitkey(self, key: str, bitkey: int) -> bool:
+        """
+        Checks if a given key is present in the bitkey.
+
+        Args:
+            key (str): The key to check.
+            bitkey (int): The bitkey in which to check for the key.
+
+        Returns:
+            bool: True if the key is present in the bitkey, False otherwise.
+        """
+        result = key in self.bitmap and bool(bitkey & (1 << self.bitmap[key]))
+        self.logger.debug(f"Checking if key '{key}' is in bitkey {bitkey}: {result}")
+        return result
+
+    def get_active_keys(
+        self, bitkey: int, single: bool = False
+    ) -> Union[str, List[str]]:
+        """
+        Retrieves the active keys from a bitkey.
+
+        Args:
+            bitkey (int): The bitkey from which to retrieve active keys.
+            single (bool, optional): If True, returns the last active key as a string.
+            If False, returns a list of active keys. Defaults to False.
+
+        Returns:
+            Union[str, List[str]]: The active keys in the bitkey.
+
+        Raises:
+            ValueError: If the bitkey is invalid (not within the valid range).
+        """
+        self.logger.debug(
+            f"Retrieving active keys from bitkey {bitkey} (single={single})"
+        )
+
+        max_bitkey = (1 << len(self.bitmap)) - 1
+        if bitkey < 0 or bitkey > max_bitkey:
+            self.logger.error(
+                f"Invalid bitkey: {bitkey}. Must be between 0 and {max_bitkey}"
+            )
+            raise ValueError(
+                f"Invalid bitkey: {bitkey}. It must be between 0 and {max_bitkey}."
+            )
+
+        active_keys = [
+            key
+            for key, bit_position in self.bitmap.items()
+            if bitkey & (1 << bit_position)
+        ]
+
+        self.logger.debug(f"Found {len(active_keys)} active keys: {active_keys}")
+
+        if single:
+            result = active_keys[-1] if active_keys else ""
+            self.logger.debug(f"Returning single active key: '{result}'")
+            return result
+        return active_keys
+
+    def toggle_key_in_bitkey(self, key: str, bitkey: int, add: bool = True) -> int:
+        """
+        Adds or removes a given key from an existing bitkey based on the 'add' parameter.
+
+        Args:
+            key (str): The key to add or remove.
+            bitkey (int): The existing bitkey.
+            add (bool, optional): If True, the key is added to the bitkey;
+            if False, the key is removed. Defaults to True.
+
+        Returns:
+            int: The updated bitkey after the operation.
+
+        Raises:
+            KeyError: If the key is invalid (not in the bitmap).
+        """
+        self.logger.debug(f"Toggling key '{key}' in bitkey {bitkey} (add={add})")
+
+        if key not in self.bitmap:
+            self.logger.error(f"Invalid key: {key}")
+            raise KeyError(f"Invalid key: {key}")
+
+        result = (
+            bitkey | (1 << self.bitmap[key])
+            if add
+            else bitkey & ~(1 << self.bitmap[key])
+        )
+
+        self.logger.debug(
+            f"Key '{key}' {'added to' if add else 'removed from'} bitkey. Result: {result}"
+        )
+        return result
+
+    def invert_bitkey(self, bitkey: int) -> int:
+        """
+        Inverts all bits in the given bitkey.
+
+        Args:
+            bitkey (int): The bitkey to be inverted.
+
+        Returns:
+            int: The inverted bitkey.
+        """
+        max_bitkey = (1 << len(self.bitmap)) - 1
+        result = ~bitkey & max_bitkey
+        self.logger.debug(f"Inverted bitkey {bitkey} to {result}")
+        return result
+
+    def count_active_bits(self, bitkey: int) -> int:
+        """
+        Counts the number of active (set) bits in the bitkey.
+
+        Args:
+            bitkey (int): The bitkey for which to count active bits.
+
+        Returns:
+            int: The count of active bits in the bitkey.
+        """
+        count = bin(bitkey).count("1")
+        self.logger.debug(f"Counted {count} active bits in bitkey {bitkey}")
+        return count
+
+    def compare_bitkeys(self, bitkey1: int, bitkey2: int) -> Dict[str, List[str]]:
+        """
+        Compares two bitkeys and returns a dictionary of differences.
+
+        Args:
+            bitkey1 (int): The first bitkey to compare.
+            bitkey2 (int): The second bitkey to compare.
+
+        Returns:
+            Dict[str, List[str]]: A dictionary containing the common keys,
+            keys only in the first bitkey, and keys only in the second bitkey.
+        """
+        self.logger.debug(f"Comparing bitkeys: {bitkey1} and {bitkey2}")
+
+        common = bitkey1 & bitkey2
+        only_in_1 = bitkey1 & ~bitkey2
+        only_in_2 = bitkey2 & ~bitkey1
+
+        # get_active_keys with single=False always returns List[str]
+        common_keys = self.get_active_keys(common, single=False)
+        only_in_1_keys = self.get_active_keys(only_in_1, single=False)
+        only_in_2_keys = self.get_active_keys(only_in_2, single=False)
+
+        result = {
+            "common_keys": (
+                common_keys if isinstance(common_keys, list) else [common_keys]
+            ),
+            "only_in_bitkey1": (
+                only_in_1_keys if isinstance(only_in_1_keys, list) else [only_in_1_keys]
+            ),
+            "only_in_bitkey2": (
+                only_in_2_keys if isinstance(only_in_2_keys, list) else [only_in_2_keys]
+            ),
+        }
+
+        self.logger.debug(
+            f"Comparison result: {len(result['common_keys'])} common, "
+            f"{len(result['only_in_bitkey1'])} only in first, "
+            f"{len(result['only_in_bitkey2'])} only in second"
+        )
+
+        return result
+
+    def add_key(self, key: str):
+        """
+        Adds a new key to the bitmap.
+
+        Args:
+            key (str): The key to add.
+
+        Raises:
+            KeyError: If the key already exists in the bitmap.
+        """
+        self.logger.debug(f"Attempting to add key: {key}")
+
+        if key in self.bitmap:
+            self.logger.error(f"Key '{key}' already exists in bitmap")
+            raise KeyError(f"Key '{key}' already exists.")
+
+        # Add the new key and update the bitmap and key_list
+        new_index = len(self.bitmap)
+        self.bitmap[key] = new_index  # Assign the next available index
+        self.key_list.append(key)  # Append the new key to the list
+
+        self.logger.info(
+            f"Added key '{key}' at position {new_index}. Total keys: {len(self.bitmap)}"
+        )
+
+    def remove_key(self, key: str):
+        """
+        Removes a key from the bitmap.
+
+        Args:
+            key (str): The key to remove.
+
+        Raises:
+            KeyError: If the key does not exist in the bitmap.
+        """
+        self.logger.debug(f"Attempting to remove key: {key}")
+
+        if key not in self.bitmap:
+            self.logger.error(f"Key '{key}' does not exist in bitmap")
+            raise KeyError(f"Key '{key}' does not exist.")
+
+        # Remove the key and reassign indices for the remaining keys
+        index_to_remove = self.bitmap[key]
+        del self.bitmap[key]
+
+        # Reassign keys and their bit positions only if the key is not the last one
+        if len(self.bitmap) > 0:
+            for k in self.bitmap:
+                if self.bitmap[k] > index_to_remove:
+                    self.bitmap[k] -= 1
+
+        self.key_list.remove(key)  # Remove from key list
+
+        self.logger.info(
+            f"Removed key '{key}' from position {index_to_remove}. Remaining keys: {len(self.bitmap)}"
+        )
+
+    def get_keys(self) -> Dict[str, int]:
+        """
+        Returns the current bitmap dictionary.
+
+        Returns:
+            Dict[str, int]: The current bitmap dictionary mapping keys to their bit positions.
+        """
+        self.logger.debug(f"Retrieving bitmap with {len(self.bitmap)} keys")
+        return self.bitmap

custommodules-2.0.3/CustomModules/bot_directory.py

@@ -0,0 +1,169 @@
+import asyncio
+import logging
+from typing import Optional
+
+import aiohttp
+
+
+class Stats:
+    # Constants for repeated string literals
+    CONTENT_TYPE_JSON = "application/json"
+    CONTENT_TYPE_JSON_UTF8 = "application/json; charset=utf-8"
+
+    def __init__(
+        self,
+        bot,
+        logger: Optional[logging.Logger] = None,
+        topgg_token: str = "",
+        discordbots_token: str = "",
+        discordbotlistcom_token: str = "",
+        discordlist_token: str = "",
+    ):
+        # Setup logger with child hierarchy: parent -> CustomModules -> BotDirectory
+        if logger:
+            self.logger = logger.getChild("CustomModules").getChild("BotDirectory")
+        else:
+            self.logger = logging.getLogger("CustomModules.BotDirectory")
+
+        self.logger.debug("Initializing Stats module")
+
+        self.bot = bot
+        self.topgg_token = topgg_token
+        self.discordbots_token = discordbots_token
+        self.discordbotlistcom_token = discordbotlistcom_token
+        self.discordlist_token = discordlist_token
+
+        self._tasks = []
+
+        active_tokens = sum(
+            [
+                bool(topgg_token),
+                bool(discordbots_token),
+                bool(discordbotlistcom_token),
+                bool(discordlist_token),
+            ]
+        )
+        self.logger.info(
+            f"Stats initialized with {active_tokens} active bot directory tokens"
+        )
+
+    async def _post_stats(self, url, headers, json_data):
+        """Post statistics to a given URL with error logging."""
+        self.logger.debug(f"Posting stats to {url}")
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.post(url, headers=headers, json=json_data) as resp:
+                    if resp.status != 200:
+                        text = await resp.text()
+                        self.logger.error(
+                            f"Failed to update {url}: {resp.status} {text}"
+                        )
+                    else:
+                        self.logger.debug(f"Successfully posted stats to {url}")
+        except Exception as e:
+            self.logger.error(f"Exception while posting stats to {url}: {e}")
+
+    async def _loop_post(self, url, headers, json_func, interval=60 * 30):
+        """Generic loop for posting stats periodically."""
+        self.logger.debug(
+            f"Starting stats update loop for {url} (interval: {interval}s)"
+        )
+        while True:
+            try:
+                json_data = json_func()
+                await self._post_stats(url, headers, json_data)
+                await asyncio.sleep(interval)
+            except asyncio.CancelledError:
+                self.logger.debug(f"Stats loop for {url} cancelled")
+                raise  # Re-raise to properly handle cancellation
+            except Exception as e:
+                self.logger.error(f"Exception in stats loop for {url}: {e}")
+                await asyncio.sleep(interval)
+
+    def _topgg_data(self):
+        return {
+            "server_count": len(self.bot.guilds),
+            "shard_count": len(self.bot.shards),
+        }
+
+    def _discordbots_data(self):
+        return {"guildCount": len(self.bot.guilds), "shardCount": len(self.bot.shards)}
+
+    def _discordbotlist_com_data(self):
+        return {
+            "guilds": len(self.bot.guilds),
+            "users": sum(guild.member_count for guild in self.bot.guilds),
+        }
+
+    def _discordlist_data(self):
+        return {"count": len(self.bot.guilds)}
+
+    def start_stats_update(self):
+        """Start all stats update tasks in parallel."""
+        self.logger.info("Starting stats update tasks")
+
+        if self.topgg_token:
+            self.logger.debug("Configuring top.gg stats updates")
+            url = f"https://top.gg/api/bots/{self.bot.user.id}/stats"
+            headers = {
+                "Authorization": self.topgg_token,
+                "Content-Type": self.CONTENT_TYPE_JSON,
+            }
+            self._tasks.append(
+                asyncio.create_task(self._loop_post(url, headers, self._topgg_data))
+            )
+
+        if self.discordbots_token:
+            self.logger.debug("Configuring discord.bots.gg stats updates")
+            url = f"https://discord.bots.gg/api/v1/bots/{self.bot.user.id}/stats"
+            headers = {
+                "Authorization": self.discordbots_token,
+                "Content-Type": self.CONTENT_TYPE_JSON,
+            }
+            self._tasks.append(
+                asyncio.create_task(
+                    self._loop_post(url, headers, self._discordbots_data)
+                )
+            )
+
+        if self.discordbotlistcom_token:
+            self.logger.debug("Configuring discordbotlist.com stats updates")
+            url = f"https://discordbotlist.com/api/v1/bots/{self.bot.user.id}/stats"
+            headers = {
+                "Authorization": self.discordbotlistcom_token,
+                "Content-Type": self.CONTENT_TYPE_JSON,
+            }
+            self._tasks.append(
+                asyncio.create_task(
+                    self._loop_post(url, headers, self._discordbotlist_com_data)
+                )
+            )
+
+        if self.discordlist_token:
+            self.logger.debug("Configuring discordlist.gg stats updates")
+            url = f"https://api.discordlist.gg/v0/bots/{self.bot.user.id}/guilds"
+            headers = {
+                "Authorization": f"Bearer {self.discordlist_token}",
+                "Content-Type": self.CONTENT_TYPE_JSON_UTF8,
+            }
+            self._tasks.append(
+                asyncio.create_task(
+                    self._loop_post(url, headers, self._discordlist_data)
+                )
+            )
+
+        self.logger.info(f"Started {len(self._tasks)} stats update tasks")
+        return self._tasks
+
+    async def stop_stats_update(self):
+        """Cancel all running stats update tasks."""
+        self.logger.info(f"Stopping {len(self._tasks)} stats update tasks")
+        for task in self._tasks:
+            task.cancel()
+        await asyncio.gather(*self._tasks, return_exceptions=True)
+        self._tasks.clear()
+        self.logger.debug("All stats update tasks stopped")
+
+
+if __name__ == "__main__":
+    print("This is a module. Do not run it directly.")