dshellInterpreter 0.1.9__py3-none-any.whl → 0.1.11__py3-none-any.whl

Dshell/DISCORD_COMMANDS/__init__.py

@@ -1,2 +1,3 @@
 from .dshell_channel import *
 from .dshell_message import *
+from .dshell_member import *

Dshell/DISCORD_COMMANDS/dshell_channel.py

@@ -8,15 +8,21 @@ from discord.abc import GuildChannel
 __all__ = [
     'dshell_create_text_channel',
     'dshell_delete_channel',
-    'dshell_delete_channels'
+    'dshell_delete_channels',
+    'dshell_create_voice_channel'
 ]
 
 
-async def dshell_create_text_channel(ctx: GuildChannel, name, category=None, position=MISSING, slowmode=MISSING,
+async def dshell_create_text_channel(ctx: GuildChannel,
+                                     name,
+                                     category=None,
+                                     position=MISSING,
+                                     slowmode=MISSING,
                                      topic=MISSING, nsfw=MISSING,
-                                     permission: dict[Union[Member, Role], PermissionOverwrite] = MISSING):
+                                     permission: dict[Union[Member, Role], PermissionOverwrite] = MISSING,
+                                     reason=None):
     """
-    Crée un salon textuel sur le serveur
+    Creates a text channel on the server
     """
 
     channel_category = ctx.guild.get_channel(category)
@@ -27,15 +33,38 @@ async def dshell_create_text_channel(ctx: GuildChannel, name, category=None, pos
                                                           slowmode_delay=slowmode,
                                                           topic=topic,
                                                           nsfw=nsfw,
-                                                          overwrites=permission)
+                                                          overwrites=permission,
+                                                          reason=reason)
+
+    return created_channel.id
+
+async def dshell_create_voice_channel(ctx: GuildChannel,
+                                      name,
+                                      category=None,
+                                      position=MISSING,
+                                      bitrate=MISSING,
+                                      permission: dict[Union[Member, Role], PermissionOverwrite] = MISSING,
+                                      reason=None):
+    """
+    Creates a voice channel on the server
+    """
+
+    channel_category = ctx.guild.get_channel(category)
+
+    created_channel = await ctx.guild.create_voice_channel(name,
+                                                           category=channel_category,
+                                                           position=position,
+                                                           bitrate=bitrate,
+                                                           overwrites=permission,
+                                                           reason=reason)
 
     return created_channel.id
 
 
 async def dshell_delete_channel(ctx: GuildChannel, channel=None, reason=None, timeout=0):
     """
-    Supprime un salon.
-    Possibilité de lui rajouter un temps d'attente avant qu'il ne le supprime (en seconde)
+    Deletes a channel.
+    You can add a waiting time before it is deleted (in seconds)
     """
 
     channel_to_delete = ctx if channel is None else ctx.guild.get_channel(channel)
