dshellInterpreter 1.2.3.0__tar.gz → 1.2.5.0__tar.gz

{dshellinterpreter-1.2.3.0 → dshellinterpreter-1.2.5.0}/Dshell/DshellInterpreteur/utils_interpreter.py

@@ -125,7 +125,7 @@ async def get_params(node: ParamNode, interpreter: "DshellInterpreteur") -> dict
 
             if tmp_tokens and len(tmp_tokens[0]) > 0:
                 for i in range(old_index_order, index_order):
-                    param_node_arguments_dict[param_node_arguments_order[i][0]] = tmp_tokens[0][i]
+                    param_node_arguments_dict[param_node_arguments_order[i][0]] = await interpreter.eval_data_token(tmp_tokens[0][i])
 
         # traitement des paramètres à tokeniser à la chaine
         elif param_node_arguments_order[index_order][1] == DTT.PARAMETERS:
@@ -140,7 +140,9 @@ async def get_params(node: ParamNode, interpreter: "DshellInterpreteur") -> dict
             tmp_tokens = DshellTokenizer(tmp_parameter).start()
 
             if tmp_tokens and len(tmp_tokens[0]) > 0:
-                param_node_arguments_dict[param_node_arguments_order[old_index_order][0]] = ListNode(tmp_tokens[0])
+                param_node_arguments_dict[param_node_arguments_order[old_index_order][0]] = ListNode(
+                    [await interpreter.eval_data_token(i) for i in tmp_tokens[0]]
+                )
 
         # traitement des paramètres à considéré comme une chaine de caractère à la chaine
         elif param_node_arguments_order[index_order][1] == DTT.STR_PARAMETER:
