kaqing 2.0.52__py3-none-any.whl → 2.0.110__py3-none-any.whl

adam/commands/help.py

@@ -23,20 +23,23 @@ class Help(Command):
             return super().run(cmd, state)
 
         def section(cmds : list[ReplCommands]):
-            return [f'  {c.help(state)}' for c in cmds if c.help(state)]
+            sorted_cmds = sorted(cmds, key=lambda cmd: cmd.command())
+            return [f'  {c.help(state)}' for c in sorted_cmds if c.help(state)]
 
         lines = []
         lines.append('NAVIGATION')
-        lines.append('  a: | c: | p:\t switch to another operational device: App, Cassandra or Postgres')
+        lines.append('  a: | c: | l: | p:\t switch to another operational device: App, Cassandra, Audit or Postgres')
         lines.extend(section(ReplCommands.navigation()))
-        lines.append('CHECK CASSANDRA')
-        lines.extend(section(ReplCommands.cassandra_check()))
-        lines.append('CASSANDRA OPERATIONS')
+        lines.append('CASSANDRA')
         lines.extend(section(ReplCommands.cassandra_ops()))
+        lines.append('POSTGRES')
+        lines.extend(section(ReplCommands.postgres_ops()))
+        lines.append('APP')
+        lines.extend(section(ReplCommands.app_ops()))
+        lines.append('AUDIT')
+        lines.extend(section(ReplCommands.audit_ops()))
         lines.append('TOOLS')
         lines.extend(section(ReplCommands.tools()))
-        lines.append('APP')
-        lines.extend(section(ReplCommands.app()))
         lines.append('')
         lines.extend(section(ReplCommands.exit()))
 

adam/commands/issues.py

@@ -21,11 +21,17 @@ class Issues(Command):
     def command(self):
         return Issues.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)
 
         state, args = self.apply_state(args, state)
+        if not self.validate_state(state):
+            return state
+
         args, show = Command.extract_options(args, ['-s', '--show'])
 
         results = run_checks(state.sts, state.namespace, state.pod, show_output=show)

adam/commands/login.py

@@ -8,7 +8,7 @@ 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
+from adam.repl_state import ReplState, RequiredState
 from adam.utils import log, log2
 
 class Login(Command):
@@ -26,6 +26,9 @@ class Login(Command):
     def command(self):
         return Login.COMMAND
 
+    def required(self):
+        return ReplState.NON_L
+
     def run(self, cmd: str, state: ReplState):
         def custom_handler(signum, frame):
             AppSession.ctrl_c_entered = True
@@ -59,8 +62,8 @@ class Login(Command):
 
         return state
 
-    def completion(self, _: ReplState):
-        return {}
+    def completion(self, state: ReplState):
+        return super().completion(state)
 
     def help(self, _: ReplState):
         return f'{Login.COMMAND}\t SSO login'

adam/commands/logs.py

@@ -1,6 +1,6 @@
 from adam.commands.command import Command
 from adam.config import Config
-from adam.k8s_utils.cassandra_nodes import CassandraNodes
+from adam.utils_k8s.cassandra_nodes import CassandraNodes
 from adam.repl_state import ReplState, RequiredState
 
 class Logs(Command):
@@ -33,6 +33,7 @@ class Logs(Command):
         return CassandraNodes.exec(state.pod, state.namespace, f'cat {path}')
 
     def completion(self, _: ReplState):
+        # available only on cli
         return {}
 
     def help(self, _: ReplState):

adam/commands/ls.py

@@ -4,16 +4,17 @@ from adam.commands.command import Command
 from adam.commands.commands_utils import show_pods, show_rollout
 from adam.commands.cql.cqlsh import Cqlsh
 from adam.commands.postgres.postgres_utils import pg_database_names, pg_table_names
-from adam.commands.postgres.postgres_session import PostgresSession
+from adam.commands.postgres.postgres_context import PostgresContext
 from adam.config import Config
-from adam.k8s_utils.custom_resources import CustomResources
-from adam.k8s_utils.ingresses import Ingresses
-from adam.k8s_utils.kube_context import KubeContext
-from adam.k8s_utils.statefulsets import StatefulSets
+from adam.utils_k8s.custom_resources import CustomResources
+from adam.utils_k8s.ingresses import Ingresses
+from adam.utils_k8s.kube_context import KubeContext
+from adam.utils_k8s.statefulsets import StatefulSets
 from adam.pod_exec_result import PodExecResult
 from adam.repl_state import ReplState
 from adam.utils import lines_to_tabular, log, log2
 from adam.apps import Apps
