dshellInterpreter 0.2.13__tar.gz → 0.2.20.5__tar.gz

{dshellinterpreter-0.2.13 → dshellinterpreter-0.2.20.5}/Dshell/DISCORD_COMMANDS/__init__.py

@@ -3,4 +3,5 @@ from .dshell_message import *
 from .dshell_member import *
 from .dshell_pastbin import *
 from .dshell_role import *
+from .dshell_interaction import *
 from .utils import *

{dshellinterpreter-0.2.13 → dshellinterpreter-0.2.20.5}/Dshell/DISCORD_COMMANDS/dshell_channel.py

@@ -2,7 +2,7 @@ from asyncio import sleep
 from re import search
 from typing import Union
 
-from discord import MISSING, PermissionOverwrite, Member, Role, Message
+from discord import MISSING, PermissionOverwrite, Member, Role, Message, CategoryChannel, PartialMessage
 from discord.utils import _MissingSentinel
 
 from .utils.utils_message import utils_get_message
@@ -21,7 +21,9 @@ __all__ = [
     'dshell_create_voice_channel',
     'dshell_edit_text_channel',
     'dshell_edit_voice_channel',
-    'dshell_edit_thread'
+    'dshell_edit_thread',
+    'dshell_create_category',
+    'dshell_edit_category'
 ]
 
 
