dshellInterpreter 0.2.15.4__py3-none-any.whl → 0.2.16.1__py3-none-any.whl

Dshell/DISCORD_COMMANDS/utils/utils_global.py

@@ -1,8 +1,59 @@
 __all__ = [
     "utils_len",
+    "utils_get_name",
+    "utils_get_id",
+    "utils_get_roles",
 ]
 
-async def utils_len(ctx, value):
+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:
@@ -12,4 +63,77 @@ async def utils_len(ctx, value):
     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)
+    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])

Dshell/DISCORD_COMMANDS/utils/utils_list.py

@@ -4,7 +4,8 @@ __all__ = [
     "utils_list_clear",
     "utils_list_pop",
     "utils_list_sort",
-    "utils_list_reverse"
+    "utils_list_reverse",
+    "utils_list_get_value",
 ]
 
 async def utils_list_add(ctx, value: "ListNode", *elements):
@@ -19,22 +20,25 @@ async def utils_list_add(ctx, value: "ListNode", *elements):
         raise TypeError("value must be a list in add command")
 
     for elem in elements:
-        value.add(elem)
+        if isinstance(elem, ListNode):
+            value.extend(elem)
+        else:
+            value.add(elem)
     return value
 
-async def utils_list_remove(ctx, value: "ListNode", *elements):
+async def utils_list_remove(ctx, value: "ListNode", element, count: int = 1):
     """
     Remove an element from a list
     :param value:
-    :param elements:
+    :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")
 
-    for elem in elements:
-        value.remove(elem)
+    value.remove(element, count)
     return value
 
 async def utils_list_clear(ctx, value: "ListNode"):
@@ -89,3 +93,17 @@ async def utils_list_reverse(ctx, 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,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]

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

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

Dshell/_DshellParser/ast_nodes.py

@@ -602,6 +602,14 @@ class ListNode(ASTNode):
         """
         self.iterable.reverse()
 
