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

adam/commands/export/export_use.py

@@ -27,26 +27,23 @@ class ExportUse(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:
-            state.export_session = None
+        with self.validate(args, state) as (args, state):
+            if not args:
+                state.export_session = None
 
-            log2('Export database is unset.')
+                log2('Export database is unset.')
 
-            return state
+                return state
 
-        state.export_session = args[0]
-        if state.export_session.startswith('e'):
-            Athena.clear_cache()
-        else:
-            SQLite.clear_cache()
+            state.export_session = args[0]
+            if state.export_session.startswith('e'):
+                Athena.clear_cache()
+            else:
+                SQLite.clear_cache()
 
-        ExportDatabases.display_export_db(state.export_session)
+            ExportDatabases.display_export_db(state.export_session)
 
-        return state
+            return state
 
     def completion(self, state: ReplState):
         return super().completion(state, {n: None for n in ExportDatabases.database_names()})

adam/commands/export/exporter.py

@@ -1,11 +1,9 @@
-from concurrent.futures import ThreadPoolExecutor, as_completed
 from datetime import datetime
 import functools
 import re
 import time
-import traceback
 
-from adam.commands.cql.cql_utils import cassandra_table_names, run_cql, table_spec
+from adam.commands.cql.utils_cql import cassandra_table_names, run_cql, table_spec
 from adam.commands.export.export_databases import ExportDatabases
 from adam.commands.export.importer import Importer
 from adam.commands.export.importer_athena import AthenaImporter
@@ -14,7 +12,7 @@ from adam.commands.export.utils_export import ExportSpec, ExportTableStatus, Exp
 from adam.config import Config
 from adam.pod_exec_result import PodExecResult
 from adam.repl_state import ReplState
-from adam.utils import elapsed_time, log2, ing
+from adam.utils import debug, parallelize, log2, ing, log_exc
 from adam.utils_k8s.cassandra_nodes import CassandraNodes
 from adam.utils_k8s.pods import log_prefix
 from adam.utils_k8s.statefulsets import StatefulSets
@@ -25,7 +23,7 @@ class Exporter:
             log2('export-only for testing')
 
         spec: ExportSpec = None
-        try:
+        with log_exc(True):
             spec = Exporter.export_spec(' '.join(args), state)
 
             statuses, spec = Exporter._export_tables(spec, state, max_workers=max_workers, export_state='init')
@@ -33,8 +31,6 @@ class Exporter:
                 return statuses, spec
 
             return Exporter._export_tables(spec, state, export_only, max_workers, 'pending_export')
-        except Exception as e:
-            log2(e)
 
         return [], None
 
@@ -53,12 +49,19 @@ class Exporter:
                         raise Exception(f"You're currently using {importer_from_session} export database. You cannot export tables with {spec.importer} type database.")
             else:
                 spec.importer = Importer.importer_from_session(session)
+
+            if spec.importer == 'athena' and not AthenaImporter.ping():
+                raise Exception('Credentials for Athena is not present.')
         else:
             if not spec.importer:
                 spec.importer = Config().get('export.default-importer', 'sqlite')
 
             prefix = Importer.prefix_from_importer(spec.importer)
             session = f'{prefix}{datetime.now().strftime("%Y%m%d%H%M%S")[3:]}'
+
+            if spec.importer == 'athena' and not AthenaImporter.ping():
+                raise Exception('Credentials for Athena is not present.')
+
             if spec.importer != 'csv':
                 state.export_session = session
 
@@ -68,7 +71,7 @@ class Exporter:
 
     def import_session(args: list[str], state: ReplState, max_workers = 0) -> tuple[list[str], ExportSpec]:
         import_spec: ImportSpec = None
-        try:
+        with log_exc(True):
             import_spec = Exporter.import_spec(' '.join(args), state)
             tables, status_in_whole = ExportTableStatus.from_session(state.sts, state.pod, state.namespace, import_spec.session)
             if status_in_whole == 'done':
@@ -77,12 +80,7 @@ class Exporter:
 
             spec = ExportSpec(None, None, importer=import_spec.importer, tables=[ExportTableSpec.from_status(table) for table in tables], session=import_spec.session)
 
-            return Exporter._export_tables(spec, state, max_workers=max_workers)
-        except Exception as e:
-            if Config().is_debug():
-                traceback.print_exception(e)
-            else:
-                log2(e)
+            return Exporter._export_tables(spec, state, max_workers=max_workers, export_state = 'import')
 
         return [], None
 
@@ -99,16 +97,19 @@ class Exporter:
                 spec.importer = Importer.importer_from_session(state.export_session)
                 if not spec.importer:
                     spec.importer = Config().get('export.default-importer', 'sqlite')
+
+            if spec.importer == 'athena' and not AthenaImporter.ping():
+                raise Exception('Credentials for Athena is not present.')
         else:
-            if spec.importer:
-                if not AthenaImporter.ping():
-                    raise Exception('Credentials for Athena are not present.')
-            else:
+            if not spec.importer:
                 spec.importer = Importer.importer_from_session(spec.session)
 
             if spec.importer == 'csv':
                 spec.importer = Config().get('export.default-importer', 'sqlite')
 
+            if spec.importer == 'athena' and not AthenaImporter.ping():
+                raise Exception('Credentials for Athena is not present.')
+
             prefix = Importer.prefix_from_importer(spec.importer)
             session = f'{prefix}{spec.session[1:]}'
             state.export_session = session
@@ -128,20 +129,14 @@ class Exporter:
         if export_state == 'init':
             CassandraNodes.exec(state.pod, state.namespace, f'rm -rf {csv_dir()}/{spec.session}_*', show_out=Config().is_debug(), shell='bash')
 
-        if max_workers > 1 and len(spec.tables) > 1:
-            log2(f'Executing on {len(spec.tables)} Cassandra tables in parallel...')
-            start_time = time.time()
-            try:
-                with ThreadPoolExecutor(max_workers=max_workers) as executor:
-                    futures = [executor.submit(Exporter.export_table, table, state, spec.session, spec.importer, export_only, True, consistency=spec.consistency, export_state=export_state) for table in spec.tables]
-                    if len(futures) == 0:
-                        return [], spec
-
-                return [future.result() for future in as_completed(futures)], spec
-            finally:
-                log2(f"{len(spec.tables)} parallel table export elapsed time: {elapsed_time(start_time)} with {max_workers} workers")
-        else:
-            return [Exporter.export_table(table, state, spec.session, spec.importer, export_only, multi_tables=len(spec.tables) > 1, consistency=spec.consistency, export_state=export_state) for table in spec.tables], spec
+        action = f'[{spec.session}] Exporting|Exported'
+        if export_state == 'init':
+            action = f'[{spec.session}] Preparing|Prepared'
+        elif export_state == 'import':
+            action = f'[{spec.session}] Importing|Imported'
+
+        with parallelize(spec.tables, max_workers, msg=action + ' {size} Cassandra tables') as exec:
+            return exec.map(lambda table: Exporter.export_table(table, state, spec.session, spec.importer, export_only, len(spec.tables) > 1, consistency=spec.consistency, export_state=export_state)), spec
 
     def export_table(spec: ExportTableSpec, state: ReplState, session: str, importer: str, export_only = False, multi_tables = True, consistency: str = None, export_state=None):
         s: str = None
@@ -167,8 +162,7 @@ class Exporter:
             status: ExportTableStatus = ExportTableStatus.from_log_file(state.pod, state.namespace, session, log_file)
             while status.status != 'done':
                 if status.status == 'export_in_pregress':
-                    if Config().is_debug():
-                        log2('Exporting to CSV is still in progess, sleeping for 1 sec...')
+                    debug('Exporting to CSV is still in progess, sleeping for 1 sec...')
                     time.sleep(1)
                 elif status.status == 'exported':
                     log_file = Exporter.rename_to_pending_import(spec, state, session, target_table)
@@ -283,20 +277,15 @@ class Exporter:
         if not max_workers:
             max_workers = Config().action_workers('export', 8)
 
-        if max_workers > 1 and len(sessions) > 1:
-            log2(f'Executing on {len(sessions)} export session clean ups in parallel...')
-            start_time = time.time()
-            try:
-                with ThreadPoolExecutor(max_workers=max_workers) as executor:
-                    futures = [executor.submit(Exporter.clean_up_session, sts, pod, namespace, session, True) for session in sessions]
-                    if len(futures) == 0:
-                        return []
-
-                return [future.result() for future in as_completed(futures)]
-            finally:
-                log2(f"{len(sessions)} parallel session clean ups elapsed time: {elapsed_time(start_time)} with {max_workers} workers")
-        else:
-            return [Exporter.clean_up_session(sts, pod, namespace, session) for session in sessions]
+        with parallelize(sessions, max_workers, msg='Cleaning|Cleaned up {size} export sessions') as exec:
+            cnt_tuples = exec.map(lambda session: Exporter.clean_up_session(sts, pod, namespace, session, True))
+            csv_cnt = 0
+            log_cnt = 0
+            for (csv, log) in cnt_tuples:
+                csv_cnt += csv
+                log_cnt += log
+
+            return csv_cnt, log_cnt
 
     def clean_up_session(sts: str, pod: str, namespace: str, session: str, multi_tables = True):
         if not sts or not namespace:

adam/commands/export/import_session.py

@@ -1,9 +1,7 @@
 from adam.commands.command import Command
-from adam.commands.export.export_databases import ExportDatabases
+from adam.commands.export.export_handlers import export
 from adam.commands.export.exporter import Exporter
 from adam.repl_state import ReplState, RequiredState
-from adam.utils import log, log2
-from adam.utils_k8s.statefulsets import StatefulSets
 
 class ImportSession(Command):
     COMMAND = 'import session'
@@ -27,35 +25,9 @@ class ImportSession(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 session name.')
-            else:
-                log2('* Export session name is missing.')
-
-                Command.display_help()
-
-            return 'command-missing'
-
-        if not state.pod:
-            state.push()
-            state.pod = StatefulSets.pod_names(state.sts, state.namespace)[0]
-
-        try:
-            tables, _ = Exporter.import_session(args, state)
-            if tables:
-                Exporter.clear_export_session_cache()
-
-                log()
-                ExportDatabases.display_export_db(state.export_session)
-        finally:
-            state.pop()
-
-        return state
+        with self.validate(args, state) as (args, state):
+            with export(state) as exporter:
+                return exporter.import_sesion(args)
 
     def completion(self, state: ReplState):
         # warm up cache

adam/commands/export/importer_athena.py

@@ -3,7 +3,7 @@ import boto3
 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.utils import debug, log2, ing
 from adam.utils_athena import Athena
 from adam.utils_k8s.pods import Pods
 
@@ -38,13 +38,11 @@ class AthenaImporter(Importer):
                 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)
+                debug(query)
                 Athena.query(query, 'default')
 
                 query = f'DROP TABLE IF EXISTS {target_table};'
-                if Config().is_debug():
-                    log2(query)
+                debug(query)
                 Athena.query(query, db)
 
                 athena_columns = ', '.join([f'{c} string' for c in columns.split(',')])
@@ -56,8 +54,7 @@ class AthenaImporter(Importer):
                             '    "quoteChar"     = "\\"")\n' + \
                         f"LOCATION 's3://{bucket}/export/{db}/{keyspace}/{target_table}'\n" + \
                             'TBLPROPERTIES ("skip.header.line.count"="1");'
-                if Config().is_debug():
-                    log2(query)
+                debug(query)
                 try:
                     Athena.query(query, db)
                 except Exception as e:

adam/commands/export/importer_sqlite.py

@@ -1,12 +1,10 @@
-import os
-import sqlite3
 import pandas
 
 from adam.commands.export.importer import Importer
 from adam.commands.export.utils_export import GeneratorStream
 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):
