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

adam/commands/devices/device_app.py

@@ -5,7 +5,7 @@ from adam.commands.command import Command, InvalidStateException
 from adam.commands.devices.device import Device
 from adam.config import Config
 from adam.repl_state import ReplState
-from adam.utils import lines_to_tabular, log, wait_log
+from adam.utils import tabulize, log, wait_log
 from adam.utils_k8s.app_pods import AppPods
 from adam.utils_k8s.ingresses import Ingresses
 
@@ -38,13 +38,20 @@ class DeviceApp(Command, Device):
     def help(self, _: ReplState):
         return f'{DeviceApp.COMMAND}\t move to App Operations device'
 
+    def pod(self, state: ReplState) -> str:
+        return state.app_pod
+
+    def pod_names(self, state: ReplState) -> list[str]:
+        return AppPods.pod_names(state.namespace, state.app_env, state.app_app)
+
+    def default_container(self, state: ReplState) -> str:
+        return Config().get('app.container-name', 'c3-server')
+
     def ls(self, cmd: str, state: ReplState):
         if state.app_pod:
             return self.bash(state, state, cmd.split(' '))
         elif state.app_app:
-            pods = AppPods.pod_names(state.namespace, state.app_env, state.app_app)
-
-            log(lines_to_tabular(pods, 'POD_NAME'))
+            tabulize(self.pod_names(state), header='POD_NAME')
         elif state.app_env:
             def line(n: str, ns: str):
                 host = Ingresses.get_host(Config().get('app.login.ingress', '{app_id}-k8singr-appleader-001').replace('{app_id}', f'{ns}-{n}'), ns)
@@ -59,30 +66,13 @@ class DeviceApp(Command, Device):
 
             svcs = [l for l in [line(n, ns) for n, ns in Apps.apps(state.app_env)] if l]
 
-            log(lines_to_tabular(svcs, 'APP,HOST,ENDPOINT', separator=','))
+            tabulize(svcs, header='APP,HOST,ENDPOINT', separator=',')
         else:
-            svcs = [n for n, ns in Apps.envs()]
-
-            log(lines_to_tabular(svcs, 'ENV', separator=','))
+            tabulize(Apps.envs(), lambda a: a[0], header='ENV', separator=',')
 
     def ls_completion(self, cmd, state, default: dict = {}):
         if state.app_app:
-            def pod_names():
-                return [p for p in AppPods.pod_names(state.namespace, state.app_env, state.app_app)]
-
-            return super().completion(state) | {f'@{p}': {cmd: None} for p in pod_names()}
-
-        return default
-
-    def cat(self, cmd: str, state: ReplState):
-        if state.app_pod:
-            return self.bash(state, state, cmd.split(' '))
-
-        raise InvalidStateException()
-
-    def cat_completion(self, cmd: str, state: ReplState, default: dict = {}):
-        if state.app_app:
-            return {f'@{p}': {cmd: None} for p in AppPods.pod_names(state.namespace, state.app_env, state.app_app)}
+            return super().completion(state) | {f'@{p}': {cmd: None} for p in self.pod_names(state)}
 
         return default
 
@@ -112,7 +102,7 @@ class DeviceApp(Command, Device):
 
     def cd_completion(self, cmd: str, state: ReplState, default: dict = {}):
         if state.app_app:
-            return {cmd: {'..': None} | {pod: None for pod in AppPods.pod_names(state.namespace, state.app_env, state.app_app)}}
+            return {cmd: {'..': None} | {pod: None for pod in self.pod_names(state)}}
         elif state.app_env:
             return {cmd: {'..': None} | {app[0].split('-')[1]: None for app in Apps.apps(state.app_env)}}
         else:
@@ -126,7 +116,7 @@ class DeviceApp(Command, Device):
         if state.app_app:
             words.append(f'app/{state.app_app}')
 
-        return '\t'.join([f'{ReplState.X}:>'] + (words if words else ['/']))
+        return '\t'.join([f'{ReplState.A}:>'] + (words if words else ['/']))
 
     def try_fallback_action(self, chain: Command, state: ReplState, cmd: str):
         if state.app_app:
@@ -144,7 +134,7 @@ class DeviceApp(Command, Device):
                         state.app_app = ea[1]
                         state.app_pod = ea[2]
                         if state.app_pod == '*':
