kaqing 2.0.171__py3-none-any.whl → 2.0.203__py3-none-any.whl

adam/repl_commands.py

@@ -1,9 +1,16 @@
 from adam.commands.alter_tables import AlterTables
-from adam.commands.app_cmd import App
-from adam.commands.app_ping import AppPing
+from adam.commands.app.app import App
+from adam.commands.app.app_ping import AppPing
+from adam.commands.app.show_app_actions import ShowAppActions
+from adam.commands.app.show_app_id import ShowAppId
+from adam.commands.app.show_app_queues import ShowAppQueues
 from adam.commands.audit.audit import Audit
 from adam.commands.cat import Cat
 from adam.commands.code import Code
+from adam.commands.debug.debug import Debug
+from adam.commands.debug.debug_timings import DebugTimings
+from adam.commands.download_cassandra_log import DownloadCassandraLog
+from adam.commands.download_file import DownloadFile
 from adam.commands.deploy.code_start import CodeStart
 from adam.commands.deploy.code_stop import CodeStop
 from adam.commands.deploy.deploy import Deploy
@@ -19,23 +26,29 @@ from adam.commands.devices.device_auit_log import DeviceAuditLog
 from adam.commands.devices.device_cass import DeviceCass
 from adam.commands.devices.device_export import DeviceExport
 from adam.commands.devices.device_postgres import DevicePostgres
+from adam.commands.export.download_export_session import DownloadExportSession
 from adam.commands.export.drop_export_database import DropExportDatabase
 from adam.commands.export.export import ExportTables
+from adam.commands.export.import_files import ImportCSVFiles
 from adam.commands.export.import_session import ImportSession
 from adam.commands.export.clean_up_export_sessions import CleanUpExportSessions
 from adam.commands.export.clean_up_all_export_sessions import CleanUpAllExportSessions
 from adam.commands.export.drop_export_databases import DropExportDatabases
-from adam.commands.export.export_select import ExportSelect
+from adam.commands.export.export_x_select import ExportXSelect
 from adam.commands.export.export_use import ExportUse
-from adam.commands.export.export_select_x import ExportSelectX
+from adam.commands.export.export_select import ExportSelect
 from adam.commands.export.show_column_counts import ShowColumnCounts
 from adam.commands.export.show_export_databases import ShowExportDatabases
 from adam.commands.export.show_export_session import ShowExportSession
 from adam.commands.export.show_export_sessions import ShowExportSessions
+from adam.commands.find_files import FindLocalFiles
+from adam.commands.find_processes import FindProcesses
+from adam.commands.head import Head
 from adam.commands.kubectl import Kubectl
+from adam.commands.restart_cluster import RestartCluster
+from adam.commands.restart_node import RestartNode
 from adam.commands.shell import Shell
-from adam.commands.show.show_app_queues import ShowAppQueues
-from adam.commands.cp import ClipboardCopy
+from adam.commands.clipboard_copy import ClipboardCopy
 from adam.commands.bash.bash import Bash
 from adam.commands.cd import Cd
 from adam.commands.check import Check
@@ -52,16 +65,14 @@ from adam.commands.preview_table import PreviewTable
 from adam.commands.pwd import Pwd
 from adam.commands.reaper.reaper import Reaper
 from adam.commands.repair.repair import Repair
-from adam.commands.report import Report
-from adam.commands.restart import Restart
+from adam.commands.generate_report import GenerateReport
+from adam.commands.restart_nodes import RestartNodes
 from adam.commands.rollout import RollOut
 from adam.commands.param_set import SetParam
 from adam.commands.show.show import Show
-from adam.commands.show.show_app_actions import ShowAppActions
-from adam.commands.show.show_app_id import ShowAppId
 from adam.commands.show.show_cassandra_status import ShowCassandraStatus
 from adam.commands.show.show_cassandra_version import ShowCassandraVersion
-from adam.commands.show.show_commands import ShowKubectlCommands
+from adam.commands.show.show_cli_commands import ShowKubectlCommands
 from adam.commands.show.show_host import ShowHost
 from adam.commands.show.show_login import ShowLogin
 from adam.commands.show.show_params import ShowParams
