kaqing 2.0.145__py3-none-any.whl → 2.0.174__py3-none-any.whl

adam/commands/export/importer.py

@@ -2,6 +2,7 @@ from abc import abstractmethod
 
 from adam.commands.export.utils_export import csv_dir
 from adam.config import Config
+from adam.repl_state import ReplState
 from adam.utils import ing
 from adam.utils_k8s.cassandra_nodes import CassandraNodes
 from adam.utils_k8s.pods import log_prefix
@@ -12,10 +13,13 @@ class Importer:
         pass
 
     @abstractmethod
-    def import_from_csv(self, pod: str, namespace: str, to_session: str, from_session: str, keyspace: str, table: str, target_table: str, columns: str, multi_tables = True, create_db = False):
+    def import_from_csv(self, state: ReplState, from_session: str, keyspace: str, table: str, target_table: str, columns: str, multi_tables = True, create_db = False):
         pass
 
-    def move_to_done(self, pod: str, namespace: str, to_session: str, from_session: str, keyspace: str, target_table: str):
+    def move_to_done(self, state: ReplState, from_session: str, keyspace: str, target_table: str):
+        pod = state.pod
+        namespace = state.namespace
+        to_session = state.export_session
         log_file = f'{log_prefix()}-{from_session}_{keyspace}.{target_table}.log.pending_import'
 
         to = f'{log_prefix()}-{to_session}_{keyspace}.{target_table}.log.done'
@@ -30,9 +34,12 @@ class Importer:
 
         return session
 
-    def remove_csv(self, pod: str, namespace: str, session: str, table: str, target_table: str, multi_tables = True):
-        with ing(f'[{session}] Cleaning up temporary files', suppress_log=multi_tables):
-            CassandraNodes.exec(pod, namespace, f'rm -rf {self.csv_file(session, table, target_table)}', show_out=Config().is_debug(), shell='bash')
+    def remove_csv(self, state: ReplState, from_session: str, table: str, target_table: str, multi_tables = True):
+        pod = state.pod
+        namespace = state.namespace
+
+        with ing(f'[{from_session}] Cleaning up temporary files', suppress_log=multi_tables):
+            CassandraNodes.exec(pod, namespace, f'rm -rf {self.csv_file(from_session, table, target_table)}', show_out=Config().is_debug(), shell='bash')
 
     def db(self, session: str, keyspace: str):
         return f'{session}_{keyspace}'

adam/commands/export/importer_athena.py

@@ -1,9 +1,11 @@
 import boto3
 
+from adam.commands.export.export_databases import export_db
 from adam.commands.export.importer import Importer
 from adam.commands.export.utils_export import GeneratorStream
 from adam.config import Config
-from adam.utils import log2, ing
+from adam.repl_state import ReplState
+from adam.utils import debug, log2, ing
 from adam.utils_athena import Athena
 from adam.utils_k8s.pods import Pods
 
@@ -17,9 +19,12 @@ class AthenaImporter(Importer):
     def prefix(self):
         return 'e'
 
-    def import_from_csv(self, pod: str, namespace: str, to_session: str, from_session: str, keyspace: str, table: str, target_table: str, columns: str, multi_tables = True, create_db = False):
+    def import_from_csv(self, state: ReplState, from_session: str, keyspace: str, table: str, target_table: str, columns: str, multi_tables = True, create_db = False):
         csv_file = self.csv_file(from_session, table, target_table)
-        db = self.db(to_session, keyspace)
+        pod = state.pod
+        namespace = state.namespace
+        to_session = state.export_session
+        database = self.db(to_session, keyspace)
 
         succeeded = False
         try:
@@ -29,23 +34,21 @@ class AthenaImporter(Importer):
                 bytes = Pods.read_file(pod, 'cassandra', namespace, csv_file)
 
                 s3 = boto3.client('s3')
-                s3.upload_fileobj(GeneratorStream(bytes), bucket, f'export/{db}/{keyspace}/{target_table}/{table}.csv')
+                s3.upload_fileobj(GeneratorStream(bytes), bucket, f'export/{database}/{keyspace}/{target_table}/{table}.csv')
 
             msg: str = None
             if create_db:
