dshellInterpreter 0.2.21.7__py3-none-any.whl

Dshell/DISCORD_COMMANDS/utils/utils_global.py

@@ -0,0 +1,155 @@
+__all__ = [
+    "utils_len",
+    "utils_random",
+    "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, Optional
+from enum import StrEnum
+from random import random, choice
+
+
+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_random(ctx: Message, value: Optional["ListNode"] = None):
+    """
+    Return a random element from a list, or a random integer between 0 and value
+    :param value:
+    :return:
+    """
+    from ..._DshellParser.ast_nodes import ListNode
+    if value is not None and not isinstance(value, ListNode):
+        raise TypeError(f"value must be a list in random command, not {type(value)}")
+
+    if value is None:
+        return random()
+    return choice(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, member = 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 member.roles])

Dshell/DISCORD_COMMANDS/utils/utils_list.py

@@ -0,0 +1,109 @@
+__all__ = [
+    "utils_list_add",
+    "utils_list_remove",
+    "utils_list_clear",
+    "utils_list_pop",
+    "utils_list_sort",
+    "utils_list_reverse",
+    "utils_list_get_value",
+]
+
+async def utils_list_add(ctx, value: "ListNode", *elements):
+    """
+    Add an element to a list
+    :param value:
+    :param elements:
+    :return:
+    """
+    from ..._DshellParser.ast_nodes import ListNode
+    if not isinstance(value, ListNode):
+        raise TypeError("value must be a list in add command")
+
+    for elem in elements:
+        if isinstance(elem, ListNode):
+            value.extend(elem)
+        else:
+            value.add(elem)
+    return value
+
+async def utils_list_remove(ctx, value: "ListNode", element, count: int = 1):
+    """
+    Remove an element from a list
+    :param value:
+    :param element:
+    :param count:
+    :return:
+    """
+    from ..._DshellParser.ast_nodes import ListNode
+    if not isinstance(value, ListNode):
+        raise TypeError("value must be a list in remove command")
+
+    value.remove(element, count)
+    return value
+
+async def utils_list_clear(ctx, value: "ListNode"):
+    """
+    Clear a list
+    :param value:
+    :return:
+    """
+    from ..._DshellParser.ast_nodes import ListNode
+    if not isinstance(value, ListNode):
+        raise TypeError("value must be a list in clear command")
+    value.clear()
+    return value
+
+async def utils_list_pop(ctx, value: "ListNode", index: int = -1):
+    """
+    Pop an element from a list
+    :param value:
+    :param index:
+    :return:
+    """
+    from ..._DshellParser.ast_nodes import ListNode
+    if not isinstance(value, ListNode):
+        raise TypeError("value must be a list in pop command")
+    if not isinstance(index, int):
+        raise TypeError("index must be an integer in pop command")
+    return value.pop(index)
+
+async def utils_list_sort(ctx, value: "ListNode", reverse: bool = False):
+    """
+    Sort a list
+    :param value:
+    :param reverse:
+    :return:
+    """
+    from ..._DshellParser.ast_nodes import ListNode
+    if not isinstance(value, ListNode):
+        raise TypeError("value must be a list in sort command")
+    if not isinstance(reverse, bool):
+        raise TypeError("reverse must be a boolean in sort command")
+    value.sort(reverse=reverse)
+    return value
+
+async def utils_list_reverse(ctx, value: "ListNode"):
+    """
+    Reverse a list
+    :param value:
+    :return:
+    """
+    from ..._DshellParser.ast_nodes import ListNode
+    if not isinstance(value, ListNode):
+        raise TypeError("value must be a list in reverse command")
+    value.reverse()
+    return value
+
+async def utils_list_get_value(ctx, value: "ListNode", index: int = 0):
+    """
+    Get a value from a list
+    :param value:
+    :param index:
+    :return:
+    """
+    from ..._DshellParser.ast_nodes import ListNode
+    if not isinstance(value, ListNode):
+        raise TypeError("value must be a list in get command")
+    if not isinstance(index, int):
+        raise TypeError("index must be an integer in get command")
+    return value[index]

