PycordViews 1.1.3__py3-none-any.whl → 1.2.0__py3-none-any.whl

pycordViews/__init__.py

@@ -1,5 +1,5 @@
-from .typeViews import *
 from .views.easy_modified_view import EasyModifiedViews
 from .pagination.pagination_view import Pagination
-from .multibot.start_multibot import Multibot
+from .multibot import Multibot
 from .menu.selectMenu import SelectMenu
+from .menu.menu import Menu, CustomSelect

pycordViews/menu/__init__.py

@@ -1,3 +1,3 @@
 from .selectMenu import SelectMenu
-from .menu import Menu
+from .menu import Menu, CustomSelect
 from .errors import *

pycordViews/menu/menu.py

@@ -1,6 +1,6 @@
 from discord.components import ComponentType
-from discord.ui import Select
-from discord import MISSING, Emoji, PartialEmoji
+from discord.ui import Select, Item
+from discord import MISSING, Emoji, PartialEmoji, Interaction
 from typing import Callable, Union
 
 from .errors import NotCoroutineError, ComponentTypeError
@@ -12,12 +12,14 @@ class Menu:
         """
         A basic menu from selectMenu class
         """
-        self.__menu: Select = Select(select_type=menu_type, **kwargs)
+        self.__menu: CustomSelect = CustomSelect(menu=self, select_type=menu_type, **kwargs)
         self.__selectMenu = selectmenu
+        self.__menu_type: ComponentType = menu_type
 
-    def set_callable(self, _callable: Callable) -> "Menu":
+    def set_callable(self, _callable: Union[Callable, None]) -> "Menu":
         """
-        Add a coroutine to the menu
+        Add a coroutine to the menu (same function on SelectMenu class)
+        This coroutine can have 2 parameters (X, interaction)
         """
         if not isinstance(_callable, Callable):
             raise NotCoroutineError(_callable)
@@ -30,28 +32,87 @@ class Menu:
         Add an option to choice.
         Only from string_select type !
         """
-        if self.__menu.type != ComponentType.string_select:
-            raise ComponentTypeError()
+        self.__is_string_select()
 
         self.__menu.add_option(label=label, value=value, description=description, emoji=emoji, default=default)
         return self
 
+    def remove_options(self, *labels: str) -> "Menu":
+        """
+        Remove an option to choice.
+        Only from string_select type !
+        :param labels: Label option name to delete
+        """
+        self.__is_string_select()
+
+        self.__menu.options = [i for i in self.__menu.options if i.label not in labels]
+        return self
+
+    def update_option(self, current_label: str, new_label: str = None, value: str = None, description: Union[str, None] = None, emoji: Union[str, Emoji, PartialEmoji, None] = None, default: Union[bool, None] = None) -> "Menu":
+        """
+        Update option. To find the option, write her actual label in "current_label" option.
+        Only from string_select type !
+        :param current_label: The current label option to edit
+        """
+        self.__is_string_select()
+
+        for option in self.__menu.options:
+            if option.label == current_label:
+                option.label = new_label if new_label is not None else option.label
+                option.value = value if value is not None else option.value
+                option.description = description if description is not None else option.description
+                option.default = default if default is not None else option.default
+                option.emoji = emoji if emoji is not None else option.emoji
+                break
+        return self
+
+    def __is_string_select(self) -> None:
+        """
+        Check if the menu is a string_select
+        :raise: ComponentTypeError
+        """
+        if self.__menu.type != ComponentType.string_select:
+            raise ComponentTypeError()
+
     @property
-    def component(self) -> Select:
+    def component(self) -> "CustomSelect":
         """
         Get the component
         """
         return self.__menu
 
+    @property
+    def selectmenu(self) -> "SelectMenu":
+        """
+        Get the selectMenu
+        """
+        return self.__selectMenu
+
     @property
     def callable(self) -> Callable:
         """
