dshellInterpreter 0.1.3__tar.gz → 0.1.6__tar.gz

{dshellinterpreter-0.1.3 → dshellinterpreter-0.1.6}/Dshell/DISCORD_COMMANDS/dshell_channel.py

@@ -1,7 +1,8 @@
 from asyncio import sleep
 from re import search
+from typing import Union
 
-from discord import MISSING
+from discord import MISSING, PermissionOverwrite, Member, Role
 from discord.abc import GuildChannel
 
 __all__ = [
@@ -10,8 +11,10 @@ __all__ = [
     'dshell_delete_channels'
 ]
 
+
 async def dshell_create_text_channel(ctx: GuildChannel, name, category=None, position=MISSING, slowmode=MISSING,
-                                     topic=MISSING, nsfw=MISSING):
+                                     topic=MISSING, nsfw=MISSING,
+                                     permission: dict[Union[Member, Role], PermissionOverwrite] = MISSING):
     """
     Crée un salon textuel sur le serveur
     """
@@ -23,7 +26,8 @@ async def dshell_create_text_channel(ctx: GuildChannel, name, category=None, pos
                                                           position=position,
                                                           slowmode_delay=slowmode,
                                                           topic=topic,
-                                                          nsfw=nsfw)
+                                                          nsfw=nsfw,
+                                                          overwrites=permission._values)
 
     return created_channel.id
 

{dshellinterpreter-0.1.3 → dshellinterpreter-0.1.6}/Dshell/DISCORD_COMMANDS/dshell_message.py

@@ -1,7 +1,6 @@
 from discord import Embed
 from discord.abc import GuildChannel
 