@@ -76,7 +87,7 @@ class ReplCommands:
         cmds: list[Command] = ReplCommands.navigation() + ReplCommands.cassandra_ops() + ReplCommands.postgres_ops() + \
             ReplCommands.app_ops() + ReplCommands.audit_ops() + ReplCommands.export_ops() + ReplCommands.tools() + ReplCommands.exit()
 
-        intermediate_cmds: list[Command] = [App(), Audit(), Reaper(), Repair(), Deploy(), Show(), Undeploy()]
+        intermediate_cmds: list[Command] = [App(), Audit(), Reaper(), Repair(), Debug(), Deploy(), Show(), Undeploy()]
         ic = [c.command() for c in intermediate_cmds]
         # 1. dedup commands
         deduped = []
@@ -93,17 +104,18 @@ class ReplCommands:
         return deduped
 
     def navigation() -> list[Command]:
-        return [Ls(), PreviewTable(), DeviceApp(), DevicePostgres(), DeviceCass(), DeviceAuditLog(), DeviceExport(), Cd(), Cat(), Pwd(), ClipboardCopy(),
+        return [Ls(), PreviewTable(), DeviceApp(), DevicePostgres(), DeviceCass(), DeviceAuditLog(), DeviceExport(),
+                Cd(), Cat(), Head(), DownloadFile(), FindLocalFiles(), FindProcesses(), Pwd(), ClipboardCopy(),
                 GetParam(), SetParam(), ShowParams(), ShowKubectlCommands(), ShowLogin(), ShowAdam(), ShowHost()]
 
     def cassandra_ops() -> list[Command]:
-        return [Cqlsh(), ShowCassandraStatus(), ShowCassandraVersion(), ShowCassandraRepairs(), ShowStorage(), ShowProcesses(),
-                Check(), Issues(), NodeTool(), Report(), AlterTables(), Bash(),
-                ExportTables(), ExportSelect(), ExportUse(),  ShowExportDatabases(), ShowColumnCounts(),
+        return [Cqlsh(), DownloadCassandraLog(), ShowCassandraStatus(), ShowCassandraVersion(), ShowCassandraRepairs(), ShowStorage(), ShowProcesses(),
+                Check(), Issues(), NodeTool(), GenerateReport(), AlterTables(), Bash(),
+                ExportTables(), ExportXSelect(), ExportUse(),  ShowExportDatabases(), ShowColumnCounts(),
                 DropExportDatabase(), DropExportDatabases(),
-                ShowExportSessions(), ShowExportSession(),
-                CleanUpExportSessions(), CleanUpAllExportSessions(), ImportSession()] + \
-                Medusa().cmd_list() + [Restart(), RollOut(), Watch()] + Reaper().cmd_list() + Repair().cmd_list()
+                ShowExportSessions(), ShowExportSession(), DownloadExportSession(),
+                CleanUpExportSessions(), CleanUpAllExportSessions(), ImportSession(), ImportCSVFiles()] + \
+                Medusa().cmd_list() + [RestartNodes(), RestartNode(), RestartCluster(), RollOut(), Watch()] + Reaper().cmd_list() + Repair().cmd_list() + Debug().cmd_list()
 
     def postgres_ops() -> list[Command]:
         return [Postgres(), DeployPgAgent(), UndeployPgAgent(), PostgresPg()]
@@ -115,7 +127,7 @@ class ReplCommands:
         return [Audit()] + Audit().cmd_list()
 
     def export_ops() -> list[Command]:
-        return [ExportSelectX(), DropExportDatabase(), DropExportDatabases(), ShowColumnCounts()]
+        return [ExportSelect(), DropExportDatabase(), DropExportDatabases(), ShowColumnCounts()]
 
     def tools() -> list[Command]:
         return [Shell(), CodeStart(), CodeStop(), DeployFrontend(), UndeployFrontend(), DeployPod(), UndeployPod(), Kubectl(), Code()]

adam/repl_session.py

@@ -1,6 +1,9 @@
 from prompt_toolkit import PromptSession
 from prompt_toolkit.auto_suggest import AutoSuggestFromHistory
 
+from adam.config import Config
+from adam.utils import ConfigHolder
+
 class ReplSession:
     # the singleton pattern
     def __new__(cls, *args, **kwargs):
@@ -10,4 +13,9 @@ class ReplSession:
 
     def __init__(self):
         if not hasattr(self, 'prompt_session'):
-            self.prompt_session = PromptSession(auto_suggest=AutoSuggestFromHistory())
+            self.prompt_session = PromptSession(auto_suggest=AutoSuggestFromHistory())
+            ConfigHolder().append_command_history = self.append_history
+
+    def append_history(self, entry: str):
+        if entry and  self.prompt_session and Config().get('repl.history.push-cat-remote-log-file', True):
+            self.prompt_session.history.append_string(entry)

adam/repl_state.py

@@ -3,7 +3,6 @@ from enum import Enum
 import re
 from typing import Callable
 
-from adam.commands.postgres.postgres_context import PostgresContext
 from adam.utils_k8s.app_clusters import AppClusters
 from adam.utils_k8s.app_pods import AppPods
 from adam.utils_k8s.cassandra_clusters import CassandraClusters
@@ -62,6 +61,7 @@ class ReplState:
         self.bash_session = bash_session
         self.remote_dir = remote_dir
         self.original_state: ReplState = None
+        self.pod_targetted = False
 
         self.export_session: str = None
 
@@ -82,11 +82,11 @@ class ReplState:
         msg = ''
         if self.device == ReplState.P:
             msg = f'{ReplState.P}:'
-            pg: PostgresContext = PostgresContext.apply(self.namespace, self.pg_path) if self.pg_path else None
-            if pg and pg.db:
-                msg += pg.db
-            elif pg and pg.host:
-                msg += pg.host
+            host, database = self.pg_host_n_database()
+            if database:
+                msg += database
+            elif host:
+                msg += host
         elif self.device == ReplState.A:
             msg = f'{ReplState.A}:'
             if self.app_env:
@@ -314,8 +314,8 @@ class ReplState:
             if self.device != ReplState.P:
                 return (False, None)
 
-            pg: PostgresContext = PostgresContext.apply(self.namespace, self.pg_path)
-            if not pg.db:
+            _, database = self.pg_host_n_database()
+            if not database:
                 def error():
                     if self.in_repl:
                         log2('cd to a database first.')
@@ -346,7 +346,10 @@ class ReplState:
             if not self.export_session:
                 def error():
                     if self.in_repl:
-                        log2("Select an export database first with 'use' command.")
+                        if self.device == ReplState.C:
+                            log2("Select an export database first with 'use' command.")
+                        else:
+                            log2('cd to an export database first.')
                     else:
                         log2('* export database is missing.')
                         log2()
@@ -390,9 +393,10 @@ class ReplState:
         self.pop()
         self.bash_session = None
 
-    def push(self):
+    def push(self, pod_targetted=False):
         if not self.original_state:
             self.original_state = copy(self)
+            self.pod_targetted = pod_targetted
 
     def pop(self):
         if o := self.original_state:
@@ -407,6 +411,31 @@ class ReplState:
             self.namespace = o.namespace
 
             self.original_state = None
+            self.pod_targetted = False
+
+    def pg_host_n_database(self):
+        host = None
+        database = None
+
+        if self.pg_path:
+            host_n_db = self.pg_path.split('/')
+            host = host_n_db[0]
+            if len(host_n_db) > 1:
+                database = host_n_db[1]
+
+        return host, database
+
+    def with_no_pod(self):
+        state1 = copy(self)
+        state1.pod = None
+
+        return state1
+
+    def with_pod(self, pod: str):
+        state1 = copy(self)
+        state1.pod = pod
+
+        return state1
 
 class DevicePodService:
     def __init__(self, handler: 'DeviceExecHandler'):

adam/sql/async_executor.py

@@ -0,0 +1,44 @@
+import asyncio
+from concurrent.futures import ThreadPoolExecutor
+import inspect
+import threading
+import traceback
+
+from adam.utils import log2, log_timing
+
+class AsyncExecutor:
+    # some lib does not handle asyncio loop properly, as sync exec submit does not work, use another async loop
+
+    lock = threading.Lock()
+    in_queue = set()
+
+    loop: asyncio.AbstractEventLoop = None
+    async_exec: ThreadPoolExecutor = None
+
+    def preload(action: callable, log_key: str = None):
+        with AsyncExecutor.lock:
+            if not AsyncExecutor.loop:
+                AsyncExecutor.loop = asyncio.new_event_loop()
+                AsyncExecutor.async_exec = ThreadPoolExecutor(max_workers=6, thread_name_prefix='async')
+                AsyncExecutor.loop.set_default_executor(AsyncExecutor.async_exec)
+
+            async def a():
+                try:
+                    arg_needed = len(action.__code__.co_varnames)
+
+                    if log_key:
+                        with log_timing(log_key):
+                            r = action(None) if arg_needed else action()
+                    else:
+                        r = action(None) if arg_needed else action()
+                    if inspect.isawaitable(r):
+                        await r
+
+                    AsyncExecutor.in_queue.remove(log_key)
+                except Exception as e:
+                    log2('preloading error', e, inspect.getsourcelines(action)[0][0])
+                    traceback.print_exc()
+
+            if log_key not in AsyncExecutor.in_queue:
+                AsyncExecutor.in_queue.add(log_key)
+                AsyncExecutor.async_exec.submit(lambda: AsyncExecutor.loop.run_until_complete(a()))

adam/sql/lark_completer.py

@@ -0,0 +1,286 @@
+import functools
+import os
+from typing import Iterable
+from prompt_toolkit.completion import CompleteEvent, Completer, Completion, NestedCompleter, WordCompleter
+from prompt_toolkit.document import Document
+
+from adam.config import Config
+from adam.sql.async_executor import AsyncExecutor
+from adam.sql.lark_parser import LarkParser
+from adam.utils import debug, log_timing, offload
+from adam.utils_repl.appendable_completer import AppendableCompleter
+from adam.utils_repl.repl_completer import merge_completions
+
+__all__ = [
+    "LarkCompleter",
+]
+
+def default_columns(x: list[str]):
+    return 'id,x.,y.,z.'.split(',')
+
+class LarkCompleter(Completer, AppendableCompleter):
+    SYSTEM = 'system'
+
+    def __init__(self,
+                 dml: str = None,
+                 expandables: dict = {},
+                 variant: str = 'c',
+
+                 name: str = None,
+                 options_lambda: callable = None,
+                 auto: str = 'lazy',
+                 debug = False
+    ) -> None:
+        self.nested: NestedCompleter = None
+        self.options_lambda = options_lambda
+        if options_lambda and auto == 'lazy':
+            AsyncExecutor.preload(options_lambda, log_key=name)
+
+        self.variant = variant
+        self.parser = None
+        self.dml = dml
+        self.expandables = expandables
+
+        self.display_dict = {}
+        self.meta_dict = {}
+        self.WORD = None
+        self.sentence = False
+        self.match_middle = False
+        self.pattern = None
+
+        self.debug = debug
+
+        if variant:
+            self.parser = LarkCompleter.lark_parser(variant)
+            self.preload_lazy_auto_completes()
+
+    def __repr__(self):
+        return f"LarkCompleter.{self.variant}"
+
+    def preload_lazy_auto_completes(self):
+        for key, value in self.expandables.items():
+            if callable(value):
+                if self.auto_complete(key) == 'lazy':
+                    AsyncExecutor.preload(value, log_key=key)
+
+    def from_lambda(name: str, options_lambda: callable, auto: str = 'lazy'):
+        return LarkCompleter(name=name, options_lambda=options_lambda, auto=auto, variant=None)
+
+    @functools.lru_cache()
+    def lark_parser(variant: str):
+        dir_path = os.path.dirname(os.path.realpath(__file__))
+        with open(dir_path + f"/qingl.lark") as f:
+            grammar: str = None
+            with log_timing(f'lark.{variant}.file-read'):
+                grammar = f.read()
+
+            common_contexts = {
+                'cd_command.file_name': 'direct-dirs',
+            }
+
+            if variant in ['a', 'c0', 'p0', 'x0']:
+                grammar = grammar.replace('start: statement_sequence', f'start: qing_{variant}_statement')
+                contexts_by_path = {
+                } | common_contexts
+
+                debug(f'* GRAMMAR replaced to start: qing_{variant}_statement')
+
+                return LarkParser(grammar, contexts_by_path)
+            elif variant == 'system':
+                grammar = grammar.replace('start: statement_sequence', f'start: qing_{variant}_statement')
+                contexts_by_path = {
+                } | common_contexts
+
+                return LarkParser(grammar, contexts_by_path)
+
+            grammar = grammar.replace('qing_statement: qing_p_statement', f'qing_statement: qing_{variant}_statement')
+            debug(f'* GRAMMAR replaced to qing_statement: qing_{variant}_statement')
+
+            bash_contexts = {
+                'bash_statement.host_name': 'hosts',
+                'bash_statement.bash_command': 'bash-commands',
+            }
+
+            contexts_by_path = {
+                'describe_keyspace.keyspace_name': 'keyspaces',
+                'keyspace_ref.keyspace_path.namespace_ref.identifier_ref': 'tables',
+                'preview_table_statement.path.identifier_ref': 'tables',
+
+                'insert_statement.insert_select': 'column-names',
+                'update_statement.set_clause.path.identifier_ref': 'column-names',
+                'update_statement.where_clause.cond.expr.path.identifier_ref': 'column-names',
+                'delete_statement.where_clause.cond.expr.path.identifier_ref': 'column-names',
+
+                'select_clause.projection.result_expr.expr.path.identifier_ref': 'columns',
+                'select_from.where_clause.cond.expr.path.identifier_ref': 'columns',
+                'select_from.where_clause.cond.expr.logical_term.and_expr.cond.expr.path.identifier_ref': 'columns',
+                'select_from.group_by_clause.group_term.expr.path.identifier_ref': 'columns',
+                'select_statement.order_by_clause.ordering_term.expr.path.identifier_ref': 'columns',
+                'select_from.from_clause.from_terms.join_clause.ansi_join_clause.ansi_join_predicate.expr.path.identifier_ref': 'columns',
+                'select_from.from_clause.from_terms.join_clause.ansi_join_clause.ansi_join_predicate.expr.comparison_term.relational_expr.expr.path.identifier_ref': 'columns',
+
+                'select_from.from_clause.from_terms.from_generic.alias.identifier_ref': 'column-aliases',
+
+                'select_statement.limit_clause.expr.literal.nbr.digit': 'limits',
+            } | common_contexts
+
+            if variant == 'p':
+                contexts_by_path = bash_contexts | contexts_by_path
+            elif variant == 'c':
+                contexts_by_path = {
+                    'export_table.path.identifier_ref': 'tables',
+                    'show_column_counts_command.path.identifier_ref': 'tables',
+                    'export_statement.export_tables.keyspace_name': 'keyspaces',
+
+                    'alter_tables_statement.properties.property.property_name': 'table-props',
+                    'alter_cql_table_statement.properties.property.property_name': 'table-props',
+                    'alter_tables_statement.properties.property.property_value.literal': 'table-props-value',
+                    'alter_cql_table_statement.properties.property.property_value.literal': 'table-props-value',
+
+                    'select_clause.projection.result_expr.expr.path.identifier_ref': 'columns',
+                    'export_statement.export_tables.export_table.column_name_list.column_name': 'columns',
+
+                    'consistency_statement.consistency': 'consistencies',
+                    'export_statement.export_to.export_database_type': 'export-database-types',
+                    'drop_export_database.export_database_name': 'export-databases',
+                    'use_export_db_statement.export_database_name': 'export-databases',
+                    'clean_up_export_session_statement.clean_up_export_sessions.export_session_name': 'export-sessions',
+                    'show_export_command.export_session_name': 'export-sessions',
+                    'import_statement.import_session.export_session_name': 'export-sessions-incomplete',
+                    'download_session_statement.export_session_name': 'export-sessions-incomplete',
+                } | bash_contexts | contexts_by_path
+            elif variant == 'l':
+                contexts_by_path = {
+                    'add_partition_action.partition_ref.partition_name': 'partition-columns',
+                    'show_topn_statement.topn_count': 'topn-counts',
+                    'show_topn_statement.topn_type': 'topn-types',
+                    'show_topn_statement.topn_window': 'topn-windows'
+                } | contexts_by_path
+            elif variant == 'x':
+                contexts_by_path = {
+                    'show_column_counts_command.path.identifier_ref': 'tables',
+                    'drop_export_database.export_database_name': 'export-databases',
+                    'use_export_db_statement.export_database_name': 'export-databases',
+                } | contexts_by_path
+
+                grammar = grammar.replace('select_clause: "SELECT"i hint_comment? projection', 'select_clause: ("SELECT"i | "XELECT"i) hint_comment? projection')
+
+            with offload():
+                with open('/tmp/grammar.lark', 'wt') as f:
+                    f.write(grammar)
+
+            return LarkParser(grammar, contexts_by_path)
+
+    def get_completions(
+        self, document: Document, complete_event: CompleteEvent
+    ) -> Iterable[Completion]:
+        if not self.nested and self.options_lambda:
+            # for lazy completions
+            self.nested = NestedCompleter.from_nested_dict(self.options_lambda())
+
+        nested_words = set()
+
+        if self.nested:
+            # from NestedCompleter
+
+            # Split document.
+            text = document.text_before_cursor.lstrip()
+            stripped_len = len(document.text_before_cursor) - len(text)
+
+            # If there is a space, check for the first term, and use a
+            # subcompleter.
+            if " " in text:
+                first_term = text.split()[0]
+                completer = self.nested.options.get(first_term)
+
+                # If we have a sub completer, use this for the completions.
+                if completer is not None:
+                    remaining_text = text[len(first_term) :].lstrip()
+                    move_cursor = len(text) - len(remaining_text) + stripped_len
+
+                    new_document = Document(
+                        remaining_text,
+                        cursor_position=document.cursor_position - move_cursor,
+                    )
+
+                    for c in completer.get_completions(new_document, complete_event):
+                        nested_words.add(c.text)
+                        yield c
+
+            # No space in the input: behave exactly like `WordCompleter`.
+            else:
+                completer = WordCompleter(
+                    list(self.nested.options.keys()), ignore_case=self.nested.ignore_case
+                )
+                for c in completer.get_completions(document, complete_event):
+                    nested_words.add(c.text)
+                    yield c
+
+        if self.parser:
+            full = document.text_before_cursor
+            if self.dml:
+                full = self.dml + ' ' + full
+
+            words0 = []
+            words1 = []
+            context = {}
+            for word in self.parser.next_terminals(full, context=context):
+                if ex := self.expandable(word):
+                    if ex in self.expandables:
+                        e = self.expandables[ex]
+                        if callable(e):
+                            if self.auto_complete(ex) != 'off':
+                                ctx = None
+                                if 'last-id' in context:
+                                    ctx = context['last-id']
+                                e = e(ctx)
+                                words0.extend(e)
+                        else:
+                            words0.extend(e)
+                else:
+                    words1.append(word)
+            words = words0 + words1
+
+            word_before_cursor = document.get_word_before_cursor(
+                WORD=self.WORD, pattern=self.pattern
+            )
+
+            word_before_cursor = word_before_cursor.lower()
+
+            def word_matches(word: str) -> bool:
+                return word.lower().startswith(word_before_cursor)
+
+            for word in words:
+                if word_matches(word) and word not in nested_words:
+                    display = self.display_dict.get(word, word)
+                    display_meta = self.meta_dict.get(word, "")
+                    yield Completion(
+                        word,
+                        -len(word_before_cursor),
+                        display=display,
+                        display_meta=display_meta,
+                    )
+
+    def completions_for_nesting(self, dml: str = None):
+        if dml:
+            return {dml: LarkCompleter(dml, expandables=self.expandables, variant=self.variant)}
+
+        return {
+            word.text.lower(): LarkCompleter(word.text, expandables=self.expandables, variant=self.variant)
+            for word in self.get_completions(Document(''), None)
+        }
+
+    def expandable(self, word: str):
+        return word.strip('`') if word.startswith('`') else None
+
+    def append_completions(self, key: str, value: dict[str, any]):
+        if isinstance(value, LarkCompleter) and self.variant == value.variant:
+            return
+
+        if self.nested:
+            self.nested = NestedCompleter.from_nested_dict(merge_completions(self.nested.options, value))
+        else:
+            self.nested = NestedCompleter.from_nested_dict(value)
+
+    def auto_complete(self, key: str, default = 'lazy'):
+        return Config().get(f'auto-complete.{self.variant}.{key}', default=default)