dshellInterpreter 0.1.13__tar.gz → 0.1.15__tar.gz

{dshellinterpreter-0.1.13 → dshellinterpreter-0.1.15}/Dshell/DISCORD_COMMANDS/dshell_channel.py

@@ -8,7 +8,9 @@ __all__ = [
     'dshell_create_text_channel',
     'dshell_delete_channel',
     'dshell_delete_channels',
-    'dshell_create_voice_channel'
+    'dshell_create_voice_channel',
+    'dshell_edit_text_channel',
+    'dshell_edit_voice_channel'
 ]
 
 
@@ -69,7 +71,7 @@ async def dshell_delete_channel(ctx: Message, channel=None, reason=None, timeout
     channel_to_delete = ctx.channel if channel is None else ctx.channel.guild.get_channel(channel)
 
     if channel_to_delete is None:
-        raise Exception(f"Le channel {channel} n'existe pas !")
+        raise Exception(f"Channel {channel} not found !")
 
     await sleep(timeout)
 
@@ -90,3 +92,54 @@ 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):
+    """
+    Edits a text channel on the server
+    """
+
+    channel_to_edit = ctx.channel if channel is None else ctx.channel.guild.get_channel(channel)
+
+    if channel_to_edit is None:
+        raise Exception(f"Channel {channel} not found !")
+
+    await channel_to_edit.edit(name=name,
+                               position=position,
+                               slowmode_delay=slowmode,
+                               topic=topic,
+                               nsfw=nsfw,
+                               overwrites=permission,
+                               reason=reason)
+
+    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):
+    """
+    Edits a voice channel on the server
+    """
+
+    channel_to_edit = ctx.channel if channel is None else ctx.channel.guild.get_channel(channel)
+
+    if channel_to_edit is None:
+        raise Exception(f"Channel {channel} not found !")
+
+    await channel_to_edit.edit(name=name,
+                               position=position,
+                               bitrate=bitrate,
+                               overwrites=permission,
+                               reason=reason)
+
+    return channel_to_edit.id

{dshellinterpreter-0.1.13 → dshellinterpreter-0.1.15}/Dshell/DISCORD_COMMANDS/dshell_member.py

@@ -1,11 +1,13 @@
-from discord import MISSING, Message
+from discord import MISSING, Message, Member
 
 
 __all__ = [
     "dshell_ban_member",
     "dshell_unban_member",
     "dshell_kick_member",
-    "dshell_rename_member"
+    "dshell_rename_member",
+    "dshell_add_roles",
+    "dshell_remove_roles",
 ]
 
 async def dshell_ban_member(ctx: Message, member: int, reason: str = MISSING):
@@ -64,4 +66,40 @@ async def dshell_rename_member(ctx: Message, new_name, member=None):
 
     await renamed_member.edit(nick=new_name)
 
-    return renamed_member.id
+    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

{dshellinterpreter-0.1.13 → dshellinterpreter-0.1.15}/Dshell/DISCORD_COMMANDS/dshell_message.py

@@ -9,7 +9,9 @@ __all__ = [
     'dshell_purge_message',
     'dshell_edit_message',
     'dshell_research_regex_message',
-    'dshell_research_regex_in_content'
+    'dshell_research_regex_in_content',
+    'dshell_add_reactions',
+    'dshell_remove_reactions'
 ]
 
 
@@ -110,7 +112,34 @@ async def dshell_research_regex_in_content(ctx: Message, regex, content):
     """
 
     if not search(regex, content):
-        return True
+        return False
 
-    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)
+
+    if isinstance(reactions, str):
+        reactions = [reactions]
+
+    for reaction in reactions:
+        await message.add_reaction(reaction)
+
+    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)
+
+    if isinstance(reactions, str):
+        reactions = [reactions]
+
+    for reaction in reactions:
+        await message.clear_reaction(reaction)
+
+    return message.id

{dshellinterpreter-0.1.13 → dshellinterpreter-0.1.15}/Dshell/_DshellInterpreteur/dshell_interpreter.py

@@ -4,7 +4,7 @@ from typing import TypeVar, Union, Any, Optional, Callable
 
 
 from discord import AutoShardedBot, Embed, Colour, PermissionOverwrite, Permissions, Guild, Member, Role, Message
-from discord.abc import GuildChannel, PrivateChannel
+from discord.abc import PrivateChannel
 
 from .._DshellParser.ast_nodes import *
 from .._DshellParser.dshell_parser import parse
@@ -24,16 +24,20 @@ class DshellInterpreteur:
     Make what you want with Dshell code to interact with Discord !
     """
 
