dshellInterpreter 0.2.16.0__tar.gz → 0.2.16.1__tar.gz

dshellinterpreter-0.2.16.1/Dshell/DISCORD_COMMANDS/utils/utils_global.py

@@ -0,0 +1,139 @@
+__all__ = [
+    "utils_len",
+    "utils_get_name",
+    "utils_get_id",
+    "utils_get_roles",
+]
+
+from discord import Message, Role, TextChannel, VoiceChannel, CategoryChannel, ForumChannel, Thread, Member, Guild
+from discord.utils import get
+from typing import Union
+from enum import StrEnum
+
+
+class DiscordType(StrEnum):
+    MEMBER = "member"
+    ROLE = "role"
+    TEXT_CHANNEL = "text_channel"
+    VOICE_CHANNEL = "voice_channel"
+    CATEGORY_CHANNEL = "category_channel"
+    FORUM_CHANNEL = "forum_channel"
+    THREAD = "thread"
+    UNKNOWN = "unknown"
+
+def utils_what_discord_type_is(ctx: Union[Message, Guild], value: int) -> tuple[str, Union[Member, Role, TextChannel, VoiceChannel, CategoryChannel, ForumChannel, Thread, None]]:
+    """
+    Return an enum of what the value is (str, int, list, Member, Role, Channel, etc.)
+    :param ctx:
+    :param value:
+    :return:
+    """
+    guild = ctx if isinstance(ctx, Guild) else ctx.guild
+
+    if member := guild.get_member(value):
+        return DiscordType.MEMBER, member
+
+    elif role := guild.get_role(value):
+        return DiscordType.ROLE, role
+
+    elif (channel := guild.get_channel(value)) and isinstance(channel, TextChannel):
+        return DiscordType.TEXT_CHANNEL, channel
+
+    elif (channel := guild.get_channel(value)) and isinstance(channel, VoiceChannel):
+        return DiscordType.VOICE_CHANNEL, channel
+
+    elif (channel := guild.get_channel(value)) and isinstance(channel, CategoryChannel):
+        return DiscordType.CATEGORY_CHANNEL, channel
+
+    elif (channel := guild.get_channel(value)) and isinstance(channel, ForumChannel):
+        return DiscordType.FORUM_CHANNEL, channel
+
+    elif (channel := guild.get_channel(value)) and isinstance(channel, Thread):
+        return DiscordType.THREAD, channel
+    else:
+        return DiscordType.UNKNOWN, None
+
+async def utils_len(ctx: Message, value):
+    """
+    Return the length of a list, or a string
+    :param value:
+    :return:
+    """
+    from ..._DshellParser.ast_nodes import ListNode
+    if not isinstance(value, (str, ListNode)):
+        raise TypeError(f"value must be a list or a string in len command, not {type(value)}")
+
+    return len(value)
+
+async def utils_get_name(ctx : Message, value: int) -> Union[str, None]:
+    """
+    Return the name of a role, member, or channel.
+    If not found, return None.
+    :param value:
+    :return:
+    """
+
+    if not isinstance(value, int):
+        raise TypeError(f"value must be an int in name command, not {type(value)}")
+
+    guild = ctx.guild
+    result = None
+
+    if role := guild.get_role(value):
+        result = role.name
+
+    elif member := guild.get_member(value):
+        result = member.name
+
+    if channel := guild.get_channel(value) :
+        result = channel.name
+
+    return result
+
+async def utils_get_id(ctx : Message, value: str) -> Union[int, None]:
+    """
+    Return the id of a role, member, or channel.
+    If not found, return None.
+    :param value:
+    :return:
+    """
+
+    if not isinstance(value, str):
+        raise TypeError(f"value must be a str in id command, not {type(value)}")
+
+    guild = ctx.guild
+    result = None
+
+    if role := get(guild.roles, name=value):
+        result = role.id
+
+    elif member := get(guild.members, name=value):
+        result = member.id
+
+    if channel := get(guild.channels, name=value) :
+        result = channel.id
+
+    return result
+
+async def utils_get_roles(ctx: Message, value: int):
+    """
+    Return the roles of a member.
+    :param value:
+    :return:
+    """
+
+    if not isinstance(value, int):
+        raise TypeError(f"value must be an int in roles command, not {type(value)}")
+
+    guild = ctx.guild
+
+    what_is = utils_what_discord_type_is(ctx, value)
+
+    if what_is == DiscordType.UNKNOWN:
+        raise ValueError(f"{value} member not found in guild {guild.name}")
+
+    if what_is != DiscordType.MEMBER:
+        raise TypeError(f"value must be a member id in roles command, not {what_is}")
+
+    from ..._DshellParser.ast_nodes import ListNode
+    return ListNode([i.id for i in guild.get_member(value).roles])

