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

adam/commands/export/importer_athena.py

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

adam/commands/export/importer_sqlite.py

@@ -1,7 +1,9 @@
 import pandas
 
+from adam.commands.export.export_databases import export_db
 from adam.commands.export.importer import Importer
 from adam.commands.export.utils_export import GeneratorStream
+from adam.repl_state import ReplState
 from adam.utils import log2, ing
 from adam.utils_k8s.pods import Pods
 from adam.utils_sqlite import SQLite, sqlite
@@ -10,30 +12,31 @@ class SqliteImporter(Importer):
     def prefix(self):
         return 's'
 
-    def import_from_csv(self, pod: str, namespace: str, to_session: str, from_session: str, keyspace: str, table: str, target_table: str, columns: str, multi_tables = True, create_db = False):
+    def import_from_csv(self, state: ReplState, from_session: str, keyspace: str, table: str, target_table: str, columns: str, multi_tables = True, create_db = False):
         csv_file = self.csv_file(from_session, table, target_table)
+        pod = state.pod
+        namespace = state.namespace
+        to_session = state.export_session
 
         succeeded = False
-        with sqlite(to_session, keyspace) as conn:
-            try:
-                with ing(f'[{to_session}] Uploading to Sqlite', suppress_log=multi_tables):
+        try:
+            with ing(f'[{to_session}] Uploading to Sqlite', suppress_log=multi_tables):
+                # create a connection to single keyspace
+                with sqlite(to_session, keyspace) as conn:
                     bytes = Pods.read_file(pod, 'cassandra', namespace, csv_file)
                     df = pandas.read_csv(GeneratorStream(bytes))
-
                     df.to_sql(target_table, conn, index=False, if_exists='replace')
 
-                to, _ = self.move_to_done(pod, namespace, to_session, from_session, keyspace, target_table)
+            to, _ = self.move_to_done(state, from_session, keyspace, target_table)
 
-                succeeded = True
+            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(state, from_session, table, target_table, multi_tables)
+                SQLite.clear_cache()
 
-                    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)
+                if not multi_tables:
+                    with export_db(state) as dbms:
+                        dbms.sql(f'select * from {keyspace}.{target_table} limit 10')

adam/commands/export/show_column_counts.py

@@ -1,3 +1,4 @@
+from adam.commands import validate_args
 from adam.commands.command import Command
 from adam.commands.export.export_databases import ExportDatabases
 from adam.config import Config
@@ -27,20 +28,10 @@ class ShowColumnCounts(Command):
             return super().run(cmd, state)
 
         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()
-
-                return 'command-missing'
-
-            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)
+            with validate_args(args, state, name='SQL statement') as table:
+                query = Config().get(f'export.column_counts_query', 'select id, count(id) as columns from {table} group by id')
+                query = query.replace('{table}', table)
+                ExportDatabases.run_query(query, state.export_session)
 
             return state
 

adam/commands/export/show_export_databases.py

@@ -1,5 +1,6 @@
 from adam.commands.command import Command
 from adam.commands.devices.device_export import DeviceExport
+from adam.commands.export.export_databases import ExportDatabases
 from adam.repl_state import ReplState
 
 class ShowExportDatabases(Command):
@@ -25,7 +26,7 @@ class ShowExportDatabases(Command):
             return super().run(cmd, state)
 
         with self.validate(args, state) as (args, state):
-            DeviceExport().show_export_databases()
+            ExportDatabases.show_databases()
 
             return state
 

adam/commands/export/show_export_session.py

@@ -1,6 +1,7 @@
+from adam.commands import validate_args
 from adam.commands.command import Command
 from adam.commands.export.export_databases import ExportDatabases
-from adam.commands.export.exporter import Exporter
+from adam.commands.export.export_sessions import ExportSessions
 from adam.repl_state import ReplState, RequiredState
 from adam.utils import log2
 
@@ -27,22 +28,13 @@ class ShowExportSession(Command):
             return super().run(cmd, state)
 
         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()
-
-                return 'command-missing'
-
-            ExportDatabases.disply_export_session(state.sts, state.pod, state.namespace, args[0])
+            with validate_args(args, state, name='database name'):
+                ExportSessions.disply_export_session(state.sts, state.pod, state.namespace, args[0])
 
             return state
 
     def completion(self, state: ReplState):