+from adam.utils_audits import Audits
 
 class Ls(Command):
     COMMAND = 'ls'
@@ -44,7 +45,7 @@ class Ls(Command):
 
         if state.device == ReplState.P:
             if state.pg_path:
-                pg = PostgresSession(state.namespace, state.pg_path)
+                pg: PostgresContext = PostgresContext.apply(state.namespace, state.pg_path)
                 if pg.db:
                     self.show_pg_tables(pg)
                 else:
@@ -71,6 +72,8 @@ class Ls(Command):
                 svcs = [n for n, ns in Apps.envs()]
 
                 log(lines_to_tabular(svcs, 'ENV', separator=','))
+        elif state.device == ReplState.L:
+            self.show_audit_log_tables()
         else:
             if state.pod:
                 r: PodExecResult = Cqlsh().run(f'cql describe tables', state)
@@ -86,9 +89,9 @@ class Ls(Command):
         return state
 
     def show_statefulsets(self):
-        ss = StatefulSets.list_sts_names(show_namespace=not KubeContext.in_cluster_namespace())
+        ss = StatefulSets.list_sts_names()
         if len(ss) == 0:
-            log2('No cassandra statefulsets found.')
+            log2('No Cassandra clusters found.')
             return
 
         app_ids = CustomResources.get_app_ids()
@@ -107,34 +110,37 @@ class Ls(Command):
 
     def show_pg_hosts(self, state: ReplState):
         if state.namespace:
-            def line(pg: PostgresSession):
-                return f'{pg.directory()},{pg.endpoint()}:{pg.port()},{pg.username()},{pg.password()}'
+            def line(pg: PostgresContext):
+                return f'{pg.path()},{pg.endpoint()}:{pg.port()},{pg.username()},{pg.password()}'
 
-            lines = [line(PostgresSession(state.namespace, pg)) for pg in PostgresSession.hosts(state.namespace)]
+            lines = [line(PostgresContext.apply(state.namespace, pg)) for pg in PostgresContext.hosts(state.namespace)]
 
             log(lines_to_tabular(lines, 'NAME,ENDPOINT,USERNAME,PASSWORD', separator=','))
         else:
-            def line(pg: PostgresSession):
-                return f'{pg.directory()},{pg.namespace},{pg.endpoint()}:{pg.port()},{pg.username()},{pg.password()}'
+            def line(pg: PostgresContext):
+                return f'{pg.path()},{pg.namespace},{pg.endpoint()}:{pg.port()},{pg.username()},{pg.password()}'
 
-            lines = [line(PostgresSession(state.namespace, pg)) for pg in PostgresSession.hosts(state.namespace)]
+            lines = [line(PostgresContext.apply(state.namespace, pg)) for pg in PostgresContext.hosts(state.namespace)]
 
             log(lines_to_tabular(lines, 'NAME,NAMESPACE,ENDPOINT,USERNAME,PASSWORD', separator=','))
 
-    def show_pg_databases(self, pg: PostgresSession):
-        log(lines_to_tabular(pg_database_names(pg.namespace, pg.directory()), 'DATABASE', separator=','))
+    def show_pg_databases(self, pg: PostgresContext):
+        log(lines_to_tabular(pg_database_names(pg.namespace, pg.path()), 'DATABASE', separator=','))
 
-    def show_pg_tables(self, pg: PostgresSession):
-        log(lines_to_tabular(pg_table_names(pg.namespace, pg.directory()), 'NAME', separator=','))
+    def show_pg_tables(self, pg: PostgresContext):
+        log(lines_to_tabular(pg_table_names(pg.namespace, pg.path()), 'NAME', separator=','))
 
-    def completion(self, state: ReplState):
-        if state.pod:
-            return {}
+    def show_audit_log_tables(self):
+        log(lines_to_tabular(Audits.audit_table_names(), 'NAME', separator=','))
 
-        if not state.sts:
-            return {Ls.COMMAND: {n: None for n in StatefulSets.list_sts_names()}}
+    def completion(self, state: ReplState):
+        if state.device == ReplState.C:
+            if state.pod:
+                return super().completion(state)
+            elif not state.sts:
+                return {Ls.COMMAND: {n: None for n in StatefulSets.list_sts_names()}}
 
-        return {Ls.COMMAND: None}
+        return super().completion(state)
 
     def help(self, _: ReplState):
         return f'{Ls.COMMAND} [device:]\t list apps, envs, clusters, nodes, pg hosts or pg databases'

