dshellInterpreter 0.1.0__tar.gz

dshellinterpreter-0.1.0/Dshell/DISCORD_COMMANDS/__init__.py

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

dshellinterpreter-0.1.0/Dshell/DISCORD_COMMANDS/dshell_channel.py

@@ -0,0 +1,60 @@
+from asyncio import sleep
+from re import search
+
+from discord import MISSING
+from discord.abc import GuildChannel
+
+__all__ = [
+    'dshell_create_text_channel',
+    'dshell_delete_channel',
+    'dshell_delete_channels'
+]
+
+async def dshell_create_text_channel(ctx: GuildChannel, name, category=None, position=MISSING, slowmode=MISSING,
+                                     topic=MISSING, nsfw=MISSING):
+    """
+    Crée un salon textuel sur le serveur
+    """
+
+    channel_category = ctx.guild.get_channel(category)
+
+    created_channel = await ctx.guild.create_text_channel(name,
+                                                          category=channel_category,
+                                                          position=position,
+                                                          slowmode_delay=slowmode,
+                                                          topic=topic,
+                                                          nsfw=nsfw)
+
+    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)
+    """
+
+    channel_to_delete = ctx if channel is None else ctx.guild.get_channel(channel)
+
+    if channel_to_delete is None:
+        raise Exception(f"Le channel {channel} n'existe pas !")
+
+    await sleep(timeout)
+
+    await channel_to_delete.delete(reason=reason)
+
+    return channel_to_delete.id
+
+
+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
+    """
+    for channel in ctx.guild.channels:
+
+        if name is not None and channel.name == str(name):
+            await channel.delete(reason=reason)
+
+        elif regex is not None and search(regex, channel.name):
+            await channel.delete(reason=reason)

dshellinterpreter-0.1.0/Dshell/DISCORD_COMMANDS/dshell_message.py

@@ -0,0 +1,61 @@
+from discord import Embed
+from discord.abc import GuildChannel
+
+from .._DshellParser.ast_nodes import ListNode
+
+__all__ = [
+    'dshell_send_message',
+    'dshell_delete_message',
+    'dshell_purge_message'
+]
+
+async def dshell_send_message(ctx: GuildChannel, message=None, delete=None, channel=None, embeds: ListNode = None,
+                              embed=None):
+    """
+    Envoie un message sur 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 !')
+
+    if embeds is None:
+        embeds = ListNode([])
+
+    elif isinstance(embeds, Embed):
+        embeds = ListNode([embeds])
+
+    if embed is not None and isinstance(embed, Embed):
+        embeds.add(embed)
+
+    sended_message = await channel_to_send.send(message,
+                                                delete_after=delete,
+                                                embeds=embeds)
+
+    return sended_message.id
+
+
+async def dshell_delete_message(ctx: GuildChannel, message, reason=None, delay=0):
+    """
+    Supprime un message
+    """
+
+    delete_message = ctx.get_partial_message(message)  # construit une référence au message (même s'il n'existe pas)
+
+    if delay > 3600:
+        raise Exception(f'Le délait de suppression du message est trop grand ! ({delay} secondes)')
+
+    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
+    """
+
+    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 !")
+
+    await purge_channel.purge(limit=message_number, reason=reason)

dshellinterpreter-0.1.0/Dshell/_DshellInterpreteur/__init__.py

@@ -0,0 +1 @@
+from .dshell_interpreter import *

dshellinterpreter-0.1.0/Dshell/_DshellInterpreteur/dshell_interpreter.py

