dshellInterpreter 1.2.2.0__tar.gz → 1.2.3.0__tar.gz

{dshellinterpreter-1.2.2.0 → dshellinterpreter-1.2.3.0}/Dshell/DISCORD_COMMANDS/dshell_channel.py

@@ -59,7 +59,7 @@ async def dshell_get_channel(ctx: Message, name: StrNode):
     if isinstance(name, StrNode):
         return next((IntNode(c.id) for c in ctx.channel.guild.channels if c.name == name), None)
 
-    raise Exception(f"Channel must be an integer or a string, not {type(name)} !")
+    raise Exception(f"Channel must be an integer or a string, not {type(name).__name__} !")
 
 
 async def dshell_get_channels(ctx: Message, name: Optional[StrNode]=None, regex: Optional[StrNode]=None) -> ListNode:

{dshellinterpreter-1.2.2.0 → dshellinterpreter-1.2.3.0}/Dshell/DISCORD_COMMANDS/dshell_interaction.py

@@ -73,7 +73,7 @@ async def dshell_respond_interaction(ctx: Interaction,
     _CMD = "sri"
 
     if not isinstance(ctx, Interaction):
-        raise Exception(f'Respond to an interaction must be used in an interaction context, not {type(ctx)} !')
+        raise Exception(f'Respond to an interaction must be used in an interaction context, not {type(ctx).__name__} !')
 
     _validate_optional_string(content, "Content", _CMD)
     _validate_optional_number(delete, "Delete", _CMD)
@@ -129,7 +129,7 @@ async def dshell_defer_interaction(ctx: Interaction) -> BoolNode:
     """
 
     if not isinstance(ctx, Interaction):
-        raise Exception(f'Respond to an interaction must be used in an interaction context, not {type(ctx)} !')
+        raise Exception(f'Respond to an interaction must be used in an interaction context, not {type(ctx).__name__} !')
 
     await ctx.response.defer()
 
@@ -154,7 +154,7 @@ async def dshell_delete_original_message(ctx: Interaction) -> IntNode:
     """
 
     if not isinstance(ctx, Interaction):
-        raise Exception(f'Respond to an interaction must be used in an interaction context, not {type(ctx)} !')
+        raise Exception(f'Respond to an interaction must be used in an interaction context, not {type(ctx).__name__} !')
 
     await ctx.delete_original_message()
 

{dshellinterpreter-1.2.2.0 → dshellinterpreter-1.2.3.0}/Dshell/DISCORD_COMMANDS/dshell_member.py

@@ -95,7 +95,7 @@ async def dshell_send_private_message(ctx: Message,
         embeds = ListNode([embeds])
 
     else:
-        raise Exception(f'Embeds must be a list of Embed objects or a single Embed object, not {type(embeds)} !')
+        raise Exception(f'Embeds must be a list of Embed objects or a single Embed object, not {type(embeds).__name__} !')
 
     sended_message = await member_to_send.send(message, delete_after=delete, embeds=embeds, files=final_files)
 

{dshellinterpreter-1.2.2.0 → dshellinterpreter-1.2.3.0}/Dshell/DISCORD_COMMANDS/dshell_message.py

@@ -280,7 +280,7 @@ async def dshell_clear_one_reactions(ctx: Message, message: Union[IntNode, StrNo
     """
 
     if not isinstance(emoji, StrNode):
-        raise Exception(f'Emoji must be StrNode, not {type(emoji)}')
+        raise Exception(f'Emoji must be StrNode, not {type(emoji).__name__}')
 
     target_message = ctx if message is None else await utils_get_message(ctx, message)
 

{dshellinterpreter-1.2.2.0 → dshellinterpreter-1.2.3.0}/Dshell/DISCORD_COMMANDS/dshell_role.py

@@ -117,13 +117,13 @@ async def dshell_delete_roles(ctx: Message, roles: Union[ListNode, IntNode], rea
     _CMD = "dr"
 
     if roles is not None and not isinstance(roles, (IntNode, ListNode)):
-        raise Exception(f"Roles must be a int, role mention or NodeList of both, not {type(roles)} !")
+        raise Exception(f"Roles must be a int, role mention or NodeList of both, not {type(roles).__name__} !")
 
     _validate_optional_string(reason, "Reason", _CMD)
 
     roles: Union[IntNode, ListNode]
     if not isinstance(roles, (IntNode, ListNode)):
-        raise Exception(f"Role must be a int, role mention or NodeList of both, not {type(roles)} !")
+        raise Exception(f"Role must be a int, role mention or NodeList of both, not {type(roles).__name__} !")
 
     if isinstance(roles, IntNode):
         roles: tuple = (roles, )

{dshellinterpreter-1.2.2.0 → dshellinterpreter-1.2.3.0}/Dshell/DISCORD_COMMANDS/dshell_ui.py

@@ -225,7 +225,7 @@ async def build_ui(ui_node: Union[UiButtonNode, UiSelectNode], interpreter: "Dsh
         update_nbr_usage_scope(interpreter.scope_id, 1)
 
     else:
-        raise TypeError(f"UI node must be UiButtonNode or UiSelectNode, not {type(ui_node)} !")
+        raise TypeError(f"UI node must be UiButtonNode or UiSelectNode, not {type(ui_node).__name__} !")
 
     return view
 

{dshellinterpreter-1.2.2.0 → dshellinterpreter-1.2.3.0}/Dshell/DISCORD_COMMANDS/utils/utils_embed.py

@@ -26,6 +26,6 @@ def utils_check_embeds_arguments(_CMD: StrNode,
 
             final_embeds = embeds
         else:
-            raise Exception(f"Embeds must be a embed object or a ListNode, not {type(embeds)} in '{_CMD}' command")
+            raise Exception(f"Embeds must be a embed object or a ListNode, not {type(embeds).__name__} in '{_CMD}' command")
 
     return final_embeds

{dshellinterpreter-1.2.2.0 → dshellinterpreter-1.2.3.0}/Dshell/DISCORD_COMMANDS/utils/utils_file.py

@@ -37,6 +37,6 @@ def utils_check_files_arguments(_CMD: StrNode, files: Optional[Union[FileNode, L
                                         spoiler=file.spoiler))
 
         else:
-            raise Exception(f"Files must be a FileNode or a ListNode, not {type(files)} in '{_CMD}' command")
+            raise Exception(f"Files must be a FileNode or a ListNode, not {type(files).__name__} in '{_CMD}' command")
 
     return final_files if len(final_files) > 0 else None

{dshellinterpreter-1.2.2.0 → dshellinterpreter-1.2.3.0}/Dshell/DISCORD_COMMANDS/utils/utils_global.py

@@ -188,7 +188,7 @@ async def utils_len(ctx: Message, value):
         3
     """
     if not isinstance(value, (StrNode, ListNode)):
-        raise TypeError(f"value must be a list or a string in len command, not {type(value)}")
+        raise TypeError(f"value must be a list or a string in len command, not {type(value).__name__}")
 
     return IntNode(len(value))
 
@@ -347,7 +347,7 @@ def utils_build_colour(color: Union[IntNode, ListNode]) -> Union[Colour, IntNode
         else:
             return Colour.from_rgb(*color)
     else:
-        raise TypeError(f"Color must be an integer or a ListNode, not {type(color)} !")
+        raise TypeError(f"Color must be an integer or a ListNode, not {type(color).__name__} !")
 
 def utils_refactor_emoji(emoji: Union[StrNode, None]) -> Union[StrNode, None]:
     """

{dshellinterpreter-1.2.2.0 → dshellinterpreter-1.2.3.0}/Dshell/DISCORD_COMMANDS/utils/utils_message.py

@@ -67,7 +67,7 @@ async def utils_get_message(ctx: Message, message: Union[IntNode, StrNode]) -> M
         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)} !")
+    raise Exception(f"Message must be an integer or a string, not {type(message).__name__} !")
 
 
 async def utils_fetch_partial_message(partial_message: Union[Message, PartialMessage]) -> Message:
@@ -81,7 +81,7 @@ async def utils_fetch_partial_message(partial_message: Union[Message, PartialMes
     if not isinstance(partial_message, PartialMessage):
         if isinstance(partial_message, Message):
             return partial_message
-        raise Exception(f"Expected a PartialMessage or Message, got '{type(partial_message)}' !")
+        raise Exception(f"Expected a PartialMessage or Message, got '{type(partial_message).__name__}' !")
 
     try:
         message = await partial_message.fetch()

{dshellinterpreter-1.2.2.0 → dshellinterpreter-1.2.3.0}/Dshell/DISCORD_COMMANDS/utils/utils_thread.py

@@ -35,4 +35,4 @@ async def utils_get_thread(ctx: Message, thread: Union[IntNode, StrNode]) -> Uni
         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)} !")
+    raise Exception(f"Thread must be an integer or a string, not {type(thread).__name__} !")

{dshellinterpreter-1.2.2.0 → dshellinterpreter-1.2.3.0}/Dshell/DshellInterpreteur/__init__.py

@@ -2,3 +2,6 @@ from .dshell_interpreter import *
 from .errors import *
 from .cached_messages import dshell_cached_messages
 from .dshell_arguments import DshellArguments
+from .dshell_iterators import *
+from .dshell_scope import *
+from .dshell_global_variables import *

{dshellinterpreter-1.2.2.0 → dshellinterpreter-1.2.3.0}/Dshell/DshellInterpreteur/dshell_arguments.py

@@ -28,6 +28,7 @@ class DshellArguments:
     """
     Manage Dshell parameters and arguments passed to a command call.
     Example: !ban @user reason for ban
+    "order" list store parameters order append to the class
     """
 
     def __init__(self):
@@ -36,6 +37,8 @@ class DshellArguments:
             '*': DshellArgumentsData([], False, DTT.LIST)  # Non-specified parameters
         }
 
+        self.order: list[tuple[str, DTT]] = []
+
     def set_parameter(self, name: StrNode, value: Any, type_: DTT, obligatory: bool = False) -> None:
         """
         Set a parameter with its type and value.
@@ -45,6 +48,7 @@ class DshellArguments:
         :param obligatory: Whether this parameter is required
         """
         self.parameters[name] = DshellArgumentsData(value, obligatory, type_)
+        self.order.append((name, type_))
 
     def get_parameter(self, name: str) -> DshellArgumentsData:
         """
@@ -83,6 +87,7 @@ class DshellArguments:
         :param value: The parameter value to add to the list
         """
         self.parameters['*'].value.append(value)
+        self.order.append(('*', DTT.PARAMETER))
 
     def __repr__(self) -> str:
         return str(self.parameters)

{dshellinterpreter-1.2.2.0 → dshellinterpreter-1.2.3.0}/Dshell/DshellInterpreteur/dshell_interpreter.py

@@ -11,8 +11,9 @@ from .utils_interpreter import get_params, eval_expression, eval_expression_inli
 from ..DISCORD_COMMANDS.dshell_embed import build_embed, rebuild_embed
 from ..DISCORD_COMMANDS.dshell_ui import build_ui
 from ..DISCORD_COMMANDS.utils.utils_permissions import build_permission
-from .dshell_scope import Scope, new_scope, get_scope, create_scope, update_nbr_usage_scope, get_usage_scope
+from .dshell_scope import Scope, new_scope, get_scope, create_scope, update_nbr_usage_scope
 from .dshell_global_variables import MAX_SLEEP_TIME_SECONDS, MIN_SLEEP_TIME_SECONDS
+from .dshell_iterators import DshellIterator
 
 
 All_nodes = TypeVar('All_nodes', IfNode, LoopNode, ElseNode, ElifNode, ArgsCommandNode, VarNode)
@@ -365,6 +366,10 @@ async def eval_CodeNode(eval_node: EvalNode, interpreter: DshellInterpreteur):
     :param interpreter: The Dshell interpreter instance.
     """
     codeNode = await interpreter.eval_data_token(eval_node.codeNode)
+
+    if not isinstance(codeNode, CodeNode):
+        raise TypeError(f"[EVAL] ident must be a CodeNode, not {type(codeNode).__name__} !")
+
     argscommand = await regroupe_commandes(eval_node.argsNode.body, interpreter)
     kwargs = argscommand.get_dict_parameters()
     kwargs.pop('*', None)
@@ -375,51 +380,3 @@ async def eval_CodeNode(eval_node: EvalNode, interpreter: DshellInterpreteur):
         result = interpreter.env.get('__ret__')
 
     return result
-
-
-class DshellIterator:
-    """
-    Used to transform anything into an iterable
-    """
-
-    def __init__(self, data):
-        self.data = self._check_data(data)
-        self.current = 0
-
-    def __iter__(self):
-        return self
-
-    def __next__(self):
-        return next(self.data)
-
-    def _check_data(self, data: Any):
-
-        if not isinstance(data, (StrNode, ListNode, FloatNode, IntNode, FileNode, FileStreamNode)):
-            raise Exception(f"{data} can't be in a loop !")
-
-        if isinstance(data, FileNode):
-            return data.stream()
-
-        elif isinstance(data, (FloatNode, IntNode)):
-            return IntIterator(IntNode(data))
-
-        else:
-            return data
-
-class IntIterator:
-
-    def __init__(self, max_iterator: IntNode):
-        self.max_iterator = max_iterator
-        self.pointer = IntNode(0)
-
-    def __iter__(self) -> "IntIterator":
-        return self
-
-    def __next__(self) -> IntNode:
-        if self.pointer >= self.max_iterator:
-            self.pointer = IntNode(0)
-            raise StopIteration
-
-        current = self.pointer
-        self.pointer += 1
-        return current

dshellinterpreter-1.2.3.0/Dshell/DshellInterpreteur/dshell_iterators.py

@@ -0,0 +1,57 @@
+from ..full_import import Any
+from ..DshellParser.ast_nodes import IntNode, FloatNode, StrNode, ListNode, FileNode, FileStreamNode
+
+class DshellIterator:
+    """
+    Used to transform anything into an iterable
+    """
+
+    def __init__(self, data):
+        self.data = self._check_data(data)
+        self.current = 0
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        return next(self.data)
+
+    def _check_data(self, data: Any):
+
+        if not isinstance(data, (StrNode, ListNode, FloatNode, IntNode, FileNode, FileStreamNode, IntIterator)):
+            raise Exception(f"{data} can't be in a loop !")
+
+        if isinstance(data, FileNode):
+            return data.stream()
+
+        elif isinstance(data, (FloatNode, IntNode)):
+            return IntIterator(IntNode(data))
+
+        else:
+            return data
+
+class IntIterator:
+
+    def __init__(self, max_iterator: IntNode,
+                 min_iterator: IntNode = IntNode(0),
+                 step: IntNode = IntNode(1)):
+
+        self.max_iterator = max_iterator
+        self.min_iterator = min_iterator
+        self.step = step
+        self.pointer = self.min_iterator
+
+    def __iter__(self) -> "IntIterator":
+        return self
+
+    def __next__(self) -> IntNode:
+        if self.pointer == self.max_iterator:
+            self.pointer = self.min_iterator
+            raise StopIteration
+
+        current = self.pointer
+        self.pointer += self.step
+        return current
+
+    def __repr__(self):
+        return f"<INT_ITERATOR> - {self.min_iterator} to {self.max_iterator} with step {self.step}"

{dshellinterpreter-1.2.2.0 → dshellinterpreter-1.2.3.0}/Dshell/DshellInterpreteur/utils_interpreter.py

@@ -6,8 +6,7 @@ from ..DshellTokenizer.dshell_token_type import DTT_DATA
 from ..DshellParser.ast_nodes import IfNode, ParamNode, ListNode, StrNode
 from ..DshellParser.dshell_parser import to_postfix
 
-from Dshell.full_import import sub, escape
-from Dshell.full_import import Any, TYPE_CHECKING
+from Dshell.full_import import Any, Union, TYPE_CHECKING
 
 if TYPE_CHECKING:
     from ..DshellInterpreteur.dshell_interpreter import DshellInterpreteur
@@ -23,7 +22,7 @@ async def regroupe_commandes(body: list[Token], interpreter: "DshellInterpreteur
 
     :param body: The list of tokens to group.
     :param interpreter: The Dshell interpreter instance.
-    :param normalise: If True, normalises the arguments (make value lowercase).
+    :param normalise: If True, normalizes the arguments (make value lowercase).
     """
     # tokens to return
 
@@ -67,10 +66,10 @@ async def regroupe_commandes(body: list[Token], interpreter: "DshellInterpreteur
 
             while (index + 1) < n and body[index + 1].type not in (DTT.PARAMETER, DTT.STR_PARAMETER, DTT.PARAMETERS):
 
-                final_argument += body[index + 1].value + ''
+                final_argument += body[index + 1].value + ' '
                 index += 1
-                instance_dhsell_arguments.set_parameter(body[current_index].value, StrNode(final_argument), type_=DTT.STR_PARAMETER)
 
+            instance_dhsell_arguments.set_parameter(body[current_index].value, StrNode(final_argument), type_=DTT.STR_PARAMETER)
             index += 1
 
         elif body[index].type == DTT.PARAMETERS:
@@ -81,8 +80,8 @@ async def regroupe_commandes(body: list[Token], interpreter: "DshellInterpreteur
 
                 list_parameters.append(await interpreter.eval_data_token(body[index + 1]))
                 index += 1
-                instance_dhsell_arguments.set_parameter(body[current_index].value, ListNode(list_parameters), type_=DTT.PARAMETERS)
 
+            instance_dhsell_arguments.set_parameter(body[current_index].value, ListNode(list_parameters), type_=DTT.PARAMETERS)
             index += 1
 
         else:
@@ -93,60 +92,75 @@ async def regroupe_commandes(body: list[Token], interpreter: "DshellInterpreteur
 
 async def get_params(node: ParamNode, interpreter: "DshellInterpreteur") -> dict[StrNode, Any]:
     """
-    Get the parameters from a ParamNode.
+    Get the parameters from a ParamNode and replace their value if an input user is valide
     :param node: The ParamNode to get the parameters from.
     :param interpreter: The Dshell interpreter instance.
     :return: A dictionary of parameters.
     """
-    def replace_match(match) -> StrNode:
-        special_char = match.group(1)
-        if special_char:
-            return ''
-        return StrNode(match.group(4))
-
-    variables = interpreter.vars
-    regrouped_parameters: DshellArguments = await regroupe_commandes(node.body, interpreter)
-
-    from ..DshellTokenizer.dshell_tokenizer import DshellTokenizer
-    _ = DshellTokenizer(variables, math_any_character=True).start()
-    regrouped_variables = await regroupe_commandes(_[0] if _ else tuple(), interpreter)
-
-    already_modified = set()
-    variables_non_specified_parameters = regrouped_variables.parameters.pop('*', None).value  # remove non-specified parameters
-
-    for param_name, param_data in regrouped_variables.parameters.items():
-        regrouped_parameters.update_parameter(param_name, param_data)
-        variables = sub(rf"--([*']?)({escape(param_name)})\s+(.*)\s*?(.*)$", replace_match, variables, count=1)
-        already_modified.add(param_name)
-
-    index_variable = 0
-    for var in regrouped_parameters.parameters.keys():
-        if var not in already_modified:
-
-            parameter_type = regrouped_parameters.get_parameter(var).type
-
-            if parameter_type == DTT.PARAMETER and index_variable < len(variables_non_specified_parameters):
-                regrouped_parameters.set_parameter(StrNode(var), variables_non_specified_parameters[index_variable], parameter_type)  # variables_post_regrouped[index_variable] is not a token so cannot be evaluated! causes problems in commands that require something other than str
-                index_variable += 1
-
-            elif parameter_type == DTT.STR_PARAMETER:
-                variables_post_regrouped: list[StrNode] = StrNode(variables.strip().split(' ')) if variables else []  # set only for full str parameters
-                str_parameters_set_for_variables = variables_post_regrouped[index_variable:]
-                # the line below allows setting a full str parameter with multiple words. If the remaining variables are empty, we use the default value (must use str function because otherwise it puts a DshellArgumentsData)
-                regrouped_parameters.set_parameter(StrNode(var), StrNode(' '.join(str_parameters_set_for_variables) if str_parameters_set_for_variables else [StrNode(regrouped_parameters.parameters.get(var, ''))]), parameter_type)
-                break
 
-            elif parameter_type == DTT.PARAMETERS:
-                regrouped_parameters.set_parameter(StrNode(var), ListNode(variables_non_specified_parameters[index_variable:]), parameter_type)
-                break
+    user_input: list[str] = interpreter.vars.strip().split()
+    param_node_arguments: DshellArguments = await regroupe_commandes(node.body, interpreter)
+    param_node_arguments_dict: dict[str, Union[Any, None]] = param_node_arguments.get_dict_parameters()
+    param_node_arguments_order: list[tuple[str, DTT]] = param_node_arguments.order
+
+    index_user_input: int = 0
+    index_order: int = 0
+
+    while index_order < len(param_node_arguments_order) and index_user_input < len(user_input):
+
+        # traitement des paramètres simple à tokeniser
+        if param_node_arguments_order[index_order][1] == DTT.PARAMETER:
+            old_index_order = index_order
+            tmp_parameter = ''
+            while (index_order < len(param_node_arguments_order) and
+                   param_node_arguments_order[index_order][1] == DTT.PARAMETER and
+                   index_user_input < len(user_input)):
+
+                tmp_parameter += user_input[index_user_input] + ' '
+                index_user_input += 1
+                index_order += 1
+
+            from ..DshellTokenizer.dshell_tokenizer import DshellTokenizer
+            tmp_tokens = DshellTokenizer(tmp_parameter).start()
+
+            if tmp_tokens and len(tmp_tokens[0]) > 0:
+                for i in range(old_index_order, index_order):
+                    param_node_arguments_dict[param_node_arguments_order[i][0]] = tmp_tokens[0][i]
+
+        # traitement des paramètres à tokeniser à la chaine
+        elif param_node_arguments_order[index_order][1] == DTT.PARAMETERS:
+            old_index_order = index_order
+            tmp_parameter = ''
+            while index_user_input < len(user_input):
+
+                tmp_parameter += user_input[index_user_input] + ' '
+                index_user_input += 1
+
+            from ..DshellTokenizer.dshell_tokenizer import DshellTokenizer
+            tmp_tokens = DshellTokenizer(tmp_parameter).start()
+
+            if tmp_tokens and len(tmp_tokens[0]) > 0:
+                param_node_arguments_dict[param_node_arguments_order[old_index_order][0]] = ListNode(tmp_tokens[0])
+
+        # traitement des paramètres à considéré comme une chaine de caractère à la chaine
+        elif param_node_arguments_order[index_order][1] == DTT.STR_PARAMETER:
+            old_index_order = index_order
+            tmp_parameter = ''
+            while index_user_input < len(user_input):
+
+                tmp_parameter += user_input[index_user_input] + ' '
+                index_user_input += 1
+
+            param_node_arguments_dict[param_node_arguments_order[old_index_order][0]] = StrNode(tmp_parameter)
+
+        else:
+            raise Exception(f"Parameter type {param_node_arguments_order[index_order][1]} not found !\n"
+                            f"Please, use : -- or --' or --*")
+
+    param_node_arguments_dict.pop('*')
+    return {StrNode(key): value for key, value in param_node_arguments_dict.items()}
 
-    for param_name, param_data in regrouped_parameters.parameters.items():
-        if param_data.obligatory and param_data.value == '*':
-            raise Exception(f"Parameter '{param_name}' is obligatory but not specified!")
 
-    x = regrouped_parameters.get_dict_parameters()
-    x.pop('*', None)
-    return x
 
 
 async def eval_expression_inline(if_node: IfNode, interpreter: "DshellInterpreteur") -> Token:

{dshellinterpreter-1.2.2.0 → dshellinterpreter-1.2.3.0}/Dshell/DshellTokenizer/dshell_keywords.py

@@ -10,7 +10,8 @@ __all__ = [
 
 from ..DISCORD_COMMANDS import *
 
-from Dshell.full_import import Callable
+from ..full_import import Callable
+from ..DshellInterpreteur.dshell_iterators import IntIterator
 
 dshell_keyword: set[str] = {
     'if', 'else', 'elif', 'loop', '#end', 'var', '#loop', '#if', 'sleep', 'param', '#param', 'code', '#code', 'eval', 'return', 'break'
@@ -183,8 +184,11 @@ dshell_mathematical_operators: dict[str, tuple[Callable, int, int, int]] = {
     r"%": (lambda a, b: a % b, 7, 2, 2),
     r"-": (lambda a, b=None: a-b if b is not None else -a, 6, 1, 2),
     r"+": (lambda a, b: a + b, 6, 2, 2),
-    r"..": (lambda a, b: ListNode([IntNode(i) for i in range(IntNode(a), IntNode(b))])
-                if a <= b else ListNode([IntNode(i) for i in range(IntNode(a), IntNode(b), -1)]), 5, 2, 2)
+    r"..": (lambda a, b: (IntIterator(
+                                min_iterator=IntNode(a),
+                                max_iterator=IntNode(b),
+                                step= IntNode(1 if a <= b else -1))
+                          ), 5, 2, 2)
     # warning: ambiguity between unary and binary to be handled in your parser
 
 }

{dshellinterpreter-1.2.2.0 → dshellinterpreter-1.2.3.0}/Dshell/DshellTokenizer/dshell_tokenizer.py

@@ -71,14 +71,14 @@ table_regex: dict[DTT, Pattern] = {
 
 class DshellTokenizer:
 
-    def __init__(self, code: str, math_any_character: bool = False):
+    def __init__(self, code: str, match_any_character: bool = False):
         """
         Initialize the tokenizer.
         :param code: The code to tokenize
-        :param math_any_character: Whether to match any character
+        :param match_any_character: Whether to match any character
         """
         self.code: str = code
-        self.match_any_character: bool = math_any_character
+        self.match_any_character: bool = match_any_character
         self.data_pre_processor: list[PreProcessorData] = []
 
     def start(self):

{dshellinterpreter-1.2.2.0/dshellInterpreter.egg-info → dshellinterpreter-1.2.3.0}/PKG-INFO

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

{dshellinterpreter-1.2.2.0 → dshellinterpreter-1.2.3.0/dshellInterpreter.egg-info}/PKG-INFO

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

{dshellinterpreter-1.2.2.0 → dshellinterpreter-1.2.3.0}/dshellInterpreter.egg-info/SOURCES.txt

@@ -31,6 +31,7 @@ Dshell/DshellInterpreteur/cached_messages.py
 Dshell/DshellInterpreteur/dshell_arguments.py
 Dshell/DshellInterpreteur/dshell_global_variables.py
 Dshell/DshellInterpreteur/dshell_interpreter.py
+Dshell/DshellInterpreteur/dshell_iterators.py
 Dshell/DshellInterpreteur/dshell_scope.py
 Dshell/DshellInterpreteur/errors.py
 Dshell/DshellInterpreteur/utils_interpreter.py

{dshellinterpreter-1.2.2.0 → dshellinterpreter-1.2.3.0}/setup.py

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