{dshellinterpreter-0.2.16.0 → dshellinterpreter-0.2.16.1}/Dshell/DISCORD_COMMANDS/utils/utils_list.py

@@ -94,7 +94,7 @@ async def utils_list_reverse(ctx, value: "ListNode"):
     value.reverse()
     return value
 
-async def utils_list_get_value(ctx, value: "ListNode", index: int):
+async def utils_list_get_value(ctx, value: "ListNode", index: int = 0):
     """
     Get a value from a list
     :param value:

dshellinterpreter-0.2.16.1/Dshell/DISCORD_COMMANDS/utils/utils_member.py

@@ -0,0 +1,27 @@
+__all__ = [
+    "utils_has_permissions",
+]
+from discord import Message, PermissionOverwrite
+
+from .utils_global import utils_what_discord_type_is, DiscordType
+
+async def utils_has_permissions(ctx: Message, member: int, permission: PermissionOverwrite) -> bool:
+    """
+    Return True if the member has the specified permissions.
+    :param member:
+    :param permission:
+    :return:
+    """
+
+    if not isinstance(member, int):
+        raise TypeError(f"member must be an int in has_perms command, not {type(member)}")
+
+    if not isinstance(permission, PermissionOverwrite):
+        raise TypeError(f"permissions must be a permission bloc in has_perms command, not {type(permission)}")
+
+    discord_type, member = utils_what_discord_type_is(ctx, member)
+
+    if discord_type != DiscordType.MEMBER:
+        raise ValueError(f"No member found with ID {member} in has_perms command.")
+
+    return (member.guild_permissions & permission.pair()[0]) == permission.pair()[0]

dshellinterpreter-0.2.16.1/Dshell/DISCORD_COMMANDS/utils/utils_permissions.py

@@ -0,0 +1,77 @@
+from typing import Union, TYPE_CHECKING
+from discord import Guild, Member, Role, Permissions, PermissionOverwrite
+
+from ..._DshellParser.ast_nodes import ListNode
+from .utils_global import utils_what_discord_type_is, DiscordType
+
+class DshellPermissions:
+
+    def __init__(self, target: dict[str, list[int]]):
+        """
+        Creates a Dshell permissions object.
+        :param target: A dictionary containing parameters and their values.
+        Expected parameters: “allow”, “deny”, ‘members’, “roles”.
+        For “members” and “roles”, values must be ID ListNodes.
+        """
+        self.target: dict[str, Union[ListNode, int]] = target
+
+    @staticmethod
+    def get_member(guild, member_id: int) -> Member:
+        """
+        Return a Member object from a member ID.
+        :param member_id:
+        :return:
+        """
+        discord_type, instance = utils_what_discord_type_is(guild, member_id)
+        if discord_type == DiscordType.MEMBER:
+            return instance
+        raise ValueError(f"No member found with ID {member_id} in perm command.")
+
+    @staticmethod
+    def get_role(guild, role_id: int) -> Role:
+        """
+        Return a Role object from a role ID.
+        :param role_id:
+        :return:
+        """
+        discord_type, instance = utils_what_discord_type_is(guild, role_id)
+        if discord_type == DiscordType.ROLE:
+            return instance
+        raise ValueError(f"No role found with ID {role_id} in perm command.")
+
+    def get_permission_overwrite(self, guild: Guild) -> dict[Union[Member, Role], PermissionOverwrite]:
+        """
+        Returns a PermissionOverwrite object with member and role permissions.
+        If no members or roles are specified, it returns a PermissionOverwrite with None key.
+        :param guild: The Discord server
+        :return: A dictionary of PermissionOverwrite objects with members and roles as keys
+        """
+        permissions: dict[Union[Member, Role, None], PermissionOverwrite] = {}
+        target_keys = self.target.keys()
+
+        if 'members' in target_keys:
+            for member_id in (
+                    self.target['members'] if isinstance(self.target['members'], ListNode) else [
+                        self.target['members']]):  # allow a single ID
+                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'] if isinstance(self.target['roles'], ListNode) else [
+                        self.target['roles']]):  # allow a single ID
+                role = self.get_role(guild, role_id)
+                permissions[role] = PermissionOverwrite.from_pair(
+                    allow=Permissions(permissions=self.target.get('allow', 0)),
+                    deny=Permissions(permissions=self.target.get('deny', 0))
+                )
+        else:
+            permissions[None] = PermissionOverwrite.from_pair(
+                allow=Permissions(permissions=self.target.get('allow', 0)),
+                deny=Permissions(permissions=self.target.get('deny', 0))
+            )
+
+        return permissions

{dshellinterpreter-0.2.16.0 → dshellinterpreter-0.2.16.1}/Dshell/_DshellInterpreteur/dshell_interpreter.py

@@ -10,6 +10,7 @@ from discord.ui import Button
 from discord.abc import PrivateChannel
 
 from .._DshellParser.ast_nodes import *
+from ..DISCORD_COMMANDS.utils.utils_permissions import DshellPermissions
 from .._DshellParser.dshell_parser import parse
 from .._DshellParser.dshell_parser import to_postfix, print_ast
 from .._DshellTokenizer.dshell_keywords import *
@@ -72,6 +73,11 @@ class DshellInterpreteur:
             '__guild_emojis__': ListNode([emoji.id for emoji in message.channel.guild.emojis]),
             '__guild_emojis_count__': len(message.channel.guild.emojis),
             '__guild_channels__': ListNode([channel.id for channel in message.channel.guild.channels]),
+            '__guild_text_channels__': ListNode([channel.id for channel in message.channel.guild.text_channels]),
+            '__guild_voice_channels__': ListNode([channel.id for channel in message.channel.guild.voice_channels]),
+            '__guild_categories__': ListNode([channel.id for channel in message.channel.guild.categories]),
+            '__guild_stage_channels__': ListNode([channel.id for channel in message.channel.guild.stage_channels]),
+            '__guild_forum_channels__': ListNode([channel.id for channel in message.channel.guild.forum_channels]),
             '__guild_channels_count__': len(message.channel.guild.channels),
 
         } if message is not None and not debug else {} # {} is used in debug mode, when ctx is None
@@ -102,7 +108,9 @@ class DshellInterpreteur:
                 await self.execute(node.body)
 
             if isinstance(node, CommandNode):
-                self.env['__ret__'] = await call_function(dshell_commands[node.name], node.body, self)
+                result = await call_function(dshell_commands[node.name], node.body, self)
+                self.env[f'__{node.name}__'] = result # return value of the command
+                self.env['__ret__'] = result  # global return variable for all commands
 
             elif isinstance(node, ParamNode):
                 params = get_params(node, self)
@@ -627,105 +635,3 @@ class DshellIterator:
         return value
 
 
-class DshellPermissions:
-
-    def __init__(self, target: dict[str, list[int]]):
-        """
-        Creates a Dshell permissions object.
-        :param target: A dictionary containing parameters and their values.
-        Expected parameters: “allow”, “deny”, ‘members’, “roles”.
-        For “members” and “roles”, values must be ID ListNodes.
-        """
-        self.target: dict[str, Union[ListNode, int]] = target
-
-    @staticmethod
-    def get_instance(guild: Guild, target_id: int) -> Union[Member, Role]:
-        """
-        Returns the instance corresponding to the given id. Only a Member or Role.
-        :param guild: The Discord server in which to search
-        :param target_id: The ID of the member or role
-        :return: An instance of Member or Role
-        """
-        try:
-            member = DshellPermissions.get_member(guild, target_id)
-        except ValueError:
-            member = None
-
-        try:
-            role = DshellPermissions.get_role(guild, target_id)
-        except ValueError:
-            role = None
-
-        if member is not None:
-            return member
-
-        elif role is not None:
-            return role
-
-        else:
-            raise ValueError(f"No member or role found with ID {target_id} in guild {guild.name}.")
-
-    @staticmethod
-    def get_member(guild: Guild, target_id: int) -> Member:
-        """
-        Returns the Member instance corresponding to the given id.
-        :param guild: The Discord server to search
-        :param target_id: The member ID
-        :return: A Member instance
-        """
-        member = guild.get_member(target_id)
-        if member is not None:
-            return member
-
-        raise ValueError(f"No member found with ID {target_id} in guild {guild.name}.")
-
-    @staticmethod
-    def get_role(guild: Guild, target_id: int) -> Role:
-        """
-        Returns the Role instance corresponding to the given id.
-        :param guild: The Discord server to search
-        :param target_id: The role ID
-        :return: A Role instance
-        """
-        role = guild.get_role(target_id)
-        if role is not None:
-            return role
-
-        raise ValueError(f"No role found with ID {target_id} in guild {guild.name}.")
-
-    def get_permission_overwrite(self, guild: Guild) -> dict[Union[Member, Role], PermissionOverwrite]:
-        """
-        Returns a PermissionOverwrite object with member and role permissions.
-        If no members or roles are specified, it returns a PermissionOverwrite with None key.
-        :param guild: The Discord server
-        :return: A dictionary of PermissionOverwrite objects with members and roles as keys
-        """
-        permissions: dict[Union[Member, Role, None], PermissionOverwrite] = {}
-        target_keys = self.target.keys()
-
-        if 'members' in target_keys:
-            for member_id in (
-                    self.target['members'] if isinstance(self.target['members'], ListNode) else [
-                        self.target['members']]):  # allow a single ID
-                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'] if isinstance(self.target['roles'], ListNode) else [
-                        self.target['roles']]):  # allow a single ID
-                role = self.get_role(guild, role_id)
-                permissions[role] = PermissionOverwrite.from_pair(
-                    allow=Permissions(permissions=self.target.get('allow', 0)),
-                    deny=Permissions(permissions=self.target.get('deny', 0))
-                )
-        else:
-            permissions[None] = PermissionOverwrite.from_pair(
-                allow=Permissions(permissions=self.target.get('allow', 0)),
-                deny=Permissions(permissions=self.target.get('deny', 0))
-            )
-
-        return permissions

{dshellinterpreter-0.2.16.0 → dshellinterpreter-0.2.16.1}/Dshell/_DshellTokenizer/dshell_keywords.py

@@ -10,7 +10,6 @@ __all__ = [
 
 from typing import Callable
 
-from ..DISCORD_COMMANDS import utils_len, utils_list_add
 from ..DISCORD_COMMANDS.dshell_channel import *
 from ..DISCORD_COMMANDS.dshell_member import *
 from ..DISCORD_COMMANDS.dshell_message import *
@@ -19,6 +18,7 @@ from ..DISCORD_COMMANDS.dshell_role import *
 from ..DISCORD_COMMANDS.dshell_interaction import *
 from ..DISCORD_COMMANDS.utils.utils_global import *
 from ..DISCORD_COMMANDS.utils.utils_list import *
+from ..DISCORD_COMMANDS.utils.utils_member import *
 
 dshell_keyword: set[str] = {
     'if', 'else', 'elif', 'loop', '#end', 'var', '#loop', '#if', 'sleep', 'param', '#param'
@@ -29,6 +29,7 @@ dshell_discord_keyword: set[str] = {
 }
 dshell_commands: dict[str, Callable] = {
 
+    ## List utils
     'length': utils_len,
     'len': utils_len,
     'add': utils_list_add,
@@ -39,8 +40,18 @@ dshell_commands: dict[str, Callable] = {
     'reverse': utils_list_reverse,
     'get': utils_list_get_value,
 
+    ## Discord utils
+    'name': utils_get_name, # get the name from id (channel, role, member)
+    'id': utils_get_id, # get the id from name (channel, role, member)
+    'roles': utils_get_roles, # get all roles of a member
+
+    ## Member utils
+    'has_perms': utils_has_permissions, # check if a member has the specified permissions
+
+    ## Pastbin command
     "gp": dshell_get_pastbin,  # get pastbin
 
+    ## Discord commands
     "sm": dshell_send_message,  # send message
     "spm": dshell_send_private_message,  # send private message
     "srm": dshell_respond_message,  # respond to a message

{dshellinterpreter-0.2.16.0/dshellInterpreter.egg-info → dshellinterpreter-0.2.16.1}/PKG-INFO

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

{dshellinterpreter-0.2.16.0 → dshellinterpreter-0.2.16.1/dshellInterpreter.egg-info}/PKG-INFO

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

{dshellinterpreter-0.2.16.0 → dshellinterpreter-0.2.16.1}/dshellInterpreter.egg-info/SOURCES.txt

@@ -13,7 +13,9 @@ Dshell/DISCORD_COMMANDS/dshell_role.py
 Dshell/DISCORD_COMMANDS/utils/__init__.py
 Dshell/DISCORD_COMMANDS/utils/utils_global.py
 Dshell/DISCORD_COMMANDS/utils/utils_list.py
+Dshell/DISCORD_COMMANDS/utils/utils_member.py
 Dshell/DISCORD_COMMANDS/utils/utils_message.py
+Dshell/DISCORD_COMMANDS/utils/utils_permissions.py
 Dshell/DISCORD_COMMANDS/utils/utils_thread.py
 Dshell/_DshellInterpreteur/__init__.py
 Dshell/_DshellInterpreteur/dshell_interpreter.py

{dshellinterpreter-0.2.16.0 → dshellinterpreter-0.2.16.1}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r") as fh:
 
 setup(
     name="dshellInterpreter",
-    version="0.2.16.0",
+    version="0.2.16.1",
     author="Chronos",
     author_email="vagabonwalybi@gmail.com",
     description="A Discord bot interpreter for creating custom commands and automations.",

dshellinterpreter-0.2.16.0/Dshell/DISCORD_COMMANDS/utils/utils_global.py

@@ -1,15 +0,0 @@
-__all__ = [
-    "utils_len",
-]
-
-async def utils_len(ctx, value):
-    """
-    Return the length of a list, or a string
-    :param value:
-    :return:
-    """
-    from ..._DshellParser.ast_nodes import ListNode
-    if not isinstance(value, (str, ListNode)):
-        raise TypeError(f"value must be a list or a string in len command, not {type(value)}")
-
-    return len(value)