adam/commands/medusa/medusa_backup.py

@@ -2,9 +2,9 @@ from datetime import datetime
 import re
 
 from adam.commands.command import Command
-from adam.k8s_utils.statefulsets import StatefulSets
+from adam.utils_k8s.statefulsets import StatefulSets
 from adam.repl_state import ReplState, RequiredState
-from adam.k8s_utils.custom_resources import CustomResources
+from adam.utils_k8s.custom_resources import CustomResources
 from adam.utils import log2
 
 

adam/commands/medusa/medusa_restore.py

@@ -1,9 +1,9 @@
 from datetime import datetime
 
 from adam.commands.command import Command
-from adam.k8s_utils.statefulsets import StatefulSets
+from adam.utils_k8s.statefulsets import StatefulSets
 from adam.repl_state import ReplState, RequiredState
-from adam.k8s_utils.custom_resources import CustomResources
+from adam.utils_k8s.custom_resources import CustomResources
 from adam.config import Config
 from adam.utils import lines_to_tabular, log2
 

adam/commands/medusa/medusa_show_backupjobs.py

@@ -1,7 +1,7 @@
 from adam.commands.command import Command
-from adam.k8s_utils.statefulsets import StatefulSets
+from adam.utils_k8s.statefulsets import StatefulSets
 from adam.repl_state import ReplState, RequiredState
-from adam.k8s_utils.custom_resources import CustomResources
+from adam.utils_k8s.custom_resources import CustomResources
 from adam.utils import lines_to_tabular, log2
 
 
@@ -29,6 +29,7 @@ class MedusaShowBackupJobs(Command):
         state, args = self.apply_state(args, state)
         if not self.validate_state(state):
             return state
+
         ns = state.namespace
         dc = StatefulSets.get_datacenter(state.sts, ns)
         if not dc:

adam/commands/medusa/medusa_show_restorejobs.py

@@ -1,7 +1,7 @@
 from adam.commands.command import Command
-from adam.k8s_utils.statefulsets import StatefulSets
+from adam.utils_k8s.statefulsets import StatefulSets
 from adam.repl_state import ReplState, RequiredState
-from adam.k8s_utils.custom_resources import CustomResources
+from adam.utils_k8s.custom_resources import CustomResources
 from adam.utils import lines_to_tabular, log2
 
 class MedusaShowRestoreJobs(Command):

adam/commands/nodetool.py

@@ -4,8 +4,8 @@ from adam.commands.command import Command
 from adam.commands.command_helpers import ClusterOrPodCommandHelper
 from adam.commands.nodetool_commands import NODETOOL_COMMANDS
 from adam.config import Config
-from adam.k8s_utils.cassandra_clusters import CassandraClusters
-from adam.k8s_utils.cassandra_nodes import CassandraNodes
+from adam.utils_k8s.cassandra_clusters import CassandraClusters
+from adam.utils_k8s.cassandra_nodes import CassandraNodes
 from adam.repl_state import ReplState, RequiredState
 from adam.utils import log
 
@@ -43,9 +43,11 @@ class NodeTool(Command):
         elif state.sts:
             return CassandraClusters.exec(state.sts, state.namespace, command, action='nodetool', show_out=True)
 
+        return state
+
     def completion(self, state: ReplState):
         if state.pod or state.sts:
-            return {NodeTool.COMMAND: {'help': None} | {c: None for c in NODETOOL_COMMANDS}}
+            return {NodeTool.COMMAND: {'help': None} | {c: {'&': None} for c in NODETOOL_COMMANDS}}
 
         return {}
 

adam/commands/postgres/postgres.py

@@ -5,7 +5,7 @@ from adam.commands.postgres.psql_completions import psql_completions
 from adam.commands.postgres.postgres_utils import pg_table_names
 from .postgres_ls import PostgresLs
 from .postgres_preview import PostgresPreview
-from .postgres_session import PostgresSession
+from .postgres_context import PostgresContext
 from adam.repl_state import ReplState
 from adam.utils import log, log2
 
@@ -62,7 +62,7 @@ class Postgres(Command):
 
             return state
 
-        PostgresSession(state.namespace, state.pg_path).run_sql(' '.join(args))
+        PostgresContext.apply(state.namespace, state.pg_path).run_sql(' '.join(args))
 
     def completion(self, state: ReplState):
         if state.device != state.P:
@@ -70,7 +70,7 @@ class Postgres(Command):
             return {}
 
         leaf = {}