-                            if (pods := AppPods.pod_names(state.namespace, ea[0], ea[1])):
+                            if (pods := self.pod_names(state)):
                                 state.app_pod = pods[0]
                                 wait_log(f'Moving to {state.app_env}/{state.app_app}/{state.app_pod}...')
                             else:
@@ -170,4 +160,4 @@ class DeviceApp(Command, Device):
 
     def bash_completion(self, cmd: str, state: ReplState, default: dict = {}):
         return {cmd: BashCompleter(lambda: [])} | \
-               {f'@{p}': {cmd: BashCompleter(lambda: [])} for p in AppPods.pod_names(state.namespace, state.app_env, state.app_app)}
+               {f'@{p}': {cmd: BashCompleter(lambda: [])} for p in self.pod_names(state)}

adam/commands/devices/device_auit_log.py

@@ -1,7 +1,7 @@
 from adam.commands.command import Command
 from adam.commands.devices.device import Device
 from adam.repl_state import ReplState
-from adam.utils import lines_to_tabular, log
+from adam.utils import tabulize, log
 from adam.utils_athena import Athena
 
 class DeviceAuditLog(Command, Device):
@@ -34,7 +34,7 @@ class DeviceAuditLog(Command, Device):
         return f'{DeviceAuditLog.COMMAND}\t move to Audit Log Operations device'
 
     def ls(self, cmd: str, _: ReplState):
-        log(lines_to_tabular(Athena.table_names(), 'NAME', separator=','))
+        tabulize(Athena.table_names(), header='NAME', separator=',')
 
     def pwd(self, _: ReplState):
         return '\t'.join([f'{ReplState.L}:>', '/'])
@@ -43,7 +43,7 @@ class DeviceAuditLog(Command, Device):
         return True, chain.run(f'audit {cmd}', state)
 
     def show_tables(self, _: ReplState):
-        log(lines_to_tabular(Athena.table_names(), separator=','))
+        tabulize(Athena.table_names(), separator=',')
 
     def show_table_preview(self, _: ReplState, table: str, rows: int):
         Athena.run_query(f'select * from {table} limit {rows}')

adam/commands/devices/device_cass.py

@@ -5,7 +5,7 @@ from adam.commands.cql.utils_cql import cassandra, cassandra_table_names
 from adam.commands.devices.device import Device
 from adam.config import Config
 from adam.repl_state import ReplState
-from adam.utils import lines_to_tabular, log, log2, wait_log
+from adam.utils import tabulize, log, log2, wait_log
 from adam.utils_k8s.cassandra_clusters import CassandraClusters
 from adam.utils_k8s.custom_resources import CustomResources
 from adam.utils_k8s.kube_context import KubeContext
@@ -34,12 +34,21 @@ class DeviceCass(Command, Device):
 
         return state
 
+    def pod(self, state: ReplState) -> str:
+        return state.pod
+
+    def pod_names(self, state: ReplState) -> list[str]:
+        return StatefulSets.pod_names(state.sts, state.namespace)
+
     def completion(self, state: ReplState):
         return super().completion(state)
 
     def help(self, _: ReplState):
         return f'{DeviceCass.COMMAND}\t move to Cassandra Operations device'
 
+    def default_container(self, _: ReplState) -> str:
+        return 'cassandra'
+
     def ls(self, cmd: str, state: ReplState):
         if state.pod:
             return self.bash(state, state, cmd.split(' '))
@@ -50,26 +59,11 @@ class DeviceCass(Command, Device):
             self.show_statefulsets()
 
     def ls_completion(self, cmd: str, state: ReplState, default: dict = {}):
-        def pod_names():
-            return [p for p in StatefulSets.pod_names(state.sts, state.namespace)]
-
         if state.sts:
-            return super().completion(state) | {f'@{p}': {'ls': None} for p in pod_names()}
+            return super().completion(state) | {f'@{p}': {'ls': None} for p in self.pod_names(state)}
         else:
             return {cmd: {n: None for n in StatefulSets.list_sts_names()}}
 
-    def cat(self, cmd: str, state: ReplState):
-        if state.pod:
-            return self.bash(state, state, cmd.split(' '))
-
-        raise InvalidStateException()
-
-    def cat_completion(self, cmd: str, state: ReplState, default: dict = {}):
-        if state.sts:
-            return {f'@{p}': {cmd: None} for p in StatefulSets.pod_names(state.sts, state.namespace)}
-
-        return default
-
     def show_statefulsets(self):
         ss = StatefulSets.list_sts_names()
         if len(ss) == 0:
@@ -88,7 +82,7 @@ class DeviceCass(Command, Device):
         header = 'STATEFULSET_NAME@NAMESPACE APP_ID'
         if KubeContext.in_cluster_namespace():
             header = 'STATEFULSET_NAME APP_ID'
-        log(lines_to_tabular(list, header))
+        tabulize(list, header=header)
 
     def cd(self, dir: str, state: ReplState):
         if dir == '':
@@ -110,7 +104,7 @@ class DeviceCass(Command, Device):
                 if p:
                     state.pod = p
                 else:
-                    names = CassandraClusters.pod_names_by_host_id(state.sts, state.namespace);
+                    names = CassandraClusters.pod_names_by_host_id(state.sts, state.namespace)
                     if dir in names:
                         state.pod = names[dir]
                     else:
@@ -120,7 +114,7 @@ class DeviceCass(Command, Device):
         if state.pod:
             return {cmd: {'..': None}}
         elif state.sts:
-            return {cmd: {'..': None} | {p: None for p in StatefulSets.pod_names(state.sts, state.namespace)}}
+            return {cmd: {'..': None} | {p: None for p in self.pod_names(state)}}
         else:
             return {cmd: {p: None for p in StatefulSets.list_sts_names()}}
 
@@ -158,7 +152,7 @@ class DeviceCass(Command, Device):
                     wait_log(f'Moving to the only Cassandra cluster: {state.sts}@{state.namespace}...')
 
     def show_tables(self, state: ReplState):
-        log(lines_to_tabular(cassandra_table_names(state), separator=','))
+        tabulize(cassandra_table_names(state), separator=',')
 
     def show_table_preview(self, state: ReplState, table: str, rows: int):
         with cassandra(state) as pods:
@@ -179,7 +173,7 @@ class DeviceCass(Command, Device):
         completions = {cmd: BashCompleter(lambda: [])}
 
         if state.sts and state.namespace:
-            completions |= {f'@{p}': {cmd: BashCompleter(lambda: [])} for p in StatefulSets.pod_names(state.sts, state.namespace)}
+            completions |= {f'@{p}': {cmd: BashCompleter(lambda: [])} for p in self.pod_names(state)}
 
         return completions
 

adam/commands/devices/device_export.py

@@ -3,7 +3,7 @@ from adam.commands.devices.device import Device
 from adam.commands.export.export_databases import ExportDatabases, export_db
 from adam.config import Config
 from adam.repl_state import ReplState
-from adam.utils import lines_to_tabular, log, log2, wait_log
+from adam.utils import tabulize, log2, wait_log
 
 class DeviceExport(Command, Device):
     COMMAND = f'{ReplState.X}:'
@@ -36,7 +36,7 @@ class DeviceExport(Command, Device):
 
     def ls(self, cmd: str, state: ReplState):
         if state.export_session:
-            log(lines_to_tabular(ExportDatabases.table_names(state.export_session), 'NAME', separator=','))
+            tabulize(ExportDatabases.table_names(state.export_session), header='NAME', separator=',')
         else:
             ExportDatabases.show_databases()
 
@@ -66,7 +66,10 @@ class DeviceExport(Command, Device):
         return '\t'.join([f'{ReplState.X}:>'] + (words if words else ['/']))
 
     def try_fallback_action(self, chain: Command, state: ReplState, cmd: str):
-        result = chain.run(f'.{cmd}', state)
+        if cmd.startswith('select '):
+            cmd = f'xelect {cmd[7:]}'
+
+        result = chain.run(cmd, state)
         if type(result) is ReplState:
             if state.export_session and not result.export_session:
                 state.export_session = None

adam/commands/devices/device_postgres.py

@@ -1,11 +1,10 @@
 from adam.commands.bash.bash_completer import BashCompleter
-from adam.commands.command import Command, InvalidStateException
+from adam.commands.command import Command
 from adam.commands.devices.device import Device
-from adam.commands.postgres.postgres_context import PostgresContext
+from adam.commands.postgres.postgres_databases import PostgresDatabases, pg_path
 from adam.commands.postgres.utils_postgres import pg_database_names, pg_table_names, postgres
 from adam.repl_state import ReplState
-from adam.utils import lines_to_tabular, log, log2, wait_log
-from adam.utils_k8s.pods import Pods
+from adam.utils import tabulize, log2, wait_log
 
 class DevicePostgres(Command, Device):
     COMMAND = f'{ReplState.P}:'
@@ -36,79 +35,98 @@ class DevicePostgres(Command, Device):
     def help(self, _: ReplState):
         return f'{DevicePostgres.COMMAND}\t move to Postgres Operations device'
 
-    def ls(self, cmd: str, state: ReplState):
-        if state.pg_path:
-            pg: PostgresContext = PostgresContext.apply(state.namespace, state.pg_path)
-            if pg.db:
-                self.show_pg_tables(pg)
-            else:
-                self.show_pg_databases(pg)
-        else:
-            self.show_pg_hosts(state)
+    def pod(self, state: ReplState) -> str:
+        pod, _ = PostgresDatabases.pod_and_container(state.namespace)
+        return pod
 
-    def cat(self, cmd: str, state: ReplState):
-        if state.pod:
-            return self.bash(state, state, cmd.split(' '))
+    def pod_names(self, state: ReplState) -> list[str]:
+        return [self.pod(state)]
 
-        raise InvalidStateException()
+    def default_container(self, state: ReplState) -> str:
+        _, container = PostgresDatabases.pod_and_container(state.namespace)
+        return container
+
+    def ls(self, cmd: str, state: ReplState):
+        if state.pod_targetted:
+            self.bash(state, state, ['ls'])
+            return
+
+        with pg_path(state) as (host, database):
+            if database:
+                tabulize(pg_table_names(state), header='NAME', separator=',')
+            elif host:
+                tabulize(pg_database_names(state), header='DATABASE', separator=',')
+            else:
+                self.show_pg_hosts(state)
 
     def show_pg_hosts(self, state: ReplState):
         if state.namespace:
-            def line(pg: PostgresContext):
-                return f'{pg.path()},{pg.endpoint()}:{pg.port()},{pg.username()},{pg.password()}'
-
-            lines = [line(PostgresContext.apply(state.namespace, pg)) for pg in PostgresContext.hosts(state.namespace)]
-
-            log(lines_to_tabular(lines, 'NAME,ENDPOINT,USERNAME,PASSWORD', separator=','))
+            tabulize(PostgresDatabases.hosts(state),
+                     lambda p: f'{p.host},{p.endpoint()}:{p.port()},{p.username()},{p.password()}',
+                     header='NAME,ENDPOINT,USERNAME,PASSWORD',
+                     separator=',')
         else:
-            def line(pg: PostgresContext):
-                return f'{pg.path()},{pg.namespace},{pg.endpoint()}:{pg.port()},{pg.username()},{pg.password()}'
-
-            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: PostgresContext):
-        log(lines_to_tabular(pg_database_names(pg.namespace, pg.path()), 'DATABASE', separator=','))
-
-    def show_pg_tables(self, pg: PostgresContext):
-        log(lines_to_tabular(pg_table_names(pg.namespace, pg.path()), 'NAME', separator=','))
+            tabulize(PostgresDatabases.hosts(state),
+                     lambda p: f'{p.host},{p.namespace},{p.endpoint()}:{p.port()},{p.username()},{p.password()}',
+                     header='NAME,NAMESPACE,ENDPOINT,USERNAME,PASSWORD',
+                     separator=',')
 
     def cd(self, dir: str, state: ReplState):
         if dir == '':
             state.pg_path = None
-        else:
-            context: PostgresContext = PostgresContext.apply(state.namespace, state.pg_path, arg=dir)
-            # patch up state.namespace from pg cd
-            if not state.namespace and context.namespace:
-                state.namespace = context.namespace
-            state.pg_path = context.path()
+            return
+
+        with pg_path(state) as (host, database):
+            if dir == '..':
+                if database:
+                    database = None
+                else:
+                    host = None
+            else:
+                tks = dir.split('@')
+                if not host:
+                    host = tks[0]
+                else:
+                    database = tks[0]
+
+                if len(tks) > 1:
+                    state.namespace = tks[1]
+
+            if database:
+                state.pg_path = f'{host}/{database}'
+            else:
+                state.pg_path = host
 
     def cd_completion(self, cmd: str, state: ReplState, default: dict = {}):
-        pg: PostgresContext = PostgresContext.apply(state.namespace, state.pg_path) if state.pg_path else None
-        if pg and pg.db:
-            return {cmd: {'..': None}}
-        elif pg and pg.host:
-            return {cmd: {'..': None} | {p: None for p in pg_database_names(state.namespace, pg.path())}}
-        else:
-            return {cmd: {p: None for p in PostgresContext.hosts(state.namespace)}}
+        return {cmd: {d: None for d in self.direct_dirs(cmd, state, default=default)}}
+
+    def direct_dirs(self, cmd: str, state: ReplState, default: dict = {}) -> list[str]:
+        with pg_path(state) as (host, database):
+            if database:
+                return ['..']
+            elif host:
+                return ['..'] + [p for p in pg_database_names(state)]
+            else:
+                return [p for p in PostgresDatabases.host_names(state.namespace)]
 
     def pwd(self, state: ReplState):
         words = []
 
-        pg: PostgresContext = PostgresContext.apply(state.namespace, state.pg_path)
+        with pg_path(state) as (host, database):
+            if host:
+                words.append(f'host/{host}')
+            if database:
+                words.append(f'database/{database}')
 
-        if pg.host:
-            words.append(f'host/{pg.host}')
-        if pg.db:
-            words.append(f'database/{pg.db}')
-
-        return '\t'.join([f'{ReplState.P}:>'] + (words if words else ['/']))
+            return '\t'.join([f'{ReplState.P}:>'] + (words if words else ['/']))
 
     def try_fallback_action(self, chain: Command, state: ReplState, cmd: str):
-        pg: PostgresContext = PostgresContext.apply(state.namespace, state.pg_path)
-        if pg.db:
-            return True, chain.run(f'pg {cmd}', state)
+        with pg_path(state) as (_, database):
+            if not database:
+                database = PostgresDatabases.default_db()
+
+            if database:
+                return True, chain.run(f'pg {cmd}', state)
 
         return False, None
 
@@ -116,15 +134,13 @@ class DevicePostgres(Command, Device):
         wait_log('Inspecting postgres database instances...')
 
     def show_tables(self, state: ReplState):
-        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=','))
+        tabulize(PostgresDatabases.tables(state, default_schema=True), lambda d: d['name'], separator=',')
 
     def show_table_preview(self, state: ReplState, table: str, rows: int):
-        PostgresContext.apply(state.namespace, state.pg_path).run_sql(f'select * from {table} limit {rows}')
+        PostgresDatabases.run_sql(state, f'select * from {table} limit {rows}')
 
     def bash(self, s0: ReplState, s1: ReplState, args: list[str]):
-        pod, container = PostgresContext.pod_and_container(s1.namespace)
+        pod, container = PostgresDatabases.pod_and_container(s1.namespace)
         log2(f'Running on {pod}(container:{container})...')
 
         return super().bash(s0, s1, args)

adam/commands/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.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.device(state).pod(state),
+                                             Devices.device(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.device(state).files(state)}, pods=Devices.device(state).pods(state, '-'), auto='jit')
+
+    def help(self, _: ReplState):
+        return f'{DownloadFile.COMMAND} from-file [to-file]\t download file from pod'

adam/commands/export/clean_up_all_export_sessions.py

@@ -1,5 +1,5 @@
 from adam.commands.command import Command
-from adam.commands.export.export_sessions import ExportSessions
+from adam.commands.export.export_sessions import export_session
 from adam.repl_state import ReplState, RequiredState
 
 class CleanUpAllExportSessions(Command):
@@ -25,8 +25,8 @@ class CleanUpAllExportSessions(Command):
             return super().run(cmd, state)
 
         with self.validate(args, state) as (args, state):
-            if ExportSessions.clean_up_all_sessions(state.sts, state.pod, state.namespace):
-                ExportSessions.clear_export_session_cache()
+            with export_session(state) as sessions:
+                sessions.clean_up_all()
 
             return state
 

adam/commands/export/clean_up_export_sessions.py

@@ -1,9 +1,7 @@
 from adam.commands import validate_args
 from adam.commands.command import Command