@@ -52,8 +81,8 @@ async def dshell_delete_channel(ctx: GuildChannel, channel=None, reason=None, ti
 
 async def dshell_delete_channels(ctx: GuildChannel, name=None, regex=None, reason=None):
     """
-    Supprime tous les salons ayant le même nom et/ou le même regex.
-    Si aucun des deux n'est mis, il supprimera tous les salons comportant le même nom que celui ou a été fait la commande
+    Deletes all channels with the same name and/or matching the same regex.
+    If neither is set, it will delete all channels with the same name as the one where the command was executed.
     """
     for channel in ctx.guild.channels:
 

Dshell/DISCORD_COMMANDS/dshell_member.py

@@ -0,0 +1,54 @@
+from discord import Member, User, MISSING
+from discord.abc import GuildChannel
+
+
+__all__ = [
+    "dshell_ban_member",
+    "dshell_unban_member",
+    "dshell_kick_member"
+]
+
+async def dshell_ban_member(ctx: GuildChannel, member: int, reason: str = MISSING):
+    """
+    Bans a member from the server.
+    """
+    banned_member = ctx.guild.get_member(member)
+
+    if not banned_member:
+        return 1 # Member not found in the server
+
+    await ctx.guild.ban(banned_member, reason=reason)
+
+    return banned_member.id
+
+async def dshell_unban_member(ctx: GuildChannel, user: int, reason: str = MISSING):
+    """
+    Unbans a user from the server.
+    """
+    banned_users = ctx.guild.bans()
+    user_to_unban = None
+
+    async for ban_entry in banned_users:
+        if ban_entry.user.id == user:
+            user_to_unban = ban_entry.user
+            break
+
+    if not user_to_unban:
+        return 1  # User not found in the banned list
+
+    await ctx.guild.unban(user_to_unban, reason=reason)
+
+    return user_to_unban.id
+
+async def dshell_kick_member(ctx: GuildChannel, member: int, reason: str = MISSING):
+    """
+    Kicks a member from the server.
+    """
+    kicked_member = ctx.guild.get_member(member)
+
+    if not kicked_member:
+        return 1  # Member not found in the server
+
+    await ctx.guild.kick(kicked_member, reason=reason)
+
+    return kicked_member.id

Dshell/DISCORD_COMMANDS/dshell_message.py

@@ -11,12 +11,12 @@ __all__ = [
 async def dshell_send_message(ctx: GuildChannel, message=None, delete=None, channel=None, embeds=None, embed=None):
     from .._DshellParser.ast_nodes import ListNode
     """
-    Envoie un message sur Discord
+    Sends a message on Discord
     """
     channel_to_send = ctx if channel is None else ctx.guild.get_channel(channel)
 
     if channel_to_send is None:
-        raise Exception(f'Le channel {channel} est introuvable !')
+        raise Exception(f'Channel {channel} not found!')
 
     if embeds is None:
         embeds = ListNode([])
@@ -36,25 +36,25 @@ async def dshell_send_message(ctx: GuildChannel, message=None, delete=None, chan
 
 async def dshell_delete_message(ctx: GuildChannel, message, reason=None, delay=0):
     """
-    Supprime un message
+    Deletes a message
     """
 
-    delete_message = ctx.get_partial_message(message)  # construit une référence au message (même s'il n'existe pas)
+    delete_message = ctx.get_partial_message(message)  # builds a reference to the message (even if it doesn't exist)
 
     if delay > 3600:
-        raise Exception(f'Le délait de suppression du message est trop grand ! ({delay} secondes)')
+        raise Exception(f'The message deletion delay is too long! ({delay} seconds)')
 
     await delete_message.delete(delay=delay, reason=reason)
 
 
 async def dshell_purge_message(ctx: GuildChannel, message_number, channel=None, reason=None):
     """
-    Purge les messages d'un salon
+    Purges messages from a channel
     """
 
     purge_channel = ctx if channel is None else ctx.guild.get_channel(channel)
 
     if purge_channel is None:
-        raise Exception(f"Le salon {channel} à purgé est introuvable !")
+        raise Exception(f"Channel {channel} to purge not found!")
 
     await purge_channel.purge(limit=message_number, reason=reason)

Dshell/_DshellInterpreteur/dshell_interpreter.py

@@ -2,6 +2,7 @@ from asyncio import sleep
 from re import findall
 from typing import TypeVar, Union, Any, Optional, Callable
 
+
 from discord import AutoShardedBot, Embed, Colour, PermissionOverwrite, Permissions, Guild, Member, Role
 from discord.abc import GuildChannel, PrivateChannel
 
@@ -18,12 +19,17 @@ context = TypeVar('context', AutoShardedBot, GuildChannel, PrivateChannel)
 
 
 class DshellInterpreteur:
+    """
+    Discord Dshell interpreter.
+    Make what you want with Dshell code to interact with Discord !
+    """
 
-    def __init__(self, ast_or_code: Union[list[All_nodes], str], ctx: context, debug: bool = False):
+    def __init__(self, code: str, ctx: context, debug: bool = False):
         """
-        Interpreter Dshell code or AST.
+        Interpreter Dshell code
+        :param code: The code to interpret. Each line must end with a newline character, except SEPARATOR and SUB_SEPARATOR tokens.
         """
-        self.ast: list[ASTNode] = parse(DshellTokenizer(ast_or_code).start(), StartNode([]))[0]
+        self.ast: list[ASTNode] = parse(DshellTokenizer(code).start(), StartNode([]))[0]
         self.env: dict[str, Any] = {}
         self.ctx: context = ctx
         if debug:
@@ -31,7 +37,16 @@ class DshellInterpreteur:
 
     async def execute(self, ast: Optional[list[All_nodes]] = None):
         """
-        Execute l'arbre syntaxique.
+        Executes the abstract syntax tree (AST) generated from the Dshell code.
+
+        This asynchronous method traverses and interprets each node in the AST, executing commands,
+        handling control flow structures (such as if, elif, else, and loops), managing variables,
+        and interacting with Discord through the provided context. It supports command execution,
+        variable assignment, sleep operations, and permission handling, among other features.
+
+        :param ast: Optional list of AST nodes to execute. If None, uses the interpreter's main AST.
+        :raises RuntimeError: If an EndNode is encountered, indicating execution should be stopped.
+        :raises Exception: If sleep duration is out of allowed bounds.
         """
         if ast is None:
             ast = self.ast
@@ -90,19 +105,20 @@ class DshellInterpreteur:
             elif isinstance(node, SleepNode):
                 sleep_time = eval_expression(node.body, self)
                 if sleep_time > 3600:
-                    raise Exception(f'Le temps maximal de sommeil est de 3600 secondes !')
+                    raise Exception(f"Sleep time is too long! ({sleep_time} seconds) - maximum is 3600 seconds)")
                 elif sleep_time < 1:
-                    raise Exception(f'Le temps minimal de sommeil est de 1 seconde !')
+                    raise Exception(f"Sleep time is too short! ({sleep_time} seconds) - minimum is 1 second)")
 
                 await sleep(sleep_time)
 
 
             elif isinstance(node, EndNode):
-                raise RuntimeError(f"Execution interromput -> #end atteint")
+                raise RuntimeError("Execution stopped - EndNode encountered")
 
     def eval_data_token(self, token: Token):
         """
-        Evalue les tokens de data
+        Eval a data token and returns its value in Python.
+        :param token: The token to evaluate.
         """
 
         if not hasattr(token, 'type'):
@@ -135,7 +151,9 @@ class DshellInterpreteur:
 
 def eval_expression_inline(if_node: IfNode, interpreter: DshellInterpreteur) -> Token:
     """
-    Evalue une expression en ligne des variables
+    Eval a conditional expression inline.
+    :param if_node: The IfNode to evaluate.
+    :param interpreter: The Dshell interpreter instance.
     """
     if eval_expression(if_node.condition, interpreter):
         return eval_expression(if_node.body, interpreter)
@@ -145,7 +163,9 @@ def eval_expression_inline(if_node: IfNode, interpreter: DshellInterpreteur) ->
 
 def eval_expression(tokens: list[Token], interpreter: DshellInterpreteur) -> Any:
     """
-    Evalue une expressions arithmétique et logique et renvoie son résultat. Cela peut-être un booléen, un entier, un flottant, une chaîne de caractère ou une liste
+    Evaluates an arithmetic and logical expression.
+    :param tokens: A list of tokens representing the expression.
+    :param interpreter: The Dshell interpreter instance.
     """
     postfix = to_postfix(tokens)
     stack = []
@@ -170,24 +190,28 @@ def eval_expression(tokens: list[Token], interpreter: DshellInterpreteur) -> Any
             stack.append(result)
 
         else:
-            raise SyntaxError(f"Token inattendu en condition: {token}")
+            raise SyntaxError(f"Unexpected token type: {token.type} - {token.value}")
 
     if len(stack) != 1:
-        raise SyntaxError("Condition mal formée")
+        raise SyntaxError("Invalid expression: stack should contain exactly one element after evaluation.")
 
     return stack[0]
 
 
 async def call_function(function: Callable, args: ArgsCommandNode, interpreter: DshellInterpreteur):
     """
-    Appelle une fonction avec évaluation des arguments Dshell en valeurs Python
+    Call the function with the given arguments.
+    It can be an async function !
+    :param function: The function to call.
+    :param args: The arguments to pass to the function.
+    :param interpreter: The Dshell interpreter instance.
     """
     reformatted = regroupe_commandes(args.body, interpreter)[0]
 
     # conversion des args en valeurs Python
     absolute_args = reformatted.pop('*', list())
 
-    reformatted: dict[str, Token]  # ne sert à rien, juste à indiquer ce qu'il contient dorénanvant
+    reformatted: dict[str, Token]
 
     absolute_args.insert(0, interpreter.ctx)
     keyword_args = {
@@ -198,64 +222,69 @@ async def call_function(function: Callable, args: ArgsCommandNode, interpreter:
 
 def regroupe_commandes(body: list[Token], interpreter: DshellInterpreteur) -> list[dict[str, list[Any]]]:
     """
-    Regroupe les arguments de la commande sous la forme d'un dictionnaire python.
-    Sachant que l'on peut spécifier le paramètre que l'on souhaite passer via -- suivit du nom du paramètre. Mais ce n'est pas obligatoire !
-    Les paramètres non obligatoire seront stocké dans une liste sous la forme de tokens avec comme clé '*'.
-    Les autres ayant été spécifié via un séparateur, ils seront sous la forme d'une liste de tokens avec comme clé le token IDENT qui suivra le séparateur pour chaque argument.
+    Groups the command arguments in the form of a python dictionary.
+    Note that you can specify the parameter you wish to pass via -- followed by the parameter name. But this is not mandatory!
+    Non-mandatory parameters will be stored in a list in the form of tokens with the key ‘*’.
+    The others, having been specified via a separator, will be in the form of a list of tokens with the IDENT token as key, following the separator for each argument.
+    If two parameters have the same name, the last one will overwrite the previous one.
+    To accept duplicates, use the SUB_SEPARATOR (~~) to create a sub-dictionary for parameters with the same name.
+
+    :param body: The list of tokens to group.
+    :param interpreter: The Dshell interpreter instance.
     """
-    tokens = {'*': []}  # les tokens à renvoyer
-    current_arg = '*'  # les clés des arguments sont les types auquels ils appartiennent. L'* sert à tous les arguments non explicité par un séparateur et un IDENT
+    tokens = {'*': []}  # tokens to return
+    current_arg = '*'  # the argument keys are the types they belong to. '*' is for all arguments not explicitly specified by a separator and an IDENT
     n = len(body)
     list_tokens: list[dict] = [tokens]
 
     i = 0
     while i < n:
         if body[i].type == DTT.SEPARATOR and body[
-            i + 1].type == DTT.IDENT:  # On regarde si c'est un séparateur et si le token suivant est un IDENT
-            current_arg = body[i + 1].value  # on change l'argument actuel. Il sera donc impossible de revenir à l'*
-            tokens[current_arg] = ''  # on lui crée une paire clé/valeur
-            i += 2  # on skip l'IDENT qu'il y a après le séparateur car on vient de le traiter
+            i + 1].type == DTT.IDENT:  # Check if it's a separator and if the next token is an IDENT
+            current_arg = body[i + 1].value  # change the current argument. It will be impossible to return to '*'
+            tokens[current_arg] = ''  # create a key/value pair for it
+            i += 2  # skip the IDENT after the separator since it has just been processed
 
         elif body[
-            i].type == DTT.SUB_SEPARATOR:  # permet de délimiter les paramètres et de pouvoir en mettre plusieurs ayant le même nom
+            i].type == DTT.SUB_SEPARATOR:  # allows to delimit parameters and to have several with the same name
             list_tokens += regroupe_commandes(
                 [Token(
                     type_=DTT.SEPARATOR, value=body[i].value, position=body[i].position)
                 ] + body[i + 1:], interpreter
-            )  # on ajoute un sous-dictionnaire pour les sous-commandes
+            )  # add a sub-dictionary for sub-commands
             return list_tokens
 
         else:
             if current_arg == '*':
                 tokens[current_arg].append(interpreter.eval_data_token(body[i]))
             else:
-                tokens[current_arg] = interpreter.eval_data_token(body[i])  # on ajoute le token à l'argument actuel
+                tokens[current_arg] = interpreter.eval_data_token(body[i])  # add the token to the current argument
             i += 1
     return list_tokens
 
 
 def build_embed(body: list[Token], fields: list[FieldEmbedNode], interpreter: DshellInterpreteur) -> Embed:
     """
-    Construit un embed à partir des informations de la commande.
+    Builds an embed from the command information.
     """
     args_main_embed: dict[str, list[Any]] = regroupe_commandes(body, interpreter)[0]
-    args_main_embed.pop('*')  # on enlève les paramètres non spécifié pour l'embed
-    args_main_embed: dict[str, Token]  # on précise se qu'il contient dorénavant
+    args_main_embed.pop('*')  # remove unspecified parameters for the embed
+    args_main_embed: dict[str, Token]  # specify what it contains from now on
 
     args_fields: list[dict[str, Token]] = []
-    for field in fields:  # on fait la même chose pour tous les fields
+    for field in fields:  # do the same for the fields
         a = regroupe_commandes(field.body, interpreter)[0]
         a.pop('*')
         a: dict[str, Token]
         args_fields.append(a)
 
     if 'color' in args_main_embed and isinstance(args_main_embed['color'],
-                                                 ListNode):  # si on passe l'argument de la couleur sous la forme d'une liste RGB
+                                                 ListNode):  # if color is a ListNode, convert it to Colour
         args_main_embed['color'] = Colour.from_rgb(*args_main_embed['color'])
 
-    embed = Embed(**args_main_embed)  # on construit l'embed principal
+    embed = Embed(**args_main_embed)  # build the main embed
     for field in args_fields:
-        embed.add_field(**field)  # on joute tous les fields
+        embed.add_field(**field)  # add all fields
 
     return embed
 
@@ -263,7 +292,7 @@ def build_embed(body: list[Token], fields: list[FieldEmbedNode], interpreter: Ds
 def build_permission(body: list[Token], interpreter: DshellInterpreteur) -> dict[
     Union[Member, Role], PermissionOverwrite]:
     """
-    Construit un dictionnaire de permissions à partir des informations de la commande.
+    Builds a dictionary of PermissionOverwrite objects from the command information.
     """
     args_permissions: list[dict[str, list[Any]]] = regroupe_commandes(body, interpreter)
     permissions: dict[Union[Member, Role], PermissionOverwrite] = {}
@@ -272,12 +301,12 @@ def build_permission(body: list[Token], interpreter: DshellInterpreteur) -> dict
         i.pop('*')
         permissions.update(DshellPermissions(i).get_permission_overwrite(interpreter.ctx.guild))
 
-    print(args_permissions)
+    return permissions
 
 
 class DshellIterator:
     """
-    Utilisé pour transformer n'importe quoi en un iterable
+    Used to transform anything into an iterable
     """
 
     def __init__(self, data):
@@ -301,20 +330,20 @@ class DshellPermissions:
 
     def __init__(self, target: dict[str, list[int]]):
         """
-        Permet de créer un objet de permissions Dshell.
-        :param target: Un dictionnaire contenant les paramètres et leurs valeurs.
-        Paramètres attendus : "allow", "deny", "members", "roles".
-        Pour "members" et "roles", les valeurs doivent être des ListNode d'IDs.
+        Creates a Dshell permissions object.
+        :param target: A dictionary containing parameters and their values.
+        Expected parameters: “allow”, “deny”, ‘members’, “roles”.
+        For “members” and “roles”, values must be ID ListNodes.
         """
         self.target: dict[str, Union[ListNode, int]] = target
 
     @staticmethod
     def get_instance(guild: Guild, target_id: int) -> Union[Member, Role]:
         """
-        Retourne l'instance correspondante à l'id donné. Uniquement un Member ou un Role.
-        :param guild: Le serveur Discord dans lequel chercher
-        :param target_id: L'ID du membre ou du rôle
-        :return: Une instance de Member ou Role
+        Returns the instance corresponding to the given id. Only a Member or Role.
+        :param guild: The Discord server in which to search
+        :param target_id: The ID of the member or role
+        :return: An instance of Member or Role
         """
         try:
             member = DshellPermissions.get_member(guild, target_id)
@@ -332,48 +361,46 @@ class DshellPermissions:
         if role is not None:
             return role
 
-        raise ValueError(f"Aucun membre ou rôle trouvé avec l'ID {target_id} dans le serveur {guild.name}.")
-
     @staticmethod
     def get_member(guild: Guild, target_id: int) -> Member:
         """
-        Retourne l'instance de Member correspondante à l'id donné.
-        :param guild: Le serveur Discord dans lequel chercher
-        :param target_id: L'ID du membre
-        :return: Une instance de Member
+        Returns the Member instance corresponding to the given id.
+        :param guild: The Discord server to search
+        :param target_id: The member ID
+        :return: A Member instance
         """
         member = guild.get_member(target_id)
         if member is not None:
             return member
 
-        raise ValueError(f"Aucun membre trouvé avec l'ID {target_id} dans le serveur {guild.name}.")
+        raise ValueError(f"No member found with ID {target_id} in guild {guild.name}.")
 
     @staticmethod
     def get_role(guild: Guild, target_id: int) -> Role:
         """
-        Retourne l'instance de Role correspondante à l'id donné.
-        :param guild: Le serveur Discord dans lequel chercher
-        :param target_id: L'ID du rôle
-        :return: Une instance de Role
+        Returns the Role instance corresponding to the given id.
+        :param guild: The Discord server to search
+        :param target_id: The role ID
+        :return: A Role instance
         """
         role = guild.get_role(target_id)
         if role is not None:
             return role
 
-        raise ValueError(f"Aucun rôle trouvé avec l'ID {target_id} dans le serveur {guild.name}.")
+        raise ValueError(f"No role found with ID {target_id} in guild {guild.name}.")
 
     def get_permission_overwrite(self, guild: Guild) -> dict[Union[Member, Role], PermissionOverwrite]:
         """
-        Retourne un objet PermissionOverwrite avec les permissions des membres et rôles.
-        :param guild: Le serveur Discord
-        :return: Un objet PermissionOverwrite
+        Returns a PermissionOverwrite object with member and role permissions.
+        :param guild: The Discord server
+        :return: A dictionary of PermissionOverwrite objects with members and roles as keys
         """
         permissions: dict[Union[Member, Role], PermissionOverwrite] = {}
         target_keys = self.target.keys()
 
         if 'members' in target_keys:
             for member_id in (
-            self.target['members'] if isinstance(self.target['members'], ListNode) else [self.target['members']]): # accepte un seul ID
+            self.target['members'] if isinstance(self.target['members'], ListNode) else [self.target['members']]): # allow a single ID
                 member = self.get_member(guild, member_id)
                 permissions[member] = PermissionOverwrite.from_pair(
                     allow=Permissions(permissions=self.target.get('allow', 0)),
@@ -382,13 +409,13 @@ class DshellPermissions:
 
         elif 'roles' in target_keys:
             for role_id in (
-            self.target['roles'] if isinstance(self.target['roles'], ListNode) else [self.target['roles']]): ## accepte un seul ID
+            self.target['roles'] if isinstance(self.target['roles'], ListNode) else [self.target['roles']]): # allow a single ID
                 role = self.get_role(guild, role_id)
                 permissions[role] = PermissionOverwrite.from_pair(
                     allow=Permissions(permissions=self.target.get('allow', 0)),
                     deny=Permissions(permissions=self.target.get('deny', 0))
                 )
         else:
-            raise ValueError("Aucun membre ou rôle spécifié dans les permissions.")
+            raise ValueError("No members or roles specified in the permissions target.")
 
         return permissions

Dshell/_DshellParser/ast_nodes.py

@@ -23,10 +23,16 @@ __all__ = [
 
 
 class ASTNode:
+    """
+    Base class for all AST nodes.
+    """
     pass
 
 
 class StartNode(ASTNode):
+    """
+    Node representing the start of the AST.
+    """
     def __init__(self, body: list):
         self.body = body
 
@@ -35,7 +41,13 @@ class StartNode(ASTNode):
 
 
 class ElseNode(ASTNode):
+    """
+    Node representing the 'else' part of an if statement.
+    """
     def __init__(self, body: list[Token]):
+        """
+        :param body: list of tokens representing the body of the else statement
+        """
         self.body = body
 
     def __repr__(self):
@@ -43,7 +55,15 @@ class ElseNode(ASTNode):
 
 
 class ElifNode(ASTNode):
+    """
+    Node representing an 'elif' part of an if statement.
+    """
     def __init__(self, condition: list[Token], body: list[Token], parent: "IfNode"):
+        """
+        :param condition: list of tokens representing the condition for the elif
+        :param body: list of tokens representing the body of the elif
+        :param parent: the if node that this elif belongs to
+        """
         self.condition = condition
         self.body = body
         self.parent = parent
@@ -53,8 +73,17 @@ class ElifNode(ASTNode):
 
 
 class IfNode(ASTNode):
+    """
+    Node representing an 'if' statement, which can contain 'elif' and 'else' parts.
+    """
     def __init__(self, condition: list[Token], body: list[Token], elif_nodes: Optional[list[ElifNode]] = None,
                  else_body: Optional[ElseNode] = None):
+        """
+        :param condition: list of tokens representing the condition for the if statement
+        :param body: list of tokens representing the body of the if statement
+        :param elif_nodes: optional list of ElifNode instances representing 'elif' parts
+        :param else_body: optional ElseNode instance representing the 'else' part
+        """
         self.condition = condition
         self.body = body
         self.elif_nodes = elif_nodes
@@ -65,8 +94,15 @@ class IfNode(ASTNode):
 
 
 class LoopNode(ASTNode):
+    """
+    Node representing a loop structure in the AST.
+    """
     def __init__(self, variable: "VarNode", body: list):
-        self.variable = variable  # content l'itérable dans son body
+        """
+        :param variable: VarNode representing the loop variable. This variable will be used to iterate over the body. Can contain a ListNode, string or integer.
+        :param body: list of tokens representing the body of the loop
+        """
+        self.variable = variable
         self.body = body
 
     def __repr__(self):
@@ -74,7 +110,13 @@ class LoopNode(ASTNode):
 
 
 class ArgsCommandNode(ASTNode):
+    """
+    Node representing the arguments of a command in the AST.
+    """
     def __init__(self, body: list[Token]):
+        """
+        :param body: list of tokens representing the arguments of the command
+        """
         self.body: list[Token] = body
 
     def __repr__(self):
@@ -82,7 +124,14 @@ class ArgsCommandNode(ASTNode):
 
 
 class CommandNode(ASTNode):
+    """
+    Node representing a command in the AST.
+    """
     def __init__(self, name: str, body: ArgsCommandNode):
+        """
+        :param name: The command name (e.g., "sm", "cc")
+        :param body: ArgsCommandNode containing the arguments of the command
+        """
         self.name = name
         self.body = body
 
@@ -91,7 +140,14 @@ class CommandNode(ASTNode):
 
 
 class VarNode(ASTNode):
+    """
+    Node representing a variable declaration in the AST.
+    """
     def __init__(self, name: Token, body: list[Token]):
+        """
+        :param name: Token representing the variable name
+        :param body: list of tokens representing the body of the variable
+        """
         self.name = name
         self.body = body
 
@@ -100,6 +156,9 @@ class VarNode(ASTNode):
 
 
 class EndNode(ASTNode):
+    """
+    Node representing the end of the AST.
+    """
     def __init__(self):
         pass
 
@@ -108,7 +167,13 @@ class EndNode(ASTNode):
 
 
 class FieldEmbedNode(ASTNode):
+    """
+    Node representing a field in an embed structure.
+    """
     def __init__(self, body: list[Token]):
+        """
+        :param body: list of tokens representing the field content
+        """
         self.body: list[Token] = body
 
     def __repr__(self):
@@ -116,7 +181,14 @@ class FieldEmbedNode(ASTNode):
 
 
 class EmbedNode(ASTNode):
+    """
+    Node representing an embed structure in the AST.
+    """
     def __init__(self, body: list[Token], fields: list[FieldEmbedNode]):
+        """
+        :param body: list of tokens representing the embed content
+        :param fields: list of FieldEmbedNode instances representing the fields of the embed
+        """
         self.body = body
         self.fields = fields
 
@@ -125,7 +197,13 @@ class EmbedNode(ASTNode):
 
 
 class PermissionNode(ASTNode):
+    """
+    Node representing a permission structure in the AST.
+    """
     def __init__(self, body: list[Token]):
+        """
+        :param body: list of tokens representing the permission content
+        """
         self.body = body
 
     def __repr__(self):
@@ -133,7 +211,13 @@ class PermissionNode(ASTNode):
 
 
 class SleepNode(ASTNode):
+    """
+    Node representing a sleep command in the AST.
+    """
     def __init__(self, body: list[Token]):
+        """
+        :param body: list of tokens representing the sleep duration
+        """
         self.body = body
 
     def __repr__(self):
@@ -142,14 +226,20 @@ class SleepNode(ASTNode):
 
 class IdentOperationNode(ASTNode):
     """
-    Gère les opération sur les idendificateur (appel de fonctions)
-    Faire en sorte que l'appel de la fonction renvoie la class associé pour permettre les imbrications. Pas obligatoire en soit si elle renvoie quelque chose
+    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):
-        self.ident = ident  # content la "class"
-        self.function = function  # contient la méthode appelé
-        self.args = args  # contient une liste de tokens des arguments passé en paramètre
+        """
+        :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})"
@@ -157,33 +247,42 @@ class IdentOperationNode(ASTNode):
 
 class ListNode(ASTNode):
     """
-    Class iterable permettant de parcourir les listes créé à partir du code Dshell.
-    Cette class permet aussi d'intéragir avec la liste via des méthodes spécifique non built-in par python.
+    Node representing a list structure in the AST.
+    Iterable class for browsing lists created from Dshell code.
+    This class also lets you interact with the list via specific methods not built in by python.
     """
 
     def __init__(self, body: list[Any]):
