dshellInterpreter 0.2.15.2__py3-none-any.whl → 0.2.15.4__py3-none-any.whl

Dshell/DISCORD_COMMANDS/utils/__init__.py

@@ -0,0 +1,4 @@
+from .utils_thread import *
+from .utils_message import *
+from .utils_list import *
+from .utils_global import *

Dshell/DISCORD_COMMANDS/utils/utils_global.py

@@ -0,0 +1,15 @@
+__all__ = [
+    "utils_len",
+]
+
+async def utils_len(ctx, value):
+    """
+    Return the length of a list, or a string
+    :param value:
+    :return:
+    """
+    from ..._DshellParser.ast_nodes import ListNode
+    if not isinstance(value, (str, ListNode)):
+        raise TypeError(f"value must be a list or a string in len command, not {type(value)}")
+
+    return len(value)

Dshell/DISCORD_COMMANDS/utils/utils_list.py

@@ -0,0 +1,91 @@
+__all__ = [
+    "utils_list_add",
+    "utils_list_remove",
+    "utils_list_clear",
+    "utils_list_pop",
+    "utils_list_sort",
+    "utils_list_reverse"
+]
+
+async def utils_list_add(ctx, value: "ListNode", *elements):
+    """
+    Add an element to a list
+    :param value:
+    :param elements:
+    :return:
+    """
+    from ..._DshellParser.ast_nodes import ListNode
+    if not isinstance(value, ListNode):
+        raise TypeError("value must be a list in add command")
+
+    for elem in elements:
+        value.add(elem)
+    return value
+
+async def utils_list_remove(ctx, value: "ListNode", *elements):
+    """
+    Remove an element from a list
+    :param value:
+    :param elements:
+    :return:
+    """
+    from ..._DshellParser.ast_nodes import ListNode
+    if not isinstance(value, ListNode):
+        raise TypeError("value must be a list in remove command")
+
+    for elem in elements:
+        value.remove(elem)
+    return value
+
+async def utils_list_clear(ctx, value: "ListNode"):
+    """
+    Clear a list
+    :param value:
+    :return:
+    """
+    from ..._DshellParser.ast_nodes import ListNode
+    if not isinstance(value, ListNode):
+        raise TypeError("value must be a list in clear command")
+    value.clear()
+    return value
+
+async def utils_list_pop(ctx, value: "ListNode", index: int = -1):
+    """
+    Pop an element from a list
+    :param value:
+    :param index:
+    :return:
+    """
+    from ..._DshellParser.ast_nodes import ListNode
+    if not isinstance(value, ListNode):
+        raise TypeError("value must be a list in pop command")
+    if not isinstance(index, int):
+        raise TypeError("index must be an integer in pop command")
+    return value.pop(index)
+
+async def utils_list_sort(ctx, value: "ListNode", reverse: bool = False):
+    """
+    Sort a list
+    :param value:
+    :param reverse:
+    :return:
+    """
+    from ..._DshellParser.ast_nodes import ListNode
+    if not isinstance(value, ListNode):
+        raise TypeError("value must be a list in sort command")
+    if not isinstance(reverse, bool):
+        raise TypeError("reverse must be a boolean in sort command")
+    value.sort(reverse=reverse)
+    return value
+
+async def utils_list_reverse(ctx, value: "ListNode"):
+    """
+    Reverse a list
+    :param value:
+    :return:
+    """
+    from ..._DshellParser.ast_nodes import ListNode
+    if not isinstance(value, ListNode):
+        raise TypeError("value must be a list in reverse command")
+    value.reverse()
+    return value

Dshell/_DshellInterpreteur/dshell_interpreter.py

@@ -17,7 +17,7 @@ from .._DshellTokenizer.dshell_token_type import DshellTokenType as DTT
 from .._DshellTokenizer.dshell_token_type import Token
 from .._DshellTokenizer.dshell_tokenizer import DshellTokenizer
 
-All_nodes = TypeVar('All_nodes', IfNode, LoopNode, ElseNode, ElifNode, ArgsCommandNode, VarNode, IdentOperationNode)
+All_nodes = TypeVar('All_nodes', IfNode, LoopNode, ElseNode, ElifNode, ArgsCommandNode, VarNode)
 context = TypeVar('context', AutoShardedBot, Message, PrivateChannel, Interaction)
 ButtonStyleValues: tuple = tuple(i.name for i in ButtonStyle)
 