-        Get the callable link to the menu
+        Get the current callable menu
         """
-        return self.__callable
+        return self.__selectMenu.get_callable(self.__menu.custom_id)
 
-    @callable.setter
-    def callable(self, _callable: Callable):
+class CustomSelect(Select):
+    """
+    Subclass of Select discord Class to use some SelectMenu functions
+    """
+
+    def __init__(self, menu: Menu, select_type: ComponentType, *items: Item, **kwargs):
+        super().__init__(select_type=select_type, *items, **kwargs)
+        self.__menu: Menu = menu
+
+    async def update(self):
+        """
+        Bridge to SelectMenu update function
+        """
+        return await self.__menu.selectmenu.update()
+
+    @property
+    def get_view(self) -> "EasyModifiedViews":
+        """
+        Bridge to SelectMenu get_view property
         """
-        Set the callable link to menu
-        """
+        return self.__menu.selectmenu.get_view

pycordViews/menu/selectMenu.py

@@ -1,9 +1,11 @@
+
 from ..views.easy_modified_view import EasyModifiedViews
 from .menu import Menu
 
 from typing import Union, Callable, Any
 from discord.components import ComponentType
-from discord import ChannelType, Member, TextChannel, ApplicationContext
+from discord import ChannelType, Member, ApplicationContext
+from discord.abc import GuildChannel
 
 class SelectMenu:
     """
@@ -52,9 +54,9 @@ class SelectMenu:
         """
         return self.__global_add_component(ComponentType.role_select, custom_id=custom_id, placeholder=placeholder, max_values=max_values, min_values=min_values, disabled=disabled, row=row)
 
-    def add_mentionnable_select_menu(self, custom_id: str = None, placeholder: str = None, min_values: int = 1, max_values: int = 1, disabled=False, row=None) -> Menu:
+    def add_mentionable_select_menu(self, custom_id: str = None, placeholder: str = None, min_values: int = 1, max_values: int = 1, disabled=False, row=None) -> Menu:
         """
-        Add a role select menu in the ui
+        Add a mentionable select menu in the ui
         :param custom_id: The ID of the select menu that gets received during an interaction. If not given then one is generated for you.
         :param placeholder: The placeholder text that is shown if nothing is selected, if any.
         :param max_values: The maximum number of items that must be chosen for this select menu. Defaults to 1 and must be between 1 and 25.
@@ -66,7 +68,7 @@ class SelectMenu:
 
     def add_channel_select_menu(self, custom_id: str = None, placeholder: str = None, min_values: int = 1, max_values: int = 1, disabled=False, row=None, channel_types: list[ChannelType] = None):
         """
-        Add a role select menu in the ui
+        Add a channel select menu in the ui
         :param custom_id: The ID of the select menu that gets received during an interaction. If not given then one is generated for you.
         :param placeholder: The placeholder text that is shown if nothing is selected, if any.
         :param max_values: The maximum number of items that must be chosen for this select menu. Defaults to 1 and must be between 1 and 25.
@@ -89,7 +91,7 @@ class SelectMenu:
         global function to add a Select component
         """
         menu = Menu(component_type,
-                    self.__select_menu,
+                    self,
                     **{'custom_id': custom_id, 'placeholder': placeholder, 'min_values': min_values,
                        'max_values': max_values, 'disabled': disabled, 'row': row, 'channel_types': channel_types})
 
@@ -97,10 +99,11 @@ class SelectMenu:
 
         return menu
 
-    def set_callable(self, *custom_ids: str, _callable : Callable) -> "SelectMenu":
+    def set_callable(self, *custom_ids: str, _callable: Union[Callable, None]) -> "SelectMenu":
         """
-        Set a callable for the menu associated with the custom_id
-        :param custom_ids: IDs to menus
+        Set a callable for menus associated with custom_ids
+        :param custom_ids: IDs menus
+        :param _callable: The coroutine to set for all menus
         """
         self.__select_menu.set_callable(*custom_ids, _callable=_callable)
         return self
@@ -111,15 +114,32 @@ class SelectMenu:
         """
         return await self.__select_menu.respond(ctx=ctx, *args, view=self.__select_menu, **kwargs)
 
-    async def send(self, target: Union[Member, TextChannel], *args, **kwargs) -> Any:
+    async def send(self, target: Union[Member, GuildChannel], *args, **kwargs) -> Any:
         """
         Send at the target
         """
         return await self.__select_menu.send(target=target, *args, view=self.__select_menu, **kwargs)
 
