dekshell 0.2.42__py3-none-any.whl → 0.2.44__py3-none-any.whl

dekshell/core/contexts/methods.py

@@ -37,7 +37,7 @@ from dektools.cmd.git import git_parse_modules, git_clean_dir, git_fetch_min, gi
 from ...utils.beep import sound_notify
 from ...utils.cmd import pack_context_full
 from ..markers.base.core import MarkerBase, get_inner_vars
-from ..markers.invoke import InvokeMarker, GotoMarker
+from ..markers.invoke import InvokeMarker, GotoMarker, ImportMarker
 from ..redirect import search_bin_by_path_tree
 
 
@@ -100,44 +100,58 @@ def _remove_path(path):
             _remove_path(item)
 
 
-_eval_default = object()
+_default_value = object()
 
 
-def _eval_mixin(expression, default=_eval_default, translate=False):
-    context = get_inner_vars('__inner_context__', full=True)
+def _parse_expression(expression, default=_default_value, translate=False):
+    context = get_inner_vars('__inner_context__')
+    try:
+        return MarkerBase.parse_expression(context, expression, translate)
+    except NameError:
+        if default is _default_value:
+            raise
+        else:
+            return default
+
+
+def _eval_mixin(expression, default=_default_value, translate=False):
+    context = get_inner_vars('__inner_context__')
     try:
         return MarkerBase.eval_mixin(context, expression, translate)
     except NameError:
-        if default is _eval_default:
+        if default is _default_value:
             raise
         else:
             return default
 
 
-def _eval_lines(expression, default=_eval_default):
-    context = get_inner_vars('__inner_context__', full=True)
+def _eval_lines(expression, default=_default_value):
+    context = get_inner_vars('__inner_context__')
     try:
         return MarkerBase.eval_lines(context, expression)
     except NameError:
-        if default is _eval_default:
+        if default is _default_value:
             raise
         else:
             return default
 
 
-def _invoke(__placeholder__filepath, *args, **kwargs):
-    marker_set = get_inner_vars('__inner_marker_set__', full=True)
-    filepath = normal_path(__placeholder__filepath)
-    cwd = os.getcwd()
-    os.chdir(os.path.dirname(filepath))
-    ret_value = marker_set.shell_exec(filepath, pack_context_full(args, kwargs))
-    os.chdir(cwd)
-    return ret_value
+def _global_update(variables):
+    context = get_inner_vars('__inner_context__')
+    for k, v in variables.items():
+        MarkerBase.set_var_raw(context, k, v)
 
 
-def _goto(__placeholder__filepath, *args, **kwargs):
-    marker_set = get_inner_vars('__inner_marker_set__', full=True)
-    return marker_set.shell_exec(normal_path(__placeholder__filepath), pack_context_full(args, kwargs))
+def _env_update(variables):
+    context = get_inner_vars('__inner_context__')
+    for k, v in variables.items():
+        context.add_env(k, v)
+
+
+def _envs_update(variables):
+    context = get_inner_vars('__inner_context__')
+    for k, v in variables.items():
+        context.environ.add_item(k, v)
 
 
 def _defined(name):
@@ -207,7 +221,7 @@ def _time_mark(begin=True, name=None):
     if name is None:
         name = ''
     name = str(name).strip()
-    marker_set = get_inner_vars('__inner_marker_set__', full=True)
+    marker_set = get_inner_vars('__inner_marker_set__')
     _now = time.time_ns()
     if begin:
         marker_set.vars.add_item(var_prefix + name, _now)
