dekshell 0.1.99__tar.gz → 0.2.6__tar.gz

{dekshell-0.1.99 → dekshell-0.2.6}/PKG-INFO

@@ -1,11 +1,12 @@
 Metadata-Version: 2.1
 Name: dekshell
-Version: 0.1.99
+Version: 0.2.6
 Author-Email: sanzenwin <sanzenwin@gmail.com>
 License: MIT
 Requires-Python: >=3.8
 Requires-Dist: packaging<=23.1
-Requires-Dist: dektools[date,fetch]<1.0.0
+Requires-Dist: extra-platforms<=3.1.0
+Requires-Dist: dektools[date,fetch,ignore,ps,tab]<1.0.0
 Requires-Dist: dekmedia[audio]<1.0.0
 Description-Content-Type: text/markdown
 

{dekshell-0.1.99 → dekshell-0.2.6}/dekshell/core/__init__.py

@@ -17,8 +17,12 @@ from ..utils.shell import shell_bin
 from ..utils.cmd import ak2cmd, pack_context_full
 
 
-def shell_file(__not_use_this_var_name__, *args, **kwargs):
-    shell_wrapper(f'{shell_bin} rf {__not_use_this_var_name__} {ak2cmd(args, kwargs)}')
+def shell_file(__placeholder__filepath, *args, **kwargs):
+    shell_wrapper(f'{shell_bin} rf "{__placeholder__filepath}" {ak2cmd(args, kwargs)}')
+
+
+def shell_file_cd(__placeholder__filepath, *args, **kwargs):
+    shell_wrapper(f'{shell_bin} rfc "{__placeholder__filepath}" {ak2cmd(args, kwargs)}')
 
 
 def shell_command_file_cd(filepath, **kwargs):