-    def __init__(self, code: str, ctx: context, debug: bool = False):
+    def __init__(self, code: str, ctx: context, debug: bool = False, vars: Optional[dict[str, Any]] = None):
         """
         Interpreter Dshell code
         :param code: The code to interpret. Each line must end with a newline character, except SEPARATOR and SUB_SEPARATOR tokens.
+        :param ctx: The context in which the code is executed. It can be a Discord bot, a message, or a channel.
+        :param debug: If True, prints the AST of the code.
+        :param vars: Optional dictionary of variables to initialize in the interpreter's environment.
         """
         self.ast: list[ASTNode] = parse(DshellTokenizer(code).start(), StartNode([]))[0]
-        self.env: dict[str, Any] = {}
+        self.env: dict[str, Any] = vars or {}
         self.ctx: context = ctx
         if debug:
             print_ast(self.ast)
+        self.env['__ret__'] = None
 
     async def execute(self, ast: Optional[list[All_nodes]] = None):
         """
@@ -57,7 +61,7 @@ class DshellInterpreteur:
                 await self.execute(node.body)
 
             if isinstance(node, CommandNode):
-                self.env['__cr__'] = await call_function(dshell_commands[node.name], node.body, self)
+                self.env['__ret__'] = await call_function(dshell_commands[node.name], node.body, self)
 
             elif isinstance(node, IfNode):
                 elif_valid = False

{dshellinterpreter-0.1.13 → dshellinterpreter-0.1.15}/Dshell/_DshellParser/ast_nodes.py

@@ -1,4 +1,5 @@
 from typing import Optional, Any
+from random import randint
 
 from .._DshellTokenizer.dshell_token_type import Token
 
@@ -39,6 +40,16 @@ class StartNode(ASTNode):
     def __repr__(self):
         return f"<Command> - {self.body}"
 
+    def to_dict(self):
+        """
+        Convert the StartNode to a dictionary representation.
+        :return: Dictionary representation of the StartNode.
+        """
+        return {
+            "type": "StartNode",
+            "body": [token.to_dict() for token in self.body]
+        }
+
 
 class ElseNode(ASTNode):
     """
@@ -53,6 +64,16 @@ class ElseNode(ASTNode):
     def __repr__(self):
         return f"<Else> - {self.body}"
 
+    def to_dict(self):
+        """
+        Convert the ElseNode to a dictionary representation.
+        :return: Dictionary representation of the ElseNode.
+        """
+        return {
+            "type": "ElseNode",
+            "body": [token.to_dict() for token in self.body]
+        }
+
 
 class ElifNode(ASTNode):
     """
@@ -71,6 +92,18 @@ class ElifNode(ASTNode):
     def __repr__(self):
         return f"<Elif> - {self.condition} - {self.body}"
 
+    def to_dict(self):
+        """
+        Convert the ElifNode to a dictionary representation.
+        :return: Dictionary representation of the ElifNode.
+        """
+        return {
+            "type": "ElifNode",
+            "condition": [token.to_dict() for token in self.condition],
+            "body": [token.to_dict() for token in self.body],
+            "parent": self.parent.id  # Assuming parent is an IfNode, we store its ID
+        }
+
 
 class IfNode(ASTNode):
     """
@@ -88,10 +121,24 @@ class IfNode(ASTNode):
         self.body = body
         self.elif_nodes = elif_nodes
         self.else_body = else_body
+        self.id = randint(0, 1000000)  # Unique identifier for the IfNode instance
 
     def __repr__(self):
         return f"<If> - {self.condition} - {self.body} *- {self.elif_nodes} **- {self.else_body}"
 
