dshellInterpreter 1.1.4.2__tar.gz → 1.1.4.4__tar.gz

{dshellinterpreter-1.1.4.2 → dshellinterpreter-1.1.4.4}/Dshell/DISCORD_COMMANDS/__init__.py

@@ -6,3 +6,4 @@ from .dshell_role import *
 from .dshell_interaction import *
 from .dshell_embed import *
 from .utils import *
+from .dshell_file import *

dshellinterpreter-1.1.4.4/Dshell/DISCORD_COMMANDS/dshell_file.py

@@ -0,0 +1,68 @@
+from ..full_import import Message, Union, PartialMessage, Optional
+from ..DshellParser.ast_nodes import ListNode, AttachmentNode, FileNode
+
+from .utils.utils_message import utils_get_message
+from .utils.utils_type_validation import (_validate_required_file_node,
+                                          _validate_required_string,
+                                          _validate_optional_string,
+                                          _validate_required_bool)
+
+__all__ = [
+
+]
+
+async def dshell_get_message_files(ctx: Message, message: Union[str, int]) -> ListNode:
+    """
+    Récupère les fichiers d'un message
+    :param ctx:
+    :param message:
+    :return:
+    """
+
+    target_message = ctx if message is None else utils_get_message(ctx, message)
+
+    attachments_list: ListNode = ListNode([], 0)
+
+    if isinstance(target_message, PartialMessage):
+        target_message = await target_message.fetch()
+
+    for attachment in target_message.attachments:
+        attachments_list.add(AttachmentNode(attachment))
+
+    return attachments_list
+
+async def dshell_read_file(ctx: Message, file: AttachmentNode) -> str:
+    """
+    Lit en entier un fichier
+    :param ctx:
+    :param file:
+    :return:
+    """
+    _CMD = "rf"
+    _validate_required_file_node(file, 'file', _CMD)
+
+    return await file.read()
+
+async def dshell_write_file(ctx: Message,
+                            file: Optional[FileNode] = None,
+                            message: str = "",
+                            append: bool = False,
+                            filename: Optional[str] = None) -> FileNode:
+    """
+    Ecrit dans un fichier
+    :param ctx:
+    :param file:
+    :param message:
+    :param append:
+    :param filename:
+    :return:
+    """
+    _validate_required_string(message, 'message', 'wf')
+    _validate_required_bool(append, 'append', 'wf')
+    _validate_optional_string(filename, 'filename', 'wf')
+
+    target_file = file if isinstance(file, FileNode) else FileNode(filename)
+
+    target_file.write(bytearray(message, "utf-8"), append)
+
+    return target_file

{dshellinterpreter-1.1.4.2 → dshellinterpreter-1.1.4.4}/Dshell/DISCORD_COMMANDS/dshell_message.py

@@ -1,8 +1,9 @@
 from Dshell.full_import import (Message,
                            Embed,
-                           PartialMessage)
+                           PartialMessage,
+                                File)
 
-from ..DshellParser.ast_nodes import ListNode, EvalNode
+from ..DshellParser.ast_nodes import ListNode, FileNode
 
 from .utils.utils_message import utils_get_message, utils_autorised_mentions
 from .utils.utils_type_validation import (_validate_optional_number,
@@ -14,7 +15,9 @@ from .utils.utils_type_validation import (_validate_optional_number,
                                           _validate_required_bool,
                                           _validate_required_int,
                                           _validate_not_none,
-                                          _validate_optional_eval_group_node)
+                                          _validate_optional_eval_group_node,
+                                          _validate_optional_list_node,
+                                          _validate_required_file_node)
 from ..DshellInterpreteur.cached_messages import dshell_cached_messages
 
 from Dshell.full_import import Optional, Union, compile, DOTALL
