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

pycordViews/multibot/process.py

@@ -0,0 +1,217 @@
+from multiprocessing import Queue
+from .errors import BotAlreadyExistError, BotNotFoundError, MultibotError, BotNotStartedError
+from .bot import DiscordBot
+from discord import Intents
+from immutableType import Str_
+
+class ManageProcess:
+
+    def __init__(self, main_queue: Queue, process_queue: Queue):
+        """
+        Gère tous les bots dans un processus
+        """
+        self.__bots: dict[str, DiscordBot] = {}
+        self.main_queue: Queue = main_queue
+        self.process_queue: Queue = process_queue
+
+        self.commandes = {
+            "ADD": self.add_bot_to_process,
+            "REMOVE": self.remove_bot_to_process,
+            "START": self.start_bot_to_process,
+            "STOP": self.stop_bot_to_process,
+            "IS_STARTED": self.is_started,
+            "IS_READY": self.is_ready,
+            "IS_WS_RATELIMITED": self.is_ws_ratelimited,
+            "STOPALL": self.stop_all_bot_to_process,
+            "STARTALL": self.start_all_bot_to_process,
+            "BOT_COUNT": self.bot_count,
+            "STARTED_BOT_COUNT": self.started_bot_count,
+            "SHUTDOWN_BOT_COUNT": self.shutdown_bot_count,
+            "BOTS_bot_name": self.get_bots_bot_name,
+            "RELOAD_COMMANDS": self.reload_all_commands,
+            "ADD_COMMAND_FILE": self.add_pyFile_commands,
+            "MODIFY_COMMAND_FILE": self.modify_pyFile_commands
+        }
+
+    def run(self):
+        """
+        Boucle principale du processus, écoute la queue principale.
+        Doit comporter aubligatoirement un dictionnaire avec la clé 'type'
+        """
+        while True:
+            if not self.main_queue.empty():
+                command: dict = self.main_queue.get()
+                print(command)
+
+                c = command["type"]
+                if c in self.commandes.keys():
+                    del command['type']
+                    try:
+                        result = self.commandes[c](**command)
+                        self.process_queue.put({'status': 'success', 'message': result})
+                    except MultibotError as e:
+                        self.process_queue.put({'status': 'error', 'message': e})
+
+    def start_bot_to_process(self, bot_name: str) -> str:
+        """
+        Lance un unique bot
+        """
+        self.if_bot_no_exist(bot_name)
+        self.__bots[bot_name].start()
+        return f'{bot_name} bot started'
+
+    def stop_bot_to_process(self, bot_name: str) -> str:
+        """
+        Stop un bot du processus
+        :param bot_name: Le nom du bot à stopper
+        """
+        self.if_bot_no_exist(bot_name)
+        self.__bots[bot_name].stop()
+        return f'{bot_name} bot stopped'
+
+    def start_all_bot_to_process(self) -> list[str]:
+        """
+        Start tous les bots du processus
+        """
+        result = []
+        for bot in self.__bots.keys():
+            result.append(self.start_bot_to_process(bot))
+        return result
+
+    def stop_all_bot_to_process(self) -> list[str]:
+        """
+        Stop tous les bots du processus
+        """
+        result = []
+        for bot in self.__bots.keys():
+            result.append(self.stop_bot_to_process(bot))
+
+        return result
+
+    def add_bot_to_process(self, bot_name: str, token: str, intents: Intents) -> str:
+        """
+        Ajoute un bot au processus
+        :param bot_name: Le nom du bot
+        :param token: Le token du bot
+        :raise: BotAlreadyExistError si le bot existe déjà
+        """
+        if bot_name in self.__bots.keys():
+            raise BotAlreadyExistError(bot_name)
+        self.__bots[bot_name] = DiscordBot(token, intents)
+        return f'Bot {bot_name} added'
+
+    def add_pyFile_commands(self, bot_bot_name: str, 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_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
+        """
+        self.if_bot_no_exist(bot_bot_name)
+        setup_function = Str_(setup_function).str_
+        file = Str_(file).str_
+        self.__bots[bot_bot_name].add_pyFile_commands(file=file, setup_function=setup_function, reload_command=reload_command)
+
+    def modify_pyFile_commands(self, bot_bot_name: str, 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 bot_bot_name: Le nom du bot
+        :param file: Le chemin d'accès relatif ou absolue du fichier
+        """
+        self.if_bot_no_exist(bot_bot_name)
+        file = Str_(file).str_
+        self.__bots[bot_bot_name].modify_pyFile_commands(file=file, setup_function=setup_function)
+
+
+    def reload_all_commands(self, bot_name: str):
+        """
+        Recharge toutes les commandes sur Discord
+        """
+        self.if_bot_no_exist(bot_name)
+        self.__bots[bot_name].reload_commands()
+        return f'Bot {bot_name} commands reloaded'
+
+    def remove_bot_to_process(self, bot_name: str) -> str:
+        """
+        Coupe et enlève un bot au processus
+        :param bot_name: Le nom du bot à retirer
+        :raise:
+        """
+        self.if_bot_no_exist(bot_name)
+        try:
+            self.__bots[bot_name].stop()
+        except BotNotStartedError:
+            pass
+        self.__bots[bot_name].close_ascyncio_loop()
+        del self.__bots[bot_name]
+        return f'Bot {bot_name} removed'
+
+    def is_started(self, bot_name: str) -> bool:
+        """
+        Regarde si la connexion au Websocket est effectué
+        :param bot_name: Le nom du bot à vérifier
+        """
+        self.if_bot_no_exist(bot_name)
+        return self.__bots[bot_name].is_running
+
+    def is_ready(self, bot_name: str) -> bool:
+        """
+        Regarde si le bot est ready
+        :param bot_name: Le nom du bot à vérifier
+        """
+        self.if_bot_no_exist(bot_name)
+        return self.__bots[bot_name].is_ready
+
+    def is_ws_ratelimited(self, bot_name: str) -> bool:
+        """
+        Regarde si le bot est ratelimit
+        :param bot_name: Le nom du bot à vérifier
+        """
+        self.if_bot_no_exist(bot_name)
+        return self.__bots[bot_name].is_ws_ratelimited
+
+    def if_bot_no_exist(self, bot_name: str) -> None:
+        """
+        Regarde si le bot existe dans la class
+        """
+        if bot_name not in self.__bots.keys():
+            raise BotNotFoundError(bot_name)
+
+    def bot_count(self) -> int:
+        """
+        Renvoie le nombre de bot au total
+        """
+        return len(self.__bots)
+
+    def started_bot_count(self) -> int:
+        """
+        Renvoie le nombre de bot démarré au total
+        """
+        s = 0
+        for bot in self.__bots.values():
+            if bot.is_running:
+                s += 1
+        return s
+
+    def shutdown_bot_count(self) -> int:
+        """
+        Renvoie le nombre de bot arrêter au total
+        """
+        s = 0
+        for bot in self.__bots.values():
+            if not bot.is_running:
+                s += 1
+        return s
+
+    def get_bots_bot_name(self) -> list[str]:
+        """
+        Renvoie tous les noms des bots entrée par l'utilisateur
+        """
+        return list(self.__bots.keys())

pycordviews-1.2.0.dist-info/METADATA

@@ -0,0 +1,241 @@
+Metadata-Version: 2.4
+Name: PycordViews
+Version: 1.2.0
+Summary: Views and multibot for py-cord library
+Home-page: https://github.com/BOXERRMD/Py-cord_Views
+Author: Chronos (alias BOXERRMD)
+Author-email: vagabonwalybi@gmail.com
+Maintainer: Chronos
+License: MIT License
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: Microsoft :: Windows :: Windows 11
+Classifier: Operating System :: Microsoft :: Windows :: Windows 10
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3.9
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: immutable-Python-type
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: maintainer
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Py-cord_Views
+ Views for py-cord library
+
+# Paginator
+The paginator instance is used to create a view acting as a “book”, with pages that can be turned using buttons.
+## `Paginator`
+> ```python
+> Paginator(timeout: Union[float, None] = None, disabled_on_timeout: bool = False)`
+> ```
+> > **Method** `add_page(*args, **kwargs) -> Pagination` : add a new page with send message function parameters _(content, embed, embeds, files...)_
+>
+> > **Method** `delete_pages(*page_numbers: Union[str, int]) -> Pagination` : Deletes pages in the order in which they were added _(start to 0)_
+> 
+> > **Method** `send(target: Union[Member, TextChannel]) -> Any` : Send the pagination in dm member or channels
+> 
+> > **Method** `respond(ctx: ApplicationContext) -> Any` : Respond at slash command call
+> 
+> > **@property** `get_view -> EasyModifiedViews` : Return the pagination view. Can be used in `view` parameter to setup a view
+> 
+> > **@property** `get_page -> int` : get the showed page number
+
+```python
+from pycordViews.pagination import Pagination
+import discord
+
+intents = discord.Intents.all()
+bot = discord.AutoShardedBot(intents=intents)
+
+@bot.command(name="My command paginator", description="...")
+async def pagination_command(ctx):
+    """
+    Create a command pagination
+    """
+    pages: Pagination = Pagination(timeout=None, disabled_on_timeout=False)
+    
+    pages.add_page(content="It's my first page !!", embed=None)# reset embed else he show the embed of the page after
+    
+    embed = discord.Embed(title="My embed title", description="..........")
+    pages.add_page(content=None, embed=embed) # reset content else he show the content of the page before
+
+    pages.add_page(content="My last page !", embed=None)# reset embed else he show the embed of the page before
+
+    await pages.respond(ctx=ctx) # respond to the command
+    await pages.send(send_to=ctx.author) # send the message to the command author
+
+bot.run("Your token")
+```
+
+# SelectMenu
+The SelectMenu instance is used to create drop-down menus that can be easily modified at will.
+
+## `SelectMenu`
+> ```python
+> SelectMenu(timeout: Union[float, None] = None, disabled_on_timeout: bool = False)`
+> ```
+> > **Method** `add_string_select_menu(custom_id: str = None, placeholder: str = None, min_values: int = 1, max_values: int = 1, disabled=False, row=None) -> Menu` : Add a string select menu in the ui. Return Menu instance to set options 
+> 
+> > **Method** `add_user_select_menu(custom_id: str = None, placeholder: str = None, min_values: int = 1, max_values: int = 1, disabled=False, row=None) -> Menu` : Add a user select menu in the ui. Return Menu instance to set options 
+> 
+> > **Method** `add_role_select_menu(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. Return Menu instance to set options
+> 
+> > **Method** `add_mentionnable_select_menu(custom_id: str = None, placeholder: str = None, min_values: int = 1, max_values: int = 1, disabled=False, row=None) -> Menu` : Add a mentionable select menu in the ui. Return Menu instance to set options
+> 
+> > **Method** `set_callable(*custom_ids: str, _callable: Union[Callable, None]) -> SelectMenu` : Set a callable for menus associated with custom_ids. This callable _(async function)_ will be set to respond at selected menus interactions
+> 
+> > **Method** `send(target: Union[Member, TextChannel]) -> Any` : Send the selectmenu in dm member or channels
+> 
+> > **Method** `respond(ctx: ApplicationContext) -> Any` : Respond at slash command call
+> 
+> > **Method** `update() -> None` : Update the view dynamically if there was sent before. 
+> 
+> > **@Method** `get_callable(self, custom_id: str) -> Union[Callable, None]` : Get the callable _async_ function link to the custom_id ui. If any callable set, return None
+> 
+> > **@property** `get_view -> EasyModifiedViews` : Return the selectmenu view. Can be used in `view` parameter to setup a view
+
+### Menu
+
+## `Menu`
+> ```python
+> Menu(...)` # Not to be initialized by the user
+> ```
+> > **Method** `set_callable(_callable: Union[Callable, None]) -> Menu` : Set a callable for menus associated. This callable _(async function)_ will be set to respond at selected menus interactions
+> 
+> > **Method** `add_option(label: str, value: str = MISSING, description: Union[str, None] = None, emoji: Union[str, Emoji, PartialEmoji, None] = None, default: bool = False) -> Menu` : Add a string select option. Only for string select menu !
+> 
+> > **Method** `remove_options(*labels: str) -> Menu` : Remove options with labels. Only for string select menu !
+> 
+> > **Method** `update_option(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 associated with `current_label` parameter
+> 
+> > **@property** `component -> CustomSelect` : Return the Select component class
+> 
+> > **@property** `selectmenu -> SelectMenu` : Return the current SelectMenu instance associated
+> 
+> > **@property** `callable -> Callable` : Return the current callable menu
+
+```python
+from pycordViews.menu import SelectMenu
+import discord
+
+intents = discord.Intents.all()
+bot = discord.AutoShardedBot(intents=intents)
+
+@bot.command(name="My command select")
+async def select_command(ctx):
+    """
+    Create a command select
+    """
+    async def your_response(select, interaction):
+        await interaction.response.send(f"You have selected {select.values[0]} !")
+    
+    my_selector = SelectMenu(timeout=None, disabled_on_timeout=False) # A basic selector menu
+    my_menu = my_selector.add_string_select_menu(placeholder="Choice anything !") # add string_select UI
+    
+    my_menu.add_option(label="My first choice !", emoji="😊", default=True, description="It's the first choice !", value='first choice')
+    my_menu.add_option(label="My second choice !", value='second choice')
+    my_menu.set_callable(your_response)
+    
+    await my_selector.respond(ctx)
+    
+bot.run("Your token")
+```
+
+# Multibot
+The Multibot instance is used to manage several bots dynamically.
+
+Each instance of this class creates a process where bots can be added. These bots will each be launched in a different thread with their own asyncio loop.
+
+## `Multibot`
+> ```python
+> Multibot(global_timeout: int = 30) # global_timeout is the time in seconds the program waits before abandoning the request
+> ```
+> > **Method** `add_bot(bot_name: str, token: str, intents: Intents) -> None` : Add a bot. The name given here is not the real bot name, it's juste an ID
+> 
+> > **Method** `remove_bot(bot_name: str) -> dict[str, str]` : Remove à bot. If the bot is online, it will turn off properly. It can take a long time !
+> 
+> > **Method** `start(*bot_names: str) -> list[dict[str, str]]` : Start bots
+> 
+> > **Method** `def stop(*bot_names: str) -> list[dict[str, str]]` : Stop bots properly
+> 
+> > **Method** `start_all() -> list[dict[str, list[str]]]` : Start all bot in the process
+> 
+> > **Method** `stop_all() -> list[dict[str, list[str]]]` : Stop all bot in the process properly
+> 
+> > **Method** `is_started(bot_name: str) -> bool` : Return if the bot is connected at the Discord WebSocket
+> 
+> > **Method** `is_ready(bot_name: str) -> bool` : Return if the bot is ready in Discord
+> 
+> > **Method** `is_ws_ratelimited(bot_name: str) -> bool` : Return if the bot is rate limited by Discord
+> 
+> > **Method** `reload_commands(*bot_names: str) -> list[dict[str, str]]` : Reload all commands for each bot passed in parameters
+> 
+> > **Method** `add_pyFile_commands(bot_name: str, file: str, setup_function: str = 'setup', reload_command: bool = True) -> dict[str, str]` : Add a python Discord command file to the bot. `file` parameter require a file path, absolute or not. By default, it automatically reloads commands on the bot after adding the file.
+> >
+> > ### _Blob_commands.py_
+> > ```python
+> > """ 
+> > Discord command file example. Follow it !
+> > This file doesn't have 'bot.run()' function. It's managed by Multibot instance.
+> > """
+> > 
+> > from discord import Bot, ApplicationContext, Message # autoaticly imported by importlib module
+> > 
+> > # this function is called when the bot load a python file command. It is mandatory to have it with a bot parameter !
+> > def setup(bot: Bot):
+> >     """
+> >     Function called by the process and give the bot instance.
+> >     This function is mandatory to have it with a bot parameter but can be renamed with 'setup_function' parameter in 'add_pyFile_commands' method.
+> >     Every discord command and discord event can be in this function, but you can make function and class outside setup function.
+> >     -> bot : Instance of your started bot.
+> >     """
+> >     @bot.command()
+> >     async def my_first_command(ctx: ApplicationContext):
+> >         await ctx.respond("It's my first command !")
+> > 
+> >     @bot.event
+> >     async def on_message(message: Message):
+> >         await message.add_reaction(emoji="😊")
+> > 
+> > # You don't need 'bot.run(...)' here !
+> > ```
+> 
+> > **Method** `modify_pyFile_commands(bot_name: str, file: str, setup_function: str = 'setup') -> dict[str, str]` : Modify python discord command file and setup function. This method doesn't reload automatically commands on the bot. Use `reload_commands` after. `file` parameter require a file path, absolute or not.
+> 
+> > **@property** `bot_count -> int` : Return the total number of bots
+> 
+> > **@property** `started_bot_count -> int` : Return the total number of started bots
+> 
+> > **@property** `shutdown_bot_count( -> int` : Return the total number of shutdown bots
+> 
+> > **@property** `get_bots_name -> list[str]` : Return all bots name _(not real name of bots)_
+```python
+from pycordViews.multibot import Multibot
+from discord import Intents
+
+if __name__ == '__main__': # Obligatory !
+    process = Multibot()
+    
+    process.add_bot(bot_name="Blob", token="TOKEN FIRST BOT", intents=Intents.all())
+    process.add_bot(bot_name="Bee", token="TOKEN SECOND BOT", intents=Intents.all())
+    
+    process.start_all()
+    process.add_pyFile_commands(bot_name='Blob', file='Blob_commands.py', reload_command=True)
+    process.add_pyFile_commands(bot_name='Bee', file='Bee_commandes.py', reload_command=True)
+
+    process.modify_pyFile_commands(bot_name='Blob', file='others_commands/Blob2_commands.py', setup_function='started_bot')
+    process.reload_commands('Blob')
+```

pycordviews-1.2.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+pycordViews/__init__.py,sha256=gJmACNCnfY5Q00aUFVODZ6Tkfdo3mgGlolPNSZnzT8k,225
+pycordViews/menu/__init__.py,sha256=QUXA9ezyeTScvS1kxMNFgKEbZMsPq5yUnWWgbXCytCk,97
+pycordViews/menu/errors.py,sha256=0Um-oH5qMdWSZB_bGlqILsf9WSDtC4n_HwkheekiMV4,480
+pycordViews/menu/menu.py,sha256=3D13C5Vs69w9SlrnixBfF0riY48jORi8JcYte65YFPs,4306
+pycordViews/menu/selectMenu.py,sha256=oYydLtoQm7YRjnFII2af5cUfIZ8ci_86lk0Il5TGYTw,10459
+pycordViews/multibot/__init__.py,sha256=93Q_URiRUMsvwQJIqUnb75aq6SPM83yteSMrH0rmXMg,30
+pycordViews/multibot/bot.py,sha256=UrRqSSmtFpkQKAqeunHxIy_O5DgO1gcW-nMEQ9yNdAo,8267
+pycordViews/multibot/errors.py,sha256=_xawL8jQZTajx253F4JKywFGVPdYf8vTALOMiNqJ9hs,1176
+pycordViews/multibot/multibot.py,sha256=xko7AdgkuYJgefKl39Rmz9fpk8R02nGdSWf6zCt_CxQ,7562
+pycordViews/multibot/process.py,sha256=MYhOUG1egKK_I8sJ8y4yW_avZut8VIyGO5D2d-CCBV4,7895
+pycordViews/pagination/__init__.py,sha256=Z9BcdoTWyC1KXGwQ1_C0tu9rkZpdrrjEHwMmjXsckeE,81
+pycordViews/pagination/errors.py,sha256=CYb5gBcXx0kYDUDkNpfUrqSxQAcJE_qfpomWtUFOsTk,316
+pycordViews/pagination/pagination_view.py,sha256=sJHDkmiTGwJzxfAUQijF2ry6NPVwepJvbdkAvA6j0es,4846
+pycordViews/views/__init__.py,sha256=yligptZmw-np8tjKLr76SVmi0807Nk6jCyKkKYLhbCY,89
+pycordViews/views/easy_modified_view.py,sha256=QuS8AnkTLHrdKl7Tya0_gjuwhWHLIvMAEK3DsyE1ALg,8986
+pycordViews/views/errors.py,sha256=0NBjBDaSFZChJua1ho9qyfbNzwXy1U6Kcob5CCUxBK8,218
+pycordviews-1.2.0.dist-info/licenses/LICENSE,sha256=lNgcw1_xb7QENAQi3uHGymaFtbs0RV-ihiCd7AoLQjA,1082
+pycordviews-1.2.0.dist-info/METADATA,sha256=ij56btgSo1NEh_GL3G4CDiPO3Rhr6exSE0OeeERlNCY,11828
+pycordviews-1.2.0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+pycordviews-1.2.0.dist-info/top_level.txt,sha256=nqBU40KmnSCjtry8kmv97-RvZC-8xQrhrrloOJX2ROs,91
+pycordviews-1.2.0.dist-info/RECORD,,

{pycordviews-1.1.4.dist-info → pycordviews-1.2.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (76.0.0)
+Generator: setuptools (78.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

pycordViews/multibot/process_for_bots.py

@@ -1,112 +0,0 @@
-from discord import AutoShardedBot, Bot
-from random import choice
-from string import ascii_letters
-from asyncio import set_event_loop, new_event_loop, sleep, run, create_task
-from multiprocessing import Queue
-
-from .errors import *
-from .runner import Runner
-from .process_messages import ProcessMessage
-
-
-class ProcessBot:
-
-    def __init__(self, queue_parent: Queue, queue_children: Queue, limit_bots_in_tread: int = -1):
-        """
-        Class to manage process and thread
-        """
-        self.__threads: dict = {}
-        self.__all_bots: dict = {}
-
-        self.__limit_bots_in_tread: int = limit_bots_in_tread
-
-        self.__queue_parent: Queue = queue_parent
-        self.__queue_children: Queue = queue_children
-        self.__loop = None
-        run(self.run_process())
-
-    async def run_process(self):
-        """
-        Function run with the process
-        """
-        await create_task(self.__message_process_receiver())  # Run the process
-
-    async def __message_process_receiver(self):
-        """
-        Wait message from parent process (always a dict with the key "parent_message")
-        """
-        while True:
-            await sleep(0.02)
-            while not self.__queue_children.empty():
-                try:
-                    message = self.__queue_children.get_nowait()
-                    await self.__decode_message(message)
-                except:
-                    break
-
-    def __message_process_sender(self, message: dict):
-        """
-        Send a message to parent process
-        """
-        self.__queue_parent.put(message)
-
-    async def __decode_message(self, message: dict):
-        """
-        Decode the current message sent by the parent process
-        :param message: The message.
-        """
-        action = message['parent_message']
-
-        if ProcessMessage.ADD_BOT.value == action:
-            self.add_bot(**message)
-
-        elif ProcessMessage.RUN_ALL.value == action:
-            print("run all bots")
-
-    def add_bot(self, token: str, *args, autoshared: bool = False, name: str = None, **kwargs) -> None:
-        """
-        Add a bot in the instance to manage it.
-        Use this function to set the bot's intents and other subtleties.
-        :param name: The name of the bot to find it. If None, a random name is given
-        :param token: The token bot
-        :param autoshared: Autoshare the bot in Discord
-        :param args: all arguments of the Discord class Bot.
-        :param kwargs: all kwargs of the Discord class Bot
-        See : https://docs.pycord.dev/en/stable/api/clients.html#discord.Bot
-        """
-        print(f"Ajout du bot {name} avec le token {token}")
-        if name is None:
-            name = ''.join([choice(ascii_letters) for _ in range(20)])
-
-        if autoshared:
-            self.__all_bots[name] = {'runner': Runner(AutoShardedBot(*args, **kwargs)),
-                                     'token': token,
-                                     'thread': None}
-
-        else:
-            self.__all_bots[name] = {'runner': Runner(Bot(*args, **kwargs)),
-                                     'token': token,
-                                     'thread': None}
-
-        print(f"Envoi de la réponse 'coucou' pour {name}")
-        self.__message_process_sender({'children_message': "coucou"})
-
-
-    def get_bots_names(self) -> list[str]:
-        """
-        Return all bots names registered in the class.
-        """
-        print('coucou', self.__event)
-        return list(self.__all_bots.keys())
-
-
-    def get_runner(self, name: str) -> "Runner":
-        """
-        Run the bot runner associated with this name
-        :raise: BotNotFoundError
-        """
-
-        if name not in self.__all_bots.keys():
-            raise BotNotFoundError(name)
-
-        return self.__all_bots[name]['runner']

pycordViews/multibot/process_messages.py

@@ -1,7 +0,0 @@
-from enum import Enum
-
-
-class ProcessMessage(Enum):
-
-    ADD_BOT = "add bot"
-    RUN_ALL = "run all"

pycordViews/multibot/runner.py

@@ -1,14 +0,0 @@
-from discord import AutoShardedBot, Bot
-from typing import Union
-
-class Runner:
-
-    def __init__(self, bot: Union[AutoShardedBot, Bot]):
-        """
-        Run the bot
-        """
-        self.bot: Union[AutoShardedBot, Bot] = bot
-
-    def __reduce__(self):
-        # Renvoyer un tuple avec les informations nécessaires pour reconstruire l'objet
-        return self.__class__, (self.bot,)