+    async def update(self):
+        """
+        Update the message.
+        If the command doesn't have been respond, nothing happened.
+        """
+        if self.get_view.message is None:
+            return
+        await self.__select_menu.update_items(*self.get_view.items)
+
+    def get_callable(self, custom_id: str) -> Union[Callable, None]:
+        """
+        Get the callable UI
+        :param custom_id: UI ID
+        """
+        return self.__select_menu.get_callable(custom_id)
+
     @property
     def get_view(self) -> EasyModifiedViews:
         """
         Get the current view
         """
         return self.__select_menu
+

pycordViews/multibot/__init__.py

@@ -1,5 +1 @@
-from .start_multibot import Multibot
-from .errors import *
-from .runner import Runner
-from .process_for_bots import ProcessBot
-from .process_messages import ProcessMessage
+from .multibot import Multibot

pycordViews/multibot/bot.py

@@ -0,0 +1,194 @@
+from threading import Thread
+from discord import Intents, Bot, ApplicationCommand
+from asyncio import run_coroutine_threadsafe, new_event_loop, set_event_loop, Future, AbstractEventLoop, sleep
+from time import sleep as tsleep
+from .errors import BotNotStartedError, SetupCommandFunctionNotFound, CommandFileNotFoundError
+from typing import Optional
+from importlib import reload
+from importlib.util import spec_from_file_location, module_from_spec
+from os import path
+from sys import modules
+
+
+class DiscordBot:
+
+    def __init__(self, token: str, intents: Intents,  command_prefix: Optional[str] = None):
+        self.__token: str = token
+        self.__command_prefix: str = command_prefix
+        self.__running_bot: Future = None
+        self.__loop: AbstractEventLoop = new_event_loop()
+        self.__thread: Thread = Thread(target=self.run_loop, daemon=True)  # Thread pour exécuter l'event loop
+        self.__thread.start()
+        self.__bot: Bot = Bot(loop=self.__loop, intents=intents, command_prefix=command_prefix, help_commad=None, auto_sync_commands=False)
+        self.__intents: Intents = intents
+        self.__imported_module: list[dict[str, ...]] = []
+
+    def run_loop(self):
+        """Lance la boucle asyncio dans un thread séparé."""
+        set_event_loop(self.__loop)
+        self.__loop.run_forever()
+
+    def start(self) -> None:
+        """Démarre le bot"""
+
+        self.__running_bot: Future = run_coroutine_threadsafe(self.__bot.start(token=self.__token, reconnect=True), self.__loop)
+
+    def stop(self) -> None:
+        """
+        Stop le bot proprement depuis un autre thread
+        :raise: BotNotStartedError
+        """
+        if self.is_running:
+            # Attendre que la fermeture du bot soit terminée
+            run_coroutine_threadsafe(self.__stop_bot_in_thread(), self.__loop).result(timeout=30)
+            self.__bot = Bot(token=self.__token, intents=self.__intents, command_prefix=self.__command_prefix, help_command=None)
+            self.__running_bot = None
+        else:
+            raise BotNotStartedError(self.__bot.user.name)
+
+    def add_pyFile_commands(self, file: str, setup_function: str, reload_command: bool):
+        """
+        Ajoute et charge un fichier de commande bot et ses dépendances.
+        Les fichiers doivent avoir une fonction appelée « setup » ou un équivalent passé en paramètre.
+
+        def setup(bot: Bot) :
+            ...
+
+        :param bot_name : Le nom du bot à ajouter au fichier de commandes
+        :param file: Chemin relatif ou absolue du fichier de commande
+        :param setup_function : Nom de la fonction appelée par le processus pour donner l'instance de Bot.
+        :param reload_command : Recharge toutes les commandes dans le fichier et les dépendances. Défaut : True
+        """
+        module_name = path.splitext(path.basename(file))[0] # récupère le nom du fichier
+        spec = spec_from_file_location(module_name, file) # renvoie un "module spec" à partir du nom et du fichier
+        if spec and spec.loader:
+            module = module_from_spec(spec) # crée le package à partir du "module spec" s'il existe
+            spec.loader.exec_module(module) # charge tout le package
+            modules[module_name] = module # enregistre le modul dans les packages du système pour qu'il soit retrouvable lors du rechargement de celui-ci
+            self.__call_setup_function_in_command_file(file, module, setup_function, reload_command)
+        else:
+            raise CommandFileNotFoundError(file)
+
+    def modify_pyFile_commands(self, file: str, setup_function: str):
+        """
+        Modifie un fichier de comandes et le recharge.
+        Ne recharge que le fichier et non les commandes du bot !
+        :param file: Le chemin d'accès relatif ou absolue du fichier
+        """
+        print('ok')
+        module_name = path.splitext(path.basename(file))[0]
+        module_found = False
+
+        # Mise à jour du module et de son setup
+        print(self.__imported_module)
+        for imported in self.__imported_module:
+            print(imported['module'].__name__, module_name)
+            if imported['module'].__name__ == module_name:
+                print('reload module :', module_name)
+                reload(imported['module'])
+                imported['setup_function'] = setup_function
+                module_found = True
+                break
+
+        if not module_found:
+            raise CommandFileNotFoundError(file)
+
+        # Supprimer toutes les commandes du bot
+        for command in self.__bot.application_commands:
+            print('del commande', command.name)
+            self.__bot.remove_application_command(command)
+
+        # Réattacher toutes les commandes en réexécutant tous les setup
+        for imported in self.__imported_module:
+            self.__call_setup_function_in_command_file(
+                file,
+                imported['module'],
+                imported['setup_function'],
+                reload_command=False
+            )
+
+
+    def reload_commands(self, commands: Optional[list[ApplicationCommand]] = None):
+        """
+        Charge toutes les commandes du bot sur Discord
+        """
+        run_coroutine_threadsafe(self.__reload_commands(commands=commands), self.__loop).result(timeout=30)
+
+
+    @property
+    def is_running(self) -> bool:
+        """Renvoie si la Websocket est connectée"""
+        return not self.__bot.is_closed()
+
+    @property
+    def is_ready(self) -> bool:
+        """
+        Renvoie si le bot est ready
+        """
+        return self.__bot.is_ready()
+
+    @property
+    def is_ws_ratelimited(self) -> bool:
+        """
+        Renvoie si le bot est rate limit
+        """
+        return self.__bot.is_ws_ratelimited()
+
+
+    async def __stop_bot_in_thread(self):
+        """
+        Clear le cache du bot de manière asynchrone
+        """
+        await self.__bot.close()
+
+    def close_ascyncio_loop(self):
+        """
+        Ferme la boucle asyncio
+        """
+        if self.__loop.is_running():
+            self.__loop.stop()
+
+        while self.__loop.is_running():
+            tsleep(0.3)
+
+        self.__loop.close()
+
+    async def __reload_commands(self, commands: Optional[list[ApplicationCommand]]):
+        """
+        Recharge les commandes quand le bot est ready
+        """
+        if self.__running_bot is not None:
+            while not self.is_ready:
+                await sleep(0.3)
+            await self.__bot.register_commands(commands=commands, method='individual', force=False)
+        else:
+            raise BotNotStartedError(self.__token)
+
+    def __call_setup_function_in_command_file(self, file: str, module, setup_function: str, reload_command: bool):
+        """
+        Appel la fonction de setup du module pour charger toutes les commandes du bot
+        :param file: Le chemin d'accès du fichier de commandes
+        :param module: Le module préchargé
+        :param setup_function: Le nom de la fonction de setup
+        :param reload_command: Si les commandes doivent être recharger sur le bot (envoie une requête à Discord) automatiquement
+        """
+        if hasattr(module, setup_function):  # si la fonction setup (ou autre) est dans le package
+            getattr(module, setup_function)(self.__bot)
+
+            ########## permet de modifier le dictionnaire des modules importés si celui-ci existe déjà, sinon il l'ajoute à la liste des dictionaires des modules importés. Utile car on reload tout si un des modules est modifié
+            find = False
+            for mod in self.__imported_module:
+                if mod['module'].__name__ == module.__name__:
+                    mod['setup_function'] = setup_function
+                    find = True
+                    break
+
+            if not find:
+                self.__imported_module.append({'setup_function': setup_function, 'module': module})
+            ##########
+
+            if reload_command:
+                self.reload_commands()
+        else:
+            raise SetupCommandFunctionNotFound(setup_function, file)
+

