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

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
@@ -20,31 +19,8 @@ class BashSession:
     def pwd(self, state: 'ReplState'):
         command = f'cat /tmp/.qing-{self.session_id}'
 
-        if state.device == ReplState.A and state.app_app:
-            if state.app_pod:
-                rs = [AppPods.exec(state.app_pod, state.namespace, command, show_out=False)]
-            else:
-                pods = AppPods.pod_names(state.namespace, state.app_env, state.app_pod)
-                rs = AppClusters.exec(pods, state.namespace, command, show_out=False)
-        elif state.pod:
-            rs = [CassandraNodes.exec(state.pod, state.namespace, command, show_out=False)]
-        elif state.sts:
-            rs = CassandraClusters.exec(state.sts, state.namespace, command, action='bash', show_out=False)
-
-        dir = None
-        for r in rs:
-            if r.exit_code(): # if fails to read the session file, ignore
-                continue
-
-            dir0 = r.stdout.strip(' \r\n')
-            if dir:
-                if dir != dir0:
-                    log2('Inconsitent working dir found across multiple pods.')
-                    return None
-            else:
-                dir = dir0
-
-        return dir
+        with device(state) as pods:
+            return pods.exec(command, action='bash', show_out=False)
 
 class RequiredState(Enum):
     CLUSTER = 'cluster'
@@ -85,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
 
@@ -105,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:
@@ -337,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.')
@@ -369,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()
@@ -413,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:
@@ -429,4 +410,72 @@ class ReplState:
             # self.export_session = o.export_session
             self.namespace = o.namespace
 
-            self.original_state = None
+            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
+
+class DevicePodService:
+    def __init__(self, handler: 'DeviceExecHandler'):
+        self.handler = handler
+
+    def exec(self, command: str, action='bash', show_out = True):
+        state = self.handler.state
+
+        rs = None
+        if state.device == ReplState.A and state.app_app:
+            if state.app_pod:
+                rs = [AppPods.exec(state.app_pod, state.namespace, command, show_out=show_out)]
+            else:
+                pods = AppPods.pod_names(state.namespace, state.app_env, state.app_app)
+                rs = AppClusters.exec(pods, state.namespace, command, show_out=show_out)
+        elif state.pod:
+            rs = [CassandraNodes.exec(state.pod, state.namespace, command, show_out=show_out)]
+        elif state.sts:
+            rs = CassandraClusters.exec(state.sts, state.namespace, command, action=action, show_out=show_out)
+        # assume that pg-agent or ops pod is single pod
+
+        dir = None
+        if rs:
+            for r in rs:
+                if r.exit_code(): # if fails to read the session file, ignore
+                    continue
+
+                dir0 = r.stdout.strip(' \r\n')
+                if dir:
+                    if dir != dir0:
+                        log2('Inconsitent working dir found across multiple pods.')
+                        return None
+                else:
+                    dir = dir0
+
+        return dir
+
+class DeviceExecHandler:
+    def __init__(self, state: ReplState):
+        self.state = state
+
+    def __enter__(self):
+        return DevicePodService(self)
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return False
+
+def device(state: ReplState):
+    return DeviceExecHandler(state)

adam/sql/lark_completer.py

@@ -0,0 +1,284 @@
+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.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, preload
+
+__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':
+            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':
+                    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_cql_table_statement.properties.property.property_name': 'table-props',
+                    'alter_tables_statement.properties.property.property_name': 'table-props',
+                    '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)