kaqing 2.0.211__py3-none-any.whl → 2.0.213__py3-none-any.whl

adam/commands/fs/cat.py

@@ -0,0 +1,36 @@
+from adam.commands import validate_args
+from adam.commands.command import Command
+from adam.commands.devices.devices import Devices
+from adam.repl_state import ReplState, RequiredState
+
+class Cat(Command):
+    COMMAND = 'cat'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(Cat, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return Cat.COMMAND
+
+    def required(self):
+        return [RequiredState.CLUSTER_OR_POD, RequiredState.APP_APP, ReplState.P]
+
+    def run(self, cmd: str, state: ReplState):
+        if not(args := self.args(cmd)):
+            return super().run(cmd, state)
+
+        with self.validate(args, state) as (args, state):
+            with validate_args(args, state, name='file'):
+                return Devices.of(state).bash(state, state, cmd.split(' '))
+
+    def completion(self, state: ReplState):
+        return super().completion(state, lambda: {f: None for f in Devices.of(state).files(state)}, pods=Devices.of(state).pods(state, '-'), auto='jit')
+
+    def help(self, _: ReplState):
+        return f'{Cat.COMMAND} file [&]\t run cat command on the pod'

adam/commands/fs/cat_local.py

@@ -0,0 +1,42 @@
+import os
+
+from adam.commands import validate_args
+from adam.commands.command import Command
+from adam.repl_state import ReplState, RequiredState
+from adam.utils import log2
+from adam.utils_local import find_local_files
+
+class CatLocal(Command):
+    COMMAND = ':cat'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(CatLocal, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return CatLocal.COMMAND
+
+    def required(self):
+        return [RequiredState.CLUSTER_OR_POD, RequiredState.APP_APP, ReplState.P]
+
+    def run(self, cmd: str, state: ReplState):
+        if not(args := self.args(cmd)):
+            return super().run(cmd, state)
+
+        with self.validate(args, state) as (args, state):
+            with validate_args(args, state, name='file') as args:
+                os.system(f'cat {args}')
+                log2()
+
+                return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state, lambda: {n: None for n in find_local_files(file_type='f', max_depth=1)}, auto='jit')
+
+    def help(self, _: ReplState):
+        return f'{CatLocal.COMMAND} file\t run cat command on local system'

adam/commands/fs/cd.py

@@ -0,0 +1,41 @@
+from adam.commands import validate_args
+from adam.commands.command import Command
+from adam.commands.devices.device import Device
+from adam.commands.devices.devices import Devices
+from adam.repl_state import ReplState
+
+class Cd(Command):
+    COMMAND = 'cd'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(Cd, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return Cd.COMMAND
+
+    def required(self):
+        return ReplState.NON_L
+
+    def run(self, cmd: str, state: ReplState):
+        if not(args := self.args(cmd)):
+            return super().run(cmd, state)
+
+        with self.validate(args, state, apply=False) as (args, state):
+            with validate_args(args, state, name='directory') as arg_str:
+                device: Device = Devices.of(state)
+                for dir in arg_str.split('/'):
+                    device.cd(dir, state)
+
+                return state
+
+    def completion(self, state: ReplState):
+        return Devices.of(state).cd_completion(Cd.COMMAND, state, default = {})
+
+    def help(self, _: ReplState):
+        return f'{Cd.COMMAND} <path> | .. \t move around on the operational device hierarchy'

adam/commands/fs/download_file.py

@@ -0,0 +1,47 @@
+from adam.commands import validate_args
+from adam.commands.command import Command
+from adam.commands.devices.devices import Devices
+from adam.config import Config
+from adam.utils_k8s.pod_exec_result import PodExecResult
+from adam.repl_state import ReplState, RequiredState
+from adam.utils import log2
+from adam.utils_k8s.pods import Pods
+
+class DownloadFile(Command):
+    COMMAND = 'download file'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(DownloadFile, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return DownloadFile.COMMAND
+
+    def required(self):
+        return [RequiredState.CLUSTER_OR_POD, RequiredState.APP_APP, ReplState.P]
+
+    def run(self, cmd: str, state: ReplState):
+        if not(args := self.args(cmd)):
+            return super().run(cmd, state)
+
+        with self.validate(args, state) as (args, state):
+            with validate_args(args, state, name='file'):
+                to_file = Pods.download_file(Devices.of(state).pod(state),
+                                             Devices.of(state).default_container(state),
+                                             state.namespace,
+                                             args[0],
+                                             args[1] if len(args) > 1 else None)
+                log2(f'Downloaded to {to_file}.')
+
+                return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state, lambda: {f: None for f in Devices.of(state).files(state)}, pods=Devices.of(state).pods(state, '-'), auto='jit')
+
+    def help(self, _: ReplState):
+        return f'{DownloadFile.COMMAND} from-file [to-file]\t download file from pod'

adam/commands/fs/find_files.py

@@ -0,0 +1,51 @@
+import os
+
+from adam.commands.command import Command
+from adam.repl_state import ReplState
+from adam.utils import log2
+from adam.utils_local import local_qing_dir
+
+class FindLocalFiles(Command):
+    COMMAND = ':find file'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(FindLocalFiles, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return FindLocalFiles.COMMAND
+
+    def run(self, cmd: str, state: ReplState):
+        if not(args := self.args(cmd)):
+            return super().run(cmd, state)
+
+        with self.validate(args, state) as (args, state):
+            cmd = 'find'
+
+            if not args:
+                cmd = f'find {local_qing_dir()}'
+            elif len(args) == 1:
+                cmd = f"find {local_qing_dir()} -name '{args[0]}'"
+            else:
+                new_args = [f"'{arg}'" if '*' in arg else arg for arg in args]
+                cmd = 'find ' + ' '.join(new_args)
+
+            log2(cmd)
+            os.system(cmd)
+
+            return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state, {
+            '*.csv': None,
+            '*.db': None,
+            '*': None
+        })
+
+    def help(self, _: ReplState):
+        return f'{FindLocalFiles.COMMAND} [linux-find-arguments]\t find files from local machine'

adam/commands/fs/find_processes.py

@@ -0,0 +1,76 @@
+from adam.commands import extract_options, validate_args
+from adam.commands.command import Command
+from adam.commands.devices.devices import Devices
+from adam.commands.export.utils_export import state_with_pod
+from adam.repl_state import ReplState, RequiredState
+from adam.utils import log2, tabulize
+
+class FindProcesses(Command):
+    COMMAND = 'find processes'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(FindProcesses, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return FindProcesses.COMMAND
+
+    def required(self):
+        return [RequiredState.CLUSTER_OR_POD, RequiredState.APP_APP, ReplState.P]
+
+    def run(self, cmd: str, state: ReplState):
+        if not(args := self.args(cmd)):
+            return super().run(cmd, state)
+
+        with self.validate(args, state) as (args, state):
+            with extract_options(args, '-kill') as (args, kill):
+                with validate_args(args, state, name='words to look for'):
+                    arg = ' | '.join([f'grep {a}' for a in args])
+                    awk = "awk '{ print $1, $2, $8, $NF }'"
+                    rs = Devices.of(state).bash(state, state, f"ps -ef | grep -v grep | {arg} | {awk}".split(' '))
+
+                    lines: list[list[str]] = []
+                    for r in rs:
+                        for l in r.stdout.split('\n'):
+                            l = l.strip(' \t\r\n')
+                            if not l:
+                                continue
+
+                            tokens = [r.pod] + l.split(' ')
+                            lines.append(tokens)
+
+                    pids = []
+                    for l in lines:
+                        pids.append(f'{l[2]}@{l[0]}')
+
+                    tabulize(lines, lambda l: '\t'.join(l), header = 'POD\tUSER\tPID\tCMD\tLAST_ARG', separator='\t')
+                    log2()
+                    log2(f'PIDS with {",".join(args)}: {",".join(pids)}')
+
+                    if kill:
+                        log2()
+                        for pidp in pids:
+                            pid_n_pod = pidp.split('@')
+                            pid = pid_n_pod[0]
+                            if len(pid_n_pod) < 2:
+                                continue
+
+                            pod = pid_n_pod[1]
+
+                            log2(f'@{pod} bash kill -9 {pid}')
+
+                            with state_with_pod(state, pod) as state1:
+                                Devices.of(state).bash(state, state1, ['kill', '-9', pid])
+
+                    return rs
+
+    def completion(self, state: ReplState):
+        return super().completion(state)
+
+    def help(self, _: ReplState):
+        return f'{FindProcesses.COMMAND} word... [-kill]\t find processes with words'

adam/commands/fs/head.py

@@ -0,0 +1,36 @@
+from adam.commands import validate_args
+from adam.commands.command import Command
+from adam.commands.devices.devices import Devices
+from adam.repl_state import ReplState, RequiredState
+
+class Head(Command):
+    COMMAND = 'head'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(Head, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return Head.COMMAND
+
+    def required(self):
+        return [RequiredState.CLUSTER_OR_POD, RequiredState.APP_APP, ReplState.P]
+
+    def run(self, cmd: str, state: ReplState):
+        if not(args := self.args(cmd)):
+            return super().run(cmd, state)
+
+        with self.validate(args, state) as (args, state):
+            with validate_args(args, state, name='file'):
+                return Devices.of(state).bash(state, state, cmd.split(' '))
+
+    def completion(self, state: ReplState):
+        return super().completion(state, lambda: {f: None for f in Devices.of(state).files(state)}, pods=Devices.of(state).pods(state, '-'), auto='jit')
+
+    def help(self, _: ReplState):
+        return f'{Head.COMMAND} file [&]\t run head command on the pod'

adam/commands/fs/ls.py

@@ -0,0 +1,41 @@
+import copy
+
+from adam.commands.command import Command
+from adam.commands.devices.devices import Devices
+from adam.repl_state import ReplState
+
+class Ls(Command):
+    COMMAND = 'ls'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(Ls, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return Ls.COMMAND
+
+    def run(self, cmd: str, state: ReplState):
+        if not(args := self.args(cmd)):
+            return super().run(cmd, state)
+
+        with self.validate(args, state) as (args, state):
+            if len(args) > 0:
+                arg = args[0]
+                if arg in ['p:', 'c:'] and arg != f'{state.device}:':
+                    state = copy.copy(state)
+                    state.device = arg.replace(':', '')
+
+            Devices.of(state).ls(cmd, state)
+
+            return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state, {'&': None}, pods=Devices.of(state).pods(state, '-'))
+
+    def help(self, _: ReplState):
+        return f'{Ls.COMMAND} [device:]\t list apps, envs, clusters, nodes, pg hosts/databases or export databases'

adam/commands/fs/ls_local.py

@@ -0,0 +1,40 @@
+import os
+
+from adam.commands.command import Command
+from adam.repl_state import ReplState
+from adam.utils import log2
+from adam.utils_local import local_qing_dir
+
+class LsLocal(Command):
+    COMMAND = ':ls'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(LsLocal, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return LsLocal.COMMAND
+
+    def run(self, cmd: str, state: ReplState):
+        if not(args := self.args(cmd)):
+            return super().run(cmd, state)
+
+        with self.validate(args, state) as (args, state):
+            if args:
+                os.system(f'ls {args}')
+            else:
+                os.system(f'ls {local_qing_dir()}')
+            log2()
+
+            return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state)
+
+    def help(self, _: ReplState):
+        return f'{LsLocal.COMMAND} [dir]\t list files on local system'

adam/commands/fs/rm.py

@@ -0,0 +1,18 @@
+from adam.commands.fs.rm_downloads import RmDownloads
+from adam.commands.fs.rm_logs import RmLogs
+from adam.commands.intermediate_command import IntermediateCommand
+
+class RmLocal(IntermediateCommand):
+    COMMAND = ':rm'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(RmLocal, cls).__new__(cls)
+
+        return cls.instance
+
+    def command(self):
+        return RmLocal.COMMAND
+
+    def cmd_list(self):
+        return [RmDownloads(), RmLogs()]

adam/commands/fs/rm_downloads.py

@@ -0,0 +1,39 @@
+import os
+
+from adam.commands.command import Command
+from adam.repl_state import ReplState
+from adam.utils import log2
+from adam.utils_local import local_downloads_dir
+
+class RmDownloads(Command):
+    COMMAND = ':rm downloads'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(RmDownloads, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return RmDownloads.COMMAND
+
+    def run(self, cmd: str, state: ReplState):
+        if not(args := self.args(cmd)):
+            return super().run(cmd, state)
+
+        with self.validate(args, state) as (args, state):
+            cmd = f'rm -rf {local_downloads_dir()}/*'
+            log2(cmd)
+            os.system(cmd)
+            log2()
+
+            return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state)
+
+    def help(self, _: ReplState):
+        return f'{RmDownloads.COMMAND}\t remove all downloads files under {local_downloads_dir()}'

adam/commands/fs/rm_logs.py

@@ -0,0 +1,38 @@
+import os
+
+from adam.commands.command import Command
+from adam.repl_state import ReplState
+from adam.utils import log2, log_dir
+
+class RmLogs(Command):
+    COMMAND = ':rm logs'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(RmLogs, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return RmLogs.COMMAND
+
+    def run(self, cmd: str, state: ReplState):
+        if not(args := self.args(cmd)):
+            return super().run(cmd, state)
+
+        with self.validate(args, state) as (args, state):
+            cmd = f'rm -rf {log_dir()}/*'
+            log2(cmd)
+            os.system(cmd)
+            log2()
+
+            return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state)
+
+    def help(self, _: ReplState):
+        return f'{RmLogs.COMMAND}\t remove all qing log files under {log_dir()}'

adam/commands/fs/shell.py

@@ -0,0 +1,41 @@
+import os
+
+from adam.commands import validate_args
+from adam.commands.command import Command
+from adam.repl_state import ReplState
+from adam.utils import log2
+
+class Shell(Command):
+    COMMAND = ':sh'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(Shell, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return Shell.COMMAND
+
+    def run(self, cmd: str, state: ReplState):
+        if not(args := self.args(cmd)):
+            return super().run(cmd, state)
+
+        with self.validate(args, state) as (args, _):
+            with validate_args(args, state, at_least=0) as args_str:
+                if args_str:
+                    os.system(args_str)
+                    log2()
+                else:
+                    os.system('QING_DROPPED=true bash')
+
+            return state
+
+    def completion(self, state: ReplState):
+        return super().completion(state)
+
+    def help(self, _: ReplState):
+        return f'{Shell.COMMAND}\t drop down to shell'

adam/repl_commands.py

@@ -45,6 +45,8 @@ from adam.commands.fs.find_files import FindLocalFiles
 from adam.commands.fs.find_processes import FindProcesses
 from adam.commands.fs.head import Head
 from adam.commands.fs.ls_local import LsLocal
+from adam.commands.fs.rm import RmLocal
+from adam.commands.fs.rm_logs import RmLogs
 from adam.commands.kubectl import Kubectl
 from adam.commands.restart_cluster import RestartCluster
 from adam.commands.restart_node import RestartNode
@@ -107,7 +109,7 @@ class ReplCommands:
     def navigation() -> list[Command]:
         return [Ls(), LsLocal(), PreviewTable(), DeviceApp(), DevicePostgres(), DeviceCass(), DeviceAuditLog(), DeviceExport(),
                 Cd(), Cat(), CatLocal(), Head(), DownloadFile(), FindLocalFiles(), FindProcesses(), Pwd(), ClipboardCopy(),
-                GetParam(), SetParam(), ShowParams(), ShowKubectlCommands(), ShowLogin(), ShowAdam(), ShowHost()]
+                GetParam(), SetParam(), ShowParams(), ShowKubectlCommands(), ShowLogin(), ShowAdam(), ShowHost()] + RmLocal().cmd_list()
 
     def cassandra_ops() -> list[Command]:
         return [Cqlsh(), DownloadCassandraLog(), ShowCassandraStatus(), ShowCassandraVersion(), ShowCassandraRepairs(), ShowStorage(), ShowProcesses(),

adam/version.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
-__version__ = "2.0.211"  #: the working version
+__version__ = "2.0.213"  #: the working version
 __release__ = "1.0.0"  #: the release version

{kaqing-2.0.211.dist-info → kaqing-2.0.213.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kaqing
-Version: 2.0.211
+Version: 2.0.213
 Summary: UNKNOWN
 Home-page: UNKNOWN
 License: UNKNOWN

{kaqing-2.0.211.dist-info → kaqing-2.0.213.dist-info}/RECORD

@@ -9,7 +9,7 @@ adam/embedded_apps.py,sha256=lKPx63mKzJbNmwz0rgL4gF76M9fDGxraYTtNAIGnZ_s,419
 adam/embedded_params.py,sha256=LDI2ph8YRoB-t_rSR9B3JqsnXsk_AvNyT6CgFAly4is,6505
 adam/log.py,sha256=vcJ1Q8LLnt3NSXqpVcKjAI2OZE6KaD3PEi1kfu_D8qs,1156
 adam/repl.py,sha256=V5q0AfFnFKPyOZNPdy9WZGJCH6_jyOTCxa3WS9jU9Ro,7623
-adam/repl_commands.py,sha256=kvf5W5Lzs7VQgiOopIXD2D-kgmJ_d86VaU-Hn2pxUJY,7405
+adam/repl_commands.py,sha256=VyeqLr2lTwtgc0sBgEMRKUQgmqVcyb3FNoSz4qb77cg,7512
 adam/repl_session.py,sha256=BWjPJq3lHrK6I5wxMqgKyv9_k98yEScn1-WHqsEk0k8,823
 adam/repl_state.py,sha256=jdW56D2gjIEM40ttYtsr2MyIC8oW4KpxuhfQLUgTWZA,16168
 adam/utils.py,sha256=AV32tqeGjDrk29oJqDTwY80WI9hgkQYUIJYitCbpvdw,26440
@@ -19,7 +19,7 @@ adam/utils_issues.py,sha256=nWhzUXmD2IfbT8MzjdyvuvpKrtUoieF74O2joaWFpUU,1438
 adam/utils_local.py,sha256=Q4jqAenWQYvL6VLb0BlAJ4Z4VoWQIZBrrfyEDCS9qAw,2308
 adam/utils_net.py,sha256=byEtNVr8iG9UaD7dM77dN2WEBClB7YNKult7LKFTCOc,428
 adam/utils_sqlite.py,sha256=NexOm1Fxq99dLvBn7XhxCh1SinwBtVUzadbyS7lorkU,4233
-adam/version.py,sha256=LA8oGVlPQjhR_LJojVqMHHE-hfv4XGeJq97PtcEYApY,140
+adam/version.py,sha256=wI4AqD_6M7TmYRXPM9JZKFB0q3f5AvvnlIBpd-OjXJM,140
 adam/checks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 adam/checks/check.py,sha256=Qopr3huYcMu2bzQgb99dEUYjFzkjKHRI76S6KA9b9Rk,702
 adam/checks/check_context.py,sha256=FEHkQ32jY1EDopQ2uYWqy9v7aEEX1orLpJWhopwAlh4,402
@@ -155,6 +155,20 @@ adam/commands/export/show_export_databases.py,sha256=zSjZ8tuMXj1dZ6iIXwFVqVk7hok
 adam/commands/export/show_export_session.py,sha256=hrUJFIaycnCpcv5wZ8bxCbYtzvdRm-JIswm_gvjzk4g,1291
 adam/commands/export/show_export_sessions.py,sha256=s5m9oGlrJe3NWE-TQZszis0WGbKBs4T6C_NeihfYdxs,1130
 adam/commands/export/utils_export.py,sha256=_j9cW_NAkTAC2kIAa3g9aFKkaunYHVivYIVyDrgTLA4,12968
+adam/commands/fs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adam/commands/fs/cat.py,sha256=_h8V1g57zKCeSeE7MVuqCC3k90_q3fd19FvdvCP8Q9g,1278
+adam/commands/fs/cat_local.py,sha256=sTzt80NWELfgMtyDj3UQeQ1kx-Jr8xylnTTfUxOCOzA,1334
+adam/commands/fs/cd.py,sha256=bvFgqzd0b4BROExcCaN_y-_tnyUUDEuoQk3dXest9l0,1330
+adam/commands/fs/download_file.py,sha256=SmR6lq309dg6TOQUt0CqtC32T0RYEhSTut8qjV_KnOg,1849
+adam/commands/fs/find_files.py,sha256=KvY2CREhhf6xr1KshG7dXBpKEi2mqWy8Gwpyc8YsfGA,1483
+adam/commands/fs/find_processes.py,sha256=Ta1l5zddaazoWjaKZb8LRa4sfemr8HbOAdlLXNWBGrM,2908
+adam/commands/fs/head.py,sha256=NeR1xRpmbyUQI5IgRE-zdWyyjs9C-C8E-g0WNulZ2Ck,1284
+adam/commands/fs/ls.py,sha256=vUQrOaptKcC9HHzQaL_82h9bWoUxwGu0YSg8YKOwrBI,1282
+adam/commands/fs/ls_local.py,sha256=FIajyaR-rcrDnMEk7COcO7KI8PAfkTXDI7nS7vBPTB8,1092
+adam/commands/fs/rm.py,sha256=LxeSD6pTgU4090buVeVTKWJ0G3T9-0a_oar4MLEfrzk,528
+adam/commands/fs/rm_downloads.py,sha256=4zvyKUDtcHTj5UzP7R047jzGm9RclZO8mE7w9c9Y26A,1119
+adam/commands/fs/rm_logs.py,sha256=oHxV-g6qgna5LEVeeGlOwxN7A3cgxv8BpS7ASL5kCBY,1029
+adam/commands/fs/shell.py,sha256=UQs4TEIDiZOjJrVsZJ_O9DDtn_k3K7-ifg1ZBsJFnsU,1155
 adam/commands/medusa/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 adam/commands/medusa/medusa.py,sha256=Ey2kJpoKqPFP6m623B3ciMoLur5SVcHEBYsvW7G7aAY,958
 adam/commands/medusa/medusa_backup.py,sha256=n-caJjd3WObm2tplVKUG-GahWoOwDS2pk_MZKQl0S7Q,1812
@@ -248,8 +262,8 @@ adam/utils_repl/state_machine.py,sha256=kO4_oSi_M53f3QQjINzzb2VFptjbnqX3KRC0G8Lq
 teddy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 teddy/lark_parser.py,sha256=1ZasiCM94C0nOA4HFJX7uMj0h2TReCMqLd1Wx9C50uA,14701
 teddy/lark_parser2.py,sha256=tXM6D8BimgG4FK5ANYS2K8MoATdcYed5QOKXivbPQHw,21499
-kaqing-2.0.211.dist-info/METADATA,sha256=YMqqbdHQBZqlEaZCVIoWYKKKOzH8uGdYu2kRBvJvt-Q,133
-kaqing-2.0.211.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-kaqing-2.0.211.dist-info/entry_points.txt,sha256=SkzhuQJUWsXOzHeZ5TgQ2c3_g53UGK23zzJU_JTZOZI,39
-kaqing-2.0.211.dist-info/top_level.txt,sha256=spQlE6mz0lPv3DfQLw8FenXyU0O-P8pi_FUCjdI2H9s,11
-kaqing-2.0.211.dist-info/RECORD,,
+kaqing-2.0.213.dist-info/METADATA,sha256=Jsuyj2bMnVhgMfFfzxa6xvBrGZ2qFUI1g4PY0syyGCI,133
+kaqing-2.0.213.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+kaqing-2.0.213.dist-info/entry_points.txt,sha256=SkzhuQJUWsXOzHeZ5TgQ2c3_g53UGK23zzJU_JTZOZI,39
+kaqing-2.0.213.dist-info/top_level.txt,sha256=spQlE6mz0lPv3DfQLw8FenXyU0O-P8pi_FUCjdI2H9s,11
+kaqing-2.0.213.dist-info/RECORD,,