-                msg = f"[{to_session}] Creating database {db}"
+                msg = f"[{to_session}] Creating database {database}"
             else:
                 msg = f"[{to_session}] Creating table {target_table}"
             with ing(msg, suppress_log=multi_tables):
-                query = f'CREATE DATABASE IF NOT EXISTS {db};'
-                if Config().is_debug():
-                    log2(query)
+                query = f'CREATE DATABASE IF NOT EXISTS {database};'
+                debug(query)
                 Athena.query(query, 'default')
 
                 query = f'DROP TABLE IF EXISTS {target_table};'
-                if Config().is_debug():
-                    log2(query)
-                Athena.query(query, db)
+                debug(query)
+                Athena.query(query, database)
 
                 athena_columns = ', '.join([f'{c} string' for c in columns.split(',')])
                 query = f'CREATE EXTERNAL TABLE IF NOT EXISTS {target_table}(\n' + \
@@ -54,27 +57,25 @@ class AthenaImporter(Importer):
                             'WITH SERDEPROPERTIES (\n' + \
                             '    "separatorChar" = ",",\n' + \
                             '    "quoteChar"     = "\\"")\n' + \
-                        f"LOCATION 's3://{bucket}/export/{db}/{keyspace}/{target_table}'\n" + \
+                        f"LOCATION 's3://{bucket}/export/{database}/{keyspace}/{target_table}'\n" + \
                             'TBLPROPERTIES ("skip.header.line.count"="1");'
-                if Config().is_debug():
-                    log2(query)
+                debug(query)
                 try:
-                    Athena.query(query, db)
+                    Athena.query(query, database)
                 except Exception as e:
                     log2(f'*** Failed query:\n{query}')
                     raise e
 
-            to, _ = self.move_to_done(pod, namespace, to_session, from_session, keyspace, target_table)
+            to, _ = self.move_to_done(state, from_session, keyspace, target_table)
 
             succeeded = True
 
             return to, to_session
         finally:
             if succeeded:
-                self.remove_csv(pod, namespace, from_session, table, target_table, multi_tables)
+                self.remove_csv(state, from_session, table, target_table, multi_tables)
                 Athena.clear_cache()
 
                 if not multi_tables:
-                    query = f'select * from {target_table} limit 10'
-                    log2(query)
-                    Athena.run_query(query, db)
+                    with export_db(state) as dbms:
+                        dbms.sql(f'select * from {database}.{target_table} limit 10')

adam/commands/export/importer_sqlite.py

@@ -1,47 +1,42 @@
-import os
-import sqlite3
 import pandas
 
+from adam.commands.export.export_databases import export_db
 from adam.commands.export.importer import Importer
 from adam.commands.export.utils_export import GeneratorStream
+from adam.repl_state import ReplState
 from adam.utils import log2, ing
 from adam.utils_k8s.pods import Pods
-from adam.utils_sqlite import SQLite
+from adam.utils_sqlite import SQLite, sqlite
 
 class SqliteImporter(Importer):
     def prefix(self):
         return 's'
 
-    def import_from_csv(self, pod: str, namespace: str, to_session: str, from_session: str, keyspace: str, table: str, target_table: str, columns: str, multi_tables = True, create_db = False):
+    def import_from_csv(self, state: ReplState, from_session: str, keyspace: str, table: str, target_table: str, columns: str, multi_tables = True, create_db = False):
         csv_file = self.csv_file(from_session, table, target_table)
-        db = self.db(to_session, keyspace)
+        pod = state.pod
+        namespace = state.namespace
+        to_session = state.export_session
 
         succeeded = False
-        conn = None
         try:
-            os.makedirs(SQLite.local_db_dir(), exist_ok=True)
-            conn = sqlite3.connect(f'{SQLite.local_db_dir()}/{db}.db')
-
             with ing(f'[{to_session}] Uploading to Sqlite', suppress_log=multi_tables):
-                bytes = Pods.read_file(pod, 'cassandra', namespace, csv_file)
-                df = pandas.read_csv(GeneratorStream(bytes))
-
-                df.to_sql(target_table, conn, index=False, if_exists='replace')
+                # create a connection to single keyspace
+                with sqlite(to_session, keyspace) as conn:
+                    bytes = Pods.read_file(pod, 'cassandra', namespace, csv_file)
+                    df = pandas.read_csv(GeneratorStream(bytes))
+                    df.to_sql(target_table, conn, index=False, if_exists='replace')
 
