./0000755000000000000000000000000014321743523007715 5ustar rootroot./bot_base/0000755000000000000000000000000014321743510011467 5ustar rootroot./bot_base/__init__.py0000644000000000000000000000001714321743510013576 0ustar rootrootimport bot_base./bot_base/bot_base.py0000644000000000000000000000464614321743510013631 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 bot_base.modules import ModuleManager from config import Config, config_types from config.config_types import factory import errors __version__ = "0.2.0" 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 # Setup logging self.log = logging.getLogger('bot_base') # Setup config self.configs = {} self.config = Config(path=os.path.join(data_folder, "config.toml")) self.config.register("data_folder", factory(config_types.Str)) self.config.set({ "data_folder": data_folder, }, no_save=True) self.config.load() self.modules = ModuleManager(self) async def on_ready(self): self.info("Bot ready.") self.modules.load_modules() def dispatch(self, event, *args, **kwargs): """Dispatch event""" super().dispatch(event, *args, **kwargs) for module in self.modules: 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): path = os.path.join(self.config["data_folder"], path) config = self.configs.get(path) or Config(path=path) self.configs.update({ path: config }) return config ./bot_base/modules.py0000644000000000000000000001103414321743510013510 0ustar rootrootimport importlib import os import sys import toml from packaging.specifiers import SpecifierSet import errors from config import config_types from config.base import BaseType from config.config_types import factory import typing MINIMAL_INFOS = ["version", "bot_version"] __version__ = "0.2.0" class Dependency: def __init__(self, name, version): self.name = name self.version = version class Module: def __init__(self, module_manager, name): self.name = name self.module_manager = module_manager self.__infos = None self.__path = os.path.join(self.module_manager.config["modules_folder"], name) self.__module = None self.__class = None self.__dispatch = lambda *x, **y: None def dispatch(self, *args, **kwargs): return self.__dispatch(*args, **kwargs) @property def version(self): """Get version of module""" return self.infos.get("version") @property def exists(self): """Check if module exists""" return os.path.isdir(self.__path) @property def has_infos(self): """Check if module contains all necessary files""" if not self.exists: raise errors.ModuleNotFoundError(f"Module {self.name} not found here: {self.__path}.") return os.path.isfile(os.path.join(self.__path, "infos.toml")) @property def infos(self): if not self.has_infos: raise errors.IncompatibleModuleError(f"Module {self.name} doesn't have infos.toml.") if not self.__infos: with open(os.path.join(self.__path, "infos.toml")) as f: self.__infos = toml.load(f) return self.__infos @property def has_all_infos(self): """Check if all required infos are in infos.toml""" for key in MINIMAL_INFOS: if key not in self.infos.keys(): return False return True @property def is_compatible_with_client(self): """Check if module is compatible with bot version""" bot_version_specifier = SpecifierSet(self.infos["bot_version"]) return __version__ in bot_version_specifier @property def is_metamodule(self): """Check if module is metamodule""" return self.infos.get("metamodule", False) @property def deps(self): deps = [] for dep, version in self.infos.get("dependencies", dict()).items(): deps.append(Dependency(dep, SpecifierSet(version))) return deps def load(self): self.__module = importlib.import_module(self.name) if not self.is_metamodule: try: # Try creating instance with client self.__class = self.__module.__main_class__(self.module_manager.client) except TypeError: self.__class = self.__module.__main_class__() self.__dispatch = self.__class.__dispatch__ class ModuleManager: def __init__(self, client): self.client = client self.modules = dict() self.dispatch_modules = dict() self.config = self.client.get_config("modules.toml") self.config.register("modules_folder", factory(config_types.Str)) self.config.register("enabled_modules", factory(config_types.List, factory(config_types.Str))) self.config.set({ "modules_folder": os.environ.get("LOCAL_MODULES", "modules"), "enabled_modules": [] }, no_save=True) self.config.load() sys.path.insert(0, self.config["modules_folder"]) def load_module(self, name, version=None): if name in self.modules.keys(): return new_module = Module(self, name) if version is not None and new_module.version not in version: raise errors.MissingDependency(f"Incompatible version for dependency {name}: {new_module.version}, require {version}.") for dep in new_module.deps: self.load_module(dep.name, version=dep.version) new_module.load() self.modules.update({name: new_module}) if not new_module.is_metamodule: self.dispatch_modules.update({name: new_module}) return if version is None and name not in self.modules["enabled_modules"]: self.config.set({"enabled_modules": self.config["enabled_modules"] + [name]}) self.config.save() def load_modules(self): for module in self.config["enabled_modules"]: self.load_module(module) def __iter__(self): return self.dispatch_modules.values().__iter__() ./config/0000755000000000000000000000000014321743510011156 5ustar rootroot./config/config_types/0000755000000000000000000000000014321743510013647 5ustar rootroot./config/config_types/discord_types/0000755000000000000000000000000014321743510016522 5ustar rootroot./config/config_types/discord_types/__init__.py0000644000000000000000000000042714321743510020636 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.py0000644000000000000000000001134614321743510020511 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.py0000644000000000000000000001105214321743510020177 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.py0000644000000000000000000001100014321743510020025 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.py0000644000000000000000000001100014321743510020042 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__.py0000644000000000000000000000226414321743510015764 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 ``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.py0000644000000000000000000000060314321743510016173 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.py0000644000000000000000000000540014321743510015153 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.py0000644000000000000000000000520114321743510015335 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.py0000644000000000000000000001140414321743510015144 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.py0000644000000000000000000001014514321743510015327 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.py0000644000000000000000000001255314321743510015021 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.py0000644000000000000000000000770614321743510015206 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.py0000644000000000000000000000437714321743510015044 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 """ 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__.py0000644000000000000000000000013214321743510013263 0ustar rootrootfrom . import config_types from .base import Config __all__ = ["Config", "config_types"] ./config/base.py0000644000000000000000000000754514321743510012455 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 """ 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.json0000644000000000000000000000254414321743510014164 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/0000755000000000000000000000000014321743510011355 5ustar rootroot./storage/__init__.py0000644000000000000000000000014014321743510013461 0ustar rootrootfrom .jsonencoder import Encoder from .objects import Objects __all__ = ["Objects", "Encoder"] ./storage/jsonencoder.py0000644000000000000000000000253514321743510014245 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.py0000644000000000000000000000173714321743510013370 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/0000755000000000000000000000000014321743510011051 5ustar rootroot./utils/__init__.py0000644000000000000000000000005314321743510013160 0ustar rootrootfrom . import emojis __all__ = ["emojis"] ./utils/emojis.py0000644000000000000000000000164714321743510012721 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.py0000644000000000000000000000040714321743510011600 0ustar rootrootclass BotBaseException(Exception): pass class ModuleException(BotBaseException): pass class ModuleNotFoundError(ModuleException): pass class IncompatibleModuleError(ModuleException): pass class MissingDependency(ModuleException): pass ./main.py0000644000000000000000000000165314321743510011214 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() print(os.environ.get("LOCAL_MODULES", "modules")) client = BotBase(max_messages=500000, data_folder="datas") 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.txt0000644000000000000000000000141314321743534013202 0ustar rootroot-i https://pypi.org/simple aiohttp==3.6.2; python_full_version >= '3.5.3' async-timeout==3.0.1; python_full_version >= '3.5.3' attrs==19.3.0; python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3' cffi==1.14.0 chardet==3.0.4 discord.py[voice]==1.3.3 idna==2.9; python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3' multidict==4.7.6; python_version >= '3.5' packaging==20.4 pycparser==2.20; python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3' pynacl==1.3.0 pyparsing==2.4.7; python_version >= '2.6' and python_version not in '3.0, 3.1, 3.2, 3.3' six==1.15.0; python_version >= '2.7' and python_version not in '3.0, 3.1, 3.2, 3.3' toml==0.10.1 websockets==8.1; python_full_version >= '3.6.1' yarl==1.4.2; python_version >= '3.5'