@@ -55,6 +58,7 @@ async def dshell_send_message(ctx: Message,
                               users_mentions: bool = True,
                               reply_mention: bool = False,
                               embeds=None,
+                              files: Optional[ListNode] = None,
                               view=None) -> int:
     """
     Sends a message on Discord
@@ -67,6 +71,7 @@ async def dshell_send_message(ctx: Message,
     _validate_required_bool(roles_mentions, "Roles mentions", _CMD)
     _validate_required_bool(users_mentions, "Users mentions", _CMD)
     _validate_required_bool(reply_mention, "Reply mention", _CMD)
+    _validate_optional_list_node(files, "files", _CMD)
 
     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)
@@ -74,7 +79,13 @@ async def dshell_send_message(ctx: Message,
     if channel_to_send is None:
         raise Exception(f'Channel {channel} not found!')
 
+    if files is not None:
+        for file in files:
+            _validate_required_file_node(file, "file", _CMD)
 
+    final_files: list[File] = []
+    for file in files:
+        final_files.append(File(fp=file.content, filename=file.filename, description=file.description, spoiler=file.spoiler))
 
     _validate_optional_embed(embeds, "Embeds", _CMD)
 
@@ -90,7 +101,8 @@ async def dshell_send_message(ctx: Message,
                                                 delete_after=delete,
                                                 embeds=embeds,
                                                 allowed_mentions=allowed_mentions,
-                                                view=view)
+                                                view=view,
+                                                files=final_files)
 
     cached_messages = dshell_cached_messages.get()
     cached_messages[sended_message.id] = sended_message
@@ -108,6 +120,7 @@ async def dshell_respond_message(ctx: Message,
                                  users_mentions: bool = True,
                                  reply_mention: bool = False,
                                  delete=None,
+                                 files: Optional[ListNode] = None,
                                  embeds=None):
     """
     Responds to a message on Discord
@@ -121,11 +134,21 @@ async def dshell_respond_message(ctx: Message,
     _validate_required_bool(roles_mentions, "Roles mentions", _CMD)
     _validate_required_bool(users_mentions, "Users mentions", _CMD)
     _validate_required_bool(reply_mention, "Reply mention", _CMD)
+    _validate_optional_list_node(files, "files", _CMD)
 
     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)
     autorised_mentions = utils_autorised_mentions(global_mentions, everyone_mention, roles_mentions, users_mentions, reply_mention)
     mention_author = True if reply_mention else False
 
+    if files is not None:
+        for file in files:
+            _validate_required_file_node(file, "file", _CMD)
+
+    final_files: list[File] = []
+    for file in files:
+        final_files.append(
+            File(fp=file.content, filename=file.filename, description=file.description, spoiler=file.spoiler))
+
     _validate_optional_embed(embeds, "Embeds", _CMD)
 
     if embeds is None:
@@ -139,7 +162,8 @@ async def dshell_respond_message(ctx: Message,
                                      mention_author=mention_author,
                                      allowed_mentions=autorised_mentions,
                                      delete_after=delete,
-                                     embeds=embeds)
+                                     embeds=embeds,
+                                     files=final_files)
 
     cached_messages = dshell_cached_messages.get()
     cached_messages[sended_message.id] = sended_message
