dshellInterpreter 0.2.8.2__py3-none-any.whl → 0.2.9.1__py3-none-any.whl

Dshell/DISCORD_COMMANDS/dshell_channel.py

@@ -2,18 +2,151 @@ 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, Thread
 from discord.utils import _MissingSentinel
+from discord import NotFound
 
 __all__ = [
+    'dshell_get_channel',
+    'dshell_get_channels',
+    'dshell_get_thread',
+    'dshell_get_channels_in_category',
     'dshell_create_text_channel',
+    'dshell_create_thread_message',
     'dshell_delete_channel',
     'dshell_delete_channels',
+    'dshell_delete_thread',
     'dshell_create_voice_channel',
     'dshell_edit_text_channel',
-    'dshell_edit_voice_channel'
+    'dshell_edit_voice_channel',
+    'dshell_edit_thread'
 ]
 
+async def utils_get_message(ctx: Message, message: Union[int, str]) -> Message:
+    """
+    Returns the message object of the specified message ID or link.
+    Message is only available in the same server as the command and in the same channel.
+    If the message is a link, it must be in the format: https://discord.com/channels/{guild_id}/{channel_id}/{message_id}
+    """
+
+    if isinstance(message, int):
+        return await ctx.channel.fetch_message(message)
+
+    elif isinstance(message, str):
+        match = search(r'https://discord\.com/channels/(\d+)/(\d+)/(\d+)', message)
+        if not match:
+            raise Exception("Invalid message link format. Use a valid Discord message link.")
+        guild_id = int(match.group(1))
+        channel_id = int(match.group(2))
+        message_id = int(match.group(3))
+
+        if guild_id != ctx.guild.id:
+            raise Exception("The message must be from the same server as the command !")
+
+        return await ctx.guild.get_channel(channel_id).fetch_message(message_id)
+
+    raise Exception(f"Message must be an integer or a string, not {type(message)} !")
+
+async def utils_get_thread(ctx: Message, thread: Union[int, str]) -> Thread:
+    """
+    Returns the thread object of the specified thread ID or link.
+    Thread is only available in the same server as the command and in the same channel.
+    If the thread is a link, it must be in the format: https://discord.com/channels/{guild_id}/{channel_id}/{message_id}
+    """
+
+    if isinstance(thread, int):
+        return ctx.channel.get_thread(thread)
+
+    elif isinstance(thread, str):
+        match = search(r'https://discord\.com/channels/(\d+)/(\d+)(/\d+)?', thread)
+        if not match:
+            raise Exception("Invalid thread link format. Use a valid Discord thread link.")
+        guild_id = int(match.group(1))
+        message_id = int(match.group(2))
+        channel_id = ctx.channel.id if len(match.groups()) == 3 else ctx.channel.id
+
+        if guild_id != ctx.guild.id:
+            raise Exception("The thread must be from the same server as the command !")
+
+        try:
+            c = await ctx.guild.get_channel(channel_id).fetch_message(message_id)
+            return c.thread
+        except NotFound:
+            raise Exception(f"Thread with ID {message_id} not found in channel {channel_id} !")
+
+    raise Exception(f"Thread must be an integer or a string, not {type(thread)} !")
+
+
+async def dshell_get_channel(ctx: Message, name):
+    """
+    Returns the channel object of the channel where the command was executed or the specified channel.
+    """
+
+    if isinstance(name, str):
+        return next((c.id for c in ctx.channel.guild.channels if c.name == name), None)
+
+    raise Exception(f"Channel must be an integer or a string, not {type(name)} !")
+
+
+async def dshell_get_channels(ctx: Message, name=None, regex=None):
+    """
+    Returns a list of channels with the same name and/or matching the same regex.
+    If neither is set, it will return all channels in the server.
+    """
+    if name is not None and not isinstance(name, str):
+        raise Exception(f"Name must be a string, not {type(name)} !")
+
+    if regex is not None and not isinstance(regex, str):
+        raise Exception(f"Regex must be a string, not {type(regex)} !")
+
+    from .._DshellParser.ast_nodes import ListNode
+    channels = ListNode([])
+
+    for channel in ctx.channel.guild.channels:
+        if name is not None and channel.name == str(name):
+            channels.add(channel.id)
+
+        elif regex is not None and search(regex, channel.name):
+            channels.add(channel.id)
+
+    return channels
+
+async def dshell_get_channels_in_category(ctx: Message, category=None, name=None, regex=None):
+    """
+    Returns a list of channels in a specific category with the same name and/or matching the same regex.
+    If neither is set, it will return all channels in the specified category.
+    """
+
+    if category is None and ctx.channel.category is not None:
+        category = ctx.channel.category.id
+
+    if category is None:
+        raise Exception("Category must be specified !")
+
+    if not isinstance(category, int):
+        raise Exception(f"Category must be an integer, not {type(category)} !")
+
+    if name is not None and not isinstance(name, str):
+        raise Exception(f"Name must be a string, not {type(name)} !")
+
+    if regex is not None and not isinstance(regex, str):
+        raise Exception(f"Regex must be a string, not {type(regex)} !")
+
+    from .._DshellParser.ast_nodes import ListNode
+    channels = ListNode([])
+
+    category_channel = ctx.channel.guild.get_channel(category)
+    if category_channel is None or not hasattr(category_channel, 'channels'):
+        raise Exception(f"Category {category} not found or does not contain channels !")
+
+    for channel in category_channel.channels:
+        if name is not None and channel.name == str(name):
+            channels.add(channel.id)
+
+        elif regex is not None and search(regex, channel.name):
+            channels.add(channel.id)
+
+    return channels
 
 async def dshell_create_text_channel(ctx: Message,
                                      name,
@@ -191,3 +324,119 @@ async def dshell_edit_voice_channel(ctx: Message,
                                reason=reason)
 
     return channel_to_edit.id
+
+
+async def dshell_create_thread_message(ctx: Message,
+                                       name,
+                                       message: Union[int, str] = None,
+                                       archive=MISSING,
+                                       slowmode=MISSING):
+    """
+    Creates a thread from a message.
+    """
+
+    if message is None:
+        message = ctx.id
+
+    message = await utils_get_message(ctx, message)
+
+
+    if not isinstance(name, str):
+        raise Exception(f"Name must be a string, not {type(name)} !")
+
+    if not isinstance(archive, _MissingSentinel) and not isinstance(archive, int):
+        raise Exception(f"Auto archive duration must be an integer, not {type(archive)} !")
+
+    if not isinstance(archive, _MissingSentinel) and archive not in (60, 1440, 4320, 10080):
+        raise Exception("Auto archive duration must be one of the following values: 60, 1440, 4320, 10080 !")
+
+    if not isinstance(slowmode, _MissingSentinel) and not isinstance(slowmode, int):
+        raise Exception(f"Slowmode delay must be an integer, not {type(slowmode)} !")
+
+    if not isinstance(slowmode, _MissingSentinel) and slowmode < 0:
+        raise Exception("Slowmode delay must be a positive integer !")
+
+    thread = await message.create_thread(name=name,
+                                         auto_archive_duration=archive,
+                                         slowmode_delay=slowmode)
+
+    return thread.id
+
+async def dshell_edit_thread(ctx: Message,
+                             thread: Union[int, str] = None,
+                             name=None,
+                             archive=MISSING,
+                             slowmode=MISSING,
+                             reason=None):
+    """ Edits a thread.
+    """
+    if thread is None:
+        thread = ctx.thread
+
+    if thread is None:
+        raise Exception("Thread must be specified !")
+
+    thread = await utils_get_thread(ctx, thread)
+
+    if not isinstance(name, _MissingSentinel) and not isinstance(name, str):
+        raise Exception(f"Name must be a string, not {type(name)} !")
+
+    if not isinstance(archive, _MissingSentinel) and not isinstance(archive, int):
+        raise Exception(f"Auto archive duration must be an integer, not {type(archive)} !")
+
+    if not isinstance(archive, _MissingSentinel) and archive not in (60, 1440, 4320, 10080):
+        raise Exception("Auto archive duration must be one of the following values: 60, 1440, 4320, 10080 !")
+
+    if not isinstance(slowmode, _MissingSentinel) and not isinstance(slowmode, int):
+        raise Exception(f"Slowmode delay must be an integer, not {type(slowmode)} !")
+
+    if not isinstance(slowmode, _MissingSentinel) and slowmode < 0:
+        raise Exception("Slowmode delay must be a positive integer !")
+
+    await thread.edit(name=name if name is not None else thread.name,
+                      auto_archive_duration=archive if archive is not MISSING else thread.auto_archive_duration,
+                      slowmode_delay=slowmode if slowmode is not MISSING else thread.slowmode_delay,
+                      reason=reason)
+
+
+async def dshell_get_thread(ctx: Message, message: Union[int, str] = None):
+    """
+    Returns the thread object of the specified thread ID.
+    """
+
+    if message is None:
+        message = ctx.id
+
+    message = await utils_get_message(ctx, message)
+
+    if not hasattr(message, 'thread'):
+        return None
+
+    thread = message.thread
+
+    if thread is None:
+        return None
+
+    return thread.id
+
+
+async def dshell_delete_thread(ctx: Message, thread: Union[int, str] = None, reason=None):
+    """
+    Deletes a thread.
+    """
+
+    if thread is None:
+        thread = ctx.id
+
+    thread = await utils_get_message(ctx, thread)
+
+    if not hasattr(thread, 'thread'):
+        raise Exception("The specified message does not have a thread !")
+
+    if thread.thread is None:
+        raise Exception("The specified message does not have a thread !")
+
+    await thread.thread.delete(reason=reason)
+
+    return thread.thread.id
+

Dshell/DISCORD_COMMANDS/dshell_member.py

@@ -1,8 +1,9 @@
 from datetime import timedelta, datetime, UTC
 
-from discord import MISSING, Message, Member, Permissions, Role
+from discord import MISSING, Message, Member, Permissions, Role, Embed
 
 __all__ = [
+    "dshell_send_private_message",
     "dshell_ban_member",
     "dshell_unban_member",
     "dshell_kick_member",
@@ -16,6 +17,35 @@ __all__ = [
     "dshell_remove_member_roles"
 ]
 
+async def dshell_send_private_message(ctx: Message, member: int = None, message: str = None, delete: int = None, embeds = None, ):
+    """
+    Sends a private message to a member.
+    If member is None, sends the message to the author of the command.
+    If delete is specified, deletes the message after the specified time in seconds.
+    """
+    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)} !')
+
+    member_to_send = ctx.author if member is None else ctx.channel.guild.get_member(member)
+
+    if member_to_send is None:
+        raise Exception(f'Member {member} not found!')
+
+    from .._DshellParser.ast_nodes import ListNode
+
+    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 member_to_send.send(message, delete_after=delete, embeds=embeds)
+
+    return sended_message.id
+
 
 async def dshell_ban_member(ctx: Message, member: int, reason: str = MISSING):
     """

Dshell/DISCORD_COMMANDS/dshell_message.py

@@ -5,6 +5,7 @@ from discord.ext import commands
 
 __all__ = [
     'dshell_send_message',
+    'dshell_respond_message',
     'dshell_delete_message',
     'dshell_purge_message',
     'dshell_edit_message',
@@ -47,6 +48,32 @@ async def dshell_send_message(ctx: Message, message=None, delete=None, channel=N
     return sended_message.id
 
 
+async def dshell_respond_message(ctx: Message, message=None, delete=None, embeds=None):
+    """
+    Responds to a message on Discord
+    """
+    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)} !')
+
+    respond_message = ctx if message is None else ctx.channel.get_partial_message(message)  # builds a reference to the message (even if it doesn't exist)
+
+    from .._DshellParser.ast_nodes import ListNode
+
+    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 ctx.reply(respond_message,
+                                     delete_after=delete,
+                                     embeds=embeds)
+
+    return sended_message.id
+
 async def dshell_delete_message(ctx: Message, message=None, reason=None, delay=0):
     """
     Deletes a message