-        return super().completion(state, {session: None for session in Exporter.export_session_names(state.sts, state.pod, state.namespace)})
+        return super().completion(state, {session: None for session in ExportSessions.export_session_names(state.sts, state.pod, state.namespace)})
 
     def help(self, _: ReplState):
         return f'{ShowExportSession.COMMAND} <export-session-name>\t show export session'

adam/commands/export/show_export_sessions.py

@@ -1,5 +1,5 @@
 from adam.commands.command import Command
-from adam.commands.export.exporter import Exporter
+from adam.commands.export.export_sessions import ExportSessions
 from adam.repl_state import ReplState, RequiredState
 from adam.utils import lines_to_tabular, log
 from adam.utils_k8s.statefulsets import StatefulSets
@@ -31,7 +31,7 @@ class ShowExportSessions(Command):
             if not pod:
                 pod = StatefulSets.pod_names(state.sts, state.namespace)[0]
 
-            sessions: dict[str, str] = Exporter.find_export_sessions(pod, state.namespace)
+            sessions: dict[str, str] = ExportSessions.find_export_sessions(pod, state.namespace)
             log(lines_to_tabular([f'{session}\t{export_state}' for session, export_state in sorted(sessions.items(), reverse=True)],
                                     header='EXPORT_SESSION\tSTATUS', separator='\t'))
 

adam/commands/export/utils_export.py

@@ -292,9 +292,10 @@ class GeneratorStream(io.RawIOBase):
             self._buffer = self._buffer[size:]
             return data
 
-class PodHandler:
+class PodPushHandler:
     def __init__(self, state: ReplState):
         self.state = state
+        self.pushed = False
 
     def __enter__(self):
         state = self.state
@@ -306,9 +307,10 @@ class PodHandler:
         return state
 
     def __exit__(self, exc_type, exc_val, exc_tb):
-        self.state.pop()
+        if self.pushed:
+            self.state.pop()
 
         return False
 
 def state_with_pod(state: ReplState):
-    return PodHandler(state)
+    return PodPushHandler(state)

adam/commands/medusa/medusa_backup.py

@@ -1,5 +1,4 @@
 from datetime import datetime
-import re
 
 from adam.commands.command import Command
 from adam.utils_k8s.statefulsets import StatefulSets
@@ -36,7 +35,7 @@ class MedusaBackup(Command):
             bkname = 'medusa-' + now_dtformat + 'full-backup-' + sts
             if len(args) == 1:
                 bkname = str(args[0])
-            groups = re.match(r'^(.*?-.*?-).*', sts)
+
             dc = StatefulSets.get_datacenter(state.sts, ns)
             if not dc:
                 return state

adam/commands/medusa/medusa_restore.py

@@ -1,6 +1,9 @@
+from collections.abc import Callable
 from datetime import datetime
+from functools import partial
 
-from adam.commands.command import Command
+from adam.commands import validate_args
+from adam.commands.command import Command, InvalidArgumentsException
 from adam.utils_k8s.statefulsets import StatefulSets
 from adam.repl_state import ReplState, RequiredState
 from adam.utils_k8s.custom_resources import CustomResources
@@ -35,31 +38,30 @@ class MedusaRestore(Command):
             if not dc:
                 return state
 
-            if len(args) == 1:
-                bkname = args[0]
-                job = CustomResources.medusa_get_backupjob(dc, ns, bkname)
-                if not job:
+            def msg(missing: bool):
+                if missing:
+                    log2('\n* Missing Backup Name')
+                    log2('Usage: qing restore <backup> <sts@name_space>\n')
+                else:
                     log2('\n* Backup job name is not valid.')
-                    bklist = [f"{x['metadata']['name']}\t{x['metadata']['creationTimestamp']}\t{x['status'].get('finishTime', '')}" for x in CustomResources.medusa_show_backupjobs(dc, ns)]
-                    log2(lines_to_tabular(bklist, 'NAME\tCREATED\tFINISHED', separator='\t'))
 