@@ -179,7 +203,7 @@ async def dshell_purge_message(ctx: Message, message_number: int, channel: Optio
     await purge_channel.purge(limit=message_number, reason=reason)
 
 
-async def dshell_edit_message(ctx: Message, message, new_content=None, embeds=None, view=None) -> int:
+async def dshell_edit_message(ctx: Message, message, new_content=None, embeds=None, view=None, files=None) -> int:
     """
     Edits a message
     """
@@ -188,8 +212,17 @@ async def dshell_edit_message(ctx: Message, message, new_content=None, embeds=No
     edit_message = utils_get_message(ctx, message)
 
     _validate_optional_embed(embeds, "Embeds", _CMD)
-
     _validate_optional_view(view, "View", _CMD)
+    _validate_optional_list_node(files, "files", _CMD)
+
+    if files is not None:
+        for file in files:
+            _validate_required_file_node(file, "file", _CMD)
+
+    final_files: list[File] = []
+    for file in files:
+        final_files.append(
+            File(fp=file.content, filename=file.filename, description=file.description, spoiler=file.spoiler))
 
     if embeds is None:
         embeds = ListNode([])
@@ -197,7 +230,7 @@ async def dshell_edit_message(ctx: Message, message, new_content=None, embeds=No
     elif isinstance(embeds, Embed):
         embeds = ListNode([embeds])
 
-    await edit_message.edit(content=new_content, embeds=embeds, view=view)
+    await edit_message.edit(content=new_content, embeds=embeds, view=view, files=final_files)
 
     return edit_message.id
 

{dshellinterpreter-1.1.4.2 → dshellinterpreter-1.1.4.4}/Dshell/DISCORD_COMMANDS/utils/utils_type_validation.py

@@ -14,11 +14,13 @@ __all__ = [
     "_validate_optional_code_node",
     "_validate_optional_list_node",
     "_validate_optional_eval_group_node",
+    "_validate_optional_file_node",
     "_validate_required_bool",
     "_validate_required_list_node",
     "_validate_required_int",
     "_validate_required_string",
     "_validate_required_dict",
+    "_validate_required_file_node",
     "_validate_missing_or_type",
     "_validate_not_none",
     "_validate_has_attribute",
@@ -153,6 +155,19 @@ def _validate_optional_list_node(value, param_name: str, command_name: str):
     if value is not None and not isinstance(value, ListNode):
         raise TypeError(f"[{command_name}] -> {param_name} must be a list, not {type(value).__name__}")
 
+def _validate_optional_file_node(value, param_name: str, command_name: str):
+        """
+        Validate that a optional value is a FileNode type.
+        :param value: The value to validate
+        :param param_name: The parameter name for error messages
+        :param command_name: The command name for error messages (optional)
+        :raises TypeError: If the value is not a FileNode
+        """
+        from ...DshellParser.ast_nodes import AttachmentNode
+
+        if value is not None and not isinstance(value, AttachmentNode):
+            raise TypeError(f"[{command_name}] -> {param_name} must be a FileNode, not {type(value).__name__}")
+
 
 # Required parameter validation functions
 
@@ -217,6 +232,21 @@ def _validate_required_dict(value, param_name: str, command_name: str):
     if not isinstance(value, dict):
         raise TypeError(f"[{command_name}] -> {param_name} must be a dict, not {type(value).__name__}")
 
+def _validate_required_file_node(value, param_name: str, command_name: str):
+    """
+    Validate that a required value is a FileNode type.
+    :param value: The value to validate
+    :param param_name: The parameter name for error messages
+    :param command_name: The command name for error messages (optional)
+    :raises TypeError: If the value is not a FileNode
+    """
+    from ...DshellParser.ast_nodes import AttachmentNode
+
+    if not isinstance(value, AttachmentNode):
+        raise TypeError(f"[{command_name}] -> {param_name} must be a FileNode, not {type(value).__name__}")
+
+
+
 
 # Validation functions for _MissingSentinel or other types
 

{dshellinterpreter-1.1.4.2 → dshellinterpreter-1.1.4.4}/Dshell/DshellParser/ast_nodes.py

@@ -1,5 +1,7 @@
-from Dshell.full_import import Any, randint, Optional, Union
+from Dshell.full_import import (Any, randint, Optional, Union, Attachment,
+                                HTTPException, Forbidden)
 from ..DshellTokenizer.dshell_token_type import Token
+from inspect import iscoroutinefunction
 
 __all__ = [
     'ASTNode',
@@ -30,7 +32,9 @@ __all__ = [
     'UiButtonNode',
     'UiSelectNode',
     'OptionUiSelectNode',
-    'ScanNode'
+    'ScanNode',
+    'AttachmentNode',
+    'FileNode'
 ]
 
 
@@ -943,3 +947,110 @@ class ListNode(ASTNode):
 
     def __repr__(self):
         return f"<LIST> - {self.iterable}"
+
+class AttachmentNode(ASTNode):
+
+    def __init__(self, attachment: Attachment):
+        super().__init__(0)
+        self.attachment = attachment
+
+    async def read(self):
+        """
+        Lit l'intégralité du fichier et le décode en utf-8
+        :return:
+        """
+        try:
+            filebytes: bytes = await self.attachment.read()
+            return filebytes.decode(encoding="utf-8", errors="ignore")
+        except Forbidden:
+            return b"The file is not accessible, the bot does not have permission to access it"
+        except HTTPException:
+            return b"Download file failed"
+        except Exception:
+            return b"An error occurred in the file read action"
+
+    async def read_sector(self, sector: int):
+        """
+        Lit tout le fichier secteur par secteur en les décodant en utf-8
+        :return:
+        """
+        try:
+            async for chunk in await self.attachment.read_chunked(sector):
+                yield chunk.decode(encoding="utf-8", errors="ignore")
+        except Forbidden:
+            yield b"The file is not accessible, the bot does not have permission to access it"
+        except HTTPException:
+            yield b"Download file failed"
+        except Exception:
+            yield b"An error occurred in the file read action"
+
+    def content_type(self):
+        return self.attachment.content_type
+
+    def desc(self):
+        return self.attachment.description
+
+    def description(self):
+        return self.attachment.description
+
+    def duration(self):
+        return self.attachment.duration_secs
+
+    def ephemeral(self):
+        return self.attachment.ephemeral
+
+    def url(self):
+        return self.attachment.url
+
+    def filename(self):
+        return self.attachment.filename
+
+    def size(self):
+        return self.attachment.size
+
+    def title(self):
+        return self.attachment.title
+
+    def height(self):
+        return self.attachment.height
+
+    def width(self):
+        return self.attachment.width
+
+    def signature(self):
+        return self.attachment.hm
+
+    def call(self, attribute: str):
+        """
+        Permet d'appeler une méthode de l'attachment
+        :param attribute: nom de la méthode à appeler
+        :return: le résultat de la méthode appelée
+        """
+        if hasattr(self, attribute) and attribute != 'call':
+            attr = getattr(self, attribute)
+            if not iscoroutinefunction(attr) and callable(attr):
+                return attr()
+            else:
+                raise AttributeError(f"'{attribute}' is not a callable method of the attachment !")
+        else:
+            raise AttributeError(f"The attachment does not have an attribute named '{attribute}' !")
+
+class FileNode(ASTNode):
+    def __init__(self, name: Optional[str], description: Optional[str] = None, spoiler: bool = False):
+        super().__init__(0)
+        self.name = name
+        self.description = description
+        self.spoiler = spoiler
+        self.content: bytearray = bytearray("", "utf-8")
+
+    def write(self, content: bytearray, append: bool):
+        if append:
+            self.content += content
+        else:
+            self.content = content
+
+    def read(self):
+        return self.content.decode(encoding="utf-8", errors="ignore")
+
+    def size(self):
+        return len(self.content)

{dshellinterpreter-1.1.4.2 → dshellinterpreter-1.1.4.4}/Dshell/DshellParser/dshell_parser.py

@@ -30,7 +30,7 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
         first_token_line = tokens_by_line[0]  # get the first token of the line
         last_block = blocks[-1]
 
-        line = pointer+1
+        line = first_token_line.position[0]
 
         if first_token_line.type == DTT.COMMAND:  # if the token is a command
             body = tokens_by_line[1:]  # get its arguments
@@ -42,7 +42,7 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
         elif first_token_line.type == DTT.KEYWORD:  # if it's a keyword
 
             if first_token_line.value == 'if':  # if it's a condition
-                if len(tokens_by_line) <= 1:
+                if len_tokens_by_line_since_command_name <= 0:
                     raise SyntaxError(f'[IF] Take one or more arguments on line {first_token_line.position} !')
 
                 if_node = IfNode(condition=tokens_by_line[1:],
@@ -67,7 +67,7 @@ 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:
+                if len_tokens_by_line_since_command_name <= 0:
                     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, line=line)
@@ -197,7 +197,7 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
                 return blocks, pointer
 
             elif first_token_line.value == 'eval':
-                if len(tokens_by_line) < 2:
+                if len_tokens_by_line_since_command_name < 1:
                     raise SyntaxError(f"[EVAL] take one or more arguments on line {first_token_line.position}")
 
                 if tokens_by_line[1].type != DTT.IDENT:
@@ -210,7 +210,7 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
             elif first_token_line.value == 'return':
                 if not isinstance(last_block, CodeNode):
                     raise SyntaxError(f"[RETURN] No code open on line {first_token_line.position} !")
-                if len(tokens_by_line) < 2:
+                if len_tokens_by_line_since_command_name < 1:
                     raise SyntaxError(f"[RETURN] take one or more arguments on line {first_token_line.position}")
 
                 return_node = ReturnNode(body=tokens_by_line[1:], line=line)
@@ -222,7 +222,7 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
 
             elif first_token_line.value == '#end':  # node pour arrêter le programme si elle est rencontré
                 error_message = True
-                if len(tokens_by_line) > 1:
+                if len_tokens_by_line_since_command_name > 0:
                     if tokens_by_line[1].type != DTT.BOOL:
                         raise TypeError(f'[#END] the variable given must be a boolean, not {tokens_by_line[1].type}')
                     else:
@@ -235,7 +235,7 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
         elif first_token_line.type == DTT.DISCORD_KEYWORD:
 
             if first_token_line.value == 'embed':
-                if len(tokens_by_line) <= 1:
+                if len_tokens_by_line_since_command_name <= 0:
                     raise SyntaxError(f'[EMBED] Take one or more arguments on line {first_token_line.position} !')
                 if tokens_by_line[1].type != DTT.IDENT:
                     raise TypeError(f'[EMBED] the variable given must be a ident, '
@@ -254,7 +254,7 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
                 return blocks, pointer
 
             elif first_token_line.value == 'field':
-                if len(tokens_by_line) <= 1:
+                if len_tokens_by_line_since_command_name <= 0:
                     raise SyntaxError(f'[FIELD] Take one or more arguments on line {first_token_line.position} !')
                 if not isinstance(last_block, EmbedNode):
                     raise SyntaxError(f'[FIELD] No embed open on line {first_token_line.position} !')
@@ -262,7 +262,7 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
                 last_block.fields.append(FieldEmbedNode(tokens_by_line[1:], line=line))
 
             elif first_token_line.value in ('perm', 'permission'):
-                if len(tokens_by_line) <= 1:
+                if len_tokens_by_line_since_command_name <= 0:
                     raise SyntaxError(f'[PERM] Take one argument on line {first_token_line.position} !')
                 if tokens_by_line[1].type != DTT.IDENT:
                     raise TypeError(f'[PERM] the variable given must be a ident, '
@@ -281,7 +281,7 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
                 return blocks, pointer
 
             elif first_token_line.value == 'button':
-                if len(tokens_by_line) <= 1:
+                if len_tokens_by_line_since_command_name <= 0:
                     raise SyntaxError(f'[BUTTON] Take one or more arguments on line {first_token_line.position} !')
                 if tokens_by_line[1].type != DTT.IDENT:
                     raise TypeError(f'[BUTTON] the variable given must be a ident, '
@@ -300,7 +300,7 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
                 return blocks, pointer
 
             elif first_token_line.value == 'select':
-                if len(tokens_by_line) <= 1:
+                if len_tokens_by_line_since_command_name <= 0:
                     raise SyntaxError(f'[SELECT] Take one or more arguments on line {first_token_line.position} !')
                 if tokens_by_line[1].type != DTT.IDENT:
                     raise TypeError(f'[SELECT] the variable given must be a ident, '
@@ -319,7 +319,7 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
                 return blocks, pointer
 
             elif first_token_line.value == 'option':
-                if len(tokens_by_line) <= 1:
+                if len_tokens_by_line_since_command_name <= 0:
                     raise SyntaxError(f'[OPTION] Take one or more arguments on line {first_token_line.position} !')
                 if not isinstance(last_block, UiSelectNode):
                     raise SyntaxError(f'[OPTION] No UISelect open on line {first_token_line.position} !')
@@ -329,10 +329,19 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
         ############################## AUTRE ##############################
 
         elif first_token_line.type in DTT_DATA:  # if the line starts with a data token, we consider it as a command with an implicit "sm" name
-            for token in tokens_by_line:
 
-                if token.type in DTT_DATA:
-                    last_block.body.append(CommandNode(name='sm', body=ArgsCommandNode([token], line=line), line=line))
+            if (len_tokens_by_line_since_command_name > 0 and
+                    tokens_by_line[1].type in (DTT.LOGIC_OPERATOR, DTT.MATHS_OPERATOR, DTT.LOGIC_WORD_OPERATOR)):
+
+                new_content = [first_token_line]
+                new_content.extend(tokens_by_line[1:])
+                last_block.body.append(VarNode(first_token_line, new_content, line=line))
+
+            else:
+                for token in tokens_by_line:
+
+                    if token.type in DTT_DATA:
+                        last_block.body.append(CommandNode(name='sm', body=ArgsCommandNode([token], line=line), line=line))
 
         else:
             last_block.body += tokens_by_line

{dshellinterpreter-1.1.4.2 → dshellinterpreter-1.1.4.4}/Dshell/DshellTokenizer/dshell_keywords.py

@@ -11,7 +11,7 @@ __all__ = [
 from ..DISCORD_COMMANDS import *
 
 from Dshell.full_import import Callable
-
+from ..DISCORD_COMMANDS.dshell_file import dshell_read_file, dshell_write_file, dshell_get_message_files
 
 dshell_keyword: set[str] = {
     'if', 'else', 'elif', 'loop', '#end', 'var', '#loop', '#if', 'sleep', 'param', '#param', 'code', '#code', 'eval', 'return'
@@ -81,6 +81,11 @@ dshell_commands: dict[str, Callable] = {
     ## Pastbin command
     "gp": dshell_get_pastbin,  # get pastbin
 
+    ## Files
+    "rf": dshell_read_file,
+    "wf": dshell_write_file,
+    "gmfs": dshell_get_message_files,
+
     ## Discord commands
     "sm": dshell_send_message,  # send message
     "spm": dshell_send_private_message,  # send private message
@@ -201,7 +206,8 @@ dshell_logical_operators: dict[str, tuple[Callable, int, int, int]] = {
     r"<": (lambda a, b: a < b, 4, 2, 2),
     r">": (lambda a, b: a > b, 4, 2, 2),
     r"!": (lambda a: not a, 3, 1, 1),
-    r"?": (lambda condition, first_choice, second_choice: first_choice if condition else second_choice, 1, 3, 3)
+    r"?": (lambda condition, first_choice, second_choice: first_choice if condition else second_choice, 1, 3, 3),
+    r".": (lambda target, attribute: target.call(attribute) if hasattr(target, attribute) and hasattr(target, 'call') else None, 9, 2, 2), # attribute access operator
 
 }
 

{dshellinterpreter-1.1.4.2 → dshellinterpreter-1.1.4.4}/Dshell/DshellTokenizer/dshell_tokenizer.py

@@ -55,12 +55,13 @@ 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|-)", flags=IGNORECASE),
     DTT.COMMAND: compile(rf"\b({'|'.join(dshell_commands.keys())})\b", flags=IGNORECASE),
-    DTT.MATHS_OPERATOR: compile(rf"({'|'.join([escape(i) for i in dshell_mathematical_operators.keys()])})"),
-    DTT.LOGIC_OPERATOR: compile(rf"({'|'.join([escape(i) for i in dshell_logical_operators.keys()])})"),
-    DTT.LOGIC_WORD_OPERATOR: compile(rf"(?:^|\s)({'|'.join([escape(i) for i in dshell_logical_word_operators.keys()])})(?:$|\s)"),
     DTT.FLOAT: compile(r"(\d+\.\d+)"),
     DTT.HEXA: compile(r"(0[Xx][0-9a-fA-F]+)"),
     DTT.INT: compile(r"(\d+)"),
+    DTT.MATHS_OPERATOR: compile(rf"({'|'.join([escape(i) for i in dshell_mathematical_operators.keys()])})"),
+    DTT.LOGIC_OPERATOR: compile(rf"({'|'.join([escape(i) for i in dshell_logical_operators.keys()])})"),
+    DTT.LOGIC_WORD_OPERATOR: compile(
+        rf"(?:^|\s)({'|'.join([escape(i) for i in dshell_logical_word_operators.keys()])})(?:$|\s)"),
     DTT.BOOL: compile(r"(True|False)", flags=IGNORECASE),
     DTT.NONE: compile(r"(None)", flags=IGNORECASE),
     DTT.IDENT: compile(rf"([A-Za-z0-9_]+)"),

{dshellinterpreter-1.1.4.2 → dshellinterpreter-1.1.4.4}/Dshell/full_import.py

@@ -7,9 +7,7 @@ from datetime import timedelta, datetime, UTC
 from requests import get
 
 from discord.ui import Button, Select
-from discord import (ButtonStyle, Interaction, Guild, Member, Role, Permissions, PermissionOverwrite, Message, MISSING,
-                     CategoryChannel, VoiceChannel, TextChannel, Thread, PartialMessage, NotFound, ForumChannel, Colour,
-                     Embed, AutoShardedBot, ComponentType, AllowedMentions)
+from discord import *
 from discord.abc import PrivateChannel
 from discord.utils import get, _MissingSentinel
 from contextvars import ContextVar

{dshellinterpreter-1.1.4.2/dshellInterpreter.egg-info → dshellinterpreter-1.1.4.4}/PKG-INFO

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

{dshellinterpreter-1.1.4.2 → dshellinterpreter-1.1.4.4/dshellInterpreter.egg-info}/PKG-INFO

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

{dshellinterpreter-1.1.4.2 → dshellinterpreter-1.1.4.4}/dshellInterpreter.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ Dshell/regex_test.py
 Dshell/DISCORD_COMMANDS/__init__.py
 Dshell/DISCORD_COMMANDS/dshell_channel.py
 Dshell/DISCORD_COMMANDS/dshell_embed.py
+Dshell/DISCORD_COMMANDS/dshell_file.py
 Dshell/DISCORD_COMMANDS/dshell_interaction.py
 Dshell/DISCORD_COMMANDS/dshell_member.py
 Dshell/DISCORD_COMMANDS/dshell_message.py

{dshellinterpreter-1.1.4.2 → dshellinterpreter-1.1.4.4}/setup.py

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