+    def to_dict(self):
+        """
+        Convert the IfNode to a dictionary representation.
+        :return: Dictionary representation of the IfNode.
+        """
+        return {
+            "type": "IfNode",
+            "condition": [token.to_dict() for token in self.condition],
+            "body": [token.to_dict() for token in self.body],
+            "elif_nodes": [elif_node.to_dict() for elif_node in self.elif_nodes] if self.elif_nodes else None,
+            "else_body": self.else_body.to_dict() if self.else_body else None,
+            "id": self.id
+        }
 
 class LoopNode(ASTNode):
     """
@@ -108,6 +155,16 @@ class LoopNode(ASTNode):
     def __repr__(self):
         return f"<Loop> - {self.variable.name} -> {self.variable.body} *- {self.body}"
 
+    def to_dict(self):
+        """
+        Convert the LoopNode to a dictionary representation.
+        :return: Dictionary representation of the LoopNode.
+        """
+        return {
+            "type": "LoopNode",
+            "variable": self.variable.to_dict(),
+            "body": [token.to_dict() for token in self.body]
+        }
 
 class ArgsCommandNode(ASTNode):
     """
@@ -122,6 +179,16 @@ class ArgsCommandNode(ASTNode):
     def __repr__(self):
         return f"<Args Command> - {self.body}"
 
+    def to_dict(self):
+        """
+        Convert the ArgsCommandNode to a dictionary representation.
+        :return: Dictionary representation of the ArgsCommandNode.
+        """
+        return {
+            "type": "ArgsCommandNode",
+            "body": [token.to_dict() for token in self.body]
+        }
+
 
 class CommandNode(ASTNode):
     """
@@ -138,6 +205,17 @@ class CommandNode(ASTNode):
     def __repr__(self):
         return f"<{self.name}> - {self.body}"
 
+    def to_dict(self):
+        """
+        Convert the CommandNode to a dictionary representation.
+        :return: Dictionary representation of the CommandNode.
+        """
+        return {
+            "type": "CommandNode",
+            "name": self.name,
+            "body": self.body.to_dict()
+        }
+
 
 class VarNode(ASTNode):
     """
@@ -154,6 +232,17 @@ class VarNode(ASTNode):
     def __repr__(self):
         return f"<VAR> - {self.name} *- {self.body}"
 
+    def to_dict(self):
+        """
+        Convert the VarNode to a dictionary representation.
+        :return: Dictionary representation of the VarNode.
+        """
+        return {
+            "type": "VarNode",
+            "name": self.name.to_dict(),
+            "body": [token.to_dict() for token in self.body]
+        }
+
 
 class EndNode(ASTNode):
     """
@@ -165,6 +254,15 @@ class EndNode(ASTNode):
     def __repr__(self):
         return f"<END>"
 
+    def to_dict(self):
+        """
+        Convert the EndNode to a dictionary representation.
+        :return: Dictionary representation of the EndNode.
+        """
+        return {
+            "type": "EndNode"
+        }
+
 
 class FieldEmbedNode(ASTNode):
     """
@@ -179,6 +277,16 @@ class FieldEmbedNode(ASTNode):
     def __repr__(self):
         return f"<EMBED_FIELD> - {self.body}"
 
+    def to_dict(self):
+        """
+        Convert the FieldEmbedNode to a dictionary representation.
+        :return: Dictionary representation of the FieldEmbedNode.
+        """
+        return {
+            "type": "FieldEmbedNode",
+            "body": [token.to_dict() for token in self.body]
+        }
+
 
 class EmbedNode(ASTNode):
     """
@@ -195,6 +303,17 @@ class EmbedNode(ASTNode):
     def __repr__(self):
         return f"<EMBED> - {self.body}"
 
+    def to_dict(self):
+        """
+        Convert the EmbedNode to a dictionary representation.
+        :return: Dictionary representation of the EmbedNode.
+        """
+        return {
+            "type": "EmbedNode",
+            "body": [token.to_dict() for token in self.body],
+            "fields": [field.to_dict() for field in self.fields]
+        }
+
 
 class PermissionNode(ASTNode):
     """
@@ -209,6 +328,16 @@ class PermissionNode(ASTNode):
     def __repr__(self):
         return f"<PERMISSION> - {self.body}"
 
+    def to_dict(self):
+        """
+        Convert the PermissionNode to a dictionary representation.
+        :return: Dictionary representation of the PermissionNode.
+        """
+        return {
+            "type": "PermissionNode",
+            "body": [token.to_dict() for token in self.body]
+        }
+
 
 class SleepNode(ASTNode):
     """
@@ -223,6 +352,16 @@ class SleepNode(ASTNode):
     def __repr__(self):
         return f"<SLEEP> - {self.body}"
 
+    def to_dict(self):
+        """
+        Convert the SleepNode to a dictionary representation.
+        :return: Dictionary representation of the SleepNode.
+        """
+        return {
+            "type": "SleepNode",
+            "body": [token.to_dict() for token in self.body]
+        }
+
 
 class IdentOperationNode(ASTNode):
     """