pycordViews/multibot/errors.py

@@ -1,10 +1,30 @@
 class MultibotError(Exception):
     pass
 
+class BotAlreadyExistError(MultibotError):
+    def __init__(self, bot_name: str):
+        super().__init__(f"'{bot_name}' bot already exist !")
 
 class BotNotFoundError(MultibotError):
-    """
-    If the bot is not found with the given name
-    """
-    def __init__(self, name: str):
-        super().__init__(f"{name} is not found")
+    def __init__(self, bot_name: str):
+        super().__init__(f"'{bot_name}' bot doesn't exist !")
+
+class BotNotStartedError(MultibotError):
+    def __init__(self, bot_name: str):
+        super().__init__(f"'{bot_name}' not started !")
+
+class BotNotReadyedError(MultibotError):
+    def __init__(self, bot_name: str):
+        super().__init__(f"'{bot_name}' not ready !")
+
+class BotAlreadyStartedError(MultibotError):
+    def __init__(self, bot_name: str):
+        super().__init__(f"'{bot_name}' already started !")
+
+class SetupCommandFunctionNotFound(MultibotError):
+    def __init__(self, setup_command_name: str, file: str):
+        super().__init__(f"'{setup_command_name}' function not found in '{file}' file ! Init commands impossible.")
+
+class CommandFileNotFoundError(MultibotError):
+    def __init__(self, file_name: str):
+        super().__init__(f"'{file_name}' file not found ! Init commands impossible.")