-            to, _ = self.move_to_done(pod, namespace, to_session, from_session, keyspace, target_table)
+            to, _ = self.move_to_done(state, from_session, keyspace, target_table)
 
             succeeded = True
 
             return to, to_session
         finally:
             if succeeded:
-                self.remove_csv(pod, namespace, from_session, table, target_table, multi_tables)
+                self.remove_csv(state, from_session, table, target_table, multi_tables)
                 SQLite.clear_cache()
 
                 if not multi_tables:
-                    query = f'select * from {target_table} limit 10'
-                    log2(query)
-                    SQLite.run_query(query, conn_passed=conn)
-
-            if conn:
-                conn.close()
+                    with export_db(state) as dbms:
+                        dbms.sql(f'select * from {keyspace}.{target_table} limit 10')

adam/commands/export/show_column_counts.py

@@ -1,10 +1,9 @@
+from adam.commands import validate_args
 from adam.commands.command import Command
 from adam.commands.export.export_databases import ExportDatabases
 from adam.config import Config
 from adam.repl_state import ReplState, RequiredState
 from adam.utils import log2
-from adam.utils_athena import Athena
-from adam.utils_sqlite import SQLite
 
 class ShowColumnCounts(Command):
     COMMAND = 'show column counts on'
@@ -28,30 +27,13 @@ class ShowColumnCounts(Command):
         if not(args := self.args(cmd)):
             return super().run(cmd, state)
 
-        state, args = self.apply_state(args, state)
-        if not self.validate_state(state):
-            return state
-
-        if not args:
-            if state.in_repl:
-                log2('Use a SQL statement.')
-            else:
-                log2('* SQL statement is missing.')
-
-                Command.display_help()
-
-            return 'command-missing'
+        with self.validate(args, state) as (args, state):
+            with validate_args(args, state, name='SQL statement') as table:
+                query = Config().get(f'export.column_counts_query', 'select id, count(id) as columns from {table} group by id')
+                query = query.replace('{table}', table)
+                ExportDatabases.run_query(query, state.export_session)
 
-        copy_or_export = 'copy'
-        if state.export_session.startswith('e'):
-            copy_or_export = 'export'
-
-        table = args[0]
-        query = Config().get(f'{copy_or_export}.column_counts_query', 'select id, count(id) as columns from {table} group by id')
-        query = query.replace('{table}', table)
-        ExportDatabases.run_query(query, state.export_session)
-
-        return state
+            return state
 
     def completion(self, state: ReplState):
         if not state.export_session:

adam/commands/export/show_export_databases.py

@@ -1,5 +1,6 @@
 from adam.commands.command import Command
 from adam.commands.devices.device_export import DeviceExport
+from adam.commands.export.export_databases import ExportDatabases
 from adam.repl_state import ReplState
 
 class ShowExportDatabases(Command):
@@ -24,13 +25,10 @@ class ShowExportDatabases(Command):
         if not(args := self.args(cmd)):
             return super().run(cmd, state)
 
-        state, args = self.apply_state(args, state)
-        if not self.validate_state(state):
-            return state
-
-        DeviceExport().show_export_databases()
+        with self.validate(args, state) as (args, state):
+            ExportDatabases.show_databases()
 
-        return state
+            return state
 
     def completion(self, state: ReplState):
         return DeviceExport().ls_completion(ShowExportDatabases.COMMAND, state, default = super().completion(state))

adam/commands/export/show_export_session.py

@@ -1,6 +1,7 @@
+from adam.commands import validate_args
 from adam.commands.command import Command
 from adam.commands.export.export_databases import ExportDatabases
-from adam.commands.export.exporter import Exporter
+from adam.commands.export.export_sessions import ExportSessions
 from adam.repl_state import ReplState, RequiredState
 from adam.utils import log2
 
@@ -26,26 +27,14 @@ class ShowExportSession(Command):
         if not(args := self.args(cmd)):
             return super().run(cmd, state)
 