@@ -188,7 +190,7 @@ async def eval_expression(tokens: list[Token], interpreter: "DshellInterpreteur"
     for token in postfix:
 
         if token.type in DTT_DATA:
-            stack.append(await interpreter.eval_data_token(token))
+            stack.append(token)
 
         elif token.type in (DTT.MATHS_OPERATOR, DTT.LOGIC_OPERATOR, DTT.LOGIC_WORD_OPERATOR):
             op = token.value
@@ -210,14 +212,46 @@ async def eval_expression(tokens: list[Token], interpreter: "DshellInterpreteur"
                     raise SyntaxError(f"Too many operands for operator '{op}'")
 
                 operands.reverse()
-                result = dshell_operators[op][0](*operands)  # call the operator function with the operands
 
-                stack.append(result)
+                stack.append(await do_operation(op, operands, interpreter, dshell_operators))
 
         else:
             raise SyntaxError(f"Unexpected token type: {token.type} - {token.value}")
 
     if len(stack) != 1:
-        raise SyntaxError(f"Invalid expression: missing operators or operands in expression <{' '.join((i.value for i in tokens))}>")
+        raise SyntaxError(f"Invalid expression: missing operators or operands in expression '{' '.join((str(i.value) for i in tokens))}'")
 
-    return stack[0]
+    result = stack[0]
+    if isinstance(result, Token):
+        result = await interpreter.eval_data_token(result)
+
+    return result
+
+async def do_operation(operator: str,
+                       operands: list[Token],
+                       interpreter: "DshellInterpreteur",
+                       all_operators: dict)  -> Any:
+    """
+    Do all convertions and operations
+    :param operator:
+    :param operands:
+    :param interpreter:
+    :param all_operators: is dshell_operators dictionnary
+    :return:
+    """
+
+    i = 0
+    if (nbr_operand_to_translate := all_operators[operator][4]) is not None:
+        while i != nbr_operand_to_translate and i < len(operands):
+            operands[i] = await interpreter.eval_data_token(operands[i])
+            i += 1
+    else:
+        while i < len(operands):
+            operands[i] = await interpreter.eval_data_token(operands[i])
+            i += 1
+
+    result = all_operators[operator][0](*operands)
+    if isinstance(result, Token):
+        result = await interpreter.eval_data_token(result)
+
+    return result

{dshellinterpreter-1.2.3.0 → dshellinterpreter-1.2.5.0}/Dshell/DshellTokenizer/dshell_keywords.py

@@ -167,61 +167,62 @@ dshell_commands: dict[str, Callable] = {
 }
 
 """
-Tuple format: (function, precedence, number of operands min, number of operands max)
+Tuple format: (function, precedence, number of operands min, number of operands max, 
+                Optional[index to translate into value])
 """
 
-dshell_mathematical_operators: dict[str, tuple[Callable, int, int, int]] = {
-
-    r"++": (lambda a: a + 1, 6, 1, 1),
-    r"--": (lambda a: a - 1, 6, 1, 1),
-    r"**": (lambda a, b: a ** b, 8, 2, 2),
-    r"//": (lambda a, b: a // b, 7, 2, 2),
-    r">>": (lambda a, b: a >> b, 5, 2, 2),
-    r"<<": (lambda a, b: a << b, 5, 2, 2),
-    r"^": (lambda a, b: a ^ b, 5, 2, 2),
-    r"/": (lambda a, b: a / b, 7, 2, 2),
-    r"*": (lambda a, b: a * b, 7, 2, 2),
-    r"%": (lambda a, b: a % b, 7, 2, 2),
-    r"-": (lambda a, b=None: a-b if b is not None else -a, 6, 1, 2),
-    r"+": (lambda a, b: a + b, 6, 2, 2),
+dshell_mathematical_operators: dict[str, tuple[Callable, int, int, int, Optional[int]]] = {
+
+    r"++": (lambda a: a + 1, 6, 1, 1, None),
+    r"--": (lambda a: a - 1, 6, 1, 1, None),
+    r"**": (lambda a, b: a ** b, 8, 2, 2, None),
+    r"//": (lambda a, b: a // b, 7, 2, 2, None),
+    r">>": (lambda a, b: a >> b, 5, 2, 2, None),
+    r"<<": (lambda a, b: a << b, 5, 2, 2, None),
+    r"^": (lambda a, b: a ^ b, 5, 2, 2, None),
+    r"/": (lambda a, b: a / b, 7, 2, 2, None),
+    r"*": (lambda a, b: a * b, 7, 2, 2, None),
+    r"%": (lambda a, b: a % b, 7, 2, 2, None),
+    r"-": (lambda a, b=None: a-b if b is not None else -a, 6, 1, 2, None),
+    r"+": (lambda a, b: a + b, 6, 2, 2, None),
     r"..": (lambda a, b: (IntIterator(
                                 min_iterator=IntNode(a),
                                 max_iterator=IntNode(b),
                                 step= IntNode(1 if a <= b else -1))
-                          ), 5, 2, 2)
+                          ), 5, 2, 2, None)
     # warning: ambiguity between unary and binary to be handled in your parser
 
 }
 
-dshell_logical_word_operators: dict[str, tuple[Callable, int, int, int]] = {
-    r"and": (lambda a, b: bool(a and b), 2, 2, 2),
-    r"or": (lambda a, b: bool(a or b), 1, 2, 2),
-    r"not": (lambda a: not a, 3, 1, 1),
-    r"in": (lambda a, b: a in b, 4, 2, 2),
+dshell_logical_word_operators: dict[str, tuple[Callable, int, int, int, Optional[int]]] = {
+    r"and": (lambda a, b: bool(a and b), 2, 2, 2, None),
+    r"or": (lambda a, b: bool(a or b), 1, 2, 2, None),
+    r"not": (lambda a: not a, 3, 1, 1, None),
+    r"in": (lambda a, b: a in b, 4, 2, 2, None),
 }
 
-dshell_logical_operators: dict[str, tuple[Callable, int, int, int]] = {
-
-    r"==": (lambda a, b: a == b, 4, 2, 2),
-    r"<=": (lambda a, b: a <= b, 4, 2, 2),
-    r"=<": (lambda a, b: a <= b, 4, 2, 2),
-    r"!=": (lambda a, b: a != b, 4, 2, 2),
-    r"=!": (lambda a, b: a != b, 4, 2, 2),
-    r">=": (lambda a, b: a >= b, 4, 2, 2),
-    r"=>": (lambda a, b: a >= b, 4, 2, 2),
-    r"&&": (lambda a, b: a and b, 2, 2, 2),
-    r"||": (lambda a, b: a or b, 1, 2, 2),
-    r"&": (lambda a, b: a & b, 2, 2, 2),
-    r"|": (lambda a, b: a | b, 1, 2, 2),
-    r"=": (lambda a, b: a == b, 4, 2, 2),
-    r"<": (lambda a, b: a < b, 4, 2, 2),
-    r">": (lambda a, b: a > b, 4, 2, 2),
-    r"!": (lambda a: not a, 3, 1, 1),
-    r"?": (lambda condition, first_choice, second_choice: first_choice if condition else second_choice, 1, 3, 3),
+dshell_logical_operators: dict[str, tuple[Callable, int, int, int, Optional[int]]] = {
+
+    r"==": (lambda a, b: a == b, 4, 2, 2, None),
+    r"<=": (lambda a, b: a <= b, 4, 2, 2, None),
+    r"=<": (lambda a, b: a <= b, 4, 2, 2, None),
+    r"!=": (lambda a, b: a != b, 4, 2, 2, None),
+    r"=!": (lambda a, b: a != b, 4, 2, 2, None),
+    r">=": (lambda a, b: a >= b, 4, 2, 2, None),
+    r"=>": (lambda a, b: a >= b, 4, 2, 2, None),
+    r"&&": (lambda a, b: a and b, 2, 2, 2, None),
+    r"||": (lambda a, b: a or b, 1, 2, 2, None),
+    r"&": (lambda a, b: a & b, 2, 2, 2, None),
+    r"|": (lambda a, b: a | b, 1, 2, 2, None),
+    r"=": (lambda a, b: a == b, 4, 2, 2, None),
+    r"<": (lambda a, b: a < b, 4, 2, 2, None),
+    r">": (lambda a, b: a > b, 4, 2, 2, None),
+    r"!": (lambda a: not a, 3, 1, 1, None),
+    r"?": (lambda condition, first, second: first if condition else second, 1, 3, 3, 1),
     #r".": (lambda target, attribute: target.call(attribute) if hasattr(target, attribute) and hasattr(target, 'call') else None, 9, 2, 2), # attribute access operator
 
 }
 
-dshell_operators: dict[str, tuple[Callable, int, int]] = dshell_logical_operators.copy()
+dshell_operators: dict[str, tuple[Callable, int, int, int, Optional[int]]] = dshell_logical_operators.copy()
 dshell_operators.update(dshell_logical_word_operators)
 dshell_operators.update(dshell_mathematical_operators)

{dshellinterpreter-1.2.3.0/dshellInterpreter.egg-info → dshellinterpreter-1.2.5.0}/PKG-INFO

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

{dshellinterpreter-1.2.3.0 → dshellinterpreter-1.2.5.0/dshellInterpreter.egg-info}/PKG-INFO

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

{dshellinterpreter-1.2.3.0 → dshellinterpreter-1.2.5.0}/setup.py

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