dshellInterpreter 1.2.1.1__tar.gz → 1.2.1.2__tar.gz

{dshellinterpreter-1.2.1.1 → dshellinterpreter-1.2.1.2}/Dshell/DISCORD_COMMANDS/dshell_ui.py

@@ -13,19 +13,24 @@ from ..DshellParser.ast_nodes import UiSelectNode, UiButtonNode, OptionUiSelectN
 
 from ..DshellInterpreteur.utils_interpreter import regroupe_commandes
 
-from ..DshellInterpreteur.dshell_scope import new_scope
+from ..DshellInterpreteur.dshell_scope import new_scope, get_scope, update_nbr_usage_scope, get_usage_scope
 
-from Dshell.full_import import Any, TYPE_CHECKING, Union
+from Dshell.full_import import Any, TYPE_CHECKING, Union, Optional
 
 from .utils.utils_type_validation import (_validate_optional_code_node,
+                                          _validate_required_int,
                                           _validate_optional_int,
-                                          _validate_optional_string)
+                                          _validate_optional_string,
+                                          _validate_required_string,
+                                          _validate_required_bool,
+                                          _validate_missing_or_type)
 
 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,
@@ -42,29 +47,26 @@ async def build_ui_button_parameters(ui_button_node: UiButtonNode, interpreter:
     :param interpreter:
     :return:
     """
+    _CMD = "button"
+
     regrouped_parameters = await regroupe_commandes(ui_button_node.body, interpreter, normalise=True)
     args_button: dict[str, list[Any]] = regrouped_parameters.get_dict_parameters()
 
     code = args_button.pop('code', None)
-    style = args_button.pop('style', 'primary').lower()
+    style = args_button.pop('style', StrNode('primary')).lower()
     custom_id = args_button.pop('custom_id', StrNode('ui_button_'+str(random())))
     row = args_button.pop('row', IntNode(0))
     emoji = utils_refactor_emoji(args_button.pop('emoji', None))
 
-    _validate_optional_code_node(code, "Button code", "build_ui_button")
-
-    if not isinstance(custom_id, StrNode):
-        raise TypeError(f"Button custom_id must be a string, not {type(custom_id)} !")
+    _validate_optional_code_node(code, "code", _CMD)
+    _validate_required_string(style, "style", _CMD)
+    _validate_required_string(custom_id, "custom_id", _CMD)
+    _validate_required_int(row, "row", _CMD)
+    _validate_optional_string(emoji, "emoji", _CMD)
 
     if style not in ButtonStyleValues:
         raise ValueError(f"Button style must be one of {', '.join(ButtonStyleValues)}, not '{style}' !")
 
-    if not isinstance(row, IntNode):
-        raise TypeError(f"Buttton row must be a int, not {type(row)} !")
-
-    if not isinstance(emoji, StrNode):
-        raise TypeError(f"Button emoji must be a str, not {type(emoji)} !")
-
     args_button['custom_id'] = custom_id
     args_button['row'] = row
     args_button['style'] = ButtonStyle[style]
@@ -80,40 +82,32 @@ async def build_ui_select_parameters(ui_select_node: UiSelectNode, interpreter:
     :param interpreter:
     :return:
     """
+    _CMD = "select"
+
     regrouped_parameters = await regroupe_commandes(ui_select_node.body, interpreter, normalise=True)
     args_select: dict[str, list[Any]] = regrouped_parameters.get_dict_parameters()
 
     code = args_select.pop('code', None)
     custom_id = args_select.pop('custom_id', StrNode('ui_select_'+str(random())))
-    select_type = args_select.pop('type', 'string').lower()
-
-    disabled = args_select.get('disabled', False)
-    max_values = args_select.get('max', 1)
-    min_values = args_select.get('min', 1)
-    placeholder = args_select.get('placeholder', "")
-    row = args_select.pop('row', 0)
-
-    _validate_optional_code_node(code, "Select code", "build_ui_select")
-
-    if not isinstance(custom_id, StrNode):
-        raise TypeError(f"Select custom_id must be a string, not {type(custom_id)} !")
-
-    if select_type is None or not isinstance(select_type, StrNode) or select_type not in SelectSyleValues:
-        raise TypeError(f"Select type must be a string, not {type(select_type)} !")
-
-    if not isinstance(disabled, BoolNode):
-        raise TypeError(f"Select disabled must be a bool, not {type(disabled)} !")
-
-    if not isinstance(max_values, IntNode):
-        raise TypeError(f"Select max_values must be an int, not {type(max_values)} !")
-
-    if not isinstance(min_values, IntNode):
-        raise TypeError(f"Select min_values must be an int, not {type(min_values)} !")
-
-    if not isinstance(placeholder, StrNode):
-        raise TypeError(f"Select placeholder must be a string, not {type(placeholder)} !")
-
-    _validate_optional_int(row, "Select row", "build_ui_select")
+    select_type = args_select.pop('type', StrNode('string')).lower()
+
+    disabled = args_select.get('disabled', BoolNode(0))
+    max_values = args_select.get('max', IntNode(1))
+    min_values = args_select.get('min', IntNode(1))
+    placeholder = args_select.get('placeholder', StrNode(""))
+    row = args_select.pop('row', IntNode(0))
+
+    _validate_optional_code_node(code, "Select code", _CMD)
+    _validate_required_string(custom_id, "custom_id", _CMD)
+    _validate_required_string(select_type, "type", _CMD)
+    _validate_required_bool(disabled, "disabled", _CMD)
+    _validate_required_int(max_values, "max", _CMD)
+    _validate_required_int(max_values, "min", _CMD)
+    _validate_required_string(placeholder, "placeholder", _CMD)
+    _validate_optional_int(row, "row", _CMD)
+
+    if select_type not in SelectSyleValues:
+        raise TypeError(f"Select style must be one of {', '.join(SelectSyleValues.keys())}, not '{select_type}' !")
 
     args_select["disabled"] = disabled
     args_select["max_values"] = max_values
@@ -134,6 +128,8 @@ async def build_ui_select_options(option_nodes: list[OptionUiSelectNode], interp
     :param interpreter:
     :return:
     """
+    _CMD = "option"
+
     option_results: list[dict[str, Any]] = []
 
     for option_node in option_nodes:
@@ -146,28 +142,21 @@ async def build_ui_select_options(option_nodes: list[OptionUiSelectNode], interp
         emoji = utils_refactor_emoji(args_option.pop('emoji', None))
         default = args_option.pop('default', False)
 
-        if label is None or not isinstance(label, str):
-            raise TypeError(f"Option label must be a string, not {type(label)} !")
+        _validate_required_string(label, "label", _CMD)
+        _validate_missing_or_type(value, "value", StrNode, _CMD)
+        _validate_optional_string(description, "description", _CMD)
+        _validate_optional_string(emoji, "emoji", _CMD)
+        _validate_required_bool(default, "default", _CMD)
 
         if len(label) > 100:
             raise ValueError("Option label must be less than 100 characters !")
 
-        if value and not isinstance(value, str):
-            raise TypeError(f"Option value must be a string, not {type(value)} !")
-
         if value and len(value) > 100:
             raise ValueError("Option value must be less than 100 characters !")
 
-        _validate_optional_string(description, "Option description", "build_ui_option")
-
         if description is not None and len(description) > 100:
             raise ValueError("Option description must be less than 100 characters !")
 
-        _validate_optional_string(emoji, "Option emoji", "build_ui_option")
-
-        if not isinstance(default, bool):
-            raise TypeError(f"Option default must be a bool, not {type(default)} !")
-
         option_dict = {
             'label': label,
             'value': value,
@@ -194,7 +183,7 @@ async def build_ui(ui_node: Union[UiButtonNode, UiSelectNode], interpreter: "Dsh
         async for _, args_button, code in build_ui_button_parameters(ui_node, interpreter):
             b = ui.Button(**args_button)
             view.add_items(b)
-            view.set_callable(b.custom_id, _callable=ui_button_callback, data={'code': code, 'interpreter': interpreter})
+            view.set_callable(b.custom_id, _callable=ui_button_callback, data={'code': code, scope_id: interpreter.scope_id})
 
     elif isinstance(ui_node, UiSelectNode):
         s = SelectMenu()
@@ -209,23 +198,23 @@ 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, 'interpreter': interpreter})
+                s.set_callable(args_select["custom_id"], _callable=ui_select_callback, data={'code': code, scope_id: interpreter.scope_id})
 
             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, 'interpreter': interpreter})
+                s.set_callable(args_select["custom_id"], _callable=ui_select_callback, data={'code': code, scope_id: interpreter.scope_id})
 
             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, 'interpreter': interpreter})
+                s.set_callable(args_select["custom_id"], _callable=ui_select_callback, data={'code': code, scope_id: interpreter.scope_id})
 
             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, 'interpreter': interpreter})
+                s.set_callable(args_select["custom_id"], _callable=ui_select_callback, data={'code': code, scope_id: interpreter.scope_id})
 
             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, 'interpreter': interpreter})
+                s.set_callable(args_select["custom_id"], _callable=ui_select_callback, data={'code': code, scope_id: interpreter.scope_id})
 
         view.add_items(s)
 
@@ -258,7 +247,7 @@ async def rebuild_ui(ui_node: Union[UiButtonNode, UiSelectNode], view: EasyModif
             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, 'interpreter': interpreter})
+            view.set_callable(args_button['custom_id'], _callable=ui_button_callback, data={'code': new_code, scope_id: interpreter.scope_id})
 
     elif isinstance(ui_node, UiSelectNode):
 
@@ -279,7 +268,7 @@ async def rebuild_ui(ui_node: Union[UiButtonNode, UiSelectNode], view: EasyModif
                 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, 'interpreter': interpreter})
+            view.set_callable(args_select['custom_id'], _callable=ui_select_callback, data={'code': new_code, scope_id: interpreter.scope_id})
 
     return view
 
@@ -294,7 +283,8 @@ async def ui_button_callback(button: ui.Button, interaction: Interaction, data:
     :return:
     """
     code = data.get('code', None)
-    interpreter: "DshellInterpreteur" = data.get('interpreter', None)
+    scope: Optional[str] = data.get(scope_id, None)
+
     if code is not None:
         message = interaction
         local_env = {
@@ -382,13 +372,23 @@ async def ui_button_callback(button: ui.Button, interaction: Interaction, data:
                 }
             )
 
-        #local_env.update(data)
         from ..DshellInterpreteur.dshell_interpreter import DshellInterpreteur
 
-        new_interpreter = DshellInterpreteur(code, ctx=interaction, debug=False, vars_env=interpreter.env)
+        new_interpreter = DshellInterpreteur(
+            code,
+            ctx=interaction,
+            debug=False,
+            vars_env=get_scope(scope))
+
+        if scope is not None:
+            update_nbr_usage_scope(scope, 1)
+
         with new_scope(new_interpreter, local_env):
             await new_interpreter.execute()
 
+        if scope is not None:
+            update_nbr_usage_scope(scope, -1)
+
     else:
         await interaction.response.defer(invisible=True)
 
@@ -403,7 +403,7 @@ async def ui_select_callback(select: ui.Select, interaction: Interaction, data:
     :return:
     """
     code = data.get('code', None)
-    interpreter: "DshellInterpreteur" = data.get('interpreter', None)
+    scope: Optional[str] = data.get(scope_id, None)
 
     message = interaction
     if code is not None:
@@ -518,7 +518,20 @@ async def ui_select_callback(select: ui.Select, interaction: Interaction, data:
 
         local_env.update(data)
         from ..DshellInterpreteur.dshell_interpreter import DshellInterpreteur
-        with new_scope(interpreter, local_env):
-            await DshellInterpreteur(code, ctx=interaction, debug=False, vars_env=interpreter.env).execute()
+        new_interpreter = DshellInterpreteur(
+            code,
+            ctx=interaction,
+            debug=False,
+            vars_env=get_scope(scope))
+
+        if scope is not None:
+            update_nbr_usage_scope(scope, 1)
+
+        with new_scope(new_interpreter, local_env):
+            await new_interpreter.execute()
+
+        if scope is not None:
+            update_nbr_usage_scope(scope, -1)
+
     else:
         await interaction.response.defer(invisible=True)

{dshellinterpreter-1.2.1.1 → dshellinterpreter-1.2.1.2}/Dshell/DshellInterpreteur/dshell_interpreter.py

@@ -1,9 +1,8 @@
 from ..DshellTokenizer.dshell_token_type import Token
 from ..DshellTokenizer.dshell_token_type import DshellTokenType as DTT
-from ..DshellInterpreteur.errors import DshellInterpreterStopExecution, DshellInterpreterError
-from Dshell.full_import import TypeVar, Union, Optional, Any, Callable, sleep, findall
+from ..full_import import TypeVar, Union, Optional, Any, Callable, sleep, findall
 from ..DshellParser.ast_nodes import *
-from Dshell.full_import import AutoShardedBot, Interaction, Message, PrivateChannel
+from ..full_import import AutoShardedBot, Interaction, Message, PrivateChannel, random
 from ..DshellParser.dshell_parser import parse, print_ast
 from ..DshellTokenizer.dshell_tokenizer import DshellTokenizer
 from .cached_messages import dshell_cached_messages
@@ -12,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
+from .dshell_scope import Scope, new_scope, get_scope, create_scope, update_nbr_usage_scope, get_usage_scope
 from .dshell_global_variables import MAX_SLEEP_TIME_SECONDS, MIN_SLEEP_TIME_SECONDS
 
 
@@ -48,7 +47,14 @@ class DshellInterpreteur:
             self.ast: list[ASTNode] = code.body
 
         message = ctx.message if isinstance(ctx, Interaction) else ctx
-        self.env: Scope = Scope()
+
+        # scope creation
+        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.update({
             '__ret__': None,  # environment variables, '__ret__' is used to store the return value of commands
             '__loop__': None,  # used to store the current loop variable in loop nodes if the loop identifier is not specified
@@ -329,6 +335,7 @@ class DshellInterpreteur:
         """
         self.env.clear()
         self.ast.clear()
+        update_nbr_usage_scope(self.scope_id, -1)
 
 
 async def call_function(function: Callable, args: ArgsCommandNode, interpreter: DshellInterpreteur):

dshellinterpreter-1.2.1.2/Dshell/DshellInterpreteur/dshell_scope.py

@@ -0,0 +1,159 @@
+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
+

{dshellinterpreter-1.2.1.1/dshellInterpreter.egg-info → dshellinterpreter-1.2.1.2}/PKG-INFO

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

{dshellinterpreter-1.2.1.1 → dshellinterpreter-1.2.1.2/dshellInterpreter.egg-info}/PKG-INFO

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

{dshellinterpreter-1.2.1.1 → dshellinterpreter-1.2.1.2}/setup.py

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

dshellinterpreter-1.2.1.1/Dshell/DshellInterpreteur/dshell_scope.py

@@ -1,81 +0,0 @@
-from contextlib import contextmanager
-from typing import Any, Optional, Dict, Set
-
-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) -> 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:
-            return self.parent.get(name)
-        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
-    interpreter.env = Scope(parent)
-    if initial_vars:
-        interpreter.env.update(initial_vars)
-    try:
-        yield
-    finally:
-        interpreter.env.clear()
-        interpreter.env = parent