@@ -254,10 +268,27 @@ default_methods = {
         'timeout': shell_timeout,
         'retry': shell_retry,
         'run': shell_wrapper,
+        'env': {
+            None: lambda k, v: _env_update({k: v}),
+            'update': _env_update,
+        },
+        'envs': {
+            None: lambda k, v: _envs_update({k: v}),
+            'update': _envs_update,
+        },
+        'expr': _parse_expression,
         'eval': _eval_mixin,
         'exec': _eval_lines,
-        'invoke': _invoke,
-        'goto': _goto,
+        'var': {
+            None: lambda k, v: _global_update({k: v}),
+            'update': _global_update,
+        },
+        'invoke': lambda __placeholder__filepath, *args, **kwargs: InvokeMarker.execute_file(
+            None, __placeholder__filepath, args, kwargs),
+        'goto': lambda __placeholder__filepath, *args, **kwargs: GotoMarker.execute_file(
+            None, __placeholder__filepath, args, kwargs),
+        'imp': lambda __placeholder__filepath, *args, **kwargs: ImportMarker.execute_file(
+            None, __placeholder__filepath, args, kwargs),
     },
     'path': {
         **path_common_methods,
@@ -350,11 +381,6 @@ default_methods = {
 
     'beep': lambda x=True: sound_notify(x),
 
-    'invoke': lambda __placeholder__filepath, *args, **kwargs: InvokeMarker.execute_file(
-        None, __placeholder__filepath, args, kwargs),
-    'goto': lambda __placeholder__filepath, *args, **kwargs: GotoMarker.execute_file(
-        None, __placeholder__filepath, args, kwargs),
-
     'glob': {
         're': glob2re,
         'compile': glob_compile,

dekshell/core/contexts/properties.py

@@ -44,37 +44,36 @@ is_on_win = os.name == "nt"
 path_root = path_home[:path_home.find(os.sep)] if is_on_win else os.sep
 
 
-class _Env:
-    def __getattr__(self, item):
-        return os.environ.get(item.upper(), '')
-
-    def __getitem__(self, item):
-        return os.environ[item.upper()]
-
-    def __contains__(self, item):
-        return item.upper() in os.environ
+class _EnvBase:
+    __getenv__ = None
 
-
-class _EnvS:
     def __getattr__(self, item):
-        context = get_inner_vars('__inner_context__', full=True)
-        return context.get_env(item.upper(), '')
+        context = get_inner_vars('__inner_context__')
+        return getattr(context, self.__getenv__)(item.upper(), '')
 
     def __getitem__(self, item):
-        context = get_inner_vars('__inner_context__', full=True)
+        context = get_inner_vars('__inner_context__')
         default = object()
-        ret = context.get_env(item.upper(), default)
+        ret = getattr(context, self.__getenv__)(item.upper(), default)
         if ret is default:
             raise KeyError(item)
         return ret
 
     def __contains__(self, item):
-        context = get_inner_vars('__inner_context__', full=True)
+        context = get_inner_vars('__inner_context__')
         default = object()
-        ret = context.get_env(item.upper(), default)
+        ret = getattr(context, self.__getenv__)(item.upper(), default)
         return ret is not default
 
 
+class _Env(_EnvBase):
+    __getenv__ = 'get_env'
+
+
+class _EnvS(_EnvBase):
+    __getenv__ = 'get_env_full'
+
+
 default_properties = {
     'meta': {
         'name': package_name,

dekshell/core/markers/__init__.py

@@ -46,8 +46,12 @@ def generate_markers(*args, **kwargs):
         TimeoutMarker, RetryMarker,
         IgnoreMarker,
         IgnoreErrorShellMarker, PrefixShellMarker,
-        AssignCallMarker, AssignInvokerMarker, AssignGotoMarker, AssignTimeoutMarker, AssignRetryMarker,
-        AssignExecMarker, AssignTranslatorEvalMarker, AssignEvalMarker, AssignCmdcallMarker, AssignCmdcallChainMarker,
+        AssignCallMarker, AssignInvokerMarker, AssignGotoMarker, AssignImportMarker, AssignTimeoutMarker,
+        AssignRetryMarker,
+        AssignExecMarker, AssignTranslatorEvalMarker, AssignEvalMarker,
+        AssignCommandRcSilenceMarker, AssignCommandRcMarker, AssignCommandOutputMarker,
+        AssignDecodeMarker, AssignEncodeMarker,
+        AssignEnvMarker, AssignEnvFullMarker, AssignCmdcallMarker, AssignCmdcallChainMarker,
         AssignMultiLineRawStrMarker, AssignMultiLineStrMarker, AssignRawStrMarker, AssignStrMarker,
         EmptyMarker,  # must be at the tail
     ]

dekshell/core/markers/base/__init__.py

@@ -1,4 +1,3 @@
-import os
 import re
 import functools
 from dektools.str import deep_format, split_table_line, shlex_split, shlex_quote
@@ -99,8 +98,9 @@ class MarkerBase:
     def raise_(self, message):
         raise RaiseException(message)
 
-    def set_var(self, context, array, index, value):
-        self.set_var_raw(context, self.get_item(array, index, self.var_name_anonymous), value)
+    @classmethod
+    def set_var(cls, context, array, index, value):
+        cls.set_var_raw(context, cls.get_item(array, index, cls.var_name_anonymous), value)
 
     @staticmethod
     def set_var_raw(context, name, value):
@@ -114,7 +114,9 @@ class MarkerBase:
     def cmd_call_split(cls, s, max_item=None):
         if max_item == 0:
             return [], s.lstrip()
-        m = re.match(rf'[ \t\f\r]*({cmd_call_prefix_simple}[{cmd_call_prefix_simple}]?)[ \t\f\r]*([^\W\d][\w.]*)', s)
+        m = re.match(
+            rf'''[ \t\f\r]*({cmd_call_prefix_simple}[{cmd_call_prefix_simple}]?)[ \t\f\r]*([^\W\d][\w.]*)'''
+            , s)
         if not m:
             return [], s.lstrip()
         rest = s[m.span()[1]:]
@@ -154,73 +156,83 @@ class MarkerBase:
         def handler(expression, _, __):
             expression = expression.lstrip()
             as_var = False
-            ignore = False
+            ignore_errors = False
             while True:
                 change = 0
                 if not as_var and expression.startswith(cls.trans_marker__as_var):
                     expression = expression[len(cls.trans_marker__as_var):].lstrip()
                     as_var = True
-                    change +=1
-                if not ignore and expression.startswith(cls.trans_marker__ignore):
+                    change += 1
+                if not ignore_errors and expression.startswith(cls.trans_marker__ignore):
                     expression = expression[len(cls.trans_marker__ignore):].lstrip()
-                    ignore = True
-                    change +=1
+                    ignore_errors = True
+                    change += 1
                 if change in (0, 2):
                     break
-            value = handler_core(expression, ignore)
+            value = cls.parse_expression(context, expression, False, False, ignore_errors)
             if as_var:
                 return context.add_variable_temp(value)
             return value
 
-        def evaluate(expression, ignore, default):
+        return deep_format(
+            s,
+            # f"{re.escape(cls.trans_marker__begin)}({cls.trans_marker__set})?",
+            f"{re.escape(cls.trans_marker__begin)}",
+            re.escape(cls.trans_marker__end), handler, cls.trans_marker__escape)
+
+    @classmethod
+    def parse_expression(cls, context, expression, translate_eval=True, translate_others=True, ignore_errors=False):
+        def evaluate(expr, default):
             try:
-                return cls.eval_mixin(context, expression, False)
+                return cls.eval_mixin(context, expr, translate_eval)
             except NameError:
-                if ignore:
+                if ignore_errors:
                     return default
                 else:
                     raise
 
-        def handler_core(expression, ignore):
-            if expression.startswith(cls.trans_marker_command_rc_silence):
-                expression = expression[len(cls.trans_marker_command_rc_silence):]
-                return shell_exitcode(expression, env=context.environ_full())
-            elif expression.startswith(cls.trans_marker_command_rc):
-                expression = expression[len(cls.trans_marker_command_rc):]
-                return shell_wrapper(expression, check=False, env=context.environ_full())
-            elif expression.startswith(cls.trans_marker_command_output):
-                expression = expression[len(cls.trans_marker_command_output):]
-                return shell_output(expression, env=context.environ_full())
-            elif expression.startswith(cls.trans_marker_env):
-                expression = expression[len(cls.trans_marker_env):]
-                return os.getenv(expression.strip(), default_value)
-            elif expression.startswith(cls.trans_marker_env_full):
-                expression = expression[len(cls.trans_marker_env_full):]
-                return context.get_env(expression.strip(), default_value)
-            elif expression.startswith(cls.trans_marker_decode):
-                expression = expression[len(cls.trans_marker_decode):]
-                value = evaluate(expression, ignore, empty_value)
-                if value is empty_value:
-                    return default_value
-                return serializer.load(value)
-            elif expression.startswith(cls.trans_marker_encode):
-                expression = expression[len(cls.trans_marker_encode):]
-                value = evaluate(expression, ignore, empty_value)
-                if value is empty_value:
-                    return default_value
-                return serializer.dump(value)
-            else:
-                return evaluate(expression, ignore, default_value)
-
         empty_value = object()
         default_value = ''
 
-        translate = deep_format(
-            s,
-            # f"{re.escape(cls.trans_marker__begin)}({cls.trans_marker__set})?",
-            f"{re.escape(cls.trans_marker__begin)}",
-            re.escape(cls.trans_marker__end), handler, cls.trans_marker__escape)
-        return translate
+        if expression.startswith(cls.trans_marker_command_rc_silence):
+            expression = expression[len(cls.trans_marker_command_rc_silence):]
+            if translate_others:
+                expression = cls.translate_case(context, expression, True)
+            return shell_exitcode(expression, env=context.environ_full())
+        elif expression.startswith(cls.trans_marker_command_rc):
+            expression = expression[len(cls.trans_marker_command_rc):]
+            if translate_others:
+                expression = cls.translate_case(context, expression, True)
+            return shell_wrapper(expression, check=False, env=context.environ_full())
+        elif expression.startswith(cls.trans_marker_command_output):
+            expression = expression[len(cls.trans_marker_command_output):]
+            if translate_others:
+                expression = cls.translate_case(context, expression, True)
+            return shell_output(expression, env=context.environ_full())
+        elif expression.startswith(cls.trans_marker_env):
+            expression = expression[len(cls.trans_marker_env):]
+            if translate_others:
+                expression = cls.translate_case(context, expression, True)
+            return context.get_env(expression.strip(), default_value)
+        elif expression.startswith(cls.trans_marker_env_full):
+            expression = expression[len(cls.trans_marker_env_full):]
+            if translate_others:
+                expression = cls.translate_case(context, expression, True)
+            return context.get_env_full(expression.strip(), default_value)
+        elif expression.startswith(cls.trans_marker_decode):
+            expression = expression[len(cls.trans_marker_decode):]
+            value = evaluate(expression, empty_value)
+            if value is empty_value:
+                return default_value
+            return serializer.load(value)
+        elif expression.startswith(cls.trans_marker_encode):
+            expression = expression[len(cls.trans_marker_encode):]
+            value = evaluate(expression, empty_value)
+            if value is empty_value:
+                return default_value
+            return serializer.dump(value)
+        else:
+            return evaluate(expression, default_value)
 
     @classproperty
     @functools.lru_cache(None)

dekshell/core/markers/base/core.py

@@ -7,7 +7,7 @@ from dektools.typing import NoneType
 from . import MarkerBase, TransformerMarker, ExitException, QuitContextException
 
 
-def get_inner_vars(*var_name_list, full=False):
+def get_inner_vars(*var_name_list, full=True):
     def walk(attr):
         depth = 1
         while True:
@@ -87,13 +87,25 @@ class MarkerContext:
         environ.update(self.environ.flat())
         return environ
 
-    def get_env(self, name, default=None):
+    def get_env_full(self, name, default=None):
         empty = object()
         value = self.environ.get_item(name, empty)
         if value is not empty:
             return value
+        return self.get_env(name, default)
+
+    @staticmethod
+    def get_env(name, default=None):
         return os.environ.get(name, default)
 
+    @staticmethod
+    def add_env(key, value):
+        os.environ[key] = value
+
+    @staticmethod
+    def remove_env(key):
+        os.environ.pop(key, None)
+
 
 class HiddenVarSet:
     def __init__(self):
@@ -192,11 +204,12 @@ class MarkerNode:
     @classmethod
     def execute_nodes(cls, context, marker_set, nodes):
         __inner_marker_set__ = marker_set  # noqa
+        context_final = None
         while nodes:
             node = nodes.pop(0)
             result = node.bubble_continue(context, marker_set, node)
             if result is not None:
-                return result
+                return result, context
             else:
                 try:
                     changes = node.marker.execute(
@@ -205,7 +218,7 @@ class MarkerNode:
                         node, marker_set
                     )
                 except QuitContextException as e:
-                    return QuitContext(context, e.args[0])
+                    return QuitContext(context, e.args[0]), context
                 except ExitException:
                     raise
                 except Exception as e:
@@ -239,9 +252,10 @@ class MarkerNode:
                         context_ = context.derive().update_variables(variables)
                 elif changes is not None:
                     raise TypeError(f"Unknown type of changes: {changes}")
+                context_final = context_
                 if nodes_ is None:
                     nodes_ = node.children[:]
-                result = cls.execute_nodes(
+                result, _ = cls.execute_nodes(
                     context_,
                     marker_set,
                     nodes_
@@ -251,16 +265,20 @@ class MarkerNode:
                     if node is node_cursor:  # Depth of the location
                         nodes[:0] = node_loop_list
                     else:
-                        return result
+                        return result, context_
                 elif isinstance(result, QuitContext):
                     if result.context is context:
-                        return result
+                        return result, context_
                     else:
                         if callback:
                             callback(result)
+        if context_final is None:
+            context_final = context
+        return None, context_final
 
     def execute(self, context, marker_set):
-        return QuitContext.real(self.execute_nodes(context, marker_set, [self]))
+        result, context = self.execute_nodes(context, marker_set, [self])
+        return QuitContext.real(result), context
 
     def walk(self, cb, depth=0):
         cb(self, depth)
@@ -281,11 +299,20 @@ class MarkerNode:
         return self.index + 1
 
 
+class ShellResult:
+    def __init__(self, marker_set: 'MarkerSet', root: MarkerNode, context: MarkerContext, result):
+        self.marker_set = marker_set
+        self.root = root
+        self.context = context
+        self.result = result
+
+
 class MarkerSet:
     node_cls = MarkerNode
     context_cls = MarkerContext
     transformer_cls = TransformerMarker
     hidden_var_set_cls = HiddenVarSet
+    shell_result_cls = ShellResult
 
     def __init__(self, markers_cls, shell_exec, shell_cmd):
         markers = []
@@ -353,7 +380,8 @@ class MarkerSet:
     def execute(self, commands, context, ln=None):
         try:
             root = self.generate_tree(commands, ln)
-            return root.execute(
+            result, context = root.execute(
                 self.context_cls().update_variables({**(context or {}), **dict(__inner_marker_set__=self)}), self)
+            return self.shell_result_cls(self, root, context, result)
         except ExitException:
             pass

dekshell/core/markers/define.py

@@ -12,5 +12,5 @@ class DefineMarker(MarkerNoTranslator):
         except NameError:
             expression = self.get_item(args, 2)
             if expression:
-                result = self.eval_mixin(context, expression)
+                result = self.parse_expression(context, expression)
                 self.set_var_raw(context, var_name, result)

dekshell/core/markers/env.py

@@ -24,9 +24,9 @@ class EnvMarker(MarkerEnvBase):
         if key:
             key = key.upper()
             if value is None:
-                os.environ.pop(key, None)
+                context.remove_env(key)
             else:
-                os.environ[key] = value
+                context.add_env(key, value)
 
 
 class EnvShellMarker(MarkerEnvBase):

dekshell/core/markers/exec.py

@@ -22,7 +22,7 @@ class ExecTranslatorMarker(MarkerBase):
 
 
 class ExecLinesMarker(MarkerWithEnd, MarkerNoTranslator):
-    tag_head = '=='
+    tag_head = cmd_call_eval_prefix * 2
 
     def execute(self, context, command, marker_node, marker_set):
         code = self.get_inner_content(context, marker_node, translate=False)
@@ -31,7 +31,7 @@ class ExecLinesMarker(MarkerWithEnd, MarkerNoTranslator):
 
 
 class ExecLinesUpdateMarker(MarkerWithEnd, MarkerNoTranslator):
-    tag_head = '==='
+    tag_head = cmd_call_eval_prefix * 3
 
     def execute(self, context, command, marker_node, marker_set):
         code = self.get_inner_content(context, marker_node, translate=False)

dekshell/core/markers/for_.py

@@ -49,4 +49,4 @@ class ForMarker(MarkerWithEnd, MarkerNoTranslator):
         ]
 
     def get_expression_value(self, context, expression):
-        return self.eval_mixin(context, expression)
+        return self.parse_expression(context, expression)

dekshell/core/markers/function.py

@@ -35,9 +35,9 @@ class Function:
         self.body = body
 
     def __call__(self, *args, **kwargs):
-        context, marker_set = get_inner_vars('__inner_context__', '__inner_marker_set__', full=True)
+        context, marker_set = get_inner_vars('__inner_context__', '__inner_marker_set__')
         context = context.derive().update_variables(self.pack_variables(context, args, kwargs))
-        return QuitContext.real(marker_set.node_cls.execute_nodes(context, marker_set, self.body[:]))
+        return QuitContext.real(marker_set.node_cls.execute_nodes(context, marker_set, self.body[:])[0])
 
     def __str__(self):
         return f"{self.__class__.__name__}<{self.name}>"
@@ -48,10 +48,11 @@ class Function:
 
 class FunctionMarker(MarkerWithEnd):
     tag_head = "function"
+    function_cls = Function
 
     def execute(self, context, command, marker_node, marker_set):
         name, params = assign_list([''] * 2, self.split_raw(command, 2)[1:])
-        self.set_var_raw(context, name, Function(name, params, marker_node.children[:]))
+        self.set_var_raw(context, name, self.function_cls(name, params, marker_node.children[:]))
         return []
 
 
@@ -60,7 +61,7 @@ class ReturnMarker(MarkerNoTranslator):
 
     def execute(self, context, command, marker_node, marker_set):
         args = self.split_raw(command, 1, self.tag_head)
-        self.ret(self.eval_mixin(context, args[1]))
+        self.ret(self.parse_expression(context, args[1]))
 
 
 class RaiseMarker(MarkerBase):

dekshell/core/markers/if_.py

@@ -18,7 +18,7 @@ class MarkerWithJudge(MarkerWithEnd, MarkerNoTranslator):
     def get_condition_result(self, context, expression):
         if not expression:
             return self.empty_expected_value
-        return self.eval_mixin(context, expression)
+        return self.parse_expression(context, expression)
 
 
 class IfElseMarker(MarkerWithJudge):

dekshell/core/markers/input.py

@@ -9,7 +9,7 @@ class InputMarker(MarkerWithEnd, MarkerNoTranslator):
     def execute(self, context, command, marker_node, marker_set):
         command_text = self.get_inner_content(context, marker_node, sep='', translate=True).strip()
         expression = self.split_raw(command, 1, self.tag_head)[1]
-        inputs = self.eval_mixin(context, expression)
+        inputs = self.parse_expression(context, expression)
         rc = shell_with_input(command_text, inputs, env=context.environ_full())
         if rc:
             raise subprocess.CalledProcessError(rc, command_text)

dekshell/core/markers/invoke.py

@@ -17,7 +17,7 @@ class MarkerInvokerBase(MarkerBase):
     @classmethod
     def execute_file(cls, marker_set, filepath, args, kwargs):
         if marker_set is None:
-            marker_set = get_inner_vars('__inner_marker_set__', full=True)
+            marker_set = get_inner_vars('__inner_marker_set__')
         return cls._run_file(marker_set, normal_path(filepath), pack_context_full(args, kwargs))
 
     @classmethod
@@ -30,7 +30,7 @@ class GotoMarker(MarkerInvokerBase):
 
     @classmethod
     def _run_file(cls, marker_set, filepath, attrs):
-        return marker_set.shell_exec(filepath, attrs)
+        return marker_set.shell_exec(filepath, attrs).result
 
 
 class InvokeMarker(MarkerInvokerBase):
@@ -40,6 +40,26 @@ class InvokeMarker(MarkerInvokerBase):
     def _run_file(cls, marker_set, filepath, attrs):
         cwd = os.getcwd()
         os.chdir(os.path.dirname(filepath))
-        ret_value = marker_set.shell_exec(filepath, attrs)
+        ret_value = marker_set.shell_exec(filepath, attrs).result
         os.chdir(cwd)
         return ret_value
+
+
+class Closure:
+    def __init__(self, shell_result):
+        self.__variables__ = shell_result.context.variables
+
+    def __getattr__(self, item):
+        return self.__variables__.get_item(item)
+
+    def __getitem__(self, item):
+        return self.__variables__.get_item(item, None)
+
+
+class ImportMarker(MarkerInvokerBase):
+    tag_head = "import"
+    closure_cls = Closure
+
+    @classmethod
+    def _run_file(cls, marker_set, filepath, attrs):
+        return cls.closure_cls(marker_set.shell_exec(filepath, attrs))

dekshell/core/markers/var.py

@@ -1,8 +1,9 @@
 import re
-from .base import MarkerBase, MarkerWithEnd, MarkerNoTranslator, cmd_call_prefix_simple, cmd_call_prefix_chain
+from .base import MarkerBase, MarkerWithEnd, MarkerNoTranslator, cmd_call_prefix_simple, cmd_call_prefix_chain, \
+    cmd_call_eval_prefix, cmd_call_eval_trans_prefix
 from .function import CallMarker
 from .shell import TimeoutMarker, RetryMarker
-from .invoke import MarkerInvokerBase, InvokeMarker, GotoMarker
+from .invoke import MarkerInvokerBase, InvokeMarker, GotoMarker, ImportMarker
 
 
 class MarkerAssignBase(MarkerBase):
@@ -57,21 +58,21 @@ class AssignMultiLineRawStrMarker(AssignMultiLineStrMarker, MarkerNoTranslator):
 
 
 class AssignEvalMarker(MarkerAssignValueBase, MarkerNoTranslator):
-    tag_head_re_args = '='
+    tag_head_re_args = cmd_call_eval_prefix
 
     def get_value(self, context, marker_node, marker_set, expression):
         return self.eval(context, expression)
 
 
 class AssignTranslatorEvalMarker(MarkerAssignValueBase):
-    tag_head_re_args = '=:'
+    tag_head_re_args = cmd_call_eval_trans_prefix
 
     def get_value(self, context, marker_node, marker_set, expression):
         return self.eval(context, expression)
 
 
 class AssignExecMarker(MarkerAssignBase, MarkerWithEnd, MarkerNoTranslator):
-    tag_head_re_args = '=='
+    tag_head_re_args = cmd_call_eval_prefix * 2
 
     def execute(self, context, command, marker_node, marker_set):
         code = self.get_inner_content(context, marker_node, translate=False)
@@ -81,15 +82,55 @@ class AssignExecMarker(MarkerAssignBase, MarkerWithEnd, MarkerNoTranslator):
         return []
 
 
-class AssignCmdcallMarker(MarkerAssignValueBase):
-    tag_head_re_args_raw = cmd_call_prefix_simple
-    tag_head_re_args = re.escape(tag_head_re_args_raw)
+class MarkerAssignValueParseExprBase(MarkerAssignValueBase):
+    tag_head_re_args_raw = None
 
     def get_value(self, context, marker_node, marker_set, expression):
-        return self.eval_mixin(context, self.tag_head_re_args_raw + expression, False)
+        return self.parse_expression(context, self.tag_head_re_args_raw + expression, False)
+
+
+class AssignCommandRcSilenceMarker(MarkerAssignValueParseExprBase):
+    tag_head_re_args_raw = MarkerBase.trans_marker_command_rc_silence
+    tag_head_re_args = re.escape(MarkerBase.trans_marker_command_rc_silence)
+
+
+class AssignCommandRcMarker(MarkerAssignValueParseExprBase):
+    tag_head_re_args_raw = MarkerBase.trans_marker_command_rc
+    tag_head_re_args = re.escape(MarkerBase.trans_marker_command_rc)
+
+
+class AssignCommandOutputMarker(MarkerAssignValueParseExprBase):
+    tag_head_re_args_raw = MarkerBase.trans_marker_command_output
+    tag_head_re_args = re.escape(MarkerBase.trans_marker_command_output)
+
+
+
+class AssignDecodeMarker(MarkerAssignValueParseExprBase):
+    tag_head_re_args_raw = MarkerBase.trans_marker_decode
+    tag_head_re_args = re.escape(MarkerBase.trans_marker_decode)
+
 
+class AssignEncodeMarker(MarkerAssignValueParseExprBase):
+    tag_head_re_args_raw = MarkerBase.trans_marker_encode
+    tag_head_re_args = re.escape(MarkerBase.trans_marker_encode)
 
-class AssignCmdcallChainMarker(AssignCmdcallMarker):
+
+class AssignEnvMarker(MarkerAssignValueParseExprBase):
+    tag_head_re_args_raw = MarkerBase.trans_marker_env
+    tag_head_re_args = re.escape(MarkerBase.trans_marker_env)
+
+
+class AssignEnvFullMarker(MarkerAssignValueParseExprBase):
+    tag_head_re_args_raw = MarkerBase.trans_marker_env_full
+    tag_head_re_args = re.escape(MarkerBase.trans_marker_env_full)
+
+
+class AssignCmdcallMarker(MarkerAssignValueParseExprBase):
+    tag_head_re_args_raw = cmd_call_prefix_simple
+    tag_head_re_args = re.escape(tag_head_re_args_raw)
+
+
+class AssignCmdcallChainMarker(MarkerAssignValueParseExprBase):
     tag_head_re_args_raw = cmd_call_prefix_chain + cmd_call_prefix_simple
     tag_head_re_args = re.escape(tag_head_re_args_raw)
 
@@ -120,6 +161,10 @@ class AssignGotoMarker(AssignMarkerInvokerBase, GotoMarker):
     tag_head_re_args = r'goto[ \t\f\r\n]+'
 
 
+class AssignImportMarker(AssignMarkerInvokerBase, ImportMarker):
+    tag_head_re_args = r'import[ \t\f\r\n]+'
+
+
 class AssignTimeoutMarker(MarkerAssignValueBase, TimeoutMarker):
     tag_head = None
     tag_head_re_args = r'timeout[ \t\f\r\n]+'

dekshell/core/markers/while_.py

@@ -29,4 +29,4 @@ class WhileMarker(MarkerWithEnd, MarkerNoTranslator):
         expression = command.split(self.tag_head, 1)[-1].strip()
         if not expression:
             return True
-        return self.eval_mixin(context, expression)
+        return self.parse_expression(context, expression)

{dekshell-0.2.42.dist-info → dekshell-0.2.44.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dekshell
-Version: 0.2.42
+Version: 0.2.44
 Author-Email: sanzenwin <sanzenwin@gmail.com>
 License: MIT
 Requires-Python: >=3.8

{dekshell-0.2.42.dist-info → dekshell-0.2.44.dist-info}/RECORD

@@ -1,34 +1,34 @@
-dekshell-0.2.42.dist-info/METADATA,sha256=_Qmh2L_sLWIq08ko5SNnZZITaHfsXTMxgNUUQ4zKXCE,573
-dekshell-0.2.42.dist-info/WHEEL,sha256=tSfRZzRHthuv7vxpI4aehrdN9scLjk-dCJkPLzkHxGg,90
-dekshell-0.2.42.dist-info/entry_points.txt,sha256=d-kbfULiUTZWIBBsrQF3J_-wESncF-4K2rwHT08grlI,75
+dekshell-0.2.44.dist-info/METADATA,sha256=6Xsby8G1U04hzm55dWk8guaay6q8AGdoHvIcXiFKte0,573
+dekshell-0.2.44.dist-info/WHEEL,sha256=tSfRZzRHthuv7vxpI4aehrdN9scLjk-dCJkPLzkHxGg,90
+dekshell-0.2.44.dist-info/entry_points.txt,sha256=d-kbfULiUTZWIBBsrQF3J_-wESncF-4K2rwHT08grlI,75
 dekshell/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dekshell/click/__entry__.py,sha256=CMuxUzXoEe4TcHFZwv-MNFwHnu1HSZCDpXFpqQ814uM,42
 dekshell/click/__init__.py,sha256=r-AHdO9CEEVvTN20-8Jozr6Zh8XSv_BnktYRwrlhtrE,2046
 dekshell/core/__init__.py,sha256=isDEKwk1odLdvTQNCILCtVNBuXp1uFVPz_uTDNihkVU,5547
 dekshell/core/contexts/__init__.py,sha256=ynsfv37azOKfI2UKd0iPl2M6iBW-k5cb1BqSLOWuJpI,482
-dekshell/core/contexts/methods.py,sha256=uSepT9G6VT2NSs_EtSWZdFD3kt6dwcHcZOSknPougCg,11089
-dekshell/core/contexts/properties.py,sha256=yilnRe2I6FTIui4kXUBCWvH2ymvpEfc_13on8pAZwnY,3456
-dekshell/core/markers/__init__.py,sha256=yRQazZ1dxMltFao_RQnDnawSnQcjN_4B930MjJhaZ40,1968
-dekshell/core/markers/base/__init__.py,sha256=CsbNYGQ2Od3XdekR9RFMJ7mo9Roj-LlXS62SY50fiAY,16826
-dekshell/core/markers/base/core.py,sha256=InsUA3md2gC6GyXQsvARfeNTrfbVD3gGOYxTM8VqqPA,11679
+dekshell/core/contexts/methods.py,sha256=3Bzfv_t8At5MqR0xD7qT8zye6KQySeXr0HpwuendrdE,11789
+dekshell/core/contexts/properties.py,sha256=TQonN3T_K2cB2uakq_DVVB13B-IFwoM6t2ZkL_OMekw,3365
+dekshell/core/markers/__init__.py,sha256=ov-mU1Bt-JbifBqJAWIywduWvyGI4WkJUx5LGZNVxhg,2178
+dekshell/core/markers/base/__init__.py,sha256=WGxAr7GRDJI4-HRaLFBasTei-aPyApAnlpfbOaKmmvw,17385
+dekshell/core/markers/base/core.py,sha256=6GPz8YVWgOPjGXtS04oa85P5LUDSg4H16rvVgiPz_EA,12556
 dekshell/core/markers/base/shell.py,sha256=fiFsTUDI8pSDDUCk834OI4ajri2qNWFJkLVhmUk2uAs,484
 dekshell/core/markers/commands.py,sha256=mDRj4dSfKbDaZ_ts4lPXd6wftvGFI4VKkRoIzxV7otA,1696
 dekshell/core/markers/comment.py,sha256=U1U3Xc4-giTqSEAPa4E_DmilZM9hs9zG-PCJ9nn4y5U,965
-dekshell/core/markers/define.py,sha256=LpMSfz9ziXq2aFJ6oMpUFFo93TpBx7GxKYNzCeht4fQ,516
+dekshell/core/markers/define.py,sha256=Xlw_YPOWlmbopVIHhIeAKWSZhHhXmqb3gCbXxvuH4BQ,522
 dekshell/core/markers/echo.py,sha256=1H61qQbY9tZnrKsdTI_shTmDY5ZaSGipDuBSRptAuZw,660
 dekshell/core/markers/empty.py,sha256=pWKsHlrp6uXWU6blqOs0IgN_3kYm1OmDQiKGPERabAo,79
-dekshell/core/markers/env.py,sha256=6ZtiMNdKFbGR_DBjG6C7A8L_lJsiymN5Y5AbnTzyMrE,1158
-dekshell/core/markers/exec.py,sha256=4_7FRUEgbAtt0_9r8TmOar_Zi6VXxe6E7p3RL6sVgQg,2705
-dekshell/core/markers/for_.py,sha256=uNOEwyDsjffttEBtUYasdlj7FP_sGnQzWuTV5d5esHY,2142
-dekshell/core/markers/function.py,sha256=rLi8Lc9nf7ex3xdj8-VdJkgC1qXpr5JVMndH1YlH4mM,3815
-dekshell/core/markers/if_.py,sha256=bBG1fDCZd5alE5FSm0QhgHl6ZJn5awiqZAXnPnO-thc,1112
-dekshell/core/markers/input.py,sha256=O0yvGtt1uhbpE2gOReLseAmshVpZYMW3zV-OabZt0lw,1182
-dekshell/core/markers/invoke.py,sha256=ReE-i-ji2Bl90M8xLi8-kZrc-lL5mRUmjbGPoRcIoPw,1452
+dekshell/core/markers/env.py,sha256=hU6irauFrvsUgK9j6jifosiMn0b6mt3aOf5t9oKhxS4,1160
+dekshell/core/markers/exec.py,sha256=3yWpaCpASrMwzqVslDNzBaUVL7Lbn-zWMs-dOxUePZU,2744
+dekshell/core/markers/for_.py,sha256=wQnK3-o0dQl4A2wx8xgs6V2dzgEjEbnt4MML2fh2x8U,2148
+dekshell/core/markers/function.py,sha256=j8Cz4ouBQi_0dT6Q6pfJie-1rfIZuSIcWzGBlsKCSd8,3850
+dekshell/core/markers/if_.py,sha256=UqEnR0X9bKO7hEKol3MJNWXvP7fuJAGt8zwk3xlBCuk,1118
+dekshell/core/markers/input.py,sha256=94SWaeLnwtxRdIn9Ck0IxMZL6vOXVCedUmsp5IPAwWo,1188
+dekshell/core/markers/invoke.py,sha256=ESL2DE9DTaq33AnrXpvEudp1qtoeZFKOhLL12OQpcs0,1975
 dekshell/core/markers/pip_.py,sha256=mxXa_oqcrk4Qz-HvhlkMoirsl-SbM9Fz610leNqP1o0,832
 dekshell/core/markers/redirect.py,sha256=cpTQaXFAuSwprsrhUNP0xTGDmu06HGNQVcwKsETEjas,1981
 dekshell/core/markers/shell.py,sha256=43BDAAzMdmgZmemkW5buh_w4LL1GDGw-s9fNZo6vhag,1929
-dekshell/core/markers/var.py,sha256=CnmBDQvA5XcQlioczXFhCvIbDc8ex4RIAgDeQvFdIiY,5176
-dekshell/core/markers/while_.py,sha256=e7lI5jsIM-qxNHMY_wUyCMvvesdXQibR5Ez2jNO9csc,1195
+dekshell/core/markers/var.py,sha256=ZNhyH6wHz3H6fM7L28dfaI-7_cqJY8m6kGE5hP756i8,6884
+dekshell/core/markers/while_.py,sha256=Q0SaElyXSrxg-wS_rfCcxMsmw9jf-0SgN1ICn860T4A,1201
 dekshell/core/plugin/__init__.py,sha256=jAB_KnnHJsyJR_zIfBU_HNLngyhcyyqVv05PdlNZtF8,428
 dekshell/core/redirect.py,sha256=6YCJpG0TkQ4WMt7LBtDD_W1T-C-QkLtGRQw0S60qe54,1058
 dekshell/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -37,4 +37,4 @@ dekshell/utils/cmd.py,sha256=K9FbXgHcGFchHA58xI0_t4YK4yb8XkWbxsNoztYRx3Y,518
 dekshell/utils/pkg.py,sha256=TgYqRqawoJfjkxt6UAHnp9ttmpjuHiWRFbqxADOS1VE,1337
 dekshell/utils/serializer.py,sha256=aIdF2Wzo-qHmIshv46jn1XD0X66vQ1JFdU-g3ZFbH2w,386
 dekshell/utils/shell.py,sha256=0NoA2-SOOMinbmZZipwzL-npBbzPOdWEfdPVYqq5G5g,92
-dekshell-0.2.42.dist-info/RECORD,,
+dekshell-0.2.44.dist-info/RECORD,,