dshellInterpreter 0.2.21.7__py3-none-any.whl

Dshell/_DshellTokenizer/dshell_tokenizer.py

@@ -0,0 +1,146 @@
+__all__ = [
+    "DshellTokenizer",
+    "table_regex",
+    "MASK_CHARACTER"
+]
+
+from re import DOTALL, IGNORECASE, ASCII
+from re import compile, Pattern, finditer, escape, sub, findall
+
+from .dshell_keywords import *
+from .dshell_token_type import DshellTokenType as DTT
+from .dshell_token_type import Token
+
+MASK_CHARACTER = '§'
+
+table_regex: dict[DTT, Pattern] = {
+    DTT.PARAMETERS: compile(rf"--\*\s*(\w+)\s*", flags=ASCII),
+    DTT.STR_PARAMETER: compile(rf"--\'\s*(\w+)\s*", flags=ASCII),
+    DTT.PARAMETER: compile(rf"--\s*(\w+)\s*", flags=ASCII),
+    DTT.STR: compile(r'"((?:[^\\"]|\\.)*)"', flags=DOTALL),
+    DTT.COMMENT: compile(r"::(.*?)$"),
+    DTT.EVAL_GROUP: compile(r"`(.*?)`"),
+    DTT.LIST: compile(r"\[(.*?)\]"),
+    DTT.MENTION: compile(r'<(?:@!?|@&|#)([0-9]+)>'),
+    DTT.SUB_SEPARATOR: compile(rf"(~~)"),
+    DTT.KEYWORD: compile(rf"(?<!\w)(#?{'|'.join(dshell_keyword)})(?!\w)"),
+    DTT.DISCORD_KEYWORD: compile(rf"(?<!\w|-)(#?{'|'.join(dshell_discord_keyword)})(?!\w|-)"),
+    DTT.COMMAND: compile(rf"\b({'|'.join(dshell_commands.keys())})\b"),
+    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.INT: compile(r"(\d+)"),
+    DTT.BOOL: compile(r"(True|False)", flags=IGNORECASE),
+    DTT.NONE: compile(r"(None)", flags=IGNORECASE),
+    DTT.IDENT: compile(rf"([A-Za-z0-9_]+)")
+}
+
+
+class DshellTokenizer:
+
+    def __init__(self, code: str):
+        """
+        Init le tokenizer.
+        :param code: Le code à tokenizer
+        """
+        self.code: str = code
+
+    def start(self):
+        """
+        Démarre le tokenizer pour qu'il traîte le code actuel.
+        Renvoie un tableau de tokens par ligne (séparé normalement pas des \n)
+        """
+        splited_commandes = self.split(self.code)
+        return self.tokenizer(splited_commandes)
+
+    def tokenizer(self, commandes_lines: list[str]) -> list[list[Token]]:
+        """
+        Tokenize chaque ligne de code
+        :param commandes_lines: Le code séparé en plusieurs lignes par la méthode split
+        """
+        tokens: list[list[Token]] = []
+
+        line_number = 1
+        for ligne in commandes_lines:  # iter chaque ligne du code
+            tokens_par_ligne: list[Token] = []
+
+            for token_type, pattern in table_regex.items():  # iter la table de régex pour tous les tester sur la ligne
+
+                for match in finditer(pattern, ligne):  # iter les résultat du match pour avoir leur position
+
+                    start_match = match.start()  # position de début du match
+
+                    if token_type != DTT.COMMENT:  # si ce n'est pas un commentaire
+                        token = Token(token_type, match.group(1), (line_number, start_match))  # on enregistre son token
+                        tokens_par_ligne.append(token)
+
+                        if token_type == DTT.STR:
+                            token.value = token.value.replace(r'\"', '"')
+
+                        if token_type in (
+                                DTT.LIST,
+                                DTT.EVAL_GROUP):  # si c'est un regroupement de donnée, on tokenize ce qu'il contient
+                            result = self.tokenizer([token.value])
+                            token.value = result[0] if len(
+                                result) > 0 else result  # gère si la structure de donnée est vide ou non
+
+                            for token_in_list in token.value:
+                                token_in_list.position = (line_number, token_in_list.position[1])
+
+                            for token_in_line in range(len(tokens_par_ligne)-1):
+                                if tokens_par_ligne[token_in_line].position[1] > start_match:
+                                    str_tokens_in_list = tokens_par_ligne[token_in_line:-1]
+                                    tokens_par_ligne = tokens_par_ligne[:token_in_line] + [tokens_par_ligne[-1]]
+                                    token.value.extend(str_tokens_in_list)
+                                    token.value.sort(key=lambda t: t.position[1])  # trie les tokens par rapport à leur position
+                                    break
+
+                    len_match = len(match.group(0))  # longueur du match trouvé
+                    ligne = ligne[:start_match] + (MASK_CHARACTER * len_match) + ligne[
+                                                                                   match.end():]  # remplace la match qui vient d'avoir lieu pour ne pas le rematch une seconde fois
+
+            tokens_par_ligne.sort(key=lambda
+                token: token.position[1])  # trie la position par rapport aux positions de match des tokens pour les avoir dans l'ordre du code
+            if tokens_par_ligne:
+                tokens.append(tokens_par_ligne)
+
+            line_number += 1  # incrémente le numéro de ligne pour la prochaine ligne
+
+        return tokens
+
+    @staticmethod
+    def split(commande: str, global_split='\n', garder_carractere_regroupant=True, carractere_regroupant='"') -> list[
+        str]:
+        """
+        Sépare les commandes en une liste en respectant les chaînes entre guillemets.
+        Echapper les caractères regroupants avec un antislash (\) pour les inclure dans la chaîne.
+        :param commande: La chaîne de caractères à découper.
+        :param global_split: Le séparateur utilisé (par défaut '\n').
+        :param garder_carractere_regroupant: Si False, enlève les guillemets autour des chaînes.
+        :param caractere_regroupant: Le caractère utilisé pour regrouper une chaîne (par défaut '"').
+        :return: Une liste des commandes découpées avec les chaînes restaurées.
+        """
+
+        commandes: str = commande.strip()
+        remplacement_temporaire = '[REMPLACER]'
+        pattern_find_regrouped_part = compile(fr'({carractere_regroupant}(?:[^\\{carractere_regroupant}]|\\.)*{carractere_regroupant})', flags=DOTALL)
+        entre_caractere_regroupant = findall(pattern_find_regrouped_part, commandes)  # repère les parties entre guillemets et les save
+
+        res = sub(pattern_find_regrouped_part,
+                  remplacement_temporaire,
+                  commandes,
+                  )  # remplace les parties entre guillemets
+
+        res = res.split(global_split)  # split les commandes sans les guillemets
+
+        # remet les guillemets à leurs place
+        result = []
+        for i in res:
+            while remplacement_temporaire in i:
+                i = i.replace(remplacement_temporaire,
+                              entre_caractere_regroupant[0][1: -1] if not garder_carractere_regroupant else
+                              entre_caractere_regroupant[0], 1)
+                entre_caractere_regroupant.pop(0)
+            result.append(i)
+        return result

