dshellInterpreter 1.2.7.10__tar.gz → 1.2.8.0__tar.gz

{dshellinterpreter-1.2.7.10 → dshellinterpreter-1.2.8.0}/Dshell/DISCORD_COMMANDS/dshell_ui.py

@@ -8,13 +8,21 @@ from ..full_import import (ButtonStyle,
                            SelectMenu,
                            ComponentType,
                            random,
-                           IntEnum)
-
-from ..DshellParser.ast_nodes import UiSelectNode, UiButtonNode, OptionUiSelectNode, ListNode, StrNode, IntNode, BoolNode
+                           IntEnum,
+                           deepcopy)
+
+from ..DshellParser.ast_nodes import (UiSelectNode,
+                                      UiButtonNode,
+                                      OptionUiSelectNode,
+                                      CodeNode,
+                                      ListNode,
+                                      StrNode,
+                                      IntNode,
+                                      BoolNode)
 
 from ..DshellInterpreteur.utils_interpreter import regroupe_commandes
 
-from ..DshellInterpreteur.dshell_scope import new_scope, update_nbr_usage_scope
+from ..DshellInterpreteur.dshell_scope import new_scope, Scope
 
 from ..full_import import Any, TYPE_CHECKING, Union, Optional
 
@@ -31,8 +39,6 @@ from .utils.utils_global import utils_refactor_emoji
 if TYPE_CHECKING:
     from ..DshellInterpreteur.dshell_interpreter import DshellInterpreteur
 
-scope_id = "scope_id"
-
 ButtonStyleValues: set = {i.name for i in ButtonStyle}
 SelectSyleValues: dict = {'string': ComponentType.string_select,
                           'role': ComponentType.role_select,
@@ -56,6 +62,25 @@ def check_timeout(timeout: Union[int, IntNode]):
                         f"and less or equal than[{UITimeout.max_timeout}]")
     return timeout
 
+
+def build_ui_scope(env: Scope, code_node: CodeNode):
+    """
+    Create a new scope to store only variables used in UI.
+    :param code_node:
+    :return:
+    """
+
+    new_ui_scope = Scope()
+
+    if not isinstance(code_node, CodeNode) or code_node.global_env_vars is None:
+        return new_ui_scope
+
+    for token in code_node.global_env_vars.env_variables:
+
+        new_ui_scope.set(token.value, deepcopy(env.get(token.value, None)))
+
+    return new_ui_scope
+
 async def build_ui_button_parameters(ui_button_node: UiButtonNode, interpreter: "DshellInterpreteur"):
     """
     Builds the parameters for a UI component from the UiNode.
@@ -201,18 +226,15 @@ async def build_ui(ui_node: Union[UiButtonNode, UiSelectNode], interpreter: "Dsh
     :return:
     """
 
-    async def ui_timeout(ctx):
-        update_nbr_usage_scope(interpreter.scope_id, -1)
-
-    view = EasyModifiedViews(timeout=600, call_on_timeout=ui_timeout, disabled_on_timeout=True)
+    view = EasyModifiedViews(timeout=600, disabled_on_timeout=True)
 
     if isinstance(ui_node, UiButtonNode):
         async for _, args_button, code in build_ui_button_parameters(ui_node, interpreter):
+            code: CodeNode
             view.timeout = args_button.pop('timeout', IntNode(UITimeout.default_timeout))
             b = ui.Button(**args_button)
             view.add_items(b)
-            view.set_callable(b.custom_id, _callable=ui_button_callback, data={'code': code, scope_id: interpreter.scope_id})
-        update_nbr_usage_scope(interpreter.scope_id, 1)
+            view.set_callable(b.custom_id, _callable=ui_button_callback, data={'code': code, 'scope': build_ui_scope(interpreter.env, code)})
 
     elif isinstance(ui_node, UiSelectNode):
         s = SelectMenu()