+        """
+        :param body: list of elements to initialize the ListNode with
+        """
         self.iterable: list[Any] = body
         self.len_iterable: int = len(body)
         self.iterateur_count: int = 0
 
     def add(self, value: Any):
         """
-        Ajoute un token à la liste
+        Add a value to the list.
         """
         if self.len_iterable > 10000:
-            raise PermissionError('Une liste ne peut dépasser les 10.000 éléments !')
+            raise PermissionError('The list is too long, it must not exceed 10,000 elements !')
 
         self.iterable.append(value)
         self.len_iterable += 1
 
     def remove(self, value: Any, number: int = 1):
         """
-        Enlève un ou plusieurs token de la liste
+        Remove a value from the list.
         """
         if number < 1:
-            raise Exception(f"Le nombre d'élément à retirer doit-être égale ou supperieur à 1 !")
+            raise Exception(f"The number of elements to remove must be at least 1, not {number} !")
 
     def __add__(self, other: "ListNode"):
+        """
+        Add another ListNode to this one.
+        :param other: Another ListNode to add to this one.
+        :return: Instance of ListNode with combined elements.
+        """
         for i in other:
             self.add(i)
         return self
@@ -192,6 +291,10 @@ class ListNode(ASTNode):
         return self
 
     def __next__(self):
