dshellInterpreter 0.2.13.14__tar.gz → 0.2.13.16__tar.gz

{dshellinterpreter-0.2.13.14 → dshellinterpreter-0.2.13.16}/Dshell/DISCORD_COMMANDS/dshell_interaction.py

@@ -4,11 +4,22 @@ __all__ = [
 ]
 
 from types import NoneType
-from discord import Interaction, Embed
+from discord import Interaction, Embed, AllowedMentions
 from pycordViews import EasyModifiedViews
 
-
-async def dshell_respond_interaction(ctx: Interaction, content: str = None, delete=None, mentions: bool = None, hide: bool = False, embeds=None, view=None) -> int:
+from .utils.utils_message import utils_autorised_mentions
+
+async def dshell_respond_interaction(ctx: Interaction,
+                                     content: str = None,
+                                     delete=None,
+                                     global_mentions: bool = None,
+                                     everyone_mention: bool = True,
+                                     roles_mentions: bool = True,
+                                     users_mentions: bool = True,
+                                     reply_mention: bool = False,
+                                     hide: bool = False,
+                                     embeds=None,
+                                     view=None) -> int:
     """
     Responds to a message interaction on Discord
     """
@@ -19,13 +30,14 @@ async def dshell_respond_interaction(ctx: Interaction, content: str = None, dele
     if delete is not None and not isinstance(delete, (int, float)):
         raise Exception(f'Delete parameter must be a number (seconds) or None, not {type(delete)} !')
 
-    if not isinstance(mentions, (NoneType, bool)):
-        raise Exception(f'Mention parameter must be a boolean or None, not {type(mentions)} !')
-
     if not isinstance(hide, bool):
         raise Exception(f'Hide parameter must be a boolean, not {type(hide)} !')
 
-    allowed_mentions = mentions if mentions is not None else False
+    allowed_mentions = utils_autorised_mentions(global_mentions,
+                                                everyone_mention,
+                                                roles_mentions,
+                                                users_mentions,
+                                                reply_mention)
 
     from .._DshellParser.ast_nodes import ListNode
 

{dshellinterpreter-0.2.13.14 → dshellinterpreter-0.2.13.16}/Dshell/DISCORD_COMMANDS/dshell_message.py

@@ -1,12 +1,11 @@
 from re import search
-from tkinter import Listbox
 
-from discord import Embed, Message, Interaction
+from discord import Embed, Message
 from discord.ext import commands
 
 from pycordViews import EasyModifiedViews
 
-from .utils.utils_message import utils_get_message
+from .utils.utils_message import utils_get_message, utils_autorised_mentions
 from .._utils import NoneType
 
 __all__ = [
@@ -24,7 +23,17 @@ __all__ = [
 ]
 
 
-async def dshell_send_message(ctx: Message, message=None, delete=None, channel=None, embeds=None, view=None) -> int:
+async def dshell_send_message(ctx: Message,
+                              message=None,
+                              delete=None,
+                              channel=None,
+                              global_mentions: bool = None,
+                              everyone_mention: bool = True,
+                              roles_mentions: bool = True,
+                              users_mentions: bool = True,
+                              reply_mention: bool = False,
+                              embeds=None,
+                              view=None) -> int:
     """
     Sends a message on Discord
     """
@@ -33,6 +42,7 @@ async def dshell_send_message(ctx: Message, message=None, delete=None, channel=N
         raise Exception(f'Delete parameter must be a number (seconds) or None, not {type(delete)} !')
 
     channel_to_send = ctx.channel if channel is None else ctx.channel.guild.get_channel(channel)
+    allowed_mentions = utils_autorised_mentions(global_mentions, everyone_mention, roles_mentions, users_mentions, reply_mention)
 
     if channel_to_send is None:
         raise Exception(f'Channel {channel} not found!')
@@ -54,12 +64,22 @@ async def dshell_send_message(ctx: Message, message=None, delete=None, channel=N
     sended_message = await channel_to_send.send(message,
                                                 delete_after=delete,
                                                 embeds=embeds,
+                                                allowed_mentions=allowed_mentions,
                                                 view=view)
 
     return sended_message.id
 
 
-async def dshell_respond_message(ctx: Message, message=None, content: str = None, delete=None, mention: bool = None, embeds=None):
+async def dshell_respond_message(ctx: Message,
+                                 message=None,
+                                 content: str = None,
+                                 global_mentions: bool = None,
+                                 everyone_mention: bool = True,
+                                 roles_mentions: bool = True,
+                                 users_mentions: bool = True,
+                                 reply_mention: bool = False,
+                                 delete=None,
+                                 embeds=None):
     """
     Responds to a message on Discord
     """
@@ -67,7 +87,8 @@ async def dshell_respond_message(ctx: Message, message=None, content: str = None
         raise Exception(f'Delete parameter must be a number (seconds) or None, not {type(delete)} !')
 
     respond_message = ctx if message is None else utils_get_message(ctx, message)  # builds a reference to the message (even if it doesn't exist)
-    mention_author = mention if mention is not None else False
+    autorised_mentions = utils_autorised_mentions(global_mentions, everyone_mention, roles_mentions, users_mentions, reply_mention)
+    mention_author = True if reply_mention else False
 
     from .._DshellParser.ast_nodes import ListNode
 
@@ -83,6 +104,7 @@ async def dshell_respond_message(ctx: Message, message=None, content: str = None
     sended_message = await respond_message.reply(
                                      content=str(content),
                                      mention_author=mention_author,
+                                     allowed_mentions=autorised_mentions,
                                      delete_after=delete,
                                      embeds=embeds)
 

{dshellinterpreter-0.2.13.14 → dshellinterpreter-0.2.13.16}/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.16/Dshell/DISCORD_COMMANDS/utils/utils_message.py

@@ -0,0 +1,68 @@
+from discord import Message, PartialMessage, AllowedMentions
+from typing import Union
+from re import search
+
+def utils_get_message(ctx: Message, message: Union[int, str]) -> PartialMessage:
+    """
+    Returns the message object of the specified message ID or link.
+    Message is only available in the same server as the command and in the same channel.
+    If the message is a link, it must be in the format: https://discord.com/channels/{guild_id}/{channel_id}/{message_id}
+    """
+
+    if isinstance(message, int):
+        return ctx.channel.get_partial_message(message)
+
+    elif isinstance(message, str):
+        match = search(r'https://discord\.com/channels/(\d+)/(\d+)/(\d+)', message)
+        if not match:
+            raise Exception("Invalid message link format. Use a valid Discord message link.")
+        guild_id = int(match.group(1))
+        channel_id = int(match.group(2))
+        message_id = int(match.group(3))
+
+        if guild_id != ctx.guild.id:
+            raise Exception("The message must be from the same server as the command !")
+
+        return ctx.guild.get_channel(channel_id).get_partial_message(message_id)
+
+    raise Exception(f"Message must be an integer or a string, not {type(message)} !")
+
+
+def utils_autorised_mentions(global_mentions: bool = None,
+                            everyone_mention: bool = True,
+                            roles_mentions: bool = True,
+                            users_mentions: bool = True,
+                            reply_mention: bool = False) -> Union[bool, 'AllowedMentions']:
+    """
+    Returns the AllowedMentions object based on the provided parameters.
+    If global_mentions is set to True or False, it overrides all other parameters.
+    """
+
+    from discord import AllowedMentions
+
+    if not isinstance(global_mentions, (type(None), bool)):
+        raise Exception(f'Mention parameter must be a boolean or None, not {type(global_mentions)} !')
+
+    if not isinstance(everyone_mention, bool):
+        raise Exception(f'Everyone mention parameter must be a boolean, not {type(everyone_mention)} !')
+
+    if not isinstance(roles_mentions, bool):
+        raise Exception(f'Roles mention parameter must be a boolean, not {type(roles_mentions)} !')
+
+    if not isinstance(users_mentions, bool):
+        raise Exception(f'Users mention parameter must be a boolean, not {type(users_mentions)} !')
+
+    if not isinstance(reply_mention, bool):
+        raise Exception(f'Reply mention parameter must be a boolean, not {type(reply_mention)} !')
+
+    if global_mentions is True:
+        return AllowedMentions.all()
+
+    elif global_mentions is False:
+        return AllowedMentions.none()
+
+    else:
+        return AllowedMentions(everyone=everyone_mention,
+                               roles=roles_mentions,
+                               users=users_mentions,
+                               replied_user=reply_mention)

{dshellinterpreter-0.2.13.14 → dshellinterpreter-0.2.13.16}/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.14 → dshellinterpreter-0.2.13.16}/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.14 → dshellinterpreter-0.2.13.16}/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:
@@ -59,6 +60,8 @@ 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 +84,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)
 
@@ -110,6 +115,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:],
@@ -123,7 +137,12 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
                 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 +153,21 @@ 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)
@@ -153,6 +183,14 @@ 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:

{dshellinterpreter-0.2.13.14 → dshellinterpreter-0.2.13.16}/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.14/dshellInterpreter.egg-info → dshellinterpreter-0.2.13.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dshellInterpreter
-Version: 0.2.13.14
+Version: 0.2.13.16
 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.14 → dshellinterpreter-0.2.13.16/dshellInterpreter.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dshellInterpreter
-Version: 0.2.13.14
+Version: 0.2.13.16
 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.14 → dshellinterpreter-0.2.13.16}/setup.py

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

dshellinterpreter-0.2.13.14/Dshell/DISCORD_COMMANDS/utils/utils_message.py

@@ -1,28 +0,0 @@
-from discord import Message, PartialMessage
-from typing import Union
-from re import search
-
-def utils_get_message(ctx: Message, message: Union[int, str]) -> PartialMessage:
-    """
-    Returns the message object of the specified message ID or link.
-    Message is only available in the same server as the command and in the same channel.
-    If the message is a link, it must be in the format: https://discord.com/channels/{guild_id}/{channel_id}/{message_id}
-    """
-
-    if isinstance(message, int):
-        return ctx.channel.get_partial_message(message)
-
-    elif isinstance(message, str):
-        match = search(r'https://discord\.com/channels/(\d+)/(\d+)/(\d+)', message)
-        if not match:
-            raise Exception("Invalid message link format. Use a valid Discord message link.")
-        guild_id = int(match.group(1))
-        channel_id = int(match.group(2))
-        message_id = int(match.group(3))
-
-        if guild_id != ctx.guild.id:
-            raise Exception("The message must be from the same server as the command !")
-
-        return ctx.guild.get_channel(channel_id).get_partial_message(message_id)
-
-    raise Exception(f"Message must be an integer or a string, not {type(message)} !")