@@ -74,7 +74,7 @@ class DshellInterpreteur:
             '__guild_channels__': ListNode([channel.id for channel in message.channel.guild.channels]),
             '__guild_channels_count__': len(message.channel.guild.channels),
 
-        } if message is not None or not debug else {} # {} is used in debug mode, when ctx is None
+        } if message is not None and not debug else {} # {} is used in debug mode, when ctx is None
         self.vars = vars if vars is not None else ''
         self.ctx: context = ctx
         if debug:
@@ -162,15 +162,9 @@ class DshellInterpreteur:
                 elif isinstance(first_node, LengthNode):
                     self.env[node.name.value] = length(first_node)
 
-                elif isinstance(first_node, IdentOperationNode):
-                    self.env[node.name.value] = self.eval_ident_operation(first_node)
-
                 else:
                     self.env[node.name.value] = eval_expression(node.body, self)
 
-            elif isinstance(node, IdentOperationNode):
-                return self.eval_ident_operation(node)
-
             elif isinstance(node, SleepNode):
                 sleep_time = eval_expression(node.body, self)
                 if sleep_time > 3600:
@@ -217,12 +211,6 @@ class DshellInterpreteur:
         else:
             return token.value  # fallback
 
-    def eval_ident_operation(self, node: IdentOperationNode) -> Optional[Any]:
-        function = self.eval_data_token(node.function)
-        listNode = self.eval_data_token(node.ident)
-        if hasattr(listNode, function):
-            return getattr(listNode, function)(self.eval_data_token(node.args))
-        return None
 
 def get_params(node: ParamNode, interpreter: DshellInterpreteur) -> dict[str, Any]:
     """

Dshell/_DshellParser/ast_nodes.py

@@ -18,7 +18,6 @@ __all__ = [
     'FieldEmbedNode',
     'EmbedNode',
     'SleepNode',
-    'IdentOperationNode',
     'ListNode',
     'PermissionNode',
     'ParamNode',
@@ -406,39 +405,6 @@ class SleepNode(ASTNode):
         }
 
 
-class IdentOperationNode(ASTNode):
-    """
-    Node representing an operation on an identifier in the AST.
-    Manages operations on idendifiers (function calls)
-    Ensure that the function call returns the associated class to allow nesting. Not mandatory in itself if it returns something
-    """
-
-    def __init__(self, ident: Token, function: Token, args: Token):
-        """
-        :param ident: Token representing the identifier (e.g., a class or object)
-        :param function: Token representing the function to be called on the identifier
-        :param args: Token representing the arguments passed to the function
-        """
-        self.ident = ident
-        self.function = function
-        self.args = args
-
-    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 ParamNode(ASTNode):
     """
     Node representing a parameter in the AST.
@@ -595,16 +561,18 @@ class ListNode(ASTNode):
                 continue
             count += 1
 
-    def pop(self):
+    def pop(self, index: int = -1):
         """
         Remove and return the last element of the list.
         :return: The last element of the list.
         """
         if self.len_iterable == 0:
             raise IndexError("pop from empty list")
+        if 0 > index >= self.len_iterable or -self.len_iterable > index < 0:
+            raise IndexError("pop index out of range")
 
         self.len_iterable -= 1
