dshellInterpreter 1.2.5.0__tar.gz → 1.2.7.1__tar.gz

{dshellinterpreter-1.2.5.0 → dshellinterpreter-1.2.7.1}/Dshell/DISCORD_COMMANDS/utils/utils_global.py

@@ -67,7 +67,7 @@ async def utils_help(ctx: Message, command: StrNode) -> StrNode:
         raise ValueError(f"[HELP] command not found : '{command}'")
 
     sig = signature(dshell_commands[command])
-    result = StrNode("## HELP `{command}`")
+    result = StrNode(f"## HELP `{command}`")
 
     for nom, param in sig.parameters.items():
         if nom == "ctx":

{dshellinterpreter-1.2.5.0 → dshellinterpreter-1.2.7.1}/Dshell/DshellInterpreteur/dshell_interpreter.py

@@ -220,6 +220,16 @@ class DshellInterpreteur:
 
         await sleep(sleep_time)
 
+    async def _execute_catch_node(self, node: CatchNode):
+        """Execute a catch node."""
+        try:
+            await self.execute(node.body)
+        except Exception as e:
+            if self.end_program:
+                raise Exception(e)
+            self.env.set(node.variable.value, StrNode(e))
+        self.raise_error = False
+
     async def execute(self, ast: Optional[list[All_nodes]] = None):
         """
         Executes the abstract syntax tree (AST) generated from the Dshell code.
@@ -263,6 +273,9 @@ class DshellInterpreteur:
                 elif isinstance(node, BreakNode):
                     await self._execute_break_node(node)
 
+                elif isinstance(node, CatchNode):
+                    await self._execute_catch_node(node)
+
                 elif isinstance(node, VarNode):
                     await self._execute_var_node(node)
 
@@ -270,17 +283,18 @@ class DshellInterpreteur:
                     await self._execute_sleep_node(node)
 
                 elif isinstance(node, EvalNode):
-
                     self.env.set('__ret__', await eval_CodeNode(node, self))
 
                 elif isinstance(node, ReturnNode):
                     self.env.set('__ret__', await eval_expression(node.body, self))
 
+                elif isinstance(node, RaiseNode):
+                    raise Exception(StrNode(await eval_expression(node.error, self)))
+
                 elif isinstance(node, EndNode):
+                    self.end_program = True
                     if await self.eval_data_token(node.error_message):
                         raise RuntimeError("Execution stopped - EndNode encountered")
-                    else:
-                        self.end_program = True
 
             except Exception as e:
                 if not self.raise_error:

{dshellinterpreter-1.2.5.0 → dshellinterpreter-1.2.7.1}/Dshell/DshellParser/ast_nodes.py

@@ -36,7 +36,9 @@ __all__ = [
     'UiSelectNode',
     'OptionUiSelectNode',
     'FileNode',
-    'FileStreamNode'
+    'FileStreamNode',
+    'CatchNode',
+    'RaiseNode'
 ]
 
 
@@ -581,6 +583,53 @@ class SleepNode(ASTNode):
             "body": [token.to_dict() for token in self.body]
         }
 
+
+class CatchNode(ASTNode):
+    """
+    Node representing a "try-except" python-like in Dshell.
+    """
+    def __init__(self, body: list[Token], variable: Token, line: int):
+        super().__init__(line)
+        self.body = body
+        self.variable = variable
+
+    def __repr__(self):
+        return StrNode(f"<CATCH> - line {self.start_line} to {self.end_line}")
+
+    def to_dict(self):
+        """
+        Convert the EvalGroupNode to a dictionary representation.
+        :return: Dictionary representation of the EvalGroupNode.
+        """
+        return {
+            "type": "CatchNode",
+            "variable": self.variable,
+            "body": [token.to_dict() for token in self.body]
+        }
+
+
+class RaiseNode(ASTNode):
+    """
+    Node representing an Ecxeption raised by the user.
+    """
+    def __init__(self, error: list[Token], line: int):
+        super().__init__(line)
+        self.error = error
+
+    def __repr__(self):
+        return f"<RAISE> - {self.error}"
+
+    def to_dict(self):
+        """
+        Convert the RaiseNode to a dictionary representation.
+        :return: Dictionary representation of the EvalGroupNode.
+        """
+        return {
+            "type": "RaiseNode",
+            "error": self.error,
+        }
+
+
 class EvalGroupNode(ASTNode):
     """
     Node representing a group of evaluations in the AST.

{dshellinterpreter-1.2.5.0 → dshellinterpreter-1.2.7.1}/Dshell/DshellParser/dshell_parser.py