Dshell/_DshellParser/ast_nodes.py

@@ -426,7 +426,7 @@ class ParamNode(ASTNode):
         self.body = body
 
     def __repr__(self):
-        return f"<PARAM> - {self.name} *- {self.body}"
+        return f"<PARAM> - {self.body}"
 
     def to_dict(self):
         """
@@ -435,7 +435,6 @@ class ParamNode(ASTNode):
         """
         return {
             "type": "ParamNode",
-            "name": self.name.to_dict(),
             "body": [token.to_dict() for token in self.body]
         }
 

Dshell/_DshellTokenizer/dshell_keywords.py

@@ -28,6 +28,8 @@ dshell_commands: dict[str, Callable] = {
     "gp": dshell_get_pastbin,  # get pastbin
 
     "sm": dshell_send_message,  # send message
+    "spm": dshell_send_private_message,  # send private message
+    "srm": dshell_respond_message,  # respond to a message
     "dm": dshell_delete_message,
     "pm": dshell_purge_message,
     "em": dshell_edit_message,  # edit message
@@ -37,6 +39,15 @@ dshell_commands: dict[str, Callable] = {
     "dc": dshell_delete_channel,  # delete channel
     "dcs": dshell_delete_channels,  # delete several channels by name or regex
 
+    "gc": dshell_get_channel,  # get channel
+    "gcs": dshell_get_channels,  # get channels by name or regex
+    "gccs": dshell_get_channels_in_category,  # get channels in category
+
+    "ct": dshell_create_thread_message,  # create thread
+    "dt": dshell_delete_thread,  # delete thread
+    "gt": dshell_get_thread,  # get thread
+    "et": dshell_edit_thread,  # edit thread
+
     "bm": dshell_ban_member,  # ban member
     "um": dshell_unban_member,  # unban member
     "km": dshell_kick_member,  # kick member
@@ -59,8 +70,8 @@ dshell_commands: dict[str, Callable] = {
 
     "ar": dshell_add_reactions,  # add reactions to a message
     "rr": dshell_remove_reactions,  # remove reactions from a message
-    "cmr": dshell_clear_message_reactions,
-    "cor": dshell_clear_one_reactions
+    "cmr": dshell_clear_message_reactions, # clear reactions from a message
+    "cor": dshell_clear_one_reactions , # clear one reaction from a message
 
 }
 

{dshellinterpreter-0.2.8.2.dist-info → dshellinterpreter-0.2.9.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dshellInterpreter
-Version: 0.2.8.2
+Version: 0.2.9.1
 Summary: A Discord bot interpreter for creating custom commands and automations.
 Home-page: https://github.com/BOXERRMD/Dshell_Interpreter
 Author: Chronos

{dshellinterpreter-0.2.8.2.dist-info → dshellinterpreter-0.2.9.1.dist-info}/RECORD

@@ -1,22 +1,22 @@
 Dshell/__init__.py,sha256=pGd94FPy8kVXH_jH566HhApQPhbPfMPnZXzH_0dPWh0,93
 Dshell/_utils.py,sha256=PJ3fwn8IMqUMnW9oTwfr9v4--rzHIhhLQoVVqjwjoJU,23
 Dshell/DISCORD_COMMANDS/__init__.py,sha256=_oo_aMEju4gZg-MIbF8bKMVM6CWAF0AO9DxAlemaXMw,149
-Dshell/DISCORD_COMMANDS/dshell_channel.py,sha256=2qnbI2tUu5sowJVOVkY4p-l6Gu-5Gw9BEP3MItScvV8,8939
-Dshell/DISCORD_COMMANDS/dshell_member.py,sha256=L3Ud4nza_55n9R02kfL-iNK9ybBczx6SDkccUTWxv3s,7646
-Dshell/DISCORD_COMMANDS/dshell_message.py,sha256=SvX9I4nYMWm8ACE56QJBM5yEiZoXIKbTLkIOyrENd5o,6253
+Dshell/DISCORD_COMMANDS/dshell_channel.py,sha256=kjSTJnTTXHprCURESlO_62jv3Yu832lUELJi47PyWdo,18538
+Dshell/DISCORD_COMMANDS/dshell_member.py,sha256=CKlE9oZqI7D986uSgyRuKWJMrJD0m5BveLtzwxRtFxY,8840
+Dshell/DISCORD_COMMANDS/dshell_message.py,sha256=pu5IUQH8wfteFUL0mO4Q9xEojKbKkticV-h8zrgpco8,7277
 Dshell/DISCORD_COMMANDS/dshell_pastbin.py,sha256=TkWFGRRTvhhJgvwkDFx9Fz4UM2UUFwxyq0laMVx0mUk,881
 Dshell/DISCORD_COMMANDS/dshell_role.py,sha256=fotsYWGHebgIx157q-zRbcCd90Y7jIuKCZ8udQoEzSU,4970
 Dshell/_DshellInterpreteur/__init__.py,sha256=xy5-J-R3YmY99JF3NBHTRRLsComFxpjnCA5xacISctU,35
 Dshell/_DshellInterpreteur/dshell_interpreter.py,sha256=sYQ9qIVjRedwkfITEeVAFN0RdHjiY7RGO6z0j4D7eno,23072
 Dshell/_DshellParser/__init__.py,sha256=ONDfhZMvClqP_6tE8SLjp-cf3pXL-auQYnfYRrHZxC4,56
-Dshell/_DshellParser/ast_nodes.py,sha256=2qwL_M0ELPia6L6gqwgV5hqprvyuo97cx3Zk2dVz09U,15341
+Dshell/_DshellParser/ast_nodes.py,sha256=heOMQzAchQ8UroQaMSfU_6SYEXw-nme0jGcoVkCXPUs,15284
 Dshell/_DshellParser/dshell_parser.py,sha256=RxS5GgmTel10pH9HII0X_8XZnVyIQGd9ThZZcZDpEqc,15545
 Dshell/_DshellTokenizer/__init__.py,sha256=LIQSRhDx2B9pmPx5ADMwwD0Xr9ybneVLhHH8qrJWw_s,172
-Dshell/_DshellTokenizer/dshell_keywords.py,sha256=l8PZhSXLhFHpi8RRoBRm2NRvAyA_NoONw0vRU4bw3t0,5058
+Dshell/_DshellTokenizer/dshell_keywords.py,sha256=yBTXKBCb7NZa-DGDeeyIZrl_CS1Y4WCmwshUdBHQhlo,5642
 Dshell/_DshellTokenizer/dshell_token_type.py,sha256=gYIb2XN2YcgeRgmar_rBDS5CGmwfmxihu8mOW_d6lbE,1533
 Dshell/_DshellTokenizer/dshell_tokenizer.py,sha256=LZGs4Ytuyx9Galazqtz32lS4Mmu9yZya1B7AzFQAQOk,7150
-dshellinterpreter-0.2.8.2.dist-info/licenses/LICENSE,sha256=lNgcw1_xb7QENAQi3uHGymaFtbs0RV-ihiCd7AoLQjA,1082
-dshellinterpreter-0.2.8.2.dist-info/METADATA,sha256=IPexhINATJKbgpDcPbkvhsTeIL0gmPSHAKI2FLm8d0k,1122
-dshellinterpreter-0.2.8.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-dshellinterpreter-0.2.8.2.dist-info/top_level.txt,sha256=B4CMhtmchGwPQJLuqUy0GhRG-0cUGxKL4GqEbCiB_vE,7
-dshellinterpreter-0.2.8.2.dist-info/RECORD,,
+dshellinterpreter-0.2.9.1.dist-info/licenses/LICENSE,sha256=lNgcw1_xb7QENAQi3uHGymaFtbs0RV-ihiCd7AoLQjA,1082
+dshellinterpreter-0.2.9.1.dist-info/METADATA,sha256=UuWw60cLp5BQu4oyfSI5gBpCg1FOuILbcNwDeLTYO6U,1122
+dshellinterpreter-0.2.9.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dshellinterpreter-0.2.9.1.dist-info/top_level.txt,sha256=B4CMhtmchGwPQJLuqUy0GhRG-0cUGxKL4GqEbCiB_vE,7
+dshellinterpreter-0.2.9.1.dist-info/RECORD,,