+        """
+        Iterate over the elements of the list.
+        :return: an element from the list.
+        """
 
         if self.iterateur_count >= self.len_iterable:
             self.iterateur_count = 0

Dshell/_DshellParser/dshell_parser.py

@@ -32,7 +32,9 @@ if TYPE_CHECKING:
 
 def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[ASTNode], int]:
     """
-    Commande de base pour parser les tokens
+    Parse the list of tokens and return a list of AST nodes.
+    :param token_lines: table of tokens
+    :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

Dshell/_DshellTokenizer/dshell_keywords.py

@@ -11,6 +11,7 @@ from typing import Callable
 
 from ..DISCORD_COMMANDS.dshell_channel import *
 from ..DISCORD_COMMANDS.dshell_message import *
+from ..DISCORD_COMMANDS.dshell_member import *
 
 dshell_keyword: set[str] = {
     'if', 'else', 'elif', 'loop', '#end', 'var', '#loop', '#if', 'sleep'
@@ -24,11 +25,12 @@ dshell_commands: dict[str, Callable] = {
     "dm": dshell_delete_message,
     "pm": dshell_purge_message,
     "cc": dshell_create_text_channel,  # create channel
+    "cvc": dshell_create_voice_channel,  # create voice channel
     "dc": dshell_delete_channel,  # delete channel
-    "dcs": dshell_delete_channels,
-    "uc": dshell_send_message,
-    # update channel (aura toutes les modifications possible -> servira à ne faire qu'une commande pour modifier plusieurs chose sur le salon)
-    "rc": dshell_send_message  # rename channel
+    "dcs": dshell_delete_channels, # delete several channels by name or regex
+    "bm": dshell_ban_member,  # ban member
+    "um": dshell_unban_member,  # unban member
+    "km": dshell_kick_member,  # kick member
 }
 
 dshell_mathematical_operators: dict[str, tuple[Callable, int]] = {
@@ -43,11 +45,11 @@ dshell_mathematical_operators: dict[str, tuple[Callable, int]] = {
     r"=>": (lambda a, b: a >= b, 4),
 
     r".": (lambda a, b: a.b, 9),
-    r"->": (lambda a: a.at, 10),  # équivalent à l'appel .at(key)
+    r"->": (lambda a: a.at, 10),  # equivalent to calling .at(key)
 
     r"+": (lambda a, b: a + b, 6),
     r"-": (lambda a, b=None: -a if b is None else a - b, 6),
-    # attention : ambiguïté entre unaire et binaire à traiter dans ton parseur
+    # warning: ambiguity between unary and binary to be handled in your parser
     r"**": (lambda a, b: a ** b, 8),
     r"*": (lambda a, b: a * b, 7),
     r"%": (lambda a, b: a % b, 7),
@@ -71,7 +73,7 @@ dshell_operators.update(dshell_mathematical_operators)
 
 '''
 C_create_var = "var"
-    C_obligate_var = "ovar" # rend obligatoire les variables
+    C_obligate_var = "ovar" # makes variables mandatory
 
     # guild
     C_create_channel = "cc"
@@ -120,5 +122,5 @@ C_create_var = "var"
     C_clear_emoji = "ce"
     C_remove_reaction = "rre"
 
-    # bouton
+    # button
     C_create_button = "b"'''

Dshell/_DshellTokenizer/dshell_token_type.py

@@ -32,7 +32,7 @@ class DshellTokenType(Enum):
 
 
 class Token:
-    def __init__(self, type_: "DTT", value: Union[str, list], position: int):
+    def __init__(self, type_: "DTT", value: Union[str, list], position: tuple[int, int]):
         self.type = type_
         self.value = value
         self.position = position

Dshell/_DshellTokenizer/dshell_tokenizer.py

@@ -59,6 +59,7 @@ class DshellTokenizer:
         """
         tokens: list[list[Token]] = []
 