Dshell/DISCORD_COMMANDS/utils/utils_member.py

@@ -0,0 +1,30 @@
+__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: dict[None, 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, dict):
+        raise TypeError(f"permissions must be a permission bloc in has_perms command, not {type(permission)}")
+
+    if None not in permission:
+        raise ValueError(f"permissions must have simple 'allow' permission in has_perms command, not {permission.keys()}")
+
+    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[None].pair()[0]) == permission[None].pair()[0]

Dshell/DISCORD_COMMANDS/utils/utils_message.py

@@ -0,0 +1,78 @@
+from discord import Message, PartialMessage, AllowedMentions
+from typing import Union
+from re import search
+
+from ..._DshellInterpreteur.cached_messages import dshell_cached_messages
+
+def utils_get_message(ctx: Message, message: Union[int, str]) -> Union[PartialMessage, Message]:
+    """
+    Returns the message object of the specified message ID or link.
+    Message is only available in the same server as the command and in the same channel.
+    If the message is a link, it must be in the format: https://discord.com/channels/{guild_id}/{channel_id}/{message_id}
+    """
+    cached_messages = dshell_cached_messages.get()
+
+    if isinstance(message, int):
+        if message in cached_messages:
+            return cached_messages[message]
+
+        cached_messages[message] = ctx.channel.get_partial_message(message)
+        dshell_cached_messages.set(cached_messages)
+        return cached_messages[message]
+
+    elif isinstance(message, str):
+        match = search(r'https://discord\.com/channels/(\d+)/(\d+)/(\d+)', message)
+        if not match:
+            raise Exception("Invalid message link format. Use a valid Discord message link.")
+        guild_id = int(match.group(1))
+        channel_id = int(match.group(2))
+        message_id = int(match.group(3))
+
+        if guild_id != ctx.guild.id:
+            raise Exception("The message must be from the same server as the command !")
+
+        cached_messages[message_id] = ctx.guild.get_channel(channel_id).get_partial_message(message_id)
+        dshell_cached_messages.set(cached_messages)
+        return cached_messages[message_id]
+
+    raise Exception(f"Message must be an integer or a string, not {type(message)} !")
+
+
+def utils_autorised_mentions(global_mentions: bool = None,
+                            everyone_mention: bool = True,
+                            roles_mentions: bool = True,
+                            users_mentions: bool = True,
+                            reply_mention: bool = False) -> Union[bool, 'AllowedMentions']:
+    """
+    Returns the AllowedMentions object based on the provided parameters.
+    If global_mentions is set to True or False, it overrides all other parameters.
+    """
+
+    from discord import AllowedMentions
+
+    if global_mentions is not None and not isinstance(global_mentions, bool):
+        raise Exception(f'Mention parameter must be a boolean or None, not {type(global_mentions)} !')
+
+    if not isinstance(everyone_mention, bool):
+        raise Exception(f'Everyone mention parameter must be a boolean, not {type(everyone_mention)} !')
+
+    if not isinstance(roles_mentions, bool):
+        raise Exception(f'Roles mention parameter must be a boolean, not {type(roles_mentions)} !')
+
+    if not isinstance(users_mentions, bool):
+        raise Exception(f'Users mention parameter must be a boolean, not {type(users_mentions)} !')
+
+    if not isinstance(reply_mention, bool):
+        raise Exception(f'Reply mention parameter must be a boolean, not {type(reply_mention)} !')
+
+    if global_mentions is True:
+        return AllowedMentions.all()
+
+    elif global_mentions is False:
+        return AllowedMentions.none()
+
+    else:
+        return AllowedMentions(everyone=everyone_mention,
+                               roles=roles_mentions,
+                               users=users_mentions,
+                               replied_user=reply_mention)

