PycordViews 1.1.3__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/pagination/pagination_view.py

@@ -23,6 +23,7 @@ class Pagination:
 
         self.__view.add_items(Button(label='⏮', row=0, custom_id='back+', style=ButtonStyle.blurple))
         self.__view.add_items(Button(label='◀', row=0, custom_id='back', style=ButtonStyle.blurple))
+        self.__view.add_items(Button(label='None', row=0, custom_id='counter', style=ButtonStyle.gray, disabled=True))
         self.__view.add_items(Button(label='▶', row=0, custom_id='forward', style=ButtonStyle.blurple))
         self.__view.add_items(Button(label='⏭', row=0, custom_id='forward+', style=ButtonStyle.blurple))
         self.__view.set_callable('back+', 'back', 'forward', 'forward+', _callable=self.__turn_page)
@@ -38,6 +39,7 @@ class Pagination:
         add_page(content="my message", embeds=[embed1, embed2], ...)
         """
         self.__pages.append((args, kwargs))
+        self.__view.get_ui('counter').label = f"{self.__current_page+1}/{len(self.__pages)}"
         return self
 
     def delete_pages(self, *page_numbers: Union[str, int]) -> "Pagination":
@@ -54,6 +56,7 @@ class Pagination:
                 raise PageNumberNotFound(page_number)
 
             del self.__pages[page_number]
+        self.__view.get_ui('counter').label = f"{self.__current_page+1}/{len(self.__pages)}"
         return self
 
     async def __turn_page(self, button, interaction: Interaction):
@@ -81,11 +84,14 @@ class Pagination:
         elif interaction.custom_id == 'forward+':  # Go to the last page
             self.__current_page = page_count-1
 
+        self.__view.get_ui('counter').label = f"{self.__current_page + 1}/{len(self.__pages)}"
 
         await interaction.message.edit(
 
             *self.__pages[self.__current_page][0],
 
+            view=self.get_view,
+
             **self.__pages[self.__current_page][1]
 
         )
@@ -117,5 +123,6 @@ class Pagination:
     def get_page(self) -> int:
         """
         Get the number of showed page
+        (start to 0)
         """
         return self.__current_page

pycordViews/views/easy_modified_view.py

@@ -1,10 +1,14 @@
+from __future__ import annotations
 from discord import Interaction, ApplicationContext, Message, Member, TextChannel
 from discord.ui import View, Item
-from typing import Union, Callable, Iterable
+from typing import Union, Callable, TYPE_CHECKING
 
-from ..typeViews import T_views
 from .errors import CustomIDNotFound
 
+if TYPE_CHECKING:
+    from ..menu.selectMenu import SelectMenu
+    from ..pagination.pagination_view import Pagination
+
 
 class EasyModifiedViews(View):
     """
@@ -21,7 +25,7 @@ class EasyModifiedViews(View):
         super().__init__(*items, timeout=timeout)
         self.__timeout: Union[float, None] = timeout
         self.__disabled_on_timeout: bool = disabled_on_timeout
-        self.__callback: dict[str, dict[str, Union[Callable[[Interaction], None], T_views]]] = {}
+        self.__callback: dict[str, dict[str, Union[Callable[[Interaction], None], Item]]] = {}
         self.__ctx: Union[Message, Interaction] = None
 
     def __check_custom_id(self, custom_id: str) -> None:
@@ -46,19 +50,25 @@ class EasyModifiedViews(View):
         self.__ctx = await target.send(*args, **kwargs)
 
     def add_items(self,
-                   *items: T_views) -> "EasyModifiedViews":
+                   *items: Union[Item, SelectMenu, Pagination]) -> "EasyModifiedViews":
         """
         Add all items in the View.
         """
 
         for ui in items:
 
-            self.__callback[ui.custom_id] = {'ui': ui, 'func': None}
-            self.add_item(ui)
+            if type(ui).__name__ in ('SelectMenu', 'Pagination'):
+                for item in ui.get_view.items:
+                    self.add_items(item)
+                    self.set_callable(item.custom_id, _callable=ui.get_callable(item.custom_id))
+
+            else:
+                self.__callback[ui.custom_id] = {'ui': ui, 'func': None}
+                self.add_item(ui)
 
         return self
 
-    async def update_items(self, *items: T_views) -> "EasyModifiedViews":
+    async def update_items(self, *items: Item) -> "EasyModifiedViews":
         """
         Update all views.
         Append items if custom_ids not in the view
@@ -67,7 +77,6 @@ class EasyModifiedViews(View):
         """
 
         for item in items:
-
             try:
                 self.__check_custom_id(item.custom_id)
                 self.__callback[item.custom_id]['ui'] = item
@@ -128,6 +137,14 @@ class EasyModifiedViews(View):
 
             self.__callback[custom_id]['func'] = _callable
 
+    def get_callable(self, custom_id: str) -> Union[Callable, None]:
+        """
+        Get the callable UI
+        :param custom_id: UI ID
+        """
+        self.__check_custom_id(custom_id)
+        return self.__callback[custom_id]['func']
+
     async def interaction_check(self, interaction: Interaction) -> bool:
         """
         Func to apply items
@@ -243,25 +260,26 @@ class EasyModifiedViews(View):
         """
         Update the View on the attached message.
         """
-        try:
+        if self.is_finished():
+            return
 
-            if self.message:
-                await self.message.edit(view=self)
+        if self.message:
+            await self.message.edit(view=self)
 
-            else:
-                await self.__ctx.edit(view=self)
+        elif self.__ctx:
+            await self.__ctx.edit(view=self)
 
-        except:
-            pass
+        else:
+            return
 
     @property
-    def get_uis(self) -> list[T_views]:
+    def get_uis(self) -> list[Item]:
         """
         Get all uis in the view
         """
         return [i['ui'] for i in self.__callback.values()]
 
-    def get_ui(self, custom_id: str) -> T_views:
+    def get_ui(self, custom_id: str) -> Item:
         """
         Get an ui in the view
         :raise: CustomIDNotFound
@@ -270,4 +288,8 @@ class EasyModifiedViews(View):
         return self.__callback[custom_id]['ui']
 
     def __str__(self):
-        return str(self.__callback)
+        return str(self.__callback)
+
+    @property
+    def items(self) -> tuple[Item]:
+        return tuple([i['ui'] for i in self.__callback.values()])

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.3.dist-info → pycordviews-1.2.0.dist-info}/WHEEL

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