@@ -28,20 +28,21 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
         len_tokens_by_line = len(tokens_by_line)
         len_tokens_by_line_since_command_name = len_tokens_by_line - 1
         first_token_line = tokens_by_line[0]  # get the first token of the line
+        first_token_line_value = first_token_line.value
         last_block = blocks[-1]
 
         line = first_token_line.position[0]
 
         if first_token_line.type == DTT.COMMAND:  # if the token is a command
             body = tokens_by_line[1:]  # get its arguments
-            last_block.body.append(CommandNode(first_token_line.value,
+            last_block.body.append(CommandNode(first_token_line_value,
                                                ArgsCommandNode(body, line=line), line=line))  # add the command to the last block's body
 
         ############################## DSHELL KEYWORDS ##############################
 
         elif first_token_line.type == DTT.KEYWORD:  # if it's a keyword
 
-            if first_token_line.value == 'if':  # if it's a condition
+            if first_token_line_value == 'if':  # if it's a condition
                 if len_tokens_by_line_since_command_name <= 0:
                     raise SyntaxError(f'[IF] Take one or more arguments on line {first_token_line.position} !')
 
@@ -52,7 +53,7 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
                              if_node)  # parse the rest of the code with if_node as the start of the new parsing
                 pointer += p + 1  # essential to not parse already processed lines
 
-            elif first_token_line.value == '#if':
+            elif first_token_line_value == '#if':
                 if not isinstance(last_block, (IfNode, ElseNode, ElifNode)):
                     raise SyntaxError(f'[#IF] No conditional bloc open on line {first_token_line.position} !')
 
@@ -64,7 +65,7 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
                 blocks.pop()
                 return blocks, pointer
 
-            elif first_token_line.value == 'elif':
+            elif first_token_line_value == 'elif':
                 if not isinstance(last_block, (IfNode, ElifNode)):
                     raise SyntaxError(f'[ELIF] No conditional bloc open on line {first_token_line.position} !')
                 if len_tokens_by_line_since_command_name <= 0:
@@ -81,7 +82,7 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
                         last_block.elif_nodes.append(elif_node)
                 blocks.append(elif_node)
 
-            elif first_token_line.value == 'else':
+            elif first_token_line_value == 'else':
                 if not isinstance(last_block, (IfNode, ElifNode)):
                     raise SyntaxError(f'[ELSE] No conditional bloc open on line {first_token_line.position} !')
 
@@ -95,7 +96,7 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
                     last_block.else_body = else_node  # once parsing is done, add it to the last block
                 blocks.append(else_node)
 
-            elif first_token_line.value == 'loop':
+            elif first_token_line_value == 'loop':
 
                 if len_tokens_by_line <= 1:
                     raise SyntaxError(f'[LOOP] Take one (or two) argument(s) on line {first_token_line.position} !')
@@ -126,19 +127,19 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
                                  loop_node)  # parse everything after the loop instruction
                     pointer += p + 1
 
-            elif first_token_line.value == '#loop':  # if encountered
+            elif first_token_line_value == '#loop':  # if encountered
                 if not isinstance(last_block, LoopNode):
                     raise SyntaxError(f'[#LOOP] No loop open on line {first_token_line.position} !')
 
                 blocks.pop()
                 return blocks, pointer  # return the parsed information to the last opened loop
 
-            elif first_token_line.value == 'break':
+            elif first_token_line_value == 'break':
 
                 break_node = BreakNode(line=line)
                 last_block.body.append(break_node)
 
-            elif first_token_line.value == 'var':
+            elif first_token_line_value == 'var':
                 if len(tokens_by_line) <= 2:
                     raise SyntaxError(f'[VAR] Take two arguments on line {first_token_line.position} !')
                 if tokens_by_line[1].type != DTT.IDENT:
@@ -155,7 +156,7 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
                     # var_node.body = parse(result, StartNode([]))[0][0].body
                     var_node.body = result[0]
 
-            elif first_token_line.value == 'sleep':
+            elif first_token_line_value == 'sleep':
                 if len(tokens_by_line) <= 1:
                     raise SyntaxError(f'[SLEEP] Take one arguments on line {first_token_line.position} !')
                 if tokens_by_line[1].type != DTT.INT:
@@ -165,21 +166,21 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
                 sleep_node = SleepNode(tokens_by_line[1:], line=line)
                 last_block.body.append(sleep_node)
 