-        return self.iterable.pop()
+        return self.iterable.pop(index)
 
     def count(self):
         """

Dshell/_DshellParser/dshell_parser.py

@@ -2,33 +2,13 @@ __all__ = [
     "parse",
     "parser_inline",
     "to_postfix",
-    "parse_postfix_expression",
     "print_ast",
     "ast_to_dict",
 ]
 
 from typing import Union
 
-from .ast_nodes import (ASTNode,
-                        LengthNode,
-                        CommandNode,
-                        IfNode,
-                        LoopNode,
-                        ElseNode,
-                        ArgsCommandNode,
-                        ElifNode,
-                        VarNode,
-                        EndNode,
-                        SleepNode,
-                        IdentOperationNode,
-                        EmbedNode,
-                        FieldEmbedNode,
-                        PermissionNode,
-                        ParamNode,
-                        UiNode,
-                        UiButtonNode,
-                        UiSelectNode,
-                        StartNode)
+from .ast_nodes import *
 from .._DshellTokenizer import dshell_operators
 from .._DshellTokenizer.dshell_token_type import DshellTokenType as DTT
 from .._DshellTokenizer.dshell_token_type import Token
@@ -181,15 +161,6 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
                 end_node = EndNode()
                 last_block.body.append(end_node)
 
-            elif first_token_line.value in ('length', 'len'):
-                if len(tokens_by_line) != 3:
-                    raise SyntaxError(f"[LENGTH] Take 2 arguments on line {first_token_line.position} !")
-                if tokens_by_line[1].type not in (DTT.IDENT, DTT.STR, DTT.LIST):
-                    raise SyntaxError(f"[LENGTH] Take an ident, str or list on line {tokens_by_line[1].position}, not {first_token_line.type} !")
-
-                var_node = VarNode(tokens_by_line[1], body=[LengthNode(tokens_by_line[2])])
-                last_block.body.append(var_node)
-
         ############################## DISCORD KEYWORDS ##############################
 
         elif first_token_line.type == DTT.DISCORD_KEYWORD:
@@ -282,9 +253,6 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
             if len(tokens_by_line) == 1:
                 last_block.body.append(CommandNode(name='sm', body=ArgsCommandNode([first_token_line])))
 
-            else:
-                last_block.body += parse_postfix_expression(to_postfix(tokens_by_line))
-
         elif first_token_line.type == DTT.STR:
             last_block.body.append(CommandNode(name='sm', body=ArgsCommandNode([first_token_line])))
 
@@ -297,13 +265,6 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
     return blocks, pointeur
 
 
-"""
-elif first_token_line.type == DTT.LIST: # si le token est une liste (qui comporte une liste python avec des Tokens)
-    list_node = ListNode(first_token_line.value) # le .value est une liste python
-    last_block.body.append(list_node)
-    """
-
-
 def ast_to_dict(obj):
     if isinstance(obj, list):
         return [ast_to_dict(item) for item in obj]
@@ -375,42 +336,6 @@ def to_postfix(expression):
     return output
 
 
-def parse_postfix_expression(postfix_tokens: list[Token]) -> list[IdentOperationNode]:
-    stack = []
-
-    for tok in postfix_tokens:
-
-        if tok.type in (DTT.IDENT, DTT.CALL_ARGS, DTT.INT, DTT.STR, DTT.LIST, DTT.FLOAT, DTT.BOOL):
-            stack.append(tok)
-
-        elif tok.type == DTT.MATHS_OPERATOR:
-            if tok.value == '.':
-                args = stack.pop()
-                func = stack.pop()
-                base = stack.pop()
-                node = IdentOperationNode(ident=base, function=func, args=args)
-                stack.append(node)
-
-            elif tok.value == '->':
-                value = stack.pop()
-                base = stack.pop()
-                fake_func = Token(DTT.IDENT, 'at', tok.position)
-                fake_args = Token(DTT.CALL_ARGS, value.value, value.position)
-                node = IdentOperationNode(ident=base, function=fake_func, args=fake_args)
-                stack.append(node)
-
-            else:
-                raise SyntaxError(f"Opérateur non supporté dans les appels : {tok.value}")
-
-        else:
-            raise SyntaxError(f"Token inattendu : {tok}")
-
-    if len(stack) != 1:
-        raise SyntaxError("Expression mal formée ou incomplète")
-
-    return stack
-
-
 def print_ast(ast: list[ASTNode], decalage: int = 0):
     for i in ast:
 
@@ -434,9 +359,6 @@ def print_ast(ast: list[ASTNode], decalage: int = 0):
                 print(f"{' ' * decalage}ELSE -> ...")
                 print_ast(i.else_body, decalage + 5)
 
-        elif isinstance(i, IdentOperationNode):
-            print(f"{' ' * decalage}IDENT_OPERATION -> {i.ident}.{i.function}({i.args})")
-
         elif isinstance(i, CommandNode):
             print(f"{' ' * decalage}COMMAND -> {i.name} : {i.body}")
 

Dshell/_DshellTokenizer/dshell_keywords.py

@@ -10,15 +10,18 @@ __all__ = [
 
 from typing import Callable
 
+from ..DISCORD_COMMANDS import utils_len, utils_list_add
 from ..DISCORD_COMMANDS.dshell_channel 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 *
 from ..DISCORD_COMMANDS.dshell_interaction import *
+from ..DISCORD_COMMANDS.utils.utils_global import *
+from ..DISCORD_COMMANDS.utils.utils_list import *
 
 dshell_keyword: set[str] = {
-    'if', 'else', 'elif', 'loop', '#end', 'var', '#loop', '#if', 'sleep', 'param', '#param', 'length', 'len'
+    'if', 'else', 'elif', 'loop', '#end', 'var', '#loop', '#if', 'sleep', 'param', '#param'
 }
 
 dshell_discord_keyword: set[str] = {
@@ -26,6 +29,15 @@ dshell_discord_keyword: set[str] = {
 }
 dshell_commands: dict[str, Callable] = {
 
+    'length': utils_len,
+    'len': utils_len,
+    'add': utils_list_add,
+    'remove': utils_list_remove,
+    'clear': utils_list_clear,
+    'pop': utils_list_pop,
+    'sort': utils_list_sort,
+    'reverse': utils_list_reverse,
+
     "gp": dshell_get_pastbin,  # get pastbin
 
     "sm": dshell_send_message,  # send message

Dshell/_DshellTokenizer/dshell_tokenizer.py

@@ -18,7 +18,6 @@ table_regex: dict[DTT, Pattern] = {
     DTT.STR: compile(r'"((?:[^\\"]|\\.)*)"', flags=DOTALL),
     DTT.COMMENT: compile(r"::(.*?)$"),
     DTT.LIST: compile(r"\[(.*?)\]"),
-    DTT.CALL_ARGS: compile(r"\((.*?)\)"),
     DTT.MENTION: compile(r'<(?:@!?|@&|#)([0-9]+)>'),
     DTT.SEPARATOR: compile(rf"(--)"),
     DTT.SUB_SEPARATOR: compile(rf"(~~)"),

{dshellinterpreter-0.2.15.2.dist-info → dshellinterpreter-0.2.15.4.dist-info}/METADATA

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

{dshellinterpreter-0.2.15.2.dist-info → dshellinterpreter-0.2.15.4.dist-info}/RECORD

@@ -7,20 +7,22 @@ Dshell/DISCORD_COMMANDS/dshell_member.py,sha256=5Iw-2dydhYMZOw2nx0svZP9JpZWHOXC0
 Dshell/DISCORD_COMMANDS/dshell_message.py,sha256=zcWl6Y1W31h9MTHS-j9tLDwcrRiE_wGOu78zu2k0y9I,9101
 Dshell/DISCORD_COMMANDS/dshell_pastbin.py,sha256=H0tUJOwdzYBXvxqipK3mzoNZUKrSLcVm4EZlWbBRScs,796
 Dshell/DISCORD_COMMANDS/dshell_role.py,sha256=t_yRZRD0FKE2gT4dIDIsHz2PSZZztDVEkkqkG_OkNh4,5002
-Dshell/DISCORD_COMMANDS/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+Dshell/DISCORD_COMMANDS/utils/__init__.py,sha256=-amNcYysjgx3YDpDSnbQmJhnm3lbJere9K9aDH-YnJg,115
+Dshell/DISCORD_COMMANDS/utils/utils_global.py,sha256=JDueE5jCIosUziWNuzzW7iw6_RjgGfHEszJXKgU6FR8,387
+Dshell/DISCORD_COMMANDS/utils/utils_list.py,sha256=kJ1vgqdAKef-siAUvGwvKgD2ezMJpnFUP2UQ3v6-ARw,2569
 Dshell/DISCORD_COMMANDS/utils/utils_message.py,sha256=cQvJ15f49ddOjybARwkJKNFe3ITYQciF-pZHERFPkr0,2964
 Dshell/DISCORD_COMMANDS/utils/utils_thread.py,sha256=tVl4msEwrWHY-0AytI6eY3JSs-eIFUigDSJfK9mT1ww,1457
 Dshell/_DshellInterpreteur/__init__.py,sha256=xy5-J-R3YmY99JF3NBHTRRLsComFxpjnCA5xacISctU,35
-Dshell/_DshellInterpreteur/dshell_interpreter.py,sha256=I22N3R0eH0mK9KlepbUcvqP4YOmTCcSZdI5_CyIsy34,32716
+Dshell/_DshellInterpreteur/dshell_interpreter.py,sha256=OGn6HHPrlVWVI9z7s90edBqrv3Fv410A0rPYW8JP-Hs,32096
 Dshell/_DshellParser/__init__.py,sha256=ONDfhZMvClqP_6tE8SLjp-cf3pXL-auQYnfYRrHZxC4,56
-Dshell/_DshellParser/ast_nodes.py,sha256=X7kw5nflGCi_h4FWlK5vytedR70Mwarj5NbhpaqYao4,19643
-Dshell/_DshellParser/dshell_parser.py,sha256=YUFfBbFQ1ApOCyVhx-0nJ6S6W5MOBG6YabbkM43BKVw,21708
+Dshell/_DshellParser/ast_nodes.py,sha256=m6a4bMFVb0grMCyghWMeb4xABxdlWxFBbycnR388dg0,18518
+Dshell/_DshellParser/dshell_parser.py,sha256=KD2ZbKYa1nnvroKmN8fIRD2exXre54Qx_roEBrTV7Mo,18588
 Dshell/_DshellTokenizer/__init__.py,sha256=LIQSRhDx2B9pmPx5ADMwwD0Xr9ybneVLhHH8qrJWw_s,172
-Dshell/_DshellTokenizer/dshell_keywords.py,sha256=7oeSKLXCsPRpyU31skCerOUMzd2cdm-GwofpmgTPkD0,5961
+Dshell/_DshellTokenizer/dshell_keywords.py,sha256=4QvBXvuXJPjKWyhVqAPBYCqE95G7dG8waXD3XtmuoBw,6345
 Dshell/_DshellTokenizer/dshell_token_type.py,sha256=gYIb2XN2YcgeRgmar_rBDS5CGmwfmxihu8mOW_d6lbE,1533
-Dshell/_DshellTokenizer/dshell_tokenizer.py,sha256=RrJA2XpcFH2vS6SnRIn5Own_uL5orIDvpq74t8xD3og,7350
-dshellinterpreter-0.2.15.2.dist-info/licenses/LICENSE,sha256=lNgcw1_xb7QENAQi3uHGymaFtbs0RV-ihiCd7AoLQjA,1082
-dshellinterpreter-0.2.15.2.dist-info/METADATA,sha256=3QaELBxioT7TBr87RxJNDV_g0WP9wxLxcCUyC7uGB8A,1151
-dshellinterpreter-0.2.15.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-dshellinterpreter-0.2.15.2.dist-info/top_level.txt,sha256=B4CMhtmchGwPQJLuqUy0GhRG-0cUGxKL4GqEbCiB_vE,7
-dshellinterpreter-0.2.15.2.dist-info/RECORD,,
+Dshell/_DshellTokenizer/dshell_tokenizer.py,sha256=AJnUocD6hbU6wvjRAN5uDha5QQieTwXlHzZVtgRGaZQ,7307
+dshellinterpreter-0.2.15.4.dist-info/licenses/LICENSE,sha256=lNgcw1_xb7QENAQi3uHGymaFtbs0RV-ihiCd7AoLQjA,1082
+dshellinterpreter-0.2.15.4.dist-info/METADATA,sha256=FkIk1dGusH1JtAgBPDrT3FSPIDu3frzRXveXsjaWcC8,1151
+dshellinterpreter-0.2.15.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dshellinterpreter-0.2.15.4.dist-info/top_level.txt,sha256=B4CMhtmchGwPQJLuqUy0GhRG-0cUGxKL4GqEbCiB_vE,7
+dshellinterpreter-0.2.15.4.dist-info/RECORD,,