Dshell/DISCORD_COMMANDS/utils/utils_permissions.py

@@ -0,0 +1,94 @@
+from typing import Union
+from discord import Guild, Member, Role, Permissions, PermissionOverwrite, Message
+
+from .utils_global import utils_what_discord_type_is, DiscordType
+
+async def utils_update_permissions(ctx: Message,
+                                   permission1: dict[Union[Member, Role, None], PermissionOverwrite],
+                                   permission2: dict[Union[Member, Role, None], PermissionOverwrite]) -> dict:
+
+    if not isinstance(permission1, dict):
+        raise ValueError(f"permission1 must be a permission block, not {type(permission1).__name__}")
+
+    if not isinstance(permission2, dict):
+        raise ValueError(f"permission2 must be a permission block, not {type(permission2).__name__}")
+
+    permission1.update(permission2)
+
+    return permission1
+
+
+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, None], 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
+        """
+        from ..._DshellParser.ast_nodes import ListNode
+        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
+                if role_id == guild.id:  # @everyone role
+                    role = guild.default_role
+                else:
+                    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

Dshell/DISCORD_COMMANDS/utils/utils_string.py

@@ -0,0 +1,157 @@
+__all__ = [
+    "utils_split_string",
+    "utils_upper_string",
+    "utils_lower_string",
+    "utils_title_string",
+    "utils_strip_string",
+    "utils_replace_string",
+    "utils_regex_findall",
+    "utils_regex_sub",
+    "utils_regex_search"
+]
+
+from discord import Message
+from re import search, findall, sub
+
+async def utils_split_string(ctx: Message, value: str, separator: str = ' ') -> "ListNode":
+    """
+    Split a string into a list of strings using the specified separator.
+    :param value:
+    :param separator:
+    :return:
+    """
+
+    if not isinstance(value, str):
+        raise TypeError(f"value must be a str in split command, not {type(value)}")
+
+    if not isinstance(separator, str):
+        raise TypeError(f"separator must be a str in split command, not {type(separator)}")
+
+    from ..._DshellParser.ast_nodes import ListNode
+
+    return ListNode(value.split(separator))
+
+async def utils_upper_string(ctx: Message, value: str) -> str:
+    """
+    Convert a string to uppercase.
+    :param value:
+    :return:
+    """
+
+    if not isinstance(value, str):
+        raise TypeError(f"value must be a str in upper command, not {type(value)}")
+
+    return value.upper()
+
+async def utils_lower_string(ctx: Message, value: str) -> str:
+    """
+    Convert a string to lowercase.
+    :param value:
+    :return:
+    """
+
+    if not isinstance(value, str):
+        raise TypeError(f"value must be a str in lower command, not {type(value)}")
+
+    return value.lower()
+
+async def utils_title_string(ctx: Message, value: str) -> str:
+    """
+    Convert a string to title case.
+    :param value:
+    :return:
+    """
+
+    if not isinstance(value, str):
+        raise TypeError(f"value must be a str in title command, not {type(value)}")
+
+    return value.title()
+
+async def utils_strip_string(ctx: Message, value: str) -> str:
+    """
+    Strip whitespace from the beginning and end of a string.
+    :param value:
+    :return:
+    """
+
+    if not isinstance(value, str):
+        raise TypeError(f"value must be a str in strip command, not {type(value)}")
+
+    return value.strip()
+
+async def utils_replace_string(ctx: Message, value: str, old: str, new: str) -> str:
+    """
+    Replace all occurrences of old with new in a string.
+    :param value:
+    :param old:
+    :param new:
+    :return:
+    """
+
+    if not isinstance(value, str):
+        raise TypeError(f"value must be a str in replace command, not {type(value)}")
+
+    if not isinstance(old, str):
+        raise TypeError(f"old must be a str in replace command, not {type(old)}")
+
+    if not isinstance(new, str):
+        raise TypeError(f"new must be a str in replace command, not {type(new)}")
+
+    return value.replace(old, new)
+
+async def utils_regex_findall(ctx: Message, regex: str, content: str = None) -> "ListNode":
+    """
+    Find all occurrences of a regex in a string.
+    :param regex:
+    :param content:
+    :return:
+    """
+
+    if not isinstance(regex, str):
+        raise Exception(f"Regex must be a string, not {type(regex)}!")
+
+    if content is not None and not isinstance(content, str):
+        raise Exception(f"Content must be a string, not {type(content)}!")
+
+    from ..._DshellParser.ast_nodes import ListNode
+
+    return ListNode(findall(regex, content if content is not None else ctx.content))
+
+
+async def utils_regex_sub(ctx: Message, regex: str, replace: str, content: str = None) -> str:
+    """
+    Replace all occurrences of a regex in a string with a replacement string.
+    :param regex:
+    :param replace:
+    :param content:
+    :return:
+    """
+
+    if not isinstance(regex, str):
+        raise Exception(f"Regex must be a string, not {type(regex)}!")
+
+    if not isinstance(replace, str):
+        raise Exception(f"Replacement must be a string, not {type(replace)}!")
+
+    if content is not None and not isinstance(content, str):
+        raise Exception(f"Content must be a string, not {type(content)}!")
+
+    return sub(regex, replace, content if content is not None else ctx.content)
+
+async def utils_regex_search(ctx: Message, regex: str, content: str = None) -> str:
+    """
+    Search for a regex in a string.
+    :param regex:
+    :param content:
+    :return:
+    """
+
+    if not isinstance(regex, str):
+        raise Exception(f"Regex must be a string, not {type(regex)}!")
+
+    if content is not None and not isinstance(content, str):
+        raise Exception(f"Content must be a string, not {type(content)}!")
+
+    result = search(regex, content if content is not None else ctx.content)
+
+    return result.group() if result else ''

Dshell/DISCORD_COMMANDS/utils/utils_thread.py

@@ -0,0 +1,35 @@
+from discord import Message, Thread
+from discord.errors import NotFound
+
+from typing import Union
+from re import search
+
+
+async def utils_get_thread(ctx: Message, thread: Union[int, str]) -> Thread:
+    """
+    Returns the thread object of the specified thread ID or link.
+    Thread is only available in the same server as the command and in the same channel.
+    If the thread is a link, it must be in the format: https://discord.com/channels/{guild_id}/{channel_id}/{message_id}
+    """
+
+    if isinstance(thread, int):
+        return ctx.channel.get_thread(thread)
+
+    elif isinstance(thread, str):
+        match = search(r'https://discord\.com/channels/(\d+)/(\d+)(/\d+)?', thread)
+        if not match:
+            raise Exception("Invalid thread link format. Use a valid Discord thread link.")
+        guild_id = int(match.group(1))
+        message_id = int(match.group(2))
+        channel_id = ctx.channel.id if len(match.groups()) == 3 else ctx.channel.id
+
+        if guild_id != ctx.guild.id:
+            raise Exception("The thread must be from the same server as the command !")
+
+        try:
+            c = await ctx.guild.get_channel(channel_id).fetch_message(message_id)
+            return c.thread
+        except NotFound:
+            raise Exception(f"Thread with ID {message_id} not found in channel {channel_id} !")
+
+    raise Exception(f"Thread must be an integer or a string, not {type(thread)} !")

Dshell/_DshellInterpreteur/__init__.py

@@ -0,0 +1,4 @@
+from .dshell_interpreter import *
+from .errors import *
+from .cached_messages import dshell_cached_messages
+from .dshell_arguments import DshellArguments

Dshell/_DshellInterpreteur/cached_messages.py

@@ -0,0 +1,4 @@
+from contextvars import ContextVar
+
+# used to save all viewed messages in the current scoop
+dshell_cached_messages = ContextVar('dshell_cached_messages')