-                    return state
+                bklist = [f"{x['metadata']['name']}\t{x['metadata']['creationTimestamp']}\t{x['status'].get('finishTime', '')}" for x in CustomResources.medusa_show_backupjobs(dc, ns)]
+                log2(lines_to_tabular(bklist, 'NAME\tCREATED\tFINISHED', separator='\t'))
+
+            with validate_args(args, state, msg=partial(msg, True)) as bkname:
+                if not (job := CustomResources.medusa_get_backupjob(dc, ns, bkname)):
+                    msg(False)
+                    raise InvalidArgumentsException()
 
                 if not input(f"Restoring from {bkname} created at {job['metadata']['creationTimestamp']}. Please enter Yes to continue: ").lower() in ['y', 'yes']:
                     return state
-            else:
-                bklist = [f"{x['metadata']['name']}\t{x['metadata']['creationTimestamp']}\t{x['status'].get('finishTime', '')}" for x in CustomResources.medusa_show_backupjobs(dc, ns)]
-                log2('\n* Missing Backup Name')
-                log2('Usage: qing medusa restore <backup> <sts@name_space>\n')
-                log2(lines_to_tabular(bklist, 'NAME\tCREATED\tFINISHED', separator='\t'))
-                return state
 
-            now_dtformat = datetime.now().strftime("%Y-%m-%d.%H.%M.%S")
-            rtname = 'medusa-' + now_dtformat + '-restore-from-' + bkname
-            with log_exc(lambda e: "Exception: MedusaRestore failed: %s\n" % e):
-                CustomResources.create_medusa_restorejob(rtname, bkname, dc, ns)
+                with log_exc(lambda e: "Exception: MedusaRestore failed: %s\n" % e):
+                    now_dtformat = datetime.now().strftime("%Y-%m-%d.%H.%M.%S")
+                    rtname = 'medusa-' + now_dtformat + '-restore-from-' + bkname
+                    CustomResources.create_medusa_restorejob(rtname, bkname, dc, ns)
 
-            return state
+                return state
 
     def completion(self, state: ReplState):
         if sc := super().completion(state):

adam/commands/param_get.py

@@ -1,3 +1,4 @@
+from adam.commands import validate_args
 from adam.commands.command import Command
 from adam.config import Config
 from adam.repl_state import ReplState
@@ -23,19 +24,17 @@ class GetParam(Command):
             return super().run(cmd, state)
 
         with self.validate(args, state) as (args, state):
-            if len(args) < 1:
+            def msg():
                 lines = [f'{key}\t{Config().get(key, None)}' for key in Config().keys()]
                 log(lines_to_tabular(lines, separator='\t'))
 
-                return state
+            with validate_args(args, state, msg=msg) as key:
+                if v := Config().get(key, None):
+                    log(v)
+                else:
+                    log2(f'{key} is not set.')
 
-            key = args[0]
-            if v := Config().get(key, None):
-                log(v)
-            else:
-                log2(f'{key} is not set.')
-
-            return v if v else state
+                return v if v else state
 
     def completion(self, _: ReplState):
         return {GetParam.COMMAND: {key: None for key in Config().keys()}}

adam/commands/param_set.py

@@ -1,3 +1,4 @@
+from adam.commands import validate_args
 from adam.commands.command import Command
 from adam.config import Config
 from adam.repl_state import ReplState
@@ -23,18 +24,14 @@ class SetParam(Command):
             return super().run(cmd, state)
 
         with self.validate(args, state) as (args, state):
-            if len(args) < 2:
-                log2('set <key> <value>')
+            with validate_args(args, state, count_at_least=2, msg=lambda: log2('set <key> <value>')):
+                key = args[0]
+                value = args[1]
+                Config().set(key, value)
 
-                return 'invalid args'
+                log(Config().get(key, None))
 
-            key = args[0]
-            value = args[1]
-            Config().set(key, value)
-
-            log(Config().get(key, None))
-
-            return value
+                return value
 
     def completion(self, _: ReplState):
         return {SetParam.COMMAND: {key: ({'true': None, 'false': None} if Config().get(key, None) in [True, False] else None) for key in Config().keys()}}

adam/commands/postgres/postgres.py

@@ -1,6 +1,6 @@
 import click
 
-from adam.commands import extract_trailing_options
+from adam.commands import extract_trailing_options, validate_args
 from adam.commands.command import Command
 from adam.commands.intermediate_command import IntermediateCommand
 from adam.commands.postgres.psql_completions import psql_completions