-from .._DshellParser.ast_nodes import ListNode
 
 __all__ = [
     'dshell_send_message',
@@ -9,8 +8,9 @@ __all__ = [
     'dshell_purge_message'
 ]
 
-async def dshell_send_message(ctx: GuildChannel, message=None, delete=None, channel=None, embeds: ListNode = None,
-                              embed=None):
+
+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
     """

{dshellinterpreter-0.1.3 → dshellinterpreter-0.1.6}/Dshell/_DshellInterpreteur/dshell_interpreter.py

@@ -2,13 +2,13 @@ from asyncio import sleep
 from re import findall
 from typing import TypeVar, Union, Any, Optional, Callable
 
-from discord import AutoShardedBot, Embed, Colour
+from discord import AutoShardedBot, Embed, Colour, PermissionOverwrite, Permissions, Guild, Member, Role
 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_keywords import *
 from .._DshellTokenizer.dshell_token_type import DshellTokenType as DTT
 from .._DshellTokenizer.dshell_token_type import Token
 from .._DshellTokenizer.dshell_tokenizer import DshellTokenizer
@@ -23,7 +23,7 @@ class DshellInterpreteur:
         """
         Interpreter Dshell code or AST.
         """
-        self.ast: StartNode = parse(DshellTokenizer(ast_or_code).start(), StartNode([]))[0]
+        self.ast: list[ASTNode] = parse(DshellTokenizer(ast_or_code).start(), StartNode([]))[0]
         self.env: dict[str, Any] = {}
         self.ctx: context = ctx
         if debug:
@@ -75,6 +75,9 @@ class DshellInterpreteur:
                 elif isinstance(first_node, EmbedNode):
                     self.env[node.name.value] = build_embed(first_node.body, first_node.fields, self)
 
+                elif isinstance(first_node, PermissionNode):
+                    self.env[node.name.value] = build_permission(first_node.body, self)
+
                 else:
                     self.env[node.name.value] = eval_expression(node.body, self)
 
@@ -93,6 +96,7 @@ class DshellInterpreteur:
 
                 await sleep(sleep_time)
 
+
             elif isinstance(node, EndNode):
                 raise RuntimeError(f"Execution interromput -> #end atteint")
 
@@ -110,6 +114,8 @@ class DshellInterpreteur:
             return float(token.value)
         elif token.type == DTT.BOOL:
             return token.value.lower() == "true"
+        elif token.type == DTT.NONE:
+            return None
         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
@@ -176,7 +182,7 @@ async def call_function(function: Callable, args: ArgsCommandNode, interpreter:
     """
     Appelle une fonction avec évaluation des arguments Dshell en valeurs Python
     """
-    reformatted = regroupe_commandes(args.body, interpreter)
+    reformatted = regroupe_commandes(args.body, interpreter)[0]
 
     # conversion des args en valeurs Python
     absolute_args = reformatted.pop('*', list())
@@ -190,7 +196,7 @@ async def call_function(function: Callable, args: ArgsCommandNode, interpreter:
     return await function(*absolute_args, **keyword_args)
 
 
-def regroupe_commandes(body: list[Token], interpreter: DshellInterpreteur) -> dict[Union[str, Token], list[Token]]:
+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 !
@@ -200,6 +206,7 @@ def regroupe_commandes(body: list[Token], interpreter: DshellInterpreteur) -> di
     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)
+    list_tokens: list[dict] = [tokens]
 
     i = 0
     while i < n:
@@ -208,26 +215,36 @@ def regroupe_commandes(body: list[Token], interpreter: DshellInterpreteur) -> di
             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
+
+        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
+            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
+            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
             i += 1
-    return tokens
+    return list_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: 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_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 = regroupe_commandes(field.body, interpreter)[0]
         a.pop('*')
         a: dict[str, Token]
         args_fields.append(a)
@@ -243,6 +260,21 @@ def build_embed(body: list[Token], fields: list[FieldEmbedNode], interpreter: Ds
     return embed
 
 
+def build_permission(body: list[Token], interpreter: DshellInterpreteur) -> dict[
+    Union[Member, Role], PermissionOverwrite]:
+    """
+    Construit un dictionnaire de permissions à partir des informations de la commande.
+    """
+    args_permissions: list[dict[str, list[Any]]] = regroupe_commandes(body, interpreter)
+    permissions: dict[Union[Member, Role], PermissionOverwrite] = {}
+
+    for i in args_permissions:
+        i.pop('*')
+        permissions.update(DshellPermissions(i).get_permission_overwrite(interpreter.ctx.guild))
+
+    print(args_permissions)
+
+
 class DshellIterator:
     """
     Utilisé pour transformer n'importe quoi en un iterable
@@ -267,3 +299,98 @@ class DshellIterator:
         value = self.data[self.current]
         self.current += 1
         return value
+
+
+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.
+        """
+        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
+        """
+        try:
+            member = DshellPermissions.get_member(guild, target_id)
+        except ValueError:
+            member = None
+
+        try:
+            role = DshellPermissions.get_role(guild, target_id)
+        except ValueError:
+            role = None
+
+        if member is not None:
+            return member
+
+        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
+        """
+        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}.")
+
+    @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
+        """
+        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}.")
+
+    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
+        """
+        permissions: dict[Union[Member, Role], PermissionOverwrite] = {}
+        target_keys = self.target.keys()
+
+        if 'members' in target_keys:
+            for member_id in self.target['members']:
+                member = self.get_member(guild, member_id)
+                permissions[member] = PermissionOverwrite.from_pair(
+                    allow=Permissions(permissions=self.target.get('allow', 0)),
+                    deny= Permissions(permissions=self.target.get('deny', 0))
+                )
+
+        elif 'roles' in target_keys:
+            for role_id in self.target['roles']:
+                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.")
+
+        return permissions

{dshellinterpreter-0.1.3 → dshellinterpreter-0.1.6}/Dshell/_DshellParser/ast_nodes.py

@@ -1,7 +1,8 @@
-from typing import Optional, Any
+from typing import Optional, Any, TYPE_CHECKING
 
 from .._DshellTokenizer.dshell_token_type import Token
 
+
 __all__ = [
     'ASTNode',
     'StartNode',
@@ -17,9 +18,11 @@ __all__ = [
     'EmbedNode',
     'SleepNode',
     'IdentOperationNode',
-    'ListNode'
+    'ListNode',
+    'PermissionNode'
 ]
 
+
 class ASTNode:
     pass
 
@@ -122,6 +125,14 @@ class EmbedNode(ASTNode):
         return f"<EMBED> - {self.body}"
 
 
+class PermissionNode(ASTNode):
+    def __init__(self, body: list[Token]):
+        self.body = body
+
+    def __repr__(self):
+        return f"<PERMISSION> - {self.body}"
+
+
 class SleepNode(ASTNode):
     def __init__(self, body: list[Token]):
         self.body = body

{dshellinterpreter-0.1.3 → dshellinterpreter-0.1.6}/Dshell/_DshellParser/dshell_parser.py

@@ -21,6 +21,7 @@ from .ast_nodes import (ASTNode,
                         IdentOperationNode,
                         EmbedNode,
                         FieldEmbedNode,
+                        PermissionNode,
                         StartNode)
 from .._DshellTokenizer.dshell_token_type import DshellTokenType as DTT
 from .._DshellTokenizer.dshell_token_type import Token
@@ -157,6 +158,19 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
                     raise SyntaxError(f'[FIELD] Aucun embed ouvert ligne {first_token_line.position} !')
                 last_block.fields.append(FieldEmbedNode(tokens_by_line[1:]))
 
+            elif first_token_line.value in ('perm', 'permission'):
+                perm_node = PermissionNode(body=[])
+                var_node = VarNode(tokens_by_line[1], body=[perm_node])
+                last_block.body.append(var_node)
+                _, p = parse(token_lines[pointeur + 1:], perm_node)
+                pointeur += p + 1
+
+            elif first_token_line.value in ('#perm', '#permission'):
+                if not isinstance(last_block, PermissionNode):
+                    raise SyntaxError(f'[#PERM] Aucun permission ouvert ligne {first_token_line.position} !')
+                blocks.pop()
+                return blocks, pointeur
+
         ############################## AUTRE ##############################
 
         elif first_token_line.type == DTT.IDENT:

{dshellinterpreter-0.1.3 → dshellinterpreter-0.1.6}/Dshell/_DshellTokenizer/dshell_keywords.py

@@ -6,7 +6,9 @@ __all__ = [
     "dshell_logical_operators",
     "dshell_operators"
 ]
+
 from typing import Callable
+
 from ..DISCORD_COMMANDS.dshell_channel import *
 from ..DISCORD_COMMANDS.dshell_message import *
 
@@ -15,9 +17,8 @@ dshell_keyword: set[str] = {
 }
 
 dshell_discord_keyword: set[str] = {
-    'embed', '#embed', 'field'
+    'embed', '#embed', 'field', 'perm', 'permission', '#perm', '#permission'
 }
-
 dshell_commands: dict[str, Callable] = {
     "sm": dshell_send_message,  # send message
     "dm": dshell_delete_message,
@@ -68,8 +69,6 @@ dshell_logical_operators: dict[str, tuple[Callable, int]] = {
 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

{dshellinterpreter-0.1.3 → dshellinterpreter-0.1.6}/Dshell/_DshellTokenizer/dshell_token_type.py

@@ -14,7 +14,8 @@ class DshellTokenType(Enum):
     INT = auto()
     FLOAT = auto()
     STR = auto()
-    BOOL = auto()
+    BOOL = auto(),
+    NONE = auto(),
     LIST = auto()
     CALL_ARGS = auto()
     DICT = auto()
@@ -23,7 +24,8 @@ class DshellTokenType(Enum):
     KEYWORD = auto()  # if, let, end, etc.
     DISCORD_KEYWORD = auto()  # embed, #embed...
     COMMAND = auto()
-    SEPARATOR = auto()
+    SEPARATOR = auto()  # --
+    SUB_SEPARATOR = auto(),  # ~~
     MATHS_OPERATOR = auto()  # ==, +, -, *, etc.
     LOGIC_OPERATOR = auto(),
     COMMENT = auto()  # lignes commençant par ##

{dshellinterpreter-0.1.3 → dshellinterpreter-0.1.6}/Dshell/_DshellTokenizer/dshell_tokenizer.py

@@ -23,12 +23,14 @@ table_regex: dict[DTT, Pattern] = {
     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.SUB_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.NONE: compile(r"(None)", flags=IGNORECASE),
     DTT.IDENT: compile(rf"([A-Za-z0-9_]+)")
 }
 

{dshellinterpreter-0.1.3 → dshellinterpreter-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dshellInterpreter
-Version: 0.1.3
+Version: 0.1.6
 Summary: A Discord bot interpreter for creating custom commands and automations.
 Home-page: https://github.com/BOXERRMD/Dshell_Interpreter
 Author: Chronos
@@ -31,4 +31,5 @@ Dynamic: requires-python
 Dynamic: summary
 
 # Dshell_Interpreter
+
 Python interpreter for Discord.

{dshellinterpreter-0.1.3 → dshellinterpreter-0.1.6}/README.md

@@ -1,2 +1,3 @@
 # Dshell_Interpreter
+
 Python interpreter for Discord.

{dshellinterpreter-0.1.3 → dshellinterpreter-0.1.6}/dshellInterpreter.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dshellInterpreter
-Version: 0.1.3
+Version: 0.1.6
 Summary: A Discord bot interpreter for creating custom commands and automations.
 Home-page: https://github.com/BOXERRMD/Dshell_Interpreter
 Author: Chronos
@@ -31,4 +31,5 @@ Dynamic: requires-python
 Dynamic: summary
 
 # Dshell_Interpreter
+
 Python interpreter for Discord.

{dshellinterpreter-0.1.3 → dshellinterpreter-0.1.6}/setup.py

@@ -5,14 +5,15 @@ with open("README.md", "r") as fh:
 
 setup(
     name="dshellInterpreter",
-    version="0.1.3",
+    version="0.1.6",
     author="Chronos",
     author_email="vagabonwalybi@gmail.com",
     description="A Discord bot interpreter for creating custom commands and automations.",
     long_description=long_description,
     long_description_content_type="text/markdown",
     url="https://github.com/BOXERRMD/Dshell_Interpreter",
-    packages=["Dshell", "Dshell._DshellInterpreteur", "Dshell._DshellTokenizer", "Dshell._DshellParser", "Dshell.DISCORD_COMMANDS"],
+    packages=["Dshell", "Dshell._DshellInterpreteur", "Dshell._DshellTokenizer", "Dshell._DshellParser",
+              "Dshell.DISCORD_COMMANDS"],
     install_requires=["py-cord==2.6.1"],
     classifiers=[
         "Programming Language :: Python :: 3",
@@ -26,4 +27,4 @@ setup(
         "Bug Tracker": "https://github.com/BOXERRMD/Dshell_Interpreter/issues",
         "Source": "https://github.com/BOXERRMD/Dshell_Interpreter"}
 
-)
+)