PycordViews 1.2.4__tar.gz → 1.2.6__tar.gz

{pycordviews-1.2.4 → pycordviews-1.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PycordViews
-Version: 1.2.4
+Version: 1.2.6
 Summary: Views and multibot for py-cord library
 Home-page: https://github.com/BOXERRMD/Py-cord_Views
 Author: Chronos (alias BOXERRMD)

{pycordviews-1.2.4 → pycordviews-1.2.6}/PycordViews.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PycordViews
-Version: 1.2.4
+Version: 1.2.6
 Summary: Views and multibot for py-cord library
 Home-page: https://github.com/BOXERRMD/Py-cord_Views
 Author: Chronos (alias BOXERRMD)

{pycordviews-1.2.4 → pycordviews-1.2.6}/PycordViews.egg-info/SOURCES.txt

@@ -8,6 +8,9 @@ PycordViews.egg-info/dependency_links.txt
 PycordViews.egg-info/requires.txt
 PycordViews.egg-info/top_level.txt
 pycordViews/__init__.py
+pycordViews/kit/__init__.py
+pycordViews/kit/confirm.py
+pycordViews/kit/poll.py
 pycordViews/menu/__init__.py
 pycordViews/menu/errors.py
 pycordViews/menu/menu.py
@@ -19,10 +22,14 @@ pycordViews/multibot/multibot.py
 pycordViews/multibot/process.py
 pycordViews/pagination/__init__.py
 pycordViews/pagination/errors.py
+pycordViews/pagination/page.py
 pycordViews/pagination/pagination_view.py
 pycordViews/views/__init__.py
 pycordViews/views/easy_modified_view.py
 pycordViews/views/errors.py
+pycordViews/kit/__init__.py
+pycordViews/kit/confirm.py
+pycordViews/kit/poll.py
 pycordViews/menu/__init__.py
 pycordViews/menu/errors.py
 pycordViews/menu/menu.py
@@ -34,6 +41,7 @@ pycordViews/multibot/multibot.py
 pycordViews/multibot/process.py
 pycordViews/pagination/__init__.py
 pycordViews/pagination/errors.py
+pycordViews/pagination/page.py
 pycordViews/pagination/pagination_view.py
 pycordViews/views/__init__.py
 pycordViews/views/easy_modified_view.py

{pycordviews-1.2.4 → pycordviews-1.2.6}/PycordViews.egg-info/top_level.txt

@@ -1,4 +1,5 @@
 pycordViews
+pycordViews/kit
 pycordViews/menu
 pycordViews/multibot
 pycordViews/pagination

{pycordviews-1.2.4 → pycordviews-1.2.6}/pycordViews/__init__.py

@@ -3,3 +3,4 @@ from .pagination.pagination_view import Pagination
 from .multibot import Multibot
 from .menu.selectMenu import SelectMenu
 from .menu.menu import Menu, CustomSelect
+from .kit import *

pycordviews-1.2.6/pycordViews/kit/__init__.py

@@ -0,0 +1,2 @@
+from .poll import Poll
+from .confirm import Confirm

pycordviews-1.2.6/pycordViews/kit/confirm.py

@@ -0,0 +1,69 @@
+from typing import Optional
+from ..views.easy_modified_view import EasyModifiedViews
+from discord import Interaction, ButtonStyle, Bot
+from discord.ui import Button
+from asyncio import wait_for, Future, get_event_loop, TimeoutError
+
+
+class Confirm:
+
+    def __init__(self, timeout: Optional[float] = None, disable_on_click: bool = False):
+        """
+        Init a Confirm class instance kit.
+        :param timeout: Time before end the view
+        """
+        self.__timeout: float = timeout
+        self.__disable_on_click: bool = disable_on_click
+        self.__view: EasyModifiedViews = EasyModifiedViews(disabled_on_timeout=True, timeout=timeout, call_on_timeout=self._on_timeout)
+        self.__button_confirm: Button = Button(label='Confirm', emoji='✅', style=ButtonStyle.green, custom_id='Confirm_confirm')
+        self.__button_denied: Button = Button(label='Denied', emoji='❌', style=ButtonStyle.gray, custom_id='Confirm_denied')
+        self.__view.add_items(self.__button_confirm, self.__button_denied)
+        self.__view.set_callable(self.__button_confirm.custom_id, _callable=self._confirm)
+        self.__view.set_callable(self.__button_denied.custom_id, _callable=self._denied)
+
+        self.__future: Future = get_event_loop().create_future()
+
+    async def _confirm(self, button: Button, interaction: Interaction):
+        """
+        Base asynchronous _confirm function called when button is pressed
+        """
+        if not self.__future.done():
+            self.__future.set_result(True)
+        if self.__disable_on_click:
+            await self.__view.disable_items('Confirm_confirm', 'Confirm_denied')
+        await interaction.response.defer()
+
+    async def _denied(self, button: Button, interaction: Interaction):
+        """
+        Base asynchronous _denied function called when button is pressed
+        """
+        if not self.__future.done():
+            self.__future.set_result(False)
+        if self.__disable_on_click:
+            await self.__view.disable_items('Confirm_confirm', 'Confirm_denied')
+        await interaction.response.defer()
+
+    async def wait_for_response(self) -> Optional[bool]:
+        """
+        Wait and return the result of current button pressed.
+        :return: True if it is confirmed, False else. If timeout is reached, return None
+        """
+        try:
+            return await wait_for(self.__future, timeout=self.__timeout)
+
+        except TimeoutError:
+            return None
+
+    async def _on_timeout(self, ctx):
+        """
+        Called when the timeout is reached to end the Future
+        """
+        if not self.__future.done():
+            self.__future.set_result(None)
+
+    @property
+    def get_view(self) -> EasyModifiedViews:
+        """
+        Get the current view
+        """
+        return self.__view

pycordviews-1.2.6/pycordViews/kit/poll.py

@@ -0,0 +1,147 @@
+from ..views.easy_modified_view import EasyModifiedViews
+from ..views.errors import CoroutineError
+from discord.ui.button import Button, ButtonStyle
+from discord import Emoji, PartialEmoji, Embed, Color
+from typing import Optional, Callable, Union
+from asyncio import iscoroutinefunction
+
+
+class Poll:
+
+    def __init__(self, timeout: Optional[float] = None, unique_vote: bool = True):
+        """
+        Class instance to make poll with buttons
+        :param timeout: Time before end the view
+        :param unique_vote: Set True to make vote unchangeable
+        """
+        self.yes_count: int = 0
+        self.no_count: int = 0
+        self.__unique_vote: bool = unique_vote
+        self.__view = EasyModifiedViews(disabled_on_timeout=True, timeout=timeout)
+        self.__button_yes = Button(label='Yes', emoji='✅', custom_id='Poll_yes', style=ButtonStyle.green)
+        self.__button_no = Button(label='No', emoji='❌', custom_id='Poll_no', style=ButtonStyle.gray)
+        self.__view.add_items(self.__button_yes, self.__button_no)
+        self.__view.set_callable('Poll_yes', _callable=self.yes)
+        self.__view.set_callable('Poll_no', _callable=self.no)
+        self.__view.call_on_timeout(self._result) # asynchrone fonction quand la view est arrivé à son timeout
+        self.__clicked_members: list[int] = []
+
+    def add_answer_button(self, label: str,
+                            custom_id: str,
+                            emoji: Optional[Union[str, Emoji, PartialEmoji]] = None,
+                            style: ButtonStyle = ButtonStyle.secondary,
+                            row: Optional[int] = None,
+                            _callable: Optional[Callable] = None) -> Button:
+        """
+        Create a new answer button and add it in the view.
+        :param label: Button label
+        :param custom_id: Button ID
+        :param emoji: Button emoji
+        :param style: Button style
+        :param row: Button row
+        :param _callable: Asynchronous function linked to the button interaction. It's called when the button is pressed
+        """
+
+        if not iscoroutinefunction(_callable):
+            raise CoroutineError(_callable)
+
+        b = Button(label=label, emoji=emoji, style=style, row=row, custom_id=custom_id)
+        self.__view.add_items(b)
+        self.__view.set_callable(custom_id, _callable=_callable)
+
+        return b
+
+
+    def set_yes_button(self, label: Optional[str] = None,
+                       emoji: Optional[Union[str, Emoji, PartialEmoji]] = None,
+                       style: Optional[ButtonStyle] = None,
+                       row: Optional[int] = None,
+                       _callable: Optional[Callable] = None):
+        """
+        Set yes button parameters (he didn't change dynamically if the view was sent before)
+        :param label: Button label
+        :param emoji: Button emoji
+        :param style: Button style
+        :param row: Button row
+        :param _callable: Asynchronous function linked to the button interaction. It's called when the button is pressed
+        """
+        self.__button_yes.emoji = emoji if emoji is not None else self.__button_yes.emoji
+        self.__button_yes.style = style if style is not None else self.__button_yes.style
+        self.__button_yes.label = label if label is not None else self.__button_yes.label
+        self.__button_yes.row = row if row is not None else self.__button_yes.row
+
+        if not iscoroutinefunction(_callable):
+            raise CoroutineError(_callable)
+
+        if _callable is not None:
+            self.__view.set_callable(self.__button_yes.custom_id, _callable=_callable)
+
+    def set_no_button(self, label: Optional[str] = None,
+                        emoji: Optional[Union[str, Emoji, PartialEmoji]] = None,
+                        style: Optional[ButtonStyle] = None,
+                        row: Optional[int] = None,
+                        _callable: Optional[Callable] = None):
+        """
+        Set no button parameters (he didn't change dynamically if the view was sent before)
+        :param label: Button label
+        :param emoji: Button emoji
+        :param row: Button row
+        :param style: Button style
+        :param callable: Asynchronous function linked to the button interaction. It's called when the button is pressed
+        """
+        self.__button_no.emoji = emoji if emoji is not None else self.__button_no.emoji
+        self.__button_no.style = style if style is not None else self.__button_no.style
+        self.__button_no.label = label if label is not None else self.__button_no.label
+        self.__button_no.row = row if row is not None else self.__button_no.row
+
+        if not iscoroutinefunction(_callable):
+            raise CoroutineError(_callable)
+
+        if _callable is not None:
+            self.__view.set_callable(self.__button_no.custom_id, _callable=_callable)
+
+    async def yes(self, button, interaction):
+        """
+        Base asynchronous function when "yes" button is pressed.
+        Increment “yes_count” attribute when pressed and respond with an ephemeral message.
+        This function can be changed.
+        """
+        if self.__unique_vote and interaction.user.id in self.__clicked_members:
+            await interaction.response.send_message(f"You have already voted !", ephemeral=True)
+            return
+        self.yes_count += 1
+        self.__clicked_members.append(interaction.user.id)
+        await interaction.response.send_message(f"You have selected : {button.label}", ephemeral=True)
+
+    async def no(self, button, interaction):
+        """
+        Base asynchronous function when "no" button is pressed.
+        Increment “yes_count” attribute when pressed and respond with an ephemeral message.
+        This function can be changed.
+        """
+        if self.__unique_vote and interaction.user.id in self.__clicked_members:
+            await interaction.response.send_message(f"You have already voted !", ephemeral=True)
+            return
+        self.yes_count += 1
+        self.__clicked_members.append(interaction.user.id)
+        await interaction.response.send_message(f"You have selected : {button.label}", ephemeral=True)
+
+    async def _result(self, ctx):
+        """
+        Asynchronous base function called when timeout is reached.
+        :param ctx: Actual command context
+        """
+        embed = Embed(title="Poll ended !",
+                      description=f"## Results :\n"
+                                  f" `-` {self.__button_yes.emoji.name} {self.__button_yes.label} -> `{self.yes_count}`\n"
+                                  f" `-` {self.__button_no.emoji.name} {self.__button_no.label} -> `{self.no_count}`",
+                      color=Color.gold())
+
+        await self.__view.message.reply(embed=embed)
+
+    @property
+    def get_view(self) -> EasyModifiedViews:
+        """
+        Get the current view
+        """
+        return self.__view

{pycordviews-1.2.4 → pycordviews-1.2.6}/pycordViews/pagination/__init__.py

@@ -1,2 +1,3 @@
 from .pagination_view import Pagination
 from .errors import PageNumberNotFound
+from .page import Page

pycordviews-1.2.6/pycordViews/pagination/page.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+from typing import Optional, Callable
+from discord import File, Embed
+from immutableType import callable_, NoneType
+from ..views import EasyModifiedViews
+
+class Page:
+
+    @callable_(is_class=True, kwargs_types={'view': [NoneType, EasyModifiedViews], 'content': [NoneType, str], 'embed': [NoneType, Embed], 'embeds': [list], 'file': [NoneType, File], 'files': [list]})
+    def __init__(self, view: EasyModifiedViews, content: Optional[str] = None, embed: Optional[Embed] = None, embeds: list[Embed] = [], file: Optional[File] = None,  files: Optional[list[File]] = []):
+        """
+        Init Page instance from Pagination class
+        """
+        self.__view: EasyModifiedViews = view if view is not None else EasyModifiedViews()
+        self.content: Optional[str] = content
+        self.embeds: list[Embed] = embeds if embed is None else embeds + [embed]
+        self.files: list[File] = files if file is None else files + [file]
+
+    @property
+    def get_page_view(self) -> EasyModifiedViews:
+        """
+        Get the current page view
+        """
+        return self.__view
+

{pycordviews-1.2.4 → pycordviews-1.2.6}/pycordViews/pagination/pagination_view.py

@@ -1,9 +1,10 @@
 from ..views.easy_modified_view import EasyModifiedViews
-from discord import ButtonStyle, Interaction, TextChannel, Member, ApplicationContext
+from discord import ButtonStyle, Interaction, TextChannel, Member, ApplicationContext, File, Embed
 from discord.ui import Button
 from .errors import PageNumberNotFound
+from .page import Page
 
-from typing import Union, Any
+from typing import Union, Any, Optional
 
 
 class Pagination:
@@ -28,17 +29,17 @@ class Pagination:
         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)
 