-        session = PostgresSession(state.namespace, state.pg_path)
+        session = PostgresContext.apply(state.namespace, state.pg_path)
         if session.db:
           if pg_table_names(state.namespace, state.pg_path):
             leaf = psql_completions(state.namespace, state.pg_path)

adam/commands/postgres/{postgres_session.py → postgres_context.py}

@@ -3,12 +3,33 @@ import re
 import subprocess
 
 from adam.config import Config
-from adam.k8s_utils.kube_context import KubeContext
-from adam.k8s_utils.pods import Pods
-from adam.k8s_utils.secrets import Secrets
+from adam.utils_k8s.kube_context import KubeContext
+from adam.utils_k8s.pods import Pods
+from adam.utils_k8s.secrets import Secrets
 from adam.utils import log2
 
-class PostgresSession:
+class PostgresContext:
+    def apply(namespace: str, path: str, arg: str = None) -> 'PostgresContext':
+        context = PostgresContext(namespace, path)
+
+        if arg:
+            if arg == '..':
+                if context.db:
+                    context.db = None
+                else:
+                    context.host = None
+            else:
+                tks = arg.split('@')
+                if not context.host:
+                    context.host = tks[0]
+                else:
+                    context.db = tks[0]
+
+                if not namespace and tks[1]:
+                    context.namespace = tks[1]
+
+        return context
+
     def __init__(self, ns: str, path: str):
         self.namespace = ns
         self.conn_details = None
@@ -25,29 +46,7 @@ class PostgresSession:
             if len(tks) > 1:
                 self.db = tks[1]
 
-    def find_namespace(self, arg: str):
-        if arg:
-            tks = arg.split('@')
-            if len(tks) > 1:
-                return tks[1]
-
-        return None
-
-    def directory(self, arg: str = None):
-        if arg:
-            if arg == '..':
-                if self.db:
-                    self.db = None
-                else:
-                    self.host = None
-            else:
-                tks = arg.split('@')
-                arg = tks[0]
-                if not self.host:
-                    self.host = arg
-                else:
-                    self.db = arg
-
+    def path(self):
         if not self.host:
             return None
 
@@ -58,7 +57,7 @@ class PostgresSession:
         return f'{self.host}/{self.db}'
 
     def hosts(ns: str):
-        return PostgresSession.hosts_for_namespace(ns)
+        return PostgresContext.hosts_for_namespace(ns)
 
     @functools.lru_cache()
     def hosts_for_namespace(ns: str):
@@ -133,7 +132,7 @@ class PostgresSession:
         return dbs
 
     def run_sql(self, sql: str, show_out = True):
-        db = self.db if self.db else PostgresSession.default_db()
+        db = self.db if self.db else PostgresContext.default_db()
 
         if KubeContext.in_cluster():
             cmd1 = f'env PGPASSWORD={self.password()} psql -h {self.endpoint()} -p {self.port()} -U {self.username()} {db} --pset pager=off -c'
@@ -151,7 +150,7 @@ class PostgresSession:
             pod_name = Config().get('pg.agent.name', 'ops-pg-agent')
 
             if Config().get('pg.agent.just-in-time', False):
-                if not PostgresSession.deploy_pg_agent(pod_name, ns):
+                if not PostgresContext.deploy_pg_agent(pod_name, ns):
                     return
 
             real_pod_name = pod_name

adam/commands/postgres/postgres_utils.py

@@ -1,6 +1,6 @@
 import functools
 
-from adam.commands.postgres.postgres_session import PostgresSession
+from adam.commands.postgres.postgres_context import PostgresContext
 from adam.config import Config
 
 TestPG = [False]
@@ -12,8 +12,8 @@ def pg_database_names(ns: str, pg_path: str):
 
     Config().wait_log('Inspecting Postgres Databases...')
 
-    pg = PostgresSession(ns, pg_path)
-    return [db['name'] for db in pg.databases() if db['owner'] == PostgresSession.default_owner()]
+    pg = PostgresContext.apply(ns, pg_path)
+    return [db['name'] for db in pg.databases() if db['owner'] == PostgresContext.default_owner()]
 
 @functools.lru_cache()
 def pg_table_names(ns: str, pg_path: str):
@@ -21,10 +21,10 @@ def pg_table_names(ns: str, pg_path: str):
         return ['C3_2_XYZ1']
 
     Config().wait_log('Inspecting Postgres Database...')