+        line_number = 1
         for ligne in commandes_lines:  # iter chaque ligne du code
             tokens_par_ligne: list[Token] = []
 
@@ -66,7 +67,7 @@ class DshellTokenizer:
 
                 for match in finditer(pattern, ligne):  # iter les résultat du match pour avoir leur position
                     if token_type != DTT.COMMENT:  # si ce n'est pas un commentaire
-                        token = Token(token_type, match.group(1), match.start())  # on enregistre son token
+                        token = Token(token_type, match.group(1), (line_number, match.start()))  # on enregistre son token
                         tokens_par_ligne.append(token)
 
                     len_match = len(match.group(0))
@@ -81,7 +82,7 @@ class DshellTokenizer:
                             result) > 0 else result  # gère si la structure de donnée est vide ou non
 
             tokens_par_ligne.sort(key=lambda
-                token: token.position)  # trie la position par rapport aux positions de match des tokens pour les avoir dans l'ordre du code
+                token: token.position[1])  # trie la position par rapport aux positions de match des tokens pour les avoir dans l'ordre du code
             if tokens_par_ligne:
                 tokens.append(tokens_par_ligne)
 

{dshellinterpreter-0.1.9.dist-info → dshellinterpreter-0.1.11.dist-info}/METADATA

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

dshellinterpreter-0.1.11.dist-info/RECORD