@@ -83,7 +87,7 @@ def shell_command_batch_core(
     def shell_exec(filepath, c=None):
         return shell_command_file(
             filepath,
-            context=(context or {}) | (c or {}),
+            context=c or {},
             marker=marker,
             ms_names=ms_names,
             marker_set_cls=marker_set_cls,

{dekshell-0.1.99 → dekshell-0.2.6}/dekshell/core/contexts/methods.py

@@ -1,10 +1,13 @@
 import os
+import shutil
 import sys
 import tempfile
 import getpass
+from functools import reduce
+from itertools import chain
 from pathlib import Path
 from dektools.file import sure_dir, write_file, read_text, remove_path, sure_parent_dir, normal_path, \
-    format_path_desc, read_file, split_ext, path_ext, clear_dir, \
+    format_path_desc, read_file, split_ext, path_ext, clear_dir, copy_recurse_ignore, \
     split_file, combine_split_files, remove_split_files, meta_split_file, tree, iglob, \
     where, where_list, which, which_list
 from dektools.hash import hash_file
@@ -14,8 +17,12 @@ from dektools.net import get_available_port
 from dektools.func import FuncAnyArgs
 from dektools.fetch import download_file
 from dektools.download import download_from_http
+from dektools.ps.process import process_detail, process_kill, process_list_all
 from dektools.time import now
 from dektools.str import shlex_split, shlex_quote
+from dektools.shell import shell_wrapper, is_user_admin
+from dektools.match import GeneralMatcher, glob2re, glob_compile, glob_match
+from dektools.cmd.git import git_clean_dir, git_apply, git_parse_modules, git_fetch_min, git_list_remotes, git_head
 from ...utils.beep import sound_notify
 from ..markers.base.core import MarkerBase, get_inner_vars
 from ..markers.invoke import InvokeMarker, GotoMarker
@@ -102,6 +109,26 @@ def _xeval(expression, default=_xeval_default, translate=False):
             return default
 
 
+def _install(name):
+    def posix(exe):
+        s = f"{exe} install -y {name}"
+        if is_user_admin():
+            s = 'sudo ' + command
+        return s
+
+    if shutil.which('apt-get'):
+        command = posix('apt-get')
+    elif shutil.which('yum'):
+        command = posix('yum')
+    elif shutil.which('brew'):
+        command = f"brew install {name}"
+    elif shutil.which('choco'):
+        command = f"choco install -y {name}"
+    else:
+        raise FileNotFoundError(f"Can't find a valid installer to install {name}")
+    shell_wrapper(command)
+
+
 path_common_methods = {
     'cd': os.chdir,
     'cwd': lambda: os.getcwd(),
@@ -113,6 +140,8 @@ path_common_methods = {
 }
 
 default_methods = {
+    'reduce': reduce,
+    'chain': chain,
     'xeval': _xeval,
     'echo': lambda *x, **y: print(*x, **dict(flush=True) | y),
     'echos': lambda *x, **y: print(*x, **dict(end='', flush=True) | y),
@@ -121,6 +150,7 @@ default_methods = {
     'o2s': obj2str,
     'now': now,
     'getpass': getpass.getpass,
+    'install': _install,
     'Path': Path,
     'path': {
         **path_common_methods,
@@ -149,6 +179,7 @@ default_methods = {
         'wf': write_file,
         'rt': read_text,
         'rf': read_file,
+        'ci': copy_recurse_ignore,
 
         'sf': split_file,
         'sfr': remove_split_files,
@@ -158,6 +189,15 @@ default_methods = {
         'hash': lambda x, name='sha256', args=None: hash_file(name, x, args=args),
     },
     **path_common_methods,
+    'pu': {
+        'ps': process_list_all,
+        'kill': process_kill,
+        'pi': process_detail,
+    },
+
+    'sys': {
+        'utf8': lambda: sys.stdout.reconfigure(encoding='utf-8')
+    },
 
     'compress': compress_files,
     'decompress': decompress_files,
@@ -173,10 +213,17 @@ default_methods = {
     'notequal': lambda x, y: x != y,
     'beep': lambda x=True: sound_notify(x),
 
-    'invoke': lambda __not_use_this_var_name__, *args, **kwargs: InvokeMarker.execute_file(
-        None, __not_use_this_var_name__, args, kwargs),
-    'goto': lambda __not_use_this_var_name__, *args, **kwargs: GotoMarker.execute_file(
-        None, __not_use_this_var_name__, args, kwargs),
+    '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,
+        'match': glob_match,
+        'matcher': GeneralMatcher,
+    },
 
     'shlex': {
         'split': shlex_split,
@@ -188,4 +235,13 @@ default_methods = {
         'fetch': download_file,
         'download': download_from_http,
     },
+
+    'git': {
+        'apply': git_apply,
+        'remotes': git_list_remotes,
+        'modules': git_parse_modules,
+        'fetch': git_fetch_min,
+        'clean': git_clean_dir,
+        'head': git_head,
+    }
 }

{dekshell-0.1.99 → dekshell-0.2.6}/dekshell/core/contexts/properties.py

@@ -2,15 +2,21 @@ import os
 import sys
 import shutil
 import tempfile
+import sysconfig
+import platform
 from pathlib import Path
 from sysconfig import get_paths
 from importlib import metadata
+from extra_platforms import current_os as extra_platforms_current_os
 from dektools.module import ModuleProxy
 from dektools.time import DateTime
+from dektools.file import read_text
 from ...utils.serializer import serializer
 from ..redirect import shell_name
 
 current_shell = shutil.which(shell_name, path=get_paths()['scripts'])
+current_os = extra_platforms_current_os()
+user_is_root = "posix" in os.name and os.geteuid() == 0
 
 
 def make_shell_properties(shell):
@@ -54,6 +60,17 @@ default_properties = {
         'win': is_on_win,
         'ps': os.pathsep,
     },
+    'platform': {
+        'cygwin': sys.platform == 'cygwin',
+        'mingw': sysconfig.get_platform() == 'mingw',
+        'msys': sys.platform == 'msys',
+        'wsl': 'Microsoft' in read_text('/proc/version', default=''),
+        'windows': platform.system() == 'Windows',
+        'macos': platform.system() == 'Darwin',
+        'linux': platform.system() == 'Linux',
+        'name': {'Windows': 'windows', 'Darwin': 'macos', 'Linux': 'linux'}.get(platform.system()),
+        'entry': current_os,
+    },
     'path': {
         'root': Path(path_root),
         'home': Path(path_home),

{dekshell-0.1.99 → dekshell-0.2.6}/dekshell/core/markers/__init__.py

@@ -12,10 +12,10 @@ from .function import *
 from .exec import *
 from .echo import *
 from .pip_ import *
-from .shell import *
+from .commands import *
 from .redirect import *
 from .input import *
-from .timout import *
+from .shell import *
 from .empty import *
 
 
@@ -39,12 +39,12 @@ def generate_markers(*args, **kwargs):
         EndMarker, BreakMarker, ContinueMarker,
         CommentMultiLineMarker, CommentMarker, CommentShebangMarker, CommentConfigMarker,
         PipMarker,
-        ShellMarker,
+        CommandsMarker,
         RedirectMarker, ShiftMarker,
-        TimeoutMarker,
+        TimeoutMarker, RetryMarker,
         IgnoreMarker,
         PrefixShellMarker,
-        AssignCallMarker, AssignInvokerMarker, AssignGotoMarker, AssignTimeoutMarker,
+        AssignCallMarker, AssignInvokerMarker, AssignGotoMarker, AssignTimeoutMarker, AssignRetryMarker,
         AssignExecMarker, AssignEvalMarker, AssignCmdcallMarker,
         AssignMultiLineRawStrMarker, AssignMultiLineStrMarker, AssignRawStrMarker, AssignStrMarker,
         EmptyMarker,  # must be at the tail

dekshell-0.1.99/dekshell/core/markers/shell.py → dekshell-0.2.6/dekshell/core/markers/commands.py

@@ -2,7 +2,7 @@ from .base import MarkerWithEnd
 from .empty import EmptyMarker
 
 
-class ShellMarker(MarkerWithEnd):
+class CommandsMarker(MarkerWithEnd):
     tag_head = "@@"
     target_marker_cls = EmptyMarker
 

{dekshell-0.1.99 → dekshell-0.2.6}/dekshell/core/markers/invoke.py

@@ -1,6 +1,6 @@
 import os
 from dektools.file import normal_path
-from ...utils.cmd import pack_context
+from ...utils.cmd import pack_context_full
 from .base import MarkerBase
 from .base.core import get_inner_vars
 
@@ -18,7 +18,7 @@ class MarkerInvokerBase(MarkerBase):
     def execute_file(cls, marker_set, filepath, args, kwargs):
         if marker_set is None:
             marker_set = get_inner_vars('__inner_marker_set__')
-        return cls._run_file(marker_set, normal_path(filepath), pack_context(args, kwargs))
+        return cls._run_file(marker_set, normal_path(filepath), pack_context_full(args, kwargs))
 
     @classmethod
     def _run_file(cls, marker_set, filepath, attrs):

{dekshell-0.1.99 → dekshell-0.2.6}/dekshell/core/markers/redirect.py

@@ -28,7 +28,7 @@ class RedirectMarker(MarkerRedirect):
         shell_properties = make_shell_properties(path_shell)
         if shell_properties['shell'] != current_shell:
             fp = self.eval(context, "fp")
-            fpp = os.path.dirname(fp).relace('/', os.sep)
+            fpp = os.path.dirname(fp).replace('/', os.sep)
             shell = shell_properties['sh']['rfc' if os.getcwd() == fpp else 'rf']
             args, kwargs = self.eval(context, f'({key_args}, {key_kwargs})')
             argv = ak2cmd(args, kwargs)

dekshell-0.2.6/dekshell/core/markers/shell.py

@@ -0,0 +1,56 @@
+import subprocess
+from dektools.shell import shell_timeout, shell_wrapper, shell_retry
+from .empty import MarkerShell, ShellCommand
+
+
+class TimeoutShellCommand(ShellCommand):
+    def shell(self, command, timeout=None, env=None, **kwargs):
+        try:
+            if timeout > 0:
+                return shell_timeout(command, timeout, env=env)
+            else:
+                return shell_wrapper(command, env=env)
+        except subprocess.SubprocessError as e:
+            return e
+
+
+class TimeoutMarker(MarkerShell):
+    tag_head = "timeout"
+
+    shell_cls = TimeoutShellCommand
+
+    def execute(self, context, command, marker_node, marker_set):
+        _, timeout, command = self.split_raw(command, 2)
+        if command:
+            self.execute_core_timeout(context, command, marker_node, marker_set, timeout)
+
+    @classmethod
+    def execute_core_timeout(cls, context, command, marker_node, marker_set, timeout):
+        return cls.execute_core(context, command, marker_node, marker_set, dict(timeout=int(float(timeout))))
+
+
+class RetryShellCommand(ShellCommand):
+    def shell(self, command, times=None, env=None, **kwargs):
+        try:
+            return shell_retry(command=command, times=times, env=env)
+        except subprocess.SubprocessError as e:
+            return e
+
+
+class RetryMarker(MarkerShell):
+    tag_head = "retry"
+
+    shell_cls = RetryShellCommand
+
+    def execute(self, context, command, marker_node, marker_set):
+        _, times, command = self.split_raw(command, 2)
+        if command:
+            self.execute_core_retry(context, command, marker_node, marker_set, times)
+
+    @classmethod
+    def execute_core_retry(cls, context, command, marker_node, marker_set, times):
+        try:
+            times = int(float(times))
+        except ValueError:
+            times = None
+        return cls.execute_core(context, command, marker_node, marker_set, dict(times=times))

{dekshell-0.1.99 → dekshell-0.2.6}/dekshell/core/markers/var.py

@@ -1,7 +1,7 @@
 import re
 from .base import MarkerBase, MarkerWithEnd, MarkerNoTranslator, cmd_call_prefix_simple
 from .function import CallMarker
-from .timout import TimeoutMarker
+from .shell import TimeoutMarker, RetryMarker
 from .invoke import MarkerInvokerBase, InvokeMarker, GotoMarker
 
 
@@ -114,6 +114,15 @@ class AssignTimeoutMarker(MarkerAssignValueBase, TimeoutMarker):
         return self.execute_core_timeout(context, expression, marker_node, marker_set, timeout)
 
 
+class AssignRetryMarker(MarkerAssignValueBase, RetryMarker):
+    tag_head = None
+    tag_head_re_args = r'retry[ \t\f\r\n]+'
+
+    def get_value(self, context, marker_node, marker_set, expression):
+        times, expression = self.split_raw(expression, 1)
+        return self.execute_core_retry(context, expression, marker_node, marker_set, times)
+
+
 class DelVarMarker(MarkerBase):
     tag_head = "del"
 

{dekshell-0.1.99 → dekshell-0.2.6}/dekshell/utils/cmd.py

@@ -34,7 +34,7 @@ def ak2cmd(args, kwargs=None):
 
 
 def pack_context(args, kwargs):
-    return {f'{key_arg}{i}': arg for i, arg in enumerate(args)} | {key_args: args, key_kwargs: kwargs} | kwargs
+    return {f'{key_arg}{i}': arg for i, arg in enumerate(args)} | {key_args: tuple(args), key_kwargs: kwargs} | kwargs
 
 
 def pack_context_argv():

{dekshell-0.1.99 → dekshell-0.2.6}/pyproject.toml

@@ -1,13 +1,14 @@
 [project]
 name = "dekshell"
-version = "0.1.99"
+version = "0.2.6"
 description = ""
 authors = [
     { name = "sanzenwin", email = "sanzenwin@gmail.com" },
 ]
 dependencies = [
     "packaging<=23.1",
-    "dektools[date,fetch]<1.0.0",
+    "extra-platforms<=3.1.0",
+    "dektools[ignore,date,fetch,ps,tab]<1.0.0",
     "dekmedia[audio]<1.0.0",
 ]
 requires-python = ">=3.8"

dekshell-0.1.99/dekshell/core/markers/timout.py

@@ -1,26 +0,0 @@
-import subprocess
-from dektools.shell import shell_timeout
-from .empty import MarkerShell, ShellCommand
-
-
-class TimeoutShellCommand(ShellCommand):
-    def shell(self, command, timeout=None, env=None, **kwargs):
-        try:
-            return shell_timeout(command, timeout, env=env, check=True)
-        except subprocess.CalledProcessError as e:
-            return e
-
-
-class TimeoutMarker(MarkerShell):
-    tag_head = "timeout"
-
-    shell_cls = TimeoutShellCommand
-
-    def execute(self, context, command, marker_node, marker_set):
-        _, timeout, command = self.split_raw(command, 2)
-        if command:
-            self.execute_core_timeout(context, command, marker_node, marker_set, timeout)
-
-    @classmethod
-    def execute_core_timeout(cls, context, command, marker_node, marker_set, timeout):
-        return cls.execute_core(context, command, marker_node, marker_set, dict(timeout=int(float(timeout))))