-        self.__pages: list[tuple[tuple, dict]] = []
+        self.__pages: list[Page] = []
         self.__current_page: int = 0
 
-    def add_page(self, *args, **kwargs) -> "Pagination":
+    def add_page(self, content: Optional[str] = None, embed: Optional[Embed] = None, embeds: list[Embed] = [], file: Optional[File] = None,  files: Optional[list[File]] = [], view: Optional[EasyModifiedViews] = None) -> "Pagination":
         """
         Adds a page (in a list) as if this function directly sent the message
         Pages are just modified and not reset ! Don't forget to disable embeds or content if the page don't need this.
 
         add_page(content="my message", embeds=[embed1, embed2], ...)
         """
-        self.__pages.append((args, kwargs))
+        self.__pages.append(Page(content=content, embed=embed, embeds=embeds, file=file, files=files, view=view))
         self.__view.get_ui('counter').label = f"{self.__current_page+1}/{len(self.__pages)}"
         return self
 
@@ -86,13 +87,15 @@ class Pagination:
 
         self.__view.get_ui('counter').label = f"{self.__current_page + 1}/{len(self.__pages)}"
 
-        await interaction.message.edit(
+        c = self.__pages[self.__current_page]
 
-            *self.__pages[self.__current_page][0],
+        await interaction.message.edit(
 
-            view=self.get_view,
+            content=c.content,
+            embeds=c.embeds,
+            files=c.files,
 
-            **self.__pages[self.__current_page][1]
+            view=self.__view.copy() + self.__pages[self.__current_page].get_page_view,
 
         )
 
@@ -104,23 +107,28 @@ class Pagination:
         Send pagination without introduction message.
         :param target: The member or channel to send the pagination
         """
-        return await self.__view.send(ctx=target, *self.__pages[0][0], **self.__pages[0][1], view=self.get_view)
+        first_page = self.__pages[0]
+        return await self.__view.send(target=target, content=first_page.content, embeds=first_page.embeds, files=first_page.files, view=self.__view.copy() + first_page.get_page_view)
 
     async def respond(self, ctx: ApplicationContext) -> Any:
         """
         Respond to the command call
+        :param ctx: ApplicationContext to respond
         """
-        return await self.__view.respond(ctx=ctx, *self.__pages[0][0], **self.__pages[0][1], view=self.get_view)
+        first_page = self.__pages[0]
+        return await self.__view.respond(ctx=ctx, content=first_page.content, embeds=first_page.embeds, files=first_page.files, view=self.__view.copy() + first_page.get_page_view)
 
-    @property
-    def get_view(self) -> EasyModifiedViews:
+    def get_page(self, page_number: int) -> Page:
         """
-        Get the view of pagination
+        Get the page
         """
-        return self.__view
+        if 0 <= page_number <= len(self.__pages):
+            return self.__pages[page_number]
+        else:
+            raise PageNumberNotFound(page_number)
 
     @property
-    def get_page(self) -> int:
+    def get_current_showed_page(self) -> int:
         """
         Get the number of showed page
         (start to 0)

{pycordviews-1.2.4 → pycordviews-1.2.6}/pycordViews/views/easy_modified_view.py

@@ -1,13 +1,16 @@
 from __future__ import annotations
-from discord import Interaction, ApplicationContext, Message, Member, TextChannel
+from discord import Interaction, ApplicationContext, Message, Member
+from discord.abc import GuildChannel
 from discord.ui import View, Item
-from typing import Union, Callable, TYPE_CHECKING
+from typing import Union, Callable, TYPE_CHECKING, Optional
+from asyncio import iscoroutinefunction, create_task
 
-from .errors import CustomIDNotFound
+from .errors import CustomIDNotFound, CoroutineError
 
 if TYPE_CHECKING:
     from ..menu.selectMenu import SelectMenu
     from ..pagination.pagination_view import Pagination
+    from ..kit import Poll, Confirm
 
 
 class EasyModifiedViews(View):
@@ -17,16 +20,19 @@ class EasyModifiedViews(View):
     Allows you to easily modify and replace an ui.
     """
 
-    def __init__(self, timeout: Union[float, None] = None, disabled_on_timeout: bool = False, *items: Item):
+    def __init__(self, timeout: Optional[float] = None, disabled_on_timeout: bool = False, call_on_timeout: Optional[Callable] = None, *items: Item):
         """
         Init a Class view for Discord UI
         :param timeout: The time before ui disable
+        :param disabled_on_timeout: disable view if timeout is reached
+        :param call_on_timeout: asynchronous function to call after view timed-out
         """
         super().__init__(*items, timeout=timeout)
-        self.__timeout: Union[float, None] = timeout
+        self.__timeout: Optional[float] = timeout
         self.__disabled_on_timeout: bool = disabled_on_timeout
         self.__callback: dict[str, dict[str, Union[Callable[[Interaction], None], Item]]] = {}
         self.__ctx: Union[Message, Interaction] = None
+        self.__call_on_timeout: Callable = call_on_timeout
 
     def __check_custom_id(self, custom_id: str) -> None:
         """
@@ -43,21 +49,24 @@ class EasyModifiedViews(View):
         """
         self.__ctx = await ctx.respond(*args, **kwargs)
 
-    async def send(self, target: Union[Member, TextChannel], *args, **kwargs) -> None:
+    async def send(self, target: Union[Member, GuildChannel], *args, **kwargs) -> None:
         """
         Send at the target
         """
         self.__ctx = await target.send(*args, **kwargs)
 
     def add_items(self,
-                   *items: Union[Item, SelectMenu, Pagination]) -> "EasyModifiedViews":
+                   *items: Union[EasyModifiedViews, Confirm, Pagination, Poll, SelectMenu, Item]) -> EasyModifiedViews:
         """
         Add all items in the View.
         """
 
         for ui in items:
 
-            if type(ui).__name__ in ('SelectMenu', 'Pagination'):
+            if ui is None: # si l'ui n'est pas setup
+                continue
+
+            if type(ui).__name__ in ('SelectMenu', 'Pagination', 'Confirm', 'Poll', 'EasyModifiedViews'):
                 for item in ui.get_view.items:
                     self.add_items(item)
                     self.set_callable(item.custom_id, _callable=ui.get_callable(item.custom_id))
@@ -118,7 +127,7 @@ class EasyModifiedViews(View):
         """
         set up a callable for items
         :param custom_ids: items IDs of the view
-        :param _callable: The callable linked
+        :param _callable: The asynchronous callable linked. Take UI (Button, Select...) and Interaction parameters.
 
         **UI and Interaction parameter is required in callable function !**
 
@@ -230,7 +239,6 @@ class EasyModifiedViews(View):
 
         return True
 
-
     async def delete_items(self, clear_all: bool = False, *custom_ids: str) -> None:
         """
         Delete an item on the view
@@ -254,13 +262,25 @@ class EasyModifiedViews(View):
         Called if timeout view is finished
         """
         if self.__disabled_on_timeout:
-            self.shutdown()
+            create_task(self.shutdown())
+        if self.__call_on_timeout is not None:
+            create_task(self.__call_on_timeout(self.__ctx))
+
+    def call_on_timeout(self, _callable: Callable) -> None:
+        """
+        Call asynchronous function passed when the timeout is reached.
+        :param _callable: asynchronous function to call. It takes one argument : ctx
+        """
+        if iscoroutinefunction(_callable):
+            self.__call_on_timeout = _callable
+        else:
+            raise CoroutineError(_callable)
 
     async def _update(self) -> None:
         """
         Update the View on the attached message.
         """
-        if self.is_finished():
+        if self.is_finished() and not self.__disabled_on_timeout:
             return
 
         if self.message:
@@ -269,16 +289,6 @@ class EasyModifiedViews(View):
         elif self.__ctx:
             await self.__ctx.edit(view=self)
 
-        else:
-            return
-
-    @property
-    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) -> Item:
         """
         Get an ui in the view
@@ -287,9 +297,39 @@ class EasyModifiedViews(View):
         self.__check_custom_id(custom_id)
         return self.__callback[custom_id]['ui']
 
+    def copy(self) -> EasyModifiedViews:
+        """
+        Return an exact copy of the view. All mutable object in the view is a new object
+        """
+        e = EasyModifiedViews(timeout=self.__timeout, disabled_on_timeout=self.__disabled_on_timeout).add_items(*self.items)
+        for i in self.items:
+            e.set_callable(i.custom_id, _callable=self.get_callable(i.custom_id))
+
+        return e
+
     def __str__(self):
         return str(self.__callback)
 
     @property
     def items(self) -> tuple[Item]:
         return tuple([i['ui'] for i in self.__callback.values()])
+
+    @property
+    def get_view(self) -> EasyModifiedViews:
+        """
+        Get The current view. Don't use in your code
+        """
+        return self
+
+    def __add__(self, _view: Union[EasyModifiedViews, Confirm, Pagination, Poll, SelectMenu, Item]) -> EasyModifiedViews:
+        """
+        Add all items to _view from the current EasyModifiedViews instance
+        """
+        self.add_items(_view)
+        return self
+
+    def __iadd__(self, _view) -> EasyModifiedViews:
+        """
+        Add all items to _view from the current EasyModifiedViews instance
+        """
+        return self.__add__(_view)

pycordviews-1.2.6/pycordViews/views/errors.py

@@ -0,0 +1,13 @@
+class Py_cordEasyModifiedViews(Exception):
+    """
+    Main class exception
+    """
+
+
+class CustomIDNotFound(Py_cordEasyModifiedViews):
+    def __init__(self):
+        super().__init__(f"custom_id not found !")
+
+class CoroutineError(Py_cordEasyModifiedViews):
+    def __init__(self, coro):
+        super().__init__(f"{coro} is not a coroutine !")

{pycordviews-1.2.4 → pycordviews-1.2.6}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", encoding='utf-8') as file:
 
 setup(
     name="PycordViews",
-    version="1.2.4",
+    version="1.2.6",
     url="https://github.com/BOXERRMD/Py-cord_Views",
     author="Chronos (alias BOXERRMD)",
     author_email="vagabonwalybi@gmail.com",
@@ -27,6 +27,6 @@ setup(
     install_requires=[
         "immutable-Python-type"
     ],
-    packages=['pycordViews', 'pycordViews/pagination', 'pycordViews/views', 'pycordViews/menu', 'pycordViews/multibot'],
+    packages=['pycordViews', 'pycordViews/pagination', 'pycordViews/views', 'pycordViews/menu', 'pycordViews/multibot', 'pycordViews/kit'],
     python_requires='>=3.9'
 )

pycordviews-1.2.4/pycordViews/views/errors.py

@@ -1,9 +0,0 @@
-class Py_cordEasyModifiedViews(Exception):
-    """
-    Main class exception
-    """
-
-
-class CustomIDNotFound(Py_cordEasyModifiedViews):
-    def __init__(self):
-        super().__init__(f"custom_id not found !")