./0000755000000000000000000000000014047436332007717 5ustar rootroot./bot_base/0000755000000000000000000000000014047252066011475 5ustar rootroot./bot_base/__init__.py0000644000000000000000000000001714047252066013604 0ustar rootrootimport bot_base./bot_base/bot_base.py0000644000000000000000000002505114047252066013630 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/0000755000000000000000000000000014047252066011164 5ustar rootroot./config/config_types/0000755000000000000000000000000014047252066013655 5ustar rootroot./config/config_types/discord_types/0000755000000000000000000000000014047252066016530 5ustar rootroot./config/config_types/discord_types/__init__.py0000644000000000000000000000042714047252066020644 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.py0000644000000000000000000001134614047252066020517 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.py0000644000000000000000000001105214047252066020205 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.py0000644000000000000000000001100014047252066020033 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.py0000644000000000000000000001100014047252066020050 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__.py0000644000000000000000000000227114047252066015770 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.py0000644000000000000000000000060314047252066016201 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.py0000644000000000000000000000540014047252066015161 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.py0000644000000000000000000000520114047252066015343 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.py0000644000000000000000000001140414047252066015152 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.py0000644000000000000000000001014514047252066015335 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.py0000644000000000000000000001255314047252066015027 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.py0000644000000000000000000000770614047252066015214 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.py0000644000000000000000000000442514047252066015044 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__.py0000644000000000000000000000013214047252066013271 0ustar rootrootfrom . import config_types from .base import Config __all__ = ["Config", "config_types"] ./config/base.py0000644000000000000000000000757414047252066012465 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.json0000644000000000000000000000254414047252066014172 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/0000755000000000000000000000000014047252066011363 5ustar rootroot./storage/__init__.py0000644000000000000000000000014014047252066013467 0ustar rootrootfrom .jsonencoder import Encoder from .objects import Objects __all__ = ["Objects", "Encoder"] ./storage/jsonencoder.py0000644000000000000000000000253514047252066014253 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.py0000644000000000000000000000173714047252066013376 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/0000755000000000000000000000000014047252066011057 5ustar rootroot./utils/__init__.py0000644000000000000000000000005314047252066013166 0ustar rootrootfrom . import emojis __all__ = ["emojis"] ./utils/emojis.py0000644000000000000000000000164714047252066012727 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.py0000644000000000000000000000032214047252066011602 0ustar rootrootclass BotBaseException(Exception): pass class ModuleException(BotBaseException): pass class ModuleNotFoundError(ModuleException): pass class IncompatibleModuleError(ModuleException): pass ./main.py0000644000000000000000000000170514047252066011220 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.txt0000644000000000000000000000042114047436333013201 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