dshellInterpreter 0.1.4__tar.gz → 0.1.7__tar.gz

{dshellinterpreter-0.1.4 → dshellinterpreter-0.1.7}/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)
 
     return created_channel.id
 

{dshellinterpreter-0.1.4 → dshellinterpreter-0.1.7}/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.4 → dshellinterpreter-0.1.7}/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, PermissionOverwrite, Permissions
+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
@@ -182,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())
@@ -196,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[Any]]:
+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 !
@@ -206,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:
@@ -214,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[Any]] = 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)
@@ -248,28 +259,20 @@ def build_embed(body: list[Token], fields: list[FieldEmbedNode], interpreter: Ds
 
     return embed
 
-def build_permission(body: list[Token], interpreter: DshellInterpreteur) -> PermissionOverwrite:
+
+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: dict[Union[str, Token], list[Any]] = regroupe_commandes(body, interpreter)
-    args_permissions.pop('*')  # on enlève les paramètres non spécifié pour les permissions
-    args_permissions: dict[str, Token]  # on précise se qu'il contient dorénavant
-
-    permissions = PermissionOverwrite()
-
-    for key, value in args_permissions.items():
-
-        if key == 'allowed':
-            permissions.update(**PermissionOverwrite.from_pair(Permissions(value), Permissions())._values)
-
-        elif key == 'denied':
-            permissions.update(**PermissionOverwrite.from_pair(Permissions(), Permissions(value))._values)
+    args_permissions: list[dict[str, list[Any]]] = regroupe_commandes(body, interpreter)
+    permissions: dict[Union[Member, Role], PermissionOverwrite] = {}
 
-        else:
-            permissions.update(**{key: value})
+    for i in args_permissions:
+        i.pop('*')
+        permissions.update(DshellPermissions(i).get_permission_overwrite(interpreter.ctx.guild))
 
-    return permissions
+    print(args_permissions)
 
 
 class DshellIterator:
@@ -296,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.4 → dshellinterpreter-0.1.7}/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',
@@ -21,6 +22,7 @@ __all__ = [
     'PermissionNode'
 ]
 
+
 class ASTNode:
     pass
 
@@ -122,6 +124,7 @@ class EmbedNode(ASTNode):
     def __repr__(self):
         return f"<EMBED> - {self.body}"
 
+
 class PermissionNode(ASTNode):
     def __init__(self, body: list[Token]):
         self.body = body

{dshellinterpreter-0.1.4 → dshellinterpreter-0.1.7}/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 *
 
@@ -14,7 +16,6 @@ dshell_keyword: set[str] = {
     'if', 'else', 'elif', 'loop', '#end', 'var', '#loop', '#if', 'sleep'
 }
 
-
 dshell_discord_keyword: set[str] = {
     'embed', '#embed', 'field', 'perm', 'permission', '#perm', '#permission'
 }
@@ -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.4 → dshellinterpreter-0.1.7}/Dshell/_DshellTokenizer/dshell_token_type.py

@@ -24,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.4 → dshellinterpreter-0.1.7}/Dshell/_DshellTokenizer/dshell_tokenizer.py

@@ -23,6 +23,7 @@ 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)"),

{dshellinterpreter-0.1.4 → dshellinterpreter-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dshellInterpreter
-Version: 0.1.4
+Version: 0.1.7
 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.4 → dshellinterpreter-0.1.7}/README.md

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

{dshellinterpreter-0.1.4 → dshellinterpreter-0.1.7}/dshellInterpreter.egg-info/PKG-INFO

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

@@ -5,14 +5,15 @@ with open("README.md", "r") as fh:
 
 setup(
     name="dshellInterpreter",
-    version="0.1.4",
+    version="0.1.7",
     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"}
 
-)
+)