-from adam.commands.export.export_sessions import ExportSessions
-from adam.commands.export.exporter import Exporter
+from adam.commands.export.export_sessions import export_session
 from adam.repl_state import ReplState, RequiredState
-from adam.utils import log, log2
 
 class CleanUpExportSessions(Command):
     COMMAND = 'clean up export sessions'
@@ -28,12 +26,9 @@ class CleanUpExportSessions(Command):
             return super().run(cmd, state)
 
         with self.validate(args, state) as (args, state):
-            with validate_args(args, state, name='export session') as arg_str:
-                sessions = [arg.strip(' ') for arg in arg_str.split(',')]
-                csv_cnt, log_cnt = ExportSessions.clean_up_sessions(state.sts, state.pod, state.namespace, sessions)
-                log(f'Removed {csv_cnt} csv and {log_cnt} log files.')
-
-                ExportSessions.clear_export_session_cache()
+            with validate_args(args, state, name='export session', separator=',') as session_names:
+                with export_session(state) as sessions:
+                    sessions.clean_up(session_names)
 
                 return state
 
@@ -41,4 +36,4 @@ class CleanUpExportSessions(Command):
         return {}
 
     def help(self, _: ReplState):
-        return f'{CleanUpExportSessions.COMMAND} <export-session-name>\t clean up export session'
+        return f'{CleanUpExportSessions.COMMAND} <export-session-name,...>\t clean up export sessions'

adam/commands/export/completions_x.py

@@ -0,0 +1,11 @@
+from adam.commands.export.export_databases import ExportDatabases
+from adam.repl_state import ReplState
+from adam.sql.lark_completer import LarkCompleter
+from adam.utils_athena import Athena
+
+def completions_x(state: ReplState):
+    return LarkCompleter(expandables={
+        'tables': lambda x: ExportDatabases.table_names(state.export_session),
+        'export-databases': lambda x: ExportDatabases.database_names(),
+        'columns': lambda x: Athena.column_names(database=state.export_session, function='export'),
+    }, variant=ReplState.X).completions_for_nesting()

adam/commands/export/download_export_session.py

@@ -0,0 +1,40 @@
+from adam.commands import validate_args
+from adam.commands.command import Command
+from adam.commands.export.export_sessions import ExportSessions, export_session
+from adam.repl_state import ReplState, RequiredState
+
+class DownloadExportSession(Command):
+    COMMAND = 'download export session'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(DownloadExportSession, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return DownloadExportSession.COMMAND
+
+    def required(self):
+        return RequiredState.CLUSTER_OR_POD
+
+    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='export session') as session:
+                with export_session(state) as sessions:
+                    sessions.download_session(session)
+
+            return state
+
+    def completion(self, state: ReplState):
+        return {}
+        # return super().completion(state, {session: None for session in ExportSessions.export_session_names(state.sts, state.pod, state.namespace, export_state='pending_import')})
+
+    def help(self, _: ReplState):
+        return f'{DownloadExportSession.COMMAND} <export-session-name>\t download csv files in export session'

adam/commands/export/export.py

@@ -1,12 +1,7 @@
 from adam.commands import extract_options
 from adam.commands.command import Command
-from adam.commands.cql.utils_cql import cassandra_keyspaces, cassandra_table_names
-from adam.commands.export.export_databases import ExportDatabases
 from adam.commands.export.exporter import export
 from adam.repl_state import ReplState, RequiredState
-from adam.sql.sql_completer import SqlCompleter, SqlVariant
-from adam.utils import log
-from adam.utils_k8s.statefulsets import StatefulSets
 
 class ExportTables(Command):
     COMMAND = 'export'
@@ -36,17 +31,6 @@ class ExportTables(Command):
                     return exporter.export(args, export_only=export_only)
 
     def completion(self, state: ReplState):
-        def sc():
-            return SqlCompleter(lambda: cassandra_table_names(state), expandables={
-                'dml':'export',
-                'columns': lambda table: ['id', '*'],
-                'keyspaces': lambda: cassandra_keyspaces(state),
-                'export-dbs': lambda: ExportDatabases.database_names(),
-            }, variant=SqlVariant.CQL)
-
-        if super().completion(state):
-            return {f'@{p}': {ExportTables.COMMAND: sc()} for p in StatefulSets.pod_names(state.sts, state.namespace)}
-
         return {}
 
     def help(self, _: ReplState):