-            elif first_token_line.value == 'param':
+            elif first_token_line_value == 'param':
 
                 param_node = ParamNode(body=[], line=line)
                 last_block.body.append(param_node)
                 _, p = parse(token_lines[pointer + 1:], param_node)
                 pointer += p + 1  # advance the pointer to the next line
 
-            elif first_token_line.value == '#param':
+            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()  # remove the last block (the parameter)
                 return blocks, pointer  # return the parsed information to the last opened parameter
 
-            elif first_token_line.value == 'code':
+            elif first_token_line_value == 'code':
 
                 if len(tokens_by_line) < 2:
                     raise SyntaxError(f"[CODE] take one argument on line {first_token_line.position}")
@@ -194,14 +195,14 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
                 _, p = parse(token_lines[pointer + 1:], code_node)
                 pointer += p + 1
 
-            elif first_token_line.value == '#code':
+            elif first_token_line_value == '#code':
                 if not isinstance(last_block, CodeNode):
                     raise SyntaxError(f"[#CODE] No code open on line {first_token_line.position}")
 
                 blocks.pop()
                 return blocks, pointer
 
-            elif first_token_line.value == 'eval':
+            elif first_token_line_value == 'eval':
                 if len_tokens_by_line_since_command_name < 1:
                     raise SyntaxError(f"[EVAL] take one or more arguments on line {first_token_line.position}")
 
@@ -212,7 +213,7 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
                 eval_node = EvalNode(codeNode=tokens_by_line[1], argsNode=ArgsCommandNode(tokens_by_line[2:], line=line), line=line)
                 last_block.body.append(eval_node)
 
-            elif first_token_line.value == 'return':
+            elif first_token_line_value == 'return':
                 if not isinstance(last_block, CodeNode):
                     raise SyntaxError(f"[RETURN] No code open on line {first_token_line.position} !")
                 if len_tokens_by_line_since_command_name < 1:
@@ -220,8 +221,29 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
 
                 return_node = ReturnNode(body=tokens_by_line[1:], line=line)
                 last_block.body.append(return_node)
+                
+            elif first_token_line_value == 'catch':
+                if len_tokens_by_line_since_command_name > 0:
+                    if tokens_by_line[1].type != DTT.IDENT:
+                        raise TypeError(f'[CATCH] the variable given must be an ident, not {tokens_by_line[1].type}')
+                catch_node = CatchNode(body=[], variable=tokens_by_line[1], line=line)
+                last_block.body.append(catch_node)
+                _, p = parse(token_lines[pointer + 1:], catch_node)
+                pointer += p + 1
+
+            elif first_token_line_value == '#catch':
+                if not isinstance(last_block, CatchNode):
+                    raise Exception(f'[#CATCH] not catch open on line {first_token_line.position}')
+
+                blocks.pop()
+                return blocks, pointer
+
+            elif first_token_line_value == 'raise':
+
+                raise_node = RaiseNode(tokens_by_line[1:], line=line)
+                last_block.body.append(raise_node)
 
-            elif first_token_line.value == '#end':  # node pour arrêter le programme si elle est rencontré
+            elif first_token_line_value == '#end':  # node pour arrêter le programme si elle est rencontré
                 error_message = BoolNode(1)
                 if len_tokens_by_line_since_command_name > 0:
                     if tokens_by_line[1].type != DTT.BOOL:
@@ -235,7 +257,7 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
 
         elif first_token_line.type == DTT.DISCORD_KEYWORD:
 
-            if first_token_line.value == 'embed':
+            if first_token_line_value == 'embed':
                 if len_tokens_by_line_since_command_name <= 0:
                     raise SyntaxError(f'[EMBED] Take one or more arguments on line {first_token_line.position} !')
                 if tokens_by_line[1].type != DTT.IDENT:
@@ -248,13 +270,13 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
                 _, p = parse(token_lines[pointer + 1:], embed_node)
                 pointer += p + 1
 
-            elif first_token_line.value == '#embed':
+            elif first_token_line_value == '#embed':
                 if not isinstance(last_block, ConstructEmbedNode):
                     raise SyntaxError(f'[#EMBED] No embed open on line {first_token_line.position} !')
                 blocks.pop()
                 return blocks, pointer
 
-            elif first_token_line.value == 'field':
+            elif first_token_line_value == 'field':
                 if len_tokens_by_line_since_command_name <= 0:
                     raise SyntaxError(f'[FIELD] Take one or more arguments on line {first_token_line.position} !')
                 if not isinstance(last_block, EmbedNode):
@@ -262,7 +284,7 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
 
                 last_block.fields.append(FieldEmbedNode(tokens_by_line[1:], line=line))
 
-            elif first_token_line.value in ('perm', 'permission'):
+            elif first_token_line_value in ('perm', 'permission'):
                 if len_tokens_by_line_since_command_name <= 0:
                     raise SyntaxError(f'[PERM] Take one argument on line {first_token_line.position} !')
                 if tokens_by_line[1].type != DTT.IDENT:
@@ -275,13 +297,13 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
                 _, p = parse(token_lines[pointer + 1:], perm_node)
                 pointer += p + 1
 
-            elif first_token_line.value in ('#perm', '#permission'):
+            elif first_token_line_value in ('#perm', '#permission'):
                 if not isinstance(last_block, ConstructPermissionNode):
                     raise SyntaxError(f'[#PERM] No permission open on line {first_token_line.position} !')
                 blocks.pop()
                 return blocks, pointer
 
-            elif first_token_line.value == 'button':
+            elif first_token_line_value == 'button':
                 if len_tokens_by_line_since_command_name <= 0:
                     raise SyntaxError(f'[BUTTON] Take one or more arguments on line {first_token_line.position} !')
                 if tokens_by_line[1].type != DTT.IDENT:
@@ -294,13 +316,13 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
                 _, p = parse(token_lines[pointer + 1:], button_node)
                 pointer += p + 1
 
-            elif first_token_line.value == '#button':
+            elif first_token_line_value == '#button':
                 if not isinstance(last_block, UiButtonNode):
                     raise SyntaxError(f'[#BUTTON] No UIButton open on line {first_token_line.position} !')
                 blocks.pop()
                 return blocks, pointer
 
-            elif first_token_line.value == 'select':
+            elif first_token_line_value == 'select':
                 if len_tokens_by_line_since_command_name <= 0:
                     raise SyntaxError(f'[SELECT] Take one or more arguments on line {first_token_line.position} !')
                 if tokens_by_line[1].type != DTT.IDENT:
@@ -313,13 +335,13 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
                 _, p = parse(token_lines[pointer + 1:], select_node)
                 pointer += p + 1
 
-            elif first_token_line.value == '#select':
+            elif first_token_line_value == '#select':
                 if not isinstance(last_block, UiSelectNode):
                     raise SyntaxError(f'[#SELECT] No UISelect open on line {first_token_line.position} !')
                 blocks.pop()
                 return blocks, pointer
 
-            elif first_token_line.value == 'option':
+            elif first_token_line_value == 'option':
                 if len_tokens_by_line_since_command_name <= 0:
                     raise SyntaxError(f'[OPTION] Take one or more arguments on line {first_token_line.position} !')
                 if not isinstance(last_block, UiSelectNode):

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

@@ -14,11 +14,14 @@ from ..full_import import Callable
 from ..DshellInterpreteur.dshell_iterators import IntIterator
 
 dshell_keyword: set[str] = {
-    'if', 'else', 'elif', 'loop', '#end', 'var', '#loop', '#if', 'sleep', 'param', '#param', 'code', '#code', 'eval', 'return', 'break'
+    'if', 'else', 'elif', 'loop', '#end', 'var', '#loop', '#if', 'sleep',
+    'param', '#param', 'code', '#code', 'eval', 'return', 'break',
+    'catch', '#catch', 'raise'
 }
 
 dshell_discord_keyword: set[str] = {
-    'embed', '#embed', 'field', 'perm', 'permission', '#perm', '#permission', 'ui', '#ui', 'button', '#button', 'select', '#select', 'option'
+    'embed', '#embed', 'field', 'perm', 'permission', '#perm', '#permission', 'ui', '#ui',
+    'button', '#button', 'select', '#select', 'option'
 }
 
 async def dshell_debug(ctx, x):

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

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

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

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

{dshellinterpreter-1.2.5.0 → dshellinterpreter-1.2.7.1}/dshellInterpreter.egg-info/SOURCES.txt

@@ -3,7 +3,6 @@ README.md
 setup.py
 Dshell/__init__.py
 Dshell/full_import.py
-Dshell/regex_test.py
 Dshell/DISCORD_COMMANDS/__init__.py
 Dshell/DISCORD_COMMANDS/dshell_channel.py
 Dshell/DISCORD_COMMANDS/dshell_embed.py

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

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

dshellinterpreter-1.2.5.0/Dshell/regex_test.py

@@ -1,3 +0,0 @@
-from re import sub, search
-
-print(sub(f"(?<![a-zA-Z])p(?![a-zA-Z])", "debug", "{p*2}"))