@@ -0,0 +1,19 @@
+Dshell/__init__.py,sha256=UPvXnewe_8FX9aoevMA78UN1k8AY-u8LTY3vEVxaDxw,72
+Dshell/DISCORD_COMMANDS/__init__.py,sha256=unbZE4sxFCbUQ4Qptr1BhWu-nwhvI2oRzcDLtRmX6Ug,92
+Dshell/DISCORD_COMMANDS/dshell_channel.py,sha256=Es1boRZmL5kTip-Lfs0JFtj6hShzEGDp-W49e8cGw3A,3722
+Dshell/DISCORD_COMMANDS/dshell_member.py,sha256=enDFS7gFqNSK4nZWN1VwSGmoXxiREuhhaf82cwReuUc,1425
+Dshell/DISCORD_COMMANDS/dshell_message.py,sha256=LBaEpwkOPDGt3xWAQI287pqEEdlZgKzpB2YmnarwrFg,1840
+Dshell/_DshellInterpreteur/__init__.py,sha256=xy5-J-R3YmY99JF3NBHTRRLsComFxpjnCA5xacISctU,35
+Dshell/_DshellInterpreteur/dshell_interpreter.py,sha256=U6appx8CA0wo1nX44szejQb2Q4E24s88FVoTe9mSmyw,17277
+Dshell/_DshellParser/__init__.py,sha256=ONDfhZMvClqP_6tE8SLjp-cf3pXL-auQYnfYRrHZxC4,56
+Dshell/_DshellParser/ast_nodes.py,sha256=ZPZAA6yqR62mLAMGVO94wTUVmpYM91qAwSKFiWNAt74,9125
+Dshell/_DshellParser/dshell_parser.py,sha256=SqZRG7i8_vdIFhaQwLi-Q8LWIwyw5FaPFEGMX5vsWwU,14074
+Dshell/_DshellTokenizer/__init__.py,sha256=LIQSRhDx2B9pmPx5ADMwwD0Xr9ybneVLhHH8qrJWw_s,172
+Dshell/_DshellTokenizer/dshell_keywords.py,sha256=pCL-y3Sppq-LecXVmrg8bTN-IVLjGh4Rkkm6ZQpR62Q,3720
+Dshell/_DshellTokenizer/dshell_token_type.py,sha256=p0cR4sxhmq03AqBjd0h_sg2eDzgBmd3dhrrchYkL1Pk,1011
+Dshell/_DshellTokenizer/dshell_tokenizer.py,sha256=DSGiSHj9jLqP7RkC-8WFRqFvitJ7P4b7p0CJn4ek7hE,5831
+dshellinterpreter-0.1.11.dist-info/licenses/LICENSE,sha256=lNgcw1_xb7QENAQi3uHGymaFtbs0RV-ihiCd7AoLQjA,1082
+dshellinterpreter-0.1.11.dist-info/METADATA,sha256=kMhgLtXUntL8mpMWQ-TksVsbEgcIp3TyTCRFQ_MNToA,1096
+dshellinterpreter-0.1.11.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dshellinterpreter-0.1.11.dist-info/top_level.txt,sha256=B4CMhtmchGwPQJLuqUy0GhRG-0cUGxKL4GqEbCiB_vE,7
+dshellinterpreter-0.1.11.dist-info/RECORD,,

