kaqing 2.0.49__tar.gz → 2.0.51__tar.gz

{kaqing-2.0.49 → kaqing-2.0.51}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kaqing
-Version: 2.0.49
+Version: 2.0.51
 Summary: UNKNOWN
 Home-page: UNKNOWN
 License: UNKNOWN

{kaqing-2.0.49 → kaqing-2.0.51}/adam/commands/cql/cql_completions.py

@@ -1,12 +1,11 @@
-from adam.commands.cql.cql_table_completer import CqlTableCompleter
 from adam.commands.cql.cql_utils import table_names
 from adam.repl_state import ReplState
+from adam.sql.sql_completer import SqlCompleter
 
 def cql_completions(state: ReplState) -> dict[str, any]:
-    completer = CqlTableCompleter(table_names(state))
     return {
         'describe': {
             'keyspaces': None,
-            'table': completer.completions(),
+            'table': {t: None for t in table_names(state)},
             'tables': None},
-    } | completer.completions()
+    } | SqlCompleter.completions(lambda: table_names(state))

kaqing-2.0.51/adam/commands/cql/cql_table_completer.py

@@ -0,0 +1,8 @@
+from adam.sql.term_completer import TermCompleter
+
+class CqlTableNameCompleter(TermCompleter):
+    def __init__(self, tables: list[str], ignore_case: bool = True):
+        super().__init__(tables, ignore_case=ignore_case)
+
+    def __repr__(self) -> str:
+        return "CqlTableCompleter(%r)" % (len(self.words))

{kaqing-2.0.49 → kaqing-2.0.51}/adam/commands/cql/cqlsh.py

@@ -55,6 +55,7 @@ class Cqlsh(Command):
 
     def completion(self, state: ReplState) -> dict[str, any]:
         if state.device != state.C:
+            # conflicts with psql completions
             return {}
 
         if state.sts or state.pod:

{kaqing-2.0.49 → kaqing-2.0.51}/adam/commands/medusa/medusa_restore.py

@@ -59,8 +59,7 @@ class MedusaRestore(Command):
         now_dtformat = datetime.now().strftime("%Y-%m-%d.%H.%M.%S")
         rtname = 'medusa-' + now_dtformat + '-restore-from-' + bkname
         try:
-            print('SEAN doing')
-            # CustomResources.create_medusa_restorejob(rtname, bkname, dc, ns)
+            CustomResources.create_medusa_restorejob(rtname, bkname, dc, ns)
         except Exception as e:
             log2("Exception: MedusaRestore failed: %s\n" % e)
 

{kaqing-2.0.49 → kaqing-2.0.51}/adam/commands/postgres/postgres.py

@@ -1,7 +1,7 @@
 import click
 
 from adam.commands.command import Command
-from adam.commands.postgres.pg_completions import pg_completions
+from adam.commands.postgres.psql_completions import psql_completions
 from adam.commands.postgres.postgres_utils import pg_table_names
 from .postgres_ls import PostgresLs
 from .postgres_preview import PostgresPreview
@@ -66,13 +66,14 @@ class Postgres(Command):
 
     def completion(self, state: ReplState):
         if state.device != state.P:
+            # conflicts with cql completions
             return {}
 
         leaf = {}
         session = PostgresSession(state.namespace, state.pg_path)
         if session.db:
           if pg_table_names(state.namespace, state.pg_path):