Dshell/__init__.py

@@ -0,0 +1,3 @@
+from ._DshellInterpreteur.dshell_interpreter import DshellInterpreteur
+from ._DshellInterpreteur.errors import *
+from ._utils import *

Dshell/_utils.py

@@ -0,0 +1 @@
+NoneType = type(None)

dshellinterpreter-0.2.21.7.dist-info/METADATA

@@ -0,0 +1,37 @@
+Metadata-Version: 2.4
+Name: dshellInterpreter
+Version: 0.2.21.7
+Summary: A Discord bot interpreter for creating custom commands and automations.
+Home-page: https://github.com/BOXERRMD/Dshell_Interpreter
+Author: Chronos
+Author-email: vagabonwalybi@gmail.com
+License: MIT
+Project-URL: Bug Tracker, https://github.com/BOXERRMD/Dshell_Interpreter/issues
+Project-URL: Source, https://github.com/BOXERRMD/Dshell_Interpreter
+Keywords: discord bot interpreter automation commands
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: py-cord==2.6.1
+Requires-Dist: requests
+Requires-Dist: pycordviews
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Dshell_Interpreter
+
+Python interpreter for Discord.

dshellinterpreter-0.2.21.7.dist-info/RECORD

@@ -0,0 +1,34 @@
+Dshell/__init__.py,sha256=gEgfeYoyHn4bUepMd0F-MSx36rR8WgQGxNpgDKo2qbA,136
+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=Zpgrhh8XGbrG7XGZqyeGsoMJFsVtmIl7Cpw8OtngiI4,23883
+Dshell/DISCORD_COMMANDS/dshell_interaction.py,sha256=5FA8JZ2_v98ZzOZl6EKyjo_fUQC7FuK6C6hij6ZSP30,3495
+Dshell/DISCORD_COMMANDS/dshell_member.py,sha256=5Iw-2dydhYMZOw2nx0svZP9JpZWHOXC0qkL9tClJHtw,8840
+Dshell/DISCORD_COMMANDS/dshell_message.py,sha256=CHbNHF5hInGfL9xjKTID-rnlRZipwyRtTJD9bPxmMUc,15315
+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=X5F-fFCXD8Y7sia0b2q-7Fr1-MJj-aL5EupT-bAejzc,234
+Dshell/DISCORD_COMMANDS/utils/utils_global.py,sha256=G_gH9iF6roT-0QR2FUZj6_P1ADr06JrxZgELOy9yIP8,4768
+Dshell/DISCORD_COMMANDS/utils/utils_list.py,sha256=zqImMWvD-1UnbPP1TZewnvZpq7qs1sOTT1YhbJ5I8h8,3160
+Dshell/DISCORD_COMMANDS/utils/utils_member.py,sha256=1EoHooxwijc7AFJGnuae3ccjQk0x69MELtZ5ES5abLY,1165
+Dshell/DISCORD_COMMANDS/utils/utils_message.py,sha256=jHHgtUOw_5gTJMawfKlODQveBBRl6yillmJ-uzubh2o,3450
+Dshell/DISCORD_COMMANDS/utils/utils_permissions.py,sha256=sCM7brCBOU4_WmLzcyrGYITgXVI4cdbQGZzWd97YKw8,4232
+Dshell/DISCORD_COMMANDS/utils/utils_string.py,sha256=2LvJG_PR_VkPdnsw0vKNTwhEQGNog-3gFd_rZIUpGKc,4709
+Dshell/DISCORD_COMMANDS/utils/utils_thread.py,sha256=tVl4msEwrWHY-0AytI6eY3JSs-eIFUigDSJfK9mT1ww,1457
+Dshell/_DshellInterpreteur/__init__.py,sha256=03qR_fbu7UqzkQWNTUzSXwJUZgvQGMVJDOn31PHqcAY,158
+Dshell/_DshellInterpreteur/cached_messages.py,sha256=BJuITd--iITD95MMuwCWVo2HPPlolIZ5FZVSLkTLVD4,156
+Dshell/_DshellInterpreteur/dshell_arguments.py,sha256=cV9SHqOLAR-aIvkQocry1WaWc5ujyE5rh92g4Qwgj5A,2605
+Dshell/_DshellInterpreteur/dshell_interpreter.py,sha256=DNF9JybvrVxJ0tVnGZ1enPS_JBkZCR5cqhsPrBSt_CM,31375
+Dshell/_DshellInterpreteur/errors.py,sha256=0PJz_VYZfNZeKR_PEHxw3tRkgKNNUerV0wwrq2r1luA,250
+Dshell/_DshellParser/__init__.py,sha256=ONDfhZMvClqP_6tE8SLjp-cf3pXL-auQYnfYRrHZxC4,56
+Dshell/_DshellParser/ast_nodes.py,sha256=Ld5-Fo8xkj3T5-G6eF2j4EXRJgktRpi9DT9rBHrLdnw,19629
+Dshell/_DshellParser/dshell_parser.py,sha256=QdAWRaYucf9UD7hHQ0Sl4guSuPL0RmY51wZTBDriDW0,19096
+Dshell/_DshellTokenizer/__init__.py,sha256=LIQSRhDx2B9pmPx5ADMwwD0Xr9ybneVLhHH8qrJWw_s,172
+Dshell/_DshellTokenizer/dshell_keywords.py,sha256=KDvq3V6yFNksVi_SBNhkl7QsTyYwjKibN8CqlQlIPms,7360
+Dshell/_DshellTokenizer/dshell_token_type.py,sha256=fjqDg_wIUbmOziGM66iTL7X85axjWbGO_yEUKNIoURE,1573
+Dshell/_DshellTokenizer/dshell_tokenizer.py,sha256=3-YjgX_ESJsCH7osdbQJr13f497nER8EQSAT95bheow,7231
+dshellinterpreter-0.2.21.7.dist-info/licenses/LICENSE,sha256=lNgcw1_xb7QENAQi3uHGymaFtbs0RV-ihiCd7AoLQjA,1082
+dshellinterpreter-0.2.21.7.dist-info/METADATA,sha256=BY1lOCs_D8uQHAdgVWwj6M9jfY4ULumPo-LMB73zvcY,1151
+dshellinterpreter-0.2.21.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dshellinterpreter-0.2.21.7.dist-info/top_level.txt,sha256=B4CMhtmchGwPQJLuqUy0GhRG-0cUGxKL4GqEbCiB_vE,7
+dshellinterpreter-0.2.21.7.dist-info/RECORD,,

dshellinterpreter-0.2.21.7.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

dshellinterpreter-0.2.21.7.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 BOXER
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

dshellinterpreter-0.2.21.7.dist-info/top_level.txt

@@ -0,0 +1 @@
+Dshell