./0000755000000000000000000000000014321742407007715 5ustar rootroot./bot_base/0000755000000000000000000000000014321742372011474 5ustar rootroot./bot_base/__init__.py0000644000000000000000000000001714321742372013603 0ustar rootrootimport bot_base./bot_base/bot_base.py0000644000000000000000000002505114321742372013627 0ustar rootrootfrom __future__ import annotations import importlib import inspect import logging import os import sys import traceback import discord import toml from packaging.specifiers import SpecifierSet, InvalidSpecifier from config import Config, config_types from config.config_types import factory import errors __version__ = "0.2.0" MINIMAL_INFOS = ["version", "bot_version"] class BotBase(discord.Client): log = None def __init__(self, data_folder: str = "data", modules_folder: str = "modules", *args, **kwargs): super().__init__(*args, **kwargs) # Create folders os.makedirs(modules_folder, exist_ok=True) os.makedirs(data_folder, exist_ok=True) # Add module folder to search path # TODO: Vérifier que ca ne casse rien sys.path.insert(0, modules_folder) # Setup logging self.log = logging.getLogger('bot_base') # Content: {"module_name": {"module": imported module, "class": initialized class}} self.modules = {} # Setup config self.configs = {} self.config = Config(path=os.path.join(data_folder, "config.toml")) self.config.register("modules", factory(config_types.List, factory(config_types.Str))) self.config.register("data_folder", factory(config_types.Str)) self.config.register("modules_folder", factory(config_types.Str)) self.config.set({ "modules": [], "data_folder": data_folder, "modules_folder": modules_folder, }, no_save=True) self.config.load() async def on_ready(self): self.info("Bot ready.") try: self.load_modules() except errors.ModuleException as e: self.loop.stop() raise e def load_modules(self): self.info("Load modules...") for module in self.config["modules"]: if module not in self.modules.keys(): self.load_module(module) self.info("Modules loaded.") def load_module(self, module: str) -> None: """ Try to load module :raise ModuleNotFoundError: If module is not in module folder :raise IncompatibleModuleError: If module is incompatible :param str module: module to load """ self.info(f"Attempt to load module {module}...") # Check if module exists if not os.path.isdir(os.path.join(self.config["modules_folder"], module)): self.warning(f"Attempt to load unknown module {module}.") raise errors.ModuleNotFoundError( f"Module {module} not found in modules folder ({self.config['modules_folder']}.)") if not os.path.isfile(os.path.join(self.config["modules_folder"], module, "infos.toml")): self.warning(f"Attempt to load incompatible module {module}: no infos.toml found") raise errors.IncompatibleModuleError(f"Module {module} is incompatible: no infos.toml found.") # Check infos.toml integrity with open(os.path.join(self.config["modules_folder"], module, "infos.toml")) as f: infos = toml.load(f) for key in MINIMAL_INFOS: if key not in infos.keys(): self.warning(f"Attempt to load incompatible module {module}: missing information {key}") raise errors.IncompatibleModuleError(f"Missing information for module {module}: missing {key}.") # Check bot_version bot_version_specifier = SpecifierSet(infos["bot_version"]) if __version__ not in bot_version_specifier: self.warning(f"Attempt to load incompatible module {module}: need bot version {infos['bot_version']} " f"and you have {__version__}") raise errors.IncompatibleModuleError(f"Module {module} is not compatible with your current bot version " f"(need {infos['bot_version']} and you have {__version__}).") # Check dependencies if infos.get("dependencies"): for dep, version in infos["dependencies"].items(): if not dep in self.modules.keys(): self.load_module(dep) dep_version_specifier = None try: dep_version_specifier = SpecifierSet(version) except InvalidSpecifier: self.warning( f"Attempt to load incompatible module {module}: dependance version is invalid ({version} for {dep})") raise errors.IncompatibleModuleError(f"Module {module} is not compatible with your current " f"installation (version specifier {version} for {dep} is " f"invalid.") if self.modules[dep]["infos"]["version"] not in dep_version_specifier: self.warning(f"Attempt to load incompatible module {module}: require {dep} ({version}) " f"and you have {dep} ({self.modules[dep]['infos']['version']})") raise errors.IncompatibleModuleError(f"Module {module} is not compatible with your current install " f"(require {dep} ({version}) and you have {dep} " f"({self.modules[dep]['infos']['version']})") # Check if module is meta if infos.get("metamodule", False) == False: # Check if module have __main_class__ try: imported = importlib.import_module(module) except Exception as e: self.warning(f"Attempt to load incompatible module {module}: failed import") raise e try: main_class = imported.__main_class__ except AttributeError: self.warning(f"Attempt to load incompatible module {module}: no __main_class__ found") raise errors.IncompatibleModuleError(f"Module {module} does not provide __main_class__.") # Check if __main_class__ is a class if not inspect.isclass(main_class): self.warning(f"Attempt to load incompatible module {module}: __main_class__ is not a type") raise errors.IncompatibleModuleError(f"Module {module} contains __main_class__ but it is not a type.") try: main_class = main_class(self) except TypeError: # Module don't need client reference main_class = main_class() # Check if __main_class__ have __dispatch__ attribute try: dispatch = main_class.__dispatch__ except AttributeError: self.warning(f"Attempt to load incompatible module {module}: __dispatch_ not found") raise errors.IncompatibleModuleError( f"Module {module} mainclass ({main_class}) does not provide __dispatch__" f" attribute)") # Check if __dispatch__ is function if not inspect.isfunction(imported.__main_class__.__dispatch__): self.warning(f"Attempt to load incompatible module {module}: __dispatch__ is not a function") raise errors.IncompatibleModuleError( f"Module {module} mainclass ({main_class}) provides __dispatch__, but it is " f"not a function ({dispatch}).") # Check if __dispatch__ can have variable positional and keyword aguments (to avoid future error on each event) sig = inspect.signature(dispatch) args_present, kwargs_present = False, False for p in sig.parameters.values(): if p.kind == p.VAR_POSITIONAL: args_present = True elif p.kind == p.VAR_KEYWORD: kwargs_present = True if not args_present: self.warning(f"Attempt to load incompatible module {module}: __dispatch__ doesn't accept variable " f"positional arguments") raise errors.IncompatibleModuleError( f"Module {module} mainclass ({main_class}) provide __dispatch__ function, but " f"this function doesn't accept variable positional arguments.") if not kwargs_present: self.warning(f"Attempt to load incompatible module {module}: __dispatch__ doesn't accept variable " f"keywords arguments.") raise errors.IncompatibleModuleError( f"Module {module} mainclass ({main_class}) provide __dispatch__ function, but " f"this function doesn't accept variable keywords arguments.") # Module is compatible! # Add module to loaded modules self.info(f"Add modules {module} to current modules.") self.modules.update({ module: { "infos": infos, "imported": imported, "initialized_class": main_class, "dispatch": dispatch, } }) else: # Module is metamodule self.info(f"Add modules {module} to current modules") self.modules.update({ module: { "infos": infos, "dispatch": lambda *x, **y: None } }) if module not in self.config["modules"]: self.config.set({"modules": self.config["modules"] + [module]}) self.config.save() def dispatch(self, event, *args, **kwargs): """Dispatch event""" super().dispatch(event, *args, **kwargs) for module in self.modules.values(): module["dispatch"](event, *args, **kwargs) async def on_error(self, event_method, *args, **kwargs): self.error(f"Error in {event_method}: \n{traceback.format_exc()}") # Logging def info(self, info, *args, **kwargs): if self.log: self.log.info(info, *args, **kwargs) self.dispatch("log_info", info, *args, **kwargs) def error(self, e, *args, **kwargs): if self.log: self.log.error(e, *args, **kwargs) self.dispatch("log_error", e, *args, **kwargs) def warning(self, warning, *args, **kwargs): if self.log: self.log.warning(warning, *args, **kwargs) self.dispatch("log_warning", warning, *args, **kwargs) # Configuration def get_config(self, path): self.configs.update({ path: self.configs.get(path) or Config(path=path) }) ./config/0000755000000000000000000000000014321742372011163 5ustar rootroot./config/config_types/0000755000000000000000000000000014321742372013654 5ustar rootroot./config/config_types/discord_types/0000755000000000000000000000000014321742372016527 5ustar rootroot./config/config_types/discord_types/__init__.py0000644000000000000000000000042714321742372020643 0ustar rootrootfrom config.config_types.discord_types.channel import Channel from config.config_types.discord_types.guild import Guild from config.config_types.discord_types.role import Role from config.config_types.discord_types.user import User __all__ = ['Channel', "Guild", "User", "Role"]./config/config_types/discord_types/channel.py0000644000000000000000000001134614321742372020516 0ustar rootrootfrom __future__ import annotations import typing import discord from config.config_types.base_type import BaseType if typing.TYPE_CHECKING: from bot_base import BotBase class Channel(BaseType): #: :class:`BotBase`: Client instance for checking client: BotBase #: :class:`typing.Optional` [:class:`int`]: Current channel id value: int #: :class:`typing.Optional` [:class:`discord.TextChannel`]: Current channel instance channel_instance: typing.Optional[discord.TextChannel] def __init__(self, client: BotBase) -> None: """ Base Channel type for config. :param BotBase client: Client instance :Basic usage: >>> Channel(client) #doctest: +SKIP """ self.value = 0 self.channel_instance = None self.client = client def check_value(self, value: typing.Union[int, discord.TextChannel]) -> bool: """ Check if value is correct If bot is not connected, always True :Basic usage: >>> my_channel = Channel(client) #doctest: +SKIP >>> my_channel.check_value(invalid_id_or_channel) #doctest: +SKIP False >>> my_channel.check_value(valid_id_or_channel) #doctest: +SKIP True :param value: Value to test :type value: Union[int, discord.TextChannel] :return: True if channel exists """ id = value if isinstance(value, discord.TextChannel): id = value.id if not self.client.is_ready(): self.client.warning(f"No check for channel {value} because client is not initialized!") return True if self.client.get_channel(id): return True return True def set(self, value: typing.Union[int, discord.TextChannel]): """ Set value of parameter :Basic usage: >>> my_channel = Channel(client) #doctest: +SKIP >>> my_channel.set(valid_id_or_channel) #doctest: +SKIP >>> my_channel.set(invalid_id_or_channel) #doctest: +SKIP +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ValueError: ... :raise ValueError: if attempt to set invalid value :param value: value to set :type value: Union[int, discord.TextChannel] """ if not self.check_value(value): raise ValueError("Attempt to set incompatible value.") if isinstance(value, discord.TextChannel): value = value.id self.value = value self._update() def get(self) -> typing.Union[int, discord.Channel]: """ Get value of parameter :Basic usage: >>> my_channel = Channel(client) #doctest: +SKIP >>> my_channel.set(valid_id_or_channel) #doctest: +SKIP >>> my_channel.get() #doctest: +SKIP If client is not connected: >>> my_channel = Channel(client) #doctest: +SKIP >>> my_channel.set(valid_id_or_channel) #doctest: +SKIP >>> my_channel.get() #doctest: +SKIP 23411424132412 :return: Channel object if client is connected, else id :rtype: Union[int, discord.Channel] """ if self.channel_instance is None: self._update() return self.channel_instance or self.value def to_save(self) -> int: """ Return id of channel :Basic usage: >>> my_channel = Channel(client) #doctest: +SKIP >>> my_channel.set(valid_id_or_channel) #doctest: +SKIP >>> my_channel.to_save() #doctest: +SKIP 123412412421 :return: Current id :rtype: int """ return self.value or 0 def load(self, value: typing.Union[int, discord.Channel]) -> None: """ Load value from config :Basic usage: >>> my_channel = Channel(client) #doctest: +SKIP >>> my_channel.set(valid_id) #doctest: +SKIP >>> my_channel.set(invalid_id) #doctest: +SKIP +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ValueError: ... :raise ValueError: if attempt to set invalid value :param value: value to set :type value: Union[int, discord.TextChannel] """ if self.check_value(value): raise ValueError("Attempt to load incompatible value.") self.set(value) self._update() def _update(self): if self.client.is_ready() and self.channel_instance is None: self.channel_instance = self.client.get_channel(self.value) else: self.channel_instance = None def __repr__(self): return f'' ./config/config_types/discord_types/guild.py0000644000000000000000000001105214321742372020204 0ustar rootrootfrom __future__ import annotations import typing import discord from config.config_types.base_type import BaseType if typing.TYPE_CHECKING: from bot_base import BotBase class Guild(BaseType): #: :class:`BotBase`: Client instance for checking client: BotBase #: :class:`typing.Optional` [:class:`int`]: Current guild id value: typing.Optional[int] #: :class:`typing.Optional` [:class:`discord.Guild`]: Current guild instance guild_instance: typing.Optional[discord.Guild] def __init__(self, client: BotBase) -> None: """ Base Guild type for config. :param BotBase client: Client instance :Basic usage: >>> Guild(client) #doctest: +SKIP """ self.value = 0 self.guild_instance = None self.client = client def check_value(self, value: typing.Union[int, discord.Guild]) -> bool: """ Check if value is correct If bot is not connected, always True :Basic usage: >>> my_guild = Guild(client) #doctest: +SKIP >>> my_guild.check_value(invalid_id_or_guild) #doctest: +SKIP False >>> my_guild.check_value(valid_id_or_guild) #doctest: +SKIP True :param value: Value to test :type value: Union[int, discord.Guild] :return: True if guild exists """ id = value if isinstance(value, discord.Guild): id = value.id if not self.client.is_ready(): self.client.warning(f"No check for guild {value} because client is not initialized!") return True if self.client.get_guild(id): return True return True def set(self, value: typing.Union[int, discord.Guild]) -> None: """ Set value of parameter :Basic usage: >>> my_guild = Guild(client) #doctest: +SKIP >>> my_guild.set(valid_id_or_guild) #doctest: +SKIP >>> my_guild.set(invalid_id_or_guild) #doctest: +SKIP +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ValueError: ... :raise ValueError: if attempt to set invalid value :param value: value to set :type value: Union[int, discord.Guild] """ if not self.check_value(value): raise ValueError("Attempt to set incompatible value.") if isinstance(value, discord.Guild): value = value.id self.value = value self._update() def get(self) -> typing.Union[int, discord.Guild]: """ Get value of parameter :Basic usage: >>> my_guild = Guild(client) #doctest: +SKIP >>> my_guild.set(valid_id_or_guild) #doctest: +SKIP >>> my_guild.get() #doctest: +SKIP If client is not connected: >>> my_guild = Guild(client) #doctest: +SKIP >>> my_guild.set(valid_id_or_guild) #doctest: +SKIP >>> my_guild.get() #doctest: +SKIP 23411424132412 :return: Guild object if client is connected, else id :rtype: Union[int, discord.Guild] """ self._update() return self.guild_instance or self.value def to_save(self) -> int: """ Return id of guild :Basic usage: >>> my_guild = Guild(client) #doctest: +SKIP >>> my_guild.set(valid_id_or_guild) #doctest: +SKIP >>> my_guild.to_save() #doctest: +SKIP 123412412421 :return: Current id :rtype: int """ return self.value or 0 def load(self, value: typing.Union[int, discord.Guild]) -> None: """ Load value from config :Basic usage: >>> my_guild = Guild(client) #doctest: +SKIP >>> my_guild.set(valid_id) #doctest: +SKIP >>> my_guild.set(invalid_id) #doctest: +SKIP +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ValueError: ... :raise ValueError: if attempt to set invalid value :param value: value to set :type value: Union[int, discord.Guild] """ if self.check_value(value): raise ValueError("Attempt to load incompatible value.") self.set(value) self._update() def __repr__(self): return f'' def _update(self): if self.client.is_ready() and self.guild_instance is None: self.guild_instance = self.client.get_guild(self.value) else: self.guild_instance = None ./config/config_types/discord_types/role.py0000644000000000000000000001100014321742372020032 0ustar rootrootfrom __future__ import annotations import typing import discord from config.config_types.base_type import BaseType if typing.TYPE_CHECKING: from bot_base import BotBase class Role(BaseType): #: :class:`BotBase`: Client instance for checking client: BotBase #: :class:`typing.Optional` [:class:`int`]: Current role id value: int #: :class:`typing.Optional` [:class:`discord.Role`]: Current role instance role_instance: typing.Optional[discord.Role] def __init__(self, client: BotBase) -> None: """ Base Role type for config. :param BotBase client: Client instance :Basic usage: >>> Role(client) #doctest: +SKIP """ self.value = 0 self.role_instance = None self.client = client def check_value(self, value: typing.Union[int, discord.Role]) -> bool: """ Check if value is correct If bot is not connected, always True :Basic usage: >>> my_role = Role(client) #doctest: +SKIP >>> my_role.check_value(invalid_id_or_role) #doctest: +SKIP False >>> my_role.check_value(valid_id_or_role) #doctest: +SKIP True :param value: Value to test :type value: Union[int, discord.Role] :return: True if role exists """ id = value if isinstance(value, discord.Role): id = value.id if not self.client.is_ready(): self.client.warning(f"No check for role {value} because client is not initialized!") return True if self.client.get_role(id): return True return True def set(self, value: typing.Union[int, discord.Role]) -> None: """ Set value of parameter :Basic usage: >>> my_role = Role(client) #doctest: +SKIP >>> my_role.set(valid_id_or_role) #doctest: +SKIP >>> my_role.set(invalid_id_or_role) #doctest: +SKIP +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ValueError: ... :raise ValueError: if attempt to set invalid value :param value: value to set :type value: Union[int, discord.Role] """ if not self.check_value(value): raise ValueError("Attempt to set incompatible value.") if isinstance(value, discord.Role): value = value.id self.value = value self._update() def get(self) -> typing.Union[int, discord.Role]: """ Get value of parameter :Basic usage: >>> my_role = Role(client) #doctest: +SKIP >>> my_role.set(valid_id_or_role) #doctest: +SKIP >>> my_role.get() #doctest: +SKIP If client is not connected: >>> my_role = Role(client) #doctest: +SKIP >>> my_role.set(valid_id_or_role) #doctest: +SKIP >>> my_role.get() #doctest: +SKIP 23411424132412 :return: Role object if client is connected, else id :rtype: Union[int, discord.Role] """ if self.role_instance is None: self._update() return self.role_instance or self.value def to_save(self) -> int: """ Return id of role :Basic usage: >>> my_role = Role(client) #doctest: +SKIP >>> my_role.set(valid_id_or_role) #doctest: +SKIP >>> my_role.to_save() #doctest: +SKIP 123412412421 :return: Current id :rtype: int """ return self.value or 0 def load(self, value: typing.Union[int, discord.Role]) -> None: """ Load value from config :Basic usage: >>> my_role = Role(client) #doctest: +SKIP >>> my_role.set(valid_id) #doctest: +SKIP >>> my_role.set(invalid_id) #doctest: +SKIP +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ValueError: ... :raise ValueError: if attempt to set invalid value :param value: value to set :type value: Union[int, discord.Role] """ if self.check_value(value): raise ValueError("Attempt to load incompatible value.") self.set(value) self._update() def _update(self): if self.client.is_ready() and self.role_instance is None: self.role_instance = self.client.get_role(self.value) else: self.role_instance = None def __repr__(self): return f''./config/config_types/discord_types/user.py0000644000000000000000000001100014321742372020047 0ustar rootrootfrom __future__ import annotations import typing import discord from config.config_types.base_type import BaseType if typing.TYPE_CHECKING: from bot_base import BotBase class User(BaseType): #: :class:`BotBase`: Client instance for checking client: BotBase #: :class:`typing.Optional` [:class:`int`]: Current user id value: int #: :class:`typing.Optional` [:class:`discord.User`]: Current user instance user_instance: typing.Optional[discord.User] def __init__(self, client: BotBase) -> None: """ Base User type for config. :param BotBase client: Client instance :Basic usage: >>> User(client) #doctest: +SKIP """ self.value = 0 self.user_instance = None self.client = client def check_value(self, value: typing.Union[int, discord.User]) -> bool: """ Check if value is correct If bot is not connected, always True :Basic usage: >>> my_user = User(client) #doctest: +SKIP >>> my_user.check_value(invalid_id_or_user) #doctest: +SKIP False >>> my_user.check_value(valid_id_or_user) #doctest: +SKIP True :param value: Value to test :type value: Union[int, discord.User] :return: True if user exists """ id = value if isinstance(value, discord.User): id = value.id if not self.client.is_ready(): self.client.warning(f"No check for user {value} because client is not initialized!") return True if self.client.get_user(id): return True return True def set(self, value: typing.Union[int, discord.User]) -> None: """ Set value of parameter :Basic usage: >>> my_user = User(client) #doctest: +SKIP >>> my_user.set(valid_id_or_user) #doctest: +SKIP >>> my_user.set(invalid_id_or_user) #doctest: +SKIP +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ValueError: ... :raise ValueError: if attempt to set invalid value :param value: value to set :type value: Union[int, discord.User] """ if not self.check_value(value): raise ValueError("Attempt to set incompatible value.") if isinstance(value, discord.User): value = value.id self.value = value self._update() def get(self) -> typing.Union[int, discord.User]: """ Get value of parameter :Basic usage: >>> my_user = User(client) #doctest: +SKIP >>> my_user.set(valid_id_or_user) #doctest: +SKIP >>> my_user.get() #doctest: +SKIP If client is not connected: >>> my_user = User(client) #doctest: +SKIP >>> my_user.set(valid_id_or_user) #doctest: +SKIP >>> my_user.get() #doctest: +SKIP 23411424132412 :return: User object if client is connected, else id :rtype: Union[int, discord.User] """ if self.user_instance is None: self._update() return self.user_instance or self.value def to_save(self) -> int: """ Return id of user :Basic usage: >>> my_user = User(client) #doctest: +SKIP >>> my_user.set(valid_id_or_user) #doctest: +SKIP >>> my_user.to_save() #doctest: +SKIP 123412412421 :return: Current id :rtype: int """ return self.value or 0 def load(self, value: typing.Union[int, discord.User]) -> None: """ Load value from config :Basic usage: >>> my_user = User(client) #doctest: +SKIP >>> my_user.set(valid_id) #doctest: +SKIP >>> my_user.set(invalid_id) #doctest: +SKIP +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ValueError: ... :raise ValueError: if attempt to set invalid value :param value: value to set :type value: Union[int, discord.User] """ if self.check_value(value): raise ValueError("Attempt to load incompatible value.") self.set(value) self._update() def _update(self): if self.client.is_ready() and self.user_instance is None: self.user_instance = self.client.get_user(self.value) else: self.user_instance = None def __repr__(self): return f''./config/config_types/__init__.py0000644000000000000000000000227114321742372015767 0ustar rootrootfrom typing import Type from . import discord_types from .base_type import BaseType from .bool import Bool from .color import Color from .dict import Dict from .float import Float from .int import Int from .list import List from .str import Str __all__ = ['factory', 'Dict', 'Float', 'Int', 'List', 'Str', 'discord_types', 'Bool', 'Color'] class Meta(type): def __repr__(cls): if hasattr(cls, '__class_repr__'): return getattr(cls, '__class_repr__')() else: return super(Meta, cls).__repr__() def factory(type: Type[BaseType], *args, **kwargs): """ Create a new test ``type`` with parameters args and kwargs :Basic usage: >>> factory(Int) >>> factory(Int, min=0, max=10) :param Type[BaseType] type: Type to create :return: New type """ class Type(type, metaclass=Meta): def __init__(self): super().__init__(*args, **kwargs) @classmethod def __class_repr__(cls): return f"" return Type ./config/config_types/base_type.py0000644000000000000000000000060314321742372016200 0ustar rootrootclass BaseType: def check_value(self, value): """Check if value is good""" pass def set(self, value): """Check and set value""" pass def get(self): """Get value""" pass def to_save(self): """Build a serializable data to save""" pass def load(self, value): """Fill with value""" pass ./config/config_types/bool.py0000644000000000000000000000540014321742372015160 0ustar rootrootimport typing from .base_type import BaseType class Bool(BaseType): #: :class:`typing.Optional` [:class:`bool`]: Current value value: typing.Optional[bool] def __init__(self) -> None: """ Base Bool type for config :Basic usage: >>> Bool() """ self.value = None def check_value(self, value: bool) -> bool: """ Check if value is a correct bool :Basic usage: >>> my_bool = Bool() >>> my_bool.check_value(0) True >>> my_bool.check_value(-2) True >>> my_bool.check_value(345) True >>> my_bool.check_value(0) True >>> my_bool.check_value(-2) True >>> my_bool.check_value(345) True >>> my_bool.check_value(10) True >>> my_bool.check_value(-2) True >>> my_bool.check_value(20) True >>> my_bool.check_value(2) True >>> my_bool.check_value(4) True >>> my_bool.check_value(5) True :param bool value: value to check :return: True if value is correct :rtype: bool """ try: bool(value) except ValueError: return False return True def set(self, value: bool) -> None: """ Set value of parameter :Basic usage: >>> my_bool = Bool() >>> my_bool.set(34) :param bool value: Value to set """ if not self.check_value(value): raise ValueError("Attempt to set incompatible value.") self.value = bool(value) def get(self) -> typing.Optional[bool]: """ Get value of parameter :Basic usage: >>> my_bool = Bool() >>> my_bool.set(34) >>> my_bool.get() True :return: Value of parameter :rtype: typing.Optional[bool] """ return self.value def to_save(self) -> bool: """ Build a serializable object :Basic usage: >>> my_bool = Bool() >>> my_bool.to_save() >>> my_bool.set(34) >>> my_bool.to_save() True :return: Current value :rtype: bool """ return self.value def load(self, value: bool) -> None: """ Load serialized value >>> my_bool = Bool() >>> my_bool.load(True) >>> my_bool.get() True :param bool value: Value to load """ if not self.check_value(value): raise ValueError("Attempt to load incompatible value.") self.value = value def __repr__(self): return f'' ./config/config_types/color.py0000644000000000000000000000520114321742372015342 0ustar rootrootimport typing from .base_type import BaseType class Color(BaseType): #: :class:`typing.Optional` [:class:`int`]: Current value value: typing.Optional[int] def __init__(self) -> None: """ Base Color type for config :Basic usage: >>> Color() """ self.value = 0 def check_value(self, value: int) -> bool: """ Check if value is a correct bool Check if value is int, and if applicable, between ``min`` and ``max`` or in ``values`` :Basic usage: >>> my_color = Color() >>> my_color.check_value(0xFF00FF) True >>> my_color.check_value(-2) False >>> my_color.check_value(345) True >>> my_color.check_value(0xFFFFFF) True >>> my_color.check_value(0x000000) True >>> my_color.check_value(0x1000000) False :param int value: value to check :return: True if value is correct :rtype: bool """ try: int(value) except ValueError: return False return 0xFFFFFF >= value >= 0x000000 def set(self, value: int) -> None: """ Set value of parameter :Basic usage: >>> my_color = Color() >>> my_color.set(34) :param int value: Value to set """ if not self.check_value(value): raise ValueError("Attempt to set incompatible value.") self.value = int(value) def get(self) -> typing.Optional[int]: """ Get value of parameter :Basic usage: >>> my_color = Color() >>> my_color.set(34) >>> my_color.get() 34 :return: Value of parameter :rtype: typing.Optional[int] """ return self.value def to_save(self) -> int: """ Build a serializable object :Basic usage: >>> my_color = Color() >>> my_color.to_save() 0 >>> my_color.set(34) >>> my_color.to_save() 34 :return: Current value :rtype: int """ return self.value def load(self, value: int) -> None: """ Load serialized value >>> my_color = Color() >>> my_color.load(True) >>> my_color.get() True :param int value: Value to load """ if not self.check_value(value): raise ValueError("Attempt to load incompatible value.") self.value = value def __repr__(self): return f'' ./config/config_types/dict.py0000644000000000000000000001140414321742372015151 0ustar rootrootimport typing from .base_type import BaseType class Dict(BaseType): #: :class:`typing.Type` [:class:`BaseType`]: Type for key type_key: typing.Type[BaseType] #: :class:`typing.Type` [:class:`BaseType`]: Type for value type_value: typing.Type[BaseType] def __init__(self, type_key: typing.Type[BaseType], type_value: typing.Type[BaseType]): """ Config type for dictionnary :Basic usage: >>> from config.config_types import factory, Int, Float >>> Dict(factory(Int), factory(Float)) : > object with value None> :param typing.Type[BaseType] type_key: Type of keys :param typing.Type[BaseType] type_value: Type of values """ self.type_key = type_key self.type_value = type_value self.values = None def check_value(self, value: typing.Dict[typing.Any, typing.Any]) -> bool: """ Check if value is good :Basic usage: >>> from config.config_types import factory, Int, Float >>> my_dict = Dict(factory(Int), factory(Float)) >>> my_dict.check_value("ere") False >>> my_dict.check_value(23) False >>> my_dict.check_value({23:0.75}) True >>> my_dict.check_value({"er":0.75}) False >>> my_dict.check_value({34:"er"}) False :param typing.Dict[typing.Any, typing.Any] value: Value to check :return: True if value is correct :rtype: bool """ o_key = self.type_key() o_value = self.type_value() if type(value) == dict: for k, v in value.items(): if not (o_key.check_value(k) and o_value.check_value(v)): return False return True return False def set(self, value: typing.Dict[typing.Any, typing.Any]) -> None: """ Set value :Basic usage: >>> from config.config_types import factory, Int, Float >>> my_dict = Dict(factory(Int), factory(Float)) >>> my_dict.set({34: 0.75}) >>> my_dict.set("error") # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ValueError: ... :raise ValueError: if attempt to set invalid value :param typing.Dict[typing.Any, typing.Any] value: Value to set """ new_dict = dict() if not self.check_value(value): raise ValueError("Attempt to set incompatible value.") for k, v in value.items(): new_key = self.type_key() new_key.set(k) new_value = self.type_value() new_value.set(v) new_dict.update({new_key: new_value}) self.values = new_dict def get(self) -> typing.Dict[typing.Any, typing.Any]: """ Get value :Basic usage: >>> from config.config_types import factory, Int, Float >>> my_dict = Dict(factory(Int), factory(Float)) >>> my_dict.set({34: 0.75}) >>> my_dict.get() {34: 0.75} :return: Current value :rtype: typing.Dict[typing.Any, typing.Any] """ if self.values is not None: return {k.get(): v.get() for k, v in self.values.items()} return dict() def to_save(self) -> typing.List[typing.List[typing.Any]]: """ Build a serializable data to save >>> from config.config_types import factory, Int, Float >>> my_dict = Dict(factory(Int), factory(Float)) >>> my_dict.set({34: 0.75}) >>> my_dict.to_save() [[34, 0.75]] :return: Dict as list of key, value tuples :rtype: typing.List[typing.List[typing.Any]] """ # Construction d'une liste de liste: [[key, value], ...] if self.values is not None: return [[k.to_save(), v.to_save()] for k, v in self.values.items()] return list() def load(self, value: typing.List[typing.List[typing.Any]]) -> None: """ Load value from saved data :Basic usage: >>> from config.config_types import factory, Int, Float >>> my_dict = Dict(factory(Int), factory(Float)) >>> my_dict.load([[34, 0.75]]) >>> my_dict.get() {34: 0.75} :param typing.List[typing.List[typing.Any]] value: """ new_values = dict() for v in value: new_key = self.type_key() new_key.load(v[0]) new_value = self.type_value() new_value.load(v[1]) new_values.update({new_key: new_value}) self.values = new_values def __repr__(self): return f' object with value {self.values}>' ./config/config_types/float.py0000644000000000000000000001014514321742372015334 0ustar rootrootimport typing from .base_type import BaseType class Float(BaseType): #: Max value for parameter max: typing.Optional[float] #: Min value for parameter min: typing.Optional[float] #: Current value of parameter value: typing.Optional[float] def __init__(self, min: typing.Optional[float] = None, max: typing.Optional[float] = None) -> None: """ Base Float type for config :Basic usage: >>> Float() >>> Float(min=0) >>> Float(max=0) >>> Float(min=10, max=20) :param float min: Minimal value for parameter :param float max: Maximal value for parameter """ self.value = None self.min = min self.max = max def check_value(self, value: float) -> bool: """ Check if value is a correct int Check if value is int, and if applicable, between ``min`` and ``max`` or in ``values`` :Basic usage: >>> positive = Float(min=0) >>> negative = Float(max=0) >>> ten_to_twenty = Float(min=10, max=20) >>> positive.check_value(0) True >>> positive.check_value(-2.143) False >>> positive.check_value(345.124) True >>> negative.check_value(0) True >>> negative.check_value(-2.1324) True >>> negative.check_value(345.124) False >>> ten_to_twenty.check_value(10) True >>> ten_to_twenty.check_value(-2.1234) False >>> ten_to_twenty.check_value(13.34) True >>> ten_to_twenty.check_value(20) True >>> ten_to_twenty.check_value(23.34) False :param float value: value to check :return: True if value is correct :rtype: bool """ try: float(value) except ValueError: return False # Check min/max if self.min is not None and float(value) < self.min: return False if self.max is not None and float(value) > self.max: return False return True def set(self, value: float) -> None: """ Set value of parameter :Basic usage: >>> my_float = Float(min=0) >>> my_float.set(34.324) >>> my_float.set(-34.32412) # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ValueError: ... :raise ValueError: if attempt to set invalid value :param float value: Value to set """ if not self.check_value(value): raise ValueError("Attempt to set incompatible value.") self.value = float(value) def get(self) -> float: """ Get value of parameter :Basic usage: >>> my_float = Float() >>> my_float.set(-3/4) >>> my_float.get() -0.75 :return: Value of parameter :rtype: float """ return self.value def to_save(self) -> float: """ Build a serializable object :Basic usage: >>> my_float = Float() >>> my_float.to_save() >>> my_float.set(3/4) >>> my_float.to_save() 0.75 :return: Current value :rtype: float """ return self.value def load(self, value: float): """ Load serialized value >>> my_float = Float() >>> my_float.load(3/4) >>> my_float.get() 0.75 :param float value: Value to load """ if not self.check_value(value): raise ValueError("Attempt to load incompatible value.") self.value = value def __repr__(self): if self.min is not None or self.max is not None: return f'' return f'' ./config/config_types/int.py0000644000000000000000000001255314321742372015026 0ustar rootrootimport typing from .base_type import BaseType class Int(BaseType): #: :class:`typing.Optional` [:class:`int`]: Max value for parameter max: typing.Optional[int] #: :class:`typing.Optional` [:class:`int`]: Min value for parameter min: typing.Optional[int] #: :class:`typing.Optional` [:class:`typing.List` [:class:`int`]]: List of valid values for parameter values: typing.Optional[typing.List[int]] #: :class:`typing.Optional` [:class:`int`] Current value of parameter value: typing.Optional[int] def __init__(self, min: typing.Optional[int] = None, max: typing.Optional[int] = None, values: typing.Optional[typing.List[int]] = None) -> None: """ Base Int type for config :Basic usage: >>> Int() >>> Int(min=0) >>> Int(max=0) >>> Int(min=10, max=20) >>> Int(values=[2, 3, 5, 7]) >>> Int(min=0, values=[3, 4, 5]) # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ValueError: ... :raise ValueError: If min and/or max are set when using values :param typing.Optional[int] min: Min value for this parameter :param typing.Optional[int] max: Max value for this parameter :param typing.Optional[typing.List[int]] values: This parameter can only be in one of these values (raise ValueError if min or max are set with values) """ self.value = None if values is not None and (min is not None or max is not None): raise ValueError("Il n'est pas possible de définir un champ avec à " "la fois un max/min et une série de valeur") self.values = values self.min = min self.max = max def check_value(self, value: int) -> bool: """ Check if value is a correct int Check if value is int, and if applicable, between ``min`` and ``max`` or in ``values`` :Basic usage: >>> positive = Int(min=0) >>> negative = Int(max=0) >>> ten_to_twenty = Int(min=10, max=20) >>> prime = Int(values=[2,3,5,7]) >>> positive.check_value(0) True >>> positive.check_value(-2) False >>> positive.check_value(345) True >>> negative.check_value(0) True >>> negative.check_value(-2) True >>> negative.check_value(345) False >>> ten_to_twenty.check_value(10) True >>> ten_to_twenty.check_value(-2) False >>> ten_to_twenty.check_value(20) True >>> prime.check_value(2) True >>> prime.check_value(4) False >>> prime.check_value(5) True :param int value: value to check :return bool: True if value is correct """ try: int(value) except ValueError: return False # Check min/max if self.min is not None and int(value) < self.min: return False if self.max is not None and int(value) > self.max: return False # Check validity if self.values is not None and value not in self.values: return False return True def set(self, value: int) -> None: """ Set value of parameter :Basic usage: >>> my_int = Int(min=0) >>> my_int.set(34) >>> my_int.set(-34) # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ValueError: ... :raise ValueError: if attempt to set invalid value :param int value: Value to set """ if not self.check_value(value): raise ValueError("Attempt to set incompatible value.") self.value = int(value) def get(self) -> typing.Optional[int]: """ Get value of parameter :Basic usage: >>> my_int = Int() >>> my_int.set(34) >>> my_int.get() 34 :return: Value of parameter :rtype: Optional[int] """ return self.value def to_save(self) -> int: """ Build a serializable object :Basic usage: >>> my_int = Int() >>> my_int.to_save() >>> my_int.set(34) >>> my_int.to_save() 34 :return: Current value :rtype: int """ return self.value def load(self, value: int) -> None: """ Load serialized value >>> my_int = Int() >>> my_int.load(34) >>> my_int.get() 34 :param int value: Value to load """ if not self.check_value(value): raise ValueError("Attempt to load incompatible value.") self.value = value def __repr__(self): if self.min is not None or self.max is not None: return f'' if self.values: return f'' return f'' ./config/config_types/list.py0000644000000000000000000000770614321742372015213 0ustar rootrootimport typing from .base_type import BaseType class List(BaseType): #: :class:`typing.List` [:class:`BaseType`]: Current list of value values: typing.List[BaseType] #: :class:`typing.Type` [:class:`BaseType`]: Type of values type_: typing.Type[BaseType] def __init__(self, type_: typing.Type[BaseType]) -> None: """ Base List type for config :Basic usage: >>> from config.config_types import factory, Int, Float >>> List(factory(Int)) objects with values []> >>> List(factory(Float)) objects with values []> :param typing.Type[BaseType] type_: Type of items """ self.type_ = type_ self.values = [] def check_value(self, value: typing.List[typing.Any]) -> bool: """ Check if value is correct :Basic usage: >>> from config.config_types import factory, Int >>> my_list = List(factory(Int)) >>> my_list.check_value([34,]) True >>> my_list.check_value(345) False >>> my_list.check_value([345, 34, 23, 45, 34, 46, 35, 2345, 'rt']) False :param typing.List[typing.Any] value: Value to check :return: True if value is correct :rtype: bool """ new_object = self.type_() try: for v in value: if not new_object.check_value(v): return False except TypeError: return False return True def set(self, value: typing.List[typing.Any]) -> None: """ Set value of parameter :Basic usage: >>> from config.config_types import factory, Int >>> my_list = List(factory(Int)) >>> my_list.set(34) # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ValueError: ... >>> my_list.set([45,]) :param typing.List[typing.Any] value: Value to set """ if not self.check_value(value): raise ValueError('Attempt to set incompatible value.') new_liste = [] for v in value: new_element = self.type_() new_element.set(v) new_liste.append(new_element) self.values = new_liste def get(self) -> typing.List[typing.Any]: """ Get value of parameter :Basic usage: >>> from config.config_types import factory, Int >>> my_list = List(factory(Int)) >>> my_list.set([34, ]) >>> my_list.get() [34] :raise ValueError: If config is empty :return: Value of parameter :rtype: typing.List[typing.Any] """ return [v.get() for v in self.values] def to_save(self) -> typing.List[typing.Any]: """ Build a serializable object :Basic usage: >>> from config.config_types import factory, Int >>> my_list = List(factory(Int)) >>> my_list.to_save() [] >>> my_list.set([34, ]) >>> my_list.to_save() [34] :return: Current value :rtype: typing.List[typing.Any] """ return [v.to_save() for v in self.values] def load(self, value: typing.List[typing.Any]) -> None: """ Load serialized value >>> from config.config_types import factory, Int >>> my_list = List(factory(Int)) >>> my_list.load([34,]) >>> my_list.get() [34] :param typing.List[typing.Any] value: Value to load """ if not self.check_value(value): raise ValueError("Attempt to load incompatible value.") for v in value: new_object = self.type_() new_object.load(v) self.values.append(new_object) def __repr__(self): return f'' ./config/config_types/str.py0000644000000000000000000000442514321742372015043 0ustar rootrootfrom .base_type import BaseType class Str(BaseType): value: str def __init__(self) -> None: """ Base Str type for config :Basic usage: >>> Str() """ self.value = "" def check_value(self, value: str) -> bool: """ Check if value is usable as str :Basic usage: >>> my_str = Str() >>> my_str.check_value("toto") True >>> my_str.check_value(45) True :param str value: Value to test :return: True if value is usable as str """ try: str(value) except ValueError: return False return True def set(self, value: str) -> None: """ Set value of parameter :Basic usage: >>> my_str = Str() >>> my_str.set("e") >>> my_str.set(34) :raise ValueError: if attempt to set invalid value :param str value: Value to set :return: None """ if not self.check_value(value): raise ValueError("Attempt to set incompatible value.") self.value = str(value) def get(self) -> str: """ Get value of parameter :Basic usage: >>> my_str = Str() >>> my_str.set(34) >>> print(my_str.get()) 34 >>> my_str.set("Hey") >>> print(my_str.get()) Hey :return: Value of parameter """ return self.value def to_save(self) -> str: """ Build a serializable data to save :Basic usage: >>> my_str = Str() >>> my_str.set(34) >>> my_str.to_save() '34' :todo: Vérifier que l'utf8 casse pas tout :return: Current string content :rtype: str """ return self.value def load(self, value: str) -> None: """ Load value :Basic usage: >>> my_str = Str() >>> my_str.load("34") >>> my_str.get() '34' """ if not self.check_value(value): raise ValueError("Attempt to load incompatible value.") self.value = value def __repr__(self): return f'' ./config/__init__.py0000644000000000000000000000013214321742372013270 0ustar rootrootfrom . import config_types from .base import Config __all__ = ["Config", "config_types"] ./config/base.py0000644000000000000000000000757414321742372012464 0ustar rootrootfrom __future__ import annotations import os import typing import toml BaseType = typing.TypeVar("BaseType") class Config: #: :class:`str`: Path of config file path: str #: :class:`typing.Type` [:class:`BaseType`]: Current fields fields: typing.Dict[str, BaseType] def __init__(self, path: typing.Optional[str]) -> None: """ Create config object Basic usage: >>> config = Config("doctest_config.toml") :param str path: Path of config file """ self.fields = {} self.path = path def register(self, name: str, type_: typing.Type[BaseType]) -> None: """ Register option Basic usage: >>> from config.config_types import factory, Int >>> config = Config("doctest_config.toml") >>> config.register("my_parameter", factory(Int)) :param str name: Name of config parameter :param typing.Type[BaseType] type_: Type of config parameter """ self.fields.update({ name: type_() }) def set(self, values: dict, no_save: bool = False) -> None: """ Set all parameters with values (and override old ones) Basic usage: >>> from config.config_types import factory, Int >>> config = Config("doctest_config.toml") >>> config.register("my_parameter", factory(Int)) >>> config.set({"my_parameter": 3}) #doctest: +SKIP >>> config.set({"my_parameter": 4}, no_save=True) :type values: dict :param values: dict of parameters """ for k, v in values.items(): try: self.fields[k].set(v) except KeyError: # TODO: trouver un moyen de warn pass if not no_save: self.save() def save(self) -> None: """ Save config to ``self.file`` Basic usage: >>> from config.config_types import factory, Int >>> config = Config("doctest_config.toml") >>> config.register("my_parameter", factory(Int)) >>> config.set({"my_parameter": 3}) #doctest: +SKIP >>> config.save() #doctest: +SKIP """ if self.path is not None: os.makedirs(os.path.dirname(self.path), exist_ok=True) with open(self.path, 'w') as file: toml.dump({k: v.to_save() for k, v in self.fields.items()}, file) def load(self) -> None: """ Load config from ``self.file`` Basic usage: >>> from config.config_types import factory, Int >>> config = Config("doctest_config.toml") >>> config.register("my_parameter", factory(Int)) >>> config.set({"my_parameter": 3}) #doctest: +SKIP >>> config.save() #doctest: +SKIP >>> new_config = Config("doctest_config.toml") >>> new_config.register("my_parameter", factory(Int)) >>> new_config.load() #doctest: +SKIP >>> new_config["my_parameter"] #doctest: +SKIP 3 :return: None """ if self.path is not None: try: with open(self.path, 'r') as file: self.set(toml.load(file)) except FileNotFoundError: pass self.save() def __getitem__(self, item: str) -> typing.Any: """ Get field from config :param str item: Config field to get Basic usage: >>> from config.config_types import factory, Int >>> config = Config("doctest_config.toml") >>> config.register("my_parameter", factory(Int)) >>> config.set({"my_parameter": 3}) #doctest: +SKIP >>> print(config["my_parameter"]) #doctest: +SKIP 3 """ self.load() return self.fields[item].get() def __str__(self): return f">" ./config/log_config.json0000644000000000000000000000254414321742372014171 0ustar rootroot{ "version": 1, "disable_existing_loggers": false, "formatters": { "simple": { "format": "%(asctime)s :: %(name)s :: %(levelname)s :: %(message)s" } }, "handlers": { "console": { "class": "logging.StreamHandler", "level": "DEBUG", "formatter": "simple", "stream": "ext://sys.stdout" }, "info_file_handler": { "class": "logging.handlers.RotatingFileHandler", "level": "INFO", "formatter": "simple", "filename": "info.log", "maxBytes": 1048576, "backupCount": 20, "encoding": "utf8" }, "error_file_handler": { "class": "logging.handlers.RotatingFileHandler", "level": "ERROR", "formatter": "simple", "filename": "errors.log", "maxBytes": 1048576, "backupCount": 20, "encoding": "utf8" } }, "loggers": { "discord": { "level":"ERROR", "handlers":["console", "info_file_handler", "error_file_handler"] }, "bot-base": { "level":"DEBUG", "handlers":["console", "info_file_handler", "error_file_handler"] } }, "root": { "level": "INFO", "handlers": [] } }./storage/0000755000000000000000000000000014321742372011362 5ustar rootroot./storage/__init__.py0000644000000000000000000000014014321742372013466 0ustar rootrootfrom .jsonencoder import Encoder from .objects import Objects __all__ = ["Objects", "Encoder"] ./storage/jsonencoder.py0000644000000000000000000000253514321742372014252 0ustar rootrootimport datetime import json data_type = "__data_type" content = "__content" class Encoder(): def __init__(self, *args, **kwargs): self.custom = {Encoder:(lambda x:x, lambda x:x)} self.JSONEncoder.custom = self.custom def register(self, type_, encode, decode): self.custom.update({type_: (encode, decode)}) def hook(self, dct): if data_type in dct: for ty in self.custom.keys(): if str(ty) == dct[data_type]: return self.custom[ty][1](dct[content]) if dct[data_type] == "datetime.datetime": return datetime.datetime.fromisoformat(dct['iso']) elif dct[data_type] == "datetime.timedelta": return datetime.timedelta(seconds=dct['totalseconds']) return dct class JSONEncoder(json.JSONEncoder) : def default(self, obj): if isinstance(obj, tuple(self.custom.keys())): return {data_type: f'{type(obj)}', content: self.custom[type(obj)][0](obj)} if isinstance(obj, (datetime.datetime)): return {data_type: 'datetime.datetime', 'iso': obj.isoformat()} if isinstance(obj, (datetime.timedelta)): return {data_type: 'datetime.timedelta', 'totalseconds': obj.total_seconds()} return json.JSONEncoder.default(self, obj) ./storage/objects.py0000644000000000000000000000173714321742372013375 0ustar rootrootimport json import os from . import jsonencoder class Objects: def __init__(self, path: str): self.path = os.path.abspath(path) os.makedirs(os.path.join(self.path, "objects"), exist_ok=True) self.encoder = jsonencoder.Encoder() def save_object(self, object_name, object_instance): """Save object into json file""" with open(os.path.join(self.path, "objects", object_name + ".json"), "w") as file: json.dump(object_instance, file, cls=self.encoder.JSONEncoder) def load_object(self, object_name): """Load object from json file""" if self.save_exists(object_name): with open(os.path.join(self.path, "objects", object_name + ".json"), "r") as f: return json.load(f, object_hook=self.encoder.hook) def save_exists(self, object_name): """Check if json file exists""" return os.access(os.path.join(self.path, "objects", object_name + ".json"), os.R_OK | os.W_OK) ./utils/0000755000000000000000000000000014321742372011056 5ustar rootroot./utils/__init__.py0000644000000000000000000000005314321742372013165 0ustar rootrootfrom . import emojis __all__ = ["emojis"] ./utils/emojis.py0000644000000000000000000000164714321742372012726 0ustar rootrootfrom typing import Union NUMBERS = ["\u0030\u20e3", "\u0031\u20e3", "\u0032\u20e3", "\u0033\u20e3", "\u0034\u20e3", "\u0035\u20e3", "\u0036\u20e3", "\u0037\u20e3", "\u0038\u20e3", "\u0039\u20e3", "\U0001f51f"] MINUS = "\u2796" THUMBS_UP = "\U0001f44d" THUMBS_DOWN = "\U0001f44e" WHITE_CHECK_MARK = "\u2705" def write_with_number(i: Union[int, float]): """ Write number with emoji :Basic usage: >>> write_with_number(23) '2⃣3⃣' >>> write_with_number(-23) '➖2⃣3⃣' >>> write_with_number(-23.34) '➖2⃣3⃣.3⃣4⃣' >>> write_with_number(-1234567890.098) '➖1⃣2⃣3⃣4⃣5⃣6⃣7⃣8⃣9⃣0⃣.0⃣9⃣8⃣' :param i: number to write :return: string with emojis """ s = "" for c in str(i): if c == ".": s += "." elif c == "-": s += MINUS else: s += NUMBERS[int(c)] return s ./errors.py0000644000000000000000000000032214321742372011601 0ustar rootrootclass BotBaseException(Exception): pass class ModuleException(BotBaseException): pass class ModuleNotFoundError(ModuleException): pass class IncompatibleModuleError(ModuleException): pass ./main.py0000644000000000000000000000170514321742372011217 0ustar rootroot#!/usr/bin/python3 import asyncio import json import logging import os from bot_base.bot_base import BotBase def setup_logging(default_path='data/log_config.json', default_level=logging.INFO, env_key='BOT_BASE_LOG_CONFIG'): """Setup logging configuration """ path = default_path value = os.getenv(env_key, None) if value: path = value if os.path.exists(path): with open(path, 'rt') as f: config = json.load(f) logging.config.dictConfig(config) else: logging.basicConfig(level=default_level) def main(): setup_logging() client = BotBase(max_messages=500000, data_folder="datas", modules_folder=os.environ.get("LOCAL_MODULES", "modules")) async def start_bot(): await client.start(os.environ.get("DISCORD_TOKEN")) loop = asyncio.get_event_loop() loop.create_task(start_bot()) loop.run_forever() if __name__ == "__main__": main() ./requirements.txt0000644000000000000000000000042114321742420013171 0ustar rootroot-i https://pypi.org/simple aiohttp==3.6.2 async-timeout==3.0.1 attrs==19.3.0 cffi==1.14.0 chardet==3.0.4 discord.py[voice]==1.3.3 idna==2.9 multidict==4.7.5 packaging==20.3 pycparser==2.20 pynacl==1.3.0 pyparsing==2.4.7 six==1.14.0 toml==0.10.0 websockets==8.1 yarl==1.4.2