@@ -244,6 +383,17 @@ class IdentOperationNode(ASTNode):
     def __repr__(self):
         return f"<IDENT OPERATION> - {self.ident}.{self.function}({self.args})"
 
+    def to_dict(self):
+        """
+        Convert the IdentOperationNode to a dictionary representation.
+        :return: Dictionary representation of the IdentOperationNode.
+        """
+        return {
+            "type": "IdentOperationNode",
+            "ident": self.ident.to_dict(),
+            "function": self.function.to_dict(),
+            "args": self.args.to_dict()
+        }
 
 class ListNode(ASTNode):
     """
@@ -260,6 +410,16 @@ class ListNode(ASTNode):
         self.len_iterable: int = len(body)
         self.iterateur_count: int = 0
 
+    def to_dict(self):
+        """
+        Convert the ListNode to a dictionary representation.
+        :return: Dictionary representation of the ListNode.
+        """
+        return {
+            "type": "ListNode",
+            "body": [token.to_dict() for token in self.iterable]
+        }
+
     def add(self, value: Any):
         """
         Add a value to the list.

{dshellinterpreter-0.1.13 → dshellinterpreter-0.1.15}/Dshell/_DshellParser/dshell_parser.py

@@ -3,7 +3,8 @@ __all__ = [
     "parser_inline",
     "to_postfix",
     "parse_postfix_expression",
-    "print_ast"
+    "print_ast",
+    "ast_to_dict",
 ]
 
 from typing import Union, TYPE_CHECKING
@@ -200,6 +201,24 @@ 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]
+    elif hasattr(obj, "to_dict"):
+        return obj.to_dict()
+    else:
+        return obj  # fallback for primitives or tokens
+
+def dict_to_ast(data):
+    """
+    Convertit un dictionnaire en une structure AST.
+    :param data: le dictionnaire à convertir
+    :return: la structure AST correspondante
+    """
+    if isinstance(data, list):
+        return [dict_to_ast(item) for item in data]
+    elif isinstance(data, dict):
+        pass
 
 def parser_inline(tokens: list[Token]) -> tuple[list[list[Token]], bool]:
     """

{dshellinterpreter-0.1.13 → dshellinterpreter-0.1.15}/Dshell/_DshellTokenizer/dshell_keywords.py

@@ -21,19 +21,31 @@ dshell_discord_keyword: set[str] = {
     'embed', '#embed', 'field', 'perm', 'permission', '#perm', '#permission'
 }
 dshell_commands: dict[str, Callable] = {
+
     "sm": dshell_send_message,  # send message
     "dm": dshell_delete_message,
     "pm": dshell_purge_message,
+    "em": dshell_edit_message,  # edit message
+
     "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
+
     "bm": dshell_ban_member,  # ban member
     "um": dshell_unban_member,  # unban member
     "km": dshell_kick_member,  # kick member
-    "em": dshell_edit_message,  # edit message
+    "rm": dshell_rename_member,  # rename member
+
     "srm": dshell_research_regex_message,  # 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
+
+    "arr": dshell_add_reactions,  # add reactions to a message
+    "rrr": dshell_remove_reactions,  # remove reactions from a message
+
 }
 
 dshell_mathematical_operators: dict[str, tuple[Callable, int]] = {

{dshellinterpreter-0.1.13 → dshellinterpreter-0.1.15}/Dshell/_DshellTokenizer/dshell_token_type.py

@@ -39,3 +39,17 @@ class Token:
 
     def __repr__(self):
         return f"<{self.type.name} '{self.value}'>"
+
+    def to_dict(self):
+        def serialize_value(value):
+            if isinstance(value, list):
+                return [serialize_value(v) for v in value]
+            elif isinstance(value, Token):
+                return value.to_dict()
+            return value
+
+        return {
+            "type": self.type.name,
+            "value": serialize_value(self.value),
+            "position": self.position
+        }

{dshellinterpreter-0.1.13/dshellInterpreter.egg-info → dshellinterpreter-0.1.15}/PKG-INFO

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

{dshellinterpreter-0.1.13 → dshellinterpreter-0.1.15/dshellInterpreter.egg-info}/PKG-INFO

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

{dshellinterpreter-0.1.13 → dshellinterpreter-0.1.15}/setup.py

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