+    def extend(self, values: "ListNode"):
+        """
+        Extend the list with another list.
+        :param values: List of values to extend the list with.
+        """
+        for v in values:
+            self.add(v)
+
     def __add__(self, other: "ListNode"):
         """
         Add another ListNode to this one.

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,
@@ -37,9 +38,20 @@ dshell_commands: dict[str, Callable] = {
     'pop': utils_list_pop,
     'sort': utils_list_sort,
     '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.15.4.dist-info → dshellinterpreter-0.2.16.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dshellInterpreter
-Version: 0.2.15.4
+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.15.4.dist-info → dshellinterpreter-0.2.16.1.dist-info}/RECORD

@@ -8,21 +8,23 @@ Dshell/DISCORD_COMMANDS/dshell_message.py,sha256=zcWl6Y1W31h9MTHS-j9tLDwcrRiE_wG
 Dshell/DISCORD_COMMANDS/dshell_pastbin.py,sha256=H0tUJOwdzYBXvxqipK3mzoNZUKrSLcVm4EZlWbBRScs,796
 Dshell/DISCORD_COMMANDS/dshell_role.py,sha256=t_yRZRD0FKE2gT4dIDIsHz2PSZZztDVEkkqkG_OkNh4,5002
 Dshell/DISCORD_COMMANDS/utils/__init__.py,sha256=-amNcYysjgx3YDpDSnbQmJhnm3lbJere9K9aDH-YnJg,115
-Dshell/DISCORD_COMMANDS/utils/utils_global.py,sha256=JDueE5jCIosUziWNuzzW7iw6_RjgGfHEszJXKgU6FR8,387
-Dshell/DISCORD_COMMANDS/utils/utils_list.py,sha256=kJ1vgqdAKef-siAUvGwvKgD2ezMJpnFUP2UQ3v6-ARw,2569
+Dshell/DISCORD_COMMANDS/utils/utils_global.py,sha256=TRqKx8FBEJ4cAFfscN-ohx3ySq9tuGI16UAAnZgB5qw,4222
+Dshell/DISCORD_COMMANDS/utils/utils_list.py,sha256=zqImMWvD-1UnbPP1TZewnvZpq7qs1sOTT1YhbJ5I8h8,3160
+Dshell/DISCORD_COMMANDS/utils/utils_member.py,sha256=PbZk4Rzz87mktvJPTIvR2f0sXdMylzUWWM6vGEx2efk,998
 Dshell/DISCORD_COMMANDS/utils/utils_message.py,sha256=cQvJ15f49ddOjybARwkJKNFe3ITYQciF-pZHERFPkr0,2964
+Dshell/DISCORD_COMMANDS/utils/utils_permissions.py,sha256=N1Ttn-n1qG87AuOuz5Dlw-mEk8io5ogxxbhiuGmBtgA,3461
 Dshell/DISCORD_COMMANDS/utils/utils_thread.py,sha256=tVl4msEwrWHY-0AytI6eY3JSs-eIFUigDSJfK9mT1ww,1457
 Dshell/_DshellInterpreteur/__init__.py,sha256=xy5-J-R3YmY99JF3NBHTRRLsComFxpjnCA5xacISctU,35
-Dshell/_DshellInterpreteur/dshell_interpreter.py,sha256=OGn6HHPrlVWVI9z7s90edBqrv3Fv410A0rPYW8JP-Hs,32096
+Dshell/_DshellInterpreteur/dshell_interpreter.py,sha256=Us9eLIUbaKC5rRkPRjGWHlX9ZEFNYeOnwEW_w7LwPhI,28665
 Dshell/_DshellParser/__init__.py,sha256=ONDfhZMvClqP_6tE8SLjp-cf3pXL-auQYnfYRrHZxC4,56
-Dshell/_DshellParser/ast_nodes.py,sha256=m6a4bMFVb0grMCyghWMeb4xABxdlWxFBbycnR388dg0,18518
+Dshell/_DshellParser/ast_nodes.py,sha256=S2byqd02RMC-ILCX-ZS8zhwOBIBtvMtQ4ESnljjsWmA,18748
 Dshell/_DshellParser/dshell_parser.py,sha256=KD2ZbKYa1nnvroKmN8fIRD2exXre54Qx_roEBrTV7Mo,18588
 Dshell/_DshellTokenizer/__init__.py,sha256=LIQSRhDx2B9pmPx5ADMwwD0Xr9ybneVLhHH8qrJWw_s,172
-Dshell/_DshellTokenizer/dshell_keywords.py,sha256=4QvBXvuXJPjKWyhVqAPBYCqE95G7dG8waXD3XtmuoBw,6345
+Dshell/_DshellTokenizer/dshell_keywords.py,sha256=crzX16IbcYCVqxgzz3NvN0-FzKtBjZcZQvtHqdxhDGk,6787
 Dshell/_DshellTokenizer/dshell_token_type.py,sha256=gYIb2XN2YcgeRgmar_rBDS5CGmwfmxihu8mOW_d6lbE,1533
 Dshell/_DshellTokenizer/dshell_tokenizer.py,sha256=AJnUocD6hbU6wvjRAN5uDha5QQieTwXlHzZVtgRGaZQ,7307
-dshellinterpreter-0.2.15.4.dist-info/licenses/LICENSE,sha256=lNgcw1_xb7QENAQi3uHGymaFtbs0RV-ihiCd7AoLQjA,1082
-dshellinterpreter-0.2.15.4.dist-info/METADATA,sha256=FkIk1dGusH1JtAgBPDrT3FSPIDu3frzRXveXsjaWcC8,1151
-dshellinterpreter-0.2.15.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-dshellinterpreter-0.2.15.4.dist-info/top_level.txt,sha256=B4CMhtmchGwPQJLuqUy0GhRG-0cUGxKL4GqEbCiB_vE,7
-dshellinterpreter-0.2.15.4.dist-info/RECORD,,
+dshellinterpreter-0.2.16.1.dist-info/licenses/LICENSE,sha256=lNgcw1_xb7QENAQi3uHGymaFtbs0RV-ihiCd7AoLQjA,1082
+dshellinterpreter-0.2.16.1.dist-info/METADATA,sha256=0YtsSJdMbvebXArTm2kTLsPOH1UrGPp-x-0gjhWCHKU,1151
+dshellinterpreter-0.2.16.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dshellinterpreter-0.2.16.1.dist-info/top_level.txt,sha256=B4CMhtmchGwPQJLuqUy0GhRG-0cUGxKL4GqEbCiB_vE,7
+dshellinterpreter-0.2.16.1.dist-info/RECORD,,