dshellInterpreter 0.1.14__tar.gz → 0.1.16__tar.gz

{dshellinterpreter-0.1.14 → dshellinterpreter-0.1.16}/Dshell/DISCORD_COMMANDS/dshell_message.py

@@ -116,11 +116,11 @@ async def dshell_research_regex_in_content(ctx: Message, regex, content):
 
     return True
 
-async def dshell_add_reactions(ctx: Message, reactions, message_id=None):
+async def dshell_add_reactions(ctx: Message, reactions, message=None):
     """
     Adds reactions to a message
     """
-    message = ctx.channel if message_id is None else ctx.channel.get_partial_message(message_id)  # 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 +130,11 @@ async def dshell_add_reactions(ctx: Message, reactions, message_id=None):
 
     return message.id
 
-async def dshell_remove_reactions(ctx: Message, reactions, message_id=None):
+async def dshell_remove_reactions(ctx: Message, reactions, message=None):
     """
     Removes reactions from a message
     """
-    message = ctx.channel if message_id is None else ctx.channel.get_partial_message(message_id)  # 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]

{dshellinterpreter-0.1.14 → dshellinterpreter-0.1.16}/Dshell/_DshellInterpreteur/dshell_interpreter.py

@@ -2,9 +2,8 @@ from asyncio import sleep
 from re import findall
 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,7 +23,7 @@ class DshellInterpreteur:
     Make what you want with Dshell code to interact with Discord !
     """
 
-    def __init__(self, code: str, ctx: context, debug: bool = False, vars: Optional[dict[str, Any]] = None):
+    def __init__(self, code: str, ctx: context, debug: bool = False, vars: Optional[str] = None):
         """
         Interpreter Dshell code
         :param code: The code to interpret. Each line must end with a newline character, except SEPARATOR and SUB_SEPARATOR tokens.
@@ -33,11 +32,12 @@ class DshellInterpreteur:
         :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] = vars or {}
+        self.env: dict[str, Any] = {
+            '__ret__': None}  # environment variables, '__ret__' is used to store the return value of commands
+        self.vars = vars if vars is not None else ''
         self.ctx: context = ctx
         if debug:
             print_ast(self.ast)
-        self.env['__ret__'] = None
 
     async def execute(self, ast: Optional[list[All_nodes]] = None):
         """
@@ -63,6 +63,10 @@ class DshellInterpreteur:
             if isinstance(node, CommandNode):
                 self.env['__ret__'] = await call_function(dshell_commands[node.name], node.body, self)
 
+            elif isinstance(node, ParamNode):
+                params = get_params(node, self)
+                self.env.update(params)  # update the environment
+
             elif isinstance(node, IfNode):
                 elif_valid = False
                 if eval_expression(node.condition, self):
@@ -153,6 +157,37 @@ class DshellInterpreteur:
             return token.value  # fallback
 
 
+def get_params(node: ParamNode, interpreter: DshellInterpreteur) -> dict[str, Any]:
+    """
+    Get the parameters from a ParamNode.
+    :param node: The ParamNode to get the parameters from.
+    :param interpreter: The Dshell interpreter instance.
+    :return: A dictionary of parameters.
+    """
+    regrouped_args: dict[str, list] = regroupe_commandes(node.body, interpreter)[
+        0]  # just regroup the commands, no need to do anything else
+    regrouped_args.pop('*', ())
+    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
+    for key, value in zip(regrouped_args.keys(), gived_variables):
+        regrouped_args[key] = value
+
+    for key, value in env_give_variables.items():
+        if key in regrouped_args:
+            regrouped_args[key] = value  # update the regrouped args with the env variables
+        else:
+            raise Exception(f"'{key}' is not a valid parameter, but was given in the environment.")
+
+    for key in obligate:
+        if regrouped_args[key] == '*':
+            raise Exception(f"'{key}' is an obligatory parameter, but no value was given for it.")
+
+    return regrouped_args
+
 def eval_expression_inline(if_node: IfNode, interpreter: DshellInterpreteur) -> Token:
     """
     Eval a conditional expression inline.
@@ -231,7 +266,7 @@ def regroupe_commandes(body: list[Token], interpreter: DshellInterpreteur) -> li
     Non-mandatory parameters will be stored in a list in the form of tokens with the key ‘*’.
     The others, having been specified via a separator, will be in the form of a list of tokens with the IDENT token as key, following the separator for each argument.
     If two parameters have the same name, the last one will overwrite the previous one.