@@ -206,6 +208,7 @@ async def dshell_delete_channels(ctx: Message, name=None, regex=None, reason=Non
 async def dshell_edit_text_channel(ctx: Message,
                                    channel=None,
                                    name=None,
+                                   category=MISSING,
                                    position=MISSING,
                                    slowmode=MISSING,
                                    topic=MISSING,
@@ -215,10 +218,15 @@ async def dshell_edit_text_channel(ctx: Message,
     """
     Edits a text channel on the server
     """
+    if name is not None and not isinstance(name, str):
+        raise Exception(f"Name must be a string, not {type(name)} !")
 
     if not isinstance(position, (_MissingSentinel, int)):
         raise Exception(f"Position must be an integer, not {type(position)} !")
 
+    if not isinstance(category, (_MissingSentinel, int)):
+        raise Exception(f"Category must be an integer, not {type(category)} !")
+
     if not isinstance(slowmode, (_MissingSentinel, int)):
         raise Exception(f"Slowmode must be an integer, not {type(slowmode)} !")
 
@@ -229,12 +237,14 @@ async def dshell_edit_text_channel(ctx: Message,
         raise Exception(f"NSFW must be a boolean, not {type(nsfw)} !")
 
     channel_to_edit = ctx.channel if channel is None else ctx.channel.guild.get_channel(channel)
+    new_categoy = ctx.channel.category if isinstance(category, _MissingSentinel) else ctx.channel.guild.get_channel(category)
 
     if channel_to_edit is None:
         raise Exception(f"Channel {channel} not found !")
 
     await channel_to_edit.edit(name=name if name is not None else channel_to_edit.name,
                                position=position if position is not MISSING else channel_to_edit.position,
+                               category=new_categoy,
                                slowmode_delay=slowmode if slowmode is not MISSING else channel_to_edit.slowmode_delay,
                                topic=topic if topic is not MISSING else channel_to_edit.topic,
                                nsfw=nsfw if nsfw is not MISSING else channel_to_edit.nsfw,
@@ -247,6 +257,7 @@ async def dshell_edit_text_channel(ctx: Message,
 async def dshell_edit_voice_channel(ctx: Message,
                                     channel=None,
                                     name=None,
+                                    category=MISSING,
                                     position=MISSING,
                                     bitrate=MISSING,
                                     permissions: dict[Union[Member, Role], PermissionOverwrite] = MISSING,
@@ -257,16 +268,21 @@ async def dshell_edit_voice_channel(ctx: Message,
     if not isinstance(position, (_MissingSentinel, int)):
         raise Exception(f"Position must be an integer, not {type(position)} !")
 
+    if not isinstance(category, (_MissingSentinel, int)):
+        raise Exception(f"Category must be an integer, not {type(category)} !")
+
     if not isinstance(bitrate, (_MissingSentinel, int)):
         raise Exception(f"Bitrate must be an integer, not {type(bitrate)} !")
 
     channel_to_edit = ctx.channel if channel is None else ctx.channel.guild.get_channel(channel)
+    new_categoy = ctx.channel.category if isinstance(category, _MissingSentinel) else ctx.channel.guild.get_channel(category)
 
     if channel_to_edit is None:
         raise Exception(f"Channel {channel} not found !")
 
     await channel_to_edit.edit(name=name if name is not None else channel_to_edit.name,
                                position=position if position is not MISSING else channel_to_edit.position,
+                               category=new_categoy,
                                bitrate=bitrate if bitrate is not MISSING else channel_to_edit.bitrate,
                                overwrites=permissions if permissions is not MISSING else channel_to_edit.overwrites,
                                reason=reason)
@@ -304,9 +320,14 @@ async def dshell_create_thread_message(ctx: Message,
     if not isinstance(slowmode, _MissingSentinel) and slowmode < 0:
         raise Exception("Slowmode delay must be a positive integer !")
 
-    thread = await message.fetch().create_thread(name=name,
-                                         auto_archive_duration=archive,
-                                         slowmode_delay=slowmode)
+    if isinstance(message, PartialMessage):
+        m = await message.fetch()
+    else:
+        m = message
+
+    thread = await m.create_thread(name=name,
+                    auto_archive_duration=archive,
+                    slowmode_delay=slowmode)
 
     return thread.id
 
@@ -355,7 +376,11 @@ async def dshell_get_thread(ctx: Message, message: Union[int, str] = None):
     if message is None:
         message = ctx.id
 
-    message = await utils_get_message(ctx, message).fetch()
+    target_message = utils_get_message(ctx, message)
+    if isinstance(target_message, PartialMessage):
+        message = await target_message.fetch()
+    else:
+        message = target_message
 
     if not hasattr(message, 'thread'):
         return None
@@ -376,7 +401,11 @@ async def dshell_delete_thread(ctx: Message, thread: Union[int, str] = None, rea
     if thread is None:
         thread = ctx.id
 
-    thread = await utils_get_message(ctx, thread).fetch()
+    target_message = utils_get_message(ctx, thread)
+    if isinstance(target_message, PartialMessage):
+        thread = await target_message.fetch()
+    else:
+        thread = target_message
 
     if not hasattr(thread, 'thread'):
         raise Exception("The specified message does not have a thread !")
@@ -388,3 +417,45 @@ async def dshell_delete_thread(ctx: Message, thread: Union[int, str] = None, rea
 
     return thread.thread.id
 
+async def dshell_create_category(ctx: Message,
+                                   name,
+                                   position=MISSING,
+                                   permissions: dict[Union[Member, Role], PermissionOverwrite] = MISSING,
+                                   reason=None):
+    """
+    Creates a category on the server
+    """
+
+    if not isinstance(position, (_MissingSentinel, int)):
+        raise Exception(f"Position must be an integer, not {type(position)} !")
+
+    created_category = await ctx.guild.create_category(str(name),
+                                                      position=position,
+                                                      overwrites=permissions,
+                                                      reason=reason)
+
+    return created_category.id
+
+async def dshell_edit_category(ctx: Message,
+                                category,
+                                name=None,
+                                position=MISSING,
+                                permissions: dict[Union[Member, Role], PermissionOverwrite] = MISSING,
+                                reason=None):
+    """
+    Edits a category on the server
+    """
+    if not isinstance(position, (_MissingSentinel, int)):
+        raise Exception(f"Position must be an integer, not {type(position)} !")
+
+    category_to_edit = ctx.channel.guild.get_channel(category)
+
+    if category_to_edit is None or not isinstance(category_to_edit, CategoryChannel):
+        raise Exception(f"Category {category} not found or is not a category !")
+
+    await category_to_edit.edit(name=name if name is not None else category_to_edit.name,
+                                position=position if position is not MISSING else category_to_edit.position,
+                                overwrites=permissions if permissions is not MISSING else category_to_edit.overwrites,
+                                reason=reason)
+
+    return category_to_edit.id

dshellinterpreter-0.2.20.5/Dshell/DISCORD_COMMANDS/dshell_interaction.py

@@ -0,0 +1,89 @@
+__all__ = [
+    'dshell_respond_interaction',
+    'dshell_defer_interaction',
+    'dshell_delete_original_message'
+]
+
+from types import NoneType
+from discord import Interaction, Embed, AllowedMentions
+from pycordViews import EasyModifiedViews
+
+from .utils.utils_message import utils_autorised_mentions
+
+async def dshell_respond_interaction(ctx: Interaction,
+                                     content: str = None,
+                                     delete=None,
+                                     global_mentions: bool = None,
+                                     everyone_mention: bool = True,
+                                     roles_mentions: bool = True,
+                                     users_mentions: bool = True,
+                                     reply_mention: bool = False,
+                                     hide: bool = False,
+                                     embeds=None,
+                                     view=None) -> int:
+    """
+    Responds to a message interaction on Discord
+    """
+
+    if not isinstance(ctx, Interaction):
+        raise Exception(f'Respond to an interaction must be used in an interaction context, not {type(ctx)} !')
+
+    if delete is not None and not isinstance(delete, (int, float)):
+        raise Exception(f'Delete parameter must be a number (seconds) or None, not {type(delete)} !')
+
+    if not isinstance(hide, bool):
+        raise Exception(f'Hide parameter must be a boolean, not {type(hide)} !')
+
+    allowed_mentions = utils_autorised_mentions(global_mentions,
+                                                everyone_mention,
+                                                roles_mentions,
+                                                users_mentions,
+                                                reply_mention)
+
+    from .._DshellParser.ast_nodes import ListNode
+
+    if not isinstance(embeds, (ListNode, Embed, NoneType)):
+        raise Exception(f'Embeds must be a list of Embed objects or a single Embed object, not {type(embeds)} !')
+
+    if embeds is None:
+        embeds = ListNode([])
+
+    elif isinstance(embeds, Embed):
+        embeds = ListNode([embeds])
+
+    if not isinstance(view, (EasyModifiedViews, NoneType)):
+        raise Exception(f'View must be an UI bloc or None, not {type(view)} !')
+
+    sended_message = await ctx.response.send_message(
+                                     content=str(content),
+                                     ephemeral=hide,
+                                     allowed_mentions=allowed_mentions,
+                                     delete_after=delete,
+                                     embeds=embeds,
+                                     view=view)
+
+    return sended_message.id
+
+async def dshell_defer_interaction(ctx: Interaction) -> bool:
+    """
+    Defer a message interaction on Discord
+    """
+
+    if not isinstance(ctx, Interaction):
+        raise Exception(f'Respond to an interaction must be used in an interaction context, not {type(ctx)} !')
+
+    await ctx.response.defer()
+
+    return True
+
+async def dshell_delete_original_message(ctx: Interaction) -> int:
+    """
+    Delete the original message of an interaction on Discord
+    """
+
+    if not isinstance(ctx, Interaction):
+        raise Exception(f'Respond to an interaction must be used in an interaction context, not {type(ctx)} !')
+
+    await ctx.delete_original_message()
+
+    return ctx.message.id

{dshellinterpreter-0.2.13 → dshellinterpreter-0.2.20.5}/Dshell/DISCORD_COMMANDS/dshell_message.py

@@ -1,10 +1,13 @@
 from re import search
 
-from discord import Embed, Message
+from discord import Embed, Message, PartialMessage
 from discord.ext import commands
-from discord.abc import Messageable
 
-from .utils.utils_message import utils_get_message
+from pycordViews import EasyModifiedViews
+
+from .utils.utils_message import utils_get_message, utils_autorised_mentions
+from .._DshellInterpreteur.cached_messages import dshell_cached_messages
+from .._utils import NoneType
 
 __all__ = [
     'dshell_send_message',
@@ -12,16 +15,26 @@ __all__ = [
     'dshell_delete_message',
     'dshell_purge_message',
     'dshell_edit_message',
-    'dshell_get_hystory_messages',
-    'dshell_research_regex_in_content',
+    'dshell_get_history_messages',
     'dshell_add_reactions',
     'dshell_remove_reactions',
     'dshell_clear_message_reactions',
-    'dshell_clear_one_reactions'
+    'dshell_clear_one_reactions',
+    'dshell_get_content_message'
 ]
 
 
-async def dshell_send_message(ctx: Message, message=None, delete=None, channel=None, embeds=None):
+async def dshell_send_message(ctx: Message,
+                              message=None,
+                              delete=None,
+                              channel=None,
+                              global_mentions: bool = None,
+                              everyone_mention: bool = True,
+                              roles_mentions: bool = True,
+                              users_mentions: bool = True,
+                              reply_mention: bool = False,
+                              embeds=None,
+                              view=None) -> int:
     """
     Sends a message on Discord
     """
@@ -30,29 +43,44 @@ async def dshell_send_message(ctx: Message, message=None, delete=None, channel=N
         raise Exception(f'Delete parameter must be a number (seconds) or None, not {type(delete)} !')
 
     channel_to_send = ctx.channel if channel is None else ctx.channel.guild.get_channel(channel)
+    allowed_mentions = utils_autorised_mentions(global_mentions, everyone_mention, roles_mentions, users_mentions, reply_mention)
 
     if channel_to_send is None:
         raise Exception(f'Channel {channel} not found!')
 
     from .._DshellParser.ast_nodes import ListNode
 
+    if not isinstance(embeds, (ListNode, Embed, NoneType)):
+        raise Exception(f'Embeds must be a list of Embed objects or a single Embed object, not {type(embeds)} !')
+
     if embeds is None:
         embeds = ListNode([])
 
     elif isinstance(embeds, Embed):
         embeds = ListNode([embeds])
 
-    else:
-        raise Exception(f'Embeds must be a list of Embed objects or a single Embed object, not {type(embeds)} !')
+    if not isinstance(view, (EasyModifiedViews, NoneType)):
+        raise Exception(f'Channel must be an UI or None, not {type(channel_to_send)} !')
 
     sended_message = await channel_to_send.send(message,
                                                 delete_after=delete,
-                                                embeds=embeds)
+                                                embeds=embeds,
+                                                allowed_mentions=allowed_mentions,
+                                                view=view)
 
     return sended_message.id
 
 
-async def dshell_respond_message(ctx: Message, message=None, content: str = None, delete=None, mention: bool = None, embeds=None):
+async def dshell_respond_message(ctx: Message,
+                                 message=None,
+                                 content: str = None,
+                                 global_mentions: bool = None,
+                                 everyone_mention: bool = True,
+                                 roles_mentions: bool = True,
+                                 users_mentions: bool = True,
+                                 reply_mention: bool = False,
+                                 delete=None,
+                                 embeds=None):
     """
     Responds to a message on Discord
     """
@@ -60,22 +88,24 @@ async def dshell_respond_message(ctx: Message, message=None, content: str = None
         raise Exception(f'Delete parameter must be a number (seconds) or None, not {type(delete)} !')
 
     respond_message = ctx if message is None else utils_get_message(ctx, message)  # builds a reference to the message (even if it doesn't exist)
-    mention_author = mention if mention is not None else False
+    autorised_mentions = utils_autorised_mentions(global_mentions, everyone_mention, roles_mentions, users_mentions, reply_mention)
+    mention_author = True if reply_mention else False
 
     from .._DshellParser.ast_nodes import ListNode
 
+    if not isinstance(embeds, (ListNode, Embed, NoneType)):
+        raise Exception(f'Embeds must be a list of Embed objects or a single Embed object, not {type(embeds)} !')
+
     if embeds is None:
         embeds = ListNode([])
 
     elif isinstance(embeds, Embed):
         embeds = ListNode([embeds])
 
-    else:
-        raise Exception(f'Embeds must be a list of Embed objects or a single Embed object, not {type(embeds)} !')
-
     sended_message = await respond_message.reply(
                                      content=str(content),
                                      mention_author=mention_author,
+                                     allowed_mentions=autorised_mentions,
                                      delete_after=delete,
                                      embeds=embeds)
 
@@ -113,24 +143,34 @@ async def dshell_purge_message(ctx: Message, message_number: int, channel=None,
     await purge_channel.purge(limit=message_number, reason=reason)
 
 
-async def dshell_edit_message(ctx: Message, message, new_content=None, embeds=None):
+async def dshell_edit_message(ctx: Message, message, new_content=None, embeds=None, view=None) -> int:
     """
     Edits a message
     """
     edit_message = utils_get_message(ctx, message)
 
+    from .._DshellParser.ast_nodes import ListNode
+
+    if not isinstance(embeds, (ListNode, Embed, NoneType)):
+        raise Exception(f'Embeds must be a list of Embed objects or a single Embed object, not {type(embeds)} !')
+
+    if not isinstance(view, (EasyModifiedViews, NoneType)):
+        raise Exception(f'View must be an UI bloc or None, not {type(view)} !')
+
     if embeds is None:
-        embeds = []
+        embeds = ListNode([])
 
     elif isinstance(embeds, Embed):
-        embeds = [embeds]
+        embeds = ListNode([embeds])
 
-    await edit_message.edit(content=new_content, embeds=embeds)
+    await edit_message.edit(content=new_content, embeds=embeds, view=view)
 
     return edit_message.id
 
 
-async def dshell_get_hystory_messages(ctx: Message, channel=None, limit=None):
+async def dshell_get_history_messages(ctx: Message,
+                                      channel=None,
+                                      limit=None) -> "ListNode":
     """
     Searches for messages matching a regex in a channel
     """
@@ -145,29 +185,19 @@ async def dshell_get_hystory_messages(ctx: Message, channel=None, limit=None):
 
     from .._DshellParser.ast_nodes import ListNode
 
+    cached_messages = dshell_cached_messages.get()
     messages = ListNode([])
     async for message in search_channel.history(limit=limit):
-        messages.add(message)
+        message_id = message.id
+        messages.add(message_id)
+        cached_messages[message_id] = message
 
     if not messages:
         raise commands.CommandError(f"No messages in {search_channel.mention}.")
-
+    dshell_cached_messages.set(cached_messages)
     return messages
 
 
-async def dshell_research_regex_in_content(ctx: Message, regex, content=None):
-    """
-    Searches for a regex in a specific message content
-    """
-
-    if not isinstance(regex, str):
-        raise Exception(f"Regex must be a string, not {type(regex)}!")
-
-    if not search(regex, str(content) if content is not None else ctx.content):
-        return False
-
-    return True
-
 
 async def dshell_add_reactions(ctx: Message, reactions, message=None):
     """
@@ -220,3 +250,22 @@ async def dshell_clear_one_reactions(ctx: Message, message, emoji):
     target_message = ctx if message is None else utils_get_message(ctx, message)
 
     await target_message.clear_reaction(emoji)
+
+async def dshell_get_content_message(ctx: Message, message=None):
+    """
+    Get the content of a message
+    """
+
+    target_message = ctx if message is None else utils_get_message(ctx, message)
+
+    if isinstance(target_message, PartialMessage):
+        try:
+            fetch_target_message = await target_message.fetch()
+        except:
+            raise Exception(f'Message not found !')
+    else:
+        fetch_target_message = target_message
+
+    return fetch_target_message.content
+
+

{dshellinterpreter-0.2.13 → dshellinterpreter-0.2.20.5}/Dshell/DISCORD_COMMANDS/dshell_pastbin.py

@@ -6,14 +6,16 @@ __all__ = [
 ]
 
 
-async def dshell_get_pastbin(ctx: Message, code: str):
+async def dshell_get_pastbin(ctx: Message, code: str) -> "ListNode":
     """
     Get a pastbin from a code snippet.
     """
     if not isinstance(code, str):
         raise Exception(f'Code must be a string, not {type(code)} !')
 
-    content = ''  # Initialize content to an empty string
+    from .._DshellParser.ast_nodes import ListNode
+
+    content = ListNode([])  # Initialize content to an empty string
 
     with get(f"https://pastebin.com/raw/{code}", stream=True, timeout=10) as response:
 
@@ -21,10 +23,6 @@ async def dshell_get_pastbin(ctx: Message, code: str):
             raise Exception(f"Failed to retrieve pastbin with code {code} !")
 
         for line in response.iter_lines(decode_unicode=True, chunk_size=512):
-            len_content = len(content)
-            if len_content < 4000 and len_content + len(line) <= 4000:
-                content += line + '\n'
-            else:
-                break
+            content.add(line)
 
     return content

dshellinterpreter-0.2.20.5/Dshell/DISCORD_COMMANDS/utils/__init__.py

@@ -0,0 +1,8 @@
+from .utils_thread import *
+from .utils_message import *
+from .utils_list import *
+from .utils_global import *
+from .utils_permissions import *
+from .utils_member import *
+from .utils_string import *
+from .utils_list import *