dshellInterpreter 0.2.1__tar.gz → 0.2.3__tar.gz

{dshellinterpreter-0.2.1 → dshellinterpreter-0.2.3}/Dshell/DISCORD_COMMANDS/__init__.py

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

{dshellinterpreter-0.2.1 → dshellinterpreter-0.2.3}/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)
 

dshellinterpreter-0.2.3/Dshell/DISCORD_COMMANDS/dshell_member.py

@@ -0,0 +1,186 @@
+from datetime import timedelta, datetime
+
+from discord import MISSING, Message, Member, Permissions
+
+__all__ = [
+    "dshell_ban_member",
+    "dshell_unban_member",
+    "dshell_kick_member",
+    "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.
+    """
+    banned_member = ctx.channel.guild.get_member(member)
+
+    if not banned_member:
+        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.
+    """
+    banned_users = ctx.channel.guild.bans()
+    user_to_unban = None
+
+    async for ban_entry in banned_users:
+        if ban_entry.user.id == user:
+            user_to_unban = ban_entry.user
+            break
+
+    if not user_to_unban:
+        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.
+    """
+    kicked_member = ctx.channel.guild.get_member(member)
+
+    if not kicked_member:
+        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.
+    """
+    renamed_member = ctx.channel.guild.get_member(member)
+
+    if not renamed_member:
+        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] | 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:
+        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:
+        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] | 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:
+        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:
+        raise Exception(f'No role found !')
+
+    await target_member.remove_roles(*roles_to_remove, reason=reason)
+
+    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

{dshellinterpreter-0.2.1 → dshellinterpreter-0.2.3}/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

dshellinterpreter-0.2.3/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 line and len_content < 4000 and len_content + len(line) <= 4000:
+                content += line + '\n'
+            else:
+                break
+
+    return content

{dshellinterpreter-0.2.1 → dshellinterpreter-0.2.3}/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:
@@ -71,7 +88,7 @@ class DshellInterpreteur:
                 elif_valid = False
                 if eval_expression(node.condition, self):
                     await self.execute(node.body)
-                    return
+                    continue
                 elif node.elif_nodes:
 
                     for i in node.elif_nodes:
@@ -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

{dshellinterpreter-0.2.1 → dshellinterpreter-0.2.3}/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.

{dshellinterpreter-0.2.1 → dshellinterpreter-0.2.3}/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

{dshellinterpreter-0.2.1 → dshellinterpreter-0.2.3}/Dshell/_DshellTokenizer/dshell_keywords.py

@@ -10,8 +10,9 @@ __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 *
 
 dshell_keyword: set[str] = {
     'if', 'else', 'elif', 'loop', '#end', 'var', '#loop', '#if', 'sleep', 'param', '#param'
@@ -22,6 +23,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,14 +33,17 @@ 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

{dshellinterpreter-0.2.1 → dshellinterpreter-0.2.3}/PKG-INFO

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

{dshellinterpreter-0.2.1 → dshellinterpreter-0.2.3}/dshellInterpreter.egg-info/PKG-INFO

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

{dshellinterpreter-0.2.1 → dshellinterpreter-0.2.3}/dshellInterpreter.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ Dshell/DISCORD_COMMANDS/__init__.py
 Dshell/DISCORD_COMMANDS/dshell_channel.py
 Dshell/DISCORD_COMMANDS/dshell_member.py
 Dshell/DISCORD_COMMANDS/dshell_message.py
+Dshell/DISCORD_COMMANDS/dshell_pastbin.py
 Dshell/_DshellInterpreteur/__init__.py
 Dshell/_DshellInterpreteur/dshell_interpreter.py
 Dshell/_DshellParser/__init__.py

{dshellinterpreter-0.2.1 → dshellinterpreter-0.2.3}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r") as fh:
 
 setup(
     name="dshellInterpreter",
-    version="0.2.1",
+    version="0.2.3",
     author="Chronos",
     author_email="vagabonwalybi@gmail.com",
     description="A Discord bot interpreter for creating custom commands and automations.",

dshellinterpreter-0.2.1/Dshell/DISCORD_COMMANDS/dshell_member.py

@@ -1,105 +0,0 @@
-from discord import MISSING, Message, Member
-
-
-__all__ = [
-    "dshell_ban_member",
-    "dshell_unban_member",
-    "dshell_kick_member",
-    "dshell_rename_member",
-    "dshell_add_roles",
-    "dshell_remove_roles",
-]
-
-async def dshell_ban_member(ctx: Message, member: int, reason: str = MISSING):
-    """
-    Bans a member from the server.
-    """
-    banned_member = ctx.channel.guild.get_member(member)
-
-    if not banned_member:
-        return 1 # 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.
-    """
-    banned_users = ctx.channel.guild.bans()
-    user_to_unban = None
-
-    async for ban_entry in banned_users:
-        if ban_entry.user.id == user:
-            user_to_unban = ban_entry.user
-            break
-
-    if not user_to_unban:
-        return 1  # 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.
-    """
-    kicked_member = ctx.channel.guild.get_member(member)
-
-    if not kicked_member:
-        return 1  # Member not found in the server
-
-    await ctx.channel.guild.kick(kicked_member, reason=reason)
-
-    return kicked_member.id
-
-async def dshell_rename_member(ctx: Message, new_name, member=None):
-    """
-    Renames a member in the server.
-    """
-    renamed_member = ctx.channel.guild.get_member(member)
-
-    if not renamed_member:
-        return 1  # 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):
-    """
-    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
-
-    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
-
-    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):
-    """
-    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
-
-    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
-
-    await target_member.remove_roles(*roles_to_remove, reason=reason)
-
-    return target_member.id