dshellInterpreter 0.1.0__py3-none-any.whl

Dshell/DISCORD_COMMANDS/__init__.py

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

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)

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)

Dshell/_DshellInterpreteur/__init__.py

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

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

Dshell/_DshellParser/__init__.py

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

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}"

Dshell/_DshellParser/dshell_parser.py

@@ -0,0 +1,308 @@
+__all__ = [
+    "parse",
+    "parser_inline",
+    "to_postfix",
+    "parse_postfix_expression",
+    "print_ast"
+]
+
+from typing import Union, TYPE_CHECKING
+
+from .ast_nodes import (ASTNode,
+                        CommandNode,
+                        IfNode,
+                        LoopNode,
+                        ElseNode,
+                        ArgsCommandNode,
+                        ElifNode,
+                        VarNode,
+                        EndNode,
+                        SleepNode,
+                        IdentOperationNode,
+                        EmbedNode,
+                        FieldEmbedNode)
+from .._DshellTokenizer.dshell_token_type import DshellTokenType as DTT
+from .._DshellTokenizer.dshell_token_type import Token
+
+if TYPE_CHECKING:
+    from .._DshellTokenizer import dshell_operators
+
+
+def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[ASTNode], int]:
+    """
+    Commande de base pour parser les tokens
+    """
+    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
+    len_token_lines = len(token_lines)
+
+    while pointeur < len_token_lines:
+
+        tokens_by_line = token_lines[pointeur]  # on récupère la liste de token par rapport au pointeur
+        first_token_line = tokens_by_line[0]  # on récupère le premier token de la ligne
+        last_block = blocks[-1]
+
+        if first_token_line.type == DTT.COMMAND:  # si le token est une comande
+            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
+
+        ############################## DSHELL KEYWORDS ##############################
+
+        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_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)
+                _, p = parse(token_lines[pointeur + 1:],
+                             if_node)  # on parse le reste du code avec la node if_node comme commancement du nouveau parsing
+                pointeur += p + 1  # essentielle pour ne pas parser les lignes déjà faite
+
+            elif first_token_line.value == '#if':
+                if not isinstance(last_block, (IfNode, ElseNode, ElifNode)):
+                    raise SyntaxError(f'[#IF] Aucun bloc conditionnel ouvert ligne {first_token_line.position} !')
+
+                if isinstance(last_block, (ElifNode, ElseNode)):
+
+                    while isinstance(last_block, (ElifNode, ElseNode)):
+                        blocks.pop()
+                        last_block = blocks[-1]
+                blocks.pop()
+                return blocks, pointeur
+
+            elif first_token_line.value == 'elif':
+                if not isinstance(last_block, (IfNode, ElifNode)):
+                    raise SyntaxError(f'[ELIF] Aucun bloc conditionnel ouvert ligne {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)
+
+                if isinstance(last_block, ElifNode):
+                    last_block.parent.elif_nodes.append(elif_node)
+                else:
+                    if last_block.elif_nodes is None:
+                        last_block.elif_nodes = [elif_node]
+                    else:
+                        last_block.elif_nodes.append(elif_node)
+
+                blocks.append(elif_node)
+
+            elif first_token_line.value == 'else':
+                if not isinstance(last_block, (IfNode, ElifNode)):
+                    raise SyntaxError(f'[ELSE] Aucun bloc conditionnel ouvert ligne {first_token_line.position} !')
+
+                if isinstance(last_block, ElseNode) and last_block.else_body is not None:
+                    raise SyntaxError(f'[ELSE] Déjà définit et n\'accepte pas les doublons dans un même if !')
+
+                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:
+                    last_block.else_body = else_node  # une fois le parsing fini, on l'ajoute au dernier bloc
+                blocks.append(else_node)
+
+            elif first_token_line.value == 'loop':
+                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:],
+                             loop_node)  # on parse tous ce qu'il y a après l'instruction loop
+                pointeur += p + 1
+
+            elif first_token_line.value == '#loop':  # si rencontré
+                if not isinstance(last_block, LoopNode):
+                    raise SyntaxError(f'[#LOOP] Aucune loop ouverte ligne {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=[])
+                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
+                if status:
+                    parse(result, var_node)  # on parse le tout dans la variable
+                else:
+                    # var_node.body = parse(result, StartNode([]))[0][0].body
+                    var_node.body = result[0]
+
+            elif first_token_line.value == 'sleep':
+                sleep_node = SleepNode(tokens_by_line[1:])
+                last_block.body.append(sleep_node)
+
+            elif first_token_line.value == '#end':  # node pour arrêter le programme si elle est rencontré
+                end_node = EndNode()
+                last_block.body.append(end_node)
+
+        ############################## DISCORD KEYWORDS ##############################
+
+        elif first_token_line.type == DTT.DISCORD_KEYWORD:
+
+            if first_token_line.value == 'embed':
+                embed_node = EmbedNode(body=[], fields=[])
+                var_node = VarNode(tokens_by_line[1], body=[embed_node])
+                last_block.body.append(var_node)
+                _, p = parse(token_lines[pointeur + 1:], embed_node)
+                pointeur += p + 1
+
+            elif first_token_line.value == '#embed':
+                if not isinstance(last_block, EmbedNode):
+                    raise SyntaxError(f'[#EMBED] Aucun embed ouvert ligne {first_token_line.position} !')
+                blocks.pop()
+                return blocks, pointeur
+
+            elif first_token_line.value == 'field':
+                if not isinstance(last_block, EmbedNode):
+                    raise SyntaxError(f'[FIELD] Aucun embed ouvert ligne {first_token_line.position} !')
+                last_block.fields.append(FieldEmbedNode(tokens_by_line[1:]))
+
+        ############################## AUTRE ##############################
+
+        elif first_token_line.type == DTT.IDENT:
+            if len(tokens_by_line) == 1:
+                last_block.body.append(CommandNode(name='sm', body=ArgsCommandNode([first_token_line])))
+
+            else:
+                last_block.body += parse_postfix_expression(to_postfix(tokens_by_line))
+
+        elif first_token_line.type == DTT.STR:
+            last_block.body.append(CommandNode(name='sm', body=ArgsCommandNode([first_token_line])))
+
+
+        else:
+            last_block.body += tokens_by_line
+
+        pointeur += 1
+
+    return blocks, pointeur
+
+
+"""
+elif first_token_line.type == DTT.LIST: # si le token est une liste (qui comporte une liste python avec des Tokens)
+    list_node = ListNode(first_token_line.value) # le .value est une liste python
+    last_block.body.append(list_node)
+    """
+
+
+def parser_inline(tokens: list[Token]) -> tuple[list[list[Token]], bool]:
+    """
+    Transforme une ligne avec un if/else inline en structure multilignes
+    """
+    result: list[list[Token]] = []
+
+    try:
+        if_index = next(i for i, tok in enumerate(tokens) if tok.value == 'if')
+        else_index = next(i for i, tok in enumerate(tokens) if tok.value == 'else')
+    except StopIteration:
+        return [tokens], False  # ligne normale
+
+    value_tokens = tokens[:if_index]
+    condition_tokens = tokens[if_index + 1:else_index]
+    else_tokens = tokens[else_index + 1:]
+
+    # On génère :
+    result.append([tokens[if_index]] + condition_tokens)  # ligne "if cond"
+    result.append(value_tokens)  # body du if
+    result.append([tokens[else_index]])  # ligne "else"
+    result.append(else_tokens)  # body du else
+    return result, True
+
+
+def to_postfix(expression):
+    """
+    Transforme l'expression en notation postfixée (RPN)
+    :param expression: l'expression donné par le tokenizer
+    :return: l'expression en notation postfixée
+    """
+    output = []
+    operators: list[Token] = []
+
+    for token in expression:
+        if token.type in (DTT.IDENT, DTT.CALL_ARGS, DTT.INT, DTT.FLOAT, DTT.LIST, DTT.STR):  # Si c'est un ident
+            output.append(token)
+        elif token.value in dshell_operators:
+            while (operators and operators[-1].value in dshell_operators and
+                   dshell_operators[operators[-1].value][1] >= dshell_operators[token.value][1]):
+                output.append(operators.pop())
+            operators.append(token)
+        else:
+            raise ValueError(f"Token inconnu : {token}")
+
+    while operators:
+        output.append(operators.pop())
+
+    return output
+
+
+def parse_postfix_expression(postfix_tokens: list[Token]) -> list[IdentOperationNode]:
+    stack = []
+
+    for tok in postfix_tokens:
+
+        if tok.type in (DTT.IDENT, DTT.CALL_ARGS, DTT.INT, DTT.STR, DTT.LIST):
+            stack.append(tok)
+
+        elif tok.type == DTT.MATHS_OPERATOR:
+            if tok.value == '.':
+                args = stack.pop()
+                func = stack.pop()
+                base = stack.pop()
+                node = IdentOperationNode(ident=base, function=func, args=args)
+                stack.append(node)
+
+            elif tok.value == '->':
+                value = stack.pop()
+                base = stack.pop()
+                fake_func = Token(DTT.IDENT, 'at', tok.position)
+                fake_args = Token(DTT.CALL_ARGS, value.value, value.position)
+                node = IdentOperationNode(ident=base, function=fake_func, args=fake_args)
+                stack.append(node)
+
+            else:
+                raise SyntaxError(f"Opérateur non supporté dans les appels : {tok.value}")
+
+        else:
+            raise SyntaxError(f"Token inattendu : {tok}")
+
+    if len(stack) != 1:
+        raise SyntaxError("Expression mal formée ou incomplète")
+
+    return stack
+
+
+def print_ast(ast: ASTNode, decalage: int = 0):
+    for i in ast.body:
+
+        if isinstance(i, LoopNode):
+            print(f"{' ' * decalage}LOOP -> {i.variable.name} : {i.variable.body}")
+            print_ast(i, decalage + 5)
+
+        elif isinstance(i, IfNode):
+            print(f"{' ' * decalage}IF -> {i.condition}")
+            print_ast(i, decalage + 5)
+
+            if i.elif_nodes is not None:
+                for elif_body in i.elif_nodes:
+                    print(f"{' ' * decalage}ELIF -> {elif_body.condition}")
+                    print_ast(elif_body, decalage + 5)
+
+            if i.else_body is not None:
+                print(f"{' ' * decalage}ELSE -> ...")
+                print_ast(i.else_body, decalage + 5)
+
+        elif isinstance(i, IdentOperationNode):
+            print(f"{' ' * decalage}IDENT_OPERATION -> {i.ident}.{i.function}({i.args})")
+
+        elif isinstance(i, CommandNode):
+            print(f"{' ' * decalage}COMMAND -> {i.name} : {i.body}")
+
+        elif isinstance(i, VarNode):
+            print(f"{' ' * decalage}VAR -> {i.name} : {i.body}")
+
+        elif isinstance(i, EmbedNode):
+            print(f"{' ' * decalage}EMBED :")
+            print_ast(i.fields, decalage + 5)
+
+        elif isinstance(i, FieldEmbedNode):
+            for field in i.body:
+                print(f"{' ' * decalage}FIELD -> {field.value}")

Dshell/_DshellTokenizer/__init__.py

@@ -0,0 +1,4 @@
+from .dshell_keywords import *
+from .dshell_token_type import DshellTokenType as DTT
+from .dshell_token_type import Token
+from .dshell_tokenizer import DshellTokenizer

Dshell/_DshellTokenizer/dshell_keywords.py

@@ -0,0 +1,125 @@
+__all__ = [
+    "dshell_keyword",
+    "dshell_discord_keyword",
+    "dshell_commands",
+    "dshell_mathematical_operators",
+    "dshell_logical_operators",
+    "dshell_operators"
+]
+from typing import Callable
+from ..DISCORD_COMMANDS.dshell_channel import *
+from ..DISCORD_COMMANDS.dshell_message import *
+
+dshell_keyword: set[str] = {
+    'if', 'else', 'elif', 'loop', '#end', 'var', '#loop', '#if', 'sleep'
+}
+
+dshell_discord_keyword: set[str] = {
+    'embed', '#embed', 'field'
+}
+
+dshell_commands: dict[str, Callable] = {
+    "sm": dshell_send_message,  # send message
+    "dm": dshell_delete_message,
+    "pm": dshell_purge_message,
+    "cc": dshell_create_text_channel,  # create 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
+}
+
+dshell_mathematical_operators: dict[str, tuple[Callable, int]] = {
+    r"<": (lambda a, b: a < b, 4),
+    r"<=": (lambda a, b: a <= b, 4),
+    r"=<": (lambda a, b: a <= b, 4),
+    r"=": (lambda a, b: a == b, 4),
+    r"!=": (lambda a, b: a != b, 4),
+    r"=!": (lambda a, b: a != b, 4),
+    r">": (lambda a, b: a > b, 4),
+    r">=": (lambda a, b: a >= b, 4),
+    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, 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
+    r"**": (lambda a, b: a ** b, 8),
+    r"*": (lambda a, b: a * b, 7),
+    r"%": (lambda a, b: a % b, 7),
+    r"//": (lambda a, b: a // b, 7),
+    r"/": (lambda a, b: a / b, 7),
+}
+
+dshell_logical_operators: dict[str, tuple[Callable, int]] = {
+
+    r"and": (lambda a, b: bool(a and b), 2),
+    r"&": (lambda a, b: a & b, 2),
+    r"or": (lambda a, b: bool(a or b), 1),
+    r"|": (lambda a, b: a | b, 1),
+    r"in": (lambda a, b: a in b, 4),
+    r"not": (lambda a: not a, 3),
+
+}
+
+dshell_operators: dict[str, tuple[Callable, int]] = dshell_logical_operators.copy()
+dshell_operators.update(dshell_mathematical_operators)
+
+
+
+'''
+C_create_var = "var"
+    C_obligate_var = "ovar" # rend obligatoire les variables
+
+    # guild
+    C_create_channel = "cc"
+    C_create_voice_channel = "cvc"
+    C_create_forum_channel = "cfc"
+    C_create_category = "cca"
+    C_create_role = "cr"
+
+    C_delete_channel = "dc"
+    C_delete_category = "dca"
+    C_delete_role = "dr"
+
+    C_edit_channel = "ec"
+    C_edit_voice_channel = "evc"
+    C_edit_forum_channel = "efc"
+    C_edit_category = "eca"
+    C_edit_role = "er"
+    C_edit_guild = "eg"
+
+    # forum
+    C_edit_ForumTag = "eft"
+    C_create_thread = "ct"
+    C_delete_tread = "dt"
+
+    # member
+    C_edit_nickname = "en"
+    C_ban_member = "bm"
+    C_unban_member = "um"
+    C_kick_member = "km"
+    C_timeout_member = "tm"
+    C_move_member = "mm"
+    C_add_roles = "ar"
+    C_remove_roles = "rr"
+
+    # message
+    C_send_message = "sm"
+    C_respond_message = "rm"
+    C_edit_message = "em"
+    C_send_user_message = "sum"
+    C_delete_message = "dm"
+    C_purge_message = "pm"
+    C_create_embed = "e"
+    C_regex = "regex"
+    C_add_emoji = "ae"
+    C_remove_emoji = "re"
+    C_clear_emoji = "ce"
+    C_remove_reaction = "rre"
+
+    # bouton
+    C_create_button = "b"'''

Dshell/_DshellTokenizer/dshell_token_type.py

@@ -0,0 +1,39 @@
+from enum import Enum, auto
+from typing import Union
+
+__all__ = [
+    'DshellTokenType',
+    'Token',
+    'MASK_CHARACTER'
+]
+
+MASK_CHARACTER = '§'
+
+
+class DshellTokenType(Enum):
+    INT = auto()
+    FLOAT = auto()
+    STR = auto()
+    BOOL = auto()
+    LIST = auto()
+    CALL_ARGS = auto()
+    DICT = auto()
+    MENTION = auto()
+    IDENT = auto()  # nom de variable, fonction
+    KEYWORD = auto()  # if, let, end, etc.
+    DISCORD_KEYWORD = auto()  # embed, #embed...
+    COMMAND = auto()
+    SEPARATOR = auto()
+    MATHS_OPERATOR = auto()  # ==, +, -, *, etc.
+    LOGIC_OPERATOR = auto(),
+    COMMENT = auto()  # lignes commençant par ##
+
+
+class Token:
+    def __init__(self, type_: "DTT", value: Union[str, list], position: int):
+        self.type = type_
+        self.value = value
+        self.position = position
+
+    def __repr__(self):
+        return f"<{self.type.name} '{self.value}'>"

Dshell/_DshellTokenizer/dshell_tokenizer.py

@@ -0,0 +1,122 @@
+__all__ = [
+    "DshellTokenizer",
+    "table_regex",
+    "MASK_CHARACTER"
+]
+
+from re import DOTALL, IGNORECASE
+from re import compile, Pattern, finditer, escape, sub, findall
+
+from .dshell_keywords import *
+from .dshell_token_type import DshellTokenType as DTT
+from .dshell_token_type import Token
+
+MASK_CHARACTER = '§'
+
+table_regex: dict[DTT, Pattern] = {
+    DTT.COMMENT: compile(r"::(.*)"),
+    # DTT.DICT: compile(r"\{(.*?)\}"),
+    DTT.CALL_ARGS: compile(r"\((.*?)\)"),
+    DTT.STR: compile(r"\"(.*?)\"", flags=DOTALL),
+    DTT.LIST: compile(r"\[(.*?)\]"),
+    DTT.MENTION: compile(r'<(?:@!?|@&|#)([0-9]+)>'),
+    DTT.KEYWORD: compile(rf"(?<!\w)(#?{'|'.join(dshell_keyword)})(?!\w)"),
+    DTT.DISCORD_KEYWORD: compile(rf"(?<!\w|-)(#?{'|'.join(dshell_discord_keyword)})(?!\w|-)"),
+    DTT.SEPARATOR: compile(rf"(--)"),
+    DTT.COMMAND: compile(rf"\b({'|'.join(dshell_commands.keys())})\b"),
+    DTT.MATHS_OPERATOR: compile(rf"({'|'.join([escape(i) for i in dshell_mathematical_operators.keys()])})"),
+    DTT.LOGIC_OPERATOR: compile(rf"(?<!\w)({'|'.join([escape(i) for i in dshell_logical_operators.keys()])})(?<!\w)"),
+    DTT.FLOAT: compile(r"(\d+\.\d+)"),
+    DTT.INT: compile(r"(\d+)"),
+    DTT.BOOL: compile(r"(True|False)", flags=IGNORECASE),
+    DTT.IDENT: compile(rf"([A-Za-z0-9_]+)")
+}
+
+
+class DshellTokenizer:
+
+    def __init__(self, code: str):
+        """
+        Init le tokenizer.
+        :param code: Le code à tokenizer
+        """
+        self.code: str = code
+
+    def start(self):
+        """
+        Démarre le tokenizer pour qu'il traîte le code actuel.
+        Renvoie un tableau de tokens par ligne (séparé normalement pas des \n)
+        """
+        splited_commandes = self.split(self.code)
+        return self.tokenizer(splited_commandes)
+
+    def tokenizer(self, commandes_lines: list[str]) -> list[list[Token]]:
+        """
+        Tokenize chaque ligne de code
+        :param commandes_lines: Le code séparé en plusieurs lignes par la méthode split
+        """
+        tokens: list[list[Token]] = []
+
+        for ligne in commandes_lines:  # iter chaque ligne du code
+            tokens_par_ligne: list[Token] = []
+
+            for token_type, pattern in table_regex.items():  # iter la table de régex pour tous les tester sur la ligne
+
+                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
+                        tokens_par_ligne.append(token)
+
+                    len_match = len(match.group(0))
+                    ligne = ligne[:match.start()] + (MASK_CHARACTER * len_match) + ligne[
+                                                                                   match.end():]  # remplace la match qui vient d'avoir lieu pour ne pas le rematch une seconde fois
+
+                    if token_type in (
+                            DTT.LIST,
+                            DTT.CALL_ARGS):  # si c'est un regrouppement de donnée, on tokenize ce qu'il contient
+                        result = self.tokenizer([token.value])
+                        token.value = result[0] if len(
+                            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
+            if tokens_par_ligne:
+                tokens.append(tokens_par_ligne)
+
+        return tokens
+
+    @staticmethod
+    def split(commande: str, global_split='\n', garder_carractere_regroupant=True, carractere_regroupant='"') -> list[
+        str]:
+        """
+        Sépare les commandes en une liste en respectant les chaînes entre guillemets.
+        :param commande: La chaîne de caractères à découper.
+        :param global_split: Le séparateur utilisé (par défaut '\n').
+        :param garder_carractere_regroupant: Si False, enlève les guillemets autour des chaînes.
+        :param caractere_regroupant: Le caractère utilisé pour regrouper une chaîne (par défaut '"').
+        :return: Une liste des commandes découpées avec les chaînes restaurées.
+        """
+
+        commandes: str = commande.strip()
+        remplacement_temporaire = '[REMPLACER]'
+        entre_caractere_regroupant = findall(fr'({carractere_regroupant}.*?{carractere_regroupant})', commandes,
+                                             flags=DOTALL)  # repère les parties entre guillemets et les save
+
+        # current_command_text = [i[1: -1] for i in
+        # entre_carractere_regroupant.copy()]  # enregistre les parties entre guillemets pour cette commande
+
+        res = sub(fr'({carractere_regroupant}.*?{carractere_regroupant})', remplacement_temporaire, commandes,
+                  flags=DOTALL)  # remplace les parties entre guillemets
+
+        res = res.split(global_split)  # split les commandes sans les guillemets
+
+        # remet les guillemets à leurs place
+        result = []
+        for i in res:
+            while remplacement_temporaire in i:
+                i = i.replace(remplacement_temporaire,
+                              entre_caractere_regroupant[0][1: -1] if not garder_carractere_regroupant else
+                              entre_caractere_regroupant[0], 1)
+                entre_caractere_regroupant.pop(0)
+            result.append(i)
+        return result

Dshell/__init__.py

@@ -0,0 +1 @@
+from ._DshellInterpreteur.dshell_interpreter import DshellInterpreteur

dshellinterpreter-0.1.0.dist-info/METADATA

@@ -0,0 +1,34 @@
+Metadata-Version: 2.4
+Name: dshellInterpreter
+Version: 0.1.0
+Summary: A Discord bot interpreter for creating custom commands and automations.
+Home-page: https://github.com/BOXERRMD/Dshell_Interpreter
+Author: Chronos
+Author-email: vagabonwalybi@gmail.com
+License: MIT
+Project-URL: Bug Tracker, https://github.com/BOXERRMD/Dshell_Interpreter/issues
+Project-URL: Source, https://github.com/BOXERRMD/Dshell_Interpreter
+Keywords: discord bot interpreter automation commands
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: py-cord==2.6.1
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Dshell_Interpreter
+Python interpreter for Discord.

dshellinterpreter-0.1.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+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=IubzNzBtGEcbgkL_NJOWRY1oqE3Yb-ySDMUmoHKjGzM,2135
+Dshell/DISCORD_COMMANDS/dshell_message.py,sha256=jgSGBeDDHVy8u9fX2WN6wzh7I9WqVkeySlpmbJsBZjs,1919
+Dshell/_DshellInterpreteur/__init__.py,sha256=xy5-J-R3YmY99JF3NBHTRRLsComFxpjnCA5xacISctU,35
+Dshell/_DshellInterpreteur/dshell_interpreter.py,sha256=bjeSkdLw6dJucNnf-bISDT_vHCOvQ_qRl_-9GJ1rbjM,10780
+Dshell/_DshellParser/__init__.py,sha256=ONDfhZMvClqP_6tE8SLjp-cf3pXL-auQYnfYRrHZxC4,56
+Dshell/_DshellParser/ast_nodes.py,sha256=ArTyuk7AykJ3xKiW656BOdZg92YEwbfAlzZF1YQeZoA,5483
+Dshell/_DshellParser/dshell_parser.py,sha256=iSlrSwoLz_yL4nXHMnPvycRik9iJ-cRzkXZMHRZw5qo,13129
+Dshell/_DshellTokenizer/__init__.py,sha256=LIQSRhDx2B9pmPx5ADMwwD0Xr9ybneVLhHH8qrJWw_s,172
+Dshell/_DshellTokenizer/dshell_keywords.py,sha256=NFa4VdfX26X5lU1Ps05hZkZg5IyBDpG9WgT9L1oTckM,3617
+Dshell/_DshellTokenizer/dshell_token_type.py,sha256=Gp-Vg2P96oTaKpOEKGHAvER7l98mbcuwmapLVJgmoCI,937
+Dshell/_DshellTokenizer/dshell_tokenizer.py,sha256=9ycZhz2X2uvZynE0illgi5AhtNyR_c5o1KX-pwCP1xM,5692
+dshellinterpreter-0.1.0.dist-info/licenses/LICENSE,sha256=lNgcw1_xb7QENAQi3uHGymaFtbs0RV-ihiCd7AoLQjA,1082
+dshellinterpreter-0.1.0.dist-info/METADATA,sha256=hkfhSw9LZKtUrbxV9xF-tow1leliffWOpaz_ijj94To,1093
+dshellinterpreter-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dshellinterpreter-0.1.0.dist-info/top_level.txt,sha256=B4CMhtmchGwPQJLuqUy0GhRG-0cUGxKL4GqEbCiB_vE,7
+dshellinterpreter-0.1.0.dist-info/RECORD,,

dshellinterpreter-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

dshellinterpreter-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 BOXER
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

dshellinterpreter-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+Dshell