dshellinterpreter-0.1.9.dist-info/RECORD

@@ -1,18 +0,0 @@
-Dshell/__init__.py,sha256=UPvXnewe_8FX9aoevMA78UN1k8AY-u8LTY3vEVxaDxw,72
-Dshell/DISCORD_COMMANDS/__init__.py,sha256=s58iMazDXNPDLZ3Hvymh__C5w7lcgEvaYfX0-SHocRo,62
-Dshell/DISCORD_COMMANDS/dshell_channel.py,sha256=RmzqXiuwWTbIUV37KtutFsw2uuXNY7HJFtbJCut5rgg,2388
-Dshell/DISCORD_COMMANDS/dshell_message.py,sha256=cOZzPbm4wkgObuIL42CH1R3qDhPP8ONiP4BA-XTfAMc,1880
-Dshell/_DshellInterpreteur/__init__.py,sha256=xy5-J-R3YmY99JF3NBHTRRLsComFxpjnCA5xacISctU,35
-Dshell/_DshellInterpreteur/dshell_interpreter.py,sha256=j3ppzNv0HIMyWbj0vkIT7RsJSozUnobvnwk2UFT3hys,16088
-Dshell/_DshellParser/__init__.py,sha256=ONDfhZMvClqP_6tE8SLjp-cf3pXL-auQYnfYRrHZxC4,56
-Dshell/_DshellParser/ast_nodes.py,sha256=dRAYD7ZgNB6q5RGwqgWrM68PtUzSFGMBb6xEwvzaDxo,5687
-Dshell/_DshellParser/dshell_parser.py,sha256=mA8uA-xBhKcfnSKfLfePwI_fD0GrHbj0VBVeJPbcGas,13956
-Dshell/_DshellTokenizer/__init__.py,sha256=LIQSRhDx2B9pmPx5ADMwwD0Xr9ybneVLhHH8qrJWw_s,172
-Dshell/_DshellTokenizer/dshell_keywords.py,sha256=wTV89px9bUY4uf0KCnDr356H_dBIVgcPr55L_6-AWdg,3661
-Dshell/_DshellTokenizer/dshell_token_type.py,sha256=NE-sVloBYtioZpWKnWuO5p0YcObGJZPNaKwc8lWDonQ,999
-Dshell/_DshellTokenizer/dshell_tokenizer.py,sha256=2tto_gXYj94fLFx99p6nBbtplALT3Ysz9oBwatX9tIA,5788
-dshellinterpreter-0.1.9.dist-info/licenses/LICENSE,sha256=lNgcw1_xb7QENAQi3uHGymaFtbs0RV-ihiCd7AoLQjA,1082
-dshellinterpreter-0.1.9.dist-info/METADATA,sha256=lLhxzDPjhB4U7iMth8pB_iWsb6vGo5WN-O5W2I6V_f4,1095
-dshellinterpreter-0.1.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-dshellinterpreter-0.1.9.dist-info/top_level.txt,sha256=B4CMhtmchGwPQJLuqUy0GhRG-0cUGxKL4GqEbCiB_vE,7
-dshellinterpreter-0.1.9.dist-info/RECORD,,