pycordViews/multibot/multibot.py

@@ -0,0 +1,206 @@
+from multiprocessing import get_context
+from multiprocessing.queues import Queue
+from .process import ManageProcess
+from discord import Intents
+from sys import platform
+from typing import Union
+
+
+class Multibot:
+
+    def __init__(self, global_timeout: int = 30):
+        """
+        Get instance to run few Discord bot
+        """
+        if platform == 'win32':
+            ctx = get_context("spawn")
+        else:
+            ctx = get_context("forkserver")
+        self.__main_queue: Queue = ctx.Queue()
+        self.__process_queue: Queue = ctx.Queue()
+        # Création du processus gérant les bots
+        self.__DiscordProcess = ctx.Process(target=self._start_process)
+        self.__DiscordProcess.start()
+        
+        self.global_timeout = global_timeout
+        
+    def __get_data_queue(self) -> Union[list[dict], dict, None]:
+        """
+        Récupère les données dans la queue processus
+        """
+        #try:
+        result = self.__process_queue.get(timeout=self.global_timeout)
+        return result
+        #except:
+            #return None
+
+    def _start_process(self):
+        """
+        Initialise et exécute le gestionnaire de processus.
+        """
+        manager = ManageProcess(self.__main_queue, self.__process_queue)
+        manager.run()
+
+    def add_bot(self, bot_name: str, token: str, intents: Intents):
+        """
+        Add a bot in the process
+        :param bot_name: Bot name
+        :param token: Token bot
+        :param intents: Intents bot to Intents discord class
+        """
+        self.__main_queue.put({"type": "ADD", "bot_name": bot_name, "token": token, 'intents': intents})
+        response = self.__get_data_queue()
+        return response  # Retourne le statut de l'ajout
+
+    def remove_bot(self, bot_name: str) -> dict[str, str]:
+        """
+        Shutdown and remove à bot
+        :param bot_name: Bot name to remove
+        """
+        self.__main_queue.put({"type": "REMOVE", "bot_name": bot_name})
+        response = self.__get_data_queue()
+        return response  # Retourne le statut de la suppression
+
+    def start(self, *bot_names: str) -> list[dict[str, str]]:
+        """
+        Start bots
+        :param bot_names: Bots name to start
+        :return: List of data bot status
+        """
+        results = []
+        for bot_name in bot_names:
+            self.__main_queue.put({'type': "START", 'bot_name': bot_name})
+            results.append(self.__get_data_queue())
+        return results
+
+    def stop(self, *bot_names: str) -> list[dict[str, str]]:
+        """
+        Stop bots
+        :param bot_names: Bots name to start
+        :return: Data status dict
+        """
+        results = []
+        for bot_name in bot_names:
+            self.__main_queue.put({'type': "STOP", 'bot_name': bot_name})
+            results.append(self.__get_data_queue())
+        return results
+    
+    def start_all(self) -> list[dict[str, list[str]]]:
+        """
+        Start all bots in the process.
+        """
+        self.__main_queue.put({'type': "STARTALL"})
+        return self.__get_data_queue()
+    
+    def stop_all(self) -> list[dict[str, list[str]]]:
+        """
+        Stop all bots in the process.
+        This function is slow ! It's shutdown all bots properly.
+        """
+        self.__main_queue.put({'type': "STOPALL"})
+        return self.__get_data_queue()
+
+    def is_started(self, bot_name: str) -> bool:
+        """
+        Return the current Websocket connexion status
+        :param bot_name: Bot name
+        :return: True if the Websocket is online, else False
+        """
+        self.__main_queue.put({'type': "IS_STARTED", 'bot_name': bot_name})
+        return self.__get_data_queue()['message']
+
+    def is_ready(self, bot_name: str) -> bool:
+        """
+        Return the current bot connexion status
+        :param bot_name: Bot name
+        :return: True if the bot if ready, else False
+        """
+        self.__main_queue.put({'type': "IS_READY", 'bot_name': bot_name})
+        return self.__get_data_queue()['message']
+
+    def is_ws_ratelimited(self, bot_name: str) -> bool:
+        """
+        Get the current ratelimit status of the bot
+        :param bot_name: Bot name
+        :return: True if the bot was ratelimited, else False
+        """
+        self.__main_queue.put({'type': "IS_WS_RATELIMITED", 'bot_name': bot_name})
+        return self.__get_data_queue()['message']
+
+    def reload_commands(self, *bot_names: str) -> list[dict[str, str]]:
+        """
+        Reload all commands for each bot when bots are ready
+        :param bot_names: Bots name to reload commands
+        """
+        result = []
+        for name in bot_names:
+            self.__main_queue.put({'type': "RELOAD_COMMANDS", 'name': name})
+            result.append(self.__get_data_queue())
+        return result
+
+    def add_pyFile_commands(self, bot_name: str, file: str, setup_function: str = 'setup', reload_command: bool = True) -> dict[str, str]:
+        """
+        Add and load a command bot file and dependencies.
+        Files must have a function called ‘setup’ or an equivalent passed as a parameter.
+
+        def setup(bot: Bot):
+            ...
+
+        :param bot_name: The bot's name to add commands file
+        :param file: Relative or absolute commands file's path
+        :param setup_function: Function name called by the process to give the Bot instance.
+        :param reload_command: Reload all command in the fil and dependencies. Default : True
+        """
+        self.__main_queue.put({'type': "ADD_COMMAND_FILE",
+                               'bot_name': bot_name,
+                               'file': file,
+                               'setup_function': setup_function,
+                               'reload_command': reload_command})
+        return self.__get_data_queue()
+
+    def modify_pyFile_commands(self, bot_name: str, file: str, setup_function: str = 'setup') -> dict[str, str]:
+
+        """
+        Modifies a file of commands and reloads it.
+        Reloads only the file, not the bot commands!
+        :param bot_name: The bot's name
+        :param file: The file's relative or absolute path
+        """
+
+        self.__main_queue.put({'type': "MODIFY_COMMAND_FILE",
+                               'bot_name': bot_name,
+                               'file': file,
+                               'setup_function': setup_function})
+        return self.__get_data_queue()
+
+    @property
+    def bot_count(self) -> int:
+        """
+        Return the total number of bots
+        """
+        self.__main_queue.put({'type': "BOT_COUNT"})
+        return self.__get_data_queue()['message']
+
+    @property
+    def started_bot_count(self) -> int:
+        """
+        Return the total number of started bots
+        """
+        self.__main_queue.put({'type': "STARTED_BOT_COUNT"})
+        return self.__get_data_queue()['message']
+
+    @property
+    def shutdown_bot_count(self) -> int:
+        """
+        Return the total number of shutdown bots
+        """
+        self.__main_queue.put({'type': "SHUTDOWN_BOT_COUNT"})
+        return self.__get_data_queue()['message']
+
+    @property
+    def get_bots_name(self) -> list[str]:
+        """
+        Return all bots name (not real name of bots)
+        """
+        self.__main_queue.put({'type': "BOTS_NAME"})
+        return self.__get_data_queue()['message']