-    return [table['name'] for table in pg_tables(ns, pg_path) if table['schema'] == PostgresSession.default_schema()]
+    return [table['name'] for table in pg_tables(ns, pg_path) if table['schema'] == PostgresContext.default_schema()]
 
 def pg_tables(ns: str, pg_path: str):
-    pg = PostgresSession(ns, pg_path)
+    pg = PostgresContext.apply(ns, pg_path)
     if pg.db:
         return pg.tables()
 

adam/commands/postgres/psql_completions.py

@@ -7,4 +7,4 @@ def psql_completions(ns: str, pg_path: str):
         '\d': None,
         '\dt': None,
         '\du': None
-    } | SqlCompleter.completions(lambda: pg_table_names(ns, pg_path))
+    } | SqlCompleter(lambda: pg_table_names(ns, pg_path)).completions_for_nesting()

adam/commands/preview_table.py

@@ -1,13 +1,10 @@
-import functools
-
 from adam.commands.command import Command
-from adam.commands.cql.cql_table_completer import CqlTableNameCompleter
-from adam.commands.cql.cql_utils import run_cql, table_names, tables
-from adam.commands.postgres.postgres_session import PostgresSession
-from adam.commands.postgres.psql_table_completer import PsqlTableNameCompleter
+from adam.commands.cql.cql_utils import cassandra_table_names, run_cql
+from adam.commands.postgres.postgres_context import PostgresContext
 from adam.config import Config
 from adam.repl_state import ReplState, RequiredState
 from adam.utils import lines_to_tabular, log, log2
+from adam.utils_audits import Audits
 
 class PreviewTable(Command):
     COMMAND = 'preview'
@@ -25,28 +22,26 @@ class PreviewTable(Command):
         return PreviewTable.COMMAND
 
     def required(self):
-        return RequiredState.CLUSTER_OR_POD
+        return [RequiredState.CLUSTER_OR_POD, RequiredState.PG_DATABASE, ReplState.L]
 
     def run(self, cmd: str, state: ReplState):
         if not(args := self.args(cmd)):
             return super().run(cmd, state)
 
         state, args = self.apply_state(args, state)
-        if state.device == ReplState.P:
-            if not self.validate_state(state, RequiredState.PG_DATABASE):
-                return state
-        else:
-            if not self.validate_state(state):
-                return state
+        if not self.validate_state(state):
+            return state
 
         if not args:
             def show_tables():
                 if state.device == ReplState.P:
-                    pg = PostgresSession(state.namespace, state.pg_path)
-                    lines = [db["name"] for db in pg.tables() if db["schema"] == PostgresSession.default_schema()]
+                    pg = PostgresContext.apply(state.namespace, state.pg_path)
+                    lines = [db["name"] for db in pg.tables() if db["schema"] == PostgresContext.default_schema()]
                     log(lines_to_tabular(lines, separator=','))
+                elif state.device == ReplState.L:
+                    log(lines_to_tabular(Audits.audit_table_names(), separator=','))
                 else:
-                    run_cql(state, f'describe tables', show_out=True)
+                    log(lines_to_tabular(cassandra_table_names(state), separator=','))
 
             if state.in_repl:
                 log2('Table is required.')
@@ -65,26 +60,16 @@ class PreviewTable(Command):
 
         rows = Config().get('preview.rows', 10)
         if state.device == ReplState.P:
-            PostgresSession(state.namespace, state.pg_path).run_sql(f'select * from {table} limit {rows}')
+            PostgresContext.apply(state.namespace, state.pg_path).run_sql(f'select * from {table} limit {rows}')
+        elif state.device == ReplState.L:
+            Audits.run_audit_query(f'select * from {table} limit {rows}')
         else:
-            run_cql(state, f'select * from {table} limit {rows}', show_out=True, use_single_quotes=True)
+            run_cql(state, f'select * from {table} limit {rows}', show_out=True, use_single_quotes=True, on_any=True)
 
         return state
 
-    def completion(self, state: ReplState):
-        if state.device == ReplState.P:
-            return {PreviewTable.COMMAND: PsqlTableNameCompleter(state.namespace, state.pg_path)}
-        elif state.sts:
-            return {PreviewTable.COMMAND: CqlTableNameCompleter(table_names(state))}
-
+    def completion(self, _: ReplState):
         return {}
 
     def help(self, _: ReplState):
-        return f'{PreviewTable.COMMAND} TABLE\t preview table'
-
-    @functools.lru_cache()
-    def cql_tables(state: ReplState):
-        if state.pod:
-            return tables(state)
-
-        return tables(state, on_any=True)
+        return f'{PreviewTable.COMMAND} TABLE\t preview table'