@@ -0,0 +1,267 @@
+from asyncio import sleep
+from re import findall
+from typing import TypeVar, Union, Any, Optional, Callable
+
+from discord import AutoShardedBot, Embed, Colour
+from discord.abc import GuildChannel, PrivateChannel
+
+from .._DshellTokenizer.dshell_keywords import *
+from .._DshellParser.ast_nodes import *
+from .._DshellParser.dshell_parser import parse
+from .._DshellParser.dshell_parser import to_postfix, print_ast
+from .._DshellTokenizer.dshell_token_type import DshellTokenType as DTT
+from .._DshellTokenizer.dshell_token_type import Token
+from .._DshellTokenizer.dshell_tokenizer import DshellTokenizer
+
+All_nodes = TypeVar('All_nodes', IfNode, LoopNode, ElseNode, ElifNode, ArgsCommandNode, VarNode, IdentOperationNode)
+context = TypeVar('context', AutoShardedBot, GuildChannel, PrivateChannel)
+
+
+class DshellInterpreteur:
+
+    def __init__(self, ast_or_code: Union[list[All_nodes], str], ctx: context, auto=False, debug: bool = False):
+        """
+        Interpreter Dshell code or AST.
+        """
+        self.ast: StartNode = parse(DshellTokenizer(ast_or_code).start(), StartNode([]))[0][0]
+        self.env: dict[str, Any] = {}
+        self.ctx: context = ctx
+        if debug:
+            print_ast(self.ast)
+
+    async def execute(self, ast: Optional[list[All_nodes]] = None):
+        """
+        Execute l'arbre syntaxique.
+        """
+
+        for node in ast:
+
+            if isinstance(node, StartNode):
+                await self.execute(node.body)
+
+            if isinstance(node, CommandNode):
+                self.env['__cr__'] = await call_function(dshell_commands[node.name], node.body, self)
+
+            elif isinstance(node, IfNode):
+                elif_valid = False
+                if eval_expression(node.condition, self):
+                    await self.execute(node.body)
+                    return
+                elif node.elif_nodes:
+
+                    for i in node.elif_nodes:
+                        if eval_expression(i.condition, self):
+                            await self.execute(i.body)
+                            elif_valid = True
+                            break
+
+                if not elif_valid and node.else_body is not None:
+                    await self.execute(node.else_body.body)
+
+            elif isinstance(node, LoopNode):
+                self.env[node.variable.name.value] = 0
+                for i in DshellIterator(eval_expression(node.variable.body, self)):
+                    self.env[node.variable.name.value] = i
+                    await self.execute(node.body)
+
+            elif isinstance(node, VarNode):
+
+                first_node = node.body[0]
+                if isinstance(first_node, IfNode):
+                    self.env[node.name.value] = eval_expression_inline(first_node, self)
+
+                elif isinstance(first_node, EmbedNode):
+                    self.env[node.name.value] = build_embed(first_node.body, first_node.fields, self)
+
+                else:
+                    self.env[node.name.value] = eval_expression(node.body, self)
+
+            elif isinstance(node, IdentOperationNode):
+                function = self.eval_data_token(node.function)
+                listNode = self.eval_data_token(node.ident)
+                if hasattr(listNode, function):
+                    getattr(listNode, function)(self.eval_data_token(node.args))
+
+            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 !')
+                elif sleep_time < 1:
+                    raise Exception(f'Le temps minimal de sommeil est de 1 seconde !')
+
+                await sleep(sleep_time)
+
+            elif isinstance(node, EndNode):
+                raise RuntimeError(f"Execution interromput -> #end atteint")
+
+    def eval_data_token(self, token: Token):
+        """
+        Evalue les tokens de data
+        """
+
+        if not hasattr(token, 'type'):
+            return token
+
+        if token.type in (DTT.INT, DTT.MENTION):
+            return int(token.value)
+        elif token.type == DTT.FLOAT:
+            return float(token.value)
+        elif token.type == DTT.BOOL:
+            return token.value.lower() == "true"
+        elif token.type == DTT.LIST:
+            return ListNode(
+                [self.eval_data_token(tok) for tok in token.value])  # token.value contient déjà une liste de Token
+        elif token.type == DTT.IDENT:
+            if token.value in self.env.keys():
+                return self.env[token.value]
+            return token.value
+        elif token.type == DTT.CALL_ARGS:
+            return (self.eval_data_token(tok) for tok in token.value)
+        elif token.type == DTT.STR:
+            for match in findall(rf"\$({'|'.join(self.env.keys())})", token.value):
+                token.value = token.value.replace('$' + match, str(self.env[match]))
+            return token.value
+        else:
+            return token.value  # fallback
+
+
+def eval_expression_inline(if_node: IfNode, interpreter: DshellInterpreteur) -> Token:
+    """
+    Evalue une expression en ligne des variables
+    """
+    if eval_expression(if_node.condition, interpreter):
+        return eval_expression(if_node.body, interpreter)
+    else:
+        return eval_expression(if_node.else_body.body, interpreter)
+
+
+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
+    """
+    postfix = to_postfix(tokens)
+    stack = []
+
+    for token in postfix:
+
+        if token.type in {DTT.INT, DTT.FLOAT, DTT.BOOL, DTT.STR, DTT.LIST, DTT.IDENT}:
+            stack.append(interpreter.eval_data_token(token))
+
+        elif token.type in (DTT.MATHS_OPERATOR, DTT.LOGIC_OPERATOR):
+            op = token.value
+
+            if op == "not":
+                a = stack.pop()
+                result = dshell_operators[op][0](a)
+
+            else:
+                b = stack.pop()
+                a = stack.pop()
+                result = dshell_operators[op][0](a, b)
+
+            stack.append(result)
+
+        else:
+            raise SyntaxError(f"Token inattendu en condition: {token}")
+
+    if len(stack) != 1:
+        raise SyntaxError("Condition mal formée")
+
+    return stack[0]
+
+
+async def call_function(function: Callable, args: ArgsCommandNode, interpreter: DshellInterpreteur):
+    """
+    Appelle une fonction avec évaluation des arguments Dshell en valeurs Python
+    """
+    reformatted = regroupe_commandes(args.body, interpreter)
+
+    # 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
+
+    absolute_args.insert(0, interpreter.ctx)
+    keyword_args = {
+        key: value for key, value in reformatted.items()
+    }
+    return await function(*absolute_args, **keyword_args)
+
+
+def regroupe_commandes(body: list[Token], interpreter: DshellInterpreteur) -> dict[Union[str, Token], list[Token]]:
+    """
+    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.
+    """
+    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
+    n = len(body)
+
+    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
+        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
+            i += 1
+    return tokens
+
+
+def build_embed(body: list[Token], fields: list[FieldEmbedNode], interpreter: DshellInterpreteur) -> Embed:
+    """
+    Construit un embed à partir des informations de la commande.
+    """
+    args_main_embed: dict[Union[str, Token], list[Token]] = regroupe_commandes(body, interpreter)
+    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_fields: list[dict[str, Token]] = []
+    for field in fields:  # on fait la même chose pour tous les fields
+        a = regroupe_commandes(field.body, interpreter)
+        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
+        args_main_embed['color'] = Colour.from_rgb(*args_main_embed['color'])
+
+    embed = Embed(**args_main_embed)  # on construit l'embed principal
+    for field in args_fields:
+        embed.add_field(**field)  # on joute tous les fields
+
+    return embed
+
+
+class DshellIterator:
+    """
+    Utilisé pour transformer n'importe quoi en un iterable
+    """
+
+    def __init__(self, data):
+        if isinstance(data, ListNode):
+            self.data = data
+        else:
+            self.data = data if isinstance(data, (str, list)) else range(int(data))
+        self.current = 0
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+
+        if self.current >= len(self.data):
+            self.current = 0
+            raise StopIteration
+
+        value = self.data[self.current]
+        self.current += 1
+        return value

dshellinterpreter-0.1.0/Dshell/_DshellParser/__init__.py

@@ -0,0 +1,2 @@
+from .ast_nodes import *
+from .dshell_parser import *

dshellinterpreter-0.1.0/Dshell/_DshellParser/ast_nodes.py

@@ -0,0 +1,204 @@
+from typing import Optional, Any
+
+from .._DshellTokenizer.dshell_token_type import Token
+
+__all__ = [
+    'ASTNode',
+    'StartNode',
+    'ElseNode',
+    'ElifNode',
+    'IfNode',
+    'LoopNode',
+    'ArgsCommandNode',
+    'CommandNode',
+    'VarNode',
+    'EndNode',
+    'FieldEmbedNode',
+    'EmbedNode',
+    'SleepNode',
+    'IdentOperationNode',
+    'ListNode'
+]
+
+class ASTNode:
+    pass
+
+
+class StartNode(ASTNode):
+    def __init__(self, body: list):
+        self.body = body
+
+    def __repr__(self):
+        return f"<Command> - {self.body}"
+
+
+class ElseNode(ASTNode):
+    def __init__(self, body: list[Token]):
+        self.body = body
+
+    def __repr__(self):
+        return f"<Else> - {self.body}"
+
+
+class ElifNode(ASTNode):
+    def __init__(self, condition: list[Token], body: list[Token], parent: "IfNode"):
+        self.condition = condition
+        self.body = body
+        self.parent = parent
+
+    def __repr__(self):
+        return f"<Elif> - {self.condition} - {self.body}"
+
+
+class IfNode(ASTNode):
+    def __init__(self, condition: list[Token], body: list[Token], elif_nodes: Optional[list[ElifNode]] = None,
+                 else_body: Optional[ElseNode] = None):
+        self.condition = condition
+        self.body = body
+        self.elif_nodes = elif_nodes
+        self.else_body = else_body
+
+    def __repr__(self):
+        return f"<If> - {self.condition} - {self.body} *- {self.elif_nodes} **- {self.else_body}"
+
+
+class LoopNode(ASTNode):
+    def __init__(self, variable: "VarNode", body: list):
+        self.variable = variable  # content l'itérable dans son body
+        self.body = body
+
+    def __repr__(self):
+        return f"<Loop> - {self.variable.name} -> {self.variable.body} *- {self.body}"
+
+
+class ArgsCommandNode(ASTNode):
+    def __init__(self, body: list[Token]):
+        self.body: list[Token] = body
+
+    def __repr__(self):
+        return f"<Args Command> - {self.body}"
+
+
+class CommandNode(ASTNode):
+    def __init__(self, name: str, body: ArgsCommandNode):
+        self.name = name
+        self.body = body
+
+    def __repr__(self):
+        return f"<{self.name}> - {self.body}"
+
+
+class VarNode(ASTNode):
+    def __init__(self, name: Token, body: list[Token]):
+        self.name = name
+        self.body = body
+
+    def __repr__(self):
+        return f"<VAR> - {self.name} *- {self.body}"
+
+
+class EndNode(ASTNode):
+    def __init__(self):
+        pass
+
+    def __repr__(self):
+        return f"<END>"
+
+
+class FieldEmbedNode(ASTNode):
+    def __init__(self, body: list[Token]):
+        self.body: list[Token] = body
+
+    def __repr__(self):
+        return f"<EMBED_FIELD> - {self.body}"
+
+
+class EmbedNode(ASTNode):
+    def __init__(self, body: list[Token], fields: list[FieldEmbedNode]):
+        self.body = body
+        self.fields = fields
+
+    def __repr__(self):
+        return f"<EMBED> - {self.body}"
+
+
+class SleepNode(ASTNode):
+    def __init__(self, body: list[Token]):
+        self.body = body
+
+    def __repr__(self):
+        return f"<SLEEP> - {self.body}"
+
+
+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
+    """
+
+    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
+
+    def __repr__(self):
+        return f"<IDENT OPERATION> - {self.ident}.{self.function}({self.args})"
+
+
+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.
+    """
+
+    def __init__(self, body: list[Any]):
+        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
+        """
+        if self.len_iterable > 10000:
+            raise PermissionError('Une liste ne peut dépasser les 10.000 éléments !')
+
+        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
+        """
+        if number < 1:
+            raise Exception(f"Le nombre d'élément à retirer doit-être égale ou supperieur à 1 !")
+
+    def __add__(self, other: "ListNode"):
+        for i in other:
+            self.add(i)
+        return self
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+
+        if self.iterateur_count >= self.len_iterable:
+            self.iterateur_count = 0
+            raise StopIteration()
+
+        v = self.iterable[self.iterateur_count]
+        self.iterateur_count += 1
+        return v
+
+    def __len__(self):
+        return self.len_iterable
+
+    def __getitem__(self, item):
+        return self.iterable[item]
+
+    def __bool__(self):
+        return bool(self.iterable)
+
+    def __repr__(self):
+        return f"<LIST> - {self.iterable}"