dshellInterpreter 0.2.2__py3-none-any.whl → 0.2.4__py3-none-any.whl

Dshell/DISCORD_COMMANDS/__init__.py

@@ -1,3 +1,5 @@
 from .dshell_channel import *
 from .dshell_message import *
 from .dshell_member import *
+from .dshell_pastbin import *
+from .dshell_role import *

Dshell/DISCORD_COMMANDS/dshell_channel.py

@@ -3,6 +3,7 @@ from re import search
 from typing import Union
 
 from discord import MISSING, PermissionOverwrite, Member, Role, Message
+from discord.utils import _MissingSentinel
 
 __all__ = [
     'dshell_create_text_channel',
@@ -19,16 +20,29 @@ async def dshell_create_text_channel(ctx: Message,
                                      category=None,
                                      position=MISSING,
                                      slowmode=MISSING,
-                                     topic=MISSING, nsfw=MISSING,
+                                     topic=MISSING,
+                                     nsfw=MISSING,
                                      permission: dict[Union[Member, Role], PermissionOverwrite] = MISSING,
                                      reason=None):
     """
     Creates a text channel on the server
     """
 
-    channel_category = ctx.channel.guild.get_channel(category)
+    if not isinstance(position, _MissingSentinel) and not isinstance(position, int):
+        raise Exception(f"Position must be an integer, not {type(position)} !")
 
-    created_channel = await ctx.guild.create_text_channel(name,
+    if not isinstance(slowmode, _MissingSentinel) and not isinstance(slowmode, int):
+        raise Exception(f"Slowmode must be an integer, not {type(slowmode)} !")
+
+    if not isinstance(topic, _MissingSentinel) and not isinstance(topic, str):
+        raise Exception(f"Topic must be a string, not {type(topic)} !")
+
+    if not isinstance(nsfw, _MissingSentinel) and not isinstance(nsfw, bool):
+        raise Exception(f"NSFW must be a boolean, not {type(nsfw)} !")
+
+    channel_category = ctx.channel.category if category is None else ctx.channel.guild.get_channel(category)
+
+    created_channel = await ctx.guild.create_text_channel(str(name),
                                                           category=channel_category,
                                                           position=position,
                                                           slowmode_delay=slowmode,
@@ -39,6 +53,7 @@ async def dshell_create_text_channel(ctx: Message,
 
     return created_channel.id
 
+
 async def dshell_create_voice_channel(ctx: Message,
                                       name,
                                       category=None,
@@ -49,10 +64,15 @@ async def dshell_create_voice_channel(ctx: Message,
     """
     Creates a voice channel on the server
     """
+    if not isinstance(position, _MissingSentinel) and not isinstance(position, int):
+        raise Exception(f"Position must be an integer, not {type(position)} !")
+
+    if not isinstance(bitrate, _MissingSentinel) and not isinstance(bitrate, int):
+        raise Exception(f"Bitrate must be an integer, not {type(bitrate)} !")
 
-    channel_category = ctx.channel.guild.get_channel(category)
+    channel_category = ctx.channel.category if category is None else ctx.channel.guild.get_channel(category)
 
-    created_channel = await ctx.guild.create_voice_channel(name,
+    created_channel = await ctx.guild.create_voice_channel(str(name),
                                                            category=channel_category,
                                                            position=position,
                                                            bitrate=bitrate,
@@ -67,6 +87,8 @@ async def dshell_delete_channel(ctx: Message, channel=None, reason=None, timeout
     Deletes a channel.
     You can add a waiting time before it is deleted (in seconds)
     """
+    if not isinstance(timeout, int):
+        raise Exception(f'Timeout must be an integer, not {type(timeout)} !')
 
     channel_to_delete = ctx.channel if channel is None else ctx.channel.guild.get_channel(channel)
 
@@ -85,6 +107,12 @@ async def dshell_delete_channels(ctx: Message, name=None, regex=None, reason=Non
     Deletes all channels with the same name and/or matching the same regex.
     If neither is set, it will delete all channels with the same name as the one where the command was executed.
     """
+    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)} !")
+
     for channel in ctx.channel.guild.channels:
 
         if name is not None and channel.name == str(name):
@@ -93,19 +121,32 @@ async def dshell_delete_channels(ctx: Message, name=None, regex=None, reason=Non
         elif regex is not None and search(regex, channel.name):
             await channel.delete(reason=reason)
 
+
 async def dshell_edit_text_channel(ctx: Message,
-                                      channel=None,
-                                      name=None,
-                                      position=MISSING,
-                                      slowmode=MISSING,
-                                      topic=MISSING,
-                                      nsfw=MISSING,
-                                      permission: dict[Union[Member, Role], PermissionOverwrite] = MISSING,
-                                      reason=None):
+                                   channel=None,
+                                   name=None,
+                                   position=MISSING,
+                                   slowmode=MISSING,
+                                   topic=MISSING,
+                                   nsfw=MISSING,
+                                   permission: dict[Union[Member, Role], PermissionOverwrite] = MISSING,
+                                   reason=None):
     """
     Edits a text channel on the server
     """
 
+    if not isinstance(position, _MissingSentinel) and not isinstance(position, int):
+        raise Exception(f"Position must be an integer, not {type(position)} !")
+
+    if not isinstance(slowmode, _MissingSentinel) and not isinstance(slowmode, int):
+        raise Exception(f"Slowmode must be an integer, not {type(slowmode)} !")
+
+    if not isinstance(topic, _MissingSentinel) and not isinstance(topic, str):
+        raise Exception(f"Topic must be a string, not {type(topic)} !")
+
+    if not isinstance(nsfw, _MissingSentinel) and not isinstance(nsfw, bool):
+        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)
 
     if channel_to_edit is None:
@@ -121,16 +162,22 @@ async def dshell_edit_text_channel(ctx: Message,
 
     return channel_to_edit.id
 
+
 async def dshell_edit_voice_channel(ctx: Message,
-                                      channel=None,
-                                      name=None,
-                                      position=MISSING,
-                                      bitrate=MISSING,
-                                      permission: dict[Union[Member, Role], PermissionOverwrite] = MISSING,
-                                      reason=None):
+                                    channel=None,
+                                    name=None,
+                                    position=MISSING,
+                                    bitrate=MISSING,
+                                    permission: dict[Union[Member, Role], PermissionOverwrite] = MISSING,
+                                    reason=None):
     """
     Edits a voice channel on the server
     """
+    if not isinstance(position, _MissingSentinel) and not isinstance(position, int):
+        raise Exception(f"Position must be an integer, not {type(position)} !")
+
+    if not isinstance(bitrate, _MissingSentinel) and not isinstance(bitrate, 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)
 

Dshell/DISCORD_COMMANDS/dshell_member.py

@@ -1,5 +1,6 @@
-from discord import MISSING, Message, Member
+from datetime import timedelta, datetime
 
+from discord import MISSING, Message, Member, Permissions
 
 __all__ = [
     "dshell_ban_member",
@@ -8,8 +9,12 @@ __all__ = [
     "dshell_rename_member",
     "dshell_add_roles",
     "dshell_remove_roles",
+    "dshell_check_permissions",
+    "dshell_timeout_member",
+    "dshell_move_member"
 ]
 
+
 async def dshell_ban_member(ctx: Message, member: int, reason: str = MISSING):
     """
     Bans a member from the server.
@@ -17,12 +22,13 @@ async def dshell_ban_member(ctx: Message, member: int, reason: str = MISSING):
     banned_member = ctx.channel.guild.get_member(member)
 
     if not banned_member:
-        return 1 # Member not found in the server
+        raise Exception(f'Member {member} not found in the server !')
 
     await ctx.channel.guild.ban(banned_member, reason=reason)
 
     return banned_member.id
 
+
 async def dshell_unban_member(ctx: Message, user: int, reason: str = MISSING):
     """
     Unbans a user from the server.
@@ -36,12 +42,13 @@ async def dshell_unban_member(ctx: Message, user: int, reason: str = MISSING):
             break
 
     if not user_to_unban:
-        return 1  # User not found in the banned list
+        raise Exception(f'User {user} not found in the banned list')
 
     await ctx.channel.guild.unban(user_to_unban, reason=reason)
 
     return user_to_unban.id
 
+
 async def dshell_kick_member(ctx: Message, member: int, reason: str = MISSING):
     """
     Kicks a member from the server.
@@ -49,12 +56,33 @@ async def dshell_kick_member(ctx: Message, member: int, reason: str = MISSING):
     kicked_member = ctx.channel.guild.get_member(member)
 
     if not kicked_member:
-        return 1  # Member not found in the server
+        raise Exception(f'Member {member} not found in the server !')
 
     await ctx.channel.guild.kick(kicked_member, reason=reason)
 
     return kicked_member.id
 
+
+async def dshell_timeout_member(ctx: Message, duration: int, member=None, reason: str = MISSING):
+    """
+    Timeouts a member in the server for a specified duration.
+    """
+    target_member = ctx.author if member is None else ctx.channel.guild.get_member(member)
+
+    if not target_member:
+        raise Exception(f'Member {member} not found in the server !')
+
+    if not isinstance(duration, int):
+        raise TypeError("Duration must be an integer representing seconds.")
+
+    if duration < 0:
+        raise ValueError("Duration must be a non-negative integer.")
+
+    await target_member.timeout(until=datetime.now() + timedelta(seconds=duration), reason=reason)
+
+    return target_member.id
+
+
 async def dshell_rename_member(ctx: Message, new_name, member=None):
     """
     Renames a member in the server.
@@ -62,44 +90,97 @@ async def dshell_rename_member(ctx: Message, new_name, member=None):
     renamed_member = ctx.channel.guild.get_member(member)
 
     if not renamed_member:
-        return 1  # Member not found in the server
+        raise Exception(f'Member {member} not found in the server !')
 
     await renamed_member.edit(nick=new_name)
 
     return renamed_member.id
 
-async def dshell_add_roles(ctx: Message, roles: list[int], member=None, reason: str = None):
+
+async def dshell_add_roles(ctx: Message, roles: list[int] | int, member=None, reason: str = None):
     """
     Adds roles to a member in the server.
     """
     target_member: Member = ctx.author if member is None else ctx.channel.guild.get_member(member)
 
     if not target_member:
-        return 1  # Member not found in the server
+        raise Exception(f'Member {member} not found in the server !')
+
+    if isinstance(roles, int):
+        roles = [roles]
 
     roles_to_add = [ctx.channel.guild.get_role(role_id) for role_id in roles if ctx.channel.guild.get_role(role_id)]
 
     if not roles_to_add:
-        return 2  # No valid roles found
+        raise Exception(f'No role found !')
 
     await target_member.add_roles(*roles_to_add, reason=reason)
 
     return target_member.id
 
-async def dshell_remove_roles(ctx: Message, roles: list[int], member=None, reason: str = None):
+
+async def dshell_remove_roles(ctx: Message, roles: list[int] | int, member=None, reason: str = None):
     """
     Removes roles from a member in the server.
     """
     target_member: Member = ctx.author if member is None else ctx.channel.guild.get_member(member)
 
     if not target_member:
-        return 1  # Member not found in the server
+        raise Exception(f'Member {member} not found in the server !')
+
+    if isinstance(roles, int):
+        roles = [roles]
 
     roles_to_remove = [ctx.channel.guild.get_role(role_id) for role_id in roles if ctx.channel.guild.get_role(role_id)]
 
     if not roles_to_remove:
-        return 2  # No valid roles found
+        raise Exception(f'No role found !')
 
     await target_member.remove_roles(*roles_to_remove, reason=reason)
 
-    return target_member.id
+    return target_member.id
+
+
+async def dshell_check_permissions(ctx: Message, permissions, member=None):
+    """
+    Checks if a member has specific permissions in the server.
+    """
+    target_member: Member = ctx.author if member is None else ctx.channel.guild.get_member(member)
+
+    if not target_member:
+        raise Exception(f'Member {member} not found in the server !')
+
+    if not isinstance(permissions, int):
+        raise TypeError("Permissions must be an integer representing permissions flags.")
+
+    permissions_to_check = Permissions(permissions)
+    member_permissions = target_member.guild_permissions
+
+    if (permissions_to_check.value & member_permissions.value) != 0:
+        return True
+    return False
+
+
+async def dshell_move_member(ctx: Message, member=None, channel=None, disconnect: bool = False, reason=None):
+    """
+    Moves a member to another channel.
+    If channel is None, disconnect the member from their current voice channel.
+    """
+    target_member = ctx.author if member is None else ctx.channel.guild.get_member(member)
+    target_channel = ctx.channel if channel is None else ctx.channel.guild.get_channel(channel)
+
+    if not target_member:
+        raise Exception(f'Member {member} not found in the server !')
+
+    if target_member.voice.channel is None:
+        raise Exception(f'Member {target_member.name} is not in a voice channel !')
+
+    if not target_channel:
+        raise Exception(f'Channel {channel} not found in the server !')
+
+    if disconnect:
+        await target_member.move_to(None, reason=reason)
+    else:
+        await target_member.move_to(target_channel, reason=reason)
+
+    return target_member.id

Dshell/DISCORD_COMMANDS/dshell_message.py

@@ -1,24 +1,27 @@
-from discord import Embed, Message
-from discord.ext import commands
 from re import search
 
+from discord import Embed, Message
+from discord.ext import commands
 
 __all__ = [
     'dshell_send_message',
     'dshell_delete_message',
     'dshell_purge_message',
     'dshell_edit_message',
-    'dshell_research_regex_message',
+    'dshell_get_hystory_messages',
     'dshell_research_regex_in_content',
     'dshell_add_reactions',
     'dshell_remove_reactions'
 ]
 
 
-async def dshell_send_message(ctx: Message, message=None, delete=None, channel=None, embeds=None, embed=None):
+async def dshell_send_message(ctx: Message, message=None, delete=None, channel=None, embeds=None):
     """
     Sends 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)} !')
+
     channel_to_send = ctx.channel if channel is None else ctx.channel.guild.get_channel(channel)
 
     if channel_to_send is None:
@@ -32,8 +35,8 @@ async def dshell_send_message(ctx: Message, message=None, delete=None, channel=N
     elif isinstance(embeds, Embed):
         embeds = ListNode([embeds])
 
-    if embed is not None and isinstance(embed, Embed):
-        embeds.add(embed)
+    else:
+        raise Exception(f'Embeds must be a list of Embed objects or a single Embed object, not {type(embeds)} !')
 
     sended_message = await channel_to_send.send(message,
                                                 delete_after=delete,
@@ -47,7 +50,11 @@ async def dshell_delete_message(ctx: Message, message=None, reason=None, delay=0
     Deletes a message
     """
 
-    delete_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)
+    delete_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)
+
+    if not isinstance(delay, int):
+        raise Exception(f'Delete delay must be an integer, not {type(delay)} !')
 
     if delay > 3600:
         raise Exception(f'The message deletion delay is too long! ({delay} seconds)')
@@ -60,6 +67,9 @@ async def dshell_purge_message(ctx: Message, message_number, channel=None, reaso
     Purges messages from a channel
     """
 
+    if not isinstance(message_number, int):
+        raise Exception(f'Message number must be an integer, not {type(message_number)} !')
+
     purge_channel = ctx.channel if channel is None else ctx.channel.guild.get_channel(channel)
 
     if purge_channel is None:
@@ -72,7 +82,8 @@ async def dshell_edit_message(ctx: Message, message, new_content=None, embeds=No
     """
     Edits a message
     """
-    edit_message = ctx.channel.get_partial_message(message)  # builds a reference to the message (even if it doesn't exist)
+    edit_message = ctx.channel.get_partial_message(
+        message)  # builds a reference to the message (even if it doesn't exist)
 
     if embeds is None:
         embeds = []
@@ -84,11 +95,15 @@ async def dshell_edit_message(ctx: Message, message, new_content=None, embeds=No
 
     return edit_message.id
 
-async def dshell_research_regex_message(ctx: Message, regex, channel=None):
+
+async def dshell_get_hystory_messages(ctx: Message, channel=None, limit=None):
     """
     Searches for messages matching a regex in a channel
     """
 
+    if limit is not None and not isinstance(limit, int):
+        raise Exception(f"Limit must be an integer or None, not {type(limit)}!")
+
     search_channel = ctx.channel if channel is None else ctx.channel.guild.get_channel(channel)
 
     if search_channel is None:
@@ -97,30 +112,35 @@ async def dshell_research_regex_message(ctx: Message, regex, channel=None):
     from .._DshellParser.ast_nodes import ListNode
 
     messages = ListNode([])
-    async for message in search_channel.history(limit=100):
-        if search(regex, message.content):
-            messages.add(message)
+    async for message in search_channel.history(limit=limit):
+        messages.add(message)
 
     if not messages:
-        raise commands.CommandError(f"No messages found matching the regex '{regex}'.")
+        raise commands.CommandError(f"No messages in {search_channel.mention}.")
 
     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 search(regex, content if content is not None else ctx.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):
     """
     Adds reactions to a message
     """
-    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)
+    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)
 
     if isinstance(reactions, str):
         reactions = (reactions,)
@@ -130,11 +150,13 @@ async def dshell_add_reactions(ctx: Message, reactions, message=None):
 
     return message.id
 
+
 async def dshell_remove_reactions(ctx: Message, reactions, message=None):
     """
     Removes reactions from a message
     """
-    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)
+    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)
 
     if isinstance(reactions, str):
         reactions = [reactions]
@@ -142,4 +164,4 @@ async def dshell_remove_reactions(ctx: Message, reactions, message=None):
     for reaction in reactions:
         await message.clear_reaction(reaction)
 
-    return message.id
+    return message.id

Dshell/DISCORD_COMMANDS/dshell_pastbin.py

@@ -0,0 +1,30 @@
+from discord import Message
+from requests import get
+
+__all__ = [
+    'dshell_get_pastbin'
+]
+
+
+async def dshell_get_pastbin(ctx: Message, code: str):
+    """
+    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
+
+    with get(f"https://pastebin.com/raw/{code}", stream=True, timeout=10) as response:
+
+        if not response.ok:
+            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
+
+    return content

Dshell/DISCORD_COMMANDS/dshell_role.py

@@ -0,0 +1,116 @@
+from discord import MISSING, Message, Role, Permissions, PermissionOverwrite
+from discord.utils import _MissingSentinel
+from .._DshellInterpreteur.dshell_interpreter import build_colour, ListNode
+
+__all__ = [
+    'dshell_create_role',
+    'dshell_delete_roles',
+    'dshell_edit_role'
+
+]
+
+async def dshell_create_role(ctx: Message,
+                             name: str = MISSING,
+                             permissions: dict[None, PermissionOverwrite] = MISSING,
+                             color: int = MISSING,
+                             hoist: bool = MISSING,
+                             mentionable: bool = MISSING,
+                             reason: str = None):
+    """
+    Creates a role on the server.
+    """
+    if not isinstance(name, (str, _MissingSentinel)):
+        raise Exception(f"Name must be a string, not {type(name)} !")
+
+    if not isinstance(permissions, (dict, _MissingSentinel)):
+        raise Exception(f"Permissions must be a PermissionNode, not {type(permissions)} !")
+
+    colour = build_colour(color)
+
+    if not isinstance(hoist, (bool, _MissingSentinel)):
+        raise Exception(f"Hoist must be a boolean, not {type(permissions)} !")
+
+    if not isinstance(mentionable, (bool, _MissingSentinel)):
+        raise Exception(f"Mentionable must be a boolean, not {type(permissions)} !")
+
+    if isinstance(permissions, dict):
+        if None in permissions:
+            allow, deny = permissions[None].pair()
+            permissions = allow
+
+    created_role = await ctx.guild.create_role(name=name,
+                                               permissions=permissions,
+                                               colour=colour,
+                                               hoist=hoist,
+                                               mentionable=mentionable,
+                                               reason=str(reason))
+
+    return created_role.id
+
+
+async def dshell_delete_roles(ctx: Message, roles, reason=None):
+    """
+    Delete the role on the server
+    """
+    roles: int | ListNode
+    if not isinstance(roles, (int, ListNode)):
+        raise Exception(f"Role must be a int, role mention or NodeList of both, not {type(roles)} !")
+
+    if isinstance(roles, int):
+        roles: tuple = (roles, )
+
+    for i in roles:
+        role_to_delete = ctx.guild.get_role(i)
+
+        if role_to_delete is None:
+            raise Exception(f'Role {i} not found in the server !')
+
+        await role_to_delete.delete(reason=str(reason))
+
+
+async def dshell_edit_role(ctx: Message,
+                           role,
+                           name=None,
+                           permissions: dict[None, PermissionOverwrite]=None,
+                           color=None,
+                           hoist=None,
+                           mentionable=None,
+                           position=None,
+                           reason=None,):
+    """
+    Edit the current role
+    """
+    if not isinstance(role, int):
+        raise Exception(f"Role must be a int or role mention not {type(role)} !")
+
+    role_to_edit = ctx.guild.get_role(role)
+
+    if not isinstance(name, (str, None)):
+        raise Exception(f"Name must be a string, not {type(name)} !")
+
+    if not isinstance(permissions, (dict, None)):
+        raise Exception(f"Permissions must be a PermissionNode, not {type(permissions)} !")
+
+    if isinstance(permissions, dict):
+        if None in permissions:
+            allow, deny = permissions[None].pair()
+            permissions = allow
+
+    colour = build_colour(color)
+
+    if not isinstance(hoist, (bool, None)):
+        raise Exception(f"Hoist must be a boolean, not {type(permissions)} !")
+
+    if not isinstance(mentionable, (bool, None)):
+        raise Exception(f"Mentionable must be a boolean, not {type(permissions)} !")
+
+    if not isinstance(position, (int, None)):
+        raise Exception(f"Position must be an integer, not {type(permissions)} !")
+
+    await role_to_edit.edit(name=name if name is not None else role_to_edit.name,
+                            permissions=permissions if permissions is not None else role_to_edit.permissions,
+                            colour=colour if color is not None else role_to_edit.colour,
+                            hoist=hoist if hoist is not None else role_to_edit.hoist,
+                            mentionable=mentionable if mentionable is not None else role_to_edit.mentionable,
+                            position=position if position is not None else role_to_edit.position,
+                            reason=str(reason))

Dshell/_DshellInterpreteur/dshell_interpreter.py

@@ -33,7 +33,24 @@ class DshellInterpreteur:
         """
         self.ast: list[ASTNode] = parse(DshellTokenizer(code).start(), StartNode([]))[0]
         self.env: dict[str, Any] = {
-            '__ret__': None}  # environment variables, '__ret__' is used to store the return value of commands
+            '__ret__': None,  # environment variables, '__ret__' is used to store the return value of commands
+            '__guild__': ctx.channel.guild.name,
+            '__channel__': ctx.channel.name,
+            '__author__': ctx.author.name,
+            '__author_display_name__': ctx.author.display_name,
+            '__author_avatar__': ctx.author.display_avatar.url if ctx.author.display_avatar else None,
+            '__author_discriminator__': ctx.author.discriminator,
+            '__author_bot__': ctx.author.bot,
+            '__author_nick__': ctx.author.nick if hasattr(ctx.author, 'nick') else None,
+            '__author_avatar_url__': ctx.author.avatar.url if ctx.author.avatar else None,
+            '__author_id__': ctx.author.id,
+            '__message__': ctx.content,
+            '__message_id__': ctx.id,
+            '__channel_name__': ctx.channel.name,
+            '__channel_type__': ctx.channel.type.name if hasattr(ctx.channel, 'type') else None,
+            '__channel_id__': ctx.channel.id,
+            '__private_channel__': isinstance(ctx.channel, PrivateChannel),
+        }
         self.vars = vars if vars is not None else ''
         self.ctx: context = ctx
         if debug:
@@ -170,12 +187,12 @@ def get_params(node: ParamNode, interpreter: DshellInterpreteur) -> dict[str, An
     englobe_args = regrouped_args.pop('--*', {})  # get the arguments that are not mandatory
     obligate = [i for i in regrouped_args.keys() if regrouped_args[i] == '*']  # get the obligatory parameters
 
-
     g: list[list[Token]] = DshellTokenizer(interpreter.vars).start()
     env_give_variables = regroupe_commandes(g[0], interpreter)[0] if g else {}
 
     gived_variables = env_give_variables.pop('*', ())  # get the variables given in the environment
-    englobe_gived_variables: dict = env_give_variables.pop('--*', {})  # get the variables given in the environment that are not mandatory
+    englobe_gived_variables: dict = env_give_variables.pop('--*',
+                                                           {})  # get the variables given in the environment that are not mandatory
 
     for key, value in zip(regrouped_args.keys(), gived_variables):
         regrouped_args[key] = value
@@ -187,7 +204,8 @@ def get_params(node: ParamNode, interpreter: DshellInterpreteur) -> dict[str, An
             del englobe_args[key]
             break
 
-    for key, englobe_gived_key, englobe_gived_value in zip(englobe_args.keys(), englobe_gived_variables.keys(), englobe_gived_variables.values()):
+    for key, englobe_gived_key, englobe_gived_value in zip(englobe_args.keys(), englobe_gived_variables.keys(),
+                                                           englobe_gived_variables.values()):
         if key == englobe_gived_key:
             regrouped_args[key] = englobe_gived_value
 
@@ -203,10 +221,9 @@ def get_params(node: ParamNode, interpreter: DshellInterpreteur) -> dict[str, An
         if regrouped_args[key] == '*':
             raise Exception(f"'{key}' is an obligatory parameter, but no value was given for it.")
 
-    print(regrouped_args)
-
     return regrouped_args
 
+
 def eval_expression_inline(if_node: IfNode, interpreter: DshellInterpreteur) -> Token:
     """
     Eval a conditional expression inline.
@@ -312,7 +329,7 @@ def regroupe_commandes(body: list[Token], interpreter: DshellInterpreteur) -> li
                     type_=DTT.SEPARATOR, value=body[i].value, position=body[i].position)
                 ] + body[i + 1:], interpreter
             )  # add a sub-dictionary for sub-commands
-            #return list_tokens
+            # return list_tokens
 
         elif (body[i].type == DTT.SEPARATOR and
               (body[i + 1].type == DTT.MATHS_OPERATOR and body[i + 1].value == '*') and
@@ -349,9 +366,8 @@ def build_embed(body: list[Token], fields: list[FieldEmbedNode], interpreter: Ds
         a: dict[str, Token]
         args_fields.append(a)
 
-    if 'color' in args_main_embed and isinstance(args_main_embed['color'],
-                                                 ListNode):  # if color is a ListNode, convert it to Colour
-        args_main_embed['color'] = Colour.from_rgb(*args_main_embed['color'])
+    if 'color' in args_main_embed:
+        args_main_embed['color'] = build_colour(args_main_embed['color'])  # convert color to Colour object or int
 
     embed = Embed(**args_main_embed)  # build the main embed
     for field in args_fields:
@@ -359,6 +375,21 @@ def build_embed(body: list[Token], fields: list[FieldEmbedNode], interpreter: Ds
 
     return embed
 
+def build_colour(color: Union[int, ListNode]) -> Union[Colour, int]:
+    """
+    Builds a Colour object from an integer or a ListNode.
+    :param color: The color to build.
+    :return: A Colour object.
+    """
+    if isinstance(color, int):
+        return color
+    elif isinstance(color, (ListNode, list)):
+        if not len(color) == 3:
+            raise ValueError(f"Color must be a list of 3 integers, not {len(color)} elements !")
+        return Colour.from_rgb(*color)
+    else:
+        raise TypeError(f"Color must be an integer or a ListNode, not {type(color)} !")
+
 
 def build_permission(body: list[Token], interpreter: DshellInterpreteur) -> dict[
     Union[Member, Role], PermissionOverwrite]:
@@ -429,9 +460,12 @@ class DshellPermissions:
         if member is not None:
             return member
 
-        if role is not None:
+        elif role is not None:
             return role
 
+        else:
+            raise ValueError(f"No member or role found with ID {target_id} in guild {guild.name}.")
+
     @staticmethod
     def get_member(guild: Guild, target_id: int) -> Member:
         """
@@ -463,10 +497,11 @@ class DshellPermissions:
     def get_permission_overwrite(self, guild: Guild) -> dict[Union[Member, Role], PermissionOverwrite]:
         """
         Returns a PermissionOverwrite object with member and role permissions.
+        If no members or roles are specified, it returns a PermissionOverwrite with None key.
         :param guild: The Discord server
         :return: A dictionary of PermissionOverwrite objects with members and roles as keys
         """
-        permissions: dict[Union[Member, Role], PermissionOverwrite] = {}
+        permissions: dict[Union[Member, Role, None], PermissionOverwrite] = {}
         target_keys = self.target.keys()
 
         if 'members' in target_keys:
@@ -489,6 +524,9 @@ class DshellPermissions:
                     deny=Permissions(permissions=self.target.get('deny', 0))
                 )
         else:
-            raise ValueError("No members or roles specified in the permissions target.")
+            permissions[None] = PermissionOverwrite.from_pair(
+                allow=Permissions(permissions=self.target.get('allow', 0)),
+                deny=Permissions(permissions=self.target.get('deny', 0))
+            )
 
         return permissions

Dshell/_DshellParser/ast_nodes.py

@@ -1,5 +1,5 @@
-from typing import Optional, Any
 from random import randint
+from typing import Optional, Any
 
 from .._DshellTokenizer.dshell_token_type import Token
 
@@ -35,6 +35,7 @@ class StartNode(ASTNode):
     """
     Node representing the start of the AST.
     """
+
     def __init__(self, body: list):
         self.body = body
 
@@ -56,6 +57,7 @@ class ElseNode(ASTNode):
     """
     Node representing the 'else' part of an if statement.
     """
+
     def __init__(self, body: list[Token]):
         """
         :param body: list of tokens representing the body of the else statement
@@ -80,6 +82,7 @@ class ElifNode(ASTNode):
     """
     Node representing an 'elif' part of an if statement.
     """
+
     def __init__(self, condition: list[Token], body: list[Token], parent: "IfNode"):
         """
         :param condition: list of tokens representing the condition for the elif
@@ -110,6 +113,7 @@ class IfNode(ASTNode):
     """
     Node representing an 'if' statement, which can contain 'elif' and 'else' parts.
     """
+
     def __init__(self, condition: list[Token], body: list[Token], elif_nodes: Optional[list[ElifNode]] = None,
                  else_body: Optional[ElseNode] = None):
         """
@@ -141,10 +145,12 @@ class IfNode(ASTNode):
             "id": self.id
         }
 
+
 class LoopNode(ASTNode):
     """
     Node representing a loop structure in the AST.
     """
+
     def __init__(self, variable: "VarNode", body: list):
         """
         :param variable: VarNode representing the loop variable. This variable will be used to iterate over the body. Can contain a ListNode, string or integer.
@@ -167,10 +173,12 @@ class LoopNode(ASTNode):
             "body": [token.to_dict() for token in self.body]
         }
 
+
 class ArgsCommandNode(ASTNode):
     """
     Node representing the arguments of a command in the AST.
     """
+
     def __init__(self, body: list[Token]):
         """
         :param body: list of tokens representing the arguments of the command
@@ -195,6 +203,7 @@ class CommandNode(ASTNode):
     """
     Node representing a command in the AST.
     """
+
     def __init__(self, name: str, body: ArgsCommandNode):
         """
         :param name: The command name (e.g., "sm", "cc")
@@ -222,6 +231,7 @@ class VarNode(ASTNode):
     """
     Node representing a variable declaration in the AST.
     """
+
     def __init__(self, name: Token, body: list[Token]):
         """
         :param name: Token representing the variable name
@@ -249,6 +259,7 @@ class EndNode(ASTNode):
     """
     Node representing the end of the AST.
     """
+
     def __init__(self):
         pass
 
@@ -269,6 +280,7 @@ class FieldEmbedNode(ASTNode):
     """
     Node representing a field in an embed structure.
     """
+
     def __init__(self, body: list[Token]):
         """
         :param body: list of tokens representing the field content
@@ -293,6 +305,7 @@ class EmbedNode(ASTNode):
     """
     Node representing an embed structure in the AST.
     """
+
     def __init__(self, body: list[Token], fields: list[FieldEmbedNode]):
         """
         :param body: list of tokens representing the embed content
@@ -320,6 +333,7 @@ class PermissionNode(ASTNode):
     """
     Node representing a permission structure in the AST.
     """
+
     def __init__(self, body: list[Token]):
         """
         :param body: list of tokens representing the permission content
@@ -344,6 +358,7 @@ class SleepNode(ASTNode):
     """
     Node representing a sleep command in the AST.
     """
+
     def __init__(self, body: list[Token]):
         """
         :param body: list of tokens representing the sleep duration
@@ -396,6 +411,7 @@ class IdentOperationNode(ASTNode):
             "args": self.args.to_dict()
         }
 
+
 class ParamNode(ASTNode):
     """
     Node representing a parameter in the AST.
@@ -423,6 +439,7 @@ class ParamNode(ASTNode):
             "body": [token.to_dict() for token in self.body]
         }
 
+
 class ListNode(ASTNode):
     """
     Node representing a list structure in the AST.

Dshell/_DshellParser/dshell_parser.py

@@ -7,7 +7,7 @@ __all__ = [
     "ast_to_dict",
 ]
 
-from typing import Union, TYPE_CHECKING
+from typing import Union
 
 from .ast_nodes import (ASTNode,
                         CommandNode,
@@ -25,11 +25,10 @@ from .ast_nodes import (ASTNode,
                         PermissionNode,
                         ParamNode,
                         StartNode)
+from .._DshellTokenizer import dshell_operators
 from .._DshellTokenizer.dshell_token_type import DshellTokenType as DTT
 from .._DshellTokenizer.dshell_token_type import Token
 
-from .._DshellTokenizer import dshell_operators
-
 
 def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[ASTNode], int]:
     """
@@ -213,6 +212,7 @@ elif first_token_line.type == DTT.LIST: # si le token est une liste (qui comport
     last_block.body.append(list_node)
     """
 
+
 def ast_to_dict(obj):
     if isinstance(obj, list):
         return [ast_to_dict(item) for item in obj]
@@ -221,6 +221,7 @@ def ast_to_dict(obj):
     else:
         return obj  # fallback for primitives or tokens
 
+
 def dict_to_ast(data):
     """
     Convertit un dictionnaire en une structure AST.
@@ -232,6 +233,7 @@ def dict_to_ast(data):
     elif isinstance(data, dict):
         pass
 
+
 def parser_inline(tokens: list[Token]) -> tuple[list[list[Token]], bool]:
     """
     Transforme une ligne avec un if/else inline en structure multilignes

Dshell/_DshellTokenizer/dshell_keywords.py

@@ -10,8 +10,10 @@ __all__ = [
 from typing import Callable
 
 from ..DISCORD_COMMANDS.dshell_channel import *
-from ..DISCORD_COMMANDS.dshell_message import *
 from ..DISCORD_COMMANDS.dshell_member import *
+from ..DISCORD_COMMANDS.dshell_message import *
+from ..DISCORD_COMMANDS.dshell_pastbin import *
+from ..DISCORD_COMMANDS.dshell_role import *
 
 dshell_keyword: set[str] = {
     'if', 'else', 'elif', 'loop', '#end', 'var', '#loop', '#if', 'sleep', 'param', '#param'
@@ -22,6 +24,8 @@ dshell_discord_keyword: set[str] = {
 }
 dshell_commands: dict[str, Callable] = {
 
+    "gp": dshell_get_pastbin,  # get pastbin
+
     "sm": dshell_send_message,  # send message
     "dm": dshell_delete_message,
     "pm": dshell_purge_message,
@@ -30,19 +34,26 @@ dshell_commands: dict[str, Callable] = {
     "cc": dshell_create_text_channel,  # create channel
     "cvc": dshell_create_voice_channel,  # create voice channel
     "dc": dshell_delete_channel,  # delete channel
-    "dcs": dshell_delete_channels, # delete several channels by name or regex
+    "dcs": dshell_delete_channels,  # delete several channels by name or regex
 
     "bm": dshell_ban_member,  # ban member
     "um": dshell_unban_member,  # unban member
     "km": dshell_kick_member,  # kick member
+    "tm": dshell_timeout_member,  # timeout member
+    "mm": dshell_move_member,  # move member to another channel
     "rm": dshell_rename_member,  # rename member
+    "cp": dshell_check_permissions,  # check permissions
 
-    "srm": dshell_research_regex_message,  # research regex in message
+    "ghm": dshell_get_hystory_messages,  # research regex in message
     "src": dshell_research_regex_in_content,  # research regex in content
 
     "ec": dshell_edit_text_channel,  # edit text channel
     "evc": dshell_edit_voice_channel,  # edit voice channel
 
+    "cr": dshell_create_role,
+    "dr": dshell_delete_roles,
+    "er": dshell_edit_role,
+
     "amr": dshell_add_reactions,  # add reactions to a message
     "rmr": dshell_remove_reactions,  # remove reactions from a message
 

{dshellinterpreter-0.2.2.dist-info → dshellinterpreter-0.2.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dshellInterpreter
-Version: 0.2.2
+Version: 0.2.4
 Summary: A Discord bot interpreter for creating custom commands and automations.
 Home-page: https://github.com/BOXERRMD/Dshell_Interpreter
 Author: Chronos
@@ -16,6 +16,7 @@ Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: py-cord==2.6.1
+Requires-Dist: requests
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

dshellinterpreter-0.2.4.dist-info/RECORD

@@ -0,0 +1,21 @@
+Dshell/__init__.py,sha256=UPvXnewe_8FX9aoevMA78UN1k8AY-u8LTY3vEVxaDxw,72
+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=KEdI14VTmDJm3zb4Mt-cFe71Jdsrolj6O8673Vzw4n8,5943
+Dshell/DISCORD_COMMANDS/dshell_message.py,sha256=fLxj_Ns-krZgXEPijhWvBFLorvmbleR6JpVOR72BIa8,5180
+Dshell/DISCORD_COMMANDS/dshell_pastbin.py,sha256=TkWFGRRTvhhJgvwkDFx9Fz4UM2UUFwxyq0laMVx0mUk,881
+Dshell/DISCORD_COMMANDS/dshell_role.py,sha256=LKWodMLC0mvm7BgImHIVeBWGHPmJvAYAG0lD_dr31WI,4660
+Dshell/_DshellInterpreteur/__init__.py,sha256=xy5-J-R3YmY99JF3NBHTRRLsComFxpjnCA5xacISctU,35
+Dshell/_DshellInterpreteur/dshell_interpreter.py,sha256=dJS8frzNhKEvs-WdC7kwcZMZKefraWO4t8vLrFctjvA,22805
+Dshell/_DshellParser/__init__.py,sha256=ONDfhZMvClqP_6tE8SLjp-cf3pXL-auQYnfYRrHZxC4,56
+Dshell/_DshellParser/ast_nodes.py,sha256=2qwL_M0ELPia6L6gqwgV5hqprvyuo97cx3Zk2dVz09U,15341
+Dshell/_DshellParser/dshell_parser.py,sha256=bdnVhx-MchM61J88fa9PimpAdwPtQumywJd-GoMqS8Q,15514
+Dshell/_DshellTokenizer/__init__.py,sha256=LIQSRhDx2B9pmPx5ADMwwD0Xr9ybneVLhHH8qrJWw_s,172
+Dshell/_DshellTokenizer/dshell_keywords.py,sha256=G9qdXr-d05QtmBdwTGa1qMDm7TDbIEkbx_-ERU97Ods,4664
+Dshell/_DshellTokenizer/dshell_token_type.py,sha256=pWzvmj6EFGkDwNHooOAjdyysi1vZRVEostFIZSW1Ais,1483
+Dshell/_DshellTokenizer/dshell_tokenizer.py,sha256=-EhwrfbcOcnAxOHWBE89531t25u6c6HmJuT1AKFn9Ew,7032
+dshellinterpreter-0.2.4.dist-info/licenses/LICENSE,sha256=lNgcw1_xb7QENAQi3uHGymaFtbs0RV-ihiCd7AoLQjA,1082
+dshellinterpreter-0.2.4.dist-info/METADATA,sha256=_1jLYXDZ0NAPjcLsFS8-BsgVMmQ6QZfwSH_bdNLGgV8,1120
+dshellinterpreter-0.2.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dshellinterpreter-0.2.4.dist-info/top_level.txt,sha256=B4CMhtmchGwPQJLuqUy0GhRG-0cUGxKL4GqEbCiB_vE,7
+dshellinterpreter-0.2.4.dist-info/RECORD,,

dshellinterpreter-0.2.2.dist-info/RECORD

@@ -1,19 +0,0 @@
-Dshell/__init__.py,sha256=UPvXnewe_8FX9aoevMA78UN1k8AY-u8LTY3vEVxaDxw,72
-Dshell/DISCORD_COMMANDS/__init__.py,sha256=unbZE4sxFCbUQ4Qptr1BhWu-nwhvI2oRzcDLtRmX6Ug,92
-Dshell/DISCORD_COMMANDS/dshell_channel.py,sha256=_qHfhVaeXLQMI926AJI3uYpjDXxVNF3sZ84EwWU-jz0,6450
-Dshell/DISCORD_COMMANDS/dshell_member.py,sha256=4cmpcu9RGHVUOGcF9pSnnxh7kEJQWAel4BBQ6Vicvbs,3126
-Dshell/DISCORD_COMMANDS/dshell_message.py,sha256=L5upeKAsski5bNjQTwzMNc2fVnUoz5_9TitQ5qJMuF0,4460
-Dshell/_DshellInterpreteur/__init__.py,sha256=xy5-J-R3YmY99JF3NBHTRRLsComFxpjnCA5xacISctU,35
-Dshell/_DshellInterpreteur/dshell_interpreter.py,sha256=Amk1Q7KM8OD6Za_pbXZs7W6rXe6BPVqG_1NRejRlccs,20859
-Dshell/_DshellParser/__init__.py,sha256=ONDfhZMvClqP_6tE8SLjp-cf3pXL-auQYnfYRrHZxC4,56
-Dshell/_DshellParser/ast_nodes.py,sha256=-zFmSeb6FnvcXd2gB3koy93apVJ-PiCY8PTUFj-_bG8,15307
-Dshell/_DshellParser/dshell_parser.py,sha256=jCnwxY_J-_u1W_tEotQznp4_Y0aeAH4pTcPl6_Fx9f8,15525
-Dshell/_DshellTokenizer/__init__.py,sha256=LIQSRhDx2B9pmPx5ADMwwD0Xr9ybneVLhHH8qrJWw_s,172
-Dshell/_DshellTokenizer/dshell_keywords.py,sha256=10VctszIRg8AX5Nsr7kwRIjdwzUgTfrrJYbD7QfYR5s,4253
-Dshell/_DshellTokenizer/dshell_token_type.py,sha256=pWzvmj6EFGkDwNHooOAjdyysi1vZRVEostFIZSW1Ais,1483
-Dshell/_DshellTokenizer/dshell_tokenizer.py,sha256=-EhwrfbcOcnAxOHWBE89531t25u6c6HmJuT1AKFn9Ew,7032
-dshellinterpreter-0.2.2.dist-info/licenses/LICENSE,sha256=lNgcw1_xb7QENAQi3uHGymaFtbs0RV-ihiCd7AoLQjA,1082
-dshellinterpreter-0.2.2.dist-info/METADATA,sha256=FHBHS3RDbndDp8iF1WanbDw8NXV52P4qijbIKt3gSdk,1095
-dshellinterpreter-0.2.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-dshellinterpreter-0.2.2.dist-info/top_level.txt,sha256=B4CMhtmchGwPQJLuqUy0GhRG-0cUGxKL4GqEbCiB_vE,7
-dshellinterpreter-0.2.2.dist-info/RECORD,,