-    To accept duplicates, use the SUB_SEPARATOR (~~) to create a sub-dictionary for parameters with the same name.
+    To accept duplicates, use the SUB_SEPARATOR (~~) to create a sub-dictionary for parameters with the same name (sub-dictionary is added to the list returned).
 
     :param body: The list of tokens to group.
     :param interpreter: The Dshell interpreter instance.
@@ -404,7 +439,8 @@ class DshellPermissions:
 
         if 'members' in target_keys:
             for member_id in (
-            self.target['members'] if isinstance(self.target['members'], ListNode) else [self.target['members']]): # allow a single ID
+                    self.target['members'] if isinstance(self.target['members'], ListNode) else [
+                        self.target['members']]):  # allow a single ID
                 member = self.get_member(guild, member_id)
                 permissions[member] = PermissionOverwrite.from_pair(
                     allow=Permissions(permissions=self.target.get('allow', 0)),
@@ -413,7 +449,8 @@ class DshellPermissions:
 
         elif 'roles' in target_keys:
             for role_id in (
-            self.target['roles'] if isinstance(self.target['roles'], ListNode) else [self.target['roles']]): # allow a single ID
+                    self.target['roles'] if isinstance(self.target['roles'], ListNode) else [
+                        self.target['roles']]):  # allow a single ID
                 role = self.get_role(guild, role_id)
                 permissions[role] = PermissionOverwrite.from_pair(
                     allow=Permissions(permissions=self.target.get('allow', 0)),

{dshellinterpreter-0.1.14 → dshellinterpreter-0.1.16}/Dshell/_DshellParser/ast_nodes.py

@@ -19,7 +19,8 @@ __all__ = [
     'SleepNode',
     'IdentOperationNode',
     'ListNode',
-    'PermissionNode'
+    'PermissionNode',
+    'ParamNode'
 ]
 
 
@@ -395,6 +396,33 @@ class IdentOperationNode(ASTNode):
             "args": self.args.to_dict()
         }
 