-        state, args = self.apply_state(args, state)
-        if not self.validate_state(state):
-            return state
-
-        if not args:
-            if state.in_repl:
-                log2('Specify export database name.')
-            else:
-                log2('* Database name is missing.')
-
-                Command.display_help()
+        with self.validate(args, state) as (args, state):
+            with validate_args(args, state, name='database name'):
+                ExportSessions.disply_export_session(state.sts, state.pod, state.namespace, args[0])
 
-            return 'command-missing'
-
-        ExportDatabases.disply_export_session(state.sts, state.pod, state.namespace, args[0])
-
-        return state
+            return state
 
     def completion(self, state: ReplState):
-        return super().completion(state, {session: None for session in Exporter.export_session_names(state.sts, state.pod, state.namespace)})
+        return super().completion(state, {session: None for session in ExportSessions.export_session_names(state.sts, state.pod, state.namespace)})
 
     def help(self, _: ReplState):
         return f'{ShowExportSession.COMMAND} <export-session-name>\t show export session'

adam/commands/export/show_export_sessions.py

@@ -1,5 +1,5 @@
 from adam.commands.command import Command
-from adam.commands.export.exporter import Exporter
+from adam.commands.export.export_sessions import ExportSessions
 from adam.repl_state import ReplState, RequiredState
 from adam.utils import lines_to_tabular, log
 from adam.utils_k8s.statefulsets import StatefulSets
@@ -26,19 +26,16 @@ class ShowExportSessions(Command):
         if not(args := self.args(cmd)):
             return super().run(cmd, state)
 
-        state, args = self.apply_state(args, state)
-        if not self.validate_state(state):
-            return state
-
-        pod = state.pod
-        if not pod:
-            pod = StatefulSets.pod_names(state.sts, state.namespace)[0]
+        with self.validate(args, state) as (args, state):
+            pod = state.pod
+            if not pod:
+                pod = StatefulSets.pod_names(state.sts, state.namespace)[0]
 
-        sessions: dict[str, str] = Exporter.find_export_sessions(pod, state.namespace)
-        log(lines_to_tabular([f'{session}\t{export_state}' for session, export_state in sorted(sessions.items(), reverse=True)],
-                                header='EXPORT_SESSION\tSTATUS', separator='\t'))
+            sessions: dict[str, str] = ExportSessions.find_export_sessions(pod, state.namespace)
+            log(lines_to_tabular([f'{session}\t{export_state}' for session, export_state in sorted(sessions.items(), reverse=True)],
+                                    header='EXPORT_SESSION\tSTATUS', separator='\t'))
 
-        return state
+            return state
 
     def completion(self, state: ReplState):
         return super().completion(state)

adam/commands/export/utils_export.py

@@ -3,8 +3,10 @@ import re
 
 from adam.config import Config
 from adam.pod_exec_result import PodExecResult
+from adam.repl_state import ReplState
 from adam.utils_k8s.cassandra_nodes import CassandraNodes
 from adam.utils_k8s.pods import log_prefix
+from adam.utils_k8s.statefulsets import StatefulSets
 
 class ImportSpec:
     def __init__(self, session: str, importer: str):
@@ -288,4 +290,27 @@ class GeneratorStream(io.RawIOBase):
 
             data = self._buffer[:size]
             self._buffer = self._buffer[size:]
-            return data
+            return data
+
+class PodPushHandler:
+    def __init__(self, state: ReplState):
+        self.state = state
+        self.pushed = False
+
+    def __enter__(self):
+        state = self.state
+
+        if not state.pod:
+            state.push()
+            state.pod = StatefulSets.pod_names(state.sts, state.namespace)[0]
+
+        return state
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if self.pushed:
+            self.state.pop()
+
+        return False
+
+def state_with_pod(state: ReplState):
+    return PodPushHandler(state)

adam/commands/intermediate_command.py

