dekshell 0.2.42__py3-none-any.whl → 0.2.43__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
 
 
@@ -125,19 +125,10 @@ def _eval_lines(expression, default=_eval_default):
             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 _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 _global_update(variables):
+    context = get_inner_vars('__inner_context__', full=True)
+    for k, v in variables.items():
+        MarkerBase.set_var_raw(context, k, v)
 
 
 def _defined(name):
@@ -256,8 +247,14 @@ default_methods = {
         'run': shell_wrapper,
         'eval': _eval_mixin,
         'exec': _eval_lines,
-        'invoke': _invoke,
-        'goto': _goto,
+        'update': _global_update,
+        'assign': lambda k, v: _global_update({k: v}),
+        '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 +347,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

@@ -58,12 +58,12 @@ class _Env:
 class _EnvS:
     def __getattr__(self, item):
         context = get_inner_vars('__inner_context__', full=True)
-        return context.get_env(item.upper(), '')
+        return context.get_env_full(item.upper(), '')
 
     def __getitem__(self, item):
         context = get_inner_vars('__inner_context__', full=True)
         default = object()
-        ret = context.get_env(item.upper(), default)
+        ret = context.get_env_full(item.upper(), default)
         if ret is default:
             raise KeyError(item)
         return ret
@@ -71,7 +71,7 @@ class _EnvS:
     def __contains__(self, item):
         context = get_inner_vars('__inner_context__', full=True)
         default = object()
-        ret = context.get_env(item.upper(), default)
+        ret = context.get_env_full(item.upper(), default)
         return ret is not default
 
 

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,
+        AssignEncodeStrMarker, AssignDecodeMarker, AssignEncodeMarker,
+        AssignEnvMarker, AssignEnvFullMarker, AssignCmdcallMarker, AssignCmdcallChainMarker,
         AssignMultiLineRawStrMarker, AssignMultiLineStrMarker, AssignRawStrMarker, AssignStrMarker,
         EmptyMarker,  # must be at the tail
     ]

dekshell/core/markers/base/__init__.py

@@ -30,6 +30,7 @@ class MarkerBase:
     trans_marker_command_rc_silence = '<<<'
     trans_marker_command_rc = '<<'
     trans_marker_command_output = '<'
+    trans_marker_encode_str = '///'
     trans_marker_decode = '//'
     trans_marker_encode = '/'
     trans_marker_env = '$$'
@@ -99,8 +100,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 +116,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 +158,76 @@ 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, 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, ignore_errors=False):
+        def evaluate(expr, default):
             try:
-                return cls.eval_mixin(context, expression, False)
+                return cls.eval_mixin(context, expr, False)
             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):]
+            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 context.get_env(expression.strip(), default_value)
+        elif expression.startswith(cls.trans_marker_env_full):
+            expression = expression[len(cls.trans_marker_env_full):]
+            return context.get_env_full(expression.strip(), default_value)
+        elif expression.startswith(cls.trans_marker_encode_str):
+            expression = expression[len(cls.trans_marker_encode_str):]
+            return serializer.dump(expression)
+        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

@@ -87,11 +87,15 @@ 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)
 
 
@@ -192,11 +196,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 +210,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 +244,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 +257,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 +291,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 +372,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/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/function.py

@@ -37,7 +37,7 @@ class Function:
     def __call__(self, *args, **kwargs):
         context, marker_set = get_inner_vars('__inner_context__', '__inner_marker_set__', full=True)
         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 []
 
 

dekshell/core/markers/invoke.py

@@ -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,59 @@ 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)
+
+
+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 AssignEncodeStrMarker(MarkerAssignValueParseExprBase):
+    tag_head_re_args_raw = MarkerBase.trans_marker_encode_str
+    tag_head_re_args = re.escape(MarkerBase.trans_marker_encode_str)
+
+
+class AssignDecodeMarker(MarkerAssignValueParseExprBase):
+    tag_head_re_args_raw = MarkerBase.trans_marker_decode
+    tag_head_re_args = re.escape(MarkerBase.trans_marker_decode)
 
 
-class AssignCmdcallChainMarker(AssignCmdcallMarker):
+class AssignEncodeMarker(MarkerAssignValueParseExprBase):
+    tag_head_re_args_raw = MarkerBase.trans_marker_encode
+    tag_head_re_args = re.escape(MarkerBase.trans_marker_encode)
+
+
+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 +165,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-0.2.42.dist-info → dekshell-0.2.43.dist-info}/METADATA

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

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

@@ -1,16 +1,16 @@
-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.43.dist-info/METADATA,sha256=7_oIag3oGwZRV1DcfxmuNFRmfSzHQRwJYo5ynVNx7Oc,573
+dekshell-0.2.43.dist-info/WHEEL,sha256=tSfRZzRHthuv7vxpI4aehrdN9scLjk-dCJkPLzkHxGg,90
+dekshell-0.2.43.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=4oGrhKT_KNtZ17Mm9Lw79pQJPkg00NwpZ_OLaM7x5s8,10897
+dekshell/core/contexts/properties.py,sha256=DCMp008aVpD-xEqrt3N1jftXonP9mVSkd80wFoBaxso,3471
+dekshell/core/markers/__init__.py,sha256=lBVNDy3fTImQn17FLvORA6kKQGrq5t_DIqoXJnJdAAY,2201
+dekshell/core/markers/base/__init__.py,sha256=RrGhwhJlgHXsKYYy2Q2oJAXS7kDOuMiLWwzAwO2j4ng,17007
+dekshell/core/markers/base/core.py,sha256=IM5mZ37k62vHfa457s5_Gh0rVEO6CXH5G4zqTeNm1IY,12399
 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
@@ -18,16 +18,16 @@ dekshell/core/markers/define.py,sha256=LpMSfz9ziXq2aFJ6oMpUFFo93TpBx7GxKYNzCeht4
 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/exec.py,sha256=3yWpaCpASrMwzqVslDNzBaUVL7Lbn-zWMs-dOxUePZU,2744
 dekshell/core/markers/for_.py,sha256=uNOEwyDsjffttEBtUYasdlj7FP_sGnQzWuTV5d5esHY,2142
-dekshell/core/markers/function.py,sha256=rLi8Lc9nf7ex3xdj8-VdJkgC1qXpr5JVMndH1YlH4mM,3815
+dekshell/core/markers/function.py,sha256=lYCfK3SAjBwxmJAanpPAqObY4s1FNvZ15FT32_qkaTc,3855
 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/invoke.py,sha256=Gf7Y3anFlpXso7oNxecqPtzKoWhFVn3PZVJ8VIgnKls,1986
 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/var.py,sha256=y7gfEtEKs7x3T95AAUTFN6aG3vFiUMMG_TAjfUJFT6U,7070
 dekshell/core/markers/while_.py,sha256=e7lI5jsIM-qxNHMY_wUyCMvvesdXQibR5Ez2jNO9csc,1195
 dekshell/core/plugin/__init__.py,sha256=jAB_KnnHJsyJR_zIfBU_HNLngyhcyyqVv05PdlNZtF8,428
 dekshell/core/redirect.py,sha256=6YCJpG0TkQ4WMt7LBtDD_W1T-C-QkLtGRQw0S60qe54,1058
@@ -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.43.dist-info/RECORD,,