+class ParamNode(ASTNode):
+    """
+    Node representing a parameter in the AST.
+    This is used to define parameters for variables passed to the dshell interpreter.
+    """
+
+    def __init__(self, body: list[Token]):
+        """
+        :param name: Token representing the parameter name
+        :param body: list of tokens representing the body of the parameter
+        """
+        self.body = body
+
+    def __repr__(self):
+        return f"<PARAM> - {self.name} *- {self.body}"
+
+    def to_dict(self):
+        """
+        Convert the ParamNode to a dictionary representation.
+        :return: Dictionary representation of the ParamNode.
+        """
+        return {
+            "type": "ParamNode",
+            "name": self.name.to_dict(),
+            "body": [token.to_dict() for token in self.body]
+        }
+
 class ListNode(ASTNode):
     """
     Node representing a list structure in the AST.

{dshellinterpreter-0.1.14 → dshellinterpreter-0.1.16}/Dshell/_DshellParser/dshell_parser.py

@@ -23,6 +23,7 @@ from .ast_nodes import (ASTNode,
                         EmbedNode,
                         FieldEmbedNode,
                         PermissionNode,
+                        ParamNode,
                         StartNode)
 from .._DshellTokenizer.dshell_token_type import DshellTokenType as DTT
 from .._DshellTokenizer.dshell_token_type import Token
@@ -66,7 +67,7 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
 
             elif first_token_line.value == '#if':
                 if not isinstance(last_block, (IfNode, ElseNode, ElifNode)):
-                    raise SyntaxError(f'[#IF] Aucun bloc conditionnel ouvert ligne {first_token_line.position} !')
+                    raise SyntaxError(f'[#IF] No conditional bloc open on line {first_token_line.position} !')
 
                 if isinstance(last_block, (ElifNode, ElseNode)):
 
@@ -78,7 +79,7 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
 
             elif first_token_line.value == 'elif':
                 if not isinstance(last_block, (IfNode, ElifNode)):
-                    raise SyntaxError(f'[ELIF] Aucun bloc conditionnel ouvert ligne {first_token_line.position} !')
+                    raise SyntaxError(f'[ELIF] No conditional bloc open on line {first_token_line.position} !')
                 elif_node = ElifNode(condition=tokens_by_line[1:], body=[],
                                      parent=last_block if isinstance(last_block, IfNode) else last_block.parent)
 
@@ -94,10 +95,10 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
 
             elif first_token_line.value == 'else':
                 if not isinstance(last_block, (IfNode, ElifNode)):
-                    raise SyntaxError(f'[ELSE] Aucun bloc conditionnel ouvert ligne {first_token_line.position} !')
+                    raise SyntaxError(f'[ELSE] No conditional bloc open on line {first_token_line.position} !')
 
                 if isinstance(last_block, ElseNode) and last_block.else_body is not None:
-                    raise SyntaxError(f'[ELSE] Déjà définit et n\'accepte pas les doublons dans un même if !')
+                    raise SyntaxError(f'[ELSE] already define !')
 
                 else_node = ElseNode(body=[])
 
@@ -116,7 +117,7 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
 
             elif first_token_line.value == '#loop':  # si rencontré
                 if not isinstance(last_block, LoopNode):
-                    raise SyntaxError(f'[#LOOP] Aucune loop ouverte ligne {first_token_line.position} !')
+                    raise SyntaxError(f'[#LOOP] No loop open on line {first_token_line.position} !')
                 blocks.pop()
                 return blocks, pointeur  # on renvoie les informations parsé à la dernière loop ouverte
 
@@ -135,6 +136,18 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
                 sleep_node = SleepNode(tokens_by_line[1:])
                 last_block.body.append(sleep_node)
 
+            elif first_token_line.value == 'param':
+                param_node = ParamNode(body=[])
+                last_block.body.append(param_node)
+                _, p = parse(token_lines[pointeur + 1:], param_node)
+                pointeur += p + 1  # on avance le pointeur de la ligne suivante
+
+            elif first_token_line.value == '#param':
+                if not isinstance(last_block, ParamNode):
+                    raise SyntaxError(f'[#PARAM] No parameters open on line {first_token_line.position} !')
+                blocks.pop()  # on supprime le dernier bloc (le paramètre)
+                return blocks, pointeur  # on renvoie les informations parsé à la dernière paramètre ouverte
+
             elif first_token_line.value == '#end':  # node pour arrêter le programme si elle est rencontré
                 end_node = EndNode()
                 last_block.body.append(end_node)
@@ -152,13 +165,13 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
 
             elif first_token_line.value == '#embed':
                 if not isinstance(last_block, EmbedNode):
-                    raise SyntaxError(f'[#EMBED] Aucun embed ouvert ligne {first_token_line.position} !')
+                    raise SyntaxError(f'[#EMBED] No embed open on line {first_token_line.position} !')
                 blocks.pop()
                 return blocks, pointeur
 
             elif first_token_line.value == 'field':
                 if not isinstance(last_block, EmbedNode):
-                    raise SyntaxError(f'[FIELD] Aucun embed ouvert ligne {first_token_line.position} !')
+                    raise SyntaxError(f'[FIELD] No embed open on line {first_token_line.position} !')
                 last_block.fields.append(FieldEmbedNode(tokens_by_line[1:]))
 
             elif first_token_line.value in ('perm', 'permission'):
@@ -170,7 +183,7 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
 
             elif first_token_line.value in ('#perm', '#permission'):
                 if not isinstance(last_block, PermissionNode):
-                    raise SyntaxError(f'[#PERM] Aucun permission ouvert ligne {first_token_line.position} !')
+                    raise SyntaxError(f'[#PERM] No permission open on line {first_token_line.position} !')
                 blocks.pop()
                 return blocks, pointeur
 
@@ -345,3 +358,9 @@ def print_ast(ast: list[ASTNode], decalage: int = 0):
         elif isinstance(i, FieldEmbedNode):
             for field in i.body:
                 print(f"{' ' * decalage}FIELD -> {field.value}")
+
+        elif isinstance(i, PermissionNode):
+            print(f"{' ' * decalage}PERMISSION -> {i.body}")
+
+        elif isinstance(i, ParamNode):
+            print(f"{' ' * decalage}PARAM -> {i.body}")

{dshellinterpreter-0.1.14 → dshellinterpreter-0.1.16}/Dshell/_DshellTokenizer/dshell_keywords.py

@@ -14,7 +14,7 @@ from ..DISCORD_COMMANDS.dshell_message import *
 from ..DISCORD_COMMANDS.dshell_member import *
 
 dshell_keyword: set[str] = {
-    'if', 'else', 'elif', 'loop', '#end', 'var', '#loop', '#if', 'sleep'
+    'if', 'else', 'elif', 'loop', '#end', 'var', '#loop', '#if', 'sleep', 'param', '#param'
 }
 
 dshell_discord_keyword: set[str] = {

{dshellinterpreter-0.1.14 → dshellinterpreter-0.1.16}/PKG-INFO

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

{dshellinterpreter-0.1.14 → dshellinterpreter-0.1.16}/dshellInterpreter.egg-info/PKG-INFO

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

{dshellinterpreter-0.1.14 → dshellinterpreter-0.1.16}/setup.py

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