@@ -0,0 +1,49 @@
+from abc import abstractmethod
+
+from adam.commands.command import Command
+from adam.commands.command_helpers import ClusterCommandHelper
+from adam.repl_state import ReplState
+from adam.utils import lines_to_tabular, log, log2
+
+class IntermediateCommand(Command):
+    def run(self, cmd: str, state: ReplState):
+        if not(args := self.args(cmd)):
+            return super().run(cmd, state)
+
+        return self.intermediate_run(cmd, state, args, self.cmd_list())
+
+    @abstractmethod
+    def cmd_list(self):
+        pass
+
+    def intermediate_run(self, cmd: str, state: ReplState, args: list[str], cmds: list['Command'], separator='\t', display_help=True):
+        state, _ = self.apply_state(args, state)
+
+        if state.in_repl:
+            if display_help:
+                log(lines_to_tabular([c.help(state) for c in cmds], separator=separator))
+
+            return 'command-missing'
+        else:
+            # head with the Chain of Responsibility pattern
+            if not self.run_subcommand(cmd, state):
+                if display_help:
+                    log2('* Command is missing.')
+                    Command.display_help()
+                return 'command-missing'
+
+        return state
+
+    def run_subcommand(self, cmd: str, state: ReplState):
+        cmds = Command.chain(self.cmd_list())
+        return cmds.run(cmd, state)
+
+    def intermediate_help(super_help: str, cmd: str, cmd_list: list['Command'], separator='\t', show_cluster_help=False):
+        log(super_help)
+        log()
+        log('Sub-Commands:')
+
+        log(lines_to_tabular([c.help(ReplState()).replace(f'{cmd} ', '  ', 1) for c in cmd_list], separator=separator))
+        if show_cluster_help:
+            log()
+            ClusterCommandHelper.cluster_help()

adam/commands/issues.py

@@ -1,10 +1,9 @@
 from adam.checks.check_result import CheckResult
 from adam.checks.check_utils import run_checks
-from adam.checks.issue import Issue
+from adam.commands import extract_options
 from adam.commands.command import Command
-from adam.repl_session import ReplSession
 from adam.repl_state import ReplState
-from adam.utils import lines_to_tabular, log, log2
+from adam.utils_issues import IssuesUtils
 
 class Issues(Command):
     COMMAND = 'issues'
@@ -28,48 +27,17 @@ class Issues(Command):
         if not(args := self.args(cmd)):
             return super().run(cmd, state)
 
-        state, args = self.apply_state(args, state)
-        if not self.validate_state(state):
-            return state
+        with self.validate(args, state) as (args, state):
+            with extract_options(args, ['-s', '--show']) as (args, show_out):
+                results = run_checks(state.sts, state.namespace, state.pod, show_out=show_out)
 
-        args, show = Command.extract_options(args, ['-s', '--show'])
+                issues = CheckResult.collect_issues(results)
+                IssuesUtils.show_issues(issues, in_repl=state.in_repl)
 
-        results = run_checks(state.sts, state.namespace, state.pod, show_output=show)
+                return issues if issues else 'issues'
 
-        issues = CheckResult.collect_issues(results)
-        Issues.show_issues(issues, in_repl=state.in_repl)
-
-        return issues if issues else 'issues'
-
-    def show(check_results: list[CheckResult], in_repl = False):
-        Issues.show_issues(CheckResult.collect_issues(check_results), in_repl=in_repl)
-
-    def show_issues(issues: list[Issue], in_repl = False):
-        if not issues:
-            log2('No issues found.')
-        else:
-            suggested = 0
-            log2(f'* {len(issues)} issues found.')
-            lines = []
-            for i, issue in enumerate(issues, start=1):
-                lines.append(f"{i}||{issue.category}||{issue.desc}")
-                lines.append(f"||statefulset||{issue.statefulset}@{issue.namespace}")
-                lines.append(f"||pod||{issue.pod}@{issue.namespace}")
-                if issue.details:
-                    lines.append(f"||details||{issue.details}")
-
-                if issue.suggestion:
-                    lines.append(f'||suggestion||{issue.suggestion}')
-                    if in_repl:
-                        ReplSession().prompt_session.history.append_string(issue.suggestion)
-                        suggested += 1
-            log(lines_to_tabular(lines, separator='||'))
-            if suggested:
-                log2()
-                log2(f'* {suggested} suggested commands are added to history. Press <Up> arrow to access them.')
-
-    def completion(self, _: ReplState):
-        return {Issues.COMMAND: None}
+    def completion(self, state: ReplState):
+        return super().completion(state, {'-s': None})
 
     def help(self, _: ReplState):
-        return f'{Issues.COMMAND}\t find all issues'
+        return f'{Issues.COMMAND} [-s]\t find all issues'

adam/commands/kubectl.py