@@ -228,26 +250,25 @@ async def build_ui(ui_node: Union[UiButtonNode, UiSelectNode], interpreter: "Dsh
                 for option in options:
                     menu.add_option(**option)
 
-                s.set_callable(args_select["custom_id"], _callable=ui_select_callback, data={'code': code, scope_id: interpreter.scope_id})
+                s.set_callable(args_select["custom_id"], _callable=ui_select_callback, data={'code': code, "scope": build_ui_scope(interpreter.env, code)})
 
             elif select_type == ComponentType.role_select:
                 s.add_role_select_menu(**args_select)
-                s.set_callable(args_select["custom_id"], _callable=ui_select_callback, data={'code': code, scope_id: interpreter.scope_id})
+                s.set_callable(args_select["custom_id"], _callable=ui_select_callback, data={'code': code, "scope": build_ui_scope(interpreter.env, code)})
 
             elif select_type == ComponentType.user_select:
                 s.add_user_select_menu(**args_select)
-                s.set_callable(args_select["custom_id"], _callable=ui_select_callback, data={'code': code, scope_id: interpreter.scope_id})
+                s.set_callable(args_select["custom_id"], _callable=ui_select_callback, data={'code': code, "scope": build_ui_scope(interpreter.env, code)})
 
             elif select_type == ComponentType.mentionable_select:
                 s.add_mentionable_select_menu(**args_select)
-                s.set_callable(args_select["custom_id"], _callable=ui_select_callback, data={'code': code, scope_id: interpreter.scope_id})
+                s.set_callable(args_select["custom_id"], _callable=ui_select_callback, data={'code': code, "scope": build_ui_scope(interpreter.env, code)})
 
             elif select_type == ComponentType.channel_select:
                 s.add_channel_select_menu(**args_select)
-                s.set_callable(args_select["custom_id"], _callable=ui_select_callback, data={'code': code, scope_id: interpreter.scope_id})
+                s.set_callable(args_select["custom_id"], _callable=ui_select_callback, data={'code': code, "scope": build_ui_scope(interpreter.env, code)})
 
         view.add_items(s)
-        update_nbr_usage_scope(interpreter.scope_id, 1)
 
     else:
         raise TypeError(f"UI node must be UiButtonNode or UiSelectNode, not {type(ui_node).__name__} !")
@@ -276,8 +297,8 @@ async def rebuild_ui(ui_node: Union[UiButtonNode, UiSelectNode], view: EasyModif
             ui.disabled = args_button.get('disabled', ui.disabled)
             ui.url = args_button.get('url', ui.url)
             ui.row = args_button.get('row', ui.row)
-            new_code = code if code is not None else view.get_callable_data(args_button['custom_id'])['code']
-            view.set_callable(args_button['custom_id'], _callable=ui_button_callback, data={'code': new_code, scope_id: interpreter.scope_id})
+            new_code: CodeNode = code if code is not None else view.get_callable_data(args_button['custom_id'])['code']
+            view.set_callable(args_button['custom_id'], _callable=ui_button_callback, data={'code': new_code, "scope": build_ui_scope(interpreter.env, new_code)})
 
     elif isinstance(ui_node, UiSelectNode):
 
@@ -297,8 +318,8 @@ async def rebuild_ui(ui_node: Union[UiButtonNode, UiSelectNode], view: EasyModif
             for option in options:
                 ui.add_option(**option)
 
-            new_code = code if code is not None else view.get_callable_data(args_select['custom_id'])['code']
-            view.set_callable(args_select['custom_id'], _callable=ui_select_callback, data={'code': new_code, scope_id: interpreter.scope_id})
+            new_code: CodeNode = code if code is not None else view.get_callable_data(args_select['custom_id'])['code']
+            view.set_callable(args_select['custom_id'], _callable=ui_select_callback, data={'code': new_code, "scope": build_ui_scope(interpreter.env, new_code)})
 
     return view
 
@@ -313,7 +334,7 @@ async def ui_button_callback(button: ui.Button, interaction: Interaction, data:
     :return:
     """
     code = data.get('code', None)
-    scope: Optional[str] = data.get(scope_id, None)
+    scope: Optional[str] = data.get("scope", None)
 
     if code is not None:
         message = interaction
@@ -427,7 +448,7 @@ async def ui_select_callback(select: ui.Select, interaction: Interaction, data:
     :return:
     """
     code = data.get('code', None)
-    scope: Optional[str] = data.get(scope_id, None)
+    scope: Optional[str] = data.get("scope", None)
 
     message = interaction
     if code is not None:

{dshellinterpreter-1.2.7.10 → dshellinterpreter-1.2.8.0}/Dshell/DshellInterpreteur/__init__.py

@@ -5,3 +5,4 @@ from .dshell_arguments import DshellArguments
 from .dshell_iterators import *
 from .dshell_scope import *
 from .dshell_global_variables import *
+from .utils_interpreter import *

{dshellinterpreter-1.2.7.10 → dshellinterpreter-1.2.8.0}/Dshell/DshellInterpreteur/dshell_global_variables.py

@@ -7,4 +7,11 @@ MAX_FILE_SIZE = 1_000_000 # bytes
 MAX_SLEEP_TIME_SECONDS = 3_600  # 1 hour
 MIN_SLEEP_TIME_SECONDS = 1
 
-MAX_WAIT_MESSAGE_TIMEOUT = 300
+MAX_WAIT_MESSAGE_TIMEOUT = 300
+
+
+class Nothing:
+    """
+    Do nothing.
+    Used if None is a usable value.
+    """

{dshellinterpreter-1.2.7.10 → dshellinterpreter-1.2.8.0}/Dshell/DshellInterpreteur/dshell_interpreter.py

@@ -11,7 +11,7 @@ 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
+from .dshell_scope import Scope, new_scope
 from .dshell_global_variables import MAX_SLEEP_TIME_SECONDS, MIN_SLEEP_TIME_SECONDS
 from .dshell_iterators import DshellIterator
 
@@ -50,16 +50,7 @@ class DshellInterpreteur:
         message = ctx.message if isinstance(ctx, Interaction) else ctx
 
         # scope creation
-        scope = get_scope(vars_env)
-        if scope:
-            self.env = scope
-            self.scope_id = vars_env
-        else:
-            self.scope_id: str = create_scope()
-            self.env: Optional[Scope] = get_scope(self.scope_id)
-
-        if self.env is None:
-            raise Exception(f"Scope {self.scope_id} not found in interpreter creation !")
+        self.env: Scope = Scope()
 
         self.env.update({
             '__ret__': None,  # environment variables, '__ret__' is used to store the return value of commands
@@ -350,7 +341,10 @@ class DshellInterpreteur:
         """
         Clear the interpreter environment.
         """
-        update_nbr_usage_scope(self.scope_id, -1)
+        self.env.clear()
+        del self.env
+        self.ast.clear()
+        del self.ast
 
 
 async def call_function(function: Callable, args: ArgsCommandNode, interpreter: DshellInterpreteur):

dshellinterpreter-1.2.8.0/Dshell/DshellInterpreteur/dshell_scope.py

@@ -0,0 +1,95 @@
+from contextlib import contextmanager
+from typing import Any, Optional, Dict, Set
+from .dshell_global_variables import Nothing
+
+
+class Scope:
+    """
+    Represents a variable scope with optional parent scope for nested scoping.
+    """
+    def __init__(self, parent: Optional["Scope"] = None):
+        self.parent: Optional[Scope] = parent
+        self.vars: Dict[str, Any] = {}
+
+    def get(self, name: str, default: Any = Nothing()) -> Any:
+        """
+        Get a variable value from this scope or parent scopes.
+        :param name: Variable name
+        :param default: The default variable to return if nothing was found
+        :return: Variable value
+        :raises KeyError: If variable not found in any scope
+        """
+        if name in self.vars:
+            return self.vars[name]
+        if self.parent:
+            return self.parent.get(name)
+        if not isinstance(default, Nothing):
+            return default
+        del default
+        raise KeyError(name)
+
+    def set(self, name: str, value: Any) -> None:
+        """
+        Set a variable in this scope.
+        :param name: Variable name
+        :param value: Variable value
+        """
+        self.vars[name] = value
+
+    def update(self, mapping: Dict[str, Any]) -> None:
+        """
+        Update multiple variables in this scope.
+        :param mapping: Dictionary of variable names and values
+        """
+        self.vars.update(mapping)
+
+    def contains(self, name: str) -> bool:
+        """
+        Check if a variable exists in this scope or parent scopes.
+        :param name: Variable name
+        :return: True if variable exists, False otherwise
+        """
+        if name in self.vars:
+            return True
+        if self.parent:
+            return self.parent.contains(name)
+        return False
+
+    def keys(self) -> Set[str]:
+        """
+        Get all variable names from this scope and parent scopes.
+        :return: Set of variable names
+        """
+        keys = set(self.vars.keys())
+        if self.parent:
+            keys.update(self.parent.keys())
+        return keys
+
+    def clear(self) -> None:
+        """Clear all variables in this scope (does not affect parent)."""
+        self.vars.clear()
+
+
+
+
+@contextmanager
+def new_scope(interpreter, initial_vars: Optional[Dict[str, Any]] = None):
+    """
+    Context manager for creating a new scope temporarily.
+    :param interpreter: The interpreter instance
+    :param initial_vars: Optional initial variables for the new scope
+    """
+    parent = interpreter.env
+
+    new_scope: Scope = Scope(parent=parent)
+
+    interpreter.env = new_scope
+
+    if initial_vars:
+        interpreter.env.update(initial_vars)
+    try:
+        yield
+    finally:
+        interpreter.clear()
+        interpreter.env = parent
+

{dshellinterpreter-1.2.7.10 → dshellinterpreter-1.2.8.0}/Dshell/DshellParser/ast_nodes.py

@@ -40,6 +40,7 @@ __all__ = [
     'PermissionNode',
     'EvalGroupNode',
     'ParamNode',
+    'GlobalNode',
     'CodeNode',
     'EvalNode',
     'ReturnNode',
@@ -144,52 +145,52 @@ class IntNode(int, ASTNode, DATANode):
         return getsizeof(IntNode)
 
     def __add__(self, value: "IntNode", /) -> "IntNode":
-        if not isinstance(value, IntNode):
+        if not isinstance(value, (IntNode, int)):
             raise Exception(f"Cannot add {type(value).__name__} type to IntNode")
         return IntNode(super().__add__(value))
 
     def __sub__(self, value: "IntNode", /) -> "IntNode":
-        if not isinstance(value, IntNode):
+        if not isinstance(value, (IntNode, int)):
             raise Exception(f"Cannot sub {type(value).__name__} type to IntNode")
         return IntNode(super().__sub__(value))
 
     def __pow__(self, x: "IntNode", /) -> "IntNode":
-        if not isinstance(x, IntNode):
+        if not isinstance(x, (IntNode, int)):
             raise Exception(f"Cannot pow {type(x).__name__} type to IntNode")
         return IntNode(super().__pow__(x))
 
     def __floordiv__(self, value: "IntNode", /) -> "IntNode":
-        if not isinstance(value, IntNode):
+        if not isinstance(value, (IntNode, int)):
             raise Exception(f"Cannot divide {type(value).__name__} type to IntNode")
         return IntNode(super().__floordiv__(value))
 
     def __rshift__(self, value: "IntNode", /) -> "IntNode":
-        if not isinstance(value, IntNode):
+        if not isinstance(value, (IntNode, int)):
             raise Exception(f"Cannot shift to the right {type(value).__name__} type to IntNode")
         return IntNode(super().__rshift__(value))
 
     def __lshift__(self, value: "IntNode", /) -> "IntNode":
-        if not isinstance(value, IntNode):
+        if not isinstance(value, (IntNode, int)):
             raise Exception(f"Cannot shift to the left {type(value).__name__} type to IntNode")
         return IntNode(super().__lshift__(value))
 
     def __xor__(self, value: "IntNode", /) -> "IntNode":
-        if not isinstance(value, IntNode):
+        if not isinstance(value, (IntNode, int)):
             raise Exception(f"Cannot xor {type(value).__name__} type to IntNode")
         return IntNode(super().__xor__(value))
 
     def __truediv__(self, value: "IntNode", /) -> "FloatNode":
-        if not isinstance(value, IntNode):
+        if not isinstance(value, (IntNode, int)):
             raise Exception(f"Cannot divide {type(value).__name__} type to IntNode")
         return FloatNode(super().__truediv__(value))
 
     def __mul__(self, value: "IntNode", /) -> "IntNode":
-        if not isinstance(value, IntNode):
+        if not isinstance(value, (IntNode, int)):
             raise Exception(f"Cannot multiply {type(value).__name__} type to IntNode")
         return IntNode(super().__mul__(value))
 
     def __mod__(self, value: "IntNode", /) -> "IntNode":
-        if not isinstance(value, IntNode):
+        if not isinstance(value, (IntNode, int)):
             raise Exception(f"Cannot modulo {type(value).__name__} type to IntNode")
         return IntNode(super().__mod__(value))
 
@@ -205,52 +206,52 @@ class FloatNode(float, ASTNode, DATANode):
         return getsizeof(FloatNode)
 
     def __add__(self, value: "FloatNode", /) -> "FloatNode":
-        if not isinstance(value, FloatNode):
+        if not isinstance(value, (FloatNode, float)):
             raise Exception(f"Cannot add {type(value).__name__} type to FloatNode")
         return FloatNode(super().__add__(value))
 
     def __sub__(self, value: "FloatNode", /) -> "FloatNode":
-        if not isinstance(value, FloatNode):
+        if not isinstance(value, (FloatNode, float)):
             raise Exception(f"Cannot sub {type(value).__name__} type to FloatNode")
         return FloatNode(super().__sub__(value))
 
     def __pow__(self, x: "FloatNode", /) -> "FloatNode":
-        if not isinstance(x, FloatNode):
+        if not isinstance(x, (FloatNode, float)):
             raise Exception(f"Cannot pow {type(x).__name__} type to FloatNode")
         return FloatNode(super().__pow__(x))
 
     def __floordiv__(self, value: "FloatNode", /) -> "FloatNode":
-        if not isinstance(value, FloatNode):
+        if not isinstance(value, (FloatNode, float)):
             raise Exception(f"Cannot divide {type(value).__name__} type to FloatNode")
         return FloatNode(super().__floordiv__(value))
 
     def __rshift__(self, value: "FloatNode", /) -> "FloatNode":
-        if not isinstance(value, FloatNode):
+        if not isinstance(value, (FloatNode, float)):
             raise Exception(f"Cannot shift to the right {type(value).__name__} type to FloatNode")
         return FloatNode(super().__rshift__(value))
 
     def __lshift__(self, value: "FloatNode", /) -> "FloatNode":
-        if not isinstance(value, FloatNode):
+        if not isinstance(value, (FloatNode, float)):
             raise Exception(f"Cannot shift to the left {type(value).__name__} type to FloatNode")
         return FloatNode(super().__lshift__(value))
 
     def __xor__(self, value: "FloatNode", /) -> "FloatNode":
-        if not isinstance(value, FloatNode):
+        if not isinstance(value, (FloatNode, float)):
             raise Exception(f"Cannot xor {type(value).__name__} type to FloatNode")
         return FloatNode(super().__xor__(value))
 
     def __truediv__(self, value: "FloatNode", /) -> "FloatNode":
-        if not isinstance(value, FloatNode):
+        if not isinstance(value, (FloatNode, float)):
             raise Exception(f"Cannot divide {type(value).__name__} type to FloatNode")
         return FloatNode(super().__truediv__(value))
 
     def __mul__(self, value: "FloatNode", /) -> "FloatNode":
-        if not isinstance(value, FloatNode):
+        if not isinstance(value, (FloatNode, float)):
             raise Exception(f"Cannot multiply {type(value).__name__} type to FloatNode")
         return FloatNode(super().__mul__(value))
 
     def __mod__(self, value: "FloatNode", /) -> "FloatNode":
-        if not isinstance(value, FloatNode):
+        if not isinstance(value, (FloatNode, float)):
             raise Exception(f"Cannot modulo {type(value).__name__} type to FloatNode")
         return FloatNode(super().__mod__(value))
 
@@ -265,52 +266,52 @@ class BoolNode(int, ASTNode, DATANode):
         return getsizeof(BoolNode)
 
     def __add__(self, value: Union["BoolNode", "IntNode"], /) -> "BoolNode":
-        if not isinstance(value, (BoolNode, IntNode)):
+        if not isinstance(value, (BoolNode, IntNode, bool)):
             raise Exception(f"Cannot add {type(value).__name__} type to IntNode")
         return BoolNode(super().__add__(value))
 
     def __sub__(self, value: Union["BoolNode", "IntNode"], /) -> "BoolNode":
-        if not isinstance(value, (BoolNode, IntNode)):
+        if not isinstance(value, (BoolNode, IntNode, bool)):
             raise Exception(f"Cannot sub {type(value).__name__} type to IntNode")
         return BoolNode(super().__sub__(value))
 
     def __pow__(self, x: Union["BoolNode", "IntNode"], /) -> "BoolNode":
-        if not isinstance(x, (BoolNode, IntNode)):
+        if not isinstance(x, (BoolNode, IntNode, bool)):
             raise Exception(f"Cannot pow {type(x).__name__} type to IntNode")
         return BoolNode(super().__pow__(x))
 
     def __floordiv__(self, value: Union["BoolNode", "IntNode"], /) -> "BoolNode":
-        if not isinstance(value, (BoolNode, IntNode)):
+        if not isinstance(value, (BoolNode, IntNode, bool)):
             raise Exception(f"Cannot divide {type(value).__name__} type to IntNode")
         return BoolNode(super().__floordiv__(value))
 
     def __rshift__(self, value: Union["BoolNode", "IntNode"], /) -> "BoolNode":
-        if not isinstance(value, (BoolNode, IntNode)):
+        if not isinstance(value, (BoolNode, IntNode, bool)):
             raise Exception(f"Cannot shift to the right {type(value).__name__} type to IntNode")
         return BoolNode(super().__rshift__(value))
 
     def __lshift__(self, value: Union["BoolNode", "IntNode"], /) -> "BoolNode":
-        if not isinstance(value, (BoolNode, IntNode)):
+        if not isinstance(value, (BoolNode, IntNode, bool)):
             raise Exception(f"Cannot shift to the left {type(value).__name__} type to IntNode")
         return BoolNode(super().__lshift__(value))
 
     def __xor__(self, value: Union["BoolNode", "IntNode"], /) -> "BoolNode":
-        if not isinstance(value, (BoolNode, IntNode)):
+        if not isinstance(value, (BoolNode, IntNode, bool)):
             raise Exception(f"Cannot xor {type(value).__name__} type to IntNode")
         return BoolNode(super().__xor__(value))
 
     def __truediv__(self, value: Union["BoolNode", "IntNode"], /) -> "BoolNode":
-        if not isinstance(value, (BoolNode, IntNode)):
+        if not isinstance(value, (BoolNode, IntNode, bool)):
             raise Exception(f"Cannot divide {type(value).__name__} type to IntNode")
         return BoolNode(super().__truediv__(value))
 
     def __mul__(self, value: Union["BoolNode", "IntNode"], /) -> "BoolNode":
-        if not isinstance(value, (BoolNode, IntNode)):
+        if not isinstance(value, (BoolNode, IntNode, bool)):
             raise Exception(f"Cannot multiply {type(value).__name__} type to IntNode")
         return BoolNode(super().__mul__(value))
 
     def __mod__(self, value: Union["BoolNode", "IntNode"], /) -> "BoolNode":
-        if not isinstance(value, (BoolNode, IntNode)):
+        if not isinstance(value, (BoolNode, IntNode, bool)):
             raise Exception(f"Cannot modulo {type(value).__name__} type to IntNode")
         return BoolNode(super().__mod__(value))
 
@@ -827,16 +828,35 @@ class ParamNode(ASTNode):
             "body": [token.to_dict() for token in self.body]
         }
 
+
+class GlobalNode(ASTNode):
+    """
+    Node representing env variables used in code node.
+    """
+    def __init__(self, line: int, *args: Token):
+        super().__init__(line)
+        self.env_variables: tuple[Token, ...] = args
+
+    def __repr__(self) -> str:
+        return StrNode(f"<GLOBAL - {', '.join((str(i) for i in self.env_variables))}")
+
+    def to_dict(self):
+        return {
+            "type": "GlobalNode",
+            "env_variables": self.env_variables
+        }
+
 class CodeNode(ASTNode):
     """
     Node representing a block of code to pass in arguments.
     """
-    def __init__(self, body: list[ASTNode], line: int):
+    def __init__(self, body: list[ASTNode], line: int, global_env_vars: Optional[GlobalNode] = None):
         """
         :param body: list of Node representing the code already parsed
         """
         super().__init__(line)
         self.body = body
+        self.global_env_vars: Optional[GlobalNode] = global_env_vars
 
     def __repr__(self):
         return StrNode(f"<CODE> - {self.body}")
@@ -848,9 +868,11 @@ class CodeNode(ASTNode):
         """
         return {
             "type": "CodeNode",
+            "global_env_vars": self.global_env_vars.to_dict(),
             "body": [token.to_dict() for token in self.body]
         }
 
+
 class EvalNode(ASTNode):
     """
     Node representing an evaluation in the AST.

{dshellinterpreter-1.2.7.10 → dshellinterpreter-1.2.8.0}/Dshell/DshellParser/dshell_parser.py

@@ -6,6 +6,7 @@ __all__ = [
     "ast_to_dict",
 ]
 
+from .ast_nodes import GlobalNode
 from ..DshellTokenizer.dshell_token_type import Token
 from ..DshellTokenizer.dshell_token_type import DshellTokenType as DTT
 from ..DshellTokenizer.dshell_token_type import DTT_DATA
@@ -202,6 +203,18 @@ def parse(token_lines: list[list[Token]], start_node: ASTNode) -> tuple[list[AST
                 blocks.pop()
                 return blocks, pointer
 
+            elif first_token_line_value == 'global':
+                if not isinstance(last_block, CodeNode):
+                    raise SyntaxError(f"[GLOBAL] No code open on line {first_token_line.position}")
+
+                for i in range(1, len_tokens_by_line):
+                    ident = tokens_by_line[i]
+                    if ident.type != DTT.IDENT:
+                        raise ValueError(f"[GLOBAL] '{ident}' value must be a ident on line {first_token_line.position}")
+
+                global_node = GlobalNode(line, *tokens_by_line[1:])
+                last_block.global_env_vars = global_node
+
             elif first_token_line_value == 'eval':
                 if len_tokens_by_line_since_command_name < 1:
                     raise SyntaxError(f"[EVAL] take one or more arguments on line {first_token_line.position}")

{dshellinterpreter-1.2.7.10 → dshellinterpreter-1.2.8.0}/Dshell/DshellTokenizer/dshell_keywords.py

@@ -17,7 +17,7 @@ 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',
-    'catch', '#catch', 'raise'
+    'catch', '#catch', 'raise', 'global'
 }
 
 dshell_discord_keyword: set[str] = {

{dshellinterpreter-1.2.7.10 → dshellinterpreter-1.2.8.0}/Dshell/DshellTokenizer/dshell_token_type.py

@@ -61,6 +61,9 @@ class Token:
         self.value = value
         self.position = position
 
+    def __str__(self):
+        return self.__repr__()
+
     def __repr__(self):
         return f"<{self.type.name} '{self.value}'>"
 

{dshellinterpreter-1.2.7.10/dshellInterpreter.egg-info → dshellinterpreter-1.2.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dshellInterpreter
-Version: 1.2.7.10
+Version: 1.2.8.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.7.10 → dshellinterpreter-1.2.8.0/dshellInterpreter.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dshellInterpreter
-Version: 1.2.7.10
+Version: 1.2.8.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.7.10 → dshellinterpreter-1.2.8.0}/setup.py

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

dshellinterpreter-1.2.7.10/Dshell/DshellInterpreteur/dshell_scope.py

@@ -1,159 +0,0 @@
-from contextlib import contextmanager
-from typing import Any, Optional, Dict, Set, Union
-from random import random
-
-# manage all scope with one unique ID by scope to separate the interpreter and scopes
-context_scope: dict[str, tuple[int, "Scope"]] = {}
-
-def generate_scope_id() -> str:
-    """
-    generate a new scope code unused
-    :return:
-    """
-    while (_id := (str(random()) + str(random()))) in context_scope: pass
-    return _id
-
-
-def get_scope(_id: str) -> Union["Scope", None]:
-    """
-    Get the current scope linked with an ID
-    :param _id:
-    :return: the scope link with the id, or None if the scope id is not found
-    """
-    x = context_scope.get(_id, None)
-    return x[1] if x is not None else x
-
-def get_usage_scope(_id: str) -> Union[int, None]:
-    """
-    Get the usage number for a scope
-    :param _id: An integer, or None if the scope id is not found
-    :return:
-    """
-    x = context_scope.get(_id, None)
-    return x[0] if x is not None else x
-
-class Scope:
-    """
-    Represents a variable scope with optional parent scope for nested scoping.
-    """
-    def __init__(self, parent: Optional[str] = None):
-        self.parent: Optional[str] = parent
-        self.vars: Dict[str, Any] = {}
-
-    def get(self, name: str) -> Any:
-        """
-        Get a variable value from this scope or parent scopes.
-        :param name: Variable name
-        :return: Variable value
-        :raises KeyError: If variable not found in any scope
-        """
-        if name in self.vars:
-            return self.vars[name]
-        if self.parent:
-            if self.parent in context_scope:
-                return context_scope[self.parent][1].get(name)
-            raise Exception(f"Scope {self.parent} not found [get] !")
-        raise KeyError(name)
-
-    def set(self, name: str, value: Any) -> None:
-        """
-        Set a variable in this scope.
-        :param name: Variable name
-        :param value: Variable value
-        """
-        self.vars[name] = value
-
-    def update(self, mapping: Dict[str, Any]) -> None:
-        """
-        Update multiple variables in this scope.
-        :param mapping: Dictionary of variable names and values
-        """
-        self.vars.update(mapping)
-
-    def contains(self, name: str) -> bool:
-        """
-        Check if a variable exists in this scope or parent scopes.
-        :param name: Variable name
-        :return: True if variable exists, False otherwise
-        """
-        if name in self.vars:
-            return True
-        if self.parent:
-            if self.parent in context_scope:
-                return context_scope[self.parent][1].contains(name)
-            Exception(f"Scope {self.parent} not found [contains] !")
-        return False
-
-    def keys(self) -> Set[str]:
-        """
-        Get all variable names from this scope and parent scopes.
-        :return: Set of variable names
-        """
-        keys = set(self.vars.keys())
-        if self.parent:
-            if self.parent in context_scope:
-                keys.update(context_scope[self.parent][1].keys())
-            else:
-                Exception(f"Scope {self.parent} not found [keys] !")
-        return keys
-
-    def clear(self) -> None:
-        """Clear all variables in this scope (does not affect parent)."""
-        self.vars.clear()
-
-
-def create_scope() -> str:
-    """
-    Create a new scope and return the scope code
-    :return:
-    """
-    _id = generate_scope_id()
-    scope = Scope()
-    context_scope[_id] = (1, scope)
-    return _id
-
-def update_nbr_usage_scope(scope_id: str, nbr_usage: int):
-    """
-    Update the usage number for a scope
-    :param nbr_usage:
-    :return:
-    """
-    if scope_id not in context_scope:
-        raise Exception(f"Scope {scope_id} not found [update nbr usage scope] !")
-
-    new_usage = get_usage_scope(scope_id)+nbr_usage
-
-    if new_usage <= 0:
-        del context_scope[scope_id]
-        return
-
-    new = (new_usage, context_scope[scope_id][1])
-
-    del context_scope[scope_id]
-    context_scope[scope_id] = new
-
-
-@contextmanager
-def new_scope(interpreter, initial_vars: Optional[Dict[str, Any]] = None):
-    """
-    Context manager for creating a new scope temporarily.
-    :param interpreter: The interpreter instance
-    :param initial_vars: Optional initial variables for the new scope
-    """
-    parent = interpreter.scope_id
-
-    new_scope_id: str = generate_scope_id()
-    context_scope[new_scope_id] = (1, Scope(parent))
-
-    interpreter.scope_id = new_scope_id
-    interpreter.env = get_scope(new_scope_id)
-
-    if initial_vars:
-        interpreter.env.update(initial_vars)
-    try:
-        yield
-    finally:
-        interpreter.clear()
-        interpreter.env = get_scope(parent)
-        interpreter.scope_id = parent
-