adam/commands/pwd.py

@@ -1,6 +1,6 @@
 from adam.app_session import AppSession
 from adam.commands.command import Command
-from adam.commands.postgres.postgres_session import PostgresSession
+from adam.commands.postgres.postgres_context import PostgresContext
 from adam.repl_state import ReplState
 from adam.utils import lines_to_tabular, log
 
@@ -29,7 +29,7 @@ class Pwd(Command):
             words = []
 
             if device == ReplState.P:
-                pg = PostgresSession(state.namespace, state.pg_path)
+                pg: PostgresContext = PostgresContext.apply(state.namespace, state.pg_path)
 
                 if pg.host:
                     words.append(f'host/{pg.host}')
@@ -40,6 +40,8 @@ class Pwd(Command):
                     words.append(f'env/{state.app_env}')
                 if state.app_app:
                     words.append(f'app/{state.app_app}')
+            elif device == ReplState.L:
+                pass
             else:
                 if state.sts:
                     words.append(f'sts/{state.sts}')
@@ -58,6 +60,7 @@ class Pwd(Command):
         log(lines_to_tabular([
             device_line(state, ReplState.A),
             device_line(state, ReplState.C),
+            device_line(state, ReplState.L),
             device_line(state, ReplState.P),
             f'',
             f'HOST\t{host}',

adam/commands/reaper/reaper.py

@@ -37,6 +37,9 @@ class Reaper(Command):
         if not(args := self.args(cmd)):
             return super().run(cmd, state)
 
+        if not self.validate_state(state):
+            return state
+
         return super().intermediate_run(cmd, state, args, Reaper.cmd_list())
 
     def cmd_list():

adam/commands/reaper/reaper_restart.py

@@ -1,5 +1,5 @@
 from adam.commands.command import Command
-from adam.k8s_utils.pods import Pods
+from adam.utils_k8s.pods import Pods
 from .reaper_session import ReaperSession
 from adam.repl_state import ReplState, RequiredState
 

adam/commands/reaper/reaper_session.py

@@ -7,7 +7,7 @@ import requests
 from typing import List, cast
 
 from adam.config import Config
-from adam.k8s_utils.kube_context import KubeContext
+from adam.utils_k8s.kube_context import KubeContext
 from adam.repl_state import ReplState
 from adam.utils import lines_to_tabular, log2
 

adam/commands/repair/repair.py

@@ -28,6 +28,8 @@ class Repair(Command):
     def run(self, cmd: str, state: ReplState):
         if not(args := self.args(cmd)):
             return super().run(cmd, state)
+        if not self.validate_state(state):
+            return state
 
         return super().intermediate_run(cmd, state, args, Repair.cmd_list())
 
@@ -35,9 +37,7 @@ class Repair(Command):
         return [RepairRun(), RepairScan(), RepairStop(), RepairLog()]
 
     def completion(self, state: ReplState):
-        if state.sts:
-            return super().completion(state)
-        return {}
+        return super().completion(state)
 
 class RepairCommandHelper(click.Command):
     def get_help(self, ctx: click.Context):

adam/commands/repair/repair_log.py

@@ -1,5 +1,5 @@
 from adam.commands.command import Command
-from adam.k8s_utils.jobs import Jobs
+from adam.utils_k8s.jobs import Jobs
 from adam.repl_state import ReplState, RequiredState
 
 class RepairLog(Command):

adam/commands/repair/repair_run.py

@@ -1,6 +1,6 @@
 from adam.commands.command import Command
-from adam.k8s_utils.jobs import Jobs
-from adam.k8s_utils.volumes import Volumes
+from adam.utils_k8s.jobs import Jobs
+from adam.utils_k8s.volumes import Volumes
 from adam.repl_state import ReplState, RequiredState
 from adam.config import Config
 from adam.commands.reaper.reaper_session import ReaperSession

adam/commands/repair/repair_scan.py

@@ -1,7 +1,7 @@
 import time
 
 from adam.commands.command import Command
-from adam.k8s_utils.pods import Pods
+from adam.utils_k8s.pods import Pods
 from adam.repl_state import ReplState, RequiredState
 from adam.utils import log2
 from adam.config import Config

adam/commands/repair/repair_stop.py

@@ -1,5 +1,5 @@
 from adam.commands.command import Command
-from adam.k8s_utils.jobs import Jobs
+from adam.utils_k8s.jobs import Jobs
 from adam.repl_state import ReplState, RequiredState
 from adam.config import Config