@@ -25,13 +25,10 @@ class Kubectl(Command):
         if not(args := self.args(cmd)):
             return super().run(cmd, state)
 
-        state, args = self.apply_state(args, state)
-        if not self.validate_state(state):
-            return state
-
-        subprocess.run(["kubectl"] + args)
+        with self.validate(args, state) as (args, state):
+            subprocess.run(["kubectl"] + args)
 
-        return state
+            return state
 
     def completion(self, state: ReplState):
         return super().completion(state)

adam/commands/login.py

@@ -1,15 +1,15 @@
 import os
 import signal
-import traceback
 
 from adam.app_session import AppSession
 from adam.apps import Apps
+from adam.commands import extract_options
 from adam.config import Config
 from adam.sso.idp import Idp
 from adam.sso.idp_login import IdpLogin
 from adam.commands.command import Command
-from adam.repl_state import ReplState, RequiredState
-from adam.utils import log, log2
+from adam.repl_state import ReplState
+from adam.utils import log, log2, log_exc
 
 class Login(Command):
     COMMAND = 'login'
@@ -30,37 +30,35 @@ class Login(Command):
         return ReplState.NON_L
 
     def run(self, cmd: str, state: ReplState):
+        if not(args := self.args(cmd)):
+            return super().run(cmd, state)
+
         def custom_handler(signum, frame):
             AppSession.ctrl_c_entered = True
 
         signal.signal(signal.SIGINT, custom_handler)
 
-        if not(args := self.args(cmd)):
-            return super().run(cmd, state)
-
-        state, args = self.apply_state(args, state)
-        args, debug = Command.extract_options(args, ['d'])
-        if debug:
-            Config().set('debug', True)
+        with self.validate(args, state) as (args, state):
+            with extract_options(args, 'd') as (args, debug):
+                if debug:
+                    Config().set('debug', True)
 
-        username: str = os.getenv('USERNAME')
-        if len(args) > 0:
-            username = args[0]
+                username: str = os.getenv('USERNAME')
+                if len(args) > 0:
+                    username = args[0]
 
-        login: IdpLogin = None
-        try:
-            if not(host := Apps.app_host('c3', 'c3', state.namespace)):
-                log2('Cannot locate ingress for app.')
-                return state
+                login: IdpLogin = None
+                with log_exc(True):
+                    if not(host := Apps.app_host('c3', 'c3', state.namespace)):
+                        log2('Cannot locate ingress for app.')
+                        return state
 
-            if not (login := Idp.login(host, username=username, use_token_from_env=False)):
-                log2('Invalid username/password. Please try again.')
-        except:
-            log2(traceback.format_exc())
+                    if not (login := Idp.login(host, username=username, use_token_from_env=False)):
+                        log2('Invalid username/password. Please try again.')
 
-        log(f'IDP_TOKEN={login.ser() if login else ""}')
+                log(f'IDP_TOKEN={login.ser() if login else ""}')
 
-        return state
+                return state
 
     def completion(self, state: ReplState):
         return super().completion(state)

adam/commands/logs.py

@@ -25,12 +25,9 @@ class Logs(Command):
         if not(args := self.args(cmd)):
             return super().run(cmd, state)
 
-        state, args = self.apply_state(args, state)
-        if not self.validate_state(state):
-            return state
-
-        path = Config().get('logs.path', '/c3/cassandra/logs/system.log')
-        return CassandraNodes.exec(state.pod, state.namespace, f'cat {path}')
+        with self.validate(args, state) as (args, state):
+            path = Config().get('logs.path', '/c3/cassandra/logs/system.log')
+            return CassandraNodes.exec(state.pod, state.namespace, f'cat {path}')
 
     def completion(self, _: ReplState):
         # available only on cli

adam/commands/ls.py

@@ -23,17 +23,16 @@ class Ls(Command):
         if not(args := self.args(cmd)):
             return super().run(cmd, state)
 
-        state, args = self.apply_state(args, 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(':', '')
 
-        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.device(state).ls(cmd, state)
 
-        Devices.device(state).ls(cmd, state)
-
-        return state
+            return state
 
     def completion(self, state: ReplState):
         return Devices.device(state).ls_completion(Ls.COMMAND, state, default = super().completion(state))