dshellInterpreter 0.2.13.14__py3-none-any.whl → 0.2.13.16__py3-none-any.whl

Dshell/DISCORD_COMMANDS/dshell_interaction.py

@@ -4,11 +4,22 @@ __all__ = [
 ]
 
 from types import NoneType
-from discord import Interaction, Embed
+from discord import Interaction, Embed, AllowedMentions
 from pycordViews import EasyModifiedViews
 
-
-async def dshell_respond_interaction(ctx: Interaction, content: str = None, delete=None, mentions: bool = None, hide: bool = False, embeds=None, view=None) -> int:
+from .utils.utils_message import utils_autorised_mentions
+
+async def dshell_respond_interaction(ctx: Interaction,
+                                     content: str = None,
+                                     delete=None,
+                                     global_mentions: bool = None,
+                                     everyone_mention: bool = True,
+                                     roles_mentions: bool = True,
+                                     users_mentions: bool = True,
+                                     reply_mention: bool = False,
+                                     hide: bool = False,
+                                     embeds=None,
+                                     view=None) -> int:
     """
     Responds to a message interaction on Discord
     """
@@ -19,13 +30,14 @@ async def dshell_respond_interaction(ctx: Interaction, content: str = None, dele
     if delete is not None and not isinstance(delete, (int, float)):
         raise Exception(f'Delete parameter must be a number (seconds) or None, not {type(delete)} !')
 
-    if not isinstance(mentions, (NoneType, bool)):
-        raise Exception(f'Mention parameter must be a boolean or None, not {type(mentions)} !')
-
     if not isinstance(hide, bool):
         raise Exception(f'Hide parameter must be a boolean, not {type(hide)} !')
 
-    allowed_mentions = mentions if mentions is not None else False
+    allowed_mentions = utils_autorised_mentions(global_mentions,
+                                                everyone_mention,
+                                                roles_mentions,
+                                                users_mentions,
+                                                reply_mention)
 
     from .._DshellParser.ast_nodes import ListNode
 

Dshell/DISCORD_COMMANDS/dshell_message.py

@@ -1,12 +1,11 @@
 from re import search
-from tkinter import Listbox
 
-from discord import Embed, Message, Interaction
+from discord import Embed, Message
 from discord.ext import commands
 
 from pycordViews import EasyModifiedViews
 
-from .utils.utils_message import utils_get_message
+from .utils.utils_message import utils_get_message, utils_autorised_mentions
 from .._utils import NoneType
 
 __all__ = [
@@ -24,7 +23,17 @@ __all__ = [
 ]
 
 
-async def dshell_send_message(ctx: Message, message=None, delete=None, channel=None, embeds=None, view=None) -> int:
+async def dshell_send_message(ctx: Message,
+                              message=None,
+                              delete=None,
+                              channel=None,
+                              global_mentions: bool = None,
+                              everyone_mention: bool = True,
+                              roles_mentions: bool = True,
+                              users_mentions: bool = True,
+                              reply_mention: bool = False,
+                              embeds=None,
+                              view=None) -> int:
     """
     Sends a message on Discord
     """
@@ -33,6 +42,7 @@ async def dshell_send_message(ctx: Message, message=None, delete=None, channel=N
         raise Exception(f'Delete parameter must be a number (seconds) or None, not {type(delete)} !')
 
     channel_to_send = ctx.channel if channel is None else ctx.channel.guild.get_channel(channel)
+    allowed_mentions = utils_autorised_mentions(global_mentions, everyone_mention, roles_mentions, users_mentions, reply_mention)
 
     if channel_to_send is None:
         raise Exception(f'Channel {channel} not found!')
@@ -54,12 +64,22 @@ async def dshell_send_message(ctx: Message, message=None, delete=None, channel=N
     sended_message = await channel_to_send.send(message,
                                                 delete_after=delete,
                                                 embeds=embeds,
+                                                allowed_mentions=allowed_mentions,
                                                 view=view)
 
     return sended_message.id
 
 
-async def dshell_respond_message(ctx: Message, message=None, content: str = None, delete=None, mention: bool = None, embeds=None):
+async def dshell_respond_message(ctx: Message,
+                                 message=None,
+                                 content: str = None,
+                                 global_mentions: bool = None,
+                                 everyone_mention: bool = True,
+                                 roles_mentions: bool = True,
+                                 users_mentions: bool = True,
+                                 reply_mention: bool = False,
+                                 delete=None,
+                                 embeds=None):
     """
     Responds to a message on Discord
     """
@@ -67,7 +87,8 @@ async def dshell_respond_message(ctx: Message, message=None, content: str = None
         raise Exception(f'Delete parameter must be a number (seconds) or None, not {type(delete)} !')
 
     respond_message = ctx if message is None else utils_get_message(ctx, message)  # builds a reference to the message (even if it doesn't exist)
-    mention_author = mention if mention is not None else False
+    autorised_mentions = utils_autorised_mentions(global_mentions, everyone_mention, roles_mentions, users_mentions, reply_mention)
+    mention_author = True if reply_mention else False
 
     from .._DshellParser.ast_nodes import ListNode
 
@@ -83,6 +104,7 @@ async def dshell_respond_message(ctx: Message, message=None, content: str = None
     sended_message = await respond_message.reply(
                                      content=str(content),
                                      mention_author=mention_author,
+                                     allowed_mentions=autorised_mentions,
                                      delete_after=delete,
                                      embeds=embeds)
 

Dshell/DISCORD_COMMANDS/dshell_pastbin.py

@@ -6,14 +6,16 @@ __all__ = [
 ]
 
 
-async def dshell_get_pastbin(ctx: Message, code: str):
+async def dshell_get_pastbin(ctx: Message, code: str) -> "ListNode":
     """
     Get a pastbin from a code snippet.
     """
     if not isinstance(code, str):
         raise Exception(f'Code must be a string, not {type(code)} !')
 
-    content = ''  # Initialize content to an empty string
+    from .._DshellParser.ast_nodes import ListNode
+
+    content = ListNode([])  # Initialize content to an empty string
 
     with get(f"https://pastebin.com/raw/{code}", stream=True, timeout=10) as response:
 
@@ -21,10 +23,6 @@ async def dshell_get_pastbin(ctx: Message, code: str):
             raise Exception(f"Failed to retrieve pastbin with code {code} !")
 
         for line in response.iter_lines(decode_unicode=True, chunk_size=512):
-            len_content = len(content)
-            if len_content < 4000 and len_content + len(line) <= 4000:
-                content += line + '\n'
-            else:
-                break
+            content.add(line)
 
     return content

Dshell/DISCORD_COMMANDS/utils/utils_message.py

@@ -1,4 +1,4 @@
-from discord import Message, PartialMessage
+from discord import Message, PartialMessage, AllowedMentions
 from typing import Union
 from re import search
 
@@ -26,3 +26,43 @@ def utils_get_message(ctx: Message, message: Union[int, str]) -> PartialMessage:
         return ctx.guild.get_channel(channel_id).get_partial_message(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 not isinstance(global_mentions, (type(None), 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/_DshellInterpreteur/dshell_interpreter.py

@@ -4,7 +4,7 @@ from typing import TypeVar, Union, Any, Optional, Callable
 from random import choice
 from string import ascii_letters, digits
 from copy import deepcopy
-from pycordViews import SelectMenu, EasyModifiedViews
+from pycordViews import EasyModifiedViews
 
 from discord import AutoShardedBot, Embed, Colour, PermissionOverwrite, Permissions, Guild, Member, Role, Message, Interaction, ButtonStyle
 from discord.ui import Button
@@ -63,10 +63,18 @@ class DshellInterpreteur:
             '__guild__': message.channel.guild.id,
             '__guild_name__': message.channel.guild.name,
             '__guild_id__': message.channel.guild.id,
+            '__guild_members__': ListNode([member.id for member in message.channel.guild.members]),
             '__guild_member_count__': message.channel.guild.member_count,
             '__guild_icon__': message.channel.guild.icon.url if message.channel.guild.icon else None,
             '__guild_owner_id__': message.channel.guild.owner_id,
             '__guild_description__': message.channel.guild.description,
+            '__guild_roles__': ListNode([role.id for role in message.channel.guild.roles]),
+            '__guild_roles_count__': len(message.channel.guild.roles),
+            '__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_channels_count__': len(message.channel.guild.channels),
+
         } if message is not None or not debug else {} # {} is used in debug mode, when ctx is None
         self.vars = vars if vars is not None else ''
         self.ctx: context = ctx
@@ -140,6 +148,9 @@ class DshellInterpreteur:
                 elif isinstance(first_node, UiNode):
                     self.env[node.name.value] = build_ui(first_node, self)
 
+                elif isinstance(first_node, LengthNode):
+                    self.env[node.name.value] = length(first_node.body)
+
                 else:
                     self.env[node.name.value] = eval_expression(node.body, self)
 
@@ -382,6 +393,19 @@ def regroupe_commandes(body: list[Token], interpreter: DshellInterpreteur, norma
 
     return list_tokens
 
+def length(variable : LengthNode) -> int:
+    """
+    Count characters or items in string/list
+    :param variable:
+    :return:
+    """
+    if not isinstance(variable.body, ListNode) and variable.body.type not in (DTT.STR, DTT.IDENT):
+        raise Exception(f'Length take string, ident or list, not {type(variable.body)} !')
+
+    if isinstance(variable.body, ListNode):
+        return len(variable.body)
+    else:
+        return len(variable.body.value)
 
 def build_embed(body: list[Token], fields: list[FieldEmbedNode], interpreter: DshellInterpreteur) -> Embed:
     """

Dshell/_DshellParser/ast_nodes.py

@@ -5,6 +5,7 @@ from .._DshellTokenizer.dshell_token_type import Token
 
 __all__ = [
     'ASTNode',
+    'LengthNode',
     'StartNode',
     'ElseNode',
     'ElifNode',
@@ -257,6 +258,29 @@ class VarNode(ASTNode):
             "body": [token.to_dict() for token in self.body]
         }
 
+class LengthNode(ASTNode):
+    """
+    Node representing the length operation in the AST.
+    """
+
+    def __init__(self, body: Token):
+        """
+        :param body: list of tokens representing the body of the length operation
+        """
+        self.body = body
+
+    def __repr__(self):
+        return f"<LENGTH> - {self.body}"
+
+    def to_dict(self):
+        """
+        Convert the LengthNode to a dictionary representation.
+        :return: Dictionary representation of the LengthNode.
+        """
+        return {
+            "type": "LengthNode",
+            "body": self.body.to_dict()
+        }
 
 class EndNode(ASTNode):
     """

Dshell/_DshellParser/dshell_parser.py

@@ -10,6 +10,7 @@ __all__ = [
 from typing import Union
 
 from .ast_nodes import (ASTNode,
+                        LengthNode,
                         CommandNode,
                         IfNode,
                         LoopNode,
@@ -40,7 +41,7 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
     :param start_node: the node where to start the parsing
     """
     pointeur = 0  # pointeur sur les listes de tokens pour savoir ou parser
-    blocks: list[Union[ASTNode, EndNode]] = [start_node]  # liste d'imbrication des blocks pour gérer l'imbrication
+    blocks = [start_node]  # liste d'imbrication des blocks pour gérer l'imbrication
     len_token_lines = len(token_lines)
 
     while pointeur < len_token_lines:
@@ -59,6 +60,8 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
         elif first_token_line.type == DTT.KEYWORD:  # si c'est un mot clé
 
             if first_token_line.value == 'if':  # si c'est une condition
+                if len(tokens_by_line) <= 1:
+                    raise SyntaxError(f'[IF] Take one or more arguments on line {first_token_line.position} !')
                 if_node = IfNode(condition=tokens_by_line[1:],
                                  body=[])  # on crée la node avec les arguments de condition du if
                 last_block.body.append(if_node)
@@ -81,6 +84,8 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
             elif first_token_line.value == 'elif':
                 if not isinstance(last_block, (IfNode, ElifNode)):
                     raise SyntaxError(f'[ELIF] No conditional bloc open on line {first_token_line.position} !')
+                if len(tokens_by_line) <= 1:
+                    raise SyntaxError(f'[ELIF] Take one or more arguments on line {first_token_line.position} !')
                 elif_node = ElifNode(condition=tokens_by_line[1:], body=[],
                                      parent=last_block if isinstance(last_block, IfNode) else last_block.parent)
 
@@ -110,6 +115,15 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
                 blocks.append(else_node)
 
             elif first_token_line.value == 'loop':
+                if len(tokens_by_line) <= 2:
+                    raise SyntaxError(f'[LOOP] Take two arguments on line {first_token_line.position} !')
+                if tokens_by_line[1].type != DTT.IDENT:
+                    raise TypeError(f'[LOOP] the variable given must be a ident, '
+                                    f'not {tokens_by_line[1].type} in line {tokens_by_line[1].position}')
+                if tokens_by_line[2].type not in (DTT.IDENT, DTT.STR, DTT.INT, DTT.FLOAT, DTT.LIST):
+                    raise TypeError(f'[LOOP] the iterator must be a ident, string, integer, float or list, '
+                                    f'not {tokens_by_line[2].type} in line {tokens_by_line[2].position}')
+
                 loop_node = LoopNode(VarNode(tokens_by_line[1], to_postfix(tokens_by_line[2:])), body=[])
                 last_block.body.append(loop_node)
                 _, p = parse(token_lines[pointeur + 1:],
@@ -123,7 +137,12 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
                 return blocks, pointeur  # on renvoie les informations parsé à la dernière loop ouverte
 
             elif first_token_line.value == 'var':
-                var_node = VarNode(name=token_lines[pointeur][1], body=[])
+                if len(tokens_by_line) <= 2:
+                    raise SyntaxError(f'[VAR] Take two arguments on line {first_token_line.position} !')
+                if tokens_by_line[1].type != DTT.IDENT:
+                    raise TypeError(f'[VAR] the variable given must be a ident, '
+                                    f'not {tokens_by_line[1].type} in line {tokens_by_line[1].position}')
+                var_node = VarNode(name=tokens_by_line[1], body=[])
                 last_block.body.append(var_node)
                 result, status = parser_inline(tokens_by_line[
                                                2:])  # on fait en sorte de mettre les tokens de la ligne séparé par des retour à la ligne à chaque condition/else
@@ -134,10 +153,21 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
                     var_node.body = result[0]
 
             elif first_token_line.value == 'sleep':
+                if len(tokens_by_line) <= 1:
+                    raise SyntaxError(f'[SLEEP] Take one arguments on line {first_token_line.position} !')
+                if tokens_by_line[1].type != DTT.INT:
+                    raise TypeError(f'[SLEEP] the variable given must be an integer, '
+                                    f'not {tokens_by_line[1].type} in line {tokens_by_line[1].position}')
+
                 sleep_node = SleepNode(tokens_by_line[1:])
                 last_block.body.append(sleep_node)
 
             elif first_token_line.value == 'param':
+                if len(tokens_by_line) <= 1:
+                    raise SyntaxError(f'[PARAM] Take one arguments on line {first_token_line.position} !')
+                if tokens_by_line[1].type != DTT.IDENT:
+                    raise TypeError(f'[PARAM] the variable given must be a ident, '
+                                    f'not {tokens_by_line[1].type} in line {tokens_by_line[1].position}')
                 param_node = ParamNode(body=[])
                 last_block.body.append(param_node)
                 _, p = parse(token_lines[pointeur + 1:], param_node)
@@ -153,6 +183,14 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
                 end_node = EndNode()
                 last_block.body.append(end_node)
 
+            elif first_token_line.value in ('length', 'len'):
+                if len(tokens_by_line) != 2:
+                    raise SyntaxError(f"[LENGTH] Take 2 arguments on line {first_token_line.position} !")
+                if first_token_line.type not in (DTT.IDENT, DTT.STR, DTT.LIST):
+                    raise SyntaxError(f"[LENGTH] Take an ident, str or list on line {first_token_line.position}, not {first_token_line.type} !")
+                var_node = VarNode(tokens_by_line[1], body=[LengthNode(tokens_by_line[2])])
+                last_block.body.append(var_node)
+
         ############################## DISCORD KEYWORDS ##############################
 
         elif first_token_line.type == DTT.DISCORD_KEYWORD:

Dshell/_DshellTokenizer/dshell_keywords.py

@@ -18,7 +18,7 @@ from ..DISCORD_COMMANDS.dshell_role import *
 from ..DISCORD_COMMANDS.dshell_interaction import *
 
 dshell_keyword: set[str] = {
-    'if', 'else', 'elif', 'loop', '#end', 'var', '#loop', '#if', 'sleep', 'param', '#param'
+    'if', 'else', 'elif', 'loop', '#end', 'var', '#loop', '#if', 'sleep', 'param', '#param', 'length', 'len'
 }
 
 dshell_discord_keyword: set[str] = {
@@ -36,7 +36,7 @@ dshell_commands: dict[str, Callable] = {
     "em": dshell_edit_message,  # edit message
 
     "sri": dshell_respond_interaction,  # respond to an interaction
-    "di": dshell_defer_interaction,  # defer an interaction
+    "sdi": dshell_defer_interaction,  # defer an interaction
 
     "cc": dshell_create_text_channel,  # create channel
     "cvc": dshell_create_voice_channel,  # create voice channel

{dshellinterpreter-0.2.13.14.dist-info → dshellinterpreter-0.2.13.16.dist-info}/METADATA

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

{dshellinterpreter-0.2.13.14.dist-info → dshellinterpreter-0.2.13.16.dist-info}/RECORD

@@ -2,25 +2,25 @@ Dshell/__init__.py,sha256=pGd94FPy8kVXH_jH566HhApQPhbPfMPnZXzH_0dPWh0,93
 Dshell/_utils.py,sha256=PJ3fwn8IMqUMnW9oTwfr9v4--rzHIhhLQoVVqjwjoJU,23
 Dshell/DISCORD_COMMANDS/__init__.py,sha256=87-YpGU74m-m7AqUQni7PGbw73JRlioQkywW_61Whms,208
 Dshell/DISCORD_COMMANDS/dshell_channel.py,sha256=qpNe3oE5VyLCmOeCjWlt0rvaSBv2yrkmJgrRswrNOZM,15721
-Dshell/DISCORD_COMMANDS/dshell_interaction.py,sha256=f1DsMeMcI8t_54x-a9mW2pF5RSxNV0hf0ZV-Dt7p_qk,2540
+Dshell/DISCORD_COMMANDS/dshell_interaction.py,sha256=Gac3J9sCcPRHApIgSoS5MRAMJ0Hd7I-YywVQI0s26p0,3229
 Dshell/DISCORD_COMMANDS/dshell_member.py,sha256=5Iw-2dydhYMZOw2nx0svZP9JpZWHOXC0qkL9tClJHtw,8840
-Dshell/DISCORD_COMMANDS/dshell_message.py,sha256=VsZk-scVn-OgIKNYFCtWnAf5WowG2ODTa_pNG2ZEZgI,7813
-Dshell/DISCORD_COMMANDS/dshell_pastbin.py,sha256=TkWFGRRTvhhJgvwkDFx9Fz4UM2UUFwxyq0laMVx0mUk,881
+Dshell/DISCORD_COMMANDS/dshell_message.py,sha256=zcWl6Y1W31h9MTHS-j9tLDwcrRiE_wGOu78zu2k0y9I,9101
+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=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-Dshell/DISCORD_COMMANDS/utils/utils_message.py,sha256=Pn0ljyeCvRfY4tlWHrSbIsxSFZZ5J4lDaeVme3WHp9o,1239
+Dshell/DISCORD_COMMANDS/utils/utils_message.py,sha256=cQvJ15f49ddOjybARwkJKNFe3ITYQciF-pZHERFPkr0,2964
 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=ukWRqOYU9pmflnlxF8tgOuuU5I0dSXf5t95R4D2AJtc,27650
+Dshell/_DshellInterpreteur/dshell_interpreter.py,sha256=qHJ9WigNurvFvtEpVppNcHTV8hIiAA8AJLT_j0h4q-s,28862
 Dshell/_DshellParser/__init__.py,sha256=ONDfhZMvClqP_6tE8SLjp-cf3pXL-auQYnfYRrHZxC4,56
-Dshell/_DshellParser/ast_nodes.py,sha256=CXUG0rIJNh4jzMCgCcRqmQwU0WQoESQ-5FkuVtZZndM,17717
-Dshell/_DshellParser/dshell_parser.py,sha256=bNdqNV3A7VEv-hK9CVSDwFFKgS2oPX_7P5uc7TfK2xA,17559
+Dshell/_DshellParser/ast_nodes.py,sha256=fU6BVe6w78ZhYib7SGR7iAfTqWqS2kvwZ0d4wMxxOHk,18366
+Dshell/_DshellParser/dshell_parser.py,sha256=VdobGNR1KU2oENJ66bTqAE8i3emqAdCXGMZLdOpOEJs,20396
 Dshell/_DshellTokenizer/__init__.py,sha256=LIQSRhDx2B9pmPx5ADMwwD0Xr9ybneVLhHH8qrJWw_s,172
-Dshell/_DshellTokenizer/dshell_keywords.py,sha256=FY9iByZkNSI4r2M6LCDjjx65awZ_iQyFeOvjYmeK-6A,5860
+Dshell/_DshellTokenizer/dshell_keywords.py,sha256=euTckA4AsWBfBGMnFFi1YVz8dvXY1HNsQjNWtvARMR8,5878
 Dshell/_DshellTokenizer/dshell_token_type.py,sha256=gYIb2XN2YcgeRgmar_rBDS5CGmwfmxihu8mOW_d6lbE,1533
 Dshell/_DshellTokenizer/dshell_tokenizer.py,sha256=RrJA2XpcFH2vS6SnRIn5Own_uL5orIDvpq74t8xD3og,7350
-dshellinterpreter-0.2.13.14.dist-info/licenses/LICENSE,sha256=lNgcw1_xb7QENAQi3uHGymaFtbs0RV-ihiCd7AoLQjA,1082
-dshellinterpreter-0.2.13.14.dist-info/METADATA,sha256=8e63xZyweFZwrMI-n2DduWjtScIDHp_WelngI3zoD-A,1152
-dshellinterpreter-0.2.13.14.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-dshellinterpreter-0.2.13.14.dist-info/top_level.txt,sha256=B4CMhtmchGwPQJLuqUy0GhRG-0cUGxKL4GqEbCiB_vE,7
-dshellinterpreter-0.2.13.14.dist-info/RECORD,,
+dshellinterpreter-0.2.13.16.dist-info/licenses/LICENSE,sha256=lNgcw1_xb7QENAQi3uHGymaFtbs0RV-ihiCd7AoLQjA,1082
+dshellinterpreter-0.2.13.16.dist-info/METADATA,sha256=cA0Lz0ryUiDX9tZxs8kLrOAtpqYHpod0vLWor0aFeL0,1152
+dshellinterpreter-0.2.13.16.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dshellinterpreter-0.2.13.16.dist-info/top_level.txt,sha256=B4CMhtmchGwPQJLuqUy0GhRG-0cUGxKL4GqEbCiB_vE,7
+dshellinterpreter-0.2.13.16.dist-info/RECORD,,