kaqing 2.0.14__py3-none-any.whl → 2.0.189__py3-none-any.whl

adam/commands/export/export_sessions.py

@@ -0,0 +1,209 @@
+import functools
+import os
+import re
+
+from adam.commands.export.importer import Importer
+from adam.commands.export.utils_export import ExportTableStatus, csv_dir, find_files
+from adam.config import Config
+from adam.repl_state import ReplState
+from adam.utils import log2, tabulize, log, parallelize
+from adam.utils_k8s.cassandra_nodes import CassandraNodes
+from adam.utils_k8s.pods import Pods, log_prefix
+from adam.utils_k8s.statefulsets import StatefulSets
+from adam.utils_local import local_tmp_dir
+
+class ExportSessions:
+    def clear_export_session_cache():
+        ExportSessions.find_export_sessions.cache_clear()
+        ExportSessions.export_session_names.cache_clear()
+
+    @functools.lru_cache()
+    def export_session_names(sts: str, pod: str, namespace: str, importer: str = None, export_state = None):
+        if not sts or not namespace:
+            return []
+
+        if not pod:
+            pod = StatefulSets.pod_names(sts, namespace)[0]
+
+        if not pod:
+            return []
+
+        return [session for session, state in ExportSessions.find_export_sessions(pod, namespace, importer).items() if not export_state or state == export_state]
+
+    @functools.lru_cache()
+    def find_export_sessions(pod: str, namespace: str, importer: str = None, limit = 100):
+        sessions: dict[str, str] = {}
+
+        prefix = Importer.prefix_from_importer(importer)
+
+        log_files: list[str] = find_files(pod, namespace, f'{log_prefix()}-{prefix}*_*.log*')
+
+        if not log_files:
+            return {}
+
+        for log_file in log_files[:limit]:
+            m = re.match(f'{log_prefix()}-(.*?)_.*\.log?(.*)', log_file)
+            if m:
+                s = m.group(1)
+                state = m.group(2) # '', '.pending_import', '.done'
+                if state:
+                    state = state.strip('.')
+                else:
+                    state = 'in_export'
+
+                if s not in sessions:
+                    sessions[s] = state
+                elif sessions[s] == 'done' and state != 'done':
+                    sessions[s] = state
+
+        return sessions
+
+    def clean_up_all_sessions(sts: str, pod: str, namespace: str):
+        if not sts or not namespace:
+            return False
+
+        if not pod:
+            pod = StatefulSets.pod_names(sts, namespace)[0]
+
+        CassandraNodes.exec(pod, namespace, f'rm -rf {csv_dir()}/*', show_out=Config().is_debug(), shell='bash')
+        CassandraNodes.exec(pod, namespace, f'rm -rf {log_prefix()}-*.log*', show_out=Config().is_debug(), shell='bash')
+
+        return True
+
+    def clean_up_sessions(sts: str, pod: str, namespace: str, sessions: list[str], max_workers = 0):
+        if not sessions:
+            return []
+
+        if not max_workers:
+            max_workers = Config().action_workers('export', 8)
+
+        with parallelize(sessions,
+                         max_workers,
+                         msg='Cleaning|Cleaned up {size} export sessions') as exec:
+            cnt_tuples = exec.map(lambda session: ExportSessions.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:
+            return 0, 0
+
+        if not pod:
+            pod = StatefulSets.pod_names(sts, namespace)[0]
+
+        if not pod:
+            return 0, 0
+
+        csv_cnt = 0
+        log_cnt = 0
+
+        log_files: list[str] = find_files(pod, namespace, f'{log_prefix()}-{session}_*.log*')
+
+        for log_file in log_files:
+            m = re.match(f'{log_prefix()}-{session}_(.*?)\.(.*?)\.log.*', log_file)
+            if m:
+                table = m.group(2)
+
+                CassandraNodes.exec(pod, namespace, f'rm -rf {csv_dir()}/{session}_{table}', show_out=not multi_tables, shell='bash')
+                csv_cnt += 1
+
+                CassandraNodes.exec(pod, namespace, f'rm -rf {log_file}', show_out=not multi_tables, shell='bash')
+                log_cnt += 1
+
+        return csv_cnt, log_cnt
+
+    def show_session(sts: str, pod: str, namespace: str, session: str):
+        if not pod:
+            pod = StatefulSets.pod_names(sts, namespace)[0]
+
+        if not pod:
+            return
+
+        tables, _ = ExportTableStatus.from_session(sts, pod, namespace, session)
+        log()
+        tabulize(tables,
+                 lambda t: f'{t.keyspace}\t{t.target_table}\t{"export_completed_pending_import" if t.status == "pending_import" else t.status}\t{t.csv_file}',
+                 header='KEYSPACE\tTARGET_TABLE\tSTATUS\tCSV_FILES',
+                 separator='\t')
+
+    def download_session(sts: str, pod: str, namespace: str, session: str):
+        if not pod:
+            pod = StatefulSets.pod_names(sts, namespace)[0]
+
+        if not pod:
+            return
+
+        tables, _ = ExportTableStatus.from_session(sts, pod, namespace, session)
+        def download_csv(table):
+            from_path: str = table.csv_file
+
+            to_path = from_path.replace(csv_dir(), local_tmp_dir())
+            os.makedirs(os.path.dirname(to_path), exist_ok=True)
+            Pods.download_file(pod, 'cassandra', namespace, from_path, to_path)
+
+            log2(f'[{session}] Downloaded to {to_path}.')
+
+        with parallelize(tables,
+                         workers=Config().get('download.workers', 8),
+                         msg='Downloading|Downloaded {size} csv files') as exec:
+            exec.map(download_csv)
+
+class ExportSessionService:
+    def __init__(self, handler: 'ExportSessionHandler'):
+        self.handler = handler
+
+    def clean_up(self, sessions: list[str]):
+        state = self.handler.state
+
+        csv_cnt, log_cnt = ExportSessions.clean_up_sessions(state.sts, self.pod(), state.namespace, sessions)
+
+        log(f'Removed {csv_cnt} csv and {log_cnt} log files.')
+
+        ExportSessions.clear_export_session_cache()
+
+    def clean_up_all(self):
+        state = self.handler.state
+
+        if ExportSessions.clean_up_all_sessions(state.sts, self.pod(), state.namespace):
+            ExportSessions.clear_export_session_cache()
+
+    def show_all_sessions(self):
+        state = self.handler.state
+
+        sessions = sorted(ExportSessions.find_export_sessions(self.pod(), state.namespace).items(), reverse=True)
+        tabulize(sessions, lambda args: f'{args[0]}\t{args[1]}', header='EXPORT_SESSION\tSTATUS', separator='\t')
+
+    def show_session(self, session: str):
+        state = self.handler.state
+        ExportSessions.show_session(state.sts, self.pod(), state.namespace, session)
+
+    def download_session(self, session: str):
+        state = self.handler.state
+        ExportSessions.download_session(state.sts, self.pod(), state.namespace, session)
+
+    def pod(self):
+        state = self.handler.state
+
+        pod = state.pod
+        if not pod:
+            pod = StatefulSets.pod_names(state.sts, state.namespace)[0]
+
+        return pod
+
+class ExportSessionHandler:
+    def __init__(self, state: ReplState = None):
+        self.state = state
+
+    def __enter__(self):
+        return ExportSessionService(self)
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return False
+
+def export_session(state: ReplState = None):
+    return ExportSessionHandler(state)

adam/commands/export/export_use.py

@@ -0,0 +1,49 @@
+from adam.commands import validate_args
+from adam.commands.command import Command
+from adam.commands.export.export_databases import export_db
+from adam.repl_state import ReplState
+from adam.utils import log2
+
+class ExportUse(Command):
+    COMMAND = 'use'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(ExportUse, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return ExportUse.COMMAND
+
+    def required(self):
+        return [ReplState.C]
+
+    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, at_least=0) as session:
+                if not session:
+                    state.export_session = None
+
+                    log2('Export database is unset.')
+
+                    return state
+
+                state.export_session = session
+
+                with export_db(state) as dbs:
+                    dbs.show_database()
+
+                return state
+
+    def completion(self, state: ReplState):
+        return {}
+
+    def help(self, _: ReplState):
+        return f'{ExportUse.COMMAND} <export-database-name>\t use export database'

adam/commands/export/export_x_select.py

@@ -0,0 +1,48 @@
+from adam.commands import extract_trailing_options, validate_args
+from adam.commands.command import Command
+from adam.commands.export.completions_x import completions_x
+from adam.commands.export.export_databases import export_db
+from adam.repl_state import ReplState, RequiredState
+
+class ExportXSelect(Command):
+    COMMAND = 'xelect'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(ExportXSelect, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return ExportXSelect.COMMAND
+
+    def required(self):
+        return RequiredState.EXPORT_DB
+
+    def run(self, cmd: str, state: ReplState):
+        if not(args := self.args(cmd)):
+            return super().run(cmd, state)
+
+        with self.validate(args, state) as (args, state):
+            with extract_trailing_options(args, '&') as (args, backgrounded):
+                with validate_args(args, state, name='SQL statement') as query:
+                    with export_db(state) as dbs:
+                        dbs.sql(f'select {query}', backgrounded=backgrounded)
+
+                    return state
+
+    def completion(self, state: ReplState):
+        if state.device != ReplState.C:
+            return {}
+
+        if not state.export_session:
+            return {}
+
+        # add only xelect completions to c: drive from lark
+        return {ExportXSelect.COMMAND: completions_x(state)[ExportXSelect.COMMAND]}
+
+    def help(self, _: ReplState):
+        return f'xelect...\t run queries on export database'

adam/commands/export/exporter.py

@@ -0,0 +1,332 @@
+from datetime import datetime
+import time
+
+from adam.commands.command import InvalidArgumentsException
+from adam.commands.cql.utils_cql import cassandra_table_names, run_cql, table_spec
+from adam.commands.export.export_databases import export_db
+from adam.commands.export.export_sessions import ExportSessions
+from adam.commands.export.importer import Importer
+from adam.commands.export.importer_athena import AthenaImporter
+from adam.commands.export.importer_sqlite import SqliteImporter
+from adam.commands.export.utils_export import ExportSpec, ExportTableStatus, ExportTableSpec, ImportSpec, csv_dir, find_files, state_with_pod
+from adam.config import Config
+from adam.pod_exec_result import PodExecResult
+from adam.repl_state import ReplState
+from adam.utils import debug, log, parallelize, log2, ing, log_exc
+from adam.utils_k8s.cassandra_nodes import CassandraNodes
+from adam.utils_k8s.pods import log_prefix
+
+class Exporter:
+    def export_tables(args: list[str], state: ReplState, export_only: bool = False, max_workers = 0) -> tuple[list[str], ExportSpec]:
+        if export_only:
+            log2('export-only for testing')
+
+        spec: ExportSpec = None
+        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')
+            if not statuses:
+                return statuses, spec
+
+            return Exporter._export_tables(spec, state, export_only, max_workers, 'pending_export')
+
+        return [], None
+
+    def export_spec(spec_str: str, state: ReplState):
+        spec: ExportSpec = ExportSpec.parse_specs(spec_str)
+
+        session = state.export_session
+        if session:
+            if spec.importer:
+                importer_from_session = Importer.importer_from_session(session)
+                if spec.importer != importer_from_session:
+                    if spec.importer == 'csv':
+                        prefix = Importer.prefix_from_importer(spec.importer)
+                        session = f'{prefix}{session[1:]}'
+                    else:
+                        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
+
+        spec.session = session
+
+        return spec
+
+    def import_session(spec_str: str, state: ReplState, max_workers = 0) -> tuple[list[str], ExportSpec]:
+        import_spec: ImportSpec = None
+        with log_exc(True):
+            import_spec = Exporter.import_spec(spec_str, state)
+            tables, status_in_whole = ExportTableStatus.from_session(state.sts, state.pod, state.namespace, import_spec.session)
+            if status_in_whole == 'done':
+                log2(f'The session has been completely done - no more csv files are found.')
+                return [], ExportSpec(None, None, importer=import_spec.importer, tables=[])
+
+            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, export_state = 'import')
+
+        return [], None
+
+    def import_local_csv_files(spec_str: str, state: ReplState, max_workers = 0) -> tuple[list[str], ExportSpec]:
+        spec: ImportSpec = None
+        with log_exc(True):
+            spec = Exporter.import_spec(spec_str, state, files=True)
+            if not spec.table_name:
+                log2(f"Use 'as <database-name>.<table-name>'.")
+                raise InvalidArgumentsException()
+
+            d_t = spec.table_name.split('.')
+            if len(d_t) != 2:
+                log2(f'Need <database-name>.<table-name> format for target table.')
+                raise InvalidArgumentsException()
+
+            database = d_t[0]
+            table = d_t[1]
+            im = AthenaImporter() if spec.importer == 'athena' else SqliteImporter()
+
+            with parallelize(spec.files, max_workers, msg='Importing|Imported {size} csv files') as exec:
+                return exec.map(lambda f: im.import_from_local_csv(state, database, table, f, len(spec.files) > 1, True)), spec
+
+        return [], None
+
+    def import_spec(spec_str: str, state: ReplState, files = False):
+        spec: ImportSpec = ImportSpec.parse_specs(spec_str, files=files)
+
+        session = state.export_session
+        if session:
+            if spec.importer:
+                importer = Importer.importer_from_session(state.export_session)
+                if spec.importer != importer:
+                    raise Exception(f"You're currently using {importer} export database. You cannot import to {spec.importer} type database.")
+            else:
+                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 not spec.importer:
+                spec.importer = Importer.importer_from_session(spec.session)
+
+            if not spec.importer or 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)
+            if spec.session:
+                spec.session = f'{prefix}{spec.session[1:]}'
+            else:
+                spec.session = f'{prefix}{datetime.now().strftime("%Y%m%d%H%M%S")[3:]}'
+
+            state.export_session = spec.session
+
+        return spec
+
+    def _export_tables(spec: ExportSpec, state: ReplState, export_only = False, max_workers = 0, export_state = None) -> tuple[list[str], ExportSpec]:
+        if not spec.keyspace:
+            spec.keyspace = f'{state.namespace}_db'
+
+        if not spec.tables:
+            spec.tables = [ExportTableSpec.parse(t) for t in cassandra_table_names(state, keyspace=spec.keyspace)]
+
+        if not max_workers:
+            max_workers = Config().action_workers(f'export.{spec.importer}', 8)
+
+        if export_state == 'init':
+            CassandraNodes.exec(state.pod, state.namespace, f'rm -rf {csv_dir()}/{spec.session}_*', show_out=Config().is_debug(), shell='bash')
+
+        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
+
+        table, target_table, columns = Exporter.resove_table_n_columns(spec, state, include_ks_in_target=False, importer=importer)
+
+        log_file = f'{log_prefix()}-{session}_{spec.keyspace}.{target_table}.log'
+        create_db = not state.export_session
+
+        if export_state == 'init':
+            Exporter.create_table_log(spec, state, session, table, target_table)
+            return 'table_log_created'
+        else:
+            if export_state == 'pending_export':
+                Exporter.export_to_csv(spec, state, session, table, target_table, columns, multi_tables=multi_tables, consistency=consistency)
+
+            log_files: list[str] = find_files(state.pod, state.namespace, f'{log_file}*')
+            if not log_files:
+                return s
+
+            log_file = log_files[0]
+
+            status: ExportTableStatus = ExportTableStatus.from_log_file(state.pod, state.namespace, session, log_file)
+            while status.status != 'done':
+                if status.status == 'export_in_pregress':
+                    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)
+                    if importer == 'csv' or export_only:
+                        return 'pending_import'
+                elif status.status == 'pending_import':
+                    log_file, session = Exporter.import_from_csv(spec, state, session, importer, table, target_table, columns, multi_tables=multi_tables, create_db=create_db)
+
+                status = ExportTableStatus.from_log_file(state.pod, state.namespace, session, log_file)
+
+            return status.status
+
+    def create_table_log(spec: ExportTableSpec, state: ReplState, session: str, table: str, target_table: str):
+        log_file = f'{log_prefix()}-{session}_{spec.keyspace}.{target_table}.log'
+
+        CassandraNodes.exec(state.pod, state.namespace, f'rm -f {log_file}* && touch {log_file}', show_out=Config().is_debug(), shell='bash')
+
+        return table
+
+    def export_to_csv(spec: ExportTableSpec, state: ReplState, session: str, table: str, target_table: str, columns: str, multi_tables = True, consistency: str = None):
+        db = f'{session}_{target_table}'
+
+        CassandraNodes.exec(state.pod, state.namespace, f'mkdir -p {csv_dir()}/{db}', show_out=Config().is_debug(), shell='bash')
+        csv_file = f'{csv_dir()}/{db}/{table}.csv'
+        log_file = f'{log_prefix()}-{session}_{spec.keyspace}.{target_table}.log'
+
+        suppress_ing_log = Config().is_debug() or multi_tables
+        queries = []
+        if consistency:
+            queries.append(f'CONSISTENCY {consistency}')
+        queries.append(f"COPY {spec.keyspace}.{table}({columns}) TO '{csv_file}' WITH HEADER = TRUE")
+        r: PodExecResult = ing(
+            f'[{session}] Dumping table {spec.keyspace}.{table}{f" with consistency {consistency}" if consistency else ""}',
+            lambda: run_cql(state, ';'.join(queries), show_out=Config().is_debug(), backgrounded=True, log_file=log_file),
+            suppress_log=suppress_ing_log)
+
+        return log_file
+
+    def rename_to_pending_import(spec: ExportTableSpec, state: ReplState, session: str, target_table: str):
+        log_file = f'{log_prefix()}-{session}_{spec.keyspace}.{target_table}.log'
+        to = f'{log_file}.pending_import'
+
+        CassandraNodes.exec(state.pod, state.namespace, f'mv {log_file} {to}', show_out=Config().is_debug(), shell='bash')
+
+        return to
+
+    def import_from_csv(spec: ExportTableSpec, state: ReplState, session: str, importer: str, table: str, target_table: str, columns: str, multi_tables = True, create_db = False):
+        im = AthenaImporter() if importer == 'athena' else SqliteImporter()
+        return im.import_from_csv(state, session if session else state.export_session, spec.keyspace, table, target_table, columns, multi_tables, create_db)
+
+    def resove_table_n_columns(spec: ExportTableSpec, state: ReplState, include_ks_in_target = False, importer = 'sqlite'):
+        table = spec.table
+        columns = spec.columns
+        if not columns:
+            columns = Config().get(f'export.{importer}.columns', f'<keys>')
+
+        keyspaced_table = f'{spec.keyspace}.{spec.table}'
+        if columns == '<keys>':
+            columns = ','.join(table_spec(state, keyspaced_table, on_any=True).keys())
+        elif columns == '<row-key>':
+            columns = table_spec(state, keyspaced_table, on_any=True).row_key()
+        elif columns == '*':
+            columns = ','.join([c.name for c in table_spec(state, keyspaced_table, on_any=True).columns])
+
+        if not columns:
+            log2(f'ERROR: Empty columns on {table}.')
+            return table, None, None
+
+        target_table = spec.target_table if spec.target_table else table
+        if not include_ks_in_target and '.' in target_table:
+            target_table = target_table.split('.')[-1]
+
+        return table, target_table, columns
+
+class ExportService:
+    def __init__(self, handler: 'ExporterHandler'):
+        self.handler = handler
+
+    def export(self, args: list[str], export_only=False):
+        state = self.handler.state
+        export_session = state.export_session
+        spec: ExportSpec = None
+        try:
+            with state_with_pod(state) as state:
+                # --export-only for testing only
+                statuses, spec = Exporter.export_tables(args, state, export_only=export_only)
+                if not statuses:
+                    return state
+
+                ExportSessions.clear_export_session_cache()
+
+                if spec.importer == 'csv' or export_only:
+                    ExportSessions.show_session(state.sts, state.pod, state.namespace, spec.session)
+                else:
+                    log()
+                    with export_db(state) as dbs:
+                        dbs.show_database()
+        finally:
+            # if exporting to csv, do not bind the new session id to repl state
+            if spec and spec.importer == 'csv':
+                state.export_session = export_session
+
+        return state
+
+    def import_session(self, spec_str: str):
+        state = self.handler.state
+
+        tables, _ = Exporter.import_session(spec_str, state)
+        if tables:
+            ExportSessions.clear_export_session_cache()
+
+            log()
+            with export_db(state) as dbs:
+                dbs.show_database()
+
+        return state
+
+    def import_files(self, spec_str: str):
+        state = self.handler.state
+
+        tables, _ = Exporter.import_local_csv_files(spec_str, state)
+        if tables:
+            ExportSessions.clear_export_session_cache()
+
+            log()
+            with export_db(state) as dbs:
+                dbs.show_database()
+
+        return state
+
+class ExporterHandler:
+    def __init__(self, state: ReplState):
+        self.state = state
+
+    def __enter__(self):
+        return ExportService(self)
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return False
+
+def export(state: ReplState):
+    return ExporterHandler(state)

adam/commands/export/import_files.py

@@ -0,0 +1,44 @@
+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 export
+from adam.commands.export.utils_export import state_with_pod
+from adam.repl_state import ReplState, RequiredState
+
+class ImportCSVFiles(Command):
+    COMMAND = 'import files'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(ImportCSVFiles, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return ImportCSVFiles.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='file') as spec:
+                with state_with_pod(state) as state:
+                    with export(state) as exporter:
+                        return exporter.import_files(spec)
+
+    def completion(self, state: ReplState):
+        # warm up cache
+        # ExportSessions.export_session_names(state.sts, state.pod, state.namespace)
+        # ExportSessions.export_session_names(state.sts, state.pod, state.namespace, export_state='pending_import')
+
+        return {}
+
+    def help(self, _: ReplState):
+        return f'{ImportCSVFiles.COMMAND} <file-names,...>\t import files in session to Athena or SQLite'