-            leaf = pg_completions(state.namespace, state.pg_path)
+            leaf = psql_completions(state.namespace, state.pg_path)
         elif state.pg_path:
             leaf = {
                 '\h': None,

kaqing-2.0.51/adam/commands/postgres/psql_completions.py

@@ -0,0 +1,10 @@
+from adam.commands.postgres.postgres_utils import pg_table_names
+from adam.sql.sql_completer import SqlCompleter
+
+def psql_completions(ns: str, pg_path: str):
+    return {
+        '\h': None,
+        '\d': None,
+        '\dt': None,
+        '\du': None
+    } | SqlCompleter.completions(lambda: pg_table_names(ns, pg_path))

kaqing-2.0.51/adam/commands/postgres/psql_table_completer.py

@@ -0,0 +1,11 @@
+from adam.commands.postgres.postgres_utils import pg_table_names
+from adam.sql.term_completer import TermCompleter
+
+class PsqlTableNameCompleter(TermCompleter):
+    def __init__(self, namespace: str, pg_path: str, ignore_case: bool = True):
+        super().__init__(pg_table_names(namespace, pg_path), ignore_case=ignore_case)
+        self.namespace = namespace
+        self.pg_path = pg_path
+
+    def __repr__(self) -> str:
+        return "PsqlTableCompleter(%r, pg_path=%r)" % (self.namespace, self.pg_path)

{kaqing-2.0.49 → kaqing-2.0.51}/adam/commands/preview_table.py

@@ -1,10 +1,10 @@
 import functools
 
 from adam.commands.command import Command
-from adam.commands.cql.cql_table_completer import CqlTableCompleter
+from adam.commands.cql.cql_table_completer import CqlTableNameCompleter
 from adam.commands.cql.cql_utils import run_cql, table_names, tables
-from adam.commands.postgres.pg_table_completer import PgTableCompleter
 from adam.commands.postgres.postgres_session import PostgresSession
+from adam.commands.postgres.psql_table_completer import PsqlTableNameCompleter
 from adam.config import Config
 from adam.repl_state import ReplState, RequiredState
 from adam.utils import lines_to_tabular, log, log2
@@ -73,9 +73,9 @@ class PreviewTable(Command):
 
     def completion(self, state: ReplState):
         if state.device == ReplState.P:
-            return {PreviewTable.COMMAND: PgTableCompleter(state.namespace, state.pg_path)}
+            return {PreviewTable.COMMAND: PsqlTableNameCompleter(state.namespace, state.pg_path)}
         elif state.sts:
-            return {PreviewTable.COMMAND: CqlTableCompleter(table_names(state))}
+            return {PreviewTable.COMMAND: CqlTableNameCompleter(table_names(state))}
 
         return {}
 

kaqing-2.0.51/adam/sql/sql_completer.py

@@ -0,0 +1,403 @@
+from typing import Callable, Iterable
+from prompt_toolkit.completion import CompleteEvent, Completer, Completion
+from prompt_toolkit.document import Document
+import sqlparse
+from sqlparse.sql import Statement, Token
+from sqlparse import tokens as T
+
+from adam.sql.term_completer import TermCompleter
+
+class SqlCompleter(Completer):
+    def __init__(self, tables: Callable[[], list[str]], dml: str = None, debug = False):
+        super().__init__()
+        self.dml = dml
+        self.tables = tables
+        self.debug = debug
+
+    def get_completions(
+        self, document: Document, complete_event: CompleteEvent
+    ) -> Iterable[Completion]:
+        text = document.text_before_cursor.lstrip()
+        if self.dml:
+            state = f'{self.dml}_'
+            text = f'{self.dml} {text}'
+
+        completer = None
+        stmts = sqlparse.parse(text)
+        if not stmts:
+            completer = TermCompleter(['select', 'insert', 'delete', 'update'])
+        else:
+            statement: Statement = stmts[0]
+            state = self.traverse_tokens(text, statement.tokens)
+            if self.debug:
+                print('\n  =>', state)
+            if state == 'dml_incomplete':
+                completer = TermCompleter(['select', 'insert', 'delete', 'update'])
+
+            elif state == 'select_':
+                completer = TermCompleter(['*'])
+            elif state == 'select_a':
+                completer = TermCompleter(['from'])
+            elif state == 'select_a,':
+                completer = TermCompleter(['*'])
+            elif state == 'select_a_':
+                completer = TermCompleter(['from'])
+            elif state == "select_a_from_":
+                completer = TermCompleter(self.tables())
+            elif state == "select_a_from_x_":
+                completer = TermCompleter(['where', 'group', 'limit'])
+            elif state == "select_a_from_x,":
+                completer = TermCompleter(self.tables())
+            elif state == "select_a_from_x_where_":
+                completer = TermCompleter(['id'])
+            elif state == "select_a_from_x_where_id":
+                completer = TermCompleter(['=', '<', '<=', '>', '>=', '<>', 'like'])
+            elif state == "select_a_from_x_where_id=":
+                completer = TermCompleter(["'"])
+            elif state == "select_a_from_x_where_id=v_":
+                completer = TermCompleter(['and', 'or', 'group', 'limit'])
+            elif state == "select_a_from_x_where_id=v_limit_":
+                completer = TermCompleter(['1'])
+            elif state == "select_a_from_x_group_":
+                completer = TermCompleter(['by'])
+            elif state == "select_a_from_x_group_by_":
+                completer = TermCompleter(['id'])
+            elif state == "select_a_from_x_group_by_a,":
+                completer = TermCompleter(['id'])
+            elif state == "select_a_from_x_group_by_a_":
+                completer = TermCompleter(['limit'])
+            elif state == "select_a_from_x_group_by_a_limit_":
+                completer = TermCompleter(['1'])
+
+            elif state == "insert_":
+                completer = TermCompleter(['into'])
+            elif state == "insert_into_":
+                completer = TermCompleter(self.tables())
+            elif state == "insert_into_x_":
+                completer = TermCompleter(['values'])
+            elif state == "insert_into_x(":
+                completer = TermCompleter(['id'])
+            elif state == "insert_into_x(a,":
+                completer = TermCompleter(['id'])
+            elif state == "insert_into_x(a)_":
+                completer = TermCompleter(['values('])
+            elif state == "insert_into_x_values":
+                completer = TermCompleter(['('])
+            elif state == "insert_into_x_values(":
+                completer = TermCompleter(["'"])
+
+            elif state == "update_":
+                completer = TermCompleter(self.tables())
+            elif state == "update_x_":
+                completer = TermCompleter(['set'])
+            elif state in ["update_x_set_", "update_x_set_a=v,"]:
+                completer = TermCompleter(['id'])
+            elif state == "update_x_set_a":
+                completer = TermCompleter(['='])
+            elif state == "update_x_set_a=":
+                completer = TermCompleter(["'"])
+            elif state == "update_x_set_a=v_":
+                completer = TermCompleter(['where'])
+            elif state == "update_x_set_a=v_where_":
+                completer = TermCompleter(['id'])
+            elif state == "update_x_set_a=v_where_id":
+                completer = TermCompleter(['='])
+            elif state == "update_x_set_a=v_where_id=v_":
+                completer = TermCompleter(['and', 'or'])
+
+            elif state == "delete_":
+                completer = TermCompleter(['from'])
+            elif state == "delete_from_":
+                completer = TermCompleter(self.tables())
+            elif state == "delete_from_x_":
+                completer = TermCompleter(['where'])
+            elif state == "delete_from_x_where_":
+                completer = TermCompleter(['id'])
+            elif state == "delete_from_x_where_id":
+                completer = TermCompleter(['='])
+            elif state == "delete_from_x_where_id=":
+                completer = TermCompleter(["'"])
+            elif state == "delete_from_x_where_id=v_":
+                completer = TermCompleter(['and', 'or'])
+
+        if completer:
+            for c in completer.get_completions(document, complete_event):
+                yield c
+
+    def traverse_tokens(self, text: str, tokens: list[Token], state: str = None, indent=0):
+        # state: str = None
+        for token in tokens:
+            if self.debug:
+                if token.ttype == T.Whitespace:
+                    print('_ ', end='')
+                elif token.ttype in [T.DML, T.Wildcard, T.Punctuation]:
+                    print(f'{token.value} ', end='')
+                elif token.ttype:
+                    tks = str(token.ttype).split('.')
+                    typ = tks[len(tks) - 1]
+                    if ' ' in token.value:
+                        print(f'"{token.value}:{typ}" ', end='')
+                    else:
+                        print(f'{token.value}:{typ} ', end='')
+                # print("  " * indent + f"Token: {token.value}, Type: {token.ttype}@{token.ttype.__class__}")
+            node: str = None
+            if token.is_group:
+                state = self.traverse_tokens(text, token.tokens, state, indent + 1)
+            else:
+                if not state:
+                    if token.ttype == T.Keyword.DML and token.value.lower() == 'select':
+                        state = 'select'
+                    if token.ttype == T.Keyword.DML and token.value.lower() == 'insert':
+                        state = 'insert'
+                    if token.ttype == T.Keyword.DML and token.value.lower() == 'update':
+                        state = 'update'
+                    if token.ttype == T.Keyword.DML and token.value.lower() == 'delete':
+                        state = 'delete'
+                    elif token.ttype == T.Name:
+                        state = 'dml_incomplete'
+
+                elif state == 'select':
+                    if token.ttype == T.Text.Whitespace:
+                        state = 'select_'
+                elif state == 'select_':
+                    if token.ttype == T.Name or token.ttype == T.Wildcard:
+                        state = 'select_a'
+                elif state == 'select_a':
+                    if token.ttype == T.Text.Whitespace:
+                        state = 'select_a_'
+                    elif token.ttype == T.Punctuation and token.value == ',':
+                        state = 'select_a,'
+                elif state == 'select_a,':
+                    if token.ttype == T.Name or token.ttype == T.Wildcard:
+                        state = 'select_a'
+                elif state == 'select_a_':
+                    if token.ttype == T.Keyword and token.value.lower() == 'from':
+                        state = 'select_a_from'
+                elif state == 'select_a_from':
+                    if token.ttype == T.Text.Whitespace:
+                        state = 'select_a_from_'
+                elif state == 'select_a_from_':
+                    if token.ttype == T.Name:
+                        state = 'select_a_from_x'
+                elif state == 'select_a_from_x':
+                    if token.ttype == T.Text.Whitespace:
+                        state = 'select_a_from_x_'
+                    elif token.ttype == T.Punctuation and token.value == ',':
+                        state = 'select_a_from_x,'
+                elif state == 'select_a_from_x,':
+                    if token.ttype == T.Name:
+                        state = 'select_a_from_x'
+                elif state == 'select_a_from_x_':
+                    if token.ttype == T.Keyword and token.value.lower() == 'where':
+                        state = 'select_a_from_x_where'
+                    elif token.ttype == T.Keyword and token.value.lower() == 'limit':
+                        state = 'select_a_from_x_where_id=v_limit'
+                    elif token.ttype == T.Keyword and token.value.lower() == 'group':
+                        state = 'select_a_from_x_group'
+                    elif token.ttype == T.Keyword and token.value.lower() == 'group by':
+                        state = 'select_a_from_x_group_by'
+                elif state == 'select_a_from_x_where':
+                    if token.ttype == T.Text.Whitespace:
+                        state = 'select_a_from_x_where_'
+                elif state == 'select_a_from_x_where_':
+                    if token.ttype == T.Name:
+                        state = 'select_a_from_x_where_id'
+                elif state == 'select_a_from_x_where_id':
+                    if token.ttype == T.Operator.Comparison:
+                        state = 'select_a_from_x_where_id='
+                elif state == 'select_a_from_x_where_id=':
+                    if token.ttype in [T.Literal.String.Single, T.Name]:
+                        state = 'select_a_from_x_where_id=v'
+                elif state == 'select_a_from_x_where_id=v':
+                    if token.ttype == T.Text.Whitespace:
+                        state = 'select_a_from_x_where_id=v_'
+                elif state == 'select_a_from_x_where_id=v_':
+                    if token.ttype == T.Keyword and token.value.lower() in ['and', 'or']:
+                        state = 'select_a_from_x_where'
+                    elif token.ttype == T.Keyword and token.value.lower() == 'group':
+                        state = 'select_a_from_x_group'
+                    elif token.ttype == T.Keyword and token.value.lower() == 'limit':
+                        state = 'select_a_from_x_where_id=v_limit'
+                elif state == 'select_a_from_x_group':
+                    if token.ttype == T.Text.Whitespace:
+                        state = 'select_a_from_x_group_'
+                elif state == 'select_a_from_x_group_':
+                    if token.ttype == T.Keyword and token.value.lower() == 'by':
+                        state = 'select_a_from_x_group_by'
+                elif state == 'select_a_from_x_group_by':
+                    if token.ttype == T.Text.Whitespace:
+                        state = 'select_a_from_x_group_by_'
+                elif state == 'select_a_from_x_group_by_':
+                    if token.ttype == T.Name:
+                        state = 'select_a_from_x_group_by_a'
+                elif state == 'select_a_from_x_group_by_a':
+                    if token.ttype == T.Text.Whitespace:
+                        state = 'select_a_from_x_group_by_a_'
+                    elif token.ttype == T.Punctuation and token.value == ',':
+                        state = 'select_a_from_x_group_by_a,'
+                elif state == 'select_a_from_x_group_by_a,':
+                    if token.ttype == T.Name:
+                        state = 'select_a_from_x_group_by_a'
+                elif state == 'select_a_from_x_group_by_a_':
+                    if token.ttype == T.Keyword and token.value.lower() == 'limit':
+                        state = 'select_a_from_x_where_id=v_limit'
+                elif state == 'select_a_from_x_where_id=v_limit':
+                    if token.ttype == T.Text.Whitespace:
+                        state = 'select_a_from_x_where_id=v_limit_'
+
+                elif state == 'insert':
+                    if token.ttype == T.Text.Whitespace:
+                        state = 'insert_'
+                elif state == 'insert_':
+                    if token.ttype == T.Keyword and token.value.lower() == 'into':
+                        state = 'insert_into'
+                elif state == 'insert_into':
+                    if token.ttype == T.Text.Whitespace:
+                        state = 'insert_into_'
+                elif state == 'insert_into_':
+                    if token.ttype == T.Name:
+                        state = 'insert_into_x'
+                elif state == 'insert_into_x':
+                    if token.ttype == T.Text.Whitespace:
+                        state = 'insert_into_x_'
+                    elif token.ttype == T.Punctuation and token.value == '(':
+                        state = 'insert_into_x('
+                elif state == 'insert_into_x_':
+                    if token.ttype == T.Punctuation and token.value == '(':
+                        state = 'insert_into_x('
+                    elif token.ttype == T.Keyword and token.value.lower() == 'values':
+                        state = 'insert_into_x_values'
+                elif state == 'insert_into_x(':
+                    if token.ttype == T.Name:
+                        state = 'insert_into_x(a'
+                elif state == 'insert_into_x(a':
+                    if token.ttype == T.Punctuation and token.value == ',':
+                        state = 'insert_into_x(a,'
+                    elif token.ttype == T.Punctuation and token.value == ')':
+                        state = 'insert_into_x(a)'
+                elif state == 'insert_into_x(a,':
+                    if token.ttype == T.Name:
+                        state = 'insert_into_x(a'
+                elif state == 'insert_into_x(a)':
+                    if token.ttype == T.Text.Whitespace:
+                        state = 'insert_into_x(a)_'
+                elif state == 'insert_into_x(a)_':
+                    if token.ttype == T.Keyword and token.value.lower() == 'values':
+                        state = 'insert_into_x_values'
+                elif state == 'insert_into_x_values':
+                    if token.ttype == T.Punctuation and token.value == '(':
+                        state = 'insert_into_x_values('
+                elif state == 'insert_into_x_values(':
+                    if token.ttype in [T.Literal.String.Single, T.Name]:
+                        state = 'insert_into_x_values(v'
+                elif state == 'insert_into_x_values(v':
+                    if token.ttype == T.Punctuation and token.value == ',':
+                        state = 'insert_into_x_values(v,'
+                    elif token.ttype == T.Punctuation and token.value == ')':
+                        state = 'insert_into_x_values(v)'
+                elif state == 'insert_into_x_values(v,':
+                    if token.ttype in [T.Literal.String.Single, T.Name]:
+                        state = 'insert_into_x_values(v'
+
+                elif state == 'update':
+                    if token.ttype == T.Text.Whitespace:
+                        state = 'update_'
+                elif state == 'update_':
+                    if token.ttype == T.Name:
+                        state = 'update_x'
+                elif state == 'update_x':
+                    if token.ttype == T.Text.Whitespace:
+                        state = 'update_x_'
+                elif state == 'update_x_':
+                    if token.ttype == T.Keyword and token.value.lower() == 'set':
+                        state = 'update_x_set'
+                elif state == 'update_x_set':
+                    if token.ttype == T.Text.Whitespace:
+                        state = 'update_x_set_'
+                elif state == 'update_x_set_':
+                    if token.ttype == T.Name:
+                        state = 'update_x_set_a'
+                elif state == 'update_x_set_a':
+                    if token.ttype == T.Operator.Comparison:
+                        state = 'update_x_set_a='
+                elif state == 'update_x_set_a=':
+                    if token.ttype in [T.Literal.String.Single, T.Name]:
+                        state = 'update_x_set_a=v'
+                elif state == 'update_x_set_a=v':
+                    if token.ttype == T.Punctuation and token.value == ',':
+                        state = 'update_x_set_a=v,'
+                    elif token.ttype == T.Text.Whitespace:
+                        state = 'update_x_set_a=v_'
+                elif state == 'update_x_set_a=v,':
+                    if token.ttype == T.Name:
+                        state = 'update_x_set_a'
+                elif state == 'update_x_set_a=v_':
+                    if token.ttype == T.Punctuation and token.value == ',':
+                        state = 'update_x_set_a=v,'
+                    elif token.ttype == T.Keyword and token.value.lower() == 'where':
+                        state = 'update_x_set_a=v_where'
+                elif state == 'update_x_set_a=v_where':
+                    if token.ttype == T.Text.Whitespace:
+                        state = 'update_x_set_a=v_where_'
+                elif state == 'update_x_set_a=v_where_':
+                    if token.ttype == T.Name:
+                        state = 'update_x_set_a=v_where_id'
+                elif state == 'update_x_set_a=v_where_id':
+                    if token.ttype == T.Operator.Comparison:
+                        state = 'update_x_set_a=v_where_id='
+                elif state == 'update_x_set_a=v_where_id=':
+                    if token.ttype in [T.Literal.String.Single, T.Name]:
+                        state = 'update_x_set_a=v_where_id=v'
+                elif state == 'update_x_set_a=v_where_id=v':
+                    if token.ttype == T.Text.Whitespace:
+                        state = 'update_x_set_a=v_where_id=v_'
+                elif state == 'update_x_set_a=v_where_id=v_':
+                    if token.ttype == T.Keyword and token.value.lower() in ['and', 'or']:
+                        state = 'update_x_set_a=v_where'
+
+                elif state == 'delete':
+                    if token.ttype == T.Text.Whitespace:
+                        state = 'delete_'
+                elif state == 'delete_':
+                    if token.ttype == T.Keyword and token.value.lower() == 'from':
+                        state = 'delete_from'
+                elif state == 'delete_from':
+                    if token.ttype == T.Text.Whitespace:
+                        state = 'delete_from_'
+                elif state == 'delete_from_':
+                    if token.ttype == T.Name:
+                        state = 'delete_from_x'
+                elif state == 'delete_from_x':
+                    if token.ttype == T.Text.Whitespace:
+                        state = 'delete_from_x_'
+                elif state == 'delete_from_x_':
+                    if token.ttype == T.Keyword and token.value.lower() == 'where':
+                        state = 'delete_from_x_where'
+                elif state == 'delete_from_x_where':
+                    if token.ttype == T.Text.Whitespace:
+                        state = 'delete_from_x_where_'
+                elif state == 'delete_from_x_where_':
+                    if token.ttype == T.Name:
+                        state = 'delete_from_x_where_id'
+                elif state == 'delete_from_x_where_id':
+                    if token.ttype == T.Operator.Comparison:
+                        state = 'delete_from_x_where_id='
+                elif state == 'delete_from_x_where_id=':
+                    if token.ttype in [T.Literal.String.Single, T.Name]:
+                        state = 'delete_from_x_where_id=v'
+                elif state == 'delete_from_x_where_id=v':
+                    if token.ttype == T.Text.Whitespace:
+                        state = 'delete_from_x_where_id=v_'
+                elif state == 'delete_from_x_where_id=v_':
+                    if token.ttype == T.Keyword and token.value.lower() in ['and', 'or']:
+                        state = 'delete_from_x_where'
+
+        return state
+
+    def completions(table_names: Callable[[], list[str]]):
+        return {
+            'delete': SqlCompleter(table_names, 'delete'),
+            'insert': SqlCompleter(table_names, 'insert'),
+            'select': SqlCompleter(table_names, 'select'),
+            'update': SqlCompleter(table_names, 'update'),
+        }

kaqing-2.0.51/adam/sql/sql_utils.py

@@ -0,0 +1,5 @@
+import re
+
+def safe_terms(text: str):
+    tokens = re.findall(r'"[^"]+"|\b\w+\b|\S', text)
+    return tokens, len(tokens) > 1 or text.startswith(' ') or text.endswith(' ')

kaqing-2.0.51/adam/sql/term_completer.py

@@ -0,0 +1,66 @@
+from typing import Callable, Iterable, List, Mapping, Optional, Pattern, Union
+
+from prompt_toolkit.completion import CompleteEvent, Completer, Completion, WordCompleter
+from prompt_toolkit.document import Document
+from prompt_toolkit.formatted_text import AnyFormattedText
+
+__all__ = [
+    "TermCompleter",
+]
+
+class TermCompleter(WordCompleter):
+    def __init__(
+        self,
+        words: Union[List[str], Callable[[], List[str]]],
+        ignore_case: bool = False,
+        display_dict: Optional[Mapping[str, AnyFormattedText]] = None,
+        meta_dict: Optional[Mapping[str, AnyFormattedText]] = None,
+        WORD: bool = False,
+        sentence: bool = False,
+        match_middle: bool = False,
+        pattern: Optional[Pattern[str]] = None,
+    ) -> None:
+        super().__init__(words, ignore_case, display_dict, meta_dict, WORD, sentence, match_middle, pattern)
+
+    def get_completions(
+        self, document: Document, complete_event: CompleteEvent
+    ) -> Iterable[Completion]:
+        # Get list of words.
+        words = self.words
+        if callable(words):
+            words = words()
+
+        # Get word/text before cursor.
+        if self.sentence:
+            word_before_cursor = document.text_before_cursor
+        else:
+            word_before_cursor = document.get_word_before_cursor(
+                WORD=self.WORD, pattern=self.pattern
+            )
+
+        if self.ignore_case:
+            word_before_cursor = word_before_cursor.lower()
+
+        def word_matches(word: str) -> bool:
+            """True when the word before the cursor matches."""
+            if self.ignore_case:
+                word = word.lower()
+
+            if word_before_cursor in ['(', ',', '=']:
+                return True
+
+            if self.match_middle:
+                return word_before_cursor in word
+            else:
+                return word.startswith(word_before_cursor)
+
+        for a in words:
+            if word_matches(a):
+                display = self.display_dict.get(a, a)
+                display_meta = self.meta_dict.get(a, "")
+                yield Completion(
+                    a,
+                    -len(word_before_cursor),
+                    display=display,
+                    display_meta=display_meta,
+                )

kaqing-2.0.51/adam/version.py

@@ -0,0 +1,5 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+__version__ = "2.0.51"  #: the working version
+__release__ = "1.0.0"  #: the release version

{kaqing-2.0.49 → kaqing-2.0.51}/kaqing.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kaqing
-Version: 2.0.49
+Version: 2.0.51
 Summary: UNKNOWN
 Home-page: UNKNOWN
 License: UNKNOWN

{kaqing-2.0.49 → kaqing-2.0.51}/kaqing.egg-info/SOURCES.txt

@@ -15,7 +15,6 @@ adam/repl.py
 adam/repl_commands.py
 adam/repl_session.py
 adam/repl_state.py
-adam/table_completer.py
 adam/utils.py
 adam/version.py
 adam/checks/__init__.py
@@ -110,13 +109,13 @@ adam/commands/medusa/medusa_restore.py
 adam/commands/medusa/medusa_show_backupjobs.py
 adam/commands/medusa/medusa_show_restorejobs.py
 adam/commands/postgres/__init__.py
-adam/commands/postgres/pg_completions.py
-adam/commands/postgres/pg_table_completer.py
 adam/commands/postgres/postgres.py
 adam/commands/postgres/postgres_ls.py
 adam/commands/postgres/postgres_preview.py
 adam/commands/postgres/postgres_session.py
 adam/commands/postgres/postgres_utils.py
+adam/commands/postgres/psql_completions.py
+adam/commands/postgres/psql_table_completer.py
 adam/commands/reaper/__init__.py
 adam/commands/reaper/reaper.py
 adam/commands/reaper/reaper_forward.py
@@ -166,6 +165,10 @@ adam/k8s_utils/service_accounts.py
 adam/k8s_utils/services.py
 adam/k8s_utils/statefulsets.py
 adam/k8s_utils/volumes.py
+adam/sql/__init__.py
+adam/sql/sql_completer.py
+adam/sql/sql_utils.py
+adam/sql/term_completer.py
 adam/sso/__init__.py
 adam/sso/authenticator.py
 adam/sso/authn_ad.py