@@ -32,32 +32,24 @@ class Postgres(IntermediateCommand):
 
         with self.validate(args, state) as (args, state):
             with extract_trailing_options(args, '&') as (args, backgrounded):
-                if not args:
-                    if state.in_repl:
-                        log2('Please use SQL statement. e.g. pg \l')
-                    else:
-                        log2('* Command or SQL statements is missing.')
-                        Command.display_help()
+                with validate_args(args, state, name='SQL statement') as sql:
+                    if not state.pg_path:
+                        if state.in_repl:
+                            log2('Enter "use <pg-name>" first.')
+                        else:
+                            log2('* pg-name is missing.')
 
-                    return 'command-missing'
+                        return state
 
-                if not state.pg_path:
                     if state.in_repl:
-                        log2('Enter "use <pg-name>" first.')
-                    else:
-                        log2('* pg-name is missing.')
+                        with postgres(state) as pod:
+                            pod.sql(args, background=backgrounded)
+                    elif not self.run_subcommand(cmd, state):
+                        with postgres(state) as pod:
+                            pod.sql(args, background=backgrounded)
 
                     return state
 
-                if state.in_repl:
-                    with postgres(state) as pod:
-                        pod.sql(args, background=backgrounded)
-                elif not self.run_subcommand(cmd, state):
-                    with postgres(state) as pod:
-                        pod.sql(args, background=backgrounded)
-
-                return state
-
     def cmd_list(self):
         return [PostgresLs(), PostgresPreview(), PostgresPg()]
 

adam/commands/postgres/utils_postgres.py

@@ -49,7 +49,11 @@ class PostgresPodService:
     def sql(self, args: list[str], background=False):
         state = self.handler.state
 
-        PostgresContext.apply(state.namespace, state.pg_path).run_sql(' '.join(args), background=background)
+        query = args
+        if isinstance(args, list):
+            query = ' '.join(args)
+
+        PostgresContext.apply(state.namespace, state.pg_path).run_sql(query, background=background)
 
 class PostgresExecHandler:
     def __init__(self, state: ReplState, background=False):

adam/commands/preview_table.py

@@ -18,7 +18,7 @@ class PreviewTable(Command):
         return PreviewTable.COMMAND
 
     def required(self):
-        return [RequiredState.CLUSTER_OR_POD, RequiredState.PG_DATABASE, ReplState.L]
+        return [RequiredState.CLUSTER_OR_POD, RequiredState.PG_DATABASE, ReplState.L, RequiredState.EXPORT_DB]
 
     def run(self, cmd: str, state: ReplState):
         if not(args := self.args(cmd)):

adam/commands/reaper/reaper_run_abort.py

@@ -1,3 +1,4 @@
+from adam.commands import validate_args
 from adam.commands.command import Command
 from adam.commands.reaper.utils_reaper import reaper
 from adam.repl_state import ReplState, RequiredState
@@ -26,19 +27,12 @@ class ReaperRunAbort(Command):
             return super().run(cmd, state)
 
         with self.validate(args, state) as (args, state):
-            if not args:
-                if state.in_repl:
-                    log2('Specify run id to abort.')
-                else:
-                    Command.display_help()
+            with validate_args(args, state, name='run id') as run_id:
+                with reaper(state) as http:
+                    http.put(f'repair_run/{run_id}/state/ABORTED')
 
                 return state
 
-            with reaper(state) as http:
-                http.put(f'repair_run/{args[0]}/state/ABORTED')
-
-            return state
-
     def completion(self, state: ReplState):
         return super().completion(state)
 

adam/commands/reaper/reaper_schedule_activate.py

@@ -1,3 +1,4 @@
+from adam.commands import validate_args
 from adam.commands.command import Command
 from adam.commands.reaper.utils_reaper import Reapers, reaper
 from adam.repl_state import ReplState, RequiredState
@@ -26,17 +27,12 @@ class ReaperScheduleActivate(Command):
             return super().run(cmd, state)
 
         with self.validate(args, state) as (args, state):
-            if not args:
-                log2('Specify schedule to activate.')
+            with validate_args(args, state, name='schedule') as schedule_id:
+                with reaper(state) as http:
+                    http.put(f'repair_schedule/{schedule_id}?state=ACTIVE')
+                    Reapers.show_schedule(state, schedule_id)
 