@@ -14,34 +12,28 @@ class SqliteImporter(Importer):
 
     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):
         csv_file = self.csv_file(from_session, table, target_table)
-        db = self.db(to_session, keyspace)
 
         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 sqlite(to_session, keyspace) as conn:
+            try:
+                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))
 
-            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')
 
-                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(pod, namespace, to_session, from_session, keyspace, target_table)
+                succeeded = True
 
-            succeeded = True
+                return to, to_session
+            finally:
+                if succeeded:
+                    self.remove_csv(pod, namespace, from_session, table, target_table, multi_tables)
+                    SQLite.clear_cache()
 
-            return to, to_session
-        finally:
-            if succeeded:
-                self.remove_csv(pod, namespace, 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()
+                    if not multi_tables:
+                        with sqlite(to_session) as conn:
+                            query = f'select * from {keyspace}.{target_table} limit 10'
+                            log2(query)
+                            SQLite.run_query_with_conn(conn, query)

adam/commands/export/show_column_counts.py

@@ -3,8 +3,6 @@ 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 +26,23 @@ 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.')
+        with self.validate(args, state) as (args, state):
+            if not args:
+                if state.in_repl:
+                    log2('Use a SQL statement.')
+                else:
+                    log2('* SQL statement is missing.')
 
-                Command.display_help()
+                    Command.display_help()
 
-            return 'command-missing'
+                return 'command-missing'
 
-        copy_or_export = 'copy'
-        if state.export_session.startswith('e'):
-            copy_or_export = 'export'
+            table = args[0]
+            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)
 
-        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

@@ -24,13 +24,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):
+            DeviceExport().show_export_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

@@ -26,23 +26,20 @@ 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.')
+        with self.validate(args, state) as (args, state):
+            if not args:
+                if state.in_repl:
+                    log2('Specify export database name.')
+                else:
+                    log2('* Database name is missing.')
 
-                Command.display_help()
+                    Command.display_help()
 
-            return 'command-missing'
+                return 'command-missing'
 
-        ExportDatabases.disply_export_session(state.sts, state.pod, state.namespace, args[0])
+            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)})

adam/commands/export/show_export_sessions.py

@@ -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] = 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'))
 
-        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,25 @@ class GeneratorStream(io.RawIOBase):
 
             data = self._buffer[:size]
             self._buffer = self._buffer[size:]
-            return data
+            return data
+
+class PodHandler:
+    def __init__(self, state: ReplState):
+        self.state = state
+
+    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):
+        self.state.pop()
+
+        return False
+
+def state_with_pod(state: ReplState):
+    return PodHandler(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'