dshellInterpreter 0.2.13.15__tar.gz → 0.2.13.17__tar.gz

{dshellinterpreter-0.2.13.15 → dshellinterpreter-0.2.13.17}/Dshell/DISCORD_COMMANDS/dshell_pastbin.py

@@ -6,14 +6,16 @@ __all__ = [
 ]
 
 
-async def dshell_get_pastbin(ctx: Message, code: str):
+async def dshell_get_pastbin(ctx: Message, code: str) -> "ListNode":
     """
     Get a pastbin from a code snippet.
     """
     if not isinstance(code, str):
         raise Exception(f'Code must be a string, not {type(code)} !')
 
-    content = ''  # Initialize content to an empty string
+    from .._DshellParser.ast_nodes import ListNode
+
+    content = ListNode([])  # Initialize content to an empty string
 
     with get(f"https://pastebin.com/raw/{code}", stream=True, timeout=10) as response:
 
@@ -21,10 +23,6 @@ async def dshell_get_pastbin(ctx: Message, code: str):
             raise Exception(f"Failed to retrieve pastbin with code {code} !")
 
         for line in response.iter_lines(decode_unicode=True, chunk_size=512):
-            len_content = len(content)
-            if len_content < 4000 and len_content + len(line) <= 4000:
-                content += line + '\n'
-            else:
-                break
+            content.add(line)
 
     return content

{dshellinterpreter-0.2.13.15 → dshellinterpreter-0.2.13.17}/Dshell/_DshellInterpreteur/dshell_interpreter.py

@@ -4,7 +4,7 @@ from typing import TypeVar, Union, Any, Optional, Callable
 from random import choice
 from string import ascii_letters, digits
 from copy import deepcopy
-from pycordViews import SelectMenu, EasyModifiedViews
+from pycordViews import EasyModifiedViews
 
 from discord import AutoShardedBot, Embed, Colour, PermissionOverwrite, Permissions, Guild, Member, Role, Message, Interaction, ButtonStyle
 from discord.ui import Button
@@ -63,10 +63,18 @@ class DshellInterpreteur:
             '__guild__': message.channel.guild.id,
             '__guild_name__': message.channel.guild.name,
             '__guild_id__': message.channel.guild.id,
+            '__guild_members__': ListNode([member.id for member in message.channel.guild.members]),
             '__guild_member_count__': message.channel.guild.member_count,
             '__guild_icon__': message.channel.guild.icon.url if message.channel.guild.icon else None,
             '__guild_owner_id__': message.channel.guild.owner_id,
             '__guild_description__': message.channel.guild.description,
+            '__guild_roles__': ListNode([role.id for role in message.channel.guild.roles]),
+            '__guild_roles_count__': len(message.channel.guild.roles),
+            '__guild_emojis__': ListNode([emoji.id for emoji in message.channel.guild.emojis]),
+            '__guild_emojis_count__': len(message.channel.guild.emojis),
+            '__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
         self.vars = vars if vars is not None else ''
         self.ctx: context = ctx
@@ -140,6 +148,9 @@ class DshellInterpreteur:
                 elif isinstance(first_node, UiNode):
                     self.env[node.name.value] = build_ui(first_node, self)
 
+                elif isinstance(first_node, LengthNode):
+                    self.env[node.name.value] = length(first_node.body)
+
                 else:
                     self.env[node.name.value] = eval_expression(node.body, self)
 
@@ -382,6 +393,19 @@ def regroupe_commandes(body: list[Token], interpreter: DshellInterpreteur, norma
 
     return list_tokens
 
+def length(variable : LengthNode) -> int:
+    """
+    Count characters or items in string/list
+    :param variable:
+    :return:
+    """
+    if not isinstance(variable.body, ListNode) and variable.body.type not in (DTT.STR, DTT.IDENT):
+        raise Exception(f'Length take string, ident or list, not {type(variable.body)} !')
+
+    if isinstance(variable.body, ListNode):
+        return len(variable.body)
+    else:
+        return len(variable.body.value)
 
 def build_embed(body: list[Token], fields: list[FieldEmbedNode], interpreter: DshellInterpreteur) -> Embed:
     """

{dshellinterpreter-0.2.13.15 → dshellinterpreter-0.2.13.17}/Dshell/_DshellParser/ast_nodes.py

@@ -5,6 +5,7 @@ from .._DshellTokenizer.dshell_token_type import Token
 
 __all__ = [
     'ASTNode',
+    'LengthNode',
     'StartNode',
     'ElseNode',
     'ElifNode',
@@ -257,6 +258,29 @@ class VarNode(ASTNode):
             "body": [token.to_dict() for token in self.body]
         }
 
+class LengthNode(ASTNode):
+    """
+    Node representing the length operation in the AST.
+    """
+
+    def __init__(self, body: Token):
+        """
+        :param body: list of tokens representing the body of the length operation
+        """
+        self.body = body
+
+    def __repr__(self):
+        return f"<LENGTH> - {self.body}"
+
+    def to_dict(self):
+        """
+        Convert the LengthNode to a dictionary representation.
+        :return: Dictionary representation of the LengthNode.
+        """
+        return {
+            "type": "LengthNode",
+            "body": self.body.to_dict()
+        }
 
 class EndNode(ASTNode):
     """

{dshellinterpreter-0.2.13.15 → dshellinterpreter-0.2.13.17}/Dshell/_DshellParser/dshell_parser.py

@@ -10,6 +10,7 @@ __all__ = [
 from typing import Union
 
 from .ast_nodes import (ASTNode,
+                        LengthNode,
                         CommandNode,
                         IfNode,
                         LoopNode,
@@ -40,7 +41,7 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
     :param start_node: the node where to start the parsing
     """
     pointeur = 0  # pointeur sur les listes de tokens pour savoir ou parser
-    blocks: list[Union[ASTNode, EndNode]] = [start_node]  # liste d'imbrication des blocks pour gérer l'imbrication
+    blocks = [start_node]  # liste d'imbrication des blocks pour gérer l'imbrication
     len_token_lines = len(token_lines)
 
     while pointeur < len_token_lines:
@@ -50,6 +51,8 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
         last_block = blocks[-1]
 
         if first_token_line.type == DTT.COMMAND:  # si le token est une comande
+            if len(tokens_by_line) <= 1:
+                raise Exception(f'[{first_token_line.value.upper()}] take one or more arguments on line {first_token_line.position} !')
             body = tokens_by_line[1:]  # on récupère ses arguments
             last_block.body.append(CommandNode(first_token_line.value,
                                                ArgsCommandNode(body)))  # on ajoute la commande au body du dernier bloc
@@ -59,6 +62,9 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
         elif first_token_line.type == DTT.KEYWORD:  # si c'est un mot clé
 
             if first_token_line.value == 'if':  # si c'est une condition
+                if len(tokens_by_line) <= 1:
+                    raise SyntaxError(f'[IF] Take one or more arguments on line {first_token_line.position} !')
+
                 if_node = IfNode(condition=tokens_by_line[1:],
                                  body=[])  # on crée la node avec les arguments de condition du if
                 last_block.body.append(if_node)
@@ -81,6 +87,8 @@ 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] No conditional bloc open on line {first_token_line.position} !')
+                if len(tokens_by_line) <= 1:
+                    raise SyntaxError(f'[ELIF] Take one or more arguments 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)
 
@@ -91,7 +99,6 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
                         last_block.elif_nodes = [elif_node]
                     else:
                         last_block.elif_nodes.append(elif_node)
-
                 blocks.append(elif_node)
 
             elif first_token_line.value == 'else':
@@ -102,7 +109,6 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
                     raise SyntaxError(f'[ELSE] already define !')
 
                 else_node = ElseNode(body=[])
-
                 if isinstance(last_block, ElifNode):  # si le dernier bloc est un elif
                     last_block.parent.else_body = else_node  # on ajoute le bloc else à son parent (qui est le dernier if)
                 else:
@@ -110,6 +116,15 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
                 blocks.append(else_node)
 
             elif first_token_line.value == 'loop':
+                if len(tokens_by_line) <= 2:
+                    raise SyntaxError(f'[LOOP] Take two arguments on line {first_token_line.position} !')
+                if tokens_by_line[1].type != DTT.IDENT:
+                    raise TypeError(f'[LOOP] the variable given must be a ident, '
+                                    f'not {tokens_by_line[1].type} in line {tokens_by_line[1].position}')
+                if tokens_by_line[2].type not in (DTT.IDENT, DTT.STR, DTT.INT, DTT.FLOAT, DTT.LIST):
+                    raise TypeError(f'[LOOP] the iterator must be a ident, string, integer, float or list, '
+                                    f'not {tokens_by_line[2].type} in line {tokens_by_line[2].position}')
+
                 loop_node = LoopNode(VarNode(tokens_by_line[1], to_postfix(tokens_by_line[2:])), body=[])
                 last_block.body.append(loop_node)
                 _, p = parse(token_lines[pointeur + 1:],
@@ -119,11 +134,18 @@ 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] No loop open on line {first_token_line.position} !')
+
                 blocks.pop()
                 return blocks, pointeur  # on renvoie les informations parsé à la dernière loop ouverte
 
             elif first_token_line.value == 'var':
-                var_node = VarNode(name=token_lines[pointeur][1], body=[])
+                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:
+                    raise TypeError(f'[VAR] the variable given must be a ident, '
+                                    f'not {tokens_by_line[1].type} in line {tokens_by_line[1].position}')
+
+                var_node = VarNode(name=tokens_by_line[1], body=[])
                 last_block.body.append(var_node)
                 result, status = parser_inline(tokens_by_line[
                                                2:])  # on fait en sorte de mettre les tokens de la ligne séparé par des retour à la ligne à chaque condition/else
@@ -134,10 +156,22 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
                     var_node.body = result[0]
 
             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:
+                    raise TypeError(f'[SLEEP] the variable given must be an integer, '
+                                    f'not {tokens_by_line[1].type} in line {tokens_by_line[1].position}')
+
                 sleep_node = SleepNode(tokens_by_line[1:])
                 last_block.body.append(sleep_node)
 
             elif first_token_line.value == 'param':
+                if len(tokens_by_line) <= 1:
+                    raise SyntaxError(f'[PARAM] Take one arguments on line {first_token_line.position} !')
+                if tokens_by_line[1].type != DTT.IDENT:
+                    raise TypeError(f'[PARAM] the variable given must be a ident, '
+                                    f'not {tokens_by_line[1].type} in line {tokens_by_line[1].position}')
+
                 param_node = ParamNode(body=[])
                 last_block.body.append(param_node)
                 _, p = parse(token_lines[pointeur + 1:], param_node)
@@ -146,6 +180,7 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
             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
 
@@ -153,11 +188,26 @@ 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) != 2:
+                    raise SyntaxError(f"[LENGTH] Take 2 arguments on line {first_token_line.position} !")
+                if first_token_line.type not in (DTT.IDENT, DTT.STR, DTT.LIST):
+                    raise SyntaxError(f"[LENGTH] Take an ident, str or list on line {first_token_line.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:
 
             if first_token_line.value == 'embed':
+                if len(tokens_by_line) <= 1:
+                    raise SyntaxError(f'[EMBED] Take one or more arguments on line {first_token_line.position} !')
+                if tokens_by_line[1].type != DTT.IDENT:
+                    raise TypeError(f'[EMBED] the variable given must be a ident, '
+                                    f'not {tokens_by_line[1].type} in line {tokens_by_line[1].position}')
+
                 embed_node = EmbedNode(body=[], fields=[])
                 var_node = VarNode(tokens_by_line[1], body=[embed_node])
                 last_block.body.append(var_node)
@@ -171,11 +221,20 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
                 return blocks, pointeur
 
             elif first_token_line.value == 'field':
+                if len(tokens_by_line) <= 1:
+                    raise SyntaxError(f'[FIELD] Take one or more arguments on line {first_token_line.position} !')
                 if not isinstance(last_block, EmbedNode):
                     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'):
+                if len(tokens_by_line) <= 1:
+                    raise SyntaxError(f'[PERM] Take one argument on line {first_token_line.position} !')
+                if tokens_by_line[1].type != DTT.IDENT:
+                    raise TypeError(f'[PERM] the variable given must be a ident, '
+                                    f'not {tokens_by_line[1].type} in line {tokens_by_line[1].position}')
+
                 perm_node = PermissionNode(body=[])
                 var_node = VarNode(tokens_by_line[1], body=[perm_node])
                 last_block.body.append(var_node)
@@ -189,6 +248,12 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
                 return blocks, pointeur
 
             elif first_token_line.value == 'ui':
+                if len(tokens_by_line) <= 1:
+                    raise SyntaxError(f'[UI] Take one argument on line {first_token_line.position} !')
+                if tokens_by_line[1].type != DTT.IDENT:
+                    raise TypeError(f'[UI] the variable given must be a ident, '
+                                    f'not {tokens_by_line[1].type} in line {tokens_by_line[1].position}')
+
                 ui_node = UiNode([])
                 var_node = VarNode(tokens_by_line[1], body=[ui_node])
                 last_block.body.append(var_node)
@@ -202,12 +267,17 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
                 return blocks, pointeur
 
             elif first_token_line.value == 'button':
+                if len(tokens_by_line) <= 1:
+                    raise SyntaxError(f'[BUTTON] Take one or more arguments on line {first_token_line.position} !')
                 if not isinstance(last_block, UiNode):
                     raise SyntaxError(f'[BUTTON] No UI open on line {first_token_line.position} !')
+
                 button_node = UiButtonNode(tokens_by_line[1:])
                 last_block.buttons.append(button_node)
 
             elif first_token_line.value == 'select':
+                if len(tokens_by_line) <= 1:
+                    raise SyntaxError(f'[SELECT] Take one or more arguments on line {first_token_line.position} !')
                 if not isinstance(last_block, UiNode):
                     raise SyntaxError(f'[SELECT] No UI open on line {first_token_line.position} !')
                 select_node = UiSelectNode(tokens_by_line[1:])

{dshellinterpreter-0.2.13.15 → dshellinterpreter-0.2.13.17}/Dshell/_DshellTokenizer/dshell_keywords.py

@@ -18,7 +18,7 @@ from ..DISCORD_COMMANDS.dshell_role import *
 from ..DISCORD_COMMANDS.dshell_interaction import *
 
 dshell_keyword: set[str] = {
-    'if', 'else', 'elif', 'loop', '#end', 'var', '#loop', '#if', 'sleep', 'param', '#param'
+    'if', 'else', 'elif', 'loop', '#end', 'var', '#loop', '#if', 'sleep', 'param', '#param', 'length', 'len'
 }
 
 dshell_discord_keyword: set[str] = {
@@ -36,7 +36,7 @@ dshell_commands: dict[str, Callable] = {
     "em": dshell_edit_message,  # edit message
 
     "sri": dshell_respond_interaction,  # respond to an interaction
-    "di": dshell_defer_interaction,  # defer an interaction
+    "sdi": dshell_defer_interaction,  # defer an interaction
 
     "cc": dshell_create_text_channel,  # create channel
     "cvc": dshell_create_voice_channel,  # create voice channel

{dshellinterpreter-0.2.13.15/dshellInterpreter.egg-info → dshellinterpreter-0.2.13.17}/PKG-INFO

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

{dshellinterpreter-0.2.13.15 → dshellinterpreter-0.2.13.17/dshellInterpreter.egg-info}/PKG-INFO

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

{dshellinterpreter-0.2.13.15 → dshellinterpreter-0.2.13.17}/setup.py

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