-                return state
-
-            schedule_id = args[0]
-            with reaper(state) as http:
-                http.put(f'repair_schedule/{schedule_id}?state=ACTIVE')
-                Reapers.show_schedule(state, schedule_id)
-
-            return schedule_id
+                return schedule_id
 
     def completion(self, state: ReplState):
         return super().completion(state, lambda: {id: None for id in Reapers.cached_schedule_ids(state)})

adam/commands/reaper/reaper_schedule_start.py

@@ -1,3 +1,4 @@
+from adam.commands import validate_args
 from adam.commands.command import Command
 from adam.commands.reaper.utils_reaper import Reapers, reaper
 from adam.repl_state import ReplState, RequiredState
@@ -26,17 +27,12 @@ class ReaperScheduleStart(Command):
             return super().run(cmd, state)
 
         with self.validate(args, state) as (args, state):
-            if not args:
-                log2('Specify schedule to activate.')
+            with validate_args(args, state, name='schedule') as schedule_id:
+                with reaper(state) as http:
+                    http.post(f'repair_schedule/start/{schedule_id}')
+                    Reapers.show_schedule(state, schedule_id)
 
-                return state
-
-            schedule_id = args[0]
-            with reaper(state) as http:
-                http.post(f'repair_schedule/start/{schedule_id}')
-                Reapers.show_schedule(state, schedule_id)
-
-            return schedule_id
+                return schedule_id
 
     def completion(self, state: ReplState):
         return super().completion(state, lambda: {id: None for id in Reapers.cached_schedule_ids(state)})

adam/commands/reaper/reaper_schedule_stop.py

@@ -1,3 +1,4 @@
+from adam.commands import validate_args
 from adam.commands.command import Command
 from adam.commands.reaper.utils_reaper import Reapers, reaper
 from adam.repl_state import ReplState, RequiredState
@@ -26,17 +27,12 @@ class ReaperScheduleStop(Command):
             return super().run(cmd, state)
 
         with self.validate(args, state) as (args, state):
-            if not args:
-                log2('Specify run schedule to stop.')
+            with validate_args(args, state, name='schedule') as schedule_id:
+                with reaper(state) as http:
+                    http.put(f'repair_schedule/{schedule_id}?state=PAUSED')
+                    Reapers.show_schedule(state, schedule_id)
 
-                return state
-
-            with reaper(state) as http:
-                schedule_id = args[0]
-                http.put(f'repair_schedule/{schedule_id}?state=PAUSED')
-                Reapers.show_schedule(state, schedule_id)
-
-            return schedule_id
+                return schedule_id
 
     def completion(self, state: ReplState):
         return super().completion(state, lambda: {id: None for id in Reapers.cached_schedule_ids(state)})

adam/repl.py

@@ -5,7 +5,7 @@ import click
 from prompt_toolkit.key_binding import KeyBindings
 
 from adam.cli_group import cli
-from adam.commands.command import Command, InvalidState
+from adam.commands.command import Command, InvalidArgumentsException, InvalidStateException
 from adam.commands.command_helpers import ClusterCommandHelper
 from adam.commands.devices.devices import Devices
 from adam.commands.help import Help
@@ -16,7 +16,7 @@ from adam.log import Log
 from adam.repl_commands import ReplCommands
 from adam.repl_session import ReplSession
 from adam.repl_state import ReplState
-from adam.utils import clear_wait_log_flag, debug, debug_trace, deep_merge_dicts, deep_sort_dict, lines_to_tabular, log2, log_exc, log_timing
+from adam.utils import clear_wait_log_flag, debug_trace, deep_merge_dicts, deep_sort_dict, lines_to_tabular, log2, log_exc, log_timing
 from adam.apps import Apps
 from adam.utils_repl.repl_completer import ReplCompleter
 from . import __version__
@@ -109,7 +109,9 @@ def enter_repl(state: ReplState):
                 try:
                     if cmd and cmd.strip(' ') and not (result := cmds.run(cmd, target)):
                         result = try_device_default_action(target, cmds, cmd_list, cmd)
-                except InvalidState:
+                except InvalidStateException:
+                    pass
+                except InvalidArgumentsException:
                     pass
 
                 if result and type(result) is